← Back to branch summary

~ci-train-bot/ubuntu-download-manager/ubuntu-download-manager-ubuntu-yakkety-landing-062

« back to all changes in this revision

Viewing changes to tests/downloads/daemon/test_transfers_queue.cpp

  • Committer: CI Train Bot
  • Author(s): Michael Sheldon
  • Date: 2016-03-08 17:45:57 UTC
  • mfrom: (347.3.2 implement-per-app-queueing)
  • Revision ID: ci-train-bot@canonical.com-20160308174557-1p5az22r7usysv5x
Implement per-app queueing instead of having one global queue for all apps
Approved by: Ken VanDine, PS Jenkins bot

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/downloads/daemon/test_transfers_queue.cpp
100
100
 
101
101
    // add a transfer, set the state to start and assert that it will
102
102
    // be started
103
 
    SignalBarrier spy(_q, SIGNAL(currentChanged(QString)));
 
103
    SignalBarrier spy(_q, SIGNAL(currentChanged(QString, QString)));
104
104
    _q->add(_first);
105
105
 
106
106
    // we do not transfer just yet
107
 
    QVERIFY(_q->currentTransfer().isEmpty());
 
107
    QVERIFY(_q->currentTransfer("").isEmpty());
108
108
 
109
109
    _first->stateChanged();
110
110
    QVERIFY(spy.ensureSignalEmitted());
111
111
    QCOMPARE(spy.count(), 1);
112
112
 
113
113
    QList<QVariant> arguments = spy.takeFirst();
114
 
    QCOMPARE(arguments.at(0).toString(), path);
 
114
    QCOMPARE(arguments.at(1).toString(), path);
 
115
 
115
116
    verifyMocks();
116
117
}
117
118
 
159
160
 
160
161
    // add a transfer, set the state to start and assert that it will
161
162
    // be started
162
 
    SignalBarrier spy(_q, SIGNAL(currentChanged(QString)));
 
163
    SignalBarrier spy(_q, SIGNAL(currentChanged(QString, QString)));
163
164
    _q->add(_first);
164
165
    _q->add(_second);
165
166
 
166
167
    // we do not transfer just yet
167
 
    QVERIFY(_q->currentTransfer().isEmpty());
 
168
    QVERIFY(_q->currentTransfer("").isEmpty());
168
169
 
169
170
    _first->stateChanged();
170
171
    _first->stateChanged();
172
173
    QCOMPARE(spy.count(), 1);
173
174
 
174
175
    QList<QVariant> arguments = spy.takeFirst();
175
 
    QCOMPARE(arguments.at(0).toString(), path);
 
176
    QCOMPARE(arguments.at(1).toString(), path);
176
177
    verifyMocks();
177
178
}
178
179
 
200
201
 
201
202
    // add a transfer, set the state to start and assert that it will
202
203
    // be started
203
 
    SignalBarrier spy(_q, SIGNAL(currentChanged(QString)));
 
204
    SignalBarrier spy(_q, SIGNAL(currentChanged(QString, QString)));
204
205
    _q->add(_first);
205
206
 
206
207
    // we do not transfer just yet
207
 
    QVERIFY(_q->currentTransfer().isEmpty());
 
208
    QVERIFY(_q->currentTransfer("").isEmpty());
208
209
 
209
210
    _first->stateChanged();
210
211
    QVERIFY(spy.ensureSignalEmitted());
211
212
    QCOMPARE(spy.count(), 1);
212
213
 
213
214
    QList<QVariant> arguments = spy.takeFirst();
214
 
    QCOMPARE(arguments.at(0).toString(), QString(""));
 
215
    QCOMPARE(arguments.at(1).toString(), QString(""));
215
216
    verifyMocks();
216
217
}
217
218
 
246
247
 
247
248
    // add a transfer, set the state to start and assert that it will
248
249
    // be started
249
 
    SignalBarrier spy(_q, SIGNAL(currentChanged(QString)));
 
250
    SignalBarrier spy(_q, SIGNAL(currentChanged(QString, QString)));
250
251
    _q->add(_first);
251
252
 
252
253
    // we do not transfer just yet
253
 
    QVERIFY(_q->currentTransfer().isEmpty());
 
254
    QVERIFY(_q->currentTransfer("").isEmpty());
254
255
 
255
256
    _first->stateChanged();
256
257
    _first->stateChanged();
258
259
    QCOMPARE(spy.count(), 2);
259
260
 
260
261
    QList<QVariant> arguments = spy.takeFirst();
261
 
    QCOMPARE(arguments.at(0).toString(), path);
 
262
    QCOMPARE(arguments.at(1).toString(), path);
262
263
    arguments = spy.takeFirst();
263
 
    QCOMPARE(arguments.at(0).toString(), QString(""));
 
264
    QCOMPARE(arguments.at(1).toString(), QString(""));
264
265
    verifyMocks();
265
266
}
266
267
 
318
319
 
319
320
    // add a transfer, set the state to start and assert that it will
320
321
    // be started
321
 
    SignalBarrier spy(_q, SIGNAL(currentChanged(QString)));
 
322
    SignalBarrier spy(_q, SIGNAL(currentChanged(QString, QString)));
322
323
    _q->add(_first);
323
324
    _q->add(_second);
324
325
 
325
326
    // we do not transfer just yet
326
 
    QVERIFY(_q->currentTransfer().isEmpty());
 
327
    QVERIFY(_q->currentTransfer("").isEmpty());
327
328
 
328
329
    _first->stateChanged();
329
330
    _second->stateChanged();
332
333
    QCOMPARE(spy.count(), 2);
333
334
 
334
335
    QList<QVariant> arguments = spy.takeFirst();
335
 
    QCOMPARE(arguments.at(0).toString(), path);
 
336
    QCOMPARE(arguments.at(1).toString(), path);
336
337
    arguments = spy.takeFirst();
337
 
    QCOMPARE(arguments.at(0).toString(), secondPath);
 
338
    QCOMPARE(arguments.at(1).toString(), secondPath);
338
339
    verifyMocks();
339
340
}
340
341
 
388
389
 
389
390
    // add a transfer, set the state to start and assert that it will
390
391
    // be started
391
 
    SignalBarrier spy(_q, SIGNAL(currentChanged(QString)));
 
392
    SignalBarrier spy(_q, SIGNAL(currentChanged(QString, QString)));
392
393
    _q->add(_first);
393
394
    _q->add(_second);
394
395
 
395
396
    // we do not transfer just yet
396
 
    QVERIFY(_q->currentTransfer().isEmpty());
 
397
    QVERIFY(_q->currentTransfer("").isEmpty());
397
398
 
398
399
    _first->stateChanged();
399
400
    _first->stateChanged();
401
402
    QCOMPARE(spy.count(), 2);
402
403
 
403
404
    QList<QVariant> arguments = spy.takeFirst();
404
 
    QCOMPARE(arguments.at(0).toString(), path);
 
405
    QCOMPARE(arguments.at(1).toString(), path);
405
406
    arguments = spy.takeFirst();
406
 
    QCOMPARE(arguments.at(0).toString(), path);
 
407
    QCOMPARE(arguments.at(1).toString(), path);
407
408
    verifyMocks();
408
409
}
409
410
 
462
463
 
463
464
    // add a transfer, set the state to start and assert that it will
464
465
    // be started
465
 
    SignalBarrier spy(_q, SIGNAL(currentChanged(QString)));
 
466
    SignalBarrier spy(_q, SIGNAL(currentChanged(QString, QString)));
466
467
    _q->add(_first);
467
468
    _q->add(_second);
468
469
 
469
470
    // we do not transfer just yet
470
 
    QVERIFY(_q->currentTransfer().isEmpty());
 
471
    QVERIFY(_q->currentTransfer("").isEmpty());
471
472
 
472
473
    _first->stateChanged();
473
474
    _second->stateChanged();
476
477
    QCOMPARE(spy.count(), 2);
477
478
 
478
479
    QList<QVariant> arguments = spy.takeFirst();
479
 
    QCOMPARE(arguments.at(0).toString(), path);
 
480
    QCOMPARE(arguments.at(1).toString(), path);
480
481
    arguments = spy.takeFirst();
481
 
    QCOMPARE(arguments.at(0).toString(), secondPath);
 
482
    QCOMPARE(arguments.at(1).toString(), secondPath);
482
483
    verifyMocks();
483
484
}
484
485
 
530
531
 
531
532
    // add a transfer, set the state to start and assert that it will
532
533
    // be started
533
 
    SignalBarrier spy(_q, SIGNAL(currentChanged(QString)));
 
534
    SignalBarrier spy(_q, SIGNAL(currentChanged(QString, QString)));
534
535
    _q->add(_first);
535
536
    _q->add(_second);
536
537
 
537
538
    // we do not transfer just yet
538
 
    QVERIFY(_q->currentTransfer().isEmpty());
 
539
    QVERIFY(_q->currentTransfer("").isEmpty());
539
540
 
540
541
    _first->stateChanged();
541
542
    _second->stateChanged();
544
545
    QCOMPARE(spy.count(), 2);
545
546
 
546
547
    QList<QVariant> arguments = spy.takeFirst();
547
 
    QCOMPARE(arguments.at(0).toString(), QString());
 
548
    QCOMPARE(arguments.at(1).toString(), QString());
548
549
    arguments = spy.takeFirst();
549
 
    QCOMPARE(arguments.at(0).toString(), path);
 
550
    QCOMPARE(arguments.at(1).toString(), path);
550
551
    verifyMocks();
551
552
}
552
553
 
580
581
 
581
582
    // add a transfer, set the state to start and assert that it will
582
583
    // be started
583
 
    SignalBarrier spy(_q, SIGNAL(currentChanged(QString)));
 
584
    SignalBarrier spy(_q, SIGNAL(currentChanged(QString, QString)));
584
585
    _q->add(_first);
585
586
 
586
587
    // we do not transfer just yet
587
 
    QVERIFY(_q->currentTransfer().isEmpty());
 
588
    QVERIFY(_q->currentTransfer("").isEmpty());
588
589
 
589
590
    _first->stateChanged();
590
591
    _first->stateChanged();
592
593
    QCOMPARE(spy.count(), 2);
593
594
 
594
595
    QList<QVariant> arguments = spy.takeFirst();
595
 
    QCOMPARE(arguments.at(0).toString(), path);
 
596
    QCOMPARE(arguments.at(1).toString(), path);
596
597
    arguments = spy.takeFirst();
597
 
    QCOMPARE(arguments.at(0).toString(), QString());
 
598
    QCOMPARE(arguments.at(1).toString(), QString());
598
599
    verifyMocks();
599
600
}
600
601
 
652
653
 
653
654
    // add a transfer, set the state to start and assert that it will
654
655
    // be started
655
 
    SignalBarrier spy(_q, SIGNAL(currentChanged(QString)));
 
656
    SignalBarrier spy(_q, SIGNAL(currentChanged(QString, QString)));
656
657
    _q->add(_first);
657
658
    _q->add(_second);
658
659
 
659
660
    // we do not transfer just yet
660
 
    QVERIFY(_q->currentTransfer().isEmpty());
 
661
    QVERIFY(_q->currentTransfer("").isEmpty());
661
662
 
662
663
    _first->stateChanged();
663
664
    _second->stateChanged();
666
667
    QCOMPARE(spy.count(), 2);
667
668
 
668
669
    QList<QVariant> arguments = spy.takeFirst();
669
 
    QCOMPARE(arguments.at(0).toString(), path);
 
670
    QCOMPARE(arguments.at(1).toString(), path);
670
671
    arguments = spy.takeFirst();
671
 
    QCOMPARE(arguments.at(0).toString(), secondPath);
 
672
    QCOMPARE(arguments.at(1).toString(), secondPath);
672
673
    verifyMocks();
673
674
}
674
675
 
726
727
 
727
728
    // add a transfer, set the state to start and assert that it will
728
729
    // be started
729
 
    SignalBarrier spy(_q, SIGNAL(currentChanged(QString)));
 
730
    SignalBarrier spy(_q, SIGNAL(currentChanged(QString, QString)));
730
731
    _q->add(_first);
731
732
    _q->add(_second);
732
733
 
733
734
    // we do not transfer just yet
734
 
    QVERIFY(_q->currentTransfer().isEmpty());
 
735
    QVERIFY(_q->currentTransfer("").isEmpty());
735
736
 
736
737
    _first->stateChanged();
737
738
    _second->stateChanged();
740
741
    QCOMPARE(spy.count(), 2);
741
742
 
742
743
    QList<QVariant> arguments = spy.takeFirst();
743
 
    QCOMPARE(arguments.at(0).toString(), path);
 
744
    QCOMPARE(arguments.at(1).toString(), path);
744
745
    arguments = spy.takeFirst();
745
 
    QCOMPARE(arguments.at(0).toString(), secondPath);
 
746
    QCOMPARE(arguments.at(1).toString(), secondPath);
746
747
    verifyMocks();
747
748
}
748
749
 
771
772
    SignalBarrier removedSpy(_q, SIGNAL(transferRemoved(QString)));
772
773
    _q->add(_first);
773
774
 
774
 
    QVERIFY(_q->currentTransfer().isEmpty());
 
775
    QVERIFY(_q->currentTransfer("").isEmpty());
775
776
 
776
777
    _first->stateChanged();
777
778
 
778
 
    QVERIFY(_q->currentTransfer().isEmpty());
 
779
    QVERIFY(_q->currentTransfer("").isEmpty());
779
780
}
780
781
 
781
782
void
858
859
 
859
860
    // add a transfer, set the state to start and assert that it will
860
861
    // be started
861
 
    QSignalSpy spy(_q, SIGNAL(currentChanged(QString)));
 
862
    QSignalSpy spy(_q, SIGNAL(currentChanged(QString, QString)));
862
863
    _q->add(_first);
863
864
    _q->add(_second);
864
865
 
865
866
    // we do not transfer just yet
866
 
    QVERIFY(_q->currentTransfer().isEmpty());
 
867
    QVERIFY(_q->currentTransfer("").isEmpty());
867
868
 
868
869
    _first->stateChanged();
869
870
    _second->stateChanged();
871
872
    QCOMPARE(spy.count(), 2);
872
873
 
873
874
    QList<QVariant> arguments = spy.takeFirst();
874
 
    QCOMPARE(arguments.at(0).toString(), path);
 
875
    QCOMPARE(arguments.at(1).toString(), path);
875
876
    arguments = spy.takeFirst();
876
 
    QCOMPARE(arguments.at(0).toString(), secondPath);
 
877
    QCOMPARE(arguments.at(1).toString(), secondPath);
877
878
    verifyMocks();
878
879
}
879
880
 
928
929
 
929
930
    // add a transfer, set the state to start and assert that it will
930
931
    // be started
931
 
    QSignalSpy spy(_q, SIGNAL(currentChanged(QString)));
 
932
    QSignalSpy spy(_q, SIGNAL(currentChanged(QString, QString)));
932
933
    _q->add(_first);
933
934
    _q->add(_second);
934
935
 
935
936
    // we do not transfer just yet
936
 
    QVERIFY(_q->currentTransfer().isEmpty());
 
937
    QVERIFY(_q->currentTransfer("").isEmpty());
937
938
 
938
939
    _first->stateChanged();
939
940
    _second->stateChanged();
941
942
    QCOMPARE(spy.count(), 2);
942
943
 
943
944
    QList<QVariant> arguments = spy.takeFirst();
944
 
    QCOMPARE(arguments.at(0).toString(), path);
 
945
    QCOMPARE(arguments.at(1).toString(), path);
945
946
    arguments = spy.takeFirst();
946
 
    QCOMPARE(arguments.at(0).toString(), secondPath);
 
947
    QCOMPARE(arguments.at(1).toString(), secondPath);
947
948
    verifyMocks();
948
949
}
949
950