1
=== modified file 'CMakeLists.txt'
2
--- CMakeLists.txt	2015-08-11 14:05:12 +0000
3
+++ CMakeLists.txt	2016-03-30 08:50:57 +0000
4
@@ -122,7 +122,7 @@
5
122
# API version
122
# API version
6
123
set(UNITY_API_MAJOR 0)
123
set(UNITY_API_MAJOR 0)
7
124
set(UNITY_API_MINOR 1)
124
set(UNITY_API_MINOR 1)
9
125
set(UNITY_API_MICRO 5)
125
set(UNITY_API_MICRO 6)
10
126
set(UNITY_API_VERSION "${UNITY_API_MAJOR}.${UNITY_API_MINOR}.${UNITY_API_MICRO}")
126
set(UNITY_API_VERSION "${UNITY_API_MAJOR}.${UNITY_API_MINOR}.${UNITY_API_MICRO}")
11
127
127
12
128
# API library
128
# API library
13
129
129
14
=== modified file 'debian/changelog'
15
--- debian/changelog	2016-03-22 07:48:55 +0000
16
+++ debian/changelog	2016-03-30 08:50:57 +0000
17
@@ -1,3 +1,9 @@
18
1
unity-api (7.109-0ubuntu1) UNRELEASED; urgency=medium
19
2
20
3
  * Add set*() methods to IniParser
21
4
22
5
 -- Marcus Tomlinson <marcus.tomlinson@canonical.com>  Tue, 29 Mar 2016 08:32:15 +0200
23
6
24
1
unity-api (7.108+16.04.20160322-0ubuntu1) xenial; urgency=medium
7
unity-api (7.108+16.04.20160322-0ubuntu1) xenial; urgency=medium
25
2
8
26
3
  [ Lukáš Tinkl, Michał Sawicz ]
9
  [ Lukáš Tinkl, Michał Sawicz ]
27
4
10
28
=== modified file 'include/unity/util/IniParser.h'
29
--- include/unity/util/IniParser.h	2014-07-03 05:00:00 +0000
30
+++ include/unity/util/IniParser.h	2016-03-30 08:50:57 +0000
31
@@ -22,8 +22,8 @@
32
22
#include <unity/SymbolExport.h>
22
#include <unity/SymbolExport.h>
33
23
#include <unity/util/DefinesPtrs.h>
23
#include <unity/util/DefinesPtrs.h>
34
24
24
37
25
#include<string>
25
#include <string>
38
26
#include<vector>
26
#include <vector>
39
27
27
40
28
namespace unity
28
namespace unity
41
29
{
29
{
42
@@ -37,11 +37,11 @@
43
37
}
37
}
44
38
38
45
39
/**
39
/**
47
40
\brief Helper class to read configuration files.
40
\brief Helper class to read and write configuration files.
48
41
41
49
42
This class reads configuration files in the .ini format
42
This class reads configuration files in the .ini format
50
43
and provides for a simple and type safe way of extracting
43
and provides for a simple and type safe way of extracting
52
44
information. A typical ini file looks like this:
44
and inserting information. A typical ini file looks like this:
53
45
45
54
46
~~~
46
~~~
55
47
[group1]
47
[group1]
56
@@ -55,14 +55,17 @@
57
55
key2 = othervalue2
55
key2 = othervalue2
58
56
~~~
56
~~~
59
57
57
68
58
To obtain a value, simply specify the group and key names to
58
To extract/insert a value, simply specify the group and key
69
59
the get* functions of this class. The array functions use
59
names to the get/set methods of this class, respectively.
70
60
a semicolon as a separator.
60
The array methods use a semicolon as a separator.
71
61
61
72
62
The get functions indicate errors by throwing LogicExceptions.
62
To write unsaved changes back to the configuration file, call
73
63
Examples why this might happen is because a value can't be
63
sync(). The sync() method will throw a FileException if it
74
64
coerced into the given type (i.e trying to convert the value
64
fails to write to file.
75
65
"hello" into a boolean).
65
76
66
The get methods indicate errors by throwing LogicException.
77
67
78
68
All methods are thread-safe.
79
66
*/
69
*/
80
67
70
81
68
class UNITY_API IniParser final {
71
class UNITY_API IniParser final {
82
@@ -78,31 +81,72 @@
83
78
    IniParser() = delete;
81
    IniParser() = delete;
84
79
    /// @endcond
82
    /// @endcond
85
80
83
86
81
    /** @name Accessors
87
82
     * These member functions provide access to configuration entries by group and key.
88
83
     * Attempts to retrieve a value as the wrong type, such as retrieving a string value
89
84
     * "abc" as an integer, throw LogicException.
90
85
      **/
91
86
    //{@
84
    //{@
92
85
93
86
    /** @name Read Methods
94
87
     * These member functions provide read access to configuration entries by group and key.<br>
95
88
     * Attempts to retrieve a value as the wrong type (such as retrieving a string value as an
96
89
     * integer) or to retrieve a value for a non-existent group or key throw LogicException.
97
90
     **/
98
91
99
87
    bool has_group(const std::string& group) const noexcept;
92
    bool has_group(const std::string& group) const noexcept;
100
88
    bool has_key(const std::string& group, const std::string& key) const;
93
    bool has_key(const std::string& group, const std::string& key) const;
101
94
102
89
    std::string get_string(const std::string& group, const std::string& key) const;
95
    std::string get_string(const std::string& group, const std::string& key) const;
103
90
    std::string get_locale_string(const std::string& group,
96
    std::string get_locale_string(const std::string& group,
104
91
                                  const std::string& key,
97
                                  const std::string& key,
105
92
                                  const std::string& locale = std::string()) const;
98
                                  const std::string& locale = std::string()) const;
106
93
    bool get_boolean(const std::string& group, const std::string& key) const;
99
    bool get_boolean(const std::string& group, const std::string& key) const;
107
94
    int get_int(const std::string& group, const std::string& key) const;
100
    int get_int(const std::string& group, const std::string& key) const;
108
101
    double get_double(const std::string& group, const std::string& key) const;
109
95
102
110
96
    std::vector<std::string> get_string_array(const std::string& group, const std::string& key) const;
103
    std::vector<std::string> get_string_array(const std::string& group, const std::string& key) const;
111
97
    std::vector<std::string> get_locale_string_array(const std::string& group,
104
    std::vector<std::string> get_locale_string_array(const std::string& group,
112
98
                                                     const std::string& key,
105
                                                     const std::string& key,
113
99
                                                     const std::string& locale = std::string()) const;
106
                                                     const std::string& locale = std::string()) const;
114
107
    std::vector<bool> get_boolean_array(const std::string& group, const std::string& key) const;
115
100
    std::vector<int> get_int_array(const std::string& group, const std::string& key) const;
108
    std::vector<int> get_int_array(const std::string& group, const std::string& key) const;
117
101
    std::vector<bool> get_boolean_array(const std::string& group, const std::string& key) const;
109
    std::vector<double> get_double_array(const std::string& group, const std::string& key) const;
118
102
110
119
103
    std::string get_start_group() const;
111
    std::string get_start_group() const;
120
104
    std::vector<std::string> get_groups() const;
112
    std::vector<std::string> get_groups() const;
121
105
    std::vector<std::string> get_keys(const std::string& group) const;
113
    std::vector<std::string> get_keys(const std::string& group) const;
122
114
123
115
    /** @name Write Methods
124
116
     * These member functions provide write access to configuration entries by group and key.<br>
125
117
     * Attempts to remove groups or keys that do not exist throw LogicException.<br>
126
118
     * The set methods replace the value for a key if the key exists. Calling a set method for a
127
119
     * non-existent group and/or key creates the group and/or key.
128
120
      **/
129
121
130
122
    bool remove_group(const std::string& group);
131
123
    bool remove_key(const std::string& group, const std::string& key);
132
124
133
125
    void set_string(const std::string& group, const std::string& key, const std::string& value);
134
126
    void set_locale_string(const std::string& group,
135
127
                           const std::string& key,
136
128
                           const std::string& value,
137
129
                           const std::string& locale = std::string());
138
130
    void set_boolean(const std::string& group, const std::string& key, bool value);
139
131
    void set_int(const std::string& group, const std::string& key, int value);
140
132
    void set_double(const std::string& group, const std::string& key, double value);
141
133
142
134
    void set_string_array(const std::string& group, const std::string& key, const std::vector<std::string>& value);
143
135
    void set_locale_string_array(const std::string& group,
144
136
                                 const std::string& key,
145
137
                                 const std::vector<std::string>& value,
146
138
                                 const std::string& locale = std::string());
147
139
    void set_boolean_array(const std::string& group, const std::string& key, const std::vector<bool>& value);
148
140
    void set_int_array(const std::string& group, const std::string& key, const std::vector<int>& value);
149
141
    void set_double_array(const std::string& group, const std::string& key, const std::vector<double>& value);
150
142
151
143
    /** @name Sync Method
152
144
     * This member function writes unsaved changes back to the configuration file.<br>
153
145
     * A failure to write to the file throws a FileException.
154
146
      **/
155
147
156
148
    void sync();
157
149
158
106
    //@}
150
    //@}
159
107
151
160
108
private:
152
private:
161
109
153
162
=== modified file 'src/unity/util/IniParser.cpp'
163
--- src/unity/util/IniParser.cpp	2014-07-03 05:00:00 +0000
164
+++ src/unity/util/IniParser.cpp	2016-03-30 08:50:57 +0000
165
@@ -16,10 +16,12 @@
166
16
 * Authored by: Jussi Pakkanen <jussi.pakkanen@canonical.com>
16
 * Authored by: Jussi Pakkanen <jussi.pakkanen@canonical.com>
167
17
 */
17
 */
168
18
18
173
19
#include<unity/UnityExceptions.h>
19
#include <unity/UnityExceptions.h>
174
20
#include<unity/util/IniParser.h>
20
#include <unity/util/IniParser.h>
175
21
#include<glib.h>
21
176
22
#include<mutex>
22
#include <mutex>
177
23
178
24
#include <glib.h>
179
23
25
180
24
using namespace std;
26
using namespace std;
181
25
27
182
@@ -29,7 +31,6 @@
183
29
namespace util
31
namespace util
184
30
{
32
{
185
31
33
186
32
187
33
namespace internal
34
namespace internal
188
34
{
35
{
189
35
36
190
@@ -37,6 +38,7 @@
191
37
{
38
{
192
38
    GKeyFile *k;
39
    GKeyFile *k;
193
39
    string filename;
40
    string filename;
194
41
    bool dirty = false;
195
40
};
42
};
196
41
43
197
42
static std::mutex parser_mutex;
44
static std::mutex parser_mutex;
198
@@ -68,8 +70,6 @@
199
68
70
200
69
IniParser::IniParser(const char* filename)
71
IniParser::IniParser(const char* filename)
201
70
{
72
{
202
71
    lock_guard<std::mutex> lock(internal::parser_mutex);
203
72
204
73
    GKeyFile* kf = g_key_file_new();
73
    GKeyFile* kf = g_key_file_new();
205
74
    GError* e = nullptr;
74
    GError* e = nullptr;
206
75
    if (!kf)
75
    if (!kf)
207
@@ -95,14 +95,14 @@
208
95
95
209
96
IniParser::~IniParser() noexcept
96
IniParser::~IniParser() noexcept
210
97
{
97
{
211
98
    lock_guard<std::mutex> lock(internal::parser_mutex);
212
99
213
100
    g_key_file_free(p->k);
98
    g_key_file_free(p->k);
214
101
    delete p;
99
    delete p;
215
102
}
100
}
216
103
101
217
104
bool IniParser::has_group(const std::string& group) const noexcept
102
bool IniParser::has_group(const std::string& group) const noexcept
218
105
{
103
{
219
104
    lock_guard<std::mutex> lock(internal::parser_mutex);
220
105
221
106
    gboolean rval;
106
    gboolean rval;
222
107
    rval = g_key_file_has_group(p->k, group.c_str());
107
    rval = g_key_file_has_group(p->k, group.c_str());
223
108
    return rval;
108
    return rval;
224
@@ -110,6 +110,8 @@
225
110
110
226
111
bool IniParser::has_key(const std::string& group, const std::string& key) const
111
bool IniParser::has_key(const std::string& group, const std::string& key) const
227
112
{
112
{
228
113
    lock_guard<std::mutex> lock(internal::parser_mutex);
229
114
230
113
    gboolean rval;
115
    gboolean rval;
231
114
    GError* e = nullptr;
116
    GError* e = nullptr;
232
115
    rval = g_key_file_has_key(p->k, group.c_str(), key.c_str(), &e);
117
    rval = g_key_file_has_key(p->k, group.c_str(), key.c_str(), &e);
233
@@ -119,6 +121,8 @@
234
119
121
235
120
std::string IniParser::get_string(const std::string& group, const std::string& key) const
122
std::string IniParser::get_string(const std::string& group, const std::string& key) const
236
121
{
123
{
237
124
    lock_guard<std::mutex> lock(internal::parser_mutex);
238
125
239
122
    gchar* value;
126
    gchar* value;
240
123
    GError* e = nullptr;
127
    GError* e = nullptr;
241
124
    string result;
128
    string result;
242
@@ -131,6 +135,8 @@
243
131
135
244
132
std::string IniParser::get_locale_string(const std::string& group, const std::string& key, const std::string& locale) const
136
std::string IniParser::get_locale_string(const std::string& group, const std::string& key, const std::string& locale) const
245
133
{
137
{
246
138
    lock_guard<std::mutex> lock(internal::parser_mutex);
247
139
248
134
    gchar* value;
140
    gchar* value;
249
135
    GError* e = nullptr;
141
    GError* e = nullptr;
250
136
    string result;
142
    string result;
251
@@ -143,6 +149,8 @@
252
143
149
253
144
bool IniParser::get_boolean(const std::string& group, const std::string& key) const
150
bool IniParser::get_boolean(const std::string& group, const std::string& key) const
254
145
{
151
{
255
152
    lock_guard<std::mutex> lock(internal::parser_mutex);
256
153
257
146
    bool rval;
154
    bool rval;
258
147
    GError* e = nullptr;
155
    GError* e = nullptr;
259
148
    rval = g_key_file_get_boolean(p->k, group.c_str(), key.c_str(), &e);
156
    rval = g_key_file_get_boolean(p->k, group.c_str(), key.c_str(), &e);
260
@@ -152,6 +160,8 @@
261
152
160
262
153
int IniParser::get_int(const std::string& group, const std::string& key) const
161
int IniParser::get_int(const std::string& group, const std::string& key) const
263
154
{
162
{
264
163
    lock_guard<std::mutex> lock(internal::parser_mutex);
265
164
266
155
    int rval;
165
    int rval;
267
156
    GError* e = nullptr;
166
    GError* e = nullptr;
268
157
    rval = g_key_file_get_integer(p->k, group.c_str(), key.c_str(), &e);
167
    rval = g_key_file_get_integer(p->k, group.c_str(), key.c_str(), &e);
269
@@ -159,8 +169,21 @@
270
159
    return rval;
169
    return rval;
271
160
}
170
}
272
161
171
273
172
double IniParser::get_double(const std::string& group, const std::string& key) const
274
173
{
275
174
    lock_guard<std::mutex> lock(internal::parser_mutex);
276
175
277
176
    double rval;
278
177
    GError* e = nullptr;
279
178
    rval = g_key_file_get_double(p->k, group.c_str(), key.c_str(), &e);
280
179
    inspect_error(e, "Could not get double value", p->filename, group);
281
180
    return rval;
282
181
}
283
182
284
162
std::vector<std::string> IniParser::get_string_array(const std::string& group, const std::string& key) const
183
std::vector<std::string> IniParser::get_string_array(const std::string& group, const std::string& key) const
285
163
{
184
{
286
185
    lock_guard<std::mutex> lock(internal::parser_mutex);
287
186
288
164
    vector<string> result;
187
    vector<string> result;
289
165
    GError* e = nullptr;
188
    GError* e = nullptr;
290
166
    gchar** strlist;
189
    gchar** strlist;
291
@@ -179,6 +202,8 @@
292
179
                                                            const std::string& key,
202
                                                            const std::string& key,
293
180
                                                            const std::string& locale) const
203
                                                            const std::string& locale) const
294
181
{
204
{
295
205
    lock_guard<std::mutex> lock(internal::parser_mutex);
296
206
297
182
    vector<string> result;
207
    vector<string> result;
298
183
    GError* e = nullptr;
208
    GError* e = nullptr;
299
184
    gchar** strlist;
209
    gchar** strlist;
300
@@ -194,8 +219,28 @@
301
194
    return result;
219
    return result;
302
195
}
220
}
303
196
221
304
222
vector<bool> IniParser::get_boolean_array(const std::string& group, const std::string& key) const
305
223
{
306
224
    lock_guard<std::mutex> lock(internal::parser_mutex);
307
225
308
226
    vector<bool> result;
309
227
    GError* e = nullptr;
310
228
    gboolean* bools;
311
229
    gsize count;
312
230
    bools = g_key_file_get_boolean_list(p->k, group.c_str(), key.c_str(), &count, &e);
313
231
    inspect_error(e, "Could not get boolean array", p->filename, group);
314
232
    for (gsize i = 0; i < count; i++)
315
233
    {
316
234
        result.push_back(bools[i]);
317
235
    }
318
236
    g_free(bools);
319
237
    return result;
320
238
}
321
239
322
197
vector<int> IniParser::get_int_array(const std::string& group, const std::string& key) const
240
vector<int> IniParser::get_int_array(const std::string& group, const std::string& key) const
323
198
{
241
{
324
242
    lock_guard<std::mutex> lock(internal::parser_mutex);
325
243
326
199
    vector<int> result;
244
    vector<int> result;
327
200
    GError* e = nullptr;
245
    GError* e = nullptr;
328
201
    gint* ints;
246
    gint* ints;
329
@@ -210,24 +255,28 @@
330
210
    return result;
255
    return result;
331
211
}
256
}
332
212
257
334
213
vector<bool> IniParser::get_boolean_array(const std::string& group, const std::string& key) const
258
vector<double> IniParser::get_double_array(const std::string& group, const std::string& key) const
335
214
{
259
{
337
215
    vector<bool> result;
260
    lock_guard<std::mutex> lock(internal::parser_mutex);
338
261
339
262
    vector<double> result;
340
216
    GError* e = nullptr;
263
    GError* e = nullptr;
342
217
    gboolean* bools;
264
    gdouble* doubles;
343
218
    gsize count;
265
    gsize count;
346
219
    bools = g_key_file_get_boolean_list(p->k, group.c_str(), key.c_str(), &count, &e);
266
    doubles = g_key_file_get_double_list(p->k, group.c_str(), key.c_str(), &count, &e);
347
220
    inspect_error(e, "Could not get boolean array", p->filename, group);
267
    inspect_error(e, "Could not get double array", p->filename, group);
348
221
    for (gsize i = 0; i < count; i++)
268
    for (gsize i = 0; i < count; i++)
349
222
    {
269
    {
351
223
        result.push_back(bools[i]);
270
        result.push_back(doubles[i]);
352
224
    }
271
    }
354
225
    g_free(bools);
272
    g_free(doubles);
355
226
    return result;
273
    return result;
356
227
}
274
}
357
228
275
358
229
string IniParser::get_start_group() const
276
string IniParser::get_start_group() const
359
230
{
277
{
360
278
    lock_guard<std::mutex> lock(internal::parser_mutex);
361
279
362
231
    gchar* sg = g_key_file_get_start_group(p->k);
280
    gchar* sg = g_key_file_get_start_group(p->k);
363
232
    string result(sg);
281
    string result(sg);
364
233
    g_free(sg);
282
    g_free(sg);
365
@@ -236,6 +285,8 @@
366
236
285
367
237
vector<string> IniParser::get_groups() const
286
vector<string> IniParser::get_groups() const
368
238
{
287
{
369
288
    lock_guard<std::mutex> lock(internal::parser_mutex);
370
289
371
239
    vector<string> result;
290
    vector<string> result;
372
240
    gsize count;
291
    gsize count;
373
241
    gchar** groups = g_key_file_get_groups(p->k, &count);
292
    gchar** groups = g_key_file_get_groups(p->k, &count);
374
@@ -249,6 +300,8 @@
375
249
300
376
250
vector<string> IniParser::get_keys(const std::string& group) const
301
vector<string> IniParser::get_keys(const std::string& group) const
377
251
{
302
{
378
303
    lock_guard<std::mutex> lock(internal::parser_mutex);
379
304
380
252
    vector<string> result;
305
    vector<string> result;
381
253
    GError* e = nullptr;
306
    GError* e = nullptr;
382
254
    gchar** strlist;
307
    gchar** strlist;
383
@@ -264,6 +317,184 @@
384
264
    return result;
317
    return result;
385
265
}
318
}
386
266
319
387
320
bool IniParser::remove_group(const std::string& group)
388
321
{
389
322
    lock_guard<std::mutex> lock(internal::parser_mutex);
390
323
391
324
    gboolean rval;
392
325
    GError* e = nullptr;
393
326
    rval = g_key_file_remove_group(p->k, group.c_str(), &e);
394
327
    inspect_error(e, "Error removing group", p->filename, group);
395
328
    return rval;
396
329
}
397
330
398
331
bool IniParser::remove_key(const std::string& group, const std::string& key)
399
332
{
400
333
    lock_guard<std::mutex> lock(internal::parser_mutex);
401
334
402
335
    gboolean rval;
403
336
    GError* e = nullptr;
404
337
    rval = g_key_file_remove_key(p->k, group.c_str(), key.c_str(), &e);
405
338
    inspect_error(e, "Error removing key", p->filename, group);
406
339
    return rval;
407
340
}
408
341
409
342
void IniParser::set_string(const std::string& group, const std::string& key, const std::string& value)
410
343
{
411
344
    lock_guard<std::mutex> lock(internal::parser_mutex);
412
345
413
346
    g_key_file_set_string(p->k, group.c_str(), key.c_str(), value.c_str());
414
347
    p->dirty = true;
415
348
}
416
349
417
350
void IniParser::set_locale_string(const std::string& group, const std::string& key,
418
351
                                  const std::string& value, const std::string& locale)
419
352
{
420
353
    lock_guard<std::mutex> lock(internal::parser_mutex);
421
354
422
355
    g_key_file_set_locale_string(p->k, group.c_str(), key.c_str(), locale.c_str(), value.c_str());
423
356
    p->dirty = true;
424
357
}
425
358
426
359
void IniParser::set_boolean(const std::string& group, const std::string& key, bool value)
427
360
{
428
361
    lock_guard<std::mutex> lock(internal::parser_mutex);
429
362
430
363
    g_key_file_set_boolean(p->k, group.c_str(), key.c_str(), value);
431
364
    p->dirty = true;
432
365
}
433
366
434
367
void IniParser::set_int(const std::string& group, const std::string& key, int value)
435
368
{
436
369
    lock_guard<std::mutex> lock(internal::parser_mutex);
437
370
438
371
    g_key_file_set_integer(p->k, group.c_str(), key.c_str(), value);
439
372
    p->dirty = true;
440
373
}
441
374
442
375
void IniParser::set_double(const std::string& group, const std::string& key, double value)
443
376
{
444
377
    lock_guard<std::mutex> lock(internal::parser_mutex);
445
378
446
379
    g_key_file_set_double(p->k, group.c_str(), key.c_str(), value);
447
380
    p->dirty = true;
448
381
}
449
382
450
383
void IniParser::set_string_array(const std::string& group, const std::string& key,
451
384
                                 const std::vector<std::string>& value)
452
385
{
453
386
    lock_guard<std::mutex> lock(internal::parser_mutex);
454
387
455
388
    int count = value.size();
456
389
    gchar** strlist = g_new(gchar*, count+1);
457
390
458
391
    for (int i = 0; i < count; ++i)
459
392
    {
460
393
        strlist[i] = g_strdup(value[i].c_str());
461
394
    }
462
395
    strlist[count] = nullptr;
463
396
464
397
    g_key_file_set_string_list(p->k, group.c_str(), key.c_str(), strlist, count);
465
398
    p->dirty = true;
466
399
467
400
    g_strfreev(strlist);
468
401
}
469
402
470
403
void IniParser::set_locale_string_array(const std::string& group, const std::string& key,
471
404
                                        const std::vector<std::string>& value, const std::string& locale)
472
405
{
473
406
    lock_guard<std::mutex> lock(internal::parser_mutex);
474
407
475
408
    int count = value.size();
476
409
    gchar** strlist = g_new(gchar*, count+1);
477
410
478
411
    for (int i = 0; i < count; ++i)
479
412
    {
480
413
        strlist[i] = g_strdup(value[i].c_str());
481
414
    }
482
415
    strlist[count] = nullptr;
483
416
484
417
    g_key_file_set_locale_string_list(p->k, group.c_str(), key.c_str(), locale.c_str(), strlist, count);
485
418
    p->dirty = true;
486
419
487
420
    g_strfreev(strlist);
488
421
}
489
422
490
423
void IniParser::set_boolean_array(const std::string& group, const std::string& key, const std::vector<bool>& value)
491
424
{
492
425
    lock_guard<std::mutex> lock(internal::parser_mutex);
493
426
494
427
    int count = value.size();
495
428
    gboolean* boollist = g_new(gboolean, count);
496
429
497
430
    for (int i = 0; i < count; ++i)
498
431
    {
499
432
        boollist[i] = value[i];
500
433
    }
501
434
502
435
    g_key_file_set_boolean_list(p->k, group.c_str(), key.c_str(), boollist, count);
503
436
    p->dirty = true;
504
437
505
438
    g_free(boollist);
506
439
}
507
440
508
441
void IniParser::set_int_array(const std::string& group, const std::string& key, const std::vector<int>& value)
509
442
{
510
443
    lock_guard<std::mutex> lock(internal::parser_mutex);
511
444
512
445
    int count = value.size();
513
446
    gint* intlist = g_new(gint, count);
514
447
515
448
    for (int i = 0; i < count; ++i)
516
449
    {
517
450
        intlist[i] = value[i];
518
451
    }
519
452
520
453
    g_key_file_set_integer_list(p->k, group.c_str(), key.c_str(), intlist, count);
521
454
    p->dirty = true;
522
455
523
456
    g_free(intlist);
524
457
}
525
458
526
459
void IniParser::set_double_array(const std::string& group, const std::string& key, const std::vector<double>& value)
527
460
{
528
461
    lock_guard<std::mutex> lock(internal::parser_mutex);
529
462
530
463
    int count = value.size();
531
464
    gdouble* doublelist = g_new(gdouble, count);
532
465
533
466
    for (int i = 0; i < count; ++i)
534
467
    {
535
468
        doublelist[i] = value[i];
536
469
    }
537
470
538
471
    g_key_file_set_double_list(p->k, group.c_str(), key.c_str(), doublelist, count);
539
472
    p->dirty = true;
540
473
541
474
    g_free(doublelist);
542
475
}
543
476
544
477
void IniParser::sync()
545
478
{
546
479
    lock_guard<std::mutex> lock(internal::parser_mutex);
547
480
548
481
    if (p->dirty)
549
482
    {
550
483
        GError* e = nullptr;
551
484
        if (!g_key_file_save_to_file(p->k, p->filename.c_str(), &e))
552
485
        {
553
486
            string message = "Could not write ini file ";
554
487
            message += p->filename;
555
488
            message += ": ";
556
489
            message += e->message;
557
490
            int errnum = e->code;
558
491
            g_error_free(e);
559
492
            throw FileException(message, errnum);
560
493
        }
561
494
562
495
        p->dirty = false;
563
496
    }
564
497
}
565
267
498
566
268
} // namespace util
499
} // namespace util
567
269
500
568
270
501
569
=== modified file 'test/data/sample.ini'
570
--- test/data/sample.ini	2014-07-03 05:00:00 +0000
571
+++ test/data/sample.ini	2016-03-30 08:50:57 +0000
572
@@ -1,6 +1,7 @@
573
1
[first]
1
[first]
574
2
2
575
3
intvalue = 1
3
intvalue = 1
576
4
doublevalue = 2.345
577
4
boolvalue = true
5
boolvalue = true
578
5
stringvalue = hello
6
stringvalue = hello
579
6
locstring = world
7
locstring = world
580
@@ -17,3 +18,4 @@
581
17
boolvalue = false
18
boolvalue = false
582
18
stringvalue = there
19
stringvalue = there
583
19
intarray = 4;5;6;78;8;9;9;345;3
20
intarray = 4;5;6;78;8;9;9;345;3
584
21
doublearray = 4.5;6.78;9;10.11
585
20
22
586
=== modified file 'test/gtest/unity/util/IniParser/CMakeLists.txt'
587
--- test/gtest/unity/util/IniParser/CMakeLists.txt	2013-06-06 12:02:05 +0000
588
+++ test/gtest/unity/util/IniParser/CMakeLists.txt	2016-03-30 08:50:57 +0000
589
@@ -1,4 +1,6 @@
590
1
add_executable(IniParser_test IniParser_test.cpp)
1
add_executable(IniParser_test IniParser_test.cpp)
591
2
target_link_libraries(IniParser_test ${LIBS} ${TESTLIBS})
2
target_link_libraries(IniParser_test ${LIBS} ${TESTLIBS})
592
3
3
593
4
add_definitions(-DTEST_RUNTIME_PATH="${CMAKE_CURRENT_BINARY_DIR}")
594
5
595
4
add_test(IniParser IniParser_test)
6
add_test(IniParser IniParser_test)
596
5
7
597
=== modified file 'test/gtest/unity/util/IniParser/IniParser_test.cpp'
598
--- test/gtest/unity/util/IniParser/IniParser_test.cpp	2014-07-03 05:00:00 +0000
599
+++ test/gtest/unity/util/IniParser/IniParser_test.cpp	2016-03-30 08:50:57 +0000
600
@@ -26,6 +26,7 @@
601
26
using namespace unity::util;
26
using namespace unity::util;
602
27
27
603
28
#define INI_FILE UNITY_API_TEST_DATADIR "/sample.ini"
28
#define INI_FILE UNITY_API_TEST_DATADIR "/sample.ini"
604
29
#define INI_TEMP_FILE TEST_RUNTIME_PATH "/temp.ini"
605
29
30
606
30
TEST(IniParser, basic)
31
TEST(IniParser, basic)
607
31
{
32
{
608
@@ -45,11 +46,23 @@
609
45
{
46
{
610
46
    IniParser conf(INI_FILE);
47
    IniParser conf(INI_FILE);
611
47
48
613
48
    ASSERT_TRUE(conf.has_group("first"));
49
    ASSERT_FALSE(conf.has_key("first", "missingvalue"));
614
49
    ASSERT_FALSE(conf.has_group("nonexisting"));
50
    ASSERT_FALSE(conf.has_group("nonexisting"));
615
50
51
616
51
    ASSERT_TRUE(conf.has_key("first", "stringvalue"));
52
    ASSERT_TRUE(conf.has_key("first", "stringvalue"));
618
52
    ASSERT_FALSE(conf.has_key("first", "missingvalue"));
53
    ASSERT_TRUE(conf.has_group("first"));
619
54
620
55
    ASSERT_TRUE(conf.remove_key("first", "stringvalue"));
621
56
    EXPECT_THROW(conf.remove_key("first", "missingvalue"), LogicException);
622
57
623
58
    ASSERT_FALSE(conf.has_key("first", "stringvalue"));
624
59
    ASSERT_TRUE(conf.has_group("first"));
625
60
626
61
    ASSERT_TRUE(conf.remove_group("first"));
627
62
    EXPECT_THROW(conf.remove_group("nonexisting"), LogicException);
628
63
629
64
    EXPECT_THROW(conf.has_key("first", "stringvalue"), LogicException);
630
65
    ASSERT_FALSE(conf.has_group("first"));
631
53
}
66
}
632
54
67
633
55
TEST(IniParser, simpleQueries)
68
TEST(IniParser, simpleQueries)
634
@@ -64,11 +77,13 @@
635
64
    ASSERT_EQ("second", groups[1]);
77
    ASSERT_EQ("second", groups[1]);
636
65
78
637
66
    vector<string> firstKeys = conf.get_keys("first");
79
    vector<string> firstKeys = conf.get_keys("first");
640
67
    ASSERT_EQ(10, firstKeys.size());
80
    ASSERT_EQ(11, firstKeys.size());
641
68
    ASSERT_EQ("boolvalue", firstKeys[1]);
81
    ASSERT_EQ("boolvalue", firstKeys[2]);
642
69
82
643
70
    ASSERT_EQ(conf.get_string("first", "stringvalue"), "hello");
83
    ASSERT_EQ(conf.get_string("first", "stringvalue"), "hello");
644
71
    ASSERT_EQ(1, conf.get_int("first", "intvalue"));
84
    ASSERT_EQ(1, conf.get_int("first", "intvalue"));
645
85
    ASSERT_EQ(1, conf.get_double("first", "intvalue"));
646
86
    ASSERT_EQ(2.345, conf.get_double("first", "doublevalue"));
647
72
    ASSERT_FALSE(conf.get_boolean("second", "boolvalue"));
87
    ASSERT_FALSE(conf.get_boolean("second", "boolvalue"));
648
73
88
649
74
    ASSERT_EQ("world", conf.get_string("first", "locstring"));
89
    ASSERT_EQ("world", conf.get_string("first", "locstring"));
650
@@ -92,6 +107,18 @@
651
92
    ASSERT_EQ(4, intArr[0]);
107
    ASSERT_EQ(4, intArr[0]);
652
93
    ASSERT_EQ(3, intArr[8]);
108
    ASSERT_EQ(3, intArr[8]);
653
94
109
654
110
    vector<double> intToDblArr = conf.get_double_array("second", "intarray");
655
111
    ASSERT_EQ(9, intToDblArr.size());
656
112
    ASSERT_EQ(4, intToDblArr[0]);
657
113
    ASSERT_EQ(3, intToDblArr[8]);
658
114
659
115
    vector<double> dblArr = conf.get_double_array("second", "doublearray");
660
116
    ASSERT_EQ(4, dblArr.size());
661
117
    ASSERT_EQ(4.5, dblArr[0]);
662
118
    ASSERT_EQ(6.78, dblArr[1]);
663
119
    ASSERT_EQ(9, dblArr[2]);
664
120
    ASSERT_EQ(10.11, dblArr[3]);
665
121
666
95
    vector<bool> boolArr = conf.get_boolean_array("first", "boolarray");
122
    vector<bool> boolArr = conf.get_boolean_array("first", "boolarray");
667
96
    ASSERT_EQ(3, boolArr.size());
123
    ASSERT_EQ(3, boolArr.size());
668
97
    ASSERT_TRUE(boolArr[0]);
124
    ASSERT_TRUE(boolArr[0]);
669
@@ -115,36 +142,263 @@
670
115
{
142
{
671
116
    IniParser conf(INI_FILE);
143
    IniParser conf(INI_FILE);
672
117
144
674
118
    try {
145
    try
675
146
    {
676
119
        conf.get_string("foo", "bar");
147
        conf.get_string("foo", "bar");
681
120
        FAIL();
148
    }
682
121
    } catch(const LogicException &e) {
149
    catch (const LogicException& e)
683
122
    }
150
    {
684
123
    try {
151
        EXPECT_NE(string::npos, string(e.what()).find("Key file does not have group 'foo'"));
685
152
    }
686
153
    try
687
154
    {
688
124
        conf.get_locale_string("foo", "bar");
155
        conf.get_locale_string("foo", "bar");
693
125
        FAIL();
156
    }
694
126
    } catch(const LogicException &e) {
157
    catch (const LogicException& e)
695
127
    }
158
    {
696
128
    try {
159
        EXPECT_NE(string::npos, string(e.what()).find("Key file does not have group 'foo'"));
697
160
    }
698
161
    try
699
162
    {
700
129
        conf.get_int("foo", "bar");
163
        conf.get_int("foo", "bar");
705
130
        FAIL();
164
    }
706
131
    } catch(const LogicException &e) {
165
    catch (const LogicException& e)
707
132
    }
166
    {
708
133
    try {
167
        EXPECT_NE(string::npos, string(e.what()).find("Key file does not have group 'foo'"));
709
168
    }
710
169
    try
711
170
    {
712
171
        conf.get_int("first", "doublevalue");
713
172
    }
714
173
    catch (const LogicException& e)
715
174
    {
716
175
        EXPECT_NE(string::npos, string(e.what()).find("Key file contains key 'doublevalue' in group 'first' which has a value that cannot be interpreted."));
717
176
    }
718
177
    try
719
178
    {
720
134
        conf.get_boolean("foo", "bar");
179
        conf.get_boolean("foo", "bar");
726
135
        FAIL();
180
    }
727
136
    } catch(const LogicException &e) {
181
    catch (const LogicException& e)
728
137
    }
182
    {
729
138
183
        EXPECT_NE(string::npos, string(e.what()).find("Key file does not have group 'foo'"));
730
139
    try {
184
    }
731
185
    try
732
186
    {
733
140
        conf.get_int_array("first", "array");
187
        conf.get_int_array("first", "array");
739
141
        FAIL();
188
    }
740
142
    } catch(const LogicException &e) {
189
    catch (const LogicException& e)
741
143
    }
190
    {
742
144
191
        EXPECT_NE(string::npos, string(e.what()).find("Value 'foo' cannot be interpreted as a number."));
743
145
    try {
192
    }
744
193
    try
745
194
    {
746
195
        conf.get_int_array("second", "doublearray");
747
196
    }
748
197
    catch (const LogicException& e)
749
198
    {
750
199
        EXPECT_NE(string::npos, string(e.what()).find("Value '4.5' cannot be interpreted as a number."));
751
200
    }
752
201
    try
753
202
    {
754
146
        conf.get_boolean_array("first", "array");
203
        conf.get_boolean_array("first", "array");
758
147
        FAIL();
204
    }
759
148
    } catch(const LogicException &e) {
205
    catch (const LogicException& e)
760
149
    }
206
    {
761
207
        EXPECT_NE(string::npos, string(e.what()).find("Value 'foo' cannot be interpreted as a boolean."));
762
208
    }
763
209
}
764
210
765
211
TEST(IniParser, writeValues)
766
212
{
767
213
    // Create an empty ini file for writing
768
214
    auto f = fopen(INI_TEMP_FILE, "w");
769
215
    fclose(f);
770
216
771
217
    IniParser conf(INI_TEMP_FILE);
772
218
773
219
    conf.set_string("g1", "k1", "s0;s1");
774
220
    conf.set_locale_string("g1", "k2", "s2", "en");
775
221
    conf.set_locale_string("g1", "k2", "s3", "pt_BR");
776
222
777
223
    // Check temp file before sync()
778
224
    {
779
225
        IniParser conf2(INI_TEMP_FILE);
780
226
        EXPECT_EQ("s0;s1", conf.get_string("g1", "k1"));
781
227
        EXPECT_THROW(conf2.get_string("g1", "k1"), LogicException);
782
228
783
229
        EXPECT_EQ("s2", conf.get_locale_string("g1", "k2", "en"));
784
230
        EXPECT_THROW(conf2.get_locale_string("g1", "k2", "en"), LogicException);
785
231
786
232
        EXPECT_EQ("s3", conf.get_locale_string("g1", "k2", "pt_BR"));
787
233
        EXPECT_THROW(conf2.get_locale_string("g1", "k2", "pt_BR"), LogicException);
788
234
    }
789
235
790
236
    // Sync
791
237
    conf.sync();
792
238
793
239
    // Write some post-sync values
794
240
    conf.set_boolean("g2", "k1", false);
795
241
    conf.set_int("g2", "k2", 123);
796
242
    conf.set_double("g3", "k3", 4.56789);
797
243
798
244
    // Check temp file after first sync()
799
245
    {
800
246
        IniParser conf2(INI_TEMP_FILE);
801
247
        EXPECT_EQ("s0;s1", conf.get_string("g1", "k1"));
802
248
        EXPECT_EQ("s0;s1", conf2.get_string("g1", "k1"));
803
249
804
250
        EXPECT_EQ("s2", conf.get_locale_string("g1", "k2", "en"));
805
251
        EXPECT_EQ("s2", conf2.get_locale_string("g1", "k2", "en"));
806
252
807
253
        EXPECT_EQ("s3", conf.get_locale_string("g1", "k2", "pt_BR"));
808
254
        EXPECT_EQ("s3", conf2.get_locale_string("g1", "k2", "pt_BR"));
809
255
810
256
        EXPECT_EQ(false, conf.get_boolean("g2", "k1"));
811
257
        EXPECT_THROW(conf2.get_boolean("g2", "k1"), LogicException);
812
258
813
259
        EXPECT_EQ(123, conf.get_int("g2", "k2"));
814
260
        EXPECT_THROW(conf2.get_int("g2", "k2"), LogicException);
815
261
816
262
        EXPECT_EQ(4.56789, conf.get_double("g3", "k3"));
817
263
        EXPECT_THROW(conf2.get_double("g3", "k3"), LogicException);
818
264
    }
819
265
820
266
    // Sync
821
267
    conf.sync();
822
268
823
269
    // Check temp file after second sync()
824
270
    {
825
271
        IniParser conf2(INI_TEMP_FILE);
826
272
        EXPECT_EQ("s0;s1", conf.get_string("g1", "k1"));
827
273
        EXPECT_EQ("s0;s1", conf2.get_string("g1", "k1"));
828
274
829
275
        EXPECT_EQ("s2", conf.get_locale_string("g1", "k2", "en"));
830
276
        EXPECT_EQ("s2", conf2.get_locale_string("g1", "k2", "en"));
831
277
832
278
        EXPECT_EQ("s3", conf.get_locale_string("g1", "k2", "pt_BR"));
833
279
        EXPECT_EQ("s3", conf2.get_locale_string("g1", "k2", "pt_BR"));
834
280
835
281
        EXPECT_EQ(false, conf.get_boolean("g2", "k1"));
836
282
        EXPECT_EQ(false, conf2.get_boolean("g2", "k1"));
837
283
838
284
        EXPECT_EQ(123, conf.get_int("g2", "k2"));
839
285
        EXPECT_EQ(123, conf2.get_int("g2", "k2"));
840
286
841
287
        EXPECT_EQ(4.56789, conf.get_double("g3", "k3"));
842
288
        EXPECT_EQ(4.56789, conf2.get_double("g3", "k3"));
843
289
    }
844
290
}
845
291
846
292
template<class T>
847
293
void EXPECT_ARRAY_EQ(const vector<T>& expected, const vector<T>& actual)
848
294
{
849
295
    EXPECT_TRUE(expected == actual);
850
296
}
851
297
852
298
TEST(IniParser, writeArrays)
853
299
{
854
300
    // Create an empty ini file for writing
855
301
    auto f = fopen(INI_TEMP_FILE, "w");
856
302
    fclose(f);
857
303
858
304
    IniParser conf(INI_TEMP_FILE);
859
305
860
306
    conf.set_string_array("g1", "k1", {"s0;s1", "s2", "s3"});
861
307
    conf.set_locale_string_array("g1", "k2", {"s4", "s5", "s6"}, "en");
862
308
    conf.set_locale_string_array("g1", "k2", {"s7", "s8", "s9=s10"}, "pt_BR");
863
309
864
310
    // Check temp file before sync()
865
311
    {
866
312
        IniParser conf2(INI_TEMP_FILE);
867
313
        EXPECT_ARRAY_EQ({"s0;s1", "s2", "s3"}, conf.get_string_array("g1", "k1"));
868
314
        EXPECT_THROW(conf2.get_string_array("g1", "k1"), LogicException);
869
315
870
316
        EXPECT_ARRAY_EQ({"s4", "s5", "s6"}, conf.get_locale_string_array("g1", "k2", "en"));
871
317
        EXPECT_THROW(conf2.get_locale_string_array("g1", "k2", "en"), LogicException);
872
318
873
319
        EXPECT_ARRAY_EQ({"s7", "s8", "s9=s10"}, conf.get_locale_string_array("g1", "k2", "pt_BR"));
874
320
        EXPECT_THROW(conf2.get_locale_string_array("g1", "k2", "pt_BR"), LogicException);
875
321
    }
876
322
877
323
    // Sync
878
324
    conf.sync();
879
325
880
326
    // Write some post-sync values
881
327
    conf.set_boolean_array("g2", "k1", {true, false, false});
882
328
    conf.set_int_array("g2", "k2", {123, 456789, 101112});
883
329
    conf.set_double_array("g2", "k3", {13.14, 15.161718, 19.2});
884
330
885
331
    // Check temp file after first sync()
886
332
    {
887
333
        IniParser conf2(INI_TEMP_FILE);
888
334
        EXPECT_ARRAY_EQ({"s0;s1", "s2", "s3"}, conf.get_string_array("g1", "k1"));
889
335
        EXPECT_ARRAY_EQ({"s0;s1", "s2", "s3"}, conf2.get_string_array("g1", "k1"));
890
336
891
337
        EXPECT_ARRAY_EQ({"s4", "s5", "s6"}, conf.get_locale_string_array("g1", "k2", "en"));
892
338
        EXPECT_ARRAY_EQ({"s4", "s5", "s6"}, conf2.get_locale_string_array("g1", "k2", "en"));
893
339
894
340
        EXPECT_ARRAY_EQ({"s7", "s8", "s9=s10"}, conf.get_locale_string_array("g1", "k2", "pt_BR"));
895
341
        EXPECT_ARRAY_EQ({"s7", "s8", "s9=s10"}, conf2.get_locale_string_array("g1", "k2", "pt_BR"));
896
342
897
343
        EXPECT_ARRAY_EQ({true, false, false}, conf.get_boolean_array("g2", "k1"));
898
344
        EXPECT_THROW(conf2.get_boolean_array("g2", "k1"), LogicException);
899
345
900
346
        EXPECT_ARRAY_EQ({123, 456789, 101112}, conf.get_int_array("g2", "k2"));
901
347
        EXPECT_THROW(conf2.get_int_array("g2", "k2"), LogicException);
902
348
903
349
        EXPECT_ARRAY_EQ({13.14, 15.161718, 19.2}, conf.get_double_array("g2", "k3"));
904
350
        EXPECT_THROW(conf2.get_double_array("g2", "k3"), LogicException);
905
351
    }
906
352
907
353
    // Sync
908
354
    conf.sync();
909
355
910
356
    // Check temp file after second sync()
911
357
    {
912
358
        IniParser conf2(INI_TEMP_FILE);
913
359
        EXPECT_ARRAY_EQ({"s0;s1", "s2", "s3"}, conf.get_string_array("g1", "k1"));
914
360
        EXPECT_ARRAY_EQ({"s0;s1", "s2", "s3"}, conf2.get_string_array("g1", "k1"));
915
361
916
362
        EXPECT_ARRAY_EQ({"s4", "s5", "s6"}, conf.get_locale_string_array("g1", "k2", "en"));
917
363
        EXPECT_ARRAY_EQ({"s4", "s5", "s6"}, conf2.get_locale_string_array("g1", "k2", "en"));
918
364
919
365
        EXPECT_ARRAY_EQ({"s7", "s8", "s9=s10"}, conf.get_locale_string_array("g1", "k2", "pt_BR"));
920
366
        EXPECT_ARRAY_EQ({"s7", "s8", "s9=s10"}, conf2.get_locale_string_array("g1", "k2", "pt_BR"));
921
367
922
368
        EXPECT_ARRAY_EQ({true, false, false}, conf.get_boolean_array("g2", "k1"));
923
369
        EXPECT_ARRAY_EQ({true, false, false}, conf2.get_boolean_array("g2", "k1"));
924
370
925
371
        EXPECT_ARRAY_EQ({123, 456789, 101112}, conf.get_int_array("g2", "k2"));
926
372
        EXPECT_ARRAY_EQ({123, 456789, 101112}, conf2.get_int_array("g2", "k2"));
927
373
928
374
        EXPECT_ARRAY_EQ({13.14, 15.161718, 19.2}, conf.get_double_array("g2", "k3"));
929
375
        EXPECT_ARRAY_EQ({13.14, 15.161718, 19.2}, conf2.get_double_array("g2", "k3"));
930
376
    }
931
377
}
932
378
933
379
TEST(IniParser, writeError)
934
380
{
935
381
    // Create an empty ini file for writing
936
382
    auto f = fopen(INI_TEMP_FILE, "w");
937
383
    fclose(f);
938
384
939
385
    IniParser conf(INI_TEMP_FILE);
940
386
941
387
    // Replace ini file with a directory
942
388
    ASSERT_EQ(0, remove(INI_TEMP_FILE));
943
389
    ASSERT_EQ(0, mkdir(INI_TEMP_FILE, 0700));
944
390
945
391
    std::shared_ptr<void> rmdir_raii(nullptr, [](void*)
946
392
    {
947
393
        rmdir(INI_TEMP_FILE);
948
394
    });
949
395
950
396
    // Sync (no exception as config is not dirty)
951
397
    EXPECT_NO_THROW(conf.sync());
952
398
953
399
    // Dirty the config
954
400
    conf.set_boolean("g1", "k1", true);
955
401
956
402
    // Sync (exception as target is a directory)
957
403
    EXPECT_THROW(conf.sync(), FileException);
958
150
}
404
}
Reviewer	Review Type	Date Requested	Status
Unity8 CI Bot	continuous-integration		Approve on 2016-03-30
Michi Henning (community)			Approve on 2016-03-30
Paweł Stołowski (community)		2016-03-14	Needs Fixing on 2016-03-16
Review via email: mp+288895@code.launchpad.net