videocollection/videocollectionwrapper/tsrc/testvideomodel/src/testvideolistdatamodel.cpp
author hgs
Fri, 16 Apr 2010 18:13:14 +0300
changeset 36 8aed59de29f9
parent 35 3738fe97f027
child 37 4eb2df7f7cbe
permissions -rw-r--r--
201015
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
34
hgs
parents:
diff changeset
     1
hgs
parents:
diff changeset
     2
/*
hgs
parents:
diff changeset
     3
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
hgs
parents:
diff changeset
     4
* All rights reserved.
hgs
parents:
diff changeset
     5
* This component and the accompanying materials are made available
hgs
parents:
diff changeset
     6
* under the terms of "Eclipse Public License v1.0"
hgs
parents:
diff changeset
     7
* which accompanies this distribution, and is available
hgs
parents:
diff changeset
     8
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
hgs
parents:
diff changeset
     9
*
hgs
parents:
diff changeset
    10
* Initial Contributors:
hgs
parents:
diff changeset
    11
* Nokia Corporation - initial contribution.
hgs
parents:
diff changeset
    12
*
hgs
parents:
diff changeset
    13
* Contributors:
hgs
parents:
diff changeset
    14
*
hgs
parents:
diff changeset
    15
* Description:  Testclas for testing VideoListDataModel class methods*
hgs
parents:
diff changeset
    16
*/
hgs
parents:
diff changeset
    17
hgs
parents:
diff changeset
    18
hgs
parents:
diff changeset
    19
#include <QObject>
hgs
parents:
diff changeset
    20
#include <qabstractitemmodel.h>
hgs
parents:
diff changeset
    21
#include <mpxmediageneraldefs.h>
hgs
parents:
diff changeset
    22
#include <mpxmediaarray.h>
hgs
parents:
diff changeset
    23
#include <mpxmedia.h>
hgs
parents:
diff changeset
    24
#include "videocollectioncommon.h"
hgs
parents:
diff changeset
    25
#include "videodeleteworker.h"
hgs
parents:
diff changeset
    26
#include "videocollectionclient.h"
hgs
parents:
diff changeset
    27
#include "videolistdatamodel_p.h"
hgs
parents:
diff changeset
    28
#include "videocollectionwrapper.h"
hgs
parents:
diff changeset
    29
hgs
parents:
diff changeset
    30
hgs
parents:
diff changeset
    31
#include "testvideolistdatamodel.h"
hgs
parents:
diff changeset
    32
#include "mediaobjectfactory.h"
hgs
parents:
diff changeset
    33
#include "videocollectioncommon.h"
hgs
parents:
diff changeset
    34
hgs
parents:
diff changeset
    35
#define private public
hgs
parents:
diff changeset
    36
#include "videolistdatamodel.h"
hgs
parents:
diff changeset
    37
#undef private
hgs
parents:
diff changeset
    38
hgs
parents:
diff changeset
    39
const int MEDIA_COUNT = 10;
hgs
parents:
diff changeset
    40
hgs
parents:
diff changeset
    41
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
    42
// main
hgs
parents:
diff changeset
    43
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
    44
//
hgs
parents:
diff changeset
    45
int main(int argc, char *argv[])
hgs
parents:
diff changeset
    46
{
hgs
parents:
diff changeset
    47
    Q_UNUSED(argc);
hgs
parents:
diff changeset
    48
    
hgs
parents:
diff changeset
    49
    TestVideoListDataModel tv;
hgs
parents:
diff changeset
    50
    
hgs
parents:
diff changeset
    51
    int res;
hgs
parents:
diff changeset
    52
    if(argc > 1)
hgs
parents:
diff changeset
    53
    {   
hgs
parents:
diff changeset
    54
        res = QTest::qExec(&tv, argc, argv);
hgs
parents:
diff changeset
    55
    }
hgs
parents:
diff changeset
    56
    else
hgs
parents:
diff changeset
    57
    {
hgs
parents:
diff changeset
    58
        char *pass[3];
hgs
parents:
diff changeset
    59
        pass[0] = argv[0];
hgs
parents:
diff changeset
    60
        pass[1] = "-o";
hgs
parents:
diff changeset
    61
        pass[2] = "c:\\data\\testvideomodel.txt";
hgs
parents:
diff changeset
    62
        res = QTest::qExec(&tv, 3, pass);
hgs
parents:
diff changeset
    63
    }
hgs
parents:
diff changeset
    64
    
hgs
parents:
diff changeset
    65
    return res;
hgs
parents:
diff changeset
    66
}
hgs
parents:
diff changeset
    67
hgs
parents:
diff changeset
    68
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
    69
// initTestCase
hgs
parents:
diff changeset
    70
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
    71
//
hgs
parents:
diff changeset
    72
void TestVideoListDataModel::initTestCase()
hgs
parents:
diff changeset
    73
{
hgs
parents:
diff changeset
    74
    mMediaFactory = new MediaObjectFactory();
hgs
parents:
diff changeset
    75
}
hgs
parents:
diff changeset
    76
hgs
parents:
diff changeset
    77
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
    78
// init
hgs
parents:
diff changeset
    79
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
    80
//
hgs
parents:
diff changeset
    81
void TestVideoListDataModel::init()
hgs
parents:
diff changeset
    82
{
hgs
parents:
diff changeset
    83
    QVERIFY2(initializeTestObjects(), "making sure if testable object creation ok");  
hgs
parents:
diff changeset
    84
}
hgs
parents:
diff changeset
    85
hgs
parents:
diff changeset
    86
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
    87
// cleanup
hgs
parents:
diff changeset
    88
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
    89
//   
hgs
parents:
diff changeset
    90
void TestVideoListDataModel::cleanup()
hgs
parents:
diff changeset
    91
{
hgs
parents:
diff changeset
    92
    cleanupTestObjects();
hgs
parents:
diff changeset
    93
}
hgs
parents:
diff changeset
    94
hgs
parents:
diff changeset
    95
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
    96
// cleanupTestCase
hgs
parents:
diff changeset
    97
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
    98
//
hgs
parents:
diff changeset
    99
void TestVideoListDataModel::cleanupTestCase()
hgs
parents:
diff changeset
   100
{
hgs
parents:
diff changeset
   101
    delete mMediaFactory;
hgs
parents:
diff changeset
   102
}
hgs
parents:
diff changeset
   103
hgs
parents:
diff changeset
   104
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   105
// testInitializeFails
hgs
parents:
diff changeset
   106
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   107
//
hgs
parents:
diff changeset
   108
void TestVideoListDataModel::testConstructor()
hgs
parents:
diff changeset
   109
{
hgs
parents:
diff changeset
   110
    QObject *parent = new QObject();
hgs
parents:
diff changeset
   111
    delete mTestObjectNotInitialized;
hgs
parents:
diff changeset
   112
    mTestObjectNotInitialized = new VideoListDataModel(parent);
hgs
parents:
diff changeset
   113
    QVERIFY( mTestObjectNotInitialized->QObject::parent() == parent );
hgs
parents:
diff changeset
   114
    QVERIFY( mTestObjectNotInitialized->mCollectionClient == 0);
hgs
parents:
diff changeset
   115
    QVERIFY( mTestObjectNotInitialized->d_ptr != 0);
hgs
parents:
diff changeset
   116
    
hgs
parents:
diff changeset
   117
    delete parent; // also deletes the test object;
hgs
parents:
diff changeset
   118
    mTestObjectNotInitialized = 0;
hgs
parents:
diff changeset
   119
}
hgs
parents:
diff changeset
   120
hgs
parents:
diff changeset
   121
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   122
// testInitializeFails
hgs
parents:
diff changeset
   123
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   124
//
hgs
parents:
diff changeset
   125
void TestVideoListDataModel::testInitializeFails()
hgs
parents:
diff changeset
   126
{
hgs
parents:
diff changeset
   127
    // Test all possible failures in the initialisation -call
hgs
parents:
diff changeset
   128
    // NOTE: signal connecting or new operator failures cannot be tested
hgs
parents:
diff changeset
   129
    
hgs
parents:
diff changeset
   130
    // - collection client init fails
hgs
parents:
diff changeset
   131
    VideoCollectionClient::mFailInitialize = true;
hgs
parents:
diff changeset
   132
    QVERIFY(mTestObjectNotInitialized->initialize() == -1 );
hgs
parents:
diff changeset
   133
    VideoCollectionClient::mFailInitialize = false;
hgs
parents:
diff changeset
   134
    
hgs
parents:
diff changeset
   135
    // - private impl init fails
hgs
parents:
diff changeset
   136
    VideoListDataModelPrivate::mFailInit = true;
hgs
parents:
diff changeset
   137
    QVERIFY( mTestObjectNotInitialized->initialize() == -1 );
hgs
parents:
diff changeset
   138
hgs
parents:
diff changeset
   139
}
hgs
parents:
diff changeset
   140
hgs
parents:
diff changeset
   141
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   142
// testInitialize
hgs
parents:
diff changeset
   143
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   144
//
hgs
parents:
diff changeset
   145
void TestVideoListDataModel::testInitialize()
hgs
parents:
diff changeset
   146
{
hgs
parents:
diff changeset
   147
    VideoListDataModelPrivate::mFailInit = false;
hgs
parents:
diff changeset
   148
    VideoCollectionClient::mFailInitialize = false;
hgs
parents:
diff changeset
   149
    VideoCollectionClient::mFailConnectSignals = false;
hgs
parents:
diff changeset
   150
    VideoCollectionClient::mInitializeCount = 0;
hgs
parents:
diff changeset
   151
    VideoDeleteWorker::mCreateCount = 0;
hgs
parents:
diff changeset
   152
    
hgs
parents:
diff changeset
   153
    QVERIFY(mTestObjectNotInitialized->initialize() == 0);
35
hgs
parents: 34
diff changeset
   154
    // second call should succeed right away
34
hgs
parents:
diff changeset
   155
    QVERIFY(mTestObjectNotInitialized->initialize() == 0);
hgs
parents:
diff changeset
   156
    QVERIFY(mTestObjectNotInitialized->getCollectionClient() != 0);
hgs
parents:
diff changeset
   157
    
hgs
parents:
diff changeset
   158
    // for the coverity, cannot be verified, because cannot get count from
hgs
parents:
diff changeset
   159
    // connected signals runtime
hgs
parents:
diff changeset
   160
    mTestObjectNotInitialized->d_ptr->callModelDisconnect();
hgs
parents:
diff changeset
   161
    
hgs
parents:
diff changeset
   162
    QVERIFY(VideoCollectionClient::mInitializeCount == 1);
hgs
parents:
diff changeset
   163
    QVERIFY(VideoDeleteWorker::mCreateCount == 1);
hgs
parents:
diff changeset
   164
    
hgs
parents:
diff changeset
   165
}
hgs
parents:
diff changeset
   166
hgs
parents:
diff changeset
   167
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   168
// testRowCount
hgs
parents:
diff changeset
   169
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   170
//
hgs
parents:
diff changeset
   171
void TestVideoListDataModel::testRowCount()
hgs
parents:
diff changeset
   172
{
hgs
parents:
diff changeset
   173
    // Test to make sure model queries correct amount of items
hgs
parents:
diff changeset
   174
    // - at beginning row count should be 0
hgs
parents:
diff changeset
   175
    // - create defined amount of items
hgs
parents:
diff changeset
   176
    // - call rowCount to get matching count
hgs
parents:
diff changeset
   177
hgs
parents:
diff changeset
   178
    mMediaFactory->removeArray();  
hgs
parents:
diff changeset
   179
   
hgs
parents:
diff changeset
   180
    // row count with invalid parent and zero -array should be 0
hgs
parents:
diff changeset
   181
    QVERIFY(mTestObjectInitialized->rowCount() == 0);
hgs
parents:
diff changeset
   182
    
hgs
parents:
diff changeset
   183
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
   184
    
hgs
parents:
diff changeset
   185
    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
hgs
parents:
diff changeset
   186
    
hgs
parents:
diff changeset
   187
    // check row count is ok
hgs
parents:
diff changeset
   188
    QVERIFY( mTestObjectInitialized->rowCount() == MEDIA_COUNT);
hgs
parents:
diff changeset
   189
          
hgs
parents:
diff changeset
   190
    // with valid parent: according to Qt documentation if parent is valid rowCount should return 0
hgs
parents:
diff changeset
   191
    QModelIndex validIndex = mTestObjectInitialized->index(0,0);
hgs
parents:
diff changeset
   192
    QVERIFY( mTestObjectInitialized->rowCount(validIndex) == 0);
hgs
parents:
diff changeset
   193
    
hgs
parents:
diff changeset
   194
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   195
    
hgs
parents:
diff changeset
   196
}
hgs
parents:
diff changeset
   197
hgs
parents:
diff changeset
   198
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   199
// testMediaIdAtIndex
hgs
parents:
diff changeset
   200
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   201
//
hgs
parents:
diff changeset
   202
void TestVideoListDataModel::testMediaIdAtIndex() 
hgs
parents:
diff changeset
   203
{
hgs
parents:
diff changeset
   204
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   205
    
hgs
parents:
diff changeset
   206
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
   207
      
hgs
parents:
diff changeset
   208
    // ownership of media-array transferred
hgs
parents:
diff changeset
   209
    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
hgs
parents:
diff changeset
   210
         
hgs
parents:
diff changeset
   211
    // invalid index: below bounds
hgs
parents:
diff changeset
   212
    QVERIFY(mTestObjectInitialized->mediaIdAtIndex(-1) == TMPXItemId::InvalidId());
hgs
parents:
diff changeset
   213
    
hgs
parents:
diff changeset
   214
    //invalid index: above bounds
hgs
parents:
diff changeset
   215
    QVERIFY(mTestObjectInitialized->mediaIdAtIndex(MEDIA_COUNT) == TMPXItemId::InvalidId());
hgs
parents:
diff changeset
   216
    
hgs
parents:
diff changeset
   217
    // first
hgs
parents:
diff changeset
   218
    QVERIFY(mTestObjectInitialized->mediaIdAtIndex(0).iId1 == 0);
hgs
parents:
diff changeset
   219
    
hgs
parents:
diff changeset
   220
    // middle
hgs
parents:
diff changeset
   221
    QVERIFY(mTestObjectInitialized->mediaIdAtIndex(MEDIA_COUNT / 2).iId1 == (MEDIA_COUNT / 2));
hgs
parents:
diff changeset
   222
    
hgs
parents:
diff changeset
   223
    // last
hgs
parents:
diff changeset
   224
    QVERIFY(mTestObjectInitialized->mediaIdAtIndex(MEDIA_COUNT - 1).iId1 == (MEDIA_COUNT - 1));
hgs
parents:
diff changeset
   225
hgs
parents:
diff changeset
   226
    // no items
hgs
parents:
diff changeset
   227
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   228
    mTestObjectInitialized->d_ptr->newVideoListSlot(0);
hgs
parents:
diff changeset
   229
    QVERIFY( mTestObjectInitialized->mediaIdAtIndex(MEDIA_COUNT / 2) == TMPXItemId::InvalidId());
hgs
parents:
diff changeset
   230
}
hgs
parents:
diff changeset
   231
hgs
parents:
diff changeset
   232
// -----------------------------------------------------------------------------
35
hgs
parents: 34
diff changeset
   233
// testIndexOfId
hgs
parents: 34
diff changeset
   234
// -----------------------------------------------------------------------------
hgs
parents: 34
diff changeset
   235
//
hgs
parents: 34
diff changeset
   236
void TestVideoListDataModel::testIndexOfId()
hgs
parents: 34
diff changeset
   237
{
hgs
parents: 34
diff changeset
   238
    mMediaFactory->removeArray();
hgs
parents: 34
diff changeset
   239
        
hgs
parents: 34
diff changeset
   240
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents: 34
diff changeset
   241
      
hgs
parents: 34
diff changeset
   242
    // ownership of media-array transferred
hgs
parents: 34
diff changeset
   243
    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
hgs
parents: 34
diff changeset
   244
    
hgs
parents: 34
diff changeset
   245
    QModelIndex index;
hgs
parents: 34
diff changeset
   246
    
hgs
parents: 34
diff changeset
   247
    // invalid id
hgs
parents: 34
diff changeset
   248
    TMPXItemId id = TMPXItemId::InvalidId();
hgs
parents: 34
diff changeset
   249
    index = mTestObjectInitialized->indexOfId(id);
hgs
parents: 34
diff changeset
   250
    QVERIFY(!index.isValid());
hgs
parents: 34
diff changeset
   251
    
hgs
parents: 34
diff changeset
   252
    //invalid index: does not exists
hgs
parents: 34
diff changeset
   253
    id = TMPXItemId(MEDIA_COUNT, 0);
hgs
parents: 34
diff changeset
   254
    index = mTestObjectInitialized->indexOfId(id);
hgs
parents: 34
diff changeset
   255
    QVERIFY(!index.isValid());
hgs
parents: 34
diff changeset
   256
    
hgs
parents: 34
diff changeset
   257
    // existing
hgs
parents: 34
diff changeset
   258
    id = TMPXItemId(0, 0);
hgs
parents: 34
diff changeset
   259
    index = mTestObjectInitialized->indexOfId(id);
hgs
parents: 34
diff changeset
   260
    QVERIFY(index.isValid());
hgs
parents: 34
diff changeset
   261
    QVERIFY(index.row() == 0);
hgs
parents: 34
diff changeset
   262
hgs
parents: 34
diff changeset
   263
    id = TMPXItemId(MEDIA_COUNT / 2, 0);
hgs
parents: 34
diff changeset
   264
    index = mTestObjectInitialized->indexOfId(id);
hgs
parents: 34
diff changeset
   265
    QVERIFY(index.isValid());
hgs
parents: 34
diff changeset
   266
    QVERIFY(index.row() == MEDIA_COUNT / 2);
hgs
parents: 34
diff changeset
   267
    
hgs
parents: 34
diff changeset
   268
    id = TMPXItemId(MEDIA_COUNT - 1, 0);
hgs
parents: 34
diff changeset
   269
    index = mTestObjectInitialized->indexOfId(id);
hgs
parents: 34
diff changeset
   270
    QVERIFY(index.isValid());
hgs
parents: 34
diff changeset
   271
    QVERIFY(index.row() == MEDIA_COUNT - 1);
hgs
parents: 34
diff changeset
   272
 
hgs
parents: 34
diff changeset
   273
}
hgs
parents: 34
diff changeset
   274
hgs
parents: 34
diff changeset
   275
// -----------------------------------------------------------------------------
34
hgs
parents:
diff changeset
   276
// testMediaFilePathForId
hgs
parents:
diff changeset
   277
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   278
//
hgs
parents:
diff changeset
   279
void TestVideoListDataModel::testMediaFilePathForId() 
hgs
parents:
diff changeset
   280
{
hgs
parents:
diff changeset
   281
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   282
    
hgs
parents:
diff changeset
   283
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
   284
      
hgs
parents:
diff changeset
   285
    // ownership of media-array transferred
hgs
parents:
diff changeset
   286
    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
hgs
parents:
diff changeset
   287
hgs
parents:
diff changeset
   288
    TMPXItemId id;
hgs
parents:
diff changeset
   289
    
hgs
parents:
diff changeset
   290
    // invalid id
hgs
parents:
diff changeset
   291
    QVERIFY(mTestObjectInitialized->mediaFilePathForId( TMPXItemId::InvalidId()) == "");
hgs
parents:
diff changeset
   292
    
hgs
parents:
diff changeset
   293
    // first
hgs
parents:
diff changeset
   294
    id.iId1 = 0;
hgs
parents:
diff changeset
   295
    id.iId2 = 0;
hgs
parents:
diff changeset
   296
    QVERIFY(mTestObjectInitialized->mediaFilePathForId(id) == 
hgs
parents:
diff changeset
   297
        QString(gQTMediaNamePrefix + QString::number(id.iId1)));
hgs
parents:
diff changeset
   298
    
hgs
parents:
diff changeset
   299
    // middle
hgs
parents:
diff changeset
   300
    id.iId1 = MEDIA_COUNT / 2;
hgs
parents:
diff changeset
   301
    id.iId2 = 0;
hgs
parents:
diff changeset
   302
    QVERIFY(mTestObjectInitialized->mediaFilePathForId(id) == 
hgs
parents:
diff changeset
   303
        QString(gQTMediaNamePrefix + QString::number(id.iId1)));
hgs
parents:
diff changeset
   304
    
hgs
parents:
diff changeset
   305
    // last
hgs
parents:
diff changeset
   306
    id.iId1 = MEDIA_COUNT - 1;
hgs
parents:
diff changeset
   307
    id.iId2 = 0;
hgs
parents:
diff changeset
   308
    QVERIFY(mTestObjectInitialized->mediaFilePathForId(id) == 
hgs
parents:
diff changeset
   309
        QString(gQTMediaNamePrefix + QString::number(id.iId1)));
hgs
parents:
diff changeset
   310
    
hgs
parents:
diff changeset
   311
    // no items
hgs
parents:
diff changeset
   312
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   313
    id.iId1 = MEDIA_COUNT / 2;
hgs
parents:
diff changeset
   314
    id.iId2 = 0;
hgs
parents:
diff changeset
   315
    mTestObjectInitialized->d_ptr->newVideoListSlot(0);
hgs
parents:
diff changeset
   316
    QVERIFY( mTestObjectInitialized->mediaFilePathForId(id) == "" );
hgs
parents:
diff changeset
   317
}
hgs
parents:
diff changeset
   318
hgs
parents:
diff changeset
   319
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   320
// testItemData
hgs
parents:
diff changeset
   321
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   322
//
hgs
parents:
diff changeset
   323
void TestVideoListDataModel::testItemData()
hgs
parents:
diff changeset
   324
{
hgs
parents:
diff changeset
   325
    // Test to make sure item data is passed ok throught model
hgs
parents:
diff changeset
   326
    // - create defined amount of items
hgs
parents:
diff changeset
   327
    // - setup their data as predefined values
hgs
parents:
diff changeset
   328
    // - call item data to make sure data is passed ok from the model
hgs
parents:
diff changeset
   329
    // Qt::DisplayRole
hgs
parents:
diff changeset
   330
    // Qt::DecorationRole
hgs
parents:
diff changeset
   331
    // Qt::BackgroundRole
hgs
parents:
diff changeset
   332
    
hgs
parents:
diff changeset
   333
    QModelIndex index;
hgs
parents:
diff changeset
   334
    QMap<int, QVariant> mapData;
hgs
parents:
diff changeset
   335
    
hgs
parents:
diff changeset
   336
    VideoListDataModelPrivate::mFailInit = false;
hgs
parents:
diff changeset
   337
 
hgs
parents:
diff changeset
   338
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   339
    
hgs
parents:
diff changeset
   340
    mTestObjectInitialized->d_ptr->newVideoListSlot(0);
hgs
parents:
diff changeset
   341
    
hgs
parents:
diff changeset
   342
    // no items
hgs
parents:
diff changeset
   343
    index = mTestObjectInitialized->index(0, 0, QModelIndex());
hgs
parents:
diff changeset
   344
    mapData = mTestObjectInitialized->itemData(index);
hgs
parents:
diff changeset
   345
    QVERIFY(mapData.count() == 0);
hgs
parents:
diff changeset
   346
    
hgs
parents:
diff changeset
   347
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
   348
    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
hgs
parents:
diff changeset
   349
    
hgs
parents:
diff changeset
   350
    // below index bounds, should not even get correct index
hgs
parents:
diff changeset
   351
    index = mTestObjectInitialized->index(-1, 0, QModelIndex());
hgs
parents:
diff changeset
   352
    QVERIFY(!index.isValid());
hgs
parents:
diff changeset
   353
    mapData = mTestObjectInitialized->itemData(index);
hgs
parents:
diff changeset
   354
    QVERIFY(mapData.count() == 0);
hgs
parents:
diff changeset
   355
    
hgs
parents:
diff changeset
   356
    // above index bounds, should not even get correct index
hgs
parents:
diff changeset
   357
    index = mTestObjectInitialized->index(MEDIA_COUNT, 0, QModelIndex());
hgs
parents:
diff changeset
   358
    QVERIFY(!index.isValid());
hgs
parents:
diff changeset
   359
    mapData = mTestObjectInitialized->itemData(index);
hgs
parents:
diff changeset
   360
    QVERIFY(mapData.count() == 0);
hgs
parents:
diff changeset
   361
    
hgs
parents:
diff changeset
   362
    // first
hgs
parents:
diff changeset
   363
    index = mTestObjectInitialized->index(0, 0, QModelIndex());
hgs
parents:
diff changeset
   364
    QVERIFY(index.isValid());
hgs
parents:
diff changeset
   365
    mapData = mTestObjectInitialized->itemData(index);
hgs
parents:
diff changeset
   366
    QVERIFY(mapData.count() == 3);
hgs
parents:
diff changeset
   367
    
hgs
parents:
diff changeset
   368
    // middle
hgs
parents:
diff changeset
   369
    index = mTestObjectInitialized->index(MEDIA_COUNT / 2, 0, QModelIndex());
hgs
parents:
diff changeset
   370
    QVERIFY(index.isValid());
hgs
parents:
diff changeset
   371
    mapData = mTestObjectInitialized->itemData(index);
hgs
parents:
diff changeset
   372
    QVERIFY(mapData.count() == 3);
hgs
parents:
diff changeset
   373
    
hgs
parents:
diff changeset
   374
    // last
hgs
parents:
diff changeset
   375
    index = mTestObjectInitialized->index(MEDIA_COUNT - 1, 0, QModelIndex());
hgs
parents:
diff changeset
   376
    QVERIFY(index.isValid());
hgs
parents:
diff changeset
   377
    mapData = mTestObjectInitialized->itemData(index);
hgs
parents:
diff changeset
   378
    QVERIFY(mapData.count() == 3);
hgs
parents:
diff changeset
   379
             
hgs
parents:
diff changeset
   380
}
hgs
parents:
diff changeset
   381
hgs
parents:
diff changeset
   382
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   383
// testData
hgs
parents:
diff changeset
   384
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   385
//
hgs
parents:
diff changeset
   386
void TestVideoListDataModel::testData()
hgs
parents:
diff changeset
   387
{
hgs
parents:
diff changeset
   388
    VideoListDataModelPrivate::mFailInit = false;
hgs
parents:
diff changeset
   389
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   390
    
hgs
parents:
diff changeset
   391
    const int TEST_INDEX = 3;
hgs
parents:
diff changeset
   392
    
hgs
parents:
diff changeset
   393
    mMediaFactory->createMediaItems(TEST_INDEX + 1);
hgs
parents:
diff changeset
   394
    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
hgs
parents:
diff changeset
   395
    QModelIndex index = QModelIndex();
hgs
parents:
diff changeset
   396
    QVariant data;
hgs
parents:
diff changeset
   397
    
hgs
parents:
diff changeset
   398
    // test with invalid QModelIndex
hgs
parents:
diff changeset
   399
    data = mTestObjectInitialized->data(index, Qt::DisplayRole);
hgs
parents:
diff changeset
   400
    QVERIFY(data.toStringList().count() == 0);
hgs
parents:
diff changeset
   401
    
hgs
parents:
diff changeset
   402
    // test with correct data
hgs
parents:
diff changeset
   403
    index = mTestObjectInitialized->index(TEST_INDEX,0, QModelIndex());
hgs
parents:
diff changeset
   404
    
hgs
parents:
diff changeset
   405
    data = mTestObjectInitialized->data(index, Qt::DisplayRole);
hgs
parents:
diff changeset
   406
    QVERIFY(data.toStringList().count() == 2);
hgs
parents:
diff changeset
   407
    QVERIFY(data.toStringList().at(0) == QString(gQTMediaNamePrefix + QString::number(TEST_INDEX)));
hgs
parents:
diff changeset
   408
    
hgs
parents:
diff changeset
   409
    data.clear();
hgs
parents:
diff changeset
   410
    data = mTestObjectInitialized->data(index, Qt::DecorationRole);
hgs
parents:
diff changeset
   411
    QVERIFY(data.isValid());
hgs
parents:
diff changeset
   412
    
hgs
parents:
diff changeset
   413
    data.clear();
hgs
parents:
diff changeset
   414
    data = mTestObjectInitialized->data(index, Qt::BackgroundRole); 
hgs
parents:
diff changeset
   415
    // at the moment we do not have background role -data, when it becomes available,
hgs
parents:
diff changeset
   416
    // this will fail and needs to be changed
hgs
parents:
diff changeset
   417
    QVERIFY(!data.isValid());
hgs
parents:
diff changeset
   418
    
hgs
parents:
diff changeset
   419
    data.clear();
hgs
parents:
diff changeset
   420
    QDate date = QDate(2009, TEST_INDEX+1, TEST_INDEX+1);
hgs
parents:
diff changeset
   421
    data = mTestObjectInitialized->data(index, VideoCollectionCommon::KeyDateTime); 
hgs
parents:
diff changeset
   422
    QCOMPARE(data.toDate(), date);
hgs
parents:
diff changeset
   423
    
hgs
parents:
diff changeset
   424
    data.clear();
hgs
parents:
diff changeset
   425
    data = mTestObjectInitialized->data(index, VideoCollectionCommon::KeySizeValue); 
hgs
parents:
diff changeset
   426
    QVERIFY(data.toUInt() == (1+TEST_INDEX));
hgs
parents:
diff changeset
   427
    
hgs
parents:
diff changeset
   428
    data.clear();
hgs
parents:
diff changeset
   429
    data = mTestObjectInitialized->data(index, VideoCollectionCommon::KeyStatus); 
hgs
parents:
diff changeset
   430
    QVERIFY(data.toInt() == VideoCollectionCommon::StatusNone);
hgs
parents:
diff changeset
   431
    
hgs
parents:
diff changeset
   432
    data.clear();
hgs
parents:
diff changeset
   433
    data = mTestObjectInitialized->data(index, VideoCollectionCommon::KeyFilePath); 
hgs
parents:
diff changeset
   434
    QCOMPARE(data.toString(), gQTMediaFilePathPrefix + QString::number(TEST_INDEX));
36
hgs
parents: 35
diff changeset
   435
hgs
parents: 35
diff changeset
   436
    data.clear();
hgs
parents: 35
diff changeset
   437
    data = mTestObjectInitialized->data(index, VideoCollectionCommon::KeyNumberOfItems); 
hgs
parents: 35
diff changeset
   438
    QCOMPARE(data.toUInt(), (uint)(10+TEST_INDEX));
34
hgs
parents:
diff changeset
   439
    
hgs
parents:
diff changeset
   440
    // invalid role
hgs
parents:
diff changeset
   441
    data.clear();
hgs
parents:
diff changeset
   442
    data = mTestObjectInitialized->data(index, VideoCollectionCommon::KeyLast); 
hgs
parents:
diff changeset
   443
    QVERIFY(!data.isValid());
hgs
parents:
diff changeset
   444
    
hgs
parents:
diff changeset
   445
    // test with incorrect (== missing details) data
hgs
parents:
diff changeset
   446
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   447
    mMediaFactory->createMediaItems(TEST_INDEX + 1, 0, MediaDetailNone);
hgs
parents:
diff changeset
   448
    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
hgs
parents:
diff changeset
   449
    data.clear();
hgs
parents:
diff changeset
   450
    data = mTestObjectInitialized->data(index, VideoCollectionCommon::KeyDateTime); 
hgs
parents:
diff changeset
   451
    QVERIFY(!data.toDateTime().isValid());
hgs
parents:
diff changeset
   452
    
hgs
parents:
diff changeset
   453
    data.clear();
hgs
parents:
diff changeset
   454
    data = mTestObjectInitialized->data(index, VideoCollectionCommon::KeyFilePath);
hgs
parents:
diff changeset
   455
    QVERIFY(!data.toString().length());
hgs
parents:
diff changeset
   456
hgs
parents:
diff changeset
   457
}
hgs
parents:
diff changeset
   458
hgs
parents:
diff changeset
   459
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   460
// testColumnCount
hgs
parents:
diff changeset
   461
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   462
//
hgs
parents:
diff changeset
   463
void TestVideoListDataModel::testColumnCount()
hgs
parents:
diff changeset
   464
{
hgs
parents:
diff changeset
   465
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   466
    const int TEST_INDEX = 3;
hgs
parents:
diff changeset
   467
       
hgs
parents:
diff changeset
   468
    // test with correct data
hgs
parents:
diff changeset
   469
    mMediaFactory->createMediaItems(1);
hgs
parents:
diff changeset
   470
    
hgs
parents:
diff changeset
   471
    QModelIndex index = QModelIndex();
hgs
parents:
diff changeset
   472
    // test with invalid "parent" index
hgs
parents:
diff changeset
   473
    QVERIFY(mTestObjectInitialized->columnCount(index) == 1);
hgs
parents:
diff changeset
   474
    
hgs
parents:
diff changeset
   475
    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
hgs
parents:
diff changeset
   476
    index = mTestObjectInitialized->index(0,0);
hgs
parents:
diff changeset
   477
    // test with valid "parent index
hgs
parents:
diff changeset
   478
    QVERIFY(mTestObjectInitialized->columnCount(index) == 0);
hgs
parents:
diff changeset
   479
}
35
hgs
parents: 34
diff changeset
   480
34
hgs
parents:
diff changeset
   481
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   482
// testIndex
hgs
parents:
diff changeset
   483
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   484
//
hgs
parents:
diff changeset
   485
void TestVideoListDataModel::testIndex()
hgs
parents:
diff changeset
   486
{
hgs
parents:
diff changeset
   487
    QModelIndex indexToGet;
hgs
parents:
diff changeset
   488
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   489
    mTestObjectInitialized->d_ptr->newVideoListSlot(0);
hgs
parents:
diff changeset
   490
    
hgs
parents:
diff changeset
   491
    
hgs
parents:
diff changeset
   492
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
   493
    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
hgs
parents:
diff changeset
   494
    
hgs
parents:
diff changeset
   495
    // index below bounds
hgs
parents:
diff changeset
   496
    indexToGet = mTestObjectInitialized->index(-1, 0);
hgs
parents:
diff changeset
   497
    QVERIFY(!indexToGet.isValid()); 
hgs
parents:
diff changeset
   498
    
hgs
parents:
diff changeset
   499
    // index above bounds
hgs
parents:
diff changeset
   500
    indexToGet = mTestObjectInitialized->index(MEDIA_COUNT, 0);
hgs
parents:
diff changeset
   501
    QVERIFY(!indexToGet.isValid()); 
hgs
parents:
diff changeset
   502
    
hgs
parents:
diff changeset
   503
    // first
hgs
parents:
diff changeset
   504
    indexToGet = mTestObjectInitialized->index(0, 0);
hgs
parents:
diff changeset
   505
    QVERIFY(indexToGet.isValid()); 
hgs
parents:
diff changeset
   506
    QVERIFY(indexToGet.row() == 0); 
hgs
parents:
diff changeset
   507
    
hgs
parents:
diff changeset
   508
    // middle
hgs
parents:
diff changeset
   509
    indexToGet = mTestObjectInitialized->index(MEDIA_COUNT / 2, 0);
hgs
parents:
diff changeset
   510
    QVERIFY(indexToGet.isValid()); 
hgs
parents:
diff changeset
   511
    QVERIFY(indexToGet.row() == (MEDIA_COUNT / 2)); 
hgs
parents:
diff changeset
   512
    
hgs
parents:
diff changeset
   513
    // last
hgs
parents:
diff changeset
   514
    indexToGet = mTestObjectInitialized->index(MEDIA_COUNT - 1, 0);
hgs
parents:
diff changeset
   515
    QVERIFY(indexToGet.isValid()); 
hgs
parents:
diff changeset
   516
    QVERIFY(indexToGet.row() == (MEDIA_COUNT -1)); 
hgs
parents:
diff changeset
   517
}
hgs
parents:
diff changeset
   518
hgs
parents:
diff changeset
   519
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   520
// testParent
hgs
parents:
diff changeset
   521
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   522
//
hgs
parents:
diff changeset
   523
void TestVideoListDataModel::testParent()
hgs
parents:
diff changeset
   524
{
hgs
parents:
diff changeset
   525
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
   526
    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
hgs
parents:
diff changeset
   527
hgs
parents:
diff changeset
   528
    QModelIndex index = mTestObjectInitialized->index(0,0);
hgs
parents:
diff changeset
   529
    QVERIFY(index.isValid());
hgs
parents:
diff changeset
   530
    QModelIndex parentIndex = mTestObjectInitialized->parent(index);
hgs
parents:
diff changeset
   531
    QVERIFY(!parentIndex.isValid());
hgs
parents:
diff changeset
   532
}
hgs
parents:
diff changeset
   533
hgs
parents:
diff changeset
   534
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   535
// testPrepareDetails
hgs
parents:
diff changeset
   536
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   537
//
hgs
parents:
diff changeset
   538
void TestVideoListDataModel::testPrepareDetails() 
hgs
parents:
diff changeset
   539
{
hgs
parents:
diff changeset
   540
    // cannot call preparedetails directly, need to call indirectly using 
hgs
parents:
diff changeset
   541
    // public data -method.
hgs
parents:
diff changeset
   542
    
hgs
parents:
diff changeset
   543
    QString details("");
hgs
parents:
diff changeset
   544
    QModelIndex modelIndex;
hgs
parents:
diff changeset
   545
    QVariant result;
hgs
parents:
diff changeset
   546
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   547
    
hgs
parents:
diff changeset
   548
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
   549
    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
hgs
parents:
diff changeset
   550
        
hgs
parents:
diff changeset
   551
    // missing size
hgs
parents:
diff changeset
   552
    mMediaFactory->removeArray();        
hgs
parents:
diff changeset
   553
    mMediaFactory->createMediaItems(MEDIA_COUNT, 0, MediaDetailDurationFlag);
hgs
parents:
diff changeset
   554
    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
hgs
parents:
diff changeset
   555
    details.clear();
hgs
parents:
diff changeset
   556
    modelIndex = mTestObjectInitialized->index(MEDIA_COUNT / 2, 0);
hgs
parents:
diff changeset
   557
  
hgs
parents:
diff changeset
   558
    result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
hgs
parents:
diff changeset
   559
    QVERIFY (result.toStringList().count() == 2 );
hgs
parents:
diff changeset
   560
    QVERIFY(!result.toStringList().at(1).contains(","));
hgs
parents:
diff changeset
   561
    
hgs
parents:
diff changeset
   562
    // missing duration
hgs
parents:
diff changeset
   563
    mMediaFactory->removeArray();        
hgs
parents:
diff changeset
   564
    mMediaFactory->createMediaItems(MEDIA_COUNT, 0, MediaDetailSizeFlag);
hgs
parents:
diff changeset
   565
    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
hgs
parents:
diff changeset
   566
    details.clear();
hgs
parents:
diff changeset
   567
    modelIndex = mTestObjectInitialized->index(MEDIA_COUNT / 2, 0);
hgs
parents:
diff changeset
   568
    result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
hgs
parents:
diff changeset
   569
    QVERIFY (result.toStringList().count() == 2 );
hgs
parents:
diff changeset
   570
    
hgs
parents:
diff changeset
   571
    // missing both
hgs
parents:
diff changeset
   572
    mMediaFactory->removeArray();        
hgs
parents:
diff changeset
   573
    mMediaFactory->createMediaItems(MEDIA_COUNT, 0, MediaDetailNone);
hgs
parents:
diff changeset
   574
    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
hgs
parents:
diff changeset
   575
    details.clear();
hgs
parents:
diff changeset
   576
    modelIndex = mTestObjectInitialized->index(MEDIA_COUNT / 2, 0);
hgs
parents:
diff changeset
   577
    result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
hgs
parents:
diff changeset
   578
    QVERIFY (result.toStringList().count() == 2 );
hgs
parents:
diff changeset
   579
    
hgs
parents:
diff changeset
   580
    // album typed data
hgs
parents:
diff changeset
   581
    mMediaFactory->removeArray();        
35
hgs
parents: 34
diff changeset
   582
    mMediaFactory->createMediaItems(5, 2, MediaDetailCategoryVideoCount);
34
hgs
parents:
diff changeset
   583
    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
hgs
parents:
diff changeset
   584
    modelIndex = mTestObjectInitialized->index(3, 0);
hgs
parents:
diff changeset
   585
    result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
hgs
parents:
diff changeset
   586
    QVERIFY (result.toStringList().count() == 2 );
35
hgs
parents: 34
diff changeset
   587
}
hgs
parents: 34
diff changeset
   588
hgs
parents: 34
diff changeset
   589
// -----------------------------------------------------------------------------
hgs
parents: 34
diff changeset
   590
// testPrepareVideoCountString
hgs
parents: 34
diff changeset
   591
// -----------------------------------------------------------------------------
hgs
parents: 34
diff changeset
   592
//
hgs
parents: 34
diff changeset
   593
void TestVideoListDataModel::testPrepareVideoCountString()
hgs
parents: 34
diff changeset
   594
{
hgs
parents: 34
diff changeset
   595
    QString details("");
hgs
parents: 34
diff changeset
   596
    QModelIndex modelIndex;
hgs
parents: 34
diff changeset
   597
    QVariant result;
hgs
parents: 34
diff changeset
   598
    
hgs
parents: 34
diff changeset
   599
    // Cagegory typed data.
hgs
parents: 34
diff changeset
   600
    mMediaFactory->removeArray();
hgs
parents: 34
diff changeset
   601
    mMediaFactory->createMediaItems(MEDIA_COUNT, 1, MediaDetailCategoryVideoCount);
hgs
parents: 34
diff changeset
   602
    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
hgs
parents: 34
diff changeset
   603
hgs
parents: 34
diff changeset
   604
    modelIndex = mTestObjectInitialized->index(MEDIA_COUNT / 2, 0);
hgs
parents: 34
diff changeset
   605
    result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
hgs
parents: 34
diff changeset
   606
    QVERIFY (result.toStringList().count() == 2 );
hgs
parents: 34
diff changeset
   607
    
hgs
parents: 34
diff changeset
   608
    modelIndex = mTestObjectInitialized->index(MEDIA_COUNT-1, 0);
hgs
parents: 34
diff changeset
   609
    result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
hgs
parents: 34
diff changeset
   610
    QVERIFY (result.toStringList().count() == 2 );
34
hgs
parents:
diff changeset
   611
}
hgs
parents:
diff changeset
   612
hgs
parents:
diff changeset
   613
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   614
// testPrepareSizeString
hgs
parents:
diff changeset
   615
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   616
//
hgs
parents:
diff changeset
   617
void TestVideoListDataModel::testPrepareSizeString()
hgs
parents:
diff changeset
   618
{
hgs
parents:
diff changeset
   619
    // This tests the CVideoCollectionUtils::prepareSizeString at the same time
hgs
parents:
diff changeset
   620
    // as we do not have separate tests for that.
hgs
parents:
diff changeset
   621
hgs
parents:
diff changeset
   622
    // cannot call prepareSizeStrings directly, need to call indirectly using 
hgs
parents:
diff changeset
   623
    // public data -method. That means: 
hgs
parents:
diff changeset
   624
    // - we cannot test without videolistdata -object -case because tested throught data -call and
hgs
parents:
diff changeset
   625
    //   existence is tested there already
hgs
parents:
diff changeset
   626
    // cannot chck the actual string due localization
hgs
parents:
diff changeset
   627
    QString details("");
hgs
parents:
diff changeset
   628
    QModelIndex modelIndex;
hgs
parents:
diff changeset
   629
    QVariant result;  
hgs
parents:
diff changeset
   630
   
hgs
parents:
diff changeset
   631
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   632
    
hgs
parents:
diff changeset
   633
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
   634
    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
hgs
parents:
diff changeset
   635
    
hgs
parents:
diff changeset
   636
    modelIndex = mTestObjectInitialized->index(MEDIA_COUNT / 2, 0);
hgs
parents:
diff changeset
   637
    
hgs
parents:
diff changeset
   638
    // zero size
hgs
parents:
diff changeset
   639
    VideoListDataModelPrivate::mOverrideSize = true;
hgs
parents:
diff changeset
   640
    VideoListDataModelPrivate::mSize = 0;
hgs
parents:
diff changeset
   641
    result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
hgs
parents:
diff changeset
   642
    QVERIFY(!result.toStringList().at(1).contains(","));    
hgs
parents:
diff changeset
   643
    result = QVariant();
hgs
parents:
diff changeset
   644
    // 1 byte
hgs
parents:
diff changeset
   645
    VideoListDataModelPrivate::mSize = 1;
hgs
parents:
diff changeset
   646
    result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
hgs
parents:
diff changeset
   647
    QVERIFY(result.toStringList().at(1).length() > 0);
hgs
parents:
diff changeset
   648
    result = QVariant();
hgs
parents:
diff changeset
   649
    
hgs
parents:
diff changeset
   650
    // under kB
hgs
parents:
diff changeset
   651
    VideoListDataModelPrivate::mSize = 1023;
hgs
parents:
diff changeset
   652
    result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
hgs
parents:
diff changeset
   653
    QVERIFY(result.toStringList().at(1).length() > 0);
hgs
parents:
diff changeset
   654
    result = QVariant();
hgs
parents:
diff changeset
   655
    // exactly on kB
hgs
parents:
diff changeset
   656
    VideoListDataModelPrivate::mSize = 1024;
hgs
parents:
diff changeset
   657
    result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
hgs
parents:
diff changeset
   658
    QVERIFY(result.toStringList().at(1).length() > 0);
hgs
parents:
diff changeset
   659
    result = QVariant();
hgs
parents:
diff changeset
   660
    // over kB but under under MB
hgs
parents:
diff changeset
   661
    VideoListDataModelPrivate::mSize = 0xFFFFF;
hgs
parents:
diff changeset
   662
    result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
hgs
parents:
diff changeset
   663
    QVERIFY(result.toStringList().at(1).length() > 0);
hgs
parents:
diff changeset
   664
    result = QVariant();
hgs
parents:
diff changeset
   665
    // MB
hgs
parents:
diff changeset
   666
    VideoListDataModelPrivate::mSize = 0x100000;
hgs
parents:
diff changeset
   667
    result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
hgs
parents:
diff changeset
   668
    QVERIFY(result.toStringList().at(1).length() > 0);
hgs
parents:
diff changeset
   669
    result = QVariant();
hgs
parents:
diff changeset
   670
    // larger than MB but smaller than GB
hgs
parents:
diff changeset
   671
    VideoListDataModelPrivate::mSize = 0x3FFFFFFF;
hgs
parents:
diff changeset
   672
    result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
hgs
parents:
diff changeset
   673
    QVERIFY(result.toStringList().at(1).length() > 0);
hgs
parents:
diff changeset
   674
    result = QVariant();
hgs
parents:
diff changeset
   675
    // 1 GB
hgs
parents:
diff changeset
   676
    VideoListDataModelPrivate::mSize = 0x40000000;
hgs
parents:
diff changeset
   677
    result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
hgs
parents:
diff changeset
   678
    QVERIFY(result.toStringList().at(1).length() > 0);
hgs
parents:
diff changeset
   679
    result = QVariant();
hgs
parents:
diff changeset
   680
    
hgs
parents:
diff changeset
   681
    // larger than 1 GB
hgs
parents:
diff changeset
   682
    VideoListDataModelPrivate::mSize = 0x90000000;
hgs
parents:
diff changeset
   683
    result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
hgs
parents:
diff changeset
   684
    QVERIFY(result.toStringList().at(1).length() > 0);
hgs
parents:
diff changeset
   685
    result = QVariant();
hgs
parents:
diff changeset
   686
    
hgs
parents:
diff changeset
   687
    VideoListDataModelPrivate::mOverrideSize = false;
hgs
parents:
diff changeset
   688
}
hgs
parents:
diff changeset
   689
hgs
parents:
diff changeset
   690
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   691
// testPrepareLengthString
hgs
parents:
diff changeset
   692
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   693
//
hgs
parents:
diff changeset
   694
void TestVideoListDataModel::testPrepareLengthString()
hgs
parents:
diff changeset
   695
{
hgs
parents:
diff changeset
   696
    // This tests the CVideoCollectionUtils::prepareSizeString at the same time
hgs
parents:
diff changeset
   697
    // as we do not have separate tests for that.
hgs
parents:
diff changeset
   698
    //
hgs
parents:
diff changeset
   699
    // cannot check the actual strin due localisation
hgs
parents:
diff changeset
   700
    //
36
hgs
parents: 35
diff changeset
   701
    // cannot call prepareShortLengthString directly, need to call indirectly using 
34
hgs
parents:
diff changeset
   702
    // public data -method. That means: 
hgs
parents:
diff changeset
   703
    // - we cannot test without videolistdata -object -case because tested throught data -call and
hgs
parents:
diff changeset
   704
    //   existence is tested there already
hgs
parents:
diff changeset
   705
    
hgs
parents:
diff changeset
   706
    QString details("");
hgs
parents:
diff changeset
   707
    QModelIndex modelIndex;
hgs
parents:
diff changeset
   708
    QVariant result;  
hgs
parents:
diff changeset
   709
   
hgs
parents:
diff changeset
   710
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   711
    
hgs
parents:
diff changeset
   712
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
   713
    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
hgs
parents:
diff changeset
   714
    modelIndex = mTestObjectInitialized->index(MEDIA_COUNT / 2, 0);
hgs
parents:
diff changeset
   715
    
hgs
parents:
diff changeset
   716
    // override size to zero, so prepareDetailRow doesn't include size in the detail row text.
hgs
parents:
diff changeset
   717
    VideoListDataModelPrivate::mOverrideSize = true;
hgs
parents:
diff changeset
   718
    VideoListDataModelPrivate::mSize = 0;
hgs
parents:
diff changeset
   719
    VideoListDataModelPrivate::mOverrideDuration = true;
hgs
parents:
diff changeset
   720
    VideoListDataModelPrivate::mDuration = 0;
hgs
parents:
diff changeset
   721
hgs
parents:
diff changeset
   722
    // zero
hgs
parents:
diff changeset
   723
    VideoListDataModelPrivate::mDuration = 0;
hgs
parents:
diff changeset
   724
    result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
hgs
parents:
diff changeset
   725
    result = QVariant();
hgs
parents:
diff changeset
   726
   
hgs
parents:
diff changeset
   727
    // second
hgs
parents:
diff changeset
   728
    VideoListDataModelPrivate::mDuration = 1;
hgs
parents:
diff changeset
   729
    result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
hgs
parents:
diff changeset
   730
    QVERIFY(result.toStringList().at(1).length() > 0); 
hgs
parents:
diff changeset
   731
    result = QVariant();
hgs
parents:
diff changeset
   732
    
hgs
parents:
diff changeset
   733
    // over 1 second, under minute
hgs
parents:
diff changeset
   734
    VideoListDataModelPrivate::mDuration = 59;
hgs
parents:
diff changeset
   735
    result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
hgs
parents:
diff changeset
   736
    QVERIFY(result.toStringList().at(1).length() > 0); 
hgs
parents:
diff changeset
   737
    result = QVariant();
hgs
parents:
diff changeset
   738
    
hgs
parents:
diff changeset
   739
    // one minute
hgs
parents:
diff changeset
   740
    VideoListDataModelPrivate::mDuration = 60;
hgs
parents:
diff changeset
   741
    result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
hgs
parents:
diff changeset
   742
    QVERIFY(result.toStringList().at(1).length() > 0); 
hgs
parents:
diff changeset
   743
    result = QVariant();
hgs
parents:
diff changeset
   744
    
hgs
parents:
diff changeset
   745
    // one minute one second 
hgs
parents:
diff changeset
   746
    VideoListDataModelPrivate::mDuration = 61;
hgs
parents:
diff changeset
   747
    result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
hgs
parents:
diff changeset
   748
    QVERIFY(result.toStringList().at(1).length() > 0); 
hgs
parents:
diff changeset
   749
    result = QVariant();
hgs
parents:
diff changeset
   750
    
hgs
parents:
diff changeset
   751
    // more than one minute and one second
hgs
parents:
diff changeset
   752
    VideoListDataModelPrivate::mDuration = 3599;
hgs
parents:
diff changeset
   753
    result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
hgs
parents:
diff changeset
   754
    QVERIFY(result.toStringList().at(1).length() > 0); 
hgs
parents:
diff changeset
   755
    result = QVariant();
hgs
parents:
diff changeset
   756
        
hgs
parents:
diff changeset
   757
    // one hour
hgs
parents:
diff changeset
   758
    VideoListDataModelPrivate::mDuration = 3600;
hgs
parents:
diff changeset
   759
    result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
hgs
parents:
diff changeset
   760
    QVERIFY(result.toStringList().at(1).length() > 0); 
hgs
parents:
diff changeset
   761
    result = QVariant();
hgs
parents:
diff changeset
   762
    
hgs
parents:
diff changeset
   763
    // one hour, one minute
hgs
parents:
diff changeset
   764
    VideoListDataModelPrivate::mDuration = 3660;
hgs
parents:
diff changeset
   765
    result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
hgs
parents:
diff changeset
   766
    QVERIFY(result.toStringList().at(1).length() > 0); 
hgs
parents:
diff changeset
   767
    result = QVariant();
hgs
parents:
diff changeset
   768
    
hgs
parents:
diff changeset
   769
    // over hour
hgs
parents:
diff changeset
   770
    VideoListDataModelPrivate::mDuration = 8654;
hgs
parents:
diff changeset
   771
    result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
hgs
parents:
diff changeset
   772
    QVERIFY(result.toStringList().at(1).length() > 0); 
hgs
parents:
diff changeset
   773
    result = QVariant();
hgs
parents:
diff changeset
   774
    
hgs
parents:
diff changeset
   775
    VideoListDataModelPrivate::mOverrideSize = false;
hgs
parents:
diff changeset
   776
    VideoListDataModelPrivate::mOverrideDuration = true;
hgs
parents:
diff changeset
   777
    VideoListDataModelPrivate::mDuration = 0;
hgs
parents:
diff changeset
   778
}
hgs
parents:
diff changeset
   779
hgs
parents:
diff changeset
   780
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   781
// testRemoveRows
hgs
parents:
diff changeset
   782
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   783
//
hgs
parents:
diff changeset
   784
void TestVideoListDataModel::testRemoveRows()
hgs
parents:
diff changeset
   785
{
hgs
parents:
diff changeset
   786
    QSignalSpy spysignal(mTestObjectInitialized, SIGNAL(modelChanged()));
hgs
parents:
diff changeset
   787
    QModelIndexList indexList;       
hgs
parents:
diff changeset
   788
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   789
    
hgs
parents:
diff changeset
   790
    // no collection neither deleteworker
hgs
parents:
diff changeset
   791
    QVERIFY(!mTestObjectNotInitialized->removeRows(indexList));
hgs
parents:
diff changeset
   792
    
hgs
parents:
diff changeset
   793
    // empty list provided
hgs
parents:
diff changeset
   794
    QVERIFY(!mTestObjectInitialized->removeRows(indexList));
hgs
parents:
diff changeset
   795
    QVERIFY(spysignal.count() == 1);
hgs
parents:
diff changeset
   796
    QVERIFY(mTestObjectInitialized->mDeleteWorker->mRequestList.count() == 0);
hgs
parents:
diff changeset
   797
    spysignal.clear();
hgs
parents:
diff changeset
   798
    
hgs
parents:
diff changeset
   799
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
   800
    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
hgs
parents:
diff changeset
   801
    indexList.append(mTestObjectInitialized->index(0,0));
hgs
parents:
diff changeset
   802
    indexList.append(mTestObjectInitialized->index(1,0));
hgs
parents:
diff changeset
   803
    
hgs
parents:
diff changeset
   804
    // invalid id from mark -call (for coverity's sake
hgs
parents:
diff changeset
   805
    VideoListDataModelPrivate::mReturnInvalidMarked = true;
hgs
parents:
diff changeset
   806
    QVERIFY(!mTestObjectInitialized->removeRows(indexList));
hgs
parents:
diff changeset
   807
    QVERIFY(spysignal.count() == 1);
hgs
parents:
diff changeset
   808
    QVERIFY(mTestObjectInitialized->mDeleteWorker->mRequestList.count() == 0);
hgs
parents:
diff changeset
   809
    spysignal.clear();
hgs
parents:
diff changeset
   810
    
hgs
parents:
diff changeset
   811
    VideoListDataModelPrivate::mReturnInvalidMarked = false;  
hgs
parents:
diff changeset
   812
    // no invalid ids
hgs
parents:
diff changeset
   813
    QVERIFY(mTestObjectInitialized->removeRows(indexList));
hgs
parents:
diff changeset
   814
    QVERIFY(spysignal.count() == 1);
hgs
parents:
diff changeset
   815
    QVERIFY(mTestObjectInitialized->mDeleteWorker->mRequestList.count() == 2);
hgs
parents:
diff changeset
   816
    QVERIFY(mTestObjectInitialized->mDeleteWorker->mRequestList.at(0) != TMPXItemId::InvalidId());
hgs
parents:
diff changeset
   817
    QVERIFY(mTestObjectInitialized->mDeleteWorker->mRequestList.at(1) != TMPXItemId::InvalidId());
hgs
parents:
diff changeset
   818
hgs
parents:
diff changeset
   819
}
hgs
parents:
diff changeset
   820
hgs
parents:
diff changeset
   821
void TestVideoListDataModel::testDeleteStartingFailsSlot()
hgs
parents:
diff changeset
   822
{
hgs
parents:
diff changeset
   823
    QSignalSpy spysignal(mTestObjectInitialized, SIGNAL(modelChanged()));
hgs
parents:
diff changeset
   824
    mTestObjectInitialized->mDeleteWorker->mIsDeleting = false;
hgs
parents:
diff changeset
   825
    VideoCollectionWrapper::mLatestStatusCode = -1;
hgs
parents:
diff changeset
   826
    VideoCollectionWrapper::mLatestAdditional = QVariant();
hgs
parents:
diff changeset
   827
    
hgs
parents:
diff changeset
   828
    QList<TMPXItemId> idList;
hgs
parents:
diff changeset
   829
    // empty list
hgs
parents:
diff changeset
   830
    emit mTestObjectInitialized->mDeleteWorker->deleteStartupFailed(idList);
hgs
parents:
diff changeset
   831
    QVERIFY(VideoCollectionWrapper::mLatestStatusCode == -1);
hgs
parents:
diff changeset
   832
    QVERIFY(!VideoCollectionWrapper::mLatestAdditional.isValid());
hgs
parents:
diff changeset
   833
    QVERIFY(spysignal.count() == 1);
hgs
parents:
diff changeset
   834
    spysignal.clear();
hgs
parents:
diff changeset
   835
    
hgs
parents:
diff changeset
   836
    
hgs
parents:
diff changeset
   837
    idList.append(TMPXItemId(0,0));
hgs
parents:
diff changeset
   838
    // list containing something
hgs
parents:
diff changeset
   839
    emit mTestObjectInitialized->mDeleteWorker->deleteStartupFailed(idList);
hgs
parents:
diff changeset
   840
    QVERIFY(VideoCollectionWrapper::mLatestStatusCode == VideoCollectionCommon::statusMultipleDeleteFail);
hgs
parents:
diff changeset
   841
    QVERIFY(VideoCollectionWrapper::mLatestAdditional.isValid());
hgs
parents:
diff changeset
   842
    QVERIFY(VideoCollectionWrapper::mLatestAdditional.toInt() == 1);
hgs
parents:
diff changeset
   843
    QVERIFY(spysignal.count() == 1);
hgs
parents:
diff changeset
   844
    spysignal.clear();
hgs
parents:
diff changeset
   845
 
hgs
parents:
diff changeset
   846
}
hgs
parents:
diff changeset
   847
hgs
parents:
diff changeset
   848
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   849
// testBelongsToAlbum
hgs
parents:
diff changeset
   850
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   851
//
hgs
parents:
diff changeset
   852
void TestVideoListDataModel::testBelongsToAlbum()
hgs
parents:
diff changeset
   853
{
hgs
parents:
diff changeset
   854
    VideoListDataModelPrivate::mBelongsToAlbum = true;
hgs
parents:
diff changeset
   855
    TMPXItemId dummyId(1,1);
hgs
parents:
diff changeset
   856
    TMPXItemId dummyVideoId(1,0);
hgs
parents:
diff changeset
   857
    QVERIFY(mTestObjectInitialized->belongsToAlbum(dummyVideoId, dummyId));
hgs
parents:
diff changeset
   858
}   
hgs
parents:
diff changeset
   859
hgs
parents:
diff changeset
   860
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   861
// testSetAlbumInUse
hgs
parents:
diff changeset
   862
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   863
//
hgs
parents:
diff changeset
   864
void TestVideoListDataModel::testSetAlbumInUse()
hgs
parents:
diff changeset
   865
{
hgs
parents:
diff changeset
   866
    TMPXItemId dummyId(1,1);   
hgs
parents:
diff changeset
   867
    mTestObjectInitialized->setAlbumInUse(dummyId);
35
hgs
parents: 34
diff changeset
   868
    QVERIFY(mTestObjectInitialized->albumInUse() == dummyId);
hgs
parents: 34
diff changeset
   869
}
hgs
parents: 34
diff changeset
   870
hgs
parents: 34
diff changeset
   871
// -----------------------------------------------------------------------------
hgs
parents: 34
diff changeset
   872
// testRemoveItemsFromAlbum
hgs
parents: 34
diff changeset
   873
// -----------------------------------------------------------------------------
hgs
parents: 34
diff changeset
   874
//
hgs
parents: 34
diff changeset
   875
void TestVideoListDataModel::testRemoveItemsFromAlbum()
hgs
parents: 34
diff changeset
   876
{
hgs
parents: 34
diff changeset
   877
    VideoListDataModelPrivate::mRemoveFrAlbumReturn = 0;
hgs
parents: 34
diff changeset
   878
    VideoCollectionClient::mRemoveItemsReturn = 0;
hgs
parents: 34
diff changeset
   879
    TMPXItemId id(0,0);
hgs
parents: 34
diff changeset
   880
    QList<TMPXItemId> items;
hgs
parents: 34
diff changeset
   881
    items.append(id);
hgs
parents: 34
diff changeset
   882
    // remove count == 0
hgs
parents: 34
diff changeset
   883
    QVERIFY(mTestObjectInitialized->removeItemsFromAlbum(id, items) == 0);
hgs
parents: 34
diff changeset
   884
    
hgs
parents: 34
diff changeset
   885
    VideoListDataModelPrivate::mRemoveFrAlbumReturn = 1;
hgs
parents: 34
diff changeset
   886
    VideoCollectionClient::mRemoveItemsReturn = -1;
hgs
parents: 34
diff changeset
   887
    // collectionclient returns < 0
hgs
parents: 34
diff changeset
   888
    QVERIFY(mTestObjectInitialized->removeItemsFromAlbum(id, items) < 0);
hgs
parents: 34
diff changeset
   889
    
hgs
parents: 34
diff changeset
   890
    VideoListDataModelPrivate::mRemoveFrAlbumReturn = 1;
hgs
parents: 34
diff changeset
   891
    VideoCollectionClient::mRemoveItemsReturn = 0;
hgs
parents: 34
diff changeset
   892
    // succeeds
hgs
parents: 34
diff changeset
   893
    QVERIFY(mTestObjectInitialized->removeItemsFromAlbum(id, items) == 1);
34
hgs
parents:
diff changeset
   894
}
hgs
parents:
diff changeset
   895
hgs
parents:
diff changeset
   896
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   897
// testreportAsyncStatus
hgs
parents:
diff changeset
   898
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   899
//
hgs
parents:
diff changeset
   900
void TestVideoListDataModel::testreportAsyncStatus()
hgs
parents:
diff changeset
   901
{
hgs
parents:
diff changeset
   902
    mTestObjectInitialized->mDeleteWorker->mIsDeleting = false;
hgs
parents:
diff changeset
   903
    VideoCollectionWrapper::mLatestStatusCode = -1;
hgs
parents:
diff changeset
   904
    VideoCollectionWrapper::mLatestAdditional = QVariant();
hgs
parents:
diff changeset
   905
    
hgs
parents:
diff changeset
   906
    QVariant data = QString("test");
hgs
parents:
diff changeset
   907
    // no deleteworker
hgs
parents:
diff changeset
   908
    VideoDeleteWorker *tmp = mTestObjectInitialized->mDeleteWorker;
hgs
parents:
diff changeset
   909
    mTestObjectInitialized->mDeleteWorker = 0;
hgs
parents:
diff changeset
   910
    mTestObjectInitialized->d_ptr->callModelAsyncReport(VideoCollectionCommon::statusMultipleDeleteFail, data);
hgs
parents:
diff changeset
   911
    QVERIFY(VideoCollectionWrapper::mLatestStatusCode == -1);
hgs
parents:
diff changeset
   912
    QVERIFY(!VideoCollectionWrapper::mLatestAdditional.isValid());
hgs
parents:
diff changeset
   913
    mTestObjectInitialized->mDeleteWorker = tmp;
hgs
parents:
diff changeset
   914
    
hgs
parents:
diff changeset
   915
    // code == VideoCollectionCommon::statusSingleDeleteFail
hgs
parents:
diff changeset
   916
    mTestObjectInitialized->mDeleteWorker->mIsDeleting = true;
hgs
parents:
diff changeset
   917
    mTestObjectInitialized->d_ptr->callModelAsyncReport(VideoCollectionCommon::statusSingleDeleteFail, data);
hgs
parents:
diff changeset
   918
    QVERIFY(VideoCollectionWrapper::mLatestStatusCode == -1);
hgs
parents:
diff changeset
   919
    QVERIFY(!VideoCollectionWrapper::mLatestAdditional.isValid());
hgs
parents:
diff changeset
   920
    mTestObjectInitialized->mDeleteWorker->mIsDeleting = false; 
hgs
parents:
diff changeset
   921
    mTestObjectInitialized->d_ptr->callModelAsyncReport(VideoCollectionCommon::statusSingleDeleteFail, data);
hgs
parents:
diff changeset
   922
    QVERIFY(VideoCollectionWrapper::mLatestStatusCode == VideoCollectionCommon::statusSingleDeleteFail);
hgs
parents:
diff changeset
   923
    QVERIFY(VideoCollectionWrapper::mLatestAdditional.isValid());
hgs
parents:
diff changeset
   924
    QVERIFY(VideoCollectionWrapper::mLatestAdditional.toString() == data.toString());
hgs
parents:
diff changeset
   925
    VideoCollectionWrapper::mLatestStatusCode = -1;
hgs
parents:
diff changeset
   926
    VideoCollectionWrapper::mLatestAdditional = QVariant();
hgs
parents:
diff changeset
   927
    
hgs
parents:
diff changeset
   928
    // code ==  VideoCollectionCommon::statusMultipleDeleteFail
hgs
parents:
diff changeset
   929
    mTestObjectInitialized->mDeleteWorker->mIsDeleting = true;
hgs
parents:
diff changeset
   930
    mTestObjectInitialized->d_ptr->callModelAsyncReport(VideoCollectionCommon::statusMultipleDeleteFail, data);
hgs
parents:
diff changeset
   931
    QVERIFY(VideoCollectionWrapper::mLatestStatusCode == -1);
hgs
parents:
diff changeset
   932
    QVERIFY(!VideoCollectionWrapper::mLatestAdditional.isValid());
hgs
parents:
diff changeset
   933
    mTestObjectInitialized->mDeleteWorker->mIsDeleting = false; 
hgs
parents:
diff changeset
   934
    mTestObjectInitialized->d_ptr->callModelAsyncReport(VideoCollectionCommon::statusMultipleDeleteFail, data);
hgs
parents:
diff changeset
   935
    QVERIFY(VideoCollectionWrapper::mLatestStatusCode == VideoCollectionCommon::statusMultipleDeleteFail);
hgs
parents:
diff changeset
   936
    QVERIFY(VideoCollectionWrapper::mLatestAdditional.isValid());
hgs
parents:
diff changeset
   937
    QVERIFY(VideoCollectionWrapper::mLatestAdditional.toString() == data.toString());
hgs
parents:
diff changeset
   938
    
hgs
parents:
diff changeset
   939
    // code is neither above
hgs
parents:
diff changeset
   940
    mTestObjectInitialized->d_ptr->callModelAsyncReport(-2, data);
hgs
parents:
diff changeset
   941
    QVERIFY(VideoCollectionWrapper::mLatestStatusCode == -2);
hgs
parents:
diff changeset
   942
    QVERIFY(VideoCollectionWrapper::mLatestAdditional.isValid());
hgs
parents:
diff changeset
   943
    QVERIFY(VideoCollectionWrapper::mLatestAdditional.toString() == data.toString());
hgs
parents:
diff changeset
   944
}
hgs
parents:
diff changeset
   945
hgs
parents:
diff changeset
   946
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   947
// initializeTestObjects
hgs
parents:
diff changeset
   948
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   949
//
hgs
parents:
diff changeset
   950
bool TestVideoListDataModel::initializeTestObjects()
hgs
parents:
diff changeset
   951
{
hgs
parents:
diff changeset
   952
hgs
parents:
diff changeset
   953
    mCollectionStub = NULL;
hgs
parents:
diff changeset
   954
    mTestObjectInitialized  = NULL;
hgs
parents:
diff changeset
   955
    mTestObjectNotInitialized = NULL;
hgs
parents:
diff changeset
   956
    
hgs
parents:
diff changeset
   957
   
hgs
parents:
diff changeset
   958
    mCollectionStub = new VideoCollectionClient();
hgs
parents:
diff changeset
   959
    if(!mCollectionStub)
hgs
parents:
diff changeset
   960
    {
hgs
parents:
diff changeset
   961
       return false;
hgs
parents:
diff changeset
   962
    }
hgs
parents:
diff changeset
   963
    
hgs
parents:
diff changeset
   964
    mTestObjectInitialized  = new VideoListDataModel();
hgs
parents:
diff changeset
   965
    if(!mTestObjectInitialized)
hgs
parents:
diff changeset
   966
    {
hgs
parents:
diff changeset
   967
       return false;
hgs
parents:
diff changeset
   968
    }
hgs
parents:
diff changeset
   969
    VideoCollectionClient::mFailConnectSignals = false;
hgs
parents:
diff changeset
   970
    VideoCollectionClient::mFailInitialize = false;
hgs
parents:
diff changeset
   971
    VideoListDataModelPrivate::mFailInit = false;
hgs
parents:
diff changeset
   972
    if( mTestObjectInitialized->initialize() == -1)
hgs
parents:
diff changeset
   973
    {
hgs
parents:
diff changeset
   974
       return false;
hgs
parents:
diff changeset
   975
    }
hgs
parents:
diff changeset
   976
    
hgs
parents:
diff changeset
   977
    mTestObjectNotInitialized  = new VideoListDataModel(); 
hgs
parents:
diff changeset
   978
    if(!mTestObjectNotInitialized)
hgs
parents:
diff changeset
   979
    {
hgs
parents:
diff changeset
   980
       return false;
hgs
parents:
diff changeset
   981
    }
hgs
parents:
diff changeset
   982
    
hgs
parents:
diff changeset
   983
    return true;
hgs
parents:
diff changeset
   984
   
hgs
parents:
diff changeset
   985
}
hgs
parents:
diff changeset
   986
hgs
parents:
diff changeset
   987
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   988
// cleanupTestObjects
hgs
parents:
diff changeset
   989
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   990
//
hgs
parents:
diff changeset
   991
void TestVideoListDataModel::cleanupTestObjects()
hgs
parents:
diff changeset
   992
{
hgs
parents:
diff changeset
   993
    delete mCollectionStub;
hgs
parents:
diff changeset
   994
    delete mTestObjectInitialized;
hgs
parents:
diff changeset
   995
    delete mTestObjectNotInitialized;
hgs
parents:
diff changeset
   996
}
hgs
parents:
diff changeset
   997
hgs
parents:
diff changeset
   998
hgs
parents:
diff changeset
   999
// End of file
hgs
parents:
diff changeset
  1000
    
hgs
parents:
diff changeset
  1001
hgs
parents:
diff changeset
  1002