← Back to branch summary

~ci-train-bot/qtubuntu-media/qtubuntu-media-ubuntu-xenial-landing-035

« back to all changes in this revision

Viewing changes to tests/integration/tst_mediaplaylist.cpp

  • Committer: CI Train Bot
  • Author(s): Jim Hodapp
  • Date: 2016-02-22 19:00:08 UTC
  • mfrom: (100.1.7 qtubuntu-media)
  • Revision ID: ci-train-bot@canonical.com-20160222190008-am4pm7lwh6fynnnw
URI encode the URI that we call setMedia() on or add to the playlist Fixes: #1449790
Approved by: Alfonso Sanchez-Beato

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/integration/tst_mediaplaylist.cpp
1
 
/*
2
 
 * Copyright (C) 2015 Canonical, Ltd.
3
 
 *
4
 
 * This program is free software; you can redistribute it and/or modify
5
 
 * it under the terms of the GNU Lesser General Public License as published by
6
 
 * the Free Software Foundation; version 3.
7
 
 *
8
 
 * This program is distributed in the hope that it will be useful,
9
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
 * GNU General Public License for more details.
12
 
 *
13
 
 * You should have received a copy of the GNU Lesser General Public License
14
 
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
15
 
 */
16
 
 
17
 
#include "tst_mediaplaylist.h"
18
 
#include "aalutility.h"
19
 
 
20
 
#include <thread>
21
 
#include <unistd.h>
22
 
 
23
 
#include <QMediaPlayer>
24
 
#include <QMediaPlaylist>
25
 
 
26
 
#include <QtTest/QtTest>
27
 
 
28
 
void tst_MediaPlaylist::initTestCase()
29
 
{
30
 
}
31
 
 
32
 
void tst_MediaPlaylist::cleanupTestCase()
33
 
{
34
 
}
35
 
 
36
 
void tst_MediaPlaylist::init()
37
 
{
38
 
    // NOTE: This sleep is currently needed in order to give media-hub a bit of time
39
 
    // between our different tests to cleanup and come back in a state where it can
40
 
    // respond to our requests.
41
 
    sleep(1);
42
 
}
43
 
 
44
 
void tst_MediaPlaylist::constructDestroyRepeat()
45
 
{
46
 
    for (int i=0; i<25; i++)
47
 
    {
48
 
        QMediaPlayer *player = new QMediaPlayer;
49
 
        QMediaPlaylist *playlist = new QMediaPlaylist;
50
 
        player->setPlaylist(playlist);
51
 
 
52
 
        delete playlist;
53
 
        delete player;
54
 
    }
55
 
}
56
 
 
57
 
void tst_MediaPlaylist::addTwoTracksAndVerify()
58
 
{
59
 
    QMediaPlayer *player = new QMediaPlayer;
60
 
    QMediaPlaylist *playlist = new QMediaPlaylist;
61
 
    player->setPlaylist(playlist);
62
 
 
63
 
    playlist->addMedia(QUrl(QFINDTESTDATA("testdata/testfile.ogg")));
64
 
    playlist->addMedia(QUrl(QFINDTESTDATA("testdata/testfile.mp4")));
65
 
 
66
 
    QCOMPARE(playlist->mediaCount(), 2);
67
 
 
68
 
    delete playlist;
69
 
    delete player;
70
 
}
71
 
 
72
 
void tst_MediaPlaylist::insertTracksAtPositionAndVerify()
73
 
{
74
 
    QMediaPlayer *player = new QMediaPlayer;
75
 
    QMediaPlaylist *playlist = new QMediaPlaylist;
76
 
    player->setPlaylist(playlist);
77
 
 
78
 
    QElapsedTimer timer;
79
 
    timer.start();
80
 
    playlist->addMedia(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
81
 
    waitTrackInserted(playlist);
82
 
    playlist->addMedia(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
83
 
    waitTrackInserted(playlist);
84
 
    playlist->addMedia(QUrl("file://" + QFINDTESTDATA("testdata/testfile1.ogg")));
85
 
    waitTrackInserted(playlist);
86
 
    playlist->addMedia(QUrl("file://" + QFINDTESTDATA("testdata/testfile2.ogg")));
87
 
    waitTrackInserted(playlist);
88
 
    playlist->addMedia(QUrl("file://" + QFINDTESTDATA("testdata/testfile3.ogg")));
89
 
    waitTrackInserted(playlist);
90
 
    qDebug() << "** addMedia took" << timer.elapsed() << "milliseconds";
91
 
 
92
 
    QCOMPARE(playlist->mediaCount(), 5);
93
 
 
94
 
    const QMediaContent insertedTrack(QUrl("file://" + QFINDTESTDATA("testdata/testfile4.ogg")));
95
 
    playlist->insertMedia(2, insertedTrack);
96
 
    waitTrackInserted(playlist);
97
 
 
98
 
    qDebug() << "playlist->media(2):" << playlist->media(2).canonicalUrl();
99
 
    qDebug() << "insertedTrack:" << insertedTrack.canonicalUrl();
100
 
    QCOMPARE(playlist->media(2), insertedTrack);
101
 
 
102
 
    delete playlist;
103
 
    delete player;
104
 
}
105
 
 
106
 
void tst_MediaPlaylist::moveTrackAndVerify()
107
 
{
108
 
    QMediaPlayer *player = new QMediaPlayer;
109
 
    QMediaPlaylist *playlist = new QMediaPlaylist;
110
 
    player->setPlaylist(playlist);
111
 
 
112
 
    QElapsedTimer timer;
113
 
    timer.start();
114
 
    QList<QMediaContent> content;
115
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
116
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
117
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile1.ogg")));
118
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile2.ogg")));
119
 
    const QMediaContent newLastTrack(QUrl("file://" + QFINDTESTDATA("testdata/testfile3.ogg")));
120
 
    content.push_back(newLastTrack);
121
 
    const QMediaContent insertedTrack(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
122
 
    content.push_back(insertedTrack);
123
 
    playlist->addMedia(content);
124
 
    waitTrackInserted(playlist);
125
 
    qDebug() << "** addMedia took" << timer.elapsed() << "milliseconds";
126
 
 
127
 
    QCOMPARE(playlist->mediaCount(), 6);
128
 
 
129
 
    connectSignal(playlist, Signals::MediaRemoved);
130
 
    connectSignal(playlist, Signals::MediaInserted);
131
 
    playlist->moveMedia(5, 2);
132
 
 
133
 
    Q_ASSERT(m_signalsDeque.pop_front() == Signals::MediaRemoved);
134
 
    Q_ASSERT(m_signalsDeque.pop_front() == Signals::MediaInserted);
135
 
    QCOMPARE(playlist->mediaCount(), 6);
136
 
 
137
 
    delete playlist;
138
 
    delete player;
139
 
}
140
 
 
141
 
void tst_MediaPlaylist::movePlayingTrackAndVerify()
142
 
{
143
 
    QMediaPlayer *player = new QMediaPlayer;
144
 
    QMediaPlaylist *playlist = new QMediaPlaylist;
145
 
    player->setPlaylist(playlist);
146
 
 
147
 
    QElapsedTimer timer;
148
 
    timer.start();
149
 
    QList<QMediaContent> content;
150
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
151
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
152
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile1.ogg")));
153
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile2.ogg")));
154
 
    const QMediaContent newLastTrack(QUrl("file://" + QFINDTESTDATA("testdata/testfile3.ogg")));
155
 
    content.push_back(newLastTrack);
156
 
    const QMediaContent insertedTrack(QUrl("file://" + QFINDTESTDATA("testdata/Ubuntu.ogg")));
157
 
    content.push_back(insertedTrack);
158
 
    playlist->addMedia(content);
159
 
    waitTrackInserted(playlist);
160
 
    qDebug() << "** addMedia took" << timer.elapsed() << "milliseconds";
161
 
 
162
 
    playlist->setCurrentIndex(5);
163
 
    waitCurrentIndexChange(playlist);
164
 
    QCOMPARE(playlist->currentIndex(), 5);
165
 
 
166
 
    player->play();
167
 
 
168
 
    QCOMPARE(playlist->mediaCount(), 6);
169
 
 
170
 
    sleep(2);
171
 
 
172
 
    connectSignal(playlist, Signals::MediaRemoved);
173
 
    connectSignal(playlist, Signals::MediaInserted);
174
 
    playlist->moveMedia(5, 2);
175
 
 
176
 
    Q_ASSERT(m_signalsDeque.pop_front() == Signals::MediaRemoved);
177
 
    qDebug() << "Verifying the presence of MediaInserted signal in deque";
178
 
    Q_ASSERT(m_signalsDeque.pop_front() == Signals::MediaInserted);
179
 
    QCOMPARE(playlist->mediaCount(), 6);
180
 
 
181
 
    waitCurrentIndexChange(playlist);
182
 
 
183
 
    QCOMPARE(player->state(), QMediaPlayer::State::PlayingState);
184
 
    QCOMPARE(playlist->currentIndex(), 2);
185
 
 
186
 
    delete playlist;
187
 
    delete player;
188
 
}
189
 
 
190
 
void tst_MediaPlaylist::addListOfTracksAndVerify()
191
 
{
192
 
    QMediaPlayer *player = new QMediaPlayer;
193
 
    QMediaPlaylist *playlist = new QMediaPlaylist;
194
 
    player->setPlaylist(playlist);
195
 
 
196
 
    QList<QMediaContent> content;
197
 
    content.push_back(QUrl(QFINDTESTDATA("testdata/testfile.ogg")));
198
 
    content.push_back(QUrl(QFINDTESTDATA("testdata/testfile.mp4")));
199
 
 
200
 
    playlist->addMedia(content);
201
 
 
202
 
    QCOMPARE(playlist->mediaCount(), 2);
203
 
 
204
 
    delete playlist;
205
 
    delete player;
206
 
}
207
 
 
208
 
void tst_MediaPlaylist::addLargeListOfTracksAndVerify()
209
 
{
210
 
    QMediaPlayer *player = new QMediaPlayer;
211
 
    QMediaPlaylist *playlist = new QMediaPlaylist;
212
 
    player->setPlaylist(playlist);
213
 
 
214
 
    // Total number of tracks added will be iterations * 5
215
 
    const uint16_t iterations = 20;
216
 
    QElapsedTimer timer;
217
 
    timer.start();
218
 
    for (uint16_t i=0; i<iterations; i++)
219
 
    {
220
 
        playlist->addMedia(QUrl(QFINDTESTDATA("testdata/testfile.mp4")));
221
 
        waitTrackInserted(playlist);
222
 
        playlist->addMedia(QUrl(QFINDTESTDATA("testdata/testfile.ogg")));
223
 
        waitTrackInserted(playlist);
224
 
        playlist->addMedia(QUrl(QFINDTESTDATA("testdata/testfile1.ogg")));
225
 
        waitTrackInserted(playlist);
226
 
        playlist->addMedia(QUrl(QFINDTESTDATA("testdata/testfile2.ogg")));
227
 
        waitTrackInserted(playlist);
228
 
        playlist->addMedia(QUrl(QFINDTESTDATA("testdata/testfile3.ogg")));
229
 
        waitTrackInserted(playlist);
230
 
    }
231
 
    qDebug() << "** addMedia loop took" << timer.elapsed() << "milliseconds";
232
 
 
233
 
    QCOMPARE(playlist->mediaCount(), iterations * 5);
234
 
 
235
 
    delete playlist;
236
 
    delete player;
237
 
}
238
 
 
239
 
void tst_MediaPlaylist::addLargeListOfTracksAtOnceAndVerify()
240
 
{
241
 
    QMediaPlayer *player = new QMediaPlayer;
242
 
    QMediaPlaylist *playlist = new QMediaPlaylist;
243
 
    player->setPlaylist(playlist);
244
 
 
245
 
    QList<QMediaContent> content;
246
 
    int i;
247
 
    for (i=0; i<20; i++)
248
 
    {
249
 
        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile.ogg")));
250
 
        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile.mp4")));
251
 
        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile1.ogg")));
252
 
        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile2.ogg")));
253
 
        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile3.ogg")));
254
 
        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile4.ogg")));
255
 
        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile1.ogg")));
256
 
        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile2.ogg")));
257
 
        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile3.ogg")));
258
 
        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile4.ogg")));
259
 
    }
260
 
 
261
 
    QElapsedTimer timer;
262
 
    timer.start();
263
 
    playlist->addMedia(content);
264
 
    qDebug() << "** addMedia(QList) took" << timer.elapsed() << "milliseconds";
265
 
 
266
 
    waitTrackInserted(playlist);
267
 
    QCOMPARE(playlist->mediaCount(), i * 10);
268
 
 
269
 
    delete playlist;
270
 
    delete player;
271
 
}
272
 
 
273
 
void tst_MediaPlaylist::addTwoListsOfTracksAtOnceAndVerify()
274
 
{
275
 
    QMediaPlayer *player = new QMediaPlayer;
276
 
    QMediaPlaylist *playlist = new QMediaPlaylist;
277
 
    player->setPlaylist(playlist);
278
 
 
279
 
    QList<QMediaContent> content1;
280
 
    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile.ogg")));
281
 
    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile.mp4")));
282
 
    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile1.ogg")));
283
 
    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile2.ogg")));
284
 
    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile3.ogg")));
285
 
    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile4.ogg")));
286
 
    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile1.ogg")));
287
 
    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile2.ogg")));
288
 
    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile3.ogg")));
289
 
    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile4.ogg")));
290
 
 
291
 
    QList<QMediaContent> content2;
292
 
    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile4.ogg")));
293
 
    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile3.ogg")));
294
 
    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile2.ogg")));
295
 
    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile1.ogg")));
296
 
    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile.mp4")));
297
 
    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile.ogg")));
298
 
    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile1.ogg")));
299
 
    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile2.ogg")));
300
 
    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile3.ogg")));
301
 
    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile4.ogg")));
302
 
 
303
 
    QElapsedTimer timer;
304
 
    timer.start();
305
 
    playlist->addMedia(content1);
306
 
    qDebug() << "** First list addMedia(QList) took" << timer.elapsed() << "milliseconds";
307
 
 
308
 
    waitTrackInserted(playlist);
309
 
    QCOMPARE(playlist->mediaCount(), 10);
310
 
 
311
 
    timer.invalidate();
312
 
    timer.start();
313
 
    playlist->addMedia(content2);
314
 
    qDebug() << "** Second list addMedia(QList) took" << timer.elapsed() << "milliseconds";
315
 
 
316
 
    waitTrackInserted(playlist);
317
 
    QCOMPARE(playlist->mediaCount(), 20);
318
 
 
319
 
    delete playlist;
320
 
    delete player;
321
 
}
322
 
 
323
 
void tst_MediaPlaylist::goToNextTrack()
324
 
{
325
 
    QMediaPlayer *player = new QMediaPlayer;
326
 
    QMediaPlaylist *playlist = new QMediaPlaylist;
327
 
    player->setPlaylist(playlist);
328
 
 
329
 
    const QUrl audio(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
330
 
    const QUrl video(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
331
 
    qDebug() << "audio URL: " << audio.toString();
332
 
    qDebug() << "video URL: " << video.toString();
333
 
    playlist->addMedia(audio);
334
 
    playlist->addMedia(video);
335
 
 
336
 
    QCOMPARE(playlist->mediaCount(), 2);
337
 
 
338
 
    player->play();
339
 
 
340
 
    QCoreApplication::processEvents();
341
 
 
342
 
    const QUrl audioToVerify(playlist->currentMedia().canonicalUrl());
343
 
    QCOMPARE(audioToVerify, audio);
344
 
 
345
 
    playlist->next();
346
 
 
347
 
    QCoreApplication::processEvents();
348
 
 
349
 
    const QUrl videoToVerify(playlist->currentMedia().canonicalUrl());
350
 
    QCOMPARE(videoToVerify, video);
351
 
 
352
 
    delete playlist;
353
 
    delete player;
354
 
}
355
 
 
356
 
void tst_MediaPlaylist::goToPreviousTrack()
357
 
{
358
 
    QMediaPlayer *player = new QMediaPlayer;
359
 
    QMediaPlaylist *playlist = new QMediaPlaylist;
360
 
    player->setPlaylist(playlist);
361
 
 
362
 
    const QUrl audio1(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
363
 
    const QUrl audio2(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
364
 
    playlist->addMedia(audio1);
365
 
    playlist->addMedia(audio2);
366
 
 
367
 
    QCOMPARE(playlist->mediaCount(), 2);
368
 
    playlist->setCurrentIndex(1);
369
 
 
370
 
    player->play();
371
 
 
372
 
    QCoreApplication::processEvents();
373
 
 
374
 
    const QUrl audio2ToVerify(playlist->currentMedia().canonicalUrl());
375
 
    QCOMPARE(audio2ToVerify, audio2);
376
 
 
377
 
    playlist->previous();
378
 
 
379
 
    QCoreApplication::processEvents();
380
 
 
381
 
    const QUrl audio1ToVerify(playlist->currentMedia().canonicalUrl());
382
 
    QCOMPARE(audio2ToVerify, audio1);
383
 
    QCOMPARE(playlist->currentIndex(), 0);
384
 
 
385
 
    delete playlist;
386
 
    delete player;
387
 
}
388
 
 
389
 
void tst_MediaPlaylist::verifyMedia()
390
 
{
391
 
    QMediaPlayer *player = new QMediaPlayer;
392
 
    QMediaPlaylist *playlist = new QMediaPlaylist;
393
 
    player->setPlaylist(playlist);
394
 
 
395
 
    const QUrl audio(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
396
 
    const QUrl video(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
397
 
    qDebug() << "audio URL: " << audio.toString();
398
 
    qDebug() << "video URL: " << video.toString();
399
 
    playlist->addMedia(audio);
400
 
    playlist->addMedia(video);
401
 
 
402
 
    QCOMPARE(playlist->mediaCount(), 2);
403
 
 
404
 
    const QUrl audioToVerify(playlist->media(0).canonicalUrl());
405
 
    QCOMPARE(audioToVerify, audio);
406
 
 
407
 
    const QUrl videoToVerify(playlist->media(1).canonicalUrl());
408
 
    QCOMPARE(videoToVerify, video);
409
 
 
410
 
    delete playlist;
411
 
    delete player;
412
 
}
413
 
 
414
 
void tst_MediaPlaylist::removeTrackAndVerify()
415
 
{
416
 
    QMediaPlayer *player = new QMediaPlayer;
417
 
    QMediaPlaylist *playlist = new QMediaPlaylist;
418
 
    player->setPlaylist(playlist);
419
 
 
420
 
    playlist->addMedia(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
421
 
    const QUrl video(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
422
 
    playlist->addMedia(video);
423
 
 
424
 
    waitTrackInserted(playlist);
425
 
    QCOMPARE(playlist->mediaCount(), 2);
426
 
 
427
 
    playlist->removeMedia(0);
428
 
 
429
 
    QCOMPARE(playlist->mediaCount(), 1);
430
 
 
431
 
    const QUrl videoToVerify(playlist->media(0).canonicalUrl());
432
 
    QCOMPARE(videoToVerify, video);
433
 
 
434
 
    delete playlist;
435
 
    delete player;
436
 
}
437
 
 
438
 
void tst_MediaPlaylist::removeCurrentNonPlayingTrackAndVerify()
439
 
{
440
 
    QMediaPlayer *player = new QMediaPlayer;
441
 
    QMediaPlaylist *playlist = new QMediaPlaylist;
442
 
    player->setPlaylist(playlist);
443
 
 
444
 
    QList<QMediaContent> content1;
445
 
    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
446
 
    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile1.ogg")));
447
 
    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile2.ogg")));
448
 
    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile3.ogg")));
449
 
    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile4.ogg")));
450
 
    playlist->addMedia(content1);
451
 
    const QUrl track(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
452
 
    playlist->addMedia(track);
453
 
 
454
 
    waitTrackInserted(playlist);
455
 
    QCOMPARE(playlist->mediaCount(), 6);
456
 
 
457
 
    playlist->setCurrentIndex(2);
458
 
    // Wait for the currentMediaChanged signal to be emited
459
 
    waitTrackChange(playlist);
460
 
    // We should not be automatically playing
461
 
    QCOMPARE(player->state(), QMediaPlayer::State::StoppedState);
462
 
    QCOMPARE(playlist->currentIndex(), 2);
463
 
 
464
 
    playlist->removeMedia(2);
465
 
 
466
 
    // We should still not be playing
467
 
    QCOMPARE(player->state(), QMediaPlayer::State::StoppedState);
468
 
 
469
 
    QCOMPARE(playlist->mediaCount(), 5);
470
 
 
471
 
    const QUrl trackToVerify(playlist->media(4).canonicalUrl());
472
 
    QCOMPARE(trackToVerify, track);
473
 
 
474
 
    delete playlist;
475
 
    delete player;
476
 
}
477
 
 
478
 
void tst_MediaPlaylist::removeCurrentPlayingTrackAndVerify()
479
 
{
480
 
    QMediaPlayer *player = new QMediaPlayer;
481
 
    QMediaPlaylist *playlist = new QMediaPlaylist;
482
 
    player->setPlaylist(playlist);
483
 
 
484
 
    QList<QMediaContent> content1;
485
 
    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
486
 
    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile1.ogg")));
487
 
    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile2.ogg")));
488
 
    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile3.ogg")));
489
 
    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile4.ogg")));
490
 
    playlist->addMedia(content1);
491
 
    const QUrl track(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
492
 
    playlist->addMedia(track);
493
 
 
494
 
    waitTrackInserted(playlist);
495
 
    QCOMPARE(playlist->mediaCount(), 6);
496
 
 
497
 
    player->play();
498
 
 
499
 
    playlist->setCurrentIndex(2);
500
 
    // Wait for the currentMediaChanged signal to be emited
501
 
    waitTrackChange(playlist);
502
 
    // We be  playing
503
 
    QCOMPARE(player->state(), QMediaPlayer::State::PlayingState);
504
 
    QCOMPARE(playlist->currentIndex(), 2);
505
 
 
506
 
    playlist->removeMedia(2);
507
 
 
508
 
    // We should still be playing
509
 
    QCOMPARE(player->state(), QMediaPlayer::State::PlayingState);
510
 
 
511
 
    QCOMPARE(playlist->mediaCount(), 5);
512
 
 
513
 
    const QUrl trackToVerify(playlist->media(4).canonicalUrl());
514
 
    QCOMPARE(trackToVerify, track);
515
 
 
516
 
    delete playlist;
517
 
    delete player;
518
 
}
519
 
 
520
 
void tst_MediaPlaylist::removeLastCurrentPlayingTrackAndVerify()
521
 
{
522
 
    QMediaPlayer *player = new QMediaPlayer;
523
 
    QMediaPlaylist *playlist = new QMediaPlaylist;
524
 
    player->setPlaylist(playlist);
525
 
 
526
 
    const QUrl track(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
527
 
    playlist->addMedia(track);
528
 
 
529
 
    waitTrackInserted(playlist);
530
 
    QCOMPARE(playlist->mediaCount(), 1);
531
 
 
532
 
    player->play();
533
 
 
534
 
    playlist->setCurrentIndex(0);
535
 
    qDebug() << "Waiting for playback status to change to playing";
536
 
    // Wait for the currentMediaChanged signal to be emited
537
 
    waitTrackChange(playlist);
538
 
    // We be  playing
539
 
    QCOMPARE(player->state(), QMediaPlayer::State::PlayingState);
540
 
 
541
 
    qDebug() << "Removing track index 0";
542
 
    playlist->removeMedia(0);
543
 
 
544
 
    waitTrackRemoved(playlist);
545
 
    // We should no longer be playing
546
 
    QCOMPARE(player->state(), QMediaPlayer::State::StoppedState);
547
 
 
548
 
    QCOMPARE(playlist->mediaCount(), 0);
549
 
 
550
 
    delete playlist;
551
 
    delete player;
552
 
}
553
 
 
554
 
void tst_MediaPlaylist::verifyCurrentIndex()
555
 
{
556
 
    QMediaPlayer *player = new QMediaPlayer;
557
 
    QMediaPlaylist *playlist = new QMediaPlaylist;
558
 
    player->setPlaylist(playlist);
559
 
 
560
 
    QList<QMediaContent> content;
561
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
562
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
563
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
564
 
    playlist->addMedia(content);
565
 
 
566
 
    waitTrackInserted(playlist);
567
 
    QCOMPARE(playlist->mediaCount(), 3);
568
 
 
569
 
    qDebug() << "Setting current index to be 1";
570
 
    playlist->setCurrentIndex(1);
571
 
 
572
 
    // Wait for the currentMediaChanged signal to be emited
573
 
    waitTrackChange(playlist);
574
 
 
575
 
    qDebug() << "Checking if current index is 1";
576
 
    QCOMPARE(playlist->currentIndex(), 1);
577
 
 
578
 
    delete playlist;
579
 
    delete player;
580
 
}
581
 
 
582
 
void tst_MediaPlaylist::verifyNextIndex()
583
 
{
584
 
    QMediaPlayer *player = new QMediaPlayer;
585
 
    QMediaPlaylist *playlist = new QMediaPlaylist;
586
 
    player->setPlaylist(playlist);
587
 
 
588
 
    QList<QMediaContent> content;
589
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
590
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
591
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
592
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
593
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
594
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
595
 
    playlist->addMedia(content);
596
 
 
597
 
    waitTrackInserted(playlist);
598
 
    QCOMPARE(playlist->mediaCount(), 6);
599
 
 
600
 
    QCOMPARE(playlist->nextIndex(1), 1);
601
 
    QCOMPARE(playlist->nextIndex(4), 4);
602
 
    QCOMPARE(playlist->nextIndex(6), 0);
603
 
    QCOMPARE(playlist->nextIndex(7), 1);
604
 
    QCOMPARE(playlist->nextIndex(11), 5);
605
 
 
606
 
    delete playlist;
607
 
    delete player;
608
 
}
609
 
 
610
 
void tst_MediaPlaylist::verifyPreviousIndex()
611
 
{
612
 
    QMediaPlayer *player = new QMediaPlayer;
613
 
    QMediaPlaylist *playlist = new QMediaPlaylist;
614
 
    player->setPlaylist(playlist);
615
 
 
616
 
    QList<QMediaContent> content;
617
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
618
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
619
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
620
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
621
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
622
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
623
 
    playlist->addMedia(content);
624
 
 
625
 
    waitTrackInserted(playlist);
626
 
    QCOMPARE(playlist->mediaCount(), 6);
627
 
 
628
 
    QCOMPARE(playlist->previousIndex(1), 5);
629
 
    QCOMPARE(playlist->previousIndex(4), 2);
630
 
    QCOMPARE(playlist->previousIndex(6), 0);
631
 
    QCOMPARE(playlist->previousIndex(11), 1);
632
 
    QCOMPARE(playlist->previousIndex(21), 3);
633
 
    QCOMPARE(playlist->previousIndex(19), 5);
634
 
 
635
 
    delete playlist;
636
 
    delete player;
637
 
}
638
 
 
639
 
void tst_MediaPlaylist::verifyPlaybackModeCurrentItemInLoop()
640
 
{
641
 
    QMediaPlayer *player = new QMediaPlayer;
642
 
    QMediaPlaylist *playlist = new QMediaPlaylist;
643
 
    player->setPlaylist(playlist);
644
 
 
645
 
    connectSignal(playlist, Signals::MediaInserted);
646
 
 
647
 
    QList<QMediaContent> content;
648
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
649
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
650
 
    playlist->addMedia(content);
651
 
 
652
 
    // Wait until the first track is set as the current one
653
 
    waitTrackChange(playlist);
654
 
    Q_ASSERT(m_signalsDeque.pop_front() == Signals::MediaInserted);
655
 
    QCOMPARE(playlist->mediaCount(), 2);
656
 
 
657
 
    waitPlaybackModeChange(playlist, [playlist]()
658
 
        {
659
 
            playlist->setPlaybackMode(QMediaPlaylist::CurrentItemInLoop);
660
 
        });
661
 
 
662
 
    player->play();
663
 
 
664
 
    // Wait for the currentMediaChanged signal to be emited
665
 
    waitTrackChange(playlist);
666
 
 
667
 
    QCOMPARE(playlist->currentIndex(), 0);
668
 
 
669
 
    delete playlist;
670
 
    delete player;
671
 
}
672
 
 
673
 
void tst_MediaPlaylist::verifyPlaybackModeSequential()
674
 
{
675
 
    QMediaPlayer *player = new QMediaPlayer;
676
 
    QMediaPlaylist *playlist = new QMediaPlaylist;
677
 
    player->setPlaylist(playlist);
678
 
 
679
 
    connectSignal(playlist, Signals::MediaInserted);
680
 
 
681
 
    QList<QMediaContent> content;
682
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
683
 
    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
684
 
    playlist->addMedia(content);
685
 
 
686
 
    // Wait until the first track is set as the current one
687
 
    waitTrackChange(playlist);
688
 
    Q_ASSERT(m_signalsDeque.pop_front() == Signals::MediaInserted);
689
 
    QCOMPARE(playlist->mediaCount(), 2);
690
 
 
691
 
    waitPlaybackModeChange(playlist, [playlist]()
692
 
        {
693
 
            playlist->setPlaybackMode(QMediaPlaylist::Sequential);
694
 
        });
695
 
 
696
 
    player->play();
697
 
 
698
 
    // Wait until the second track is selected
699
 
    waitTrackChange(playlist);
700
 
 
701
 
    QCOMPARE(playlist->currentIndex(), 1);
702
 
 
703
 
    delete playlist;
704
 
    delete player;
705
 
}
706
 
 
707
 
void tst_MediaPlaylist::playReusePlayTrackList()
708
 
{
709
 
    QMediaPlayer *player = new QMediaPlayer;
710
 
    QMediaPlaylist *playlist = new QMediaPlaylist;
711
 
    player->setPlaylist(playlist);
712
 
 
713
 
    const QUrl audio(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
714
 
    const QUrl video(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
715
 
 
716
 
    for (int i = 0; i < 5; ++i) {
717
 
        playlist->addMedia(audio);
718
 
        waitTrackInserted(playlist);
719
 
        playlist->addMedia(video);
720
 
        waitTrackInserted(playlist);
721
 
        playlist->addMedia(audio);
722
 
        waitTrackInserted(playlist);
723
 
        QCOMPARE(playlist->mediaCount(), 3);
724
 
 
725
 
        player->play();
726
 
 
727
 
        const QUrl audioToVerify(playlist->currentMedia().canonicalUrl());
728
 
        QCOMPARE(audioToVerify, audio);
729
 
 
730
 
        player->stop();
731
 
 
732
 
        connectSignal(playlist, Signals::MediaRemoved);
733
 
        playlist->clear();
734
 
 
735
 
        Q_ASSERT(m_signalsDeque.pop_front() == Signals::MediaRemoved);
736
 
 
737
 
        QCOMPARE(playlist->mediaCount(), 0);
738
 
    }
739
 
 
740
 
    delete playlist;
741
 
    delete player;
742
 
}
743
 
 
744
 
template<typename R>
745
 
void tst_MediaPlaylist::wait_for_signal(std::future<R> const& f)
746
 
{
747
 
    while (!is_ready<R>(f))
748
 
    {
749
 
        // Make sure we don't block the main QEventLoop, which
750
 
        // would hinder receiving the currentMediaChanged event above
751
 
        QCoreApplication::processEvents();
752
 
        std::this_thread::yield();
753
 
    }
754
 
}
755
 
 
756
 
void tst_MediaPlaylist::waitTrackChange(QMediaPlaylist *playlist)
757
 
{
758
 
    QMediaContent current_media;
759
 
    std::promise<QMediaContent> promise;
760
 
    std::future<QMediaContent> future{promise.get_future()};
761
 
 
762
 
    QMetaObject::Connection c = connect(playlist, &QMediaPlaylist::currentMediaChanged,
763
 
        [&](const QMediaContent& content)
764
 
        {
765
 
            qDebug() << "currentMediaChanged to: " << content.canonicalUrl().toString();
766
 
            current_media = content;
767
 
            promise.set_value(current_media);
768
 
            // Make sure the promise is not fulfilled twice
769
 
            QObject::disconnect(c);
770
 
        });
771
 
 
772
 
    wait_for_signal(future);
773
 
}
774
 
 
775
 
void tst_MediaPlaylist::waitTrackInserted(QMediaPlaylist *playlist)
776
 
{
777
 
    int index = 0;
778
 
    std::promise<int> promise;
779
 
    std::future<int> future{promise.get_future()};
780
 
 
781
 
    QMetaObject::Connection c = connect(playlist, &QMediaPlaylist::mediaInserted,
782
 
        [&](int start, int end)
783
 
        {
784
 
            qDebug() << "mediaInserted start: " << start << ", end: " << end;
785
 
            index = end;
786
 
            promise.set_value(index);
787
 
            // Make sure the promise is not fulfilled twice
788
 
            QObject::disconnect(c);
789
 
        });
790
 
 
791
 
    wait_for_signal(future);
792
 
}
793
 
 
794
 
void tst_MediaPlaylist::waitTrackRemoved(QMediaPlaylist *playlist)
795
 
{
796
 
    int index = 0;
797
 
    std::promise<int> promise;
798
 
    std::future<int> future{promise.get_future()};
799
 
 
800
 
    QMetaObject::Connection c = connect(playlist, &QMediaPlaylist::mediaRemoved,
801
 
        [&](int start, int end)
802
 
        {
803
 
            qDebug() << "mediaRemoved start: " << start << ", end: " << end;
804
 
            index = end;
805
 
            promise.set_value(index);
806
 
            // Make sure the promise is not fulfilled twice
807
 
            QObject::disconnect(c);
808
 
        });
809
 
 
810
 
    wait_for_signal(future);
811
 
}
812
 
 
813
 
void tst_MediaPlaylist::waitPlaybackModeChange(QMediaPlaylist *playlist,
814
 
                                               const std::function<void()>& action)
815
 
{
816
 
    QMediaPlaylist::PlaybackMode current_mode;
817
 
    std::promise<QMediaPlaylist::PlaybackMode> promise;
818
 
    std::future<QMediaPlaylist::PlaybackMode> future{promise.get_future()};
819
 
 
820
 
    QMetaObject::Connection c = connect(playlist, &QMediaPlaylist::playbackModeChanged,
821
 
        [&](QMediaPlaylist::PlaybackMode mode)
822
 
        {
823
 
            qDebug() << "playbackModeChanged to: " << mode;
824
 
            current_mode = mode;
825
 
            promise.set_value(current_mode);
826
 
            // Make sure the promise is not fulfilled twice
827
 
            QObject::disconnect(c);
828
 
        });
829
 
 
830
 
    action();
831
 
 
832
 
    wait_for_signal(future);
833
 
}
834
 
 
835
 
void tst_MediaPlaylist::waitCurrentIndexChange(QMediaPlaylist *playlist)
836
 
{
837
 
    int index = 0;
838
 
    std::promise<int> promise;
839
 
    std::future<int> future{promise.get_future()};
840
 
 
841
 
    QMetaObject::Connection c = connect(playlist, &QMediaPlaylist::currentIndexChanged,
842
 
        [&](int i)
843
 
        {
844
 
            qDebug() << "currentIndexChanged index: " << i;
845
 
            index = i;
846
 
            promise.set_value(index);
847
 
            // Make sure the promise is not fulfilled twice
848
 
            QObject::disconnect(c);
849
 
        });
850
 
 
851
 
    wait_for_signal(future);
852
 
}
853
 
 
854
 
void tst_MediaPlaylist::connectSignal(QMediaPlaylist *playlist, Signals signal)
855
 
{
856
 
    switch (signal)
857
 
    {
858
 
        case Signals::Unknown:
859
 
            break;
860
 
        case Signals::CurrentMediaChanged:
861
 
        {
862
 
            connect(playlist, &QMediaPlaylist::currentMediaChanged, [&](const QMediaContent& content)
863
 
            {
864
 
                (void) content;
865
 
                qDebug() << "Pushing CurrentMediaChanged onto m_signalsDeque";
866
 
                m_signalsDeque.push_back(signal);
867
 
            });
868
 
            break;
869
 
        }
870
 
        case Signals::MediaInserted:
871
 
        {
872
 
            connect(playlist, &QMediaPlaylist::mediaInserted, [&](int start, int end)
873
 
            {
874
 
                (void) start;
875
 
                (void) end;
876
 
                qDebug() << "Pushing MediaInserted onto m_signalsDeque";
877
 
                m_signalsDeque.push_back(signal);
878
 
            });
879
 
            break;
880
 
        }
881
 
        case Signals::MediaRemoved:
882
 
        {
883
 
            connect(playlist, &QMediaPlaylist::mediaRemoved, [&](int index)
884
 
            {
885
 
                (void) index;
886
 
                qDebug() << "Pushing MediaRemoved onto m_signalsDeque";
887
 
                m_signalsDeque.push_back(signal);
888
 
            });
889
 
            break;
890
 
        }
891
 
        default:
892
 
            qWarning() << "Unknown signal type, can't add to queue:" << signal;
893
 
    }
894
 
}
895
 
 
896
 
QTEST_GUILESS_MAIN(tst_MediaPlaylist)