← Back to branch summary

~ricmm/media-hub/multiple-sessions

« back to all changes in this revision

Viewing changes to tests/acceptance-tests/service.cpp

Merged lp:~thomas-voss/media-hub/switch-to-properties-cpp

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/acceptance-tests/service.cpp
18
18
 
19
19
#include <core/media/service.h>
20
20
#include <core/media/player.h>
21
 
#include <core/media/property.h>
22
21
#include <core/media/track_list.h>
23
22
 
24
23
#include "core/media/service_implementation.h"
25
24
 
26
 
#include "../cross_process_sync.h"
27
 
#include "../fork_and_run.h"
28
25
#include "../waitable_state_transition.h"
29
26
 
30
27
#include "test_data.h"
31
28
 
 
29
#include <core/testing/cross_process_sync.h>
 
30
#include <core/testing/fork_and_run.h>
 
31
 
32
32
#include <gtest/gtest.h>
33
33
 
34
34
#include <cstdio>
39
39
 
40
40
namespace media = core::ubuntu::media;
41
41
 
42
 
TEST(MusicService, accessing_and_creating_a_session_works)
43
 
{
44
 
    test::CrossProcessSync sync_service_start;
45
 
 
46
 
    auto service = [&sync_service_start]()
47
 
    {
 
42
namespace
 
43
{
 
44
struct SigTermCatcher
 
45
{
 
46
    inline SigTermCatcher()
 
47
    {
 
48
        sigemptyset(&signal_mask);
 
49
 
 
50
        if (-1 == sigaddset(&signal_mask, SIGTERM))
 
51
            throw std::system_error(errno, std::system_category());
 
52
 
 
53
        if (-1 == sigprocmask(SIG_BLOCK, &signal_mask, NULL))
 
54
            throw std::system_error(errno, std::system_category());
 
55
    }
 
56
 
 
57
    inline void wait_for_signal()
 
58
    {
 
59
        int signal = -1;
 
60
        ::sigwait(&signal_mask, &signal);
 
61
    }
 
62
 
 
63
    sigset_t signal_mask;
 
64
};
 
65
 
 
66
void sleep_for(const std::chrono::milliseconds& ms)
 
67
{
 
68
    long int ns = ms.count() * 1000 * 1000;
 
69
    timespec ts{ 0, ns};
 
70
    ::nanosleep(&ts, nullptr);
 
71
}
 
72
}
 
73
 
 
74
TEST(MusicService, DISABLED_accessing_and_creating_a_session_works)
 
75
{
 
76
    core::testing::CrossProcessSync sync_service_start;
 
77
 
 
78
    auto service = [this, &sync_service_start]()
 
79
    {
 
80
        SigTermCatcher sc;
 
81
 
48
82
        auto service = std::make_shared<media::ServiceImplementation>();
49
83
        std::thread t([&service](){service->run();});
50
84
 
51
 
        sync_service_start.signal_ready();
 
85
        sync_service_start.try_signal_ready_for(std::chrono::milliseconds{500});
 
86
 
 
87
        sc.wait_for_signal(); service->stop();
52
88
 
53
89
        if (t.joinable())
54
90
            t.join();
 
91
 
 
92
        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
55
93
    };
56
94
 
57
 
    auto client = [&sync_service_start]()
 
95
    auto client = [this, &sync_service_start]()
58
96
    {
59
 
        sync_service_start.wait_for_signal_ready();
 
97
        sync_service_start.wait_for_signal_ready_for(std::chrono::milliseconds{500});
60
98
 
61
99
        auto service = media::Service::Client::instance();
62
100
        auto session = service->create_session(media::Player::Client::default_configuration());
63
101
 
64
102
        EXPECT_TRUE(session != nullptr);
 
103
 
 
104
        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
65
105
    };
66
106
 
67
 
    ASSERT_NO_FATAL_FAILURE(test::fork_and_run(service, client));
 
107
    EXPECT_EQ(core::testing::ForkAndRunResult::empty,
 
108
              core::testing::fork_and_run(service, client));
68
109
}
69
110
 
70
 
TEST(MusicService, remotely_querying_track_meta_data_works)
 
111
TEST(MusicService, DISABLED_remotely_querying_track_meta_data_works)
71
112
{
72
113
    const std::string test_file{"/tmp/test.ogg"};
73
114
    const std::string test_file_uri{"file:///tmp/test.ogg"};
74
115
    std::remove(test_file.c_str());
75
116
    ASSERT_TRUE(test::copy_test_ogg_file_to(test_file));
76
117
 
77
 
    test::CrossProcessSync sync_service_start;
 
118
    core::testing::CrossProcessSync sync_service_start;
78
119
 
79
 
    auto service = [&sync_service_start]()
 
120
    auto service = [this, &sync_service_start]()
80
121
    {
 
122
        SigTermCatcher sc;
 
123
 
81
124
        auto service = std::make_shared<media::ServiceImplementation>();
82
125
        std::thread t([&service](){service->run();});
83
126
 
84
 
        sync_service_start.signal_ready();
 
127
        sync_service_start.try_signal_ready_for(std::chrono::milliseconds{500});
 
128
 
 
129
        sc.wait_for_signal(); service->stop();
85
130
 
86
131
        if (t.joinable())
87
132
            t.join();
 
133
 
 
134
        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
88
135
    };
89
136
 
90
 
    auto client = [&sync_service_start]()
 
137
    auto client = [this, &sync_service_start]()
91
138
    {
92
 
        sync_service_start.wait_for_signal_ready();
 
139
        sync_service_start.wait_for_signal_ready_for(std::chrono::milliseconds{500});
93
140
 
94
141
        static const media::Track::UriType uri{"file:///tmp/test.ogg"};
95
142
 
99
146
 
100
147
        track_list->add_track_with_uri_at(uri, media::TrackList::after_empty_track(), false);
101
148
 
102
 
        EXPECT_EQ(1, track_list->tracks()->size());
 
149
        EXPECT_EQ(std::uint32_t{1}, track_list->tracks()->size());
103
150
 
104
151
        auto md = track_list->query_meta_data_for_track(track_list->tracks()->front());
105
152
 
107
154
        {
108
155
            std::cout << pair.first << " -> " << pair.second << std::endl;
109
156
        }
 
157
 
 
158
        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
110
159
    };
111
160
 
112
 
    ASSERT_NO_FATAL_FAILURE(test::fork_and_run(service, client));
 
161
    EXPECT_EQ(core::testing::ForkAndRunResult::empty,
 
162
              core::testing::fork_and_run(service, client));
113
163
}
114
164
 
115
165
TEST(MusicService, DISABLED_play_pause_seek_after_open_uri_works)
118
168
    std::remove(test_file.c_str());
119
169
    ASSERT_TRUE(test::copy_test_mp3_file_to(test_file));
120
170
 
121
 
    test::CrossProcessSync sync_service_start;
 
171
    core::testing::CrossProcessSync sync_service_start;
122
172
 
123
 
    auto service = [&sync_service_start]()
 
173
    auto service = [this, &sync_service_start]()
124
174
    {
 
175
        SigTermCatcher sc;
 
176
 
125
177
        auto service = std::make_shared<media::ServiceImplementation>();
126
178
        std::thread t([&service](){service->run();});
127
179
 
128
 
        sync_service_start.signal_ready();
 
180
        sync_service_start.try_signal_ready_for(std::chrono::milliseconds{500});
 
181
 
 
182
        sc.wait_for_signal(); service->stop();
129
183
 
130
184
        if (t.joinable())
131
185
            t.join();
 
186
 
 
187
        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
132
188
    };
133
189
 
134
 
    auto client = [&sync_service_start]()
 
190
    auto client = [this, &sync_service_start]()
135
191
    {
136
 
        sync_service_start.wait_for_signal_ready();
 
192
        sync_service_start.wait_for_signal_ready_for(std::chrono::milliseconds{500});
137
193
 
138
194
        static const media::Track::UriType uri{"file:///tmp/test.mp3"};
139
195
 
140
196
        auto service = media::Service::Client::instance();
141
197
        auto session = service->create_session(media::Player::Client::default_configuration());
142
198
 
143
 
        ASSERT_EQ(true, session->can_play().get());
144
 
        ASSERT_EQ(true, session->can_pause().get());
145
 
        ASSERT_EQ(true, session->can_seek().get());
146
 
        ASSERT_EQ(true, session->can_go_previous().get());
147
 
        ASSERT_EQ(true, session->can_go_next().get());
148
 
        ASSERT_EQ(media::Player::PlaybackStatus::null, session->playback_status());
149
 
        ASSERT_EQ(media::Player::LoopStatus::none, session->loop_status());
150
 
        ASSERT_NEAR(1.f, session->playback_rate().get(), 1E-5);
151
 
        ASSERT_EQ(true, session->is_shuffle());
152
 
        ASSERT_EQ(true, session->track_list()->can_edit_tracks().get());
 
199
        EXPECT_EQ(true, session->can_play().get());
 
200
        EXPECT_EQ(true, session->can_pause().get());
 
201
        EXPECT_EQ(true, session->can_seek().get());
 
202
        EXPECT_EQ(true, session->can_go_previous().get());
 
203
        EXPECT_EQ(true, session->can_go_next().get());
 
204
        EXPECT_EQ(media::Player::PlaybackStatus::null, session->playback_status());
 
205
        EXPECT_EQ(media::Player::LoopStatus::none, session->loop_status());
 
206
        EXPECT_NEAR(1.f, session->playback_rate().get(), 1E-5);
 
207
        EXPECT_EQ(true, session->is_shuffle());
 
208
        EXPECT_EQ(true, session->track_list()->can_edit_tracks().get());
153
209
 
154
210
        EXPECT_TRUE(session->open_uri(uri));
155
211
 
156
 
        test::WaitableStateTransition<media::Player::PlaybackStatus>
 
212
        core::testing::WaitableStateTransition<media::Player::PlaybackStatus>
157
213
                state_transition(
158
214
                    media::Player::stopped);
159
215
 
160
216
        session->playback_status().changed().connect(
161
 
            std::bind(&test::WaitableStateTransition<media::Player::PlaybackStatus>::trigger,
 
217
            std::bind(&core::testing::WaitableStateTransition<media::Player::PlaybackStatus>::trigger,
162
218
                      std::ref(state_transition),
163
219
                      std::placeholders::_1));
164
220
 
165
221
        session->play();
166
 
        std::this_thread::sleep_for(std::chrono::seconds{1});
167
 
        ASSERT_EQ(media::Player::PlaybackStatus::playing, session->playback_status());
 
222
        sleep_for(std::chrono::seconds{1});
 
223
        EXPECT_EQ(media::Player::PlaybackStatus::playing, session->playback_status());
168
224
        session->stop();
169
 
        std::this_thread::sleep_for(std::chrono::seconds{1});
170
 
        ASSERT_EQ(media::Player::PlaybackStatus::stopped, session->playback_status());
 
225
        sleep_for(std::chrono::seconds{1});
 
226
        EXPECT_EQ(media::Player::PlaybackStatus::stopped, session->playback_status());
171
227
        session->play();
172
 
        std::this_thread::sleep_for(std::chrono::seconds{1});
173
 
        ASSERT_EQ(media::Player::PlaybackStatus::playing, session->playback_status());
 
228
        sleep_for(std::chrono::seconds{1});
 
229
        EXPECT_EQ(media::Player::PlaybackStatus::playing, session->playback_status());
174
230
        session->pause();
175
 
        std::this_thread::sleep_for(std::chrono::seconds{1});
176
 
        ASSERT_EQ(media::Player::PlaybackStatus::paused, session->playback_status());
 
231
        sleep_for(std::chrono::seconds{1});
 
232
        EXPECT_EQ(media::Player::PlaybackStatus::paused, session->playback_status());
 
233
        session->stop();
 
234
        sleep_for(std::chrono::seconds{1});
 
235
        EXPECT_EQ(media::Player::PlaybackStatus::stopped, session->playback_status());
 
236
 
 
237
        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
177
238
    };
178
239
 
179
 
    ASSERT_NO_FATAL_FAILURE(test::fork_and_run(service, client));
 
240
    EXPECT_EQ(core::testing::ForkAndRunResult::empty,
 
241
              core::testing::fork_and_run(service, client));
180
242
}
181
243
 
182
244
 
186
248
    std::remove(test_file.c_str());
187
249
    ASSERT_TRUE(test::copy_test_mp3_file_to(test_file));
188
250
 
189
 
    test::CrossProcessSync sync_service_start;
 
251
    core::testing::CrossProcessSync sync_service_start;
190
252
 
191
 
    auto service = [&sync_service_start]()
 
253
    auto service = [this, &sync_service_start]()
192
254
    {
 
255
        SigTermCatcher sc;
 
256
 
193
257
        auto service = std::make_shared<media::ServiceImplementation>();
194
258
        std::thread t([&service](){service->run();});
195
259
 
196
 
        sync_service_start.signal_ready();
 
260
        sync_service_start.try_signal_ready_for(std::chrono::milliseconds{500});
 
261
 
 
262
        sc.wait_for_signal(); service->stop();
197
263
 
198
264
        if (t.joinable())
199
265
            t.join();
 
266
 
 
267
        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
200
268
    };
201
269
 
202
 
    auto client = [&sync_service_start]()
 
270
    auto client = [this, &sync_service_start]()
203
271
    {
204
 
        sync_service_start.wait_for_signal_ready();
 
272
        sync_service_start.wait_for_signal_ready_for(std::chrono::milliseconds{500});
205
273
 
206
274
        static const media::Track::UriType uri{"file:///tmp/test.mp3"};
207
275
        static const bool dont_make_current{false};
209
277
        auto service = media::Service::Client::instance();
210
278
        auto session = service->create_session(media::Player::Client::default_configuration());
211
279
 
212
 
        ASSERT_EQ(true, session->can_play().get());
213
 
        ASSERT_EQ(true, session->can_play().get());
214
 
        ASSERT_EQ(true, session->can_pause().get());
215
 
        ASSERT_EQ(true, session->can_seek().get());
216
 
        ASSERT_EQ(true, session->can_go_previous().get());
217
 
        ASSERT_EQ(true, session->can_go_next().get());
218
 
        ASSERT_EQ(media::Player::PlaybackStatus::null, session->playback_status());
219
 
        ASSERT_EQ(media::Player::LoopStatus::none, session->loop_status());
220
 
        ASSERT_NEAR(1.f, session->playback_rate().get(), 1E-5);
221
 
        ASSERT_EQ(true, session->is_shuffle());
222
 
        ASSERT_EQ(true, session->track_list()->can_edit_tracks().get());
 
280
        EXPECT_EQ(true, session->can_play().get());
 
281
        EXPECT_EQ(true, session->can_play().get());
 
282
        EXPECT_EQ(true, session->can_pause().get());
 
283
        EXPECT_EQ(true, session->can_seek().get());
 
284
        EXPECT_EQ(true, session->can_go_previous().get());
 
285
        EXPECT_EQ(true, session->can_go_next().get());
 
286
        EXPECT_EQ(media::Player::PlaybackStatus::null, session->playback_status());
 
287
        EXPECT_EQ(media::Player::LoopStatus::none, session->loop_status());
 
288
        EXPECT_NEAR(1.f, session->playback_rate().get(), 1E-5);
 
289
        EXPECT_EQ(true, session->is_shuffle());
 
290
        EXPECT_EQ(true, session->track_list()->can_edit_tracks().get());
223
291
 
224
292
        session->track_list()->add_track_with_uri_at(uri, media::TrackList::after_empty_track(), dont_make_current);
225
293
 
226
 
        EXPECT_EQ(1, session->track_list()->tracks()->size());
 
294
        EXPECT_EQ(std::uint32_t{1}, session->track_list()->tracks()->size());
227
295
 
228
 
        test::WaitableStateTransition<media::Player::PlaybackStatus>
 
296
        core::testing::WaitableStateTransition<media::Player::PlaybackStatus>
229
297
                state_transition(
230
298
                    media::Player::stopped);
231
299
 
232
300
        session->playback_status().changed().connect(
233
 
            std::bind(&test::WaitableStateTransition<media::Player::PlaybackStatus>::trigger,
 
301
            std::bind(&core::testing::WaitableStateTransition<media::Player::PlaybackStatus>::trigger,
234
302
                      std::ref(state_transition),
235
303
                      std::placeholders::_1));
236
304
 
238
306
 
239
307
        EXPECT_TRUE(state_transition.wait_for_state_for(
240
308
                        media::Player::playing,
241
 
                        std::chrono::milliseconds{500}));
 
309
                        std::chrono::milliseconds{2000}));
 
310
 
 
311
        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
242
312
    };
243
313
 
244
 
    ASSERT_NO_FATAL_FAILURE(test::fork_and_run(service, client));
 
314
    EXPECT_EQ(core::testing::ForkAndRunResult::empty,
 
315
              core::testing::fork_and_run(service, client));
245
316
}