1
=== modified file 'debian/changelog'
2
--- debian/changelog	2017-03-17 11:08:20 +0000
3
+++ debian/changelog	2017-04-04 09:33:34 +0000
4
@@ -1,3 +1,9 @@
5
1
unity-api (8.7-0ubuntu1) UNRELEASED; urgency=medium
6
2
7
3
  * Add Glib and GObject Assigner helpers.
8
4
9
5
 -- Pete <pete.woods@canonical.com>  Fri, 24 Mar 2017 10:25:45 +0000
10
6
11
1
unity-api (8.6+17.04.20170317-0ubuntu1) zesty; urgency=medium
7
unity-api (8.6+17.04.20170317-0ubuntu1) zesty; urgency=medium
12
2
8
13
3
  [ Michael Zanetti ]
9
  [ Michael Zanetti ]
14
4
10
15
=== modified file 'include/unity/util/GObjectMemory.h'
16
--- include/unity/util/GObjectMemory.h	2017-03-17 10:20:10 +0000
17
+++ include/unity/util/GObjectMemory.h	2017-04-04 09:33:34 +0000
18
@@ -57,7 +57,7 @@
19
57
 */
57
 */
20
58
struct GObjectDeleter
58
struct GObjectDeleter
21
59
{
59
{
23
60
    void operator()(gpointer ptr)
60
    void operator()(gpointer ptr) noexcept
24
61
    {
61
    {
25
62
        if (G_IS_OBJECT(ptr))
62
        if (G_IS_OBJECT(ptr))
26
63
        {
63
        {
27
@@ -66,6 +66,51 @@
28
66
    }
66
    }
29
67
};
67
};
30
68
68
31
69
template<typename T> using GObjectSPtr = std::shared_ptr<T>;
32
70
template<typename T> using GObjectUPtr = std::unique_ptr<T, GObjectDeleter>;
33
71
34
72
namespace internal
35
73
{
36
74
37
75
template<typename SP>
38
76
class GObjectAssigner
39
77
{
40
78
public:
41
79
    typedef typename SP::element_type ElementType;
42
80
43
81
    GObjectAssigner(SP& smart_ptr) noexcept:
44
82
            smart_ptr_(smart_ptr)
45
83
    {
46
84
    }
47
85
48
86
    GObjectAssigner(const GObjectAssigner& other) = delete;
49
87
50
88
    GObjectAssigner(GObjectAssigner&& other) noexcept:
51
89
            ptr_(other.ptr_), smart_ptr_(other.smart_ptr_)
52
90
    {
53
91
        other.ptr_ = nullptr;
54
92
    }
55
93
56
94
    ~GObjectAssigner() noexcept
57
95
    {
58
96
        smart_ptr_ = SP(ptr_, GObjectDeleter());
59
97
    }
60
98
61
99
    GObjectAssigner& operator=(const GObjectAssigner& other) = delete;
62
100
63
101
    operator ElementType**() noexcept
64
102
    {
65
103
        return &ptr_;
66
104
    }
67
105
68
106
private:
69
107
    ElementType* ptr_ = nullptr;
70
108
71
109
    SP& smart_ptr_;
72
110
};
73
111
74
112
}
75
113
76
69
/**
114
/**
77
70
 \brief Helper method to wrap a unique_ptr around an existing GObject.
115
 \brief Helper method to wrap a unique_ptr around an existing GObject.
78
71
116
79
@@ -79,11 +124,11 @@
80
79
 \endcode
124
 \endcode
81
80
 */
125
 */
82
81
template<typename T>
126
template<typename T>
84
82
inline std::unique_ptr<T, GObjectDeleter> unique_gobject(T* ptr)
127
inline GObjectUPtr<T> unique_gobject(T* ptr)
85
83
{
128
{
86
84
    check_floating_gobject(ptr);
129
    check_floating_gobject(ptr);
87
85
    GObjectDeleter d;
130
    GObjectDeleter d;
89
86
    return std::unique_ptr<T, GObjectDeleter>(ptr, d);
131
    return GObjectUPtr<T>(ptr, d);
90
87
}
132
}
91
88
133
92
89
/**
134
/**
93
@@ -99,11 +144,11 @@
94
99
 \endcode
144
 \endcode
95
100
 */
145
 */
96
101
template<typename T>
146
template<typename T>
98
102
inline std::shared_ptr<T> share_gobject(T* ptr)
147
inline GObjectSPtr<T> share_gobject(T* ptr)
99
103
{
148
{
100
104
    check_floating_gobject(ptr);
149
    check_floating_gobject(ptr);
101
105
    GObjectDeleter d;
150
    GObjectDeleter d;
103
106
    return std::shared_ptr<T>(ptr, d);
151
    return GObjectSPtr<T>(ptr, d);
104
107
}
152
}
105
108
153
106
109
/**
154
/**
107
@@ -117,7 +162,7 @@
108
117
 \endcode
162
 \endcode
109
118
 */
163
 */
110
119
template<typename T, typename ... Args>
164
template<typename T, typename ... Args>
112
120
inline std::unique_ptr<T, GObjectDeleter> make_gobject(GType object_type, const gchar *first_property_name, Args&&... args)
165
inline GObjectUPtr<T> make_gobject(GType object_type, const gchar *first_property_name, Args&&... args) noexcept
113
121
{
166
{
114
122
    gpointer ptr = g_object_new(object_type, first_property_name, std::forward<Args>(args)...);
167
    gpointer ptr = g_object_new(object_type, first_property_name, std::forward<Args>(args)...);
115
123
    if (G_IS_OBJECT(ptr) && g_object_is_floating(ptr))
168
    if (G_IS_OBJECT(ptr) && g_object_is_floating(ptr))
116
@@ -127,6 +172,22 @@
117
127
    return unique_gobject(G_TYPE_CHECK_INSTANCE_CAST(ptr, object_type, T));
172
    return unique_gobject(G_TYPE_CHECK_INSTANCE_CAST(ptr, object_type, T));
118
128
}
173
}
119
129
174
120
175
/**
121
176
 \brief Helper method to take ownership of GObjects assigned from a reference.
122
177
123
178
 Example:
124
179
 \code{.cpp}
125
180
 GObjectUPtr<FooBar> o;
126
181
 method_that_assigns_a_foobar(assign_gobject(o));
127
182
 \endcode
128
183
 */
129
184
template<typename SP>
130
185
inline internal::GObjectAssigner<SP> assign_gobject(SP& smart_ptr) noexcept
131
186
{
132
187
    return internal::GObjectAssigner<SP>(smart_ptr);
133
188
}
134
189
135
190
136
130
}  // namespace until
191
}  // namespace until
137
131
192
138
132
}  // namespace unity
193
}  // namespace unity
139
133
194
140
=== modified file 'include/unity/util/GlibMemory.h'
141
--- include/unity/util/GlibMemory.h	2017-02-23 11:18:54 +0000
142
+++ include/unity/util/GlibMemory.h	2017-04-04 09:33:34 +0000
143
@@ -14,6 +14,8 @@
144
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
145
15
 *
15
 *
146
16
 * Authored by: Pete Woods <pete.woods@canonical.com>
16
 * Authored by: Pete Woods <pete.woods@canonical.com>
147
17
 *              Michi Henning <michi.henning@canonical.com>
148
18
 *              James Henstridge <james.henstridge@canonical.com>
149
17
 */
19
 */
150
18
20
151
19
#ifndef UNITY_UTIL_GLIBMEMORY_H
21
#ifndef UNITY_UTIL_GLIBMEMORY_H
152
@@ -28,45 +30,161 @@
153
28
namespace util
30
namespace util
154
29
{
31
{
155
30
32
168
31
template<typename T, typename D>
33
namespace internal
169
32
struct GlibDeleter
34
{
170
33
{
35
171
34
    D _d;
36
template<typename T> struct GlibDeleter;
172
35
37
template<typename T> using GlibSPtr = std::shared_ptr<T>;
173
36
    void operator()(T* ptr)
38
template<typename T> using GlibUPtr = std::unique_ptr<T, GlibDeleter<T>>;
174
37
    {
39
175
38
        if (ptr != nullptr)
40
/**
176
39
        {
41
 * \brief Adapter class to assign to smart pointers from functions that take a reference.
177
40
            _d(ptr);
42
 *
178
41
        }
43
 * Adapter class that allows passing a shared_ptr or unique_ptr where glib
179
42
    }
44
 * expects a parameter of type ElementType** (such as GError**), by providing
180
45
 * a default conversion operator to ElementType**. This allows the glib method
181
46
 * to assign to the ptr_ member. From the destructor, we assign to the
182
47
 * provided smart pointer.
183
48
 */
184
49
template<typename SP>
185
50
class GlibAssigner
186
51
{
187
52
public:
188
53
    typedef typename SP::element_type ElementType;
189
54
190
55
    GlibAssigner(SP& smart_ptr) noexcept :
191
56
            smart_ptr_(smart_ptr)
192
57
    {
193
58
    }
194
59
195
60
    GlibAssigner(const GlibAssigner& other) = delete;
196
61
197
62
    GlibAssigner(GlibAssigner&& other) noexcept:
198
63
            ptr_(other.ptr_), smart_ptr_(other.smart_ptr_)
199
64
    {
200
65
        other.ptr_ = nullptr;
201
66
    }
202
67
203
68
    ~GlibAssigner() noexcept
204
69
    {
205
70
        smart_ptr_ = SP(ptr_, GlibDeleter<ElementType>());
206
71
    }
207
72
208
73
    GlibAssigner& operator=(const GlibAssigner& other) = delete;
209
74
210
75
    operator ElementType**() noexcept
211
76
    {
212
77
        return &ptr_;
213
78
    }
214
79
215
80
private:
216
81
    ElementType* ptr_ = nullptr;
217
82
218
83
    SP& smart_ptr_;
219
43
};
84
};
220
44
85
221
86
}
222
87
223
88
#define UNITY_UTIL_DEFINE_GLIB_SMART_POINTERS(TypeName, func) \
224
89
using TypeName##Deleter = internal::GlibDeleter<TypeName>; \
225
90
using TypeName##SPtr = internal::GlibSPtr<TypeName>; \
226
91
using TypeName##UPtr = internal::GlibUPtr<TypeName>; \
227
92
namespace internal \
228
93
{ \
229
94
template<> struct GlibDeleter<TypeName> \
230
95
{ \
231
96
    void operator()(TypeName* ptr) noexcept \
232
97
    { \
233
98
        if (ptr) \
234
99
        { \
235
100
            ::func(ptr); \
236
101
        } \
237
102
    } \
238
103
}; \
239
104
}
240
105
241
106
/**
242
107
 \brief Helper method to wrap a shared_ptr around a Glib type.
243
108
244
109
 Example:
245
110
 \code{.cpp}
246
111
 auto gkf = shared_glib(g_key_file_new());
247
112
 \endcode
248
113
 */
249
114
template<typename T>
250
115
inline internal::GlibSPtr<T> share_glib(T* ptr) noexcept
251
116
{
252
117
    return internal::GlibSPtr<T>(ptr, internal::GlibDeleter<T>());
253
118
}
254
119
255
120
/**
256
121
 \brief Helper method to wrap a unique_ptr around a Glib type.
257
122
258
123
 Example:
259
124
 \code{.cpp}
260
125
 auto gkf = unique_glib(g_key_file_new());
261
126
 \endcode
262
127
 */
263
128
template<typename T>
264
129
inline internal::GlibUPtr<T> unique_glib(T* ptr) noexcept
265
130
{
266
131
    return internal::GlibUPtr<T>(ptr, internal::GlibDeleter<T>());
267
132
}
268
133
269
134
/**
270
135
 \brief Helper method to take ownership of glib types assigned from a reference.
271
136
272
137
 Example:
273
138
 \code{.cpp}
274
139
 GErrorUPtr error;
275
140
 if (!g_key_file_get_boolean(gkf.get(), "group", "key", assign_glib(error)))
276
141
 {
277
142
     std::cerr << error->message << std::endl;
278
143
     throw some_exception();
279
144
 }
280
145
 \endcode
281
146
282
147
 Another example:
283
148
 \code{.cpp}
284
149
 gcharUPtr name;
285
150
 g_object_get(obj, "name", assign_glib(name), nullptr);
286
151
 \endcode
287
152
 */
288
153
template<typename SP>
289
154
inline internal::GlibAssigner<SP> assign_glib(SP& smart_ptr) noexcept
290
155
{
291
156
    return internal::GlibAssigner<SP>(smart_ptr);
292
157
}
293
158
294
159
/**
295
160
 * Below here is some hackery to extract the matching deleters for all built in glib types.
296
161
 */
297
45
#pragma push_macro("G_DEFINE_AUTOPTR_CLEANUP_FUNC")
162
#pragma push_macro("G_DEFINE_AUTOPTR_CLEANUP_FUNC")
298
46
#undef G_DEFINE_AUTOPTR_CLEANUP_FUNC
163
#undef G_DEFINE_AUTOPTR_CLEANUP_FUNC
311
47
#define G_DEFINE_AUTOPTR_CLEANUP_FUNC(TypeName, func) \
164
#define G_DEFINE_AUTOPTR_CLEANUP_FUNC(TypeName, func) UNITY_UTIL_DEFINE_GLIB_SMART_POINTERS(TypeName, func)
300
48
typedef GlibDeleter<TypeName, decltype(&func)> TypeName##Deleter; \
301
49
typedef std::shared_ptr<TypeName> TypeName##SPtr; \
302
50
inline TypeName##SPtr share_glib(TypeName* ptr) \
303
51
{ \
304
52
    return TypeName##SPtr(ptr, TypeName##Deleter{&func}); \
305
53
} \
306
54
typedef std::unique_ptr<TypeName, TypeName##Deleter> TypeName##UPtr; \
307
55
inline TypeName##UPtr unique_glib(TypeName* ptr) \
308
56
{ \
309
57
    return TypeName##UPtr(ptr, TypeName##Deleter{&func}); \
310
58
}
312
59
165
313
60
#pragma push_macro("G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC")
166
#pragma push_macro("G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC")
314
61
#undef G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC
167
#undef G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC
315
62
#define G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC(TypeName, func)
168
#define G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC(TypeName, func)
316
63
169
317
170
#pragma push_macro("G_DEFINE_AUTO_CLEANUP_FREE_FUNC")
318
171
#undef G_DEFINE_AUTO_CLEANUP_FREE_FUNC
319
172
#define G_DEFINE_AUTO_CLEANUP_FREE_FUNC(TypeName, func, none)
320
173
321
64
#define __GLIB_H_INSIDE__
174
#define __GLIB_H_INSIDE__
322
65
#include <glib/glib-autocleanups.h>
175
#include <glib/glib-autocleanups.h>
323
66
#undef __GLIB_H_INSIDE__
176
#undef __GLIB_H_INSIDE__
324
67
177
325
68
#pragma pop_macro("G_DEFINE_AUTOPTR_CLEANUP_FUNC")
178
#pragma pop_macro("G_DEFINE_AUTOPTR_CLEANUP_FUNC")
326
69
#pragma pop_macro("G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC")
179
#pragma pop_macro("G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC")
327
180
#pragma pop_macro("G_DEFINE_AUTO_CLEANUP_FREE_FUNC")
328
181
329
182
/**
330
183
 * Manually add extra definitions for gchar* and gchar**
331
184
 */
332
185
UNITY_UTIL_DEFINE_GLIB_SMART_POINTERS(gchar, g_free)
333
186
typedef gchar* gcharv;
334
187
UNITY_UTIL_DEFINE_GLIB_SMART_POINTERS(gcharv, g_strfreev)
335
70
188
336
71
}  // namespace until
189
}  // namespace until
337
72
190
338
73
191
339
=== modified file 'test/gtest/unity/util/GObjectMemory/GObjectMemory_test.cpp'
340
--- test/gtest/unity/util/GObjectMemory/GObjectMemory_test.cpp	2017-03-17 10:20:10 +0000
341
+++ test/gtest/unity/util/GObjectMemory/GObjectMemory_test.cpp	2017-04-04 09:33:34 +0000
342
@@ -17,8 +17,8 @@
343
17
 *              Pete Woods <pete.woods@canonical.com>
17
 *              Pete Woods <pete.woods@canonical.com>
344
18
 */
18
 */
345
19
19
346
20
#include <unity/util/GlibMemory.h>
347
20
#include <unity/util/GObjectMemory.h>
21
#include <unity/util/GObjectMemory.h>
348
21
#include <glib-object.h>
349
22
#include <gtest/gtest.h>
22
#include <gtest/gtest.h>
350
23
#include <list>
23
#include <list>
351
24
#include <string>
24
#include <string>
352
@@ -46,8 +46,14 @@
353
46
46
354
47
FooBar *foo_bar_new();
47
FooBar *foo_bar_new();
355
48
48
356
49
void foo_bar_assigner(FooBar** in);
357
50
358
49
FooBar *foo_bar_new_full(const gchar* const name, guint id);
51
FooBar *foo_bar_new_full(const gchar* const name, guint id);
359
50
52
360
53
void foo_bar_assigner_full(const gchar* const name, guint id, FooBar** in);
361
54
362
55
void foo_bar_assigner_null(FooBar** in);
363
56
364
51
G_END_DECLS
57
G_END_DECLS
365
52
58
366
53
// private implementation
59
// private implementation
367
@@ -167,6 +173,30 @@
368
167
    return FOO_BAR(g_object_new(FOO_TYPE_BAR, "name", name, "id", id, NULL));
173
    return FOO_BAR(g_object_new(FOO_TYPE_BAR, "name", name, "id", id, NULL));
369
168
}
174
}
370
169
175
371
176
void foo_bar_assigner(FooBar** in)
372
177
{
373
178
    if (in != nullptr)
374
179
    {
375
180
        *in = foo_bar_new();
376
181
    }
377
182
}
378
183
379
184
void foo_bar_assigner_full(const gchar* const name, guint id, FooBar** in)
380
185
{
381
186
    if (in != nullptr)
382
187
    {
383
188
        *in = foo_bar_new_full(name, id);
384
189
    }
385
190
}
386
191
387
192
void foo_bar_assigner_null(FooBar** in)
388
193
{
389
194
    if (in != nullptr)
390
195
    {
391
196
        *in = nullptr;
392
197
    }
393
198
}
394
199
395
170
//
200
//
396
171
// Test cases
201
// Test cases
397
172
//
202
//
398
@@ -337,12 +367,12 @@
399
337
}
367
}
400
338
368
401
339
TEST_F(GObjectMemoryTest, sizeoftest) {
369
TEST_F(GObjectMemoryTest, sizeoftest) {
403
340
    EXPECT_EQ(sizeof(FooBar*), sizeof(unique_ptr<FooBar>));
370
    EXPECT_EQ(sizeof(FooBar*), sizeof(GObjectUPtr<FooBar>));
404
341
}
371
}
405
342
372
406
343
TEST_F(GObjectMemoryTest, hash)
373
TEST_F(GObjectMemoryTest, hash)
407
344
{
374
{
409
345
    unordered_set<shared_ptr<FooBar>> s;
375
    unordered_set<GObjectSPtr<FooBar>> s;
410
346
    auto a = share_gobject(foo_bar_new());
376
    auto a = share_gobject(foo_bar_new());
411
347
    auto b = share_gobject(foo_bar_new());
377
    auto b = share_gobject(foo_bar_new());
412
348
    auto c = share_gobject(foo_bar_new());
378
    auto c = share_gobject(foo_bar_new());
413
@@ -403,10 +433,57 @@
414
403
    EXPECT_EQ(list<Deleted>({{"c", 3}, {"b", 2}, {"a", 1}}), DELETED_OBJECTS);
433
    EXPECT_EQ(list<Deleted>({{"c", 3}, {"b", 2}, {"a", 1}}), DELETED_OBJECTS);
415
404
}
434
}
416
405
435
421
406
TEST_F(GObjectMemoryTest, foo)
436
TEST_F(GObjectMemoryTest, uptrAssignerDeletesGObjects)
422
407
{
437
{
423
408
    {
438
    {
424
409
        shared_ptr<FooBar> s;
439
        GObjectUPtr<FooBar> a, b;
425
440
        foo_bar_assigner_full("a", 1, assign_gobject(a));
426
441
        foo_bar_assigner_full("b", 2, assign_gobject(b));
427
442
    }
428
443
    EXPECT_EQ(list<Deleted>({{"b", 2}, {"a", 1}}), DELETED_OBJECTS);
429
444
}
430
445
431
446
TEST_F(GObjectMemoryTest, sptrAssignerDeletesGObjects)
432
447
{
433
448
    {
434
449
        GObjectSPtr<FooBar> a, b, c;
435
450
        foo_bar_assigner_full("a", 3, assign_gobject(a));
436
451
        foo_bar_assigner_full("b", 4, assign_gobject(b));
437
452
        foo_bar_assigner_full("c", 5, assign_gobject(c));
438
453
    }
439
454
    EXPECT_EQ(list<Deleted>({{"c", 5}, {"b", 4}, {"a", 3}}), DELETED_OBJECTS);
440
455
}
441
456
442
457
TEST_F(GObjectMemoryTest, uptrAssignerAssignsNull)
443
458
{
444
459
    {
445
460
       GObjectUPtr<FooBar> o;
446
461
       foo_bar_assigner_full("o", 1, assign_gobject(o));
447
462
       ASSERT_TRUE(bool(o));
448
463
       foo_bar_assigner_null(assign_gobject(o));
449
464
       ASSERT_FALSE(bool(o));
450
465
451
466
    }
452
467
    EXPECT_EQ(list<Deleted>({{"o", 1}}), DELETED_OBJECTS);
453
468
}
454
469
455
470
TEST_F(GObjectMemoryTest, sptrAssignerAssignsNull)
456
471
{
457
472
    {
458
473
       GObjectSPtr<FooBar> o;
459
474
       foo_bar_assigner_full("o", 1, assign_gobject(o));
460
475
       ASSERT_TRUE(bool(o));
461
476
       foo_bar_assigner_null(assign_gobject(o));
462
477
       ASSERT_FALSE(bool(o));
463
478
464
479
    }
465
480
    EXPECT_EQ(list<Deleted>({{"o", 1}}), DELETED_OBJECTS);
466
481
}
467
482
468
483
TEST_F(GObjectMemoryTest, moveUptrSptr)
469
484
{
470
485
    {
471
486
        GObjectSPtr<FooBar> s;
472
410
        auto u = unique_gobject(foo_bar_new_full("hi", 6));
487
        auto u = unique_gobject(foo_bar_new_full("hi", 6));
473
411
        s = move(u);
488
        s = move(u);
474
412
        // unique instance has been stolen from
489
        // unique instance has been stolen from
475
@@ -414,7 +491,7 @@
476
414
    }
491
    }
477
415
    EXPECT_EQ(list<Deleted>({{"hi", 6}}), DELETED_OBJECTS);
492
    EXPECT_EQ(list<Deleted>({{"hi", 6}}), DELETED_OBJECTS);
478
416
    {
493
    {
480
417
        shared_ptr<FooBar> s(unique_gobject(foo_bar_new_full("bye", 7)));
494
        GObjectSPtr<FooBar> s(unique_gobject(foo_bar_new_full("bye", 7)));
481
418
    }
495
    }
482
419
    EXPECT_EQ(list<Deleted>({{"hi", 6}, {"bye", 7}}), DELETED_OBJECTS);
496
    EXPECT_EQ(list<Deleted>({{"hi", 6}, {"bye", 7}}), DELETED_OBJECTS);
483
420
}
497
}
484
@@ -431,14 +508,12 @@
485
431
     */
508
     */
486
432
    static void checkProperties(gpointer obj, const char* expectedName, guint expectedId)
509
    static void checkProperties(gpointer obj, const char* expectedName, guint expectedId)
487
433
    {
510
    {
489
434
        char* name = NULL;
511
        gcharUPtr name;
490
435
        guint id = 0;
512
        guint id = 0;
491
436
513
494
437
        g_object_get(obj, "name", &name, "id", &id, NULL);
514
        g_object_get(obj, "name", assign_glib(name), "id", &id, nullptr);
495
438
        EXPECT_STREQ(expectedName, name);
515
        EXPECT_STREQ(expectedName, name.get());
496
439
        EXPECT_EQ(expectedId, id);
516
        EXPECT_EQ(expectedId, id);
497
440
498
441
        g_free(name);
499
442
    }
517
    }
500
443
};
518
};
501
444
519
502
@@ -471,6 +546,22 @@
503
471
    checkProperties(obj.get(), p.first, p.second);
546
    checkProperties(obj.get(), p.first, p.second);
504
472
}
547
}
505
473
548
506
549
TEST_P(GObjectMemoryMakeHelperMethodsTest, assign_foo_bar_uptr_assigner)
507
550
{
508
551
    auto p = GetParam();
509
552
    GObjectUPtr<FooBar> obj;
510
553
    foo_bar_assigner_full(p.first, p.second, assign_gobject(obj));
511
554
    checkProperties(obj.get(), p.first, p.second);
512
555
}
513
556
514
557
TEST_P(GObjectMemoryMakeHelperMethodsTest, assign_foo_bar_sptr_assigner)
515
558
{
516
559
    auto p = GetParam();
517
560
    GObjectSPtr<FooBar> obj;
518
561
    foo_bar_assigner_full(p.first, p.second, assign_gobject(obj));
519
562
    checkProperties(obj.get(), p.first, p.second);
520
563
}
521
564
522
474
INSTANTIATE_TEST_CASE_P(BunchOfNames,
565
INSTANTIATE_TEST_CASE_P(BunchOfNames,
523
475
                        GObjectMemoryMakeHelperMethodsTest,
566
                        GObjectMemoryMakeHelperMethodsTest,
524
476
                        ::testing::Values(GObjectMemoryMakeSharedTestParam{"meeny", 1},
567
                        ::testing::Values(GObjectMemoryMakeSharedTestParam{"meeny", 1},
525
477
568
526
=== modified file 'test/gtest/unity/util/GlibMemory/GlibMemory_test.cpp'
527
--- test/gtest/unity/util/GlibMemory/GlibMemory_test.cpp	2017-02-23 11:18:54 +0000
528
+++ test/gtest/unity/util/GlibMemory/GlibMemory_test.cpp	2017-04-04 09:33:34 +0000
529
@@ -89,6 +89,30 @@
530
89
    {
89
    {
531
90
        return share_glib(g_hash_table_new_full(g_str_hash, g_str_equal, deleteKey, deleteValue));
90
        return share_glib(g_hash_table_new_full(g_str_hash, g_str_equal, deleteKey, deleteValue));
532
91
    }
91
    }
533
92
534
93
    static void assignGChar(gchar** in)
535
94
    {
536
95
        if (in != nullptr)
537
96
        {
538
97
            *in = g_strdup("hi");
539
98
        }
540
99
    }
541
100
542
101
    static void assignGError(GError** in)
543
102
    {
544
103
        if (in != nullptr)
545
104
        {
546
105
            *in = g_error_new_literal(g_key_file_error_quark(), 1, "hello");
547
106
        }
548
107
    }
549
108
550
109
    static void assignEmptyGError(GError** in)
551
110
    {
552
111
        if (in != nullptr)
553
112
        {
554
113
            *in = nullptr;
555
114
        }
556
115
    }
557
92
};
116
};
558
93
117
559
94
TEST_F(GlibMemoryTest, Unique)
118
TEST_F(GlibMemoryTest, Unique)
560
@@ -147,4 +171,108 @@
561
147
    }
171
    }
562
148
}
172
}
563
149
173
564
174
TEST_F(GlibMemoryTest, UPtrAssigner)
565
175
{
566
176
    auto gkf = unique_glib(g_key_file_new());
567
177
568
178
    {
569
179
        GErrorUPtr error;
570
180
        EXPECT_FALSE(g_key_file_get_boolean(gkf.get(), "group", "key", assign_glib(error)));
571
181
        ASSERT_TRUE(bool(error));
572
182
        EXPECT_EQ(G_KEY_FILE_ERROR_GROUP_NOT_FOUND, error->code);
573
183
    }
574
184
575
185
    g_key_file_set_boolean(gkf.get(), "group", "key", TRUE);
576
186
577
187
    {
578
188
        GErrorUPtr error;
579
189
        EXPECT_TRUE(g_key_file_get_boolean(gkf.get(), "group", "key", assign_glib(error)));
580
190
        EXPECT_FALSE(bool(error));
581
191
    }
582
192
583
193
    {
584
194
        gcharUPtr str;
585
195
        assignGChar(assign_glib(str));
586
196
        ASSERT_TRUE(bool(str));
587
197
        EXPECT_STREQ("hi", str.get());
588
198
    }
589
199
590
200
    {
591
201
       GErrorUPtr error;
592
202
       assignGError(assign_glib(error));
593
203
       ASSERT_TRUE(bool(error));
594
204
       assignEmptyGError(assign_glib(error));
595
205
       ASSERT_FALSE(bool(error));
596
206
   }
597
207
}
598
208
599
209
TEST_F(GlibMemoryTest, SPtrAssigner)
600
210
{
601
211
    auto gkf = share_glib(g_key_file_new());
602
212
603
213
    {
604
214
        GErrorSPtr error;
605
215
        EXPECT_FALSE(g_key_file_get_boolean(gkf.get(), "group", "key", assign_glib(error)));
606
216
        ASSERT_TRUE(bool(error));
607
217
        EXPECT_EQ(G_KEY_FILE_ERROR_GROUP_NOT_FOUND, error->code);
608
218
    }
609
219
610
220
    g_key_file_set_boolean(gkf.get(), "group", "key", TRUE);
611
221
612
222
    {
613
223
        GErrorSPtr error;
614
224
        EXPECT_TRUE(g_key_file_get_boolean(gkf.get(), "group", "key", assign_glib(error)));
615
225
        EXPECT_FALSE(bool(error));
616
226
    }
617
227
618
228
    {
619
229
        gcharSPtr str;
620
230
        assignGChar(assign_glib(str));
621
231
        ASSERT_TRUE(bool(str));
622
232
        EXPECT_STREQ("hi", str.get());
623
233
    }
624
234
625
235
    {
626
236
       GErrorSPtr error;
627
237
       assignGError(assign_glib(error));
628
238
       ASSERT_TRUE(bool(error));
629
239
       assignEmptyGError(assign_glib(error));
630
240
       ASSERT_FALSE(bool(error));
631
241
   }
632
242
}
633
243
634
244
TEST_F(GlibMemoryTest, GCharUPtr)
635
245
{
636
246
    {
637
247
        auto strv = unique_glib(g_strsplit("a b c", " ", 0));
638
248
        ASSERT_TRUE(bool(strv));
639
249
        EXPECT_STREQ("a", strv.get()[0]);
640
250
        EXPECT_STREQ("b", strv.get()[1]);
641
251
        EXPECT_STREQ("c", strv.get()[2]);
642
252
    }
643
253
644
254
    {
645
255
        auto str = unique_glib(g_strdup("hello"));
646
256
        ASSERT_TRUE(bool(str));
647
257
        EXPECT_STREQ("hello", str.get());
648
258
    }
649
259
}
650
260
651
261
TEST_F(GlibMemoryTest, GCharSPtr)
652
262
{
653
263
    {
654
264
        auto strv = share_glib(g_strsplit("a b c", " ", 0));
655
265
        ASSERT_TRUE(bool(strv));
656
266
        EXPECT_STREQ("a", strv.get()[0]);
657
267
        EXPECT_STREQ("b", strv.get()[1]);
658
268
        EXPECT_STREQ("c", strv.get()[2]);
659
269
    }
660
270
661
271
    {
662
272
        auto str = share_glib(g_strdup("hello"));
663
273
        ASSERT_TRUE(bool(str));
664
274
        EXPECT_STREQ("hello", str.get());
665
275
    }
666
276
}
667
277
668
150
}
278
}
Status:	Merged
Approved by:	Pete Woods on 2017-04-04
Approved revision:	296
Merged at revision:	281
Proposed branch:	lp:~pete-woods/unity-api/add-glib-assigner-class
Merge into:	lp:unity-api
Prerequisite:	lp:~pete-woods/unity-api/throw-for-unowned-types-lp1672657
Diff against target:	668 lines (+447/-43) 5 files modified debian/changelog (+6/-0) include/unity/util/GObjectMemory.h (+67/-6) include/unity/util/GlibMemory.h (+142/-24) test/gtest/unity/util/GObjectMemory/GObjectMemory_test.cpp (+104/-13) test/gtest/unity/util/GlibMemory/GlibMemory_test.cpp (+128/-0)
To merge this branch:	bzr merge lp:~pete-woods/unity-api/add-glib-assigner-class
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Michi Henning (community)			Approve on 2017-03-23
Unity8 CI Bot	continuous-integration		Approve on 2017-03-23
Alan Griffiths			Abstain on 2017-03-22
Charles Kerr (community)		2017-03-20	Approve on 2017-03-20
Review via email: mp+320375@code.launchpad.net