DBus Test Runner

Merge lp:~3v1n0/dbus-test-runner/new-priv-gobject-abi into lp:dbus-test-runner

  1. new-priv-gobject-abi
  2. Merge into trunk.16.10
Proposed by Marco Trevisan (Treviño)
Status: Merged
Approved by: Marco Trevisan (Treviño)
Approved revision: 102
Merged at revision: 101
Proposed branch: lp:~3v1n0/dbus-test-runner/new-priv-gobject-abi
Merge into: lp:dbus-test-runner
Diff against target: 2382 lines (+551/-483)
14 files modified
configure.ac (+2/-2)
debian/control (+1/-1)
libdbustest/bustle.c (+57/-56)
libdbustest/bustle.h (+0/-2)
libdbustest/dbus-mock.c (+87/-69)
libdbustest/dbus-mock.h (+0/-2)
libdbustest/process.c (+80/-73)
libdbustest/process.h (+0/-2)
libdbustest/service.c (+203/-170)
libdbustest/service.h (+0/-2)
libdbustest/task.c (+105/-82)
libdbustest/task.h (+0/-2)
libdbustest/watchdog.c (+16/-18)
libdbustest/watchdog.h (+0/-2)
To merge this branch: bzr merge lp:~3v1n0/dbus-test-runner/new-priv-gobject-abi
Reviewer Review Type Date Requested Status
Sebastien Bacher Approve
Review via email: mp+361260@code.launchpad.net

Commit message

libdbustest: port to new GObject private ABI

To post a comment you must log in.
lp:~3v1n0/dbus-test-runner/new-priv-gobject-abi updated
102. By Marco Trevisan (Treviño)

configure.ac, debian/control: bump build-dependency to glib 2.38

This is the first version exposing the newly used G_DEFINE_TYPE_WITH_PRIVATE

Revision history for this message
Sebastien Bacher (seb128) wrote :

Looks fine to me, perhaps we should just sync the package from Debian now though?
They have a similar fix in
https://salsa.debian.org/debian/dbus-test-runner/blob/master/debian/patches/1002_new-gobject-private-api.patch

review: Approve

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1=== modified file 'configure.ac'
2--- configure.ac 2015-01-20 22:26:38 +0000
3+++ configure.ac 2018-12-22 01:46:34 +0000
4@@ -22,10 +22,10 @@
5 m4_ifdef([AM_SILENT_RULES],[AM_SILENT_RULES([yes])])
6
7 ###########################
8-# Dependencies
9+# Dependencies
10 ###########################
11
12-GLIB_REQUIRED_VERSION=2.34
13+GLIB_REQUIRED_VERSION=2.38
14 DBUS_REQUIRED_VERSION=0.76
15 GIO_REQUIRED_VERSION=2.30
16
17
18=== modified file 'debian/control'
19--- debian/control 2015-01-20 22:26:38 +0000
20+++ debian/control 2018-12-22 01:46:34 +0000
21@@ -7,7 +7,7 @@
22 gnome-common,
23 xvfb,
24 libdbus-glib-1-dev,
25- libglib2.0-dev (>= 2.34.0),
26+ libglib2.0-dev (>= 2.38.0),
27 dbus,
28 python3-dbusmock,
29 Standards-Version: 3.9.3
30
31=== modified file 'libdbustest/bustle.c'
32--- libdbustest/bustle.c 2013-12-06 10:04:57 +0000
33+++ libdbustest/bustle.c 2018-12-22 01:46:34 +0000
34@@ -25,7 +25,7 @@
35 #include "glib-compat.h"
36 #include "dbus-test.h"
37
38-struct _DbusTestBustlePrivate {
39+typedef struct {
40 gchar * filename;
41 gchar * executable;
42
43@@ -35,10 +35,7 @@
44 GPid pid;
45
46 gboolean crashed;
47-};
48-
49-#define DBUS_TEST_BUSTLE_GET_PRIVATE(o) \
50-(G_TYPE_INSTANCE_GET_PRIVATE ((o), DBUS_TEST_TYPE_BUSTLE, DbusTestBustlePrivate))
51+} DbusTestBustlePrivate;
52
53 static void dbus_test_bustle_class_init (DbusTestBustleClass *klass);
54 static void dbus_test_bustle_init (DbusTestBustle *self);
55@@ -51,15 +48,13 @@
56 GIOCondition condition,
57 gpointer data);
58
59-G_DEFINE_TYPE (DbusTestBustle, dbus_test_bustle, DBUS_TEST_TYPE_TASK);
60+G_DEFINE_TYPE_WITH_PRIVATE (DbusTestBustle, dbus_test_bustle, DBUS_TEST_TYPE_TASK);
61
62 static void
63 dbus_test_bustle_class_init (DbusTestBustleClass *klass)
64 {
65 GObjectClass *object_class = G_OBJECT_CLASS (klass);
66
67- g_type_class_add_private (klass, sizeof (DbusTestBustlePrivate));
68-
69 object_class->dispose = dbus_test_bustle_dispose;
70 object_class->finalize = dbus_test_bustle_finalize;
71
72@@ -77,17 +72,17 @@
73 {
74 gchar * current_dir = g_get_current_dir();
75
76- self->priv = DBUS_TEST_BUSTLE_GET_PRIVATE(self);
77-
78- self->priv->filename = g_strconcat(current_dir, G_DIR_SEPARATOR_S, "bustle.log", NULL);
79- self->priv->executable = g_strdup(BUSTLE_DUAL_MONITOR);
80-
81- self->priv->watch = 0;
82- self->priv->stderr = NULL;
83- self->priv->file = NULL;
84- self->priv->pid = 0;
85-
86- self->priv->crashed = FALSE;
87+ DbusTestBustlePrivate *priv = dbus_test_bustle_get_instance_private(self);
88+
89+ priv->filename = g_strconcat(current_dir, G_DIR_SEPARATOR_S, "bustle.log", NULL);
90+ priv->executable = g_strdup(BUSTLE_DUAL_MONITOR);
91+
92+ priv->watch = 0;
93+ priv->stderr = NULL;
94+ priv->file = NULL;
95+ priv->pid = 0;
96+
97+ priv->crashed = FALSE;
98
99 g_free (current_dir);
100 return;
101@@ -98,31 +93,32 @@
102 {
103 g_return_if_fail(DBUS_TEST_IS_BUSTLE(object));
104 DbusTestBustle * bustler = DBUS_TEST_BUSTLE(object);
105+ DbusTestBustlePrivate *priv = dbus_test_bustle_get_instance_private(bustler);
106
107- if (bustler->priv->watch != 0) {
108- g_source_remove(bustler->priv->watch);
109- bustler->priv->watch = 0;
110+ if (priv->watch != 0) {
111+ g_source_remove(priv->watch);
112+ priv->watch = 0;
113 }
114
115- if (bustler->priv->pid != 0) {
116- gchar * command = g_strdup_printf("kill -INT %d", bustler->priv->pid);
117+ if (priv->pid != 0) {
118+ gchar * command = g_strdup_printf("kill -INT %d", priv->pid);
119 g_spawn_command_line_sync(command, NULL, NULL, NULL, NULL);
120 g_free(command);
121
122- g_spawn_close_pid(bustler->priv->pid);
123+ g_spawn_close_pid(priv->pid);
124 }
125
126- if (bustler->priv->stderr != NULL) {
127- while (G_IO_IN & g_io_channel_get_buffer_condition(bustler->priv->stderr)) {
128- bustle_write_error(bustler->priv->stderr, 0 /* unused */, bustler);
129+ if (priv->stderr != NULL) {
130+ while (G_IO_IN & g_io_channel_get_buffer_condition(priv->stderr)) {
131+ bustle_write_error(priv->stderr, 0 /* unused */, bustler);
132 }
133
134- g_clear_pointer(&bustler->priv->stderr, g_io_channel_unref);
135+ g_clear_pointer(&priv->stderr, g_io_channel_unref);
136 }
137
138- if (bustler->priv->file != NULL) {
139- g_io_channel_shutdown(bustler->priv->file, TRUE, NULL);
140- g_clear_pointer(&bustler->priv->file, g_io_channel_unref);
141+ if (priv->file != NULL) {
142+ g_io_channel_shutdown(priv->file, TRUE, NULL);
143+ g_clear_pointer(&priv->file, g_io_channel_unref);
144 }
145
146 G_OBJECT_CLASS (dbus_test_bustle_parent_class)->dispose (object);
147@@ -134,9 +130,10 @@
148 {
149 g_return_if_fail(DBUS_TEST_IS_BUSTLE(object));
150 DbusTestBustle * bustler = DBUS_TEST_BUSTLE(object);
151+ DbusTestBustlePrivate *priv = dbus_test_bustle_get_instance_private(bustler);
152
153- g_free(bustler->priv->filename);
154- g_free(bustler->priv->executable);
155+ g_free(priv->filename);
156+ g_free(priv->executable);
157
158 G_OBJECT_CLASS (dbus_test_bustle_parent_class)->finalize (object);
159 return;
160@@ -149,9 +146,10 @@
161
162 DbusTestBustle * bustler = g_object_new(DBUS_TEST_TYPE_BUSTLE,
163 NULL);
164+ DbusTestBustlePrivate *priv = dbus_test_bustle_get_instance_private(bustler);
165
166- g_free(bustler->priv->filename);
167- bustler->priv->filename = g_strdup(filename);
168+ g_free(priv->filename);
169+ priv->filename = g_strdup(filename);
170
171 dbus_test_task_set_name(DBUS_TEST_TASK(bustler), "Bustle");
172
173@@ -164,8 +162,9 @@
174 g_return_if_fail(DBUS_TEST_IS_BUSTLE(bustle));
175 g_return_if_fail(executable != NULL);
176
177- g_free(bustle->priv->executable);
178- bustle->priv->executable = g_strdup(executable);
179+ DbusTestBustlePrivate *priv = dbus_test_bustle_get_instance_private(bustle);
180+ g_free(priv->executable);
181+ priv->executable = g_strdup(executable);
182
183 return;
184 }
185@@ -175,13 +174,14 @@
186 {
187 g_critical("Bustle Monitor exited abruptly!");
188 DbusTestBustle * bustler = DBUS_TEST_BUSTLE(data);
189+ DbusTestBustlePrivate *priv = dbus_test_bustle_get_instance_private(bustler);
190
191- if (bustler->priv->pid != 0) {
192+ if (priv->pid != 0) {
193 g_spawn_close_pid(pid);
194- bustler->priv->pid = 0;
195+ priv->pid = 0;
196 }
197
198- bustler->priv->crashed = TRUE;
199+ priv->crashed = TRUE;
200 g_signal_emit_by_name(G_OBJECT(bustler), DBUS_TEST_TASK_SIGNAL_STATE_CHANGED, DBUS_TEST_TASK_STATE_FINISHED, NULL);
201
202 return;
203@@ -218,20 +218,21 @@
204 {
205 g_return_if_fail(DBUS_TEST_IS_BUSTLE(task));
206 DbusTestBustle * bustler = DBUS_TEST_BUSTLE(task);
207+ DbusTestBustlePrivate *priv = dbus_test_bustle_get_instance_private(bustler);
208
209- if (bustler->priv->pid != 0) {
210+ if (priv->pid != 0) {
211 return;
212 }
213
214 GError * error = NULL;
215
216- bustler->priv->file = g_io_channel_new_file(bustler->priv->filename, "w", &error);
217+ priv->file = g_io_channel_new_file(priv->filename, "w", &error);
218
219 if (error != NULL) {
220- g_critical("Unable to open bustle file '%s': %s", bustler->priv->filename, error->message);
221+ g_critical("Unable to open bustle file '%s': %s", priv->filename, error->message);
222 g_error_free(error);
223
224- bustler->priv->crashed = TRUE;
225+ priv->crashed = TRUE;
226 g_signal_emit_by_name(G_OBJECT(bustler), DBUS_TEST_TASK_SIGNAL_STATE_CHANGED, DBUS_TEST_TASK_STATE_FINISHED, NULL);
227 return;
228 }
229@@ -241,8 +242,8 @@
230 gchar * current_dir = g_get_current_dir();
231
232 gchar ** bustle_monitor = g_new0(gchar *, 3);
233- bustle_monitor[0] = (gchar *)bustler->priv->executable;
234- bustle_monitor[1] = (gchar *)bustler->priv->filename;
235+ bustle_monitor[0] = (gchar *)priv->executable;
236+ bustle_monitor[1] = (gchar *)priv->filename;
237
238 g_spawn_async_with_pipes(current_dir,
239 bustle_monitor, /* argv */
240@@ -251,7 +252,7 @@
241 G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD, /* flags */
242 NULL, /* child setup func */
243 NULL, /* child setup data */
244- &bustler->priv->pid, /* PID */
245+ &priv->pid, /* PID */
246 NULL, /* stdin */
247 NULL, /* stdout */
248 &bustle_stderr_num, /* stderr */
249@@ -264,21 +265,21 @@
250 g_critical("Unable to start bustling data: %s", error->message);
251 g_error_free(error);
252
253- bustler->priv->pid = 0; /* ensure this */
254- bustler->priv->crashed = TRUE;
255+ priv->pid = 0; /* ensure this */
256+ priv->crashed = TRUE;
257 g_signal_emit_by_name(G_OBJECT(bustler), DBUS_TEST_TASK_SIGNAL_STATE_CHANGED, DBUS_TEST_TASK_STATE_FINISHED, NULL);
258 return;
259 }
260
261 if (TRUE) {
262- gchar * start = g_strdup_printf("Starting bustle monitor. PID: %d", bustler->priv->pid);
263+ gchar * start = g_strdup_printf("Starting bustle monitor. PID: %d", priv->pid);
264 dbus_test_task_print(DBUS_TEST_TASK(bustler), start);
265 g_free(start);
266 }
267- bustler->priv->watch = g_child_watch_add(bustler->priv->pid, bustle_watcher, bustler);
268+ priv->watch = g_child_watch_add(priv->pid, bustle_watcher, bustler);
269
270- bustler->priv->stderr = g_io_channel_unix_new(bustle_stderr_num);
271- g_io_add_watch(bustler->priv->stderr,
272+ priv->stderr = g_io_channel_unix_new(bustle_stderr_num);
273+ g_io_add_watch(priv->stderr,
274 G_IO_IN | G_IO_HUP | G_IO_ERR, /* conditions */
275 bustle_write_error, /* func */
276 bustler); /* func data */
277@@ -299,11 +300,11 @@
278 {
279 g_return_val_if_fail(DBUS_TEST_IS_BUSTLE(task), FALSE);
280 DbusTestBustle * bustler = DBUS_TEST_BUSTLE(task);
281+ DbusTestBustlePrivate *priv = dbus_test_bustle_get_instance_private(bustler);
282
283- if (bustler->priv->crashed) {
284+ if (priv->crashed) {
285 return FALSE;
286 } else {
287 return TRUE;
288 }
289 }
290-
291
292=== modified file 'libdbustest/bustle.h'
293--- libdbustest/bustle.h 2012-04-19 15:54:50 +0000
294+++ libdbustest/bustle.h 2018-12-22 01:46:34 +0000
295@@ -34,7 +34,6 @@
296
297 typedef struct _DbusTestBustle DbusTestBustle;
298 typedef struct _DbusTestBustleClass DbusTestBustleClass;
299-typedef struct _DbusTestBustlePrivate DbusTestBustlePrivate;
300
301 struct _DbusTestBustleClass {
302 DbusTestTaskClass parent_class;
303@@ -42,7 +41,6 @@
304
305 struct _DbusTestBustle {
306 DbusTestTask parent;
307- DbusTestBustlePrivate * priv;
308 };
309
310 GType dbus_test_bustle_get_type (void);
311
312=== modified file 'libdbustest/dbus-mock.c'
313--- libdbustest/dbus-mock.c 2015-01-30 02:43:44 +0000
314+++ libdbustest/dbus-mock.c 2018-12-22 01:46:34 +0000
315@@ -28,7 +28,7 @@
316 typedef struct _MockObjectProperty MockObjectProperty;
317 typedef struct _MockObjectMethod MockObjectMethod;
318
319-struct _DbusTestDbusMockPrivate {
320+typedef struct {
321 gchar * name;
322 _DbusMockIfaceOrgFreedesktopDBusMock * proxy;
323 /* Entries of DbusTestDbusMockObject */
324@@ -36,7 +36,7 @@
325 GHashTable * object_proxies;
326 GDBusConnection * bus;
327 GCancellable * cancel;
328-};
329+} DbusTestDbusMockPrivate;
330
331 /* Represents every object on the bus that we're mocking */
332 struct _DbusTestDbusMockObject {
333@@ -75,9 +75,6 @@
334
335 static guint mock_cnt = 0;
336
337-#define DBUS_TEST_DBUS_MOCK_GET_PRIVATE(o) \
338-(G_TYPE_INSTANCE_GET_PRIVATE ((o), DBUS_TEST_TYPE_DBUS_MOCK, DbusTestDbusMockPrivate))
339-
340 static void dbus_test_dbus_mock_class_init (DbusTestDbusMockClass *klass);
341 static void dbus_test_dbus_mock_init (DbusTestDbusMock *self);
342 static void constructed (GObject * object);
343@@ -96,7 +93,7 @@
344 static void method_free (gpointer data);
345 static void property_free (gpointer data);
346
347-G_DEFINE_TYPE (DbusTestDbusMock, dbus_test_dbus_mock, DBUS_TEST_TYPE_PROCESS);
348+G_DEFINE_TYPE_WITH_PRIVATE (DbusTestDbusMock, dbus_test_dbus_mock, DBUS_TEST_TYPE_PROCESS);
349 G_DEFINE_QUARK("dbus-test-dbus-mock", _dbus_mock);
350
351 /* Initialize Class */
352@@ -105,8 +102,6 @@
353 {
354 GObjectClass *object_class = G_OBJECT_CLASS (klass);
355
356- g_type_class_add_private (klass, sizeof (DbusTestDbusMockPrivate));
357-
358 object_class->dispose = dbus_test_dbus_mock_dispose;
359 object_class->finalize = dbus_test_dbus_mock_finalize;
360 object_class->get_property = get_property;
361@@ -131,12 +126,12 @@
362 static void
363 dbus_test_dbus_mock_init (DbusTestDbusMock *self)
364 {
365- self->priv = DBUS_TEST_DBUS_MOCK_GET_PRIVATE(self);
366-
367- self->priv->objects = NULL;
368- self->priv->object_proxies = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_object_unref);
369-
370- self->priv->cancel = g_cancellable_new();
371+ DbusTestDbusMockPrivate *priv = dbus_test_dbus_mock_get_instance_private(self);
372+
373+ priv->objects = NULL;
374+ priv->object_proxies = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_object_unref);
375+
376+ priv->cancel = g_cancellable_new();
377
378 return;
379 }
380@@ -162,18 +157,19 @@
381 dbus_test_dbus_mock_dispose (GObject *object)
382 {
383 DbusTestDbusMock * self = DBUS_TEST_DBUS_MOCK(object);
384-
385- if (self->priv->cancel != NULL)
386- g_cancellable_cancel(self->priv->cancel);
387- g_clear_object(&self->priv->cancel);
388-
389- g_hash_table_remove_all(self->priv->object_proxies);
390-
391- g_list_free_full(self->priv->objects, object_free);
392- self->priv->objects = NULL;
393-
394- g_clear_object(&self->priv->proxy);
395- g_clear_object(&self->priv->bus);
396+ DbusTestDbusMockPrivate *priv = dbus_test_dbus_mock_get_instance_private(self);
397+
398+ if (priv->cancel != NULL)
399+ g_cancellable_cancel(priv->cancel);
400+ g_clear_object(&priv->cancel);
401+
402+ g_hash_table_remove_all(priv->object_proxies);
403+
404+ g_list_free_full(priv->objects, object_free);
405+ priv->objects = NULL;
406+
407+ g_clear_object(&priv->proxy);
408+ g_clear_object(&priv->bus);
409
410 G_OBJECT_CLASS (dbus_test_dbus_mock_parent_class)->dispose (object);
411 return;
412@@ -184,9 +180,10 @@
413 dbus_test_dbus_mock_finalize (GObject *object)
414 {
415 DbusTestDbusMock * self = DBUS_TEST_DBUS_MOCK(object);
416+ DbusTestDbusMockPrivate *priv = dbus_test_dbus_mock_get_instance_private(self);
417
418- g_free(self->priv->name);
419- g_hash_table_destroy(self->priv->object_proxies);
420+ g_free(priv->name);
421+ g_hash_table_destroy(priv->object_proxies);
422
423 G_OBJECT_CLASS (dbus_test_dbus_mock_parent_class)->finalize (object);
424 return;
425@@ -197,10 +194,11 @@
426 get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec)
427 {
428 DbusTestDbusMock * self = DBUS_TEST_DBUS_MOCK(object);
429+ DbusTestDbusMockPrivate *priv = dbus_test_dbus_mock_get_instance_private(self);
430
431 switch (property_id) {
432 case PROP_DBUS_NAME:
433- g_value_set_string(value, self->priv->name);
434+ g_value_set_string(value, priv->name);
435 break;
436 default:
437 G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
438@@ -214,11 +212,12 @@
439 set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec)
440 {
441 DbusTestDbusMock * self = DBUS_TEST_DBUS_MOCK(object);
442+ DbusTestDbusMockPrivate *priv = dbus_test_dbus_mock_get_instance_private(self);
443
444 switch (property_id) {
445 case PROP_DBUS_NAME:
446- g_free(self->priv->name);
447- self->priv->name = g_value_dup_string(value);
448+ g_free(priv->name);
449+ priv->name = g_value_dup_string(value);
450 break;
451 default:
452 G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
453@@ -300,7 +299,9 @@
454 GVariant * properties = NULL;
455 GVariant * methods = NULL;
456
457- g_return_val_if_fail(mock->priv->proxy != NULL, FALSE);
458+ DbusTestDbusMockPrivate *priv = dbus_test_dbus_mock_get_instance_private(mock);
459+
460+ g_return_val_if_fail(priv->proxy != NULL, FALSE);
461
462 if (object->properties->len > 0) {
463 GVariantBuilder property_builder;
464@@ -335,29 +336,29 @@
465 }
466
467
468- _DbusMockIfaceOrgFreedesktopDBusMock * proxy = g_hash_table_lookup(mock->priv->object_proxies, object->object_path);
469+ _DbusMockIfaceOrgFreedesktopDBusMock * proxy = g_hash_table_lookup(priv->object_proxies, object->object_path);
470
471 if (proxy == NULL) {
472 g_debug("Add object (%s) on '%s'", object->interface, object->object_path);
473 gboolean add_object = _dbus_mock_iface_org_freedesktop_dbus_mock_call_add_object_sync(
474- mock->priv->proxy,
475+ priv->proxy,
476 object->object_path,
477 object->interface,
478 properties,
479 methods,
480- mock->priv->cancel,
481+ priv->cancel,
482 error);
483
484 if (add_object) {
485- proxy = _dbus_mock_iface_org_freedesktop_dbus_mock_proxy_new_sync(mock->priv->bus,
486+ proxy = _dbus_mock_iface_org_freedesktop_dbus_mock_proxy_new_sync(priv->bus,
487 G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
488- mock->priv->name,
489+ priv->name,
490 object->object_path, /* path */
491- mock->priv->cancel,
492+ priv->cancel,
493 error
494 );
495
496- g_hash_table_insert(mock->priv->object_proxies, g_strdup(object->object_path), proxy);
497+ g_hash_table_insert(priv->object_proxies, g_strdup(object->object_path), proxy);
498 }
499 } else {
500 gboolean methods_sent = FALSE;
501@@ -442,7 +443,9 @@
502 paramval = "--system"; g_array_append_val(params, paramval);
503 }
504
505- g_array_append_val(params, self->priv->name);
506+ DbusTestDbusMockPrivate *priv = dbus_test_dbus_mock_get_instance_private(self);
507+
508+ g_array_append_val(params, priv->name);
509 paramval = "/"; g_array_append_val(params, paramval);
510 paramval = "com.canonical.DbusTest.DbusMock"; g_array_append_val(params, paramval);
511
512@@ -456,12 +459,13 @@
513 {
514 GError * error = NULL;
515 DbusTestDbusMock * self = DBUS_TEST_DBUS_MOCK(task);
516+ DbusTestDbusMockPrivate *priv = dbus_test_dbus_mock_get_instance_private(self);
517
518 /* Grab the new bus */
519 if (dbus_test_task_get_bus(DBUS_TEST_TASK(self)) == DBUS_TEST_SERVICE_BUS_SYSTEM) {
520- self->priv->bus = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
521+ priv->bus = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
522 } else {
523- self->priv->bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, &error);
524+ priv->bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, &error);
525 }
526
527 if (error != NULL) {
528@@ -477,11 +481,11 @@
529 /**** Initialize the DBus Mock instance ****/
530
531 /* Zero, Setup the proxy */
532- self->priv->proxy = _dbus_mock_iface_org_freedesktop_dbus_mock_proxy_new_sync(self->priv->bus,
533+ priv->proxy = _dbus_mock_iface_org_freedesktop_dbus_mock_proxy_new_sync(priv->bus,
534 G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
535- self->priv->name,
536+ priv->name,
537 "/", /* path */
538- self->priv->cancel,
539+ priv->cancel,
540 &error
541 );
542
543@@ -492,21 +496,21 @@
544 }
545
546 /* First, Ensure we have a proxy */
547- gchar * owner = g_dbus_proxy_get_name_owner(G_DBUS_PROXY(self->priv->proxy));
548+ gchar * owner = g_dbus_proxy_get_name_owner(G_DBUS_PROXY(priv->proxy));
549 if (owner == NULL) {
550 g_debug("Waiting on name from DBusMock");
551 GMainLoop * mainloop = g_main_loop_new(NULL, FALSE);
552
553 guint timeout_sig = g_timeout_add_seconds(3, mock_start_check, mainloop);
554- gulong owner_sig = g_signal_connect(G_OBJECT(self->priv->proxy), "notify::g-name-owner", G_CALLBACK(got_name_owner), mainloop);
555+ gulong owner_sig = g_signal_connect(G_OBJECT(priv->proxy), "notify::g-name-owner", G_CALLBACK(got_name_owner), mainloop);
556
557 g_main_loop_run(mainloop);
558 g_main_loop_unref(mainloop);
559
560- g_signal_handler_disconnect(self->priv->proxy, owner_sig);
561+ g_signal_handler_disconnect(priv->proxy, owner_sig);
562 g_source_remove(timeout_sig);
563
564- owner = g_dbus_proxy_get_name_owner(G_DBUS_PROXY(self->priv->proxy));
565+ owner = g_dbus_proxy_get_name_owner(G_DBUS_PROXY(priv->proxy));
566 if (owner == NULL) {
567 g_critical("Unable to get DBusMock started within 3 seconds");
568 return;
569@@ -515,8 +519,8 @@
570 g_free(owner);
571
572 /* Second, Install Objects */
573- GList * lobj = self->priv->objects;
574- for (lobj = self->priv->objects; lobj != NULL; lobj = g_list_next(lobj)) {
575+ GList * lobj = priv->objects;
576+ for (lobj = priv->objects; lobj != NULL; lobj = g_list_next(lobj)) {
577 GError * error = NULL;
578
579 DbusTestDbusMockObject * obj = (DbusTestDbusMockObject *)lobj->data;
580@@ -574,9 +578,11 @@
581 g_return_val_if_fail(path != NULL, NULL);
582 g_return_val_if_fail(interface != NULL, NULL);
583
584+ DbusTestDbusMockPrivate *priv = dbus_test_dbus_mock_get_instance_private(mock);
585+
586 /* Check to see if we have that one */
587- GList * lobj = mock->priv->objects;
588- for (lobj = mock->priv->objects; lobj != NULL; lobj = g_list_next(lobj)) {
589+ GList * lobj = priv->objects;
590+ for (lobj = priv->objects; lobj != NULL; lobj = g_list_next(lobj)) {
591 DbusTestDbusMockObject * obj = (DbusTestDbusMockObject *)lobj->data;
592
593 if (g_strcmp0(path, obj->object_path) == 0 &&
594@@ -595,7 +601,7 @@
595 newobj->methods = g_array_new(FALSE, TRUE, sizeof(MockObjectMethod));
596 g_array_set_clear_func(newobj->methods, method_free);
597
598- mock->priv->objects = g_list_prepend(mock->priv->objects, newobj);
599+ priv->objects = g_list_prepend(priv->objects, newobj);
600
601 g_debug("Creating object: %s (%s)", newobj->object_path, newobj->interface);
602
603@@ -699,7 +705,9 @@
604 g_variant_ref_sink(in);
605 g_variant_ref_sink(out);
606
607- _DbusMockIfaceOrgFreedesktopDBusMock * proxy = g_hash_table_lookup(mock->priv->object_proxies, obj->object_path);
608+ DbusTestDbusMockPrivate *priv = dbus_test_dbus_mock_get_instance_private(mock);
609+
610+ _DbusMockIfaceOrgFreedesktopDBusMock * proxy = g_hash_table_lookup(priv->object_proxies, obj->object_path);
611 g_return_val_if_fail(proxy != NULL, FALSE); /* Should never happen */
612
613 gboolean ret = _dbus_mock_iface_org_freedesktop_dbus_mock_call_add_method_sync(
614@@ -709,7 +717,7 @@
615 g_variant_get_string(in, NULL),
616 g_variant_get_string(out, NULL),
617 python_code,
618- mock->priv->cancel,
619+ priv->cancel,
620 error
621 );
622
623@@ -796,12 +804,14 @@
624 return FALSE;
625 }
626
627- _DbusMockIfaceOrgFreedesktopDBusMock * proxy = g_hash_table_lookup(mock->priv->object_proxies, obj->object_path);
628+ DbusTestDbusMockPrivate *priv = dbus_test_dbus_mock_get_instance_private(mock);
629+
630+ _DbusMockIfaceOrgFreedesktopDBusMock * proxy = g_hash_table_lookup(priv->object_proxies, obj->object_path);
631 g_return_val_if_fail(proxy != NULL, FALSE); /* Should never happen */
632
633 return _dbus_mock_iface_org_freedesktop_dbus_mock_call_clear_calls_sync(
634 proxy,
635- mock->priv->cancel,
636+ priv->cancel,
637 error
638 );
639 }
640@@ -859,7 +869,9 @@
641 return NULL;
642 }
643
644- _DbusMockIfaceOrgFreedesktopDBusMock * proxy = g_hash_table_lookup(mock->priv->object_proxies, obj->object_path);
645+ DbusTestDbusMockPrivate *priv = dbus_test_dbus_mock_get_instance_private(mock);
646+
647+ _DbusMockIfaceOrgFreedesktopDBusMock * proxy = g_hash_table_lookup(priv->object_proxies, obj->object_path);
648 g_return_val_if_fail(proxy != NULL, FALSE); /* Should never happen */
649
650 /* Find our method */
651@@ -876,7 +888,7 @@
652 _dbus_mock_iface_org_freedesktop_dbus_mock_call_get_calls_sync(
653 proxy,
654 &call_list,
655- mock->priv->cancel,
656+ priv->cancel,
657 error);
658
659 if (call_list == NULL) {
660@@ -968,7 +980,9 @@
661 return TRUE;
662 }
663
664- _DbusMockIfaceOrgFreedesktopDBusMock * proxy = g_hash_table_lookup(mock->priv->object_proxies, obj->object_path);
665+ DbusTestDbusMockPrivate *priv = dbus_test_dbus_mock_get_instance_private(mock);
666+
667+ _DbusMockIfaceOrgFreedesktopDBusMock * proxy = g_hash_table_lookup(priv->object_proxies, obj->object_path);
668 g_return_val_if_fail(proxy != NULL, FALSE); /* Should never happen */
669
670 GVariantBuilder builder;
671@@ -984,7 +998,7 @@
672 proxy,
673 obj->interface,
674 g_variant_builder_end(&builder),
675- mock->priv->cancel,
676+ priv->cancel,
677 error
678 );
679 }
680@@ -1036,11 +1050,13 @@
681 return FALSE;
682 }
683
684+ DbusTestDbusMockPrivate *priv = dbus_test_dbus_mock_get_instance_private(mock);
685+
686 /* Send the update to Dbusmock */
687 if (is_running(mock)) {
688 GError * local_error = NULL;
689- g_dbus_connection_call_sync(mock->priv->bus,
690- mock->priv->name,
691+ g_dbus_connection_call_sync(priv->bus,
692+ priv->name,
693 obj->object_path,
694 "org.freedesktop.DBus.Properties",
695 "Set",
696@@ -1051,7 +1067,7 @@
697 NULL, /* return */
698 G_DBUS_CALL_FLAGS_NO_AUTO_START,
699 -1, /* timeout */
700- mock->priv->cancel,
701+ priv->cancel,
702 &local_error);
703
704 if (local_error != NULL) {
705@@ -1061,7 +1077,7 @@
706 return FALSE;
707 }
708
709- _DbusMockIfaceOrgFreedesktopDBusMock * proxy = g_hash_table_lookup(mock->priv->object_proxies, obj->object_path);
710+ _DbusMockIfaceOrgFreedesktopDBusMock * proxy = g_hash_table_lookup(priv->object_proxies, obj->object_path);
711 if (proxy != NULL) {
712 GVariantBuilder changed_builder;
713 g_variant_builder_init(&changed_builder, G_VARIANT_TYPE_ARRAY);
714@@ -1090,7 +1106,7 @@
715 "PropertiesChanged",
716 "sa{sv}as",
717 g_variant_builder_end(&changed_builder),
718- mock->priv->cancel,
719+ priv->cancel,
720 &local_error);
721
722 if (local_error != NULL) {
723@@ -1175,7 +1191,9 @@
724 return FALSE;
725 }
726
727- _DbusMockIfaceOrgFreedesktopDBusMock * proxy = g_hash_table_lookup(mock->priv->object_proxies, obj->object_path);
728+ DbusTestDbusMockPrivate *priv = dbus_test_dbus_mock_get_instance_private(mock);
729+
730+ _DbusMockIfaceOrgFreedesktopDBusMock * proxy = g_hash_table_lookup(priv->object_proxies, obj->object_path);
731 g_return_val_if_fail(proxy != NULL, FALSE); /* Should never happen */
732
733 /* floating ref swallowed by call_emit_signal() */
734@@ -1190,7 +1208,7 @@
735 name,
736 g_variant_get_string(sig_types, NULL),
737 sig_params,
738- mock->priv->cancel,
739+ priv->cancel,
740 error
741 );
742
743
744=== modified file 'libdbustest/dbus-mock.h'
745--- libdbustest/dbus-mock.h 2013-11-01 01:16:08 +0000
746+++ libdbustest/dbus-mock.h 2018-12-22 01:46:34 +0000
747@@ -38,7 +38,6 @@
748
749 typedef struct _DbusTestDbusMock DbusTestDbusMock;
750 typedef struct _DbusTestDbusMockClass DbusTestDbusMockClass;
751-typedef struct _DbusTestDbusMockPrivate DbusTestDbusMockPrivate;
752 typedef struct _DbusTestDbusMockObject DbusTestDbusMockObject;
753 typedef struct _DbusTestDbusMockCall DbusTestDbusMockCall;
754
755@@ -48,7 +47,6 @@
756
757 struct _DbusTestDbusMock {
758 DbusTestProcess parent;
759- DbusTestDbusMockPrivate * priv;
760 };
761
762 struct _DbusTestDbusMockCall {
763
764=== modified file 'libdbustest/process.c'
765--- libdbustest/process.c 2013-12-20 21:49:44 +0000
766+++ libdbustest/process.c 2018-12-22 01:46:34 +0000
767@@ -25,7 +25,7 @@
768
769 #include "glib-compat.h"
770
771-struct _DbusTestProcessPrivate {
772+typedef struct {
773 gchar * executable;
774 GArray * parameters;
775
776@@ -36,7 +36,7 @@
777
778 gboolean complete;
779 gint status;
780-};
781+} DbusTestProcessPrivate;
782
783 enum {
784 PROP_0,
785@@ -45,9 +45,6 @@
786 NUM_PROPS
787 };
788
789-#define DBUS_TEST_PROCESS_GET_PRIVATE(o) \
790-(G_TYPE_INSTANCE_GET_PRIVATE ((o), DBUS_TEST_TYPE_PROCESS, DbusTestProcessPrivate))
791-
792 static void dbus_test_process_class_init (DbusTestProcessClass *klass);
793 static void dbus_test_process_init (DbusTestProcess *self);
794 static void dbus_test_process_dispose (GObject *object);
795@@ -64,15 +61,13 @@
796 const GValue * value,
797 GParamSpec * pspec);
798
799-G_DEFINE_TYPE (DbusTestProcess, dbus_test_process, DBUS_TEST_TYPE_TASK);
800+G_DEFINE_TYPE_WITH_PRIVATE (DbusTestProcess, dbus_test_process, DBUS_TEST_TYPE_TASK);
801
802 static void
803 dbus_test_process_class_init (DbusTestProcessClass *klass)
804 {
805 GObjectClass *object_class = G_OBJECT_CLASS (klass);
806
807- g_type_class_add_private (klass, sizeof (DbusTestProcessPrivate));
808-
809 object_class->dispose = dbus_test_process_dispose;
810 object_class->finalize = dbus_test_process_finalize;
811 object_class->get_property = get_property;
812@@ -112,16 +107,16 @@
813 static void
814 dbus_test_process_init (DbusTestProcess *self)
815 {
816- self->priv = DBUS_TEST_PROCESS_GET_PRIVATE(self);
817-
818- self->priv->executable = NULL;
819-
820- self->priv->parameters = g_array_new(TRUE /* zero terminated */,
821- TRUE /* clear */,
822- sizeof(gchar *));
823- g_array_set_clear_func(self->priv->parameters, array_free_helper);
824-
825- self->priv->io_chan = NULL;
826+ DbusTestProcessPrivate *priv = dbus_test_process_get_instance_private(self);
827+
828+ priv->executable = NULL;
829+
830+ priv->parameters = g_array_new(TRUE /* zero terminated */,
831+ TRUE /* clear */,
832+ sizeof(gchar *));
833+ g_array_set_clear_func(priv->parameters, array_free_helper);
834+
835+ priv->io_chan = NULL;
836
837 return;
838 }
839@@ -131,34 +126,35 @@
840 {
841 g_return_if_fail(DBUS_TEST_IS_PROCESS(object));
842 DbusTestProcess * process = DBUS_TEST_PROCESS(object);
843-
844- if (process->priv->io_watch != 0) {
845- g_source_remove(process->priv->io_watch);
846- process->priv->io_watch = 0;
847- }
848-
849- if (process->priv->watcher != 0) {
850- g_source_remove(process->priv->watcher);
851- process->priv->watcher = 0;
852- }
853-
854- if (process->priv->pid != 0) {
855- gchar * killstr = g_strdup_printf("kill -9 %d", process->priv->pid);
856+ DbusTestProcessPrivate *priv = dbus_test_process_get_instance_private(process);
857+
858+ if (priv->io_watch != 0) {
859+ g_source_remove(priv->io_watch);
860+ priv->io_watch = 0;
861+ }
862+
863+ if (priv->watcher != 0) {
864+ g_source_remove(priv->watcher);
865+ priv->watcher = 0;
866+ }
867+
868+ if (priv->pid != 0) {
869+ gchar * killstr = g_strdup_printf("kill -9 %d", priv->pid);
870 g_spawn_command_line_async(killstr, NULL);
871 g_free(killstr);
872
873- g_spawn_close_pid(process->priv->pid);
874- process->priv->pid = 0;
875+ g_spawn_close_pid(priv->pid);
876+ priv->pid = 0;
877 }
878
879- if (process->priv->io_chan != NULL) {
880+ if (priv->io_chan != NULL) {
881 GIOStatus status = G_IO_STATUS_NORMAL;
882
883- while ((G_IO_IN & g_io_channel_get_buffer_condition(process->priv->io_chan)) && status == G_IO_STATUS_NORMAL) {
884+ while ((G_IO_IN & g_io_channel_get_buffer_condition(priv->io_chan)) && status == G_IO_STATUS_NORMAL) {
885 gchar * line = NULL;
886 gsize termloc;
887
888- status = g_io_channel_read_line (process->priv->io_chan, &line, NULL, &termloc, NULL);
889+ status = g_io_channel_read_line (priv->io_chan, &line, NULL, &termloc, NULL);
890
891 if (status != G_IO_STATUS_NORMAL) {
892 continue;
893@@ -169,7 +165,7 @@
894 g_free(line);
895 }
896
897- g_clear_pointer(&process->priv->io_chan, g_io_channel_unref);
898+ g_clear_pointer(&priv->io_chan, g_io_channel_unref);
899 }
900
901 G_OBJECT_CLASS (dbus_test_process_parent_class)->dispose (object);
902@@ -181,12 +177,13 @@
903 {
904 g_return_if_fail(DBUS_TEST_IS_PROCESS(object));
905 DbusTestProcess * process = DBUS_TEST_PROCESS(object);
906-
907- g_free(process->priv->executable);
908- process->priv->executable = NULL;
909-
910- g_array_free(process->priv->parameters, TRUE /* free segment */);
911- process->priv->parameters = NULL;
912+ DbusTestProcessPrivate *priv = dbus_test_process_get_instance_private(process);
913+
914+ g_free(priv->executable);
915+ priv->executable = NULL;
916+
917+ g_array_free(priv->parameters, TRUE /* free segment */);
918+ priv->parameters = NULL;
919
920 G_OBJECT_CLASS (dbus_test_process_parent_class)->finalize (object);
921 return;
922@@ -197,13 +194,14 @@
923 get_property (GObject * object, guint property_id, G_GNUC_UNUSED GValue * value, GParamSpec * pspec)
924 {
925 DbusTestProcess * self = DBUS_TEST_PROCESS(object);
926+ DbusTestProcessPrivate *priv = dbus_test_process_get_instance_private(self);
927
928 switch (property_id) {
929 case PROP_EXECUTABLE:
930- g_value_set_string(value, self->priv->executable);
931+ g_value_set_string(value, priv->executable);
932 break;
933 case PROP_PARAMETERS:
934- g_value_set_boxed(value, self->priv->parameters);
935+ g_value_set_boxed(value, priv->parameters);
936 break;
937 default:
938 G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
939@@ -222,15 +220,16 @@
940 }
941
942 DbusTestProcess * self = DBUS_TEST_PROCESS(object);
943+ DbusTestProcessPrivate *priv = dbus_test_process_get_instance_private(self);
944
945 switch (property_id) {
946 case PROP_EXECUTABLE:
947- g_free(self->priv->executable);
948- self->priv->executable = g_value_dup_string(value);
949+ g_free(priv->executable);
950+ priv->executable = g_value_dup_string(value);
951 break;
952 case PROP_PARAMETERS:
953- g_array_free(self->priv->parameters, TRUE);
954- self->priv->parameters = g_value_dup_boxed(value);
955+ g_array_free(priv->parameters, TRUE);
956+ priv->parameters = g_value_dup_boxed(value);
957 break;
958 default:
959 G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
960@@ -245,15 +244,16 @@
961 gchar *message;
962 g_return_if_fail(DBUS_TEST_IS_PROCESS(data));
963 DbusTestProcess * process = DBUS_TEST_PROCESS(data);
964+ DbusTestProcessPrivate *priv = dbus_test_process_get_instance_private(process);
965
966 if (pid != 0) {
967 g_spawn_close_pid(pid);
968- process->priv->pid = 0;
969+ priv->pid = 0;
970 }
971
972- process->priv->complete = TRUE;
973- process->priv->status = status;
974- process->priv->watcher = 0;
975+ priv->complete = TRUE;
976+ priv->status = status;
977+ priv->watcher = 0;
978
979 if (status) {
980 message = g_strdup_printf("Exited with status %d", status);
981@@ -271,6 +271,7 @@
982 {
983 g_return_val_if_fail(DBUS_TEST_IS_PROCESS(data), FALSE);
984 DbusTestProcess * process = DBUS_TEST_PROCESS(data);
985+ DbusTestProcessPrivate *priv = dbus_test_process_get_instance_private(process);
986
987 gchar * line;
988 gsize termloc;
989@@ -294,7 +295,7 @@
990 } while (G_IO_IN & g_io_channel_get_buffer_condition(channel));
991
992 if (done) {
993- process->priv->io_watch = 0;
994+ priv->io_watch = 0;
995 // wait for proc_watcher to switch state to FINISHED
996 return FALSE;
997 }
998@@ -307,16 +308,17 @@
999 {
1000 g_return_if_fail(DBUS_TEST_IS_PROCESS(task));
1001 DbusTestProcess * process = DBUS_TEST_PROCESS(task);
1002+ DbusTestProcessPrivate *priv = dbus_test_process_get_instance_private(process);
1003
1004 gchar * current_dir = g_get_current_dir();
1005
1006 gchar ** argv;
1007- argv = g_new0(gchar *, process->priv->parameters->len + 2);
1008+ argv = g_new0(gchar *, priv->parameters->len + 2);
1009
1010- argv[0] = process->priv->executable;
1011+ argv[0] = priv->executable;
1012 guint i;
1013- for (i = 0; i < process->priv->parameters->len; i++) {
1014- argv[i + 1] = g_array_index(process->priv->parameters, gchar *, i);
1015+ for (i = 0; i < priv->parameters->len; i++) {
1016+ argv[i + 1] = g_array_index(priv->parameters, gchar *, i);
1017 }
1018
1019 GError * error = NULL;
1020@@ -327,7 +329,7 @@
1021 G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD, /* flags */
1022 NULL, /* child setup func */
1023 NULL, /* child setup data */
1024- &(process->priv->pid), /* PID */
1025+ &(priv->pid), /* PID */
1026 NULL, /* stdin */
1027 &proc_stdout, /* stdout */
1028 NULL, /* stderr */
1029@@ -336,27 +338,27 @@
1030 g_free(argv);
1031
1032 if (error != NULL) {
1033- g_warning("Unable to start process '%s': %s", process->priv->executable, error->message);
1034- process->priv->complete = TRUE;
1035- process->priv->status = -1;
1036+ g_warning("Unable to start process '%s': %s", priv->executable, error->message);
1037+ priv->complete = TRUE;
1038+ priv->status = -1;
1039 g_signal_emit_by_name(G_OBJECT(process), DBUS_TEST_TASK_SIGNAL_STATE_CHANGED, DBUS_TEST_TASK_STATE_FINISHED, NULL);
1040 return;
1041 }
1042
1043 if (TRUE) {
1044- gchar * message = g_strdup_printf("Started with PID: %d", process->priv->pid);
1045+ gchar * message = g_strdup_printf("Started with PID: %d", priv->pid);
1046 dbus_test_task_print(task, message);
1047 g_free(message);
1048 }
1049
1050- process->priv->io_chan = g_io_channel_unix_new(proc_stdout);
1051- g_io_channel_set_buffer_size(process->priv->io_chan, 10 * 1024 * 1024); /* 10 MB should be enough for anyone */
1052- process->priv->io_watch = g_io_add_watch(process->priv->io_chan,
1053+ priv->io_chan = g_io_channel_unix_new(proc_stdout);
1054+ g_io_channel_set_buffer_size(priv->io_chan, 10 * 1024 * 1024); /* 10 MB should be enough for anyone */
1055+ priv->io_watch = g_io_add_watch(priv->io_chan,
1056 G_IO_IN | G_IO_HUP | G_IO_ERR, /* conditions */
1057 proc_writes, /* func */
1058 process); /* func data */
1059
1060- process->priv->watcher = g_child_watch_add(process->priv->pid, proc_watcher, process);
1061+ priv->watcher = g_child_watch_add(priv->pid, proc_watcher, process);
1062
1063 g_signal_emit_by_name(G_OBJECT(process), DBUS_TEST_TASK_SIGNAL_STATE_CHANGED, DBUS_TEST_TASK_STATE_RUNNING, NULL);
1064
1065@@ -387,9 +389,10 @@
1066 dbus_test_process_get_pid (DbusTestProcess * process)
1067 {
1068 g_return_val_if_fail(DBUS_TEST_IS_PROCESS(process), 0);
1069+ DbusTestProcessPrivate *priv = dbus_test_process_get_instance_private(process);
1070
1071 if (get_state(DBUS_TEST_TASK(process)) == DBUS_TEST_TASK_STATE_RUNNING) {
1072- return process->priv->pid;
1073+ return priv->pid;
1074 }
1075
1076 return 0;
1077@@ -401,8 +404,10 @@
1078 g_return_if_fail(DBUS_TEST_IS_PROCESS(process));
1079 g_return_if_fail(parameter != NULL);
1080
1081+ DbusTestProcessPrivate *priv = dbus_test_process_get_instance_private(process);
1082+
1083 gchar * newstr = g_strdup(parameter);
1084- g_array_append_val(process->priv->parameters, newstr);
1085+ g_array_append_val(priv->parameters, newstr);
1086
1087 return;
1088 }
1089@@ -412,12 +417,13 @@
1090 {
1091 g_return_val_if_fail(DBUS_TEST_IS_PROCESS(task), DBUS_TEST_TASK_STATE_FINISHED);
1092 DbusTestProcess * process = DBUS_TEST_PROCESS(task);
1093+ DbusTestProcessPrivate *priv = dbus_test_process_get_instance_private(process);
1094
1095- if (process->priv->complete) {
1096+ if (priv->complete) {
1097 return DBUS_TEST_TASK_STATE_FINISHED;
1098 }
1099
1100- if (process->priv->pid != 0) {
1101+ if (priv->pid != 0) {
1102 return DBUS_TEST_TASK_STATE_RUNNING;
1103 }
1104
1105@@ -429,12 +435,13 @@
1106 {
1107 g_return_val_if_fail(DBUS_TEST_IS_PROCESS(task), FALSE);
1108 DbusTestProcess * process = DBUS_TEST_PROCESS(task);
1109+ DbusTestProcessPrivate *priv = dbus_test_process_get_instance_private(process);
1110
1111- if (!process->priv->complete) {
1112+ if (!priv->complete) {
1113 return FALSE;
1114 }
1115
1116- if (process->priv->status == 0) {
1117+ if (priv->status == 0) {
1118 return TRUE;
1119 }
1120
1121
1122=== modified file 'libdbustest/process.h'
1123--- libdbustest/process.h 2013-10-23 15:38:31 +0000
1124+++ libdbustest/process.h 2018-12-22 01:46:34 +0000
1125@@ -35,7 +35,6 @@
1126
1127 typedef struct _DbusTestProcess DbusTestProcess;
1128 typedef struct _DbusTestProcessClass DbusTestProcessClass;
1129-typedef struct _DbusTestProcessPrivate DbusTestProcessPrivate;
1130
1131 struct _DbusTestProcessClass {
1132 DbusTestTaskClass parent_class;
1133@@ -43,7 +42,6 @@
1134
1135 struct _DbusTestProcess {
1136 DbusTestTask parent;
1137- DbusTestProcessPrivate * priv;
1138 };
1139
1140 GType dbus_test_process_get_type (void);
1141
1142=== modified file 'libdbustest/service.c'
1143--- libdbustest/service.c 2015-02-13 17:19:17 +0000
1144+++ libdbustest/service.c 2018-12-22 01:46:34 +0000
1145@@ -43,7 +43,7 @@
1146 STATE_FINISHED
1147 };
1148
1149-struct _DbusTestServicePrivate {
1150+typedef struct {
1151 GQueue tasks_first;
1152 GQueue tasks_normal;
1153 GQueue tasks_last;
1154@@ -67,28 +67,23 @@
1155 guint watchdog_source;
1156
1157 DbusTestServiceBus bus_type;
1158-};
1159+} DbusTestServicePrivate;
1160
1161 #define SERVICE_CHANGE_HANDLER "dbus-test-service-change-handler"
1162
1163-#define DBUS_TEST_SERVICE_GET_PRIVATE(o) \
1164-(G_TYPE_INSTANCE_GET_PRIVATE ((o), DBUS_TEST_TYPE_SERVICE, DbusTestServicePrivate))
1165-
1166 static void dbus_test_service_class_init (DbusTestServiceClass *klass);
1167 static void dbus_test_service_init (DbusTestService *self);
1168 static void dbus_test_service_dispose (GObject *object);
1169 static void dbus_test_service_finalize (GObject *object);
1170 static gboolean watchdog_ping (gpointer user_data);
1171
1172-G_DEFINE_TYPE (DbusTestService, dbus_test_service, G_TYPE_OBJECT);
1173+G_DEFINE_TYPE_WITH_PRIVATE (DbusTestService, dbus_test_service, G_TYPE_OBJECT);
1174
1175 static void
1176 dbus_test_service_class_init (DbusTestServiceClass *klass)
1177 {
1178 GObjectClass *object_class = G_OBJECT_CLASS (klass);
1179
1180- g_type_class_add_private (klass, sizeof (DbusTestServicePrivate));
1181-
1182 object_class->dispose = dbus_test_service_dispose;
1183 object_class->finalize = dbus_test_service_finalize;
1184
1185@@ -98,35 +93,35 @@
1186 static void
1187 dbus_test_service_init (DbusTestService *self)
1188 {
1189- self->priv = DBUS_TEST_SERVICE_GET_PRIVATE(self);
1190-
1191- g_queue_init(&self->priv->tasks_first);
1192- g_queue_init(&self->priv->tasks_normal);
1193- g_queue_init(&self->priv->tasks_last);
1194-
1195- self->priv->mainloop = g_main_loop_new(NULL, FALSE);
1196- self->priv->state = STATE_INIT;
1197-
1198- self->priv->daemon_crashed = FALSE;
1199-
1200- self->priv->dbus = 0;
1201- self->priv->dbus_watch = 0;
1202- self->priv->dbus_io = NULL;
1203- self->priv->dbus_io_watch = 0;
1204- self->priv->dbus_daemon = g_strdup("dbus-daemon");
1205- self->priv->dbus_configfile = g_strdup(DEFAULT_SESSION_CONF);
1206-
1207- self->priv->first_time = TRUE;
1208- self->priv->keep_env = FALSE;
1209-
1210- self->priv->watchdog = g_object_new(DBUS_TEST_TYPE_WATCHDOG, NULL);
1211- self->priv->watchdog_source = g_timeout_add_seconds_full(G_PRIORITY_DEFAULT,
1212+ DbusTestServicePrivate *priv = dbus_test_service_get_instance_private(self);
1213+
1214+ g_queue_init(&priv->tasks_first);
1215+ g_queue_init(&priv->tasks_normal);
1216+ g_queue_init(&priv->tasks_last);
1217+
1218+ priv->mainloop = g_main_loop_new(NULL, FALSE);
1219+ priv->state = STATE_INIT;
1220+
1221+ priv->daemon_crashed = FALSE;
1222+
1223+ priv->dbus = 0;
1224+ priv->dbus_watch = 0;
1225+ priv->dbus_io = NULL;
1226+ priv->dbus_io_watch = 0;
1227+ priv->dbus_daemon = g_strdup("dbus-daemon");
1228+ priv->dbus_configfile = g_strdup(DEFAULT_SESSION_CONF);
1229+
1230+ priv->first_time = TRUE;
1231+ priv->keep_env = FALSE;
1232+
1233+ priv->watchdog = g_object_new(DBUS_TEST_TYPE_WATCHDOG, NULL);
1234+ priv->watchdog_source = g_timeout_add_seconds_full(G_PRIORITY_DEFAULT,
1235 5,
1236 watchdog_ping,
1237- g_object_ref(self->priv->watchdog),
1238+ g_object_ref(priv->watchdog),
1239 g_object_unref);
1240
1241- self->priv->bus_type = DBUS_TEST_SERVICE_BUS_SESSION;
1242+ priv->bus_type = DBUS_TEST_SERVICE_BUS_SESSION;
1243
1244 return;
1245 }
1246@@ -150,58 +145,59 @@
1247 {
1248 g_return_if_fail(DBUS_TEST_IS_SERVICE(object));
1249 DbusTestService * self = DBUS_TEST_SERVICE(object);
1250-
1251- if (!g_queue_is_empty(&self->priv->tasks_last)) {
1252- g_queue_foreach(&self->priv->tasks_last, task_unref, NULL);
1253- g_queue_clear(&self->priv->tasks_last);
1254- }
1255-
1256- if (!g_queue_is_empty(&self->priv->tasks_normal)) {
1257- g_queue_foreach(&self->priv->tasks_normal, task_unref, NULL);
1258- g_queue_clear(&self->priv->tasks_normal);
1259- }
1260-
1261- if (!g_queue_is_empty(&self->priv->tasks_first)) {
1262- g_queue_foreach(&self->priv->tasks_first, task_unref, NULL);
1263- g_queue_clear(&self->priv->tasks_first);
1264- }
1265-
1266- if (self->priv->dbus_watch != 0) {
1267- g_source_remove(self->priv->dbus_watch);
1268- self->priv->dbus_watch = 0;
1269- }
1270-
1271- if (self->priv->dbus_io_watch != 0) {
1272- g_source_remove(self->priv->dbus_io_watch);
1273- self->priv->dbus_io_watch = 0;
1274- }
1275-
1276- if (self->priv->dbus_io != NULL) {
1277- g_io_channel_shutdown(self->priv->dbus_io, TRUE, NULL);
1278- g_io_channel_unref(self->priv->dbus_io);
1279- self->priv->dbus_io = NULL;
1280+ DbusTestServicePrivate *priv = dbus_test_service_get_instance_private(self);
1281+
1282+ if (!g_queue_is_empty(&priv->tasks_last)) {
1283+ g_queue_foreach(&priv->tasks_last, task_unref, NULL);
1284+ g_queue_clear(&priv->tasks_last);
1285+ }
1286+
1287+ if (!g_queue_is_empty(&priv->tasks_normal)) {
1288+ g_queue_foreach(&priv->tasks_normal, task_unref, NULL);
1289+ g_queue_clear(&priv->tasks_normal);
1290+ }
1291+
1292+ if (!g_queue_is_empty(&priv->tasks_first)) {
1293+ g_queue_foreach(&priv->tasks_first, task_unref, NULL);
1294+ g_queue_clear(&priv->tasks_first);
1295+ }
1296+
1297+ if (priv->dbus_watch != 0) {
1298+ g_source_remove(priv->dbus_watch);
1299+ priv->dbus_watch = 0;
1300+ }
1301+
1302+ if (priv->dbus_io_watch != 0) {
1303+ g_source_remove(priv->dbus_io_watch);
1304+ priv->dbus_io_watch = 0;
1305+ }
1306+
1307+ if (priv->dbus_io != NULL) {
1308+ g_io_channel_shutdown(priv->dbus_io, TRUE, NULL);
1309+ g_io_channel_unref(priv->dbus_io);
1310+ priv->dbus_io = NULL;
1311 }
1312
1313 g_print("DBus daemon: Shutdown\n");
1314- if (self->priv->dbus != 0) {
1315- gchar * cmd = g_strdup_printf("kill -9 %d", self->priv->dbus);
1316+ if (priv->dbus != 0) {
1317+ gchar * cmd = g_strdup_printf("kill -9 %d", priv->dbus);
1318 g_spawn_command_line_async(cmd, NULL);
1319 g_free(cmd);
1320
1321- g_spawn_close_pid(self->priv->dbus);
1322- self->priv->dbus = 0;
1323- }
1324-
1325- if (self->priv->mainloop != NULL) {
1326- g_main_loop_unref(self->priv->mainloop);
1327- self->priv->mainloop = NULL;
1328- }
1329-
1330- g_clear_object(&self->priv->watchdog);
1331-
1332- if (self->priv->watchdog_source != 0) {
1333- g_source_remove(self->priv->watchdog_source);
1334- self->priv->watchdog_source = 0;
1335+ g_spawn_close_pid(priv->dbus);
1336+ priv->dbus = 0;
1337+ }
1338+
1339+ if (priv->mainloop != NULL) {
1340+ g_main_loop_unref(priv->mainloop);
1341+ priv->mainloop = NULL;
1342+ }
1343+
1344+ g_clear_object(&priv->watchdog);
1345+
1346+ if (priv->watchdog_source != 0) {
1347+ g_source_remove(priv->watchdog_source);
1348+ priv->watchdog_source = 0;
1349 }
1350
1351 G_OBJECT_CLASS (dbus_test_service_parent_class)->dispose (object);
1352@@ -213,11 +209,12 @@
1353 {
1354 g_return_if_fail(DBUS_TEST_IS_SERVICE(object));
1355 DbusTestService * self = DBUS_TEST_SERVICE(object);
1356+ DbusTestServicePrivate *priv = dbus_test_service_get_instance_private(self);
1357
1358- g_free(self->priv->dbus_daemon);
1359- self->priv->dbus_daemon = NULL;
1360- g_free(self->priv->dbus_configfile);
1361- self->priv->dbus_configfile = NULL;
1362+ g_free(priv->dbus_daemon);
1363+ priv->dbus_daemon = NULL;
1364+ g_free(priv->dbus_configfile);
1365+ priv->dbus_configfile = NULL;
1366
1367 G_OBJECT_CLASS (dbus_test_service_parent_class)->finalize (object);
1368 return;
1369@@ -273,9 +270,11 @@
1370 static gboolean
1371 all_tasks_bus_match (DbusTestService * service, DbusTestTask * task, G_GNUC_UNUSED gpointer user_data)
1372 {
1373- return service->priv->bus_type == DBUS_TEST_SERVICE_BUS_BOTH ||
1374+ DbusTestServicePrivate *priv = dbus_test_service_get_instance_private(service);
1375+
1376+ return priv->bus_type == DBUS_TEST_SERVICE_BUS_BOTH ||
1377 dbus_test_task_get_bus(task) == DBUS_TEST_SERVICE_BUS_BOTH ||
1378- dbus_test_task_get_bus(task) == service->priv->bus_type;
1379+ dbus_test_task_get_bus(task) == priv->bus_type;
1380 }
1381
1382 typedef struct {
1383@@ -301,6 +300,8 @@
1384 static gboolean
1385 all_tasks (DbusTestService * service, gboolean (*helper) (DbusTestService * service, DbusTestTask * task, gpointer user_data), gpointer user_data)
1386 {
1387+ DbusTestServicePrivate *priv = dbus_test_service_get_instance_private(service);
1388+
1389 all_tasks_helper_data_t data = {
1390 .passing = TRUE,
1391 .service = service,
1392@@ -308,17 +309,17 @@
1393 .user_data = user_data
1394 };
1395
1396- g_queue_foreach(&service->priv->tasks_first, all_tasks_helper, &data);
1397- if (!data.passing) {
1398- return FALSE;
1399- }
1400-
1401- g_queue_foreach(&service->priv->tasks_normal, all_tasks_helper, &data);
1402- if (!data.passing) {
1403- return FALSE;
1404- }
1405-
1406- g_queue_foreach(&service->priv->tasks_last, all_tasks_helper, &data);
1407+ g_queue_foreach(&priv->tasks_first, all_tasks_helper, &data);
1408+ if (!data.passing) {
1409+ return FALSE;
1410+ }
1411+
1412+ g_queue_foreach(&priv->tasks_normal, all_tasks_helper, &data);
1413+ if (!data.passing) {
1414+ return FALSE;
1415+ }
1416+
1417+ g_queue_foreach(&priv->tasks_last, all_tasks_helper, &data);
1418 if (!data.passing) {
1419 return FALSE;
1420 }
1421@@ -356,13 +357,15 @@
1422 {
1423 glong length = 0;
1424
1425- g_queue_foreach(&service->priv->tasks_first, task_get_name_length, &length);
1426- g_queue_foreach(&service->priv->tasks_normal, task_get_name_length, &length);
1427- g_queue_foreach(&service->priv->tasks_last, task_get_name_length, &length);
1428-
1429- g_queue_foreach(&service->priv->tasks_first, task_set_name_length, &length);
1430- g_queue_foreach(&service->priv->tasks_normal, task_set_name_length, &length);
1431- g_queue_foreach(&service->priv->tasks_last, task_set_name_length, &length);
1432+ DbusTestServicePrivate *priv = dbus_test_service_get_instance_private(service);
1433+
1434+ g_queue_foreach(&priv->tasks_first, task_get_name_length, &length);
1435+ g_queue_foreach(&priv->tasks_normal, task_get_name_length, &length);
1436+ g_queue_foreach(&priv->tasks_last, task_get_name_length, &length);
1437+
1438+ g_queue_foreach(&priv->tasks_first, task_set_name_length, &length);
1439+ g_queue_foreach(&priv->tasks_normal, task_set_name_length, &length);
1440+ g_queue_foreach(&priv->tasks_last, task_set_name_length, &length);
1441
1442 return;
1443 }
1444@@ -381,6 +384,7 @@
1445 dbus_writes (GIOChannel * channel, GIOCondition condition, gpointer data)
1446 {
1447 DbusTestService * service = DBUS_TEST_SERVICE(data);
1448+ DbusTestServicePrivate *priv = dbus_test_service_get_instance_private(service);
1449
1450 if (condition & G_IO_ERR) {
1451 g_critical("DBus writing failure!");
1452@@ -395,12 +399,12 @@
1453
1454 g_print("DBus daemon: %s\n", line);
1455
1456- if (service->priv->first_time) {
1457- service->priv->first_time = FALSE;
1458+ if (priv->first_time) {
1459+ priv->first_time = FALSE;
1460
1461 g_setenv("DBUS_STARTER_ADDRESS", line, TRUE);
1462
1463- switch (service->priv->bus_type) {
1464+ switch (priv->bus_type) {
1465 case DBUS_TEST_SERVICE_BUS_SESSION:
1466 g_setenv("DBUS_SESSION_BUS_ADDRESS", line, TRUE);
1467 g_setenv("DBUS_STARTER_BUS_TYPE", "session", TRUE);
1468@@ -416,8 +420,8 @@
1469 break;
1470 }
1471
1472- if (service->priv->state == STATE_DAEMON_STARTING) {
1473- g_main_loop_quit(service->priv->mainloop);
1474+ if (priv->state == STATE_DAEMON_STARTING) {
1475+ g_main_loop_quit(priv->mainloop);
1476 }
1477 }
1478
1479@@ -430,10 +434,12 @@
1480 dbus_watcher (GPid pid, G_GNUC_UNUSED gint status, gpointer data)
1481 {
1482 DbusTestService * service = DBUS_TEST_SERVICE(data);
1483+ DbusTestServicePrivate *priv = dbus_test_service_get_instance_private(service);
1484+
1485 g_critical("DBus Daemon exited abruptly!");
1486
1487- service->priv->daemon_crashed = TRUE;
1488- g_main_loop_quit(DBUS_TEST_SERVICE(data)->priv->mainloop);
1489+ priv->daemon_crashed = TRUE;
1490+ g_main_loop_quit(priv->mainloop);
1491
1492 if (pid != 0) {
1493 g_spawn_close_pid(pid);
1494@@ -451,24 +457,26 @@
1495 static void
1496 start_daemon (DbusTestService * service)
1497 {
1498- if (service->priv->dbus != 0) {
1499+ DbusTestServicePrivate *priv = dbus_test_service_get_instance_private(service);
1500+
1501+ if (priv->dbus != 0) {
1502 return;
1503 }
1504
1505- service->priv->state = STATE_DAEMON_STARTING;
1506+ priv->state = STATE_DAEMON_STARTING;
1507
1508 gint dbus_stdout = 0;
1509 GError * error = NULL;
1510 gchar * blank[1] = {NULL};
1511 gchar * current_dir = g_get_current_dir();
1512- gchar * dbus_startup[] = {service->priv->dbus_daemon, "--config-file", service->priv->dbus_configfile, "--print-address", NULL};
1513+ gchar * dbus_startup[] = {priv->dbus_daemon, "--config-file", priv->dbus_configfile, "--print-address", NULL};
1514 g_spawn_async_with_pipes(current_dir,
1515 dbus_startup, /* argv */
1516- service->priv->keep_env ? NULL : blank, /* envp */
1517+ priv->keep_env ? NULL : blank, /* envp */
1518 G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD, /* flags */
1519 (GSpawnChildSetupFunc) dbus_child_setup, /* child setup func */
1520 NULL, /* child setup data */
1521- &service->priv->dbus, /* PID */
1522+ &priv->dbus, /* PID */
1523 NULL, /* stdin */
1524 &dbus_stdout, /* stdout */
1525 NULL, /* stderr */
1526@@ -479,25 +487,25 @@
1527 if (error != NULL) {
1528 g_critical("Unable to start dbus daemon: %s", error->message);
1529 g_error_free(error);
1530- service->priv->daemon_crashed = TRUE;
1531+ priv->daemon_crashed = TRUE;
1532 return;
1533 }
1534
1535- dbus_test_watchdog_add_pid(service->priv->watchdog, service->priv->dbus);
1536-
1537- service->priv->dbus_watch = g_child_watch_add(service->priv->dbus, dbus_watcher, service);
1538-
1539- service->priv->dbus_io = g_io_channel_unix_new(dbus_stdout);
1540- service->priv->dbus_io_watch = g_io_add_watch(service->priv->dbus_io,
1541+ dbus_test_watchdog_add_pid(priv->watchdog, priv->dbus);
1542+
1543+ priv->dbus_watch = g_child_watch_add(priv->dbus, dbus_watcher, service);
1544+
1545+ priv->dbus_io = g_io_channel_unix_new(dbus_stdout);
1546+ priv->dbus_io_watch = g_io_add_watch(priv->dbus_io,
1547 G_IO_IN | G_IO_HUP | G_IO_ERR, /* conditions */
1548 dbus_writes, /* func */
1549 service); /* func data */
1550
1551- g_main_loop_run(service->priv->mainloop);
1552+ g_main_loop_run(priv->mainloop);
1553
1554 /* we should have a usable connection now, let's check */
1555 const gchar * bus_address = NULL;
1556- if (service->priv->bus_type == DBUS_TEST_SERVICE_BUS_SYSTEM) {
1557+ if (priv->bus_type == DBUS_TEST_SERVICE_BUS_SYSTEM) {
1558 bus_address = g_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1559 } else {
1560 bus_address = g_getenv("DBUS_SESSION_BUS_ADDRESS");
1561@@ -516,13 +524,13 @@
1562 g_strfreev(tokens);
1563
1564 if (!is_valid) {
1565- service->priv->state = STATE_DAEMON_FAILED;
1566+ priv->state = STATE_DAEMON_FAILED;
1567 g_critical ("DBus daemon failed: Bus address is not supported");
1568 g_error_free (error);
1569 return;
1570 }
1571
1572- service->priv->state = STATE_DAEMON_STARTED;
1573+ priv->state = STATE_DAEMON_STARTED;
1574 return;
1575 }
1576
1577@@ -532,43 +540,45 @@
1578 g_return_if_fail(DBUS_TEST_SERVICE(service));
1579 g_return_if_fail(all_tasks(service, all_tasks_bus_match, NULL));
1580
1581+ DbusTestServicePrivate *priv = dbus_test_service_get_instance_private(service);
1582+
1583 start_daemon(service);
1584 g_return_if_fail(g_getenv("DBUS_SESSION_BUS_ADDRESS") != NULL ||
1585 g_getenv("DBUS_SYSTEM_BUS_ADDRESS") != NULL);
1586- g_return_if_fail(service->priv->state != STATE_DAEMON_FAILED);
1587+ g_return_if_fail(priv->state != STATE_DAEMON_FAILED);
1588
1589 if (all_tasks(service, all_tasks_started_helper, NULL)) {
1590 /* If we have all started we can mark it as such as long
1591 as we understand where we could hit this case */
1592- if (service->priv->state == STATE_INIT || service->priv->state == STATE_DAEMON_STARTED) {
1593- service->priv->state = STATE_STARTED;
1594+ if (priv->state == STATE_INIT || priv->state == STATE_DAEMON_STARTED) {
1595+ priv->state = STATE_STARTED;
1596 }
1597 return;
1598 }
1599
1600 normalize_name_lengths(service);
1601
1602- g_queue_foreach(&service->priv->tasks_first, task_starter, NULL);
1603- if (!g_queue_is_empty(&service->priv->tasks_first)) {
1604- g_usleep(100000);
1605- }
1606-
1607- g_queue_foreach(&service->priv->tasks_normal, task_starter, NULL);
1608-
1609- if (!g_queue_is_empty(&service->priv->tasks_last)) {
1610- g_usleep(100000);
1611- }
1612- g_queue_foreach(&service->priv->tasks_last, task_starter, NULL);
1613+ g_queue_foreach(&priv->tasks_first, task_starter, NULL);
1614+ if (!g_queue_is_empty(&priv->tasks_first)) {
1615+ g_usleep(100000);
1616+ }
1617+
1618+ g_queue_foreach(&priv->tasks_normal, task_starter, NULL);
1619+
1620+ if (!g_queue_is_empty(&priv->tasks_last)) {
1621+ g_usleep(100000);
1622+ }
1623+ g_queue_foreach(&priv->tasks_last, task_starter, NULL);
1624
1625 if (!all_tasks(service, all_tasks_started_helper, NULL)) {
1626- service->priv->state = STATE_STARTING;
1627- g_main_loop_run(service->priv->mainloop);
1628+ priv->state = STATE_STARTING;
1629+ g_main_loop_run(priv->mainloop);
1630
1631 /* This should never happen, but let's be sure */
1632 g_return_if_fail(all_tasks(service, all_tasks_started_helper, NULL));
1633 }
1634
1635- service->priv->state = STATE_STARTED;
1636+ priv->state = STATE_STARTED;
1637
1638 return;
1639 }
1640@@ -582,7 +592,9 @@
1641 static int
1642 get_status (DbusTestService * service)
1643 {
1644- if (service->priv->daemon_crashed || service->priv->state == STATE_DAEMON_FAILED) {
1645+ DbusTestServicePrivate *priv = dbus_test_service_get_instance_private(service);
1646+
1647+ if (priv->daemon_crashed || priv->state == STATE_DAEMON_FAILED) {
1648 return -1;
1649 }
1650
1651@@ -597,20 +609,21 @@
1652 dbus_test_service_run (DbusTestService * service)
1653 {
1654 g_return_val_if_fail(DBUS_TEST_SERVICE(service), -1);
1655+ DbusTestServicePrivate *priv = dbus_test_service_get_instance_private(service);
1656
1657 dbus_test_service_start_tasks(service);
1658- g_return_val_if_fail(service->priv->state == STATE_STARTED, get_status(service));
1659+ g_return_val_if_fail(priv->state == STATE_STARTED, get_status(service));
1660
1661 if (all_tasks(service, all_tasks_finished_helper, NULL)) {
1662 return get_status(service);
1663 }
1664
1665- service->priv->state = STATE_RUNNING;
1666- g_main_loop_run(service->priv->mainloop);
1667+ priv->state = STATE_RUNNING;
1668+ g_main_loop_run(priv->mainloop);
1669
1670 /* This should never happen, but let's be sure */
1671 g_return_val_if_fail(all_tasks(service, all_tasks_finished_helper, NULL), -1);
1672- service->priv->state = STATE_FINISHED;
1673+ priv->state = STATE_FINISHED;
1674
1675 return get_status(service);
1676 }
1677@@ -620,14 +633,15 @@
1678 {
1679 g_return_if_fail(DBUS_TEST_IS_SERVICE(user_data));
1680 DbusTestService * service = DBUS_TEST_SERVICE(user_data);
1681+ DbusTestServicePrivate *priv = dbus_test_service_get_instance_private(service);
1682
1683- if (service->priv->state == STATE_STARTING && all_tasks(service, all_tasks_started_helper, NULL)) {
1684- g_main_loop_quit(service->priv->mainloop);
1685+ if (priv->state == STATE_STARTING && all_tasks(service, all_tasks_started_helper, NULL)) {
1686+ g_main_loop_quit(priv->mainloop);
1687 return;
1688 }
1689
1690- if (service->priv->state == STATE_RUNNING && all_tasks(service, all_tasks_finished_helper, NULL)) {
1691- g_main_loop_quit(service->priv->mainloop);
1692+ if (priv->state == STATE_RUNNING && all_tasks(service, all_tasks_finished_helper, NULL)) {
1693+ g_main_loop_quit(priv->mainloop);
1694 return;
1695 }
1696
1697@@ -650,17 +664,19 @@
1698 goals for busness. Fail early. */
1699 g_return_if_fail(all_tasks_bus_match(service, task, NULL));
1700
1701+ DbusTestServicePrivate *priv = dbus_test_service_get_instance_private(service);
1702+
1703 GQueue * queue = NULL;
1704
1705 switch (prio) {
1706 case DBUS_TEST_SERVICE_PRIORITY_FIRST:
1707- queue = &service->priv->tasks_first;
1708+ queue = &priv->tasks_first;
1709 break;
1710 case DBUS_TEST_SERVICE_PRIORITY_NORMAL:
1711- queue = &service->priv->tasks_normal;
1712+ queue = &priv->tasks_normal;
1713 break;
1714 case DBUS_TEST_SERVICE_PRIORITY_LAST:
1715- queue = &service->priv->tasks_last;
1716+ queue = &priv->tasks_last;
1717 break;
1718 default:
1719 g_assert_not_reached();
1720@@ -690,10 +706,12 @@
1721 g_return_val_if_fail(DBUS_TEST_IS_SERVICE(service), FALSE);
1722 g_return_val_if_fail(DBUS_TEST_IS_TASK(task), FALSE);
1723
1724+ DbusTestServicePrivate *priv = dbus_test_service_get_instance_private(service);
1725+
1726 guint count = 0;
1727- count += g_queue_remove_all(&service->priv->tasks_first, task);
1728- count += g_queue_remove_all(&service->priv->tasks_normal, task);
1729- count += g_queue_remove_all(&service->priv->tasks_last, task);
1730+ count += g_queue_remove_all(&priv->tasks_first, task);
1731+ count += g_queue_remove_all(&priv->tasks_normal, task);
1732+ count += g_queue_remove_all(&priv->tasks_last, task);
1733
1734 /* Checking the count here so that we can generate a warning. Guessing that
1735 this actually never happens, but it's easy to check */
1736@@ -718,8 +736,11 @@
1737 dbus_test_service_set_daemon (DbusTestService * service, const gchar * daemon)
1738 {
1739 g_return_if_fail(DBUS_TEST_IS_SERVICE(service));
1740- g_free(service->priv->dbus_daemon);
1741- service->priv->dbus_daemon = g_strdup(daemon);
1742+
1743+ DbusTestServicePrivate *priv = dbus_test_service_get_instance_private(service);
1744+
1745+ g_free(priv->dbus_daemon);
1746+ priv->dbus_daemon = g_strdup(daemon);
1747 return;
1748 }
1749
1750@@ -727,8 +748,11 @@
1751 dbus_test_service_set_conf_file (DbusTestService * service, const gchar * conffile)
1752 {
1753 g_return_if_fail(DBUS_TEST_IS_SERVICE(service));
1754- g_free(service->priv->dbus_configfile);
1755- service->priv->dbus_configfile = g_strdup(conffile);
1756+
1757+ DbusTestServicePrivate *priv = dbus_test_service_get_instance_private(service);
1758+
1759+ g_free(priv->dbus_configfile);
1760+ priv->dbus_configfile = g_strdup(conffile);
1761 return;
1762 }
1763
1764@@ -736,35 +760,44 @@
1765 dbus_test_service_set_keep_environment (DbusTestService * service, gboolean keep_env)
1766 {
1767 g_return_if_fail(DBUS_TEST_IS_SERVICE(service));
1768- service->priv->keep_env = keep_env;
1769+
1770+ DbusTestServicePrivate *priv = dbus_test_service_get_instance_private(service);
1771+
1772+ priv->keep_env = keep_env;
1773 }
1774
1775 void
1776 dbus_test_service_stop (DbusTestService * service)
1777 {
1778 g_return_if_fail(DBUS_TEST_IS_SERVICE(service));
1779- g_main_loop_quit(service->priv->mainloop);
1780+
1781+ DbusTestServicePrivate *priv = dbus_test_service_get_instance_private(service);
1782+
1783+ g_main_loop_quit(priv->mainloop);
1784 return;
1785 }
1786
1787 void dbus_test_service_set_bus (DbusTestService * service, DbusTestServiceBus bus)
1788 {
1789 g_return_if_fail(DBUS_TEST_IS_SERVICE(service));
1790- g_return_if_fail(service->priv->dbus == 0); /* we can't change after we're running */
1791+
1792+ DbusTestServicePrivate *priv = dbus_test_service_get_instance_private(service);
1793+
1794+ g_return_if_fail(priv->dbus == 0); /* we can't change after we're running */
1795
1796 if (bus == DBUS_TEST_SERVICE_BUS_BOTH) {
1797 g_warning("Setting bus to BOTH, which is typically only used as a default value.");
1798 }
1799
1800- service->priv->bus_type = bus;
1801+ priv->bus_type = bus;
1802 g_warn_if_fail(all_tasks(service, all_tasks_bus_match, NULL));
1803
1804 if (bus == DBUS_TEST_SERVICE_BUS_SYSTEM) {
1805- g_free(service->priv->dbus_configfile);
1806- service->priv->dbus_configfile = g_strdup(DEFAULT_SYSTEM_CONF);
1807+ g_free(priv->dbus_configfile);
1808+ priv->dbus_configfile = g_strdup(DEFAULT_SYSTEM_CONF);
1809 } else {
1810 /* BOTH and SESSION get the session config — for backwards compatibility there */
1811- g_free(service->priv->dbus_configfile);
1812- service->priv->dbus_configfile = g_strdup(DEFAULT_SESSION_CONF);
1813+ g_free(priv->dbus_configfile);
1814+ priv->dbus_configfile = g_strdup(DEFAULT_SESSION_CONF);
1815 }
1816 }
1817
1818=== modified file 'libdbustest/service.h'
1819--- libdbustest/service.h 2015-02-13 17:19:17 +0000
1820+++ libdbustest/service.h 2018-12-22 01:46:34 +0000
1821@@ -39,7 +39,6 @@
1822
1823 typedef struct _DbusTestService DbusTestService;
1824 typedef struct _DbusTestServiceClass DbusTestServiceClass;
1825-typedef struct _DbusTestServicePrivate DbusTestServicePrivate;
1826
1827 struct _DbusTestServiceClass {
1828 GObjectClass parent_class;
1829@@ -47,7 +46,6 @@
1830
1831 struct _DbusTestService {
1832 GObject parent;
1833- DbusTestServicePrivate * priv;
1834 };
1835
1836 typedef enum
1837
1838=== modified file 'libdbustest/task.c'
1839--- libdbustest/task.c 2015-01-30 02:36:45 +0000
1840+++ libdbustest/task.c 2018-12-22 01:46:34 +0000
1841@@ -24,7 +24,7 @@
1842 #include "dbus-test.h"
1843 #include <gio/gio.h>
1844
1845-struct _DbusTestTaskPrivate {
1846+typedef struct {
1847 DbusTestTaskReturn return_type;
1848
1849 gchar * wait_for;
1850@@ -39,7 +39,7 @@
1851 gboolean wait_until_complete;
1852
1853 DbusTestServiceBus preferred_bus;
1854-};
1855+} DbusTestTaskPrivate;
1856
1857 /* Signals */
1858 enum {
1859@@ -47,15 +47,12 @@
1860 LAST_SIGNAL /* Don't touch! */
1861 };
1862
1863-#define DBUS_TEST_TASK_GET_PRIVATE(o) \
1864-(G_TYPE_INSTANCE_GET_PRIVATE ((o), DBUS_TEST_TYPE_TASK, DbusTestTaskPrivate))
1865-
1866 static void dbus_test_task_class_init (DbusTestTaskClass *klass);
1867 static void dbus_test_task_init (DbusTestTask *self);
1868 static void dbus_test_task_dispose (GObject *object);
1869 static void dbus_test_task_finalize (GObject *object);
1870
1871-G_DEFINE_TYPE (DbusTestTask, dbus_test_task, G_TYPE_OBJECT);
1872+G_DEFINE_TYPE_WITH_PRIVATE (DbusTestTask, dbus_test_task, G_TYPE_OBJECT);
1873
1874 static guint signals[LAST_SIGNAL] = {0};
1875
1876@@ -64,8 +61,6 @@
1877 {
1878 GObjectClass *object_class = G_OBJECT_CLASS (klass);
1879
1880- g_type_class_add_private (klass, sizeof (DbusTestTaskPrivate));
1881-
1882 object_class->dispose = dbus_test_task_dispose;
1883 object_class->finalize = dbus_test_task_finalize;
1884
1885@@ -89,22 +84,22 @@
1886 {
1887 static gint task_count = 0;
1888
1889- self->priv = DBUS_TEST_TASK_GET_PRIVATE(self);
1890-
1891- self->priv->return_type = DBUS_TEST_TASK_RETURN_NORMAL;
1892-
1893- self->priv->wait_for = NULL;
1894- self->priv->wait_for_bus = DBUS_TEST_SERVICE_BUS_BOTH;
1895- self->priv->wait_task = 0;
1896-
1897- self->priv->name = g_strdup_printf("task-%d", task_count++);
1898- self->priv->name_padded = NULL;
1899- self->priv->padding_cnt = 0;
1900-
1901- self->priv->been_run = FALSE;
1902- self->priv->wait_until_complete = FALSE;
1903-
1904- self->priv->preferred_bus = DBUS_TEST_SERVICE_BUS_BOTH;
1905+ DbusTestTaskPrivate *priv = dbus_test_task_get_instance_private(self);
1906+
1907+ priv->return_type = DBUS_TEST_TASK_RETURN_NORMAL;
1908+
1909+ priv->wait_for = NULL;
1910+ priv->wait_for_bus = DBUS_TEST_SERVICE_BUS_BOTH;
1911+ priv->wait_task = 0;
1912+
1913+ priv->name = g_strdup_printf("task-%d", task_count++);
1914+ priv->name_padded = NULL;
1915+ priv->padding_cnt = 0;
1916+
1917+ priv->been_run = FALSE;
1918+ priv->wait_until_complete = FALSE;
1919+
1920+ priv->preferred_bus = DBUS_TEST_SERVICE_BUS_BOTH;
1921
1922 return;
1923 }
1924@@ -114,10 +109,11 @@
1925 {
1926 g_return_if_fail(DBUS_TEST_IS_TASK(object));
1927 DbusTestTask * self = DBUS_TEST_TASK(object);
1928+ DbusTestTaskPrivate *priv = dbus_test_task_get_instance_private(self);
1929
1930- if (self->priv->wait_task != 0) {
1931- g_bus_unwatch_name(self->priv->wait_task);
1932- self->priv->wait_task = 0;
1933+ if (priv->wait_task != 0) {
1934+ g_bus_unwatch_name(priv->wait_task);
1935+ priv->wait_task = 0;
1936 }
1937
1938 G_OBJECT_CLASS (dbus_test_task_parent_class)->dispose (object);
1939@@ -129,12 +125,13 @@
1940 {
1941 g_return_if_fail(DBUS_TEST_IS_TASK(object));
1942 DbusTestTask * self = DBUS_TEST_TASK(object);
1943-
1944- g_print("%s: Shutting down\n", self->priv->name);
1945-
1946- g_free(self->priv->name);
1947- g_free(self->priv->name_padded);
1948- g_free(self->priv->wait_for);
1949+ DbusTestTaskPrivate *priv = dbus_test_task_get_instance_private(self);
1950+
1951+ g_print("%s: Shutting down\n", priv->name);
1952+
1953+ g_free(priv->name);
1954+ g_free(priv->name_padded);
1955+ g_free(priv->wait_for);
1956
1957 G_OBJECT_CLASS (dbus_test_task_parent_class)->finalize (object);
1958 return;
1959@@ -154,16 +151,18 @@
1960 {
1961 g_return_if_fail(DBUS_TEST_IS_TASK(task));
1962
1963- g_free(task->priv->name);
1964- g_free(task->priv->name_padded);
1965-
1966- task->priv->name = g_strdup(name);
1967- if (task->priv->padding_cnt != 0 && task->priv->name != NULL) {
1968- gchar * fillstr = g_strnfill(task->priv->padding_cnt - g_utf8_strlen(task->priv->name, -1), ' ');
1969- task->priv->name_padded = g_strconcat(task->priv->name, fillstr, NULL);
1970+ DbusTestTaskPrivate *priv = dbus_test_task_get_instance_private(task);
1971+
1972+ g_free(priv->name);
1973+ g_free(priv->name_padded);
1974+
1975+ priv->name = g_strdup(name);
1976+ if (priv->padding_cnt != 0 && priv->name != NULL) {
1977+ gchar * fillstr = g_strnfill(priv->padding_cnt - g_utf8_strlen(priv->name, -1), ' ');
1978+ priv->name_padded = g_strconcat(priv->name, fillstr, NULL);
1979 g_free(fillstr);
1980 } else {
1981- task->priv->name_padded = NULL;
1982+ priv->name_padded = NULL;
1983 }
1984
1985 return;
1986@@ -174,17 +173,19 @@
1987 {
1988 g_return_if_fail(DBUS_TEST_IS_TASK(task));
1989
1990- g_free(task->priv->name_padded);
1991- task->priv->padding_cnt = chars;
1992-
1993- g_return_if_fail(task->priv->padding_cnt >= g_utf8_strlen(task->priv->name, -1));
1994-
1995- if (chars != 0 && task->priv->name != NULL) {
1996- gchar * fillstr = g_strnfill(task->priv->padding_cnt - g_utf8_strlen(task->priv->name, -1), ' ');
1997- task->priv->name_padded = g_strconcat(task->priv->name, fillstr, NULL);
1998+ DbusTestTaskPrivate *priv = dbus_test_task_get_instance_private(task);
1999+
2000+ g_free(priv->name_padded);
2001+ priv->padding_cnt = chars;
2002+
2003+ g_return_if_fail(priv->padding_cnt >= g_utf8_strlen(priv->name, -1));
2004+
2005+ if (chars != 0 && priv->name != NULL) {
2006+ gchar * fillstr = g_strnfill(priv->padding_cnt - g_utf8_strlen(priv->name, -1), ' ');
2007+ priv->name_padded = g_strconcat(priv->name, fillstr, NULL);
2008 g_free(fillstr);
2009 } else {
2010- task->priv->name_padded = NULL;
2011+ priv->name_padded = NULL;
2012 }
2013
2014 return;
2015@@ -200,18 +201,20 @@
2016 {
2017 g_return_if_fail(DBUS_TEST_IS_TASK(task));
2018
2019- if (task->priv->wait_for != NULL) {
2020- g_free(task->priv->wait_for);
2021- task->priv->wait_for = NULL;
2022- task->priv->wait_for_bus = DBUS_TEST_SERVICE_BUS_BOTH;
2023+ DbusTestTaskPrivate *priv = dbus_test_task_get_instance_private(task);
2024+
2025+ if (priv->wait_for != NULL) {
2026+ g_free(priv->wait_for);
2027+ priv->wait_for = NULL;
2028+ priv->wait_for_bus = DBUS_TEST_SERVICE_BUS_BOTH;
2029 }
2030
2031 if (dbus_name == NULL) {
2032 return;
2033 }
2034
2035- task->priv->wait_for = g_strdup(dbus_name);
2036- task->priv->wait_for_bus = bus;
2037+ priv->wait_for = g_strdup(dbus_name);
2038+ priv->wait_for_bus = bus;
2039
2040 return;
2041 }
2042@@ -221,11 +224,13 @@
2043 {
2044 g_return_if_fail(DBUS_TEST_IS_TASK(task));
2045
2046- if (ret != task->priv->return_type && dbus_test_task_get_state(task) == DBUS_TEST_TASK_STATE_FINISHED) {
2047+ DbusTestTaskPrivate *priv = dbus_test_task_get_instance_private(task);
2048+
2049+ if (ret != priv->return_type && dbus_test_task_get_state(task) == DBUS_TEST_TASK_STATE_FINISHED) {
2050 g_warning("Changing return type after the task has finished");
2051 }
2052
2053- task->priv->return_type = ret;
2054+ priv->return_type = ret;
2055 return;
2056 }
2057
2058@@ -235,9 +240,11 @@
2059 g_return_if_fail(DBUS_TEST_IS_TASK(task));
2060 g_return_if_fail(message != NULL);
2061
2062- gchar * name = task->priv->name;
2063- if (task->priv->name_padded != NULL) {
2064- name = task->priv->name_padded;
2065+ DbusTestTaskPrivate *priv = dbus_test_task_get_instance_private(task);
2066+
2067+ gchar * name = priv->name;
2068+ if (priv->name_padded != NULL) {
2069+ name = priv->name_padded;
2070 }
2071
2072 g_print("%s: %s\n", name, message);
2073@@ -250,7 +257,9 @@
2074 {
2075 g_return_val_if_fail(DBUS_TEST_IS_TASK(task), DBUS_TEST_TASK_STATE_FINISHED);
2076
2077- if (task->priv->wait_task != 0) {
2078+ DbusTestTaskPrivate *priv = dbus_test_task_get_instance_private(task);
2079+
2080+ if (priv->wait_task != 0) {
2081 return DBUS_TEST_TASK_STATE_WAITING;
2082 }
2083
2084@@ -259,7 +268,7 @@
2085 return klass->get_state(task);
2086 }
2087
2088- if (task->priv->been_run) {
2089+ if (priv->been_run) {
2090 return DBUS_TEST_TASK_STATE_FINISHED;
2091 } else {
2092 return DBUS_TEST_TASK_STATE_INIT;
2093@@ -271,7 +280,9 @@
2094 {
2095 g_return_val_if_fail(DBUS_TEST_IS_TASK(task), DBUS_TEST_TASK_RETURN_IGNORE);
2096
2097- return task->priv->return_type;
2098+ DbusTestTaskPrivate *priv = dbus_test_task_get_instance_private(task);
2099+
2100+ return priv->return_type;
2101 }
2102
2103 static void
2104@@ -280,11 +291,13 @@
2105 g_return_if_fail(DBUS_TEST_IS_TASK(user_data));
2106 DbusTestTask * task = DBUS_TEST_TASK(user_data);
2107
2108- g_bus_unwatch_name(task->priv->wait_task);
2109- task->priv->wait_task = 0;
2110+ DbusTestTaskPrivate *priv = dbus_test_task_get_instance_private(task);
2111+
2112+ g_bus_unwatch_name(priv->wait_task);
2113+ priv->wait_task = 0;
2114
2115 DbusTestTaskClass * klass = DBUS_TEST_TASK_GET_CLASS(task);
2116- task->priv->been_run = TRUE;
2117+ priv->been_run = TRUE;
2118 if (klass->run != NULL) {
2119 klass->run(task);
2120 } else {
2121@@ -299,17 +312,19 @@
2122 {
2123 g_return_if_fail(DBUS_TEST_IS_TASK(task));
2124
2125+ DbusTestTaskPrivate *priv = dbus_test_task_get_instance_private(task);
2126+
2127 /* We're going to process the waiting at this level if we've been
2128 asked to do so */
2129- if (task->priv->wait_for != NULL) {
2130+ if (priv->wait_for != NULL) {
2131 GBusType bustype = G_BUS_TYPE_SESSION;
2132- if (task->priv->wait_for_bus == DBUS_TEST_SERVICE_BUS_BOTH &&
2133- task->priv->preferred_bus == DBUS_TEST_SERVICE_BUS_SYSTEM) {
2134+ if (priv->wait_for_bus == DBUS_TEST_SERVICE_BUS_BOTH &&
2135+ priv->preferred_bus == DBUS_TEST_SERVICE_BUS_SYSTEM) {
2136 bustype = G_BUS_TYPE_SYSTEM;
2137 }
2138
2139- task->priv->wait_task = g_bus_watch_name(bustype,
2140- task->priv->wait_for,
2141+ priv->wait_task = g_bus_watch_name(bustype,
2142+ priv->wait_for,
2143 G_BUS_NAME_WATCHER_FLAGS_NONE,
2144 wait_for_found,
2145 NULL,
2146@@ -320,7 +335,7 @@
2147 }
2148
2149 DbusTestTaskClass * klass = DBUS_TEST_TASK_GET_CLASS(task);
2150- task->priv->been_run = TRUE;
2151+ priv->been_run = TRUE;
2152 if (klass->run != NULL) {
2153 klass->run(task);
2154 } else {
2155@@ -334,10 +349,12 @@
2156 dbus_test_task_passed (DbusTestTask * task)
2157 {
2158 g_return_val_if_fail(DBUS_TEST_IS_TASK(task), FALSE);
2159- g_return_val_if_fail(task->priv->been_run, FALSE);
2160+ DbusTestTaskPrivate *priv = dbus_test_task_get_instance_private(task);
2161+
2162+ g_return_val_if_fail(priv->been_run, FALSE);
2163
2164 /* If we don't care, we always pass */
2165- if (task->priv->return_type == DBUS_TEST_TASK_RETURN_IGNORE) {
2166+ if (priv->return_type == DBUS_TEST_TASK_RETURN_IGNORE) {
2167 return TRUE;
2168 }
2169
2170@@ -348,7 +365,7 @@
2171
2172 gboolean subret = klass->get_passed(task);
2173
2174- if (task->priv->return_type == DBUS_TEST_TASK_RETURN_INVERT) {
2175+ if (priv->return_type == DBUS_TEST_TASK_RETURN_INVERT) {
2176 return !subret;
2177 }
2178
2179@@ -359,16 +376,18 @@
2180 dbus_test_task_get_name (DbusTestTask * task)
2181 {
2182 g_return_val_if_fail(DBUS_TEST_IS_TASK(task), NULL);
2183+ DbusTestTaskPrivate *priv = dbus_test_task_get_instance_private(task);
2184
2185- return task->priv->name;
2186+ return priv->name;
2187 }
2188
2189 const gchar *
2190 dbus_test_task_get_wait_for (DbusTestTask * task)
2191 {
2192 g_return_val_if_fail(DBUS_TEST_IS_TASK(task), NULL);
2193+ DbusTestTaskPrivate *priv = dbus_test_task_get_instance_private(task);
2194
2195- return task->priv->wait_for;
2196+ return priv->wait_for;
2197 }
2198
2199 /**
2200@@ -384,8 +403,9 @@
2201 dbus_test_task_set_wait_finished (DbusTestTask * task, gboolean wait_till_complete)
2202 {
2203 g_return_if_fail(DBUS_TEST_IS_TASK(task));
2204+ DbusTestTaskPrivate *priv = dbus_test_task_get_instance_private(task);
2205
2206- task->priv->wait_until_complete = wait_till_complete;
2207+ priv->wait_until_complete = wait_till_complete;
2208
2209 return;
2210 }
2211@@ -401,8 +421,9 @@
2212 dbus_test_task_get_wait_finished (DbusTestTask * task)
2213 {
2214 g_return_val_if_fail(DBUS_TEST_IS_TASK(task), FALSE);
2215+ DbusTestTaskPrivate *priv = dbus_test_task_get_instance_private(task);
2216
2217- return task->priv->wait_until_complete;
2218+ return priv->wait_until_complete;
2219 }
2220
2221 /**
2222@@ -416,8 +437,9 @@
2223 dbus_test_task_set_bus (DbusTestTask * task, DbusTestServiceBus bus)
2224 {
2225 g_return_if_fail(DBUS_TEST_IS_TASK(task));
2226+ DbusTestTaskPrivate *priv = dbus_test_task_get_instance_private(task);
2227
2228- task->priv->preferred_bus = bus;
2229+ priv->preferred_bus = bus;
2230 }
2231
2232 /**
2233@@ -430,6 +452,7 @@
2234 dbus_test_task_get_bus (DbusTestTask * task)
2235 {
2236 g_return_val_if_fail(DBUS_TEST_IS_TASK(task), DBUS_TEST_SERVICE_BUS_BOTH);
2237+ DbusTestTaskPrivate *priv = dbus_test_task_get_instance_private(task);
2238
2239- return task->priv->preferred_bus;
2240+ return priv->preferred_bus;
2241 }
2242
2243=== modified file 'libdbustest/task.h'
2244--- libdbustest/task.h 2015-01-30 02:36:45 +0000
2245+++ libdbustest/task.h 2018-12-22 01:46:34 +0000
2246@@ -40,7 +40,6 @@
2247
2248 typedef struct _DbusTestTask DbusTestTask;
2249 typedef struct _DbusTestTaskClass DbusTestTaskClass;
2250-typedef struct _DbusTestTaskPrivate DbusTestTaskPrivate;
2251
2252 typedef enum
2253 {
2254@@ -71,7 +70,6 @@
2255
2256 struct _DbusTestTask {
2257 GObject parent;
2258- DbusTestTaskPrivate * priv;
2259 };
2260
2261 #include "service.h"
2262
2263=== modified file 'libdbustest/watchdog.c'
2264--- libdbustest/watchdog.c 2016-09-06 14:28:48 +0000
2265+++ libdbustest/watchdog.c 2018-12-22 01:46:34 +0000
2266@@ -4,18 +4,15 @@
2267
2268 #include "watchdog.h"
2269
2270-struct _DbusTestWatchdogPrivate {
2271+typedef struct {
2272 GPid watchdog;
2273-};
2274-
2275-#define DBUS_TEST_WATCHDOG_GET_PRIVATE(o) \
2276-(G_TYPE_INSTANCE_GET_PRIVATE ((o), DBUS_TEST_TYPE_WATCHDOG, DbusTestWatchdogPrivate))
2277+} DbusTestWatchdogPrivate;
2278
2279 static void dbus_test_watchdog_class_init (DbusTestWatchdogClass *klass);
2280 static void dbus_test_watchdog_init (DbusTestWatchdog *self);
2281 static void dbus_test_watchdog_finalize (GObject *object);
2282
2283-G_DEFINE_TYPE (DbusTestWatchdog, dbus_test_watchdog, G_TYPE_OBJECT);
2284+G_DEFINE_TYPE_WITH_PRIVATE (DbusTestWatchdog, dbus_test_watchdog, G_TYPE_OBJECT);
2285
2286 /* Initialize class */
2287 static void
2288@@ -23,8 +20,6 @@
2289 {
2290 GObjectClass *object_class = G_OBJECT_CLASS (klass);
2291
2292- g_type_class_add_private (klass, sizeof (DbusTestWatchdogPrivate));
2293-
2294 object_class->finalize = dbus_test_watchdog_finalize;
2295
2296 return;
2297@@ -34,9 +29,9 @@
2298 static void
2299 dbus_test_watchdog_init (G_GNUC_UNUSED DbusTestWatchdog *self)
2300 {
2301- self->priv = DBUS_TEST_WATCHDOG_GET_PRIVATE(self);
2302+ DbusTestWatchdogPrivate *priv = dbus_test_watchdog_get_instance_private (self);
2303
2304- self->priv->watchdog = 0;
2305+ priv->watchdog = 0;
2306
2307 return;
2308 }
2309@@ -46,9 +41,10 @@
2310 dbus_test_watchdog_finalize (GObject *object)
2311 {
2312 DbusTestWatchdog * watchdog = DBUS_TEST_WATCHDOG(object);
2313-
2314- if (watchdog->priv->watchdog != 0) {
2315- kill(watchdog->priv->watchdog, SIGTERM);
2316+ DbusTestWatchdogPrivate *priv = dbus_test_watchdog_get_instance_private (watchdog);
2317+
2318+ if (priv->watchdog != 0) {
2319+ kill(priv->watchdog, SIGTERM);
2320 }
2321
2322 G_OBJECT_CLASS (dbus_test_watchdog_parent_class)->finalize (object);
2323@@ -67,7 +63,8 @@
2324 {
2325 g_return_if_fail(DBUS_TEST_IS_WATCHDOG(watchdog));
2326 g_return_if_fail(pid != 0);
2327- g_return_if_fail(watchdog->priv->watchdog == 0);
2328+ DbusTestWatchdogPrivate *priv = dbus_test_watchdog_get_instance_private (watchdog);
2329+ g_return_if_fail(priv->watchdog == 0);
2330
2331 /* Setting up argument vector */
2332 gchar * strpid = g_strdup_printf("%d", pid);
2333@@ -84,14 +81,14 @@
2334 NULL, /* env */
2335 0, /* flags */
2336 NULL, NULL, /* Setup function */
2337- &watchdog->priv->watchdog,
2338+ &priv->watchdog,
2339 &error);
2340
2341 g_free(strpid);
2342
2343 if (error != NULL) {
2344 g_warning("Unable to start watchdog");
2345- watchdog->priv->watchdog = 0;
2346+ priv->watchdog = 0;
2347 g_error_free(error);
2348 return;
2349 }
2350@@ -109,9 +106,10 @@
2351 dbus_test_watchdog_ping (DbusTestWatchdog * watchdog)
2352 {
2353 g_return_if_fail(DBUS_TEST_IS_WATCHDOG(watchdog));
2354+ DbusTestWatchdogPrivate *priv = dbus_test_watchdog_get_instance_private (watchdog);
2355
2356- if (watchdog->priv->watchdog != 0) {
2357- kill(watchdog->priv->watchdog, SIGHUP);
2358+ if (priv->watchdog != 0) {
2359+ kill(priv->watchdog, SIGHUP);
2360 }
2361
2362 return;
2363
2364=== modified file 'libdbustest/watchdog.h'
2365--- libdbustest/watchdog.h 2013-01-29 17:31:34 +0000
2366+++ libdbustest/watchdog.h 2018-12-22 01:46:34 +0000
2367@@ -15,7 +15,6 @@
2368
2369 typedef struct _DbusTestWatchdog DbusTestWatchdog;
2370 typedef struct _DbusTestWatchdogClass DbusTestWatchdogClass;
2371-typedef struct _DbusTestWatchdogPrivate DbusTestWatchdogPrivate;
2372
2373 struct _DbusTestWatchdogClass {
2374 GObjectClass parent_class;
2375@@ -23,7 +22,6 @@
2376
2377 struct _DbusTestWatchdog {
2378 GObject parent;
2379- DbusTestWatchdogPrivate * priv;
2380 };
2381
2382 GType dbus_test_watchdog_get_type (void);

Subscribers

People subscribed via source and target branches