← Back to branch summary

~xavi-garcia-mena/indicator-sound/check-mpris-properties

« back to all changes in this revision

Viewing changes to tests/media-player-user.cc

  • Committer: CI Train Bot
  • Author(s): Ted Gould
  • Date: 2015-06-05 19:50:04 UTC
  • mfrom: (496.1.9 eventually-testing)
  • Revision ID: ci-train-bot@canonical.com-20150605195004-sgv3p2rpgtdt9svo
Using eventually to avoid arbitrary timeouts in tests
Approved by: Charles Kerr, PS Jenkins bot

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/media-player-user.cc
17
17
 *      Ted Gould <ted@canonical.com>
18
18
 */
19
19
 
 
20
#include <chrono>
 
21
#include <future>
 
22
 
20
23
#include <gtest/gtest.h>
21
24
#include <gio/gio.h>
22
25
#include <libdbustest/dbus-test.h>
31
34
{
32
35
 
33
36
        protected:
34
 
                DbusTestService * service = NULL;
 
37
                DbusTestService * testsystem = NULL;
35
38
                AccountsServiceMock service_mock;
36
39
 
 
40
                DbusTestService * testsession = NULL;
 
41
 
 
42
                DbusTestProcess * systemmonitor = nullptr;
 
43
                DbusTestProcess * sessionmonitor = nullptr;
 
44
 
37
45
                GDBusConnection * system = NULL;
 
46
                GDBusConnection * session = NULL;
38
47
                GDBusProxy * proxy = NULL;
39
48
 
 
49
                std::chrono::milliseconds _eventuallyTime = std::chrono::seconds{5};
 
50
 
40
51
                virtual void SetUp() {
41
 
                        service = dbus_test_service_new(NULL);
42
 
                        dbus_test_service_set_bus(service, DBUS_TEST_SERVICE_BUS_SYSTEM);
43
 
 
44
 
                        dbus_test_service_add_task(service, (DbusTestTask*)service_mock);
45
 
                        dbus_test_service_start_tasks(service);
 
52
                        /* System Bus */
 
53
                        testsystem = dbus_test_service_new(NULL);
 
54
                        dbus_test_service_set_bus(testsystem, DBUS_TEST_SERVICE_BUS_SYSTEM);
 
55
 
 
56
                        systemmonitor = dbus_test_process_new("dbus-monitor");
 
57
                        dbus_test_process_append_param(systemmonitor, "--system");
 
58
                        dbus_test_task_set_name(DBUS_TEST_TASK(systemmonitor), "System");
 
59
                        dbus_test_service_add_task(testsystem, DBUS_TEST_TASK(systemmonitor));
 
60
 
 
61
                        dbus_test_service_add_task(testsystem, (DbusTestTask*)service_mock);
 
62
                        dbus_test_service_start_tasks(testsystem);
46
63
 
47
64
                        system = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
48
65
                        ASSERT_NE(nullptr, system);
49
66
                        g_dbus_connection_set_exit_on_close(system, FALSE);
50
67
                        g_object_add_weak_pointer(G_OBJECT(system), (gpointer *)&system);
51
68
 
 
69
                        /* Session Bus */
 
70
                        testsession = dbus_test_service_new(NULL);
 
71
                        dbus_test_service_set_bus(testsession, DBUS_TEST_SERVICE_BUS_SESSION);
 
72
 
 
73
                        sessionmonitor = dbus_test_process_new("dbus-monitor");
 
74
                        dbus_test_process_append_param(sessionmonitor, "--session");
 
75
                        dbus_test_task_set_name(DBUS_TEST_TASK(sessionmonitor), "Session");
 
76
                        dbus_test_service_add_task(testsession, DBUS_TEST_TASK(sessionmonitor));
 
77
 
 
78
                        dbus_test_service_start_tasks(testsession);
 
79
 
 
80
                        session = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
 
81
                        ASSERT_NE(nullptr, session);
 
82
                        g_dbus_connection_set_exit_on_close(session, FALSE);
 
83
                        g_object_add_weak_pointer(G_OBJECT(session), (gpointer *)&session);
 
84
 
 
85
                        /* Setup proxy */
52
86
                        proxy = g_dbus_proxy_new_sync(system,
53
87
                                G_DBUS_PROXY_FLAGS_NONE,
54
88
                                NULL,
60
94
                }
61
95
 
62
96
                virtual void TearDown() {
 
97
                        g_clear_object(&sessionmonitor);
 
98
                        g_clear_object(&systemmonitor);
 
99
 
63
100
                        g_clear_object(&proxy);
64
 
                        g_clear_object(&service);
 
101
                        g_clear_object(&testsystem);
 
102
                        g_clear_object(&testsession);
65
103
 
66
104
                        g_object_unref(system);
 
105
                        g_object_unref(session);
67
106
 
68
107
                        #if 0
69
108
                        /* Accounts Service keeps a bunch of references around so we
95
134
                void set_property (const gchar * name, GVariant * value) {
96
135
                        dbus_test_dbus_mock_object_update_property((DbusTestDbusMock *)service_mock, service_mock.get_sound(), name, value, NULL);
97
136
                }
 
137
 
 
138
                testing::AssertionResult expectEventually (std::function<testing::AssertionResult(void)> &testfunc) {
 
139
                        auto loop = std::shared_ptr<GMainLoop>(g_main_loop_new(nullptr, FALSE), [](GMainLoop * loop) { if (loop != nullptr) g_main_loop_unref(loop); });
 
140
 
 
141
                        std::promise<testing::AssertionResult> retpromise;
 
142
                        auto retfuture = retpromise.get_future();
 
143
                        auto start = std::chrono::steady_clock::now();
 
144
 
 
145
                        /* The core of the idle function as an object so we can use the C++-isms
 
146
                           of attaching the variables and make this code reasonably readable */
 
147
                        std::function<void(void)> idlefunc = [&loop, &retpromise, &testfunc, &start, this]() -> void {
 
148
                                auto result = testfunc();
 
149
 
 
150
                                if (result == false && _eventuallyTime > (std::chrono::steady_clock::now() - start)) {
 
151
                                        return;
 
152
                                }
 
153
 
 
154
                                retpromise.set_value(result);
 
155
                                g_main_loop_quit(loop.get());
 
156
                        };
 
157
 
 
158
                        auto idlesrc = g_idle_add([](gpointer data) -> gboolean {
 
159
                                auto func = reinterpret_cast<std::function<void(void)> *>(data);
 
160
                                (*func)();
 
161
                                return G_SOURCE_CONTINUE;
 
162
                        }, &idlefunc);
 
163
 
 
164
                        g_main_loop_run(loop.get());
 
165
                        g_source_remove(idlesrc);
 
166
 
 
167
                        return retfuture.get();
 
168
                }
 
169
 
 
170
                /* Eventually Helpers */
 
171
                #define _EVENTUALLY_HELPER(oper) \
 
172
                template <typename... Args> testing::AssertionResult expectEventually##oper (Args&& ... args) { \
 
173
                        std::function<testing::AssertionResult(void)> func = [&]() { \
 
174
                                return testing::internal::CmpHelper##oper(std::forward<Args>(args)...); \
 
175
                        }; \
 
176
                        return expectEventually(func); \
 
177
                }
 
178
 
 
179
                _EVENTUALLY_HELPER(EQ);
 
180
                _EVENTUALLY_HELPER(NE);
 
181
                _EVENTUALLY_HELPER(LT);
 
182
                _EVENTUALLY_HELPER(GT);
 
183
                _EVENTUALLY_HELPER(STREQ);
 
184
                _EVENTUALLY_HELPER(STRNE);
 
185
 
 
186
                #undef _EVENTUALLY_HELPER
98
187
};
99
188
 
 
189
/* Helpers */
 
190
#define EXPECT_EVENTUALLY_EQ(expected, actual) \
 
191
        EXPECT_PRED_FORMAT2(MediaPlayerUserTest::expectEventuallyEQ, expected, actual)
 
192
 
 
193
#define EXPECT_EVENTUALLY_NE(expected, actual) \
 
194
        EXPECT_PRED_FORMAT2(MediaPlayerUserTest::expectEventuallyNE, expected, actual)
 
195
 
 
196
#define EXPECT_EVENTUALLY_LT(expected, actual) \
 
197
        EXPECT_PRED_FORMAT2(MediaPlayerUserTest::expectEventuallyLT, expected, actual)
 
198
 
 
199
#define EXPECT_EVENTUALLY_GT(expected, actual) \
 
200
        EXPECT_PRED_FORMAT2(MediaPlayerUserTest::expectEventuallyGT, expected, actual)
 
201
 
 
202
#define EXPECT_EVENTUALLY_STREQ(expected, actual) \
 
203
        EXPECT_PRED_FORMAT2(MediaPlayerUserTest::expectEventuallySTREQ, expected, actual)
 
204
 
 
205
#define EXPECT_EVENTUALLY_STRNE(expected, actual) \
 
206
        EXPECT_PRED_FORMAT2(MediaPlayerUserTest::expectEventuallySTRNE, expected, actual)
 
207
 
 
208
 
100
209
TEST_F(MediaPlayerUserTest, BasicObject) {
101
210
        MediaPlayerUser * player = media_player_user_new("user");
102
211
        ASSERT_NE(nullptr, player);
125
234
        g_clear_object(&player);
126
235
}
127
236
 
 
237
void
 
238
running_update (GObject * obj, GParamSpec * pspec, bool * running) {
 
239
        *running = media_player_get_is_running(MEDIA_PLAYER(obj)) == TRUE;
 
240
};
 
241
 
128
242
TEST_F(MediaPlayerUserTest, DataSet) {
129
243
        /* Put data into Acts */
130
244
        set_property("Timestamp", g_variant_new_uint64(g_get_monotonic_time()));
141
255
        MediaPlayerUser * player = media_player_user_new("user");
142
256
        ASSERT_NE(nullptr, player);
143
257
 
144
 
        /* Get the proxy -- and it's precious precious data -- oh, my, precious! */
145
 
        loop(100);
146
 
 
147
258
        /* Ensure even with the proxy we don't have anything */
148
 
        EXPECT_TRUE(media_player_get_is_running(MEDIA_PLAYER(player)));
 
259
        bool running = false;
 
260
        g_signal_connect(G_OBJECT(player), "notify::is-running", G_CALLBACK(running_update), &running);
 
261
        running_update(G_OBJECT(player), nullptr, &running);
 
262
        EXPECT_EVENTUALLY_EQ(true, running);
149
263
        EXPECT_TRUE(media_player_get_can_raise(MEDIA_PLAYER(player)));
150
264
        EXPECT_STREQ("user", media_player_get_id(MEDIA_PLAYER(player)));
151
265
        EXPECT_STREQ("The Player Formerly Known as Prince", media_player_get_name(MEDIA_PLAYER(player)));
180
294
        set_property("Album", g_variant_new_string("Vinyl is dead"));
181
295
        set_property("ArtUrl", g_variant_new_string("http://art.url"));
182
296
 
183
 
        /* Ensure the properties get set before we pull them */
184
 
        loop(100);
185
 
 
186
297
        /* Build our media player */
187
298
        MediaPlayerUser * player = media_player_user_new("user");
188
299
        ASSERT_NE(nullptr, player);
189
300
 
190
 
        /* Get the proxy -- and the old data, so old, like forever */
191
 
        loop(100);
 
301
        bool running = false;
 
302
        g_signal_connect(G_OBJECT(player), "notify::is-running", G_CALLBACK(running_update), &running);
 
303
        running_update(G_OBJECT(player), nullptr, &running);
192
304
 
193
305
        /* Ensure that we show up as not running */
194
 
        EXPECT_FALSE(media_player_get_is_running(MEDIA_PLAYER(player)));
 
306
        EXPECT_EVENTUALLY_EQ(false, running);
195
307
 
196
308
        /* Update to make running */
197
309
        set_property("Timestamp", g_variant_new_uint64(g_get_monotonic_time()));
198
 
        loop(100);
199
 
 
200
 
        EXPECT_TRUE(media_player_get_is_running(MEDIA_PLAYER(player)));
 
310
 
 
311
        EXPECT_EVENTUALLY_EQ(true, running);
 
312
 
 
313
        /* Clear to not run */
 
314
        set_property("Timestamp", g_variant_new_uint64(1));
 
315
 
 
316
        EXPECT_EVENTUALLY_EQ(false, running);
201
317
 
202
318
        g_clear_object(&in_icon);
203
319
        g_clear_object(&player);