1 /******************************************************************************
2 *
3 * Copyright (C) 2022 Google, Inc.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 ******************************************************************************/
18
19 #include "device/include/device_iot_config.h"
20
21 #include <com_android_bluetooth_flags.h>
22 #include <flag_macros.h>
23 #include <gmock/gmock.h>
24 #include <gtest/gtest.h>
25 #include <sys/mman.h>
26
27 #include "btcore/include/module.h"
28 #include "btif/include/btif_common.h"
29 #include "device/src/device_iot_config_int.h"
30 #include "test/common/mock_functions.h"
31 #include "test/mock/mock_osi_alarm.h"
32 #include "test/mock/mock_osi_allocator.h"
33 #include "test/mock/mock_osi_config.h"
34 #include "test/mock/mock_osi_future.h"
35 #include "test/mock/mock_osi_properties.h"
36
37 #define TEST_BT com::android::bluetooth::flags
38
39 using namespace bluetooth;
40 using namespace testing;
41
42 extern module_t device_iot_config_module;
43
btif_transfer_context(tBTIF_CBACK *,uint16_t,char *,int,tBTIF_COPY_CBACK *)44 bt_status_t btif_transfer_context(tBTIF_CBACK* /*p_cback*/, uint16_t /*event*/, char* /*p_params*/,
45 int /*param_len*/, tBTIF_COPY_CBACK* /*p_copy_cback*/) {
46 inc_func_call_count(__func__);
47 return BT_STATUS_SUCCESS;
48 }
49
50 struct alarm_t {
alarm_talarm_t51 alarm_t(const char* /*name*/) {}
52 int any_value;
53 };
54
55 struct future_t {
future_tfuture_t56 future_t(void* /*value*/) {}
57 void* value;
58 };
59
60 struct alarm_t placeholder_alarm("");
61 struct future_t placeholder_future(NULL);
62 std::string true_val = "true";
63
64 class DeviceIotConfigModuleTest : public testing::Test {
65 protected:
SetUp()66 void SetUp() override {
67 test::mock::osi_alarm::alarm_new.body = [&](const char* /*name*/) -> alarm_t* {
68 return &placeholder_alarm;
69 };
70
71 test::mock::osi_properties::osi_property_get_bool.body =
72 [&](const char* /*key*/, bool /*default_value*/) -> int { return false; };
73
74 test::mock::osi_alarm::alarm_set.body = [&](alarm_t* /*alarm*/, uint64_t /*interval_ms*/,
75 alarm_callback_t /*cb*/,
76 void* /*data*/) { return; };
77
78 test::mock::osi_alarm::alarm_free.body = [](alarm_t* /*alarm*/) {};
79
80 test::mock::osi_alarm::alarm_is_scheduled.body = [&](const alarm_t* /*alarm*/) -> bool {
81 return false;
82 };
83
84 test::mock::osi_future::future_new_immediate.body = [&](void* /*value*/) -> future_t* {
85 return &placeholder_future;
86 };
87
88 test::mock::osi_config::config_new_empty.body = [&]() -> std::unique_ptr<config_t> {
89 return std::make_unique<config_t>();
90 };
91
92 test::mock::osi_config::config_new.body =
93 [&](const char* /*filename*/) -> std::unique_ptr<config_t> {
94 return std::make_unique<config_t>();
95 };
96
97 test::mock::osi_config::config_get_int.body =
98 [&](const config_t& /*config*/, const std::string& /*section*/,
99 const std::string& /*key*/, int def_value) { return def_value; };
100
101 test::mock::osi_config::config_set_int.body =
102 [&](config_t* /*config*/, const std::string& /*section*/, const std::string& /*key*/,
103 int /*value*/) { return; };
104
105 test::mock::osi_config::config_get_string.body =
106 [&](const config_t& /*config*/, const std::string& /*section*/,
107 const std::string& /*key*/, const std::string* def_value) { return def_value; };
108
109 test::mock::osi_config::config_set_string.body =
110 [&](config_t* /*config*/, const std::string& /*section*/, const std::string& /*key*/,
111 const std::string& /*value*/) { return; };
112
113 test::mock::osi_allocator::osi_free.body = [&](void* /*ptr*/) {};
114
115 reset_mock_function_count_map();
116 }
117
TearDown()118 void TearDown() override {
119 test::mock::osi_alarm::alarm_new = {};
120 test::mock::osi_alarm::alarm_set = {};
121 test::mock::osi_alarm::alarm_free = {};
122 test::mock::osi_alarm::alarm_is_scheduled = {};
123 test::mock::osi_future::future_new_immediate = {};
124 test::mock::osi_properties::osi_property_get = {};
125 test::mock::osi_config::config_new_empty = {};
126 test::mock::osi_config::config_new = {};
127 test::mock::osi_config::config_get_int = {};
128 test::mock::osi_config::config_set_int = {};
129 test::mock::osi_config::config_get_string = {};
130 test::mock::osi_config::config_set_string = {};
131 test::mock::osi_allocator::osi_free = {};
132 }
133 };
134
TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest,test_device_iot_config_module_init_is_factory_reset,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))135 TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest, test_device_iot_config_module_init_is_factory_reset,
136 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
137 bool is_factory_reset = false;
138 config_t* config_new_return_value = NULL;
139 config_t* config_new_empty_return_value = NULL;
140
141 test::mock::osi_properties::osi_property_get_bool.body =
142 [&](const char* /*key*/, bool /*default_value*/) -> int { return is_factory_reset; };
143
144 test::mock::osi_config::config_new.body = [&](const char* /*filename*/) {
145 return std::unique_ptr<config_t>(config_new_return_value);
146 };
147
148 test::mock::osi_config::config_new_empty.body = [&](void) {
149 return std::unique_ptr<config_t>(config_new_empty_return_value);
150 };
151
152 {
153 reset_mock_function_count_map();
154
155 is_factory_reset = true;
156 config_new_return_value = NULL;
157 config_new_empty_return_value = NULL;
158
159 errno = 0;
160 int file_fd = -1;
161 int backup_fd = -1;
162
163 file_fd = open(IOT_CONFIG_FILE_PATH, O_CREAT | O_RDWR | O_TRUNC | O_CLOEXEC, S_IRUSR | S_IWUSR);
164 EXPECT_GT(file_fd, 0);
165 EXPECT_EQ(errno, 0);
166
167 backup_fd =
168 open(IOT_CONFIG_BACKUP_PATH, O_CREAT | O_RDWR | O_TRUNC | O_CLOEXEC, S_IRUSR | S_IWUSR);
169 EXPECT_GT(backup_fd, 0);
170 EXPECT_EQ(errno, 0);
171
172 EXPECT_EQ(access(IOT_CONFIG_FILE_PATH, F_OK), 0);
173 EXPECT_EQ(access(IOT_CONFIG_BACKUP_PATH, F_OK), 0);
174
175 device_iot_config_module_init();
176
177 errno = 0;
178 EXPECT_EQ(access(IOT_CONFIG_FILE_PATH, F_OK), -1);
179 EXPECT_EQ(errno, ENOENT);
180
181 errno = 0;
182 EXPECT_EQ(access(IOT_CONFIG_BACKUP_PATH, F_OK), -1);
183 EXPECT_EQ(errno, ENOENT);
184
185 EXPECT_EQ(get_func_call_count("config_new"), 2);
186 EXPECT_EQ(get_func_call_count("config_new_empty"), 1);
187 EXPECT_EQ(get_func_call_count("alarm_free"), 1);
188 EXPECT_EQ(get_func_call_count("future_new_immediate"), 1);
189 }
190
191 test::mock::osi_config::config_new.body = {};
192 test::mock::osi_config::config_new_empty.body = {};
193 }
194
TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest,test_device_iot_config_module_init_no_config,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))195 TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest, test_device_iot_config_module_init_no_config,
196 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
197 test::mock::osi_config::config_new.body = [&](const char* /*filename*/) {
198 return std::unique_ptr<config_t>(nullptr);
199 };
200
201 test::mock::osi_config::config_new_empty.body = [&](void) {
202 return std::unique_ptr<config_t>(nullptr);
203 };
204
205 {
206 reset_mock_function_count_map();
207
208 device_iot_config_module_init();
209
210 EXPECT_EQ(get_func_call_count("config_new"), 2);
211 EXPECT_EQ(get_func_call_count("config_new_empty"), 1);
212 EXPECT_EQ(get_func_call_count("alarm_free"), 1);
213 EXPECT_EQ(get_func_call_count("future_new_immediate"), 1);
214 }
215
216 test::mock::osi_config::config_new.body = {};
217 test::mock::osi_config::config_new_empty.body = {};
218 }
219
TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest,test_device_iot_config_module_init_original,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))220 TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest, test_device_iot_config_module_init_original,
221 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
222 std::string enable_logging_property_get_value;
223 std::string factory_reset_property_get_value;
224 config_t* config_new_return_value = NULL;
225 config_t* config_new_empty_return_value = NULL;
226
227 test::mock::osi_config::config_new.body = [&](const char* /*filename*/) {
228 return std::unique_ptr<config_t>(config_new_return_value);
229 };
230
231 test::mock::osi_config::config_new_empty.body = [&](void) {
232 return std::unique_ptr<config_t>(config_new_empty_return_value);
233 };
234
235 {
236 reset_mock_function_count_map();
237
238 enable_logging_property_get_value = "true";
239 factory_reset_property_get_value = "false";
240 config_new_return_value = new config_t();
241 config_new_empty_return_value = NULL;
242 int config_get_int_return_value = DEVICE_IOT_INFO_CURRENT_VERSION;
243 std::string config_get_string_return_value(TIME_STRING_FORMAT);
244
245 test::mock::osi_config::config_get_int.body =
246 [&](const config_t& /*config*/, const std::string& /*section*/,
247 const std::string& /*key*/,
248 int /*def_value*/) { return config_get_int_return_value; };
249
250 test::mock::osi_config::config_get_string.body =
251 [&](const config_t& /*config*/, const std::string& /*section*/,
252 const std::string& /*key*/,
253 const std::string* /*def_value*/) { return &config_get_string_return_value; };
254
255 device_iot_config_module_init();
256
257 EXPECT_EQ(get_func_call_count("config_new"), 1);
258 EXPECT_EQ(get_func_call_count("config_new_empty"), 0);
259 EXPECT_EQ(get_func_call_count("config_set_int"), 0);
260 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
261 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
262 EXPECT_EQ(get_func_call_count("alarm_new"), 1);
263 EXPECT_EQ(get_func_call_count("alarm_free"), 0);
264 EXPECT_EQ(get_func_call_count("future_new_immediate"), 1);
265 }
266
267 test::mock::osi_config::config_new.body = {};
268 test::mock::osi_config::config_new_empty.body = {};
269 }
270
TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest,test_device_iot_config_module_init_backup,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))271 TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest, test_device_iot_config_module_init_backup,
272 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
273 std::string enable_logging_property_get_value;
274 std::string factory_reset_property_get_value;
275 config_t* config_new_return_value = NULL;
276 config_t* config_new_empty_return_value = NULL;
277
278 test::mock::osi_config::config_new.body = [&](const char* filename) {
279 if (strcmp(filename, IOT_CONFIG_BACKUP_PATH) == 0) {
280 return std::unique_ptr<config_t>(config_new_return_value);
281 }
282 return std::unique_ptr<config_t>(nullptr);
283 };
284
285 test::mock::osi_config::config_new_empty.body = [&](void) {
286 return std::unique_ptr<config_t>(config_new_empty_return_value);
287 };
288
289 {
290 reset_mock_function_count_map();
291
292 enable_logging_property_get_value = "true";
293 factory_reset_property_get_value = "false";
294 config_new_return_value = new config_t();
295 config_new_empty_return_value = NULL;
296 int config_get_int_return_value = DEVICE_IOT_INFO_CURRENT_VERSION;
297 std::string config_get_string_return_value(TIME_STRING_FORMAT);
298
299 test::mock::osi_config::config_get_int.body =
300 [&](const config_t& /*config*/, const std::string& /*section*/,
301 const std::string& /*key*/,
302 int /*def_value*/) { return config_get_int_return_value; };
303
304 test::mock::osi_config::config_get_string.body =
305 [&](const config_t& /*config*/, const std::string& /*section*/,
306 const std::string& /*key*/,
307 const std::string* /*def_value*/) { return &config_get_string_return_value; };
308
309 device_iot_config_module_init();
310
311 EXPECT_EQ(get_func_call_count("config_new"), 2);
312 EXPECT_EQ(get_func_call_count("config_new_empty"), 0);
313 EXPECT_EQ(get_func_call_count("config_set_int"), 0);
314 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
315 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
316 EXPECT_EQ(get_func_call_count("alarm_new"), 1);
317 EXPECT_EQ(get_func_call_count("alarm_free"), 0);
318 EXPECT_EQ(get_func_call_count("future_new_immediate"), 1);
319 }
320
321 test::mock::osi_config::config_new.body = {};
322 test::mock::osi_config::config_new_empty.body = {};
323 }
324
TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest,test_device_iot_config_module_init_new_file,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))325 TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest, test_device_iot_config_module_init_new_file,
326 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
327 std::string enable_logging_property_get_value;
328 std::string factory_reset_property_get_value;
329 config_t* config_new_return_value = NULL;
330 config_t* config_new_empty_return_value = NULL;
331
332 test::mock::osi_config::config_new.body = [&](const char* /*filename*/) {
333 return std::unique_ptr<config_t>(config_new_return_value);
334 };
335
336 test::mock::osi_config::config_new_empty.body = [&](void) {
337 return std::unique_ptr<config_t>(config_new_empty_return_value);
338 };
339
340 {
341 reset_mock_function_count_map();
342
343 enable_logging_property_get_value = "true";
344 factory_reset_property_get_value = "false";
345 config_new_return_value = NULL;
346 config_new_empty_return_value = new config_t();
347 std::string config_get_string_return_value(TIME_STRING_FORMAT);
348
349 test::mock::osi_config::config_get_string.body =
350 [&](const config_t& /*config*/, const std::string& /*section*/,
351 const std::string& /*key*/,
352 const std::string* /*def_value*/) { return &config_get_string_return_value; };
353
354 device_iot_config_module_init();
355
356 EXPECT_EQ(get_func_call_count("config_new"), 2);
357 EXPECT_EQ(get_func_call_count("config_new_empty"), 1);
358 EXPECT_EQ(get_func_call_count("config_set_int"), 1);
359 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
360 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
361 EXPECT_EQ(get_func_call_count("alarm_new"), 1);
362 EXPECT_EQ(get_func_call_count("alarm_free"), 0);
363 EXPECT_EQ(get_func_call_count("future_new_immediate"), 1);
364 }
365
366 test::mock::osi_config::config_new.body = {};
367 test::mock::osi_config::config_new_empty.body = {};
368 }
369
TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest,test_device_iot_config_module_init_version_invalid,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))370 TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest, test_device_iot_config_module_init_version_invalid,
371 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
372 std::string enable_logging_property_get_value;
373 std::string factory_reset_property_get_value;
374 config_t* config_new_return_value = NULL;
375 config_t* config_new_empty_return_value = NULL;
376
377 test::mock::osi_config::config_new.body = [&](const char* /*filename*/) {
378 return std::unique_ptr<config_t>(config_new_return_value);
379 };
380
381 test::mock::osi_config::config_new_empty.body = [&](void) {
382 return std::unique_ptr<config_t>(config_new_empty_return_value);
383 };
384
385 {
386 reset_mock_function_count_map();
387
388 enable_logging_property_get_value = "true";
389 factory_reset_property_get_value = "false";
390 config_new_return_value = new config_t();
391 config_new_empty_return_value = NULL;
392 int config_get_int_return_value = -1;
393 std::string config_get_string_return_value(TIME_STRING_FORMAT);
394
395 test::mock::osi_config::config_get_int.body =
396 [&](const config_t& /*config*/, const std::string& /*section*/,
397 const std::string& /*key*/,
398 int /*def_value*/) { return config_get_int_return_value; };
399
400 test::mock::osi_config::config_get_string.body =
401 [&](const config_t& /*config*/, const std::string& /*section*/,
402 const std::string& /*key*/,
403 const std::string* /*def_value*/) { return &config_get_string_return_value; };
404
405 device_iot_config_module_init();
406
407 EXPECT_EQ(get_func_call_count("config_new"), 1);
408 EXPECT_EQ(get_func_call_count("config_new_empty"), 0);
409 EXPECT_EQ(get_func_call_count("config_set_int"), 1);
410 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
411 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
412 EXPECT_EQ(get_func_call_count("alarm_new"), 1);
413 EXPECT_EQ(get_func_call_count("alarm_free"), 0);
414 EXPECT_EQ(get_func_call_count("future_new_immediate"), 1);
415 }
416
417 test::mock::osi_config::config_new.body = {};
418 test::mock::osi_config::config_new_empty.body = {};
419 }
420
TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest,test_device_iot_config_module_init_version_new_config_new_empty_success,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))421 TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest,
422 test_device_iot_config_module_init_version_new_config_new_empty_success,
423 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
424 std::string enable_logging_property_get_value;
425 std::string factory_reset_property_get_value;
426 config_t* config_new_return_value = NULL;
427 config_t* config_new_empty_return_value = NULL;
428
429 test::mock::osi_config::config_new.body = [&](const char* /*filename*/) {
430 return std::unique_ptr<config_t>(config_new_return_value);
431 };
432
433 test::mock::osi_config::config_new_empty.body = [&](void) {
434 return std::unique_ptr<config_t>(config_new_empty_return_value);
435 };
436
437 {
438 reset_mock_function_count_map();
439
440 enable_logging_property_get_value = "true";
441 factory_reset_property_get_value = "true";
442 config_new_return_value = new config_t();
443 config_new_empty_return_value = new config_t();
444 int config_get_int_return_value = 2;
445 std::string config_get_string_return_value(TIME_STRING_FORMAT);
446
447 test::mock::osi_config::config_get_int.body =
448 [&](const config_t& /*config*/, const std::string& /*section*/,
449 const std::string& /*key*/,
450 int /*def_value*/) { return config_get_int_return_value; };
451
452 test::mock::osi_config::config_get_string.body =
453 [&](const config_t& /*config*/, const std::string& /*section*/,
454 const std::string& /*key*/,
455 const std::string* /*def_value*/) { return &config_get_string_return_value; };
456
457 int file_fd = -1;
458 int backup_fd = -1;
459
460 errno = 0;
461 file_fd = open(IOT_CONFIG_FILE_PATH, O_CREAT | O_RDWR | O_TRUNC | O_CLOEXEC, S_IRUSR | S_IWUSR);
462 EXPECT_GT(file_fd, 0);
463 EXPECT_EQ(errno, 0);
464
465 errno = 0;
466 backup_fd =
467 open(IOT_CONFIG_BACKUP_PATH, O_CREAT | O_RDWR | O_TRUNC | O_CLOEXEC, S_IRUSR | S_IWUSR);
468 EXPECT_GT(backup_fd, 0);
469 EXPECT_EQ(errno, 0);
470
471 EXPECT_EQ(access(IOT_CONFIG_FILE_PATH, F_OK), 0);
472 EXPECT_EQ(access(IOT_CONFIG_BACKUP_PATH, F_OK), 0);
473
474 device_iot_config_module_init();
475
476 errno = 0;
477 EXPECT_EQ(access(IOT_CONFIG_FILE_PATH, F_OK), -1);
478 EXPECT_EQ(errno, ENOENT);
479
480 errno = 0;
481 EXPECT_EQ(access(IOT_CONFIG_BACKUP_PATH, F_OK), -1);
482 EXPECT_EQ(errno, ENOENT);
483
484 EXPECT_EQ(get_func_call_count("config_new"), 1);
485 EXPECT_EQ(get_func_call_count("config_new_empty"), 1);
486 EXPECT_EQ(get_func_call_count("config_set_int"), 1);
487 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
488 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
489 EXPECT_EQ(get_func_call_count("alarm_new"), 1);
490 EXPECT_EQ(get_func_call_count("alarm_free"), 0);
491 EXPECT_EQ(get_func_call_count("future_new_immediate"), 1);
492 }
493
494 test::mock::osi_config::config_new.body = {};
495 test::mock::osi_config::config_new_empty.body = {};
496 }
497
TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest,test_device_iot_config_module_init_version_new_config_new_empty_fail,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))498 TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest,
499 test_device_iot_config_module_init_version_new_config_new_empty_fail,
500 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
501 std::string enable_logging_property_get_value;
502 std::string factory_reset_property_get_value;
503 config_t* config_new_return_value = NULL;
504 config_t* config_new_empty_return_value = NULL;
505
506 test::mock::osi_config::config_new.body = [&](const char* /*filename*/) {
507 return std::unique_ptr<config_t>(config_new_return_value);
508 };
509
510 test::mock::osi_config::config_new_empty.body = [&](void) {
511 return std::unique_ptr<config_t>(config_new_empty_return_value);
512 };
513
514 {
515 reset_mock_function_count_map();
516
517 enable_logging_property_get_value = "true";
518 factory_reset_property_get_value = "false";
519 config_new_return_value = new config_t();
520 config_new_empty_return_value = NULL;
521 int config_get_int_return_value = 2;
522 std::string config_get_string_return_value(TIME_STRING_FORMAT);
523
524 test::mock::osi_config::config_get_int.body =
525 [&](const config_t& /*config*/, const std::string& /*section*/,
526 const std::string& /*key*/,
527 int /*def_value*/) { return config_get_int_return_value; };
528
529 test::mock::osi_config::config_get_string.body =
530 [&](const config_t& /*config*/, const std::string& /*section*/,
531 const std::string& /*key*/,
532 const std::string* /*def_value*/) { return &config_get_string_return_value; };
533
534 int file_fd = -1;
535 int backup_fd = -1;
536
537 errno = 0;
538 file_fd = open(IOT_CONFIG_FILE_PATH, O_CREAT | O_RDWR | O_TRUNC | O_CLOEXEC, S_IRUSR | S_IWUSR);
539 EXPECT_GT(file_fd, 0);
540 EXPECT_EQ(errno, 0);
541
542 errno = 0;
543 backup_fd =
544 open(IOT_CONFIG_BACKUP_PATH, O_CREAT | O_RDWR | O_TRUNC | O_CLOEXEC, S_IRUSR | S_IWUSR);
545 EXPECT_GT(backup_fd, 0);
546 EXPECT_EQ(errno, 0);
547
548 EXPECT_EQ(access(IOT_CONFIG_FILE_PATH, F_OK), 0);
549 EXPECT_EQ(access(IOT_CONFIG_BACKUP_PATH, F_OK), 0);
550
551 device_iot_config_module_init();
552
553 errno = 0;
554 EXPECT_EQ(access(IOT_CONFIG_FILE_PATH, F_OK), -1);
555 EXPECT_EQ(errno, ENOENT);
556
557 errno = 0;
558 EXPECT_EQ(access(IOT_CONFIG_BACKUP_PATH, F_OK), -1);
559 EXPECT_EQ(errno, ENOENT);
560
561 EXPECT_EQ(get_func_call_count("config_new"), 1);
562 EXPECT_EQ(get_func_call_count("config_new_empty"), 1);
563 EXPECT_EQ(get_func_call_count("config_set_int"), 0);
564 EXPECT_EQ(get_func_call_count("config_get_string"), 0);
565 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
566 EXPECT_EQ(get_func_call_count("alarm_new"), 0);
567 EXPECT_EQ(get_func_call_count("alarm_free"), 1);
568 EXPECT_EQ(get_func_call_count("future_new_immediate"), 1);
569 }
570
571 test::mock::osi_config::config_new.body = {};
572 test::mock::osi_config::config_new_empty.body = {};
573 }
574
TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest,test_device_iot_config_module_init_original_timestamp_null,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))575 TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest,
576 test_device_iot_config_module_init_original_timestamp_null,
577 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
578 std::string enable_logging_property_get_value;
579 std::string factory_reset_property_get_value;
580 config_t* config_new_return_value = NULL;
581 config_t* config_new_empty_return_value = NULL;
582
583 test::mock::osi_config::config_new.body = [&](const char* /*filename*/) {
584 return std::unique_ptr<config_t>(config_new_return_value);
585 };
586
587 test::mock::osi_config::config_new_empty.body = [&](void) {
588 return std::unique_ptr<config_t>(config_new_empty_return_value);
589 };
590
591 {
592 reset_mock_function_count_map();
593
594 enable_logging_property_get_value = "true";
595 factory_reset_property_get_value = "false";
596 config_new_return_value = new config_t();
597 config_new_empty_return_value = NULL;
598 int config_get_int_return_value = DEVICE_IOT_INFO_CURRENT_VERSION;
599
600 test::mock::osi_config::config_get_int.body =
601 [&](const config_t& /*config*/, const std::string& /*section*/,
602 const std::string& /*key*/,
603 int /*def_value*/) { return config_get_int_return_value; };
604
605 test::mock::osi_config::config_get_string.body =
606 [&](const config_t& /*config*/, const std::string& /*section*/,
607 const std::string& /*key*/, const std::string* /*def_value*/) { return nullptr; };
608
609 device_iot_config_module_init();
610
611 EXPECT_EQ(get_func_call_count("config_new"), 1);
612 EXPECT_EQ(get_func_call_count("config_new_empty"), 0);
613 EXPECT_EQ(get_func_call_count("config_set_int"), 0);
614 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
615 EXPECT_EQ(get_func_call_count("config_set_string"), 1);
616 EXPECT_EQ(get_func_call_count("alarm_new"), 1);
617 EXPECT_EQ(get_func_call_count("alarm_free"), 0);
618 EXPECT_EQ(get_func_call_count("future_new_immediate"), 1);
619 }
620
621 test::mock::osi_config::config_new.body = {};
622 test::mock::osi_config::config_new_empty.body = {};
623 }
624
TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest,test_device_iot_config_module_init_alarm_new_fail,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))625 TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest, test_device_iot_config_module_init_alarm_new_fail,
626 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
627 std::string enable_logging_property_get_value;
628 std::string factory_reset_property_get_value;
629 config_t* config_new_return_value = NULL;
630 config_t* config_new_empty_return_value = NULL;
631
632 test::mock::osi_config::config_new.body = [&](const char* /*filename*/) {
633 return std::unique_ptr<config_t>(config_new_return_value);
634 };
635
636 test::mock::osi_config::config_new_empty.body = [&](void) {
637 return std::unique_ptr<config_t>(config_new_empty_return_value);
638 };
639
640 {
641 reset_mock_function_count_map();
642
643 enable_logging_property_get_value = "true";
644 factory_reset_property_get_value = "false";
645 config_new_return_value = new config_t();
646 config_new_empty_return_value = NULL;
647 int config_get_int_return_value = DEVICE_IOT_INFO_CURRENT_VERSION;
648 std::string config_get_string_return_value(TIME_STRING_FORMAT);
649
650 test::mock::osi_config::config_get_int.body =
651 [&](const config_t& /*config*/, const std::string& /*section*/,
652 const std::string& /*key*/,
653 int /*def_value*/) { return config_get_int_return_value; };
654
655 test::mock::osi_config::config_get_string.body =
656 [&](const config_t& /*config*/, const std::string& /*section*/,
657 const std::string& /*key*/,
658 const std::string* /*def_value*/) { return &config_get_string_return_value; };
659
660 test::mock::osi_alarm::alarm_new.body = [&](const char* /*name*/) { return nullptr; };
661
662 device_iot_config_module_init();
663
664 EXPECT_EQ(get_func_call_count("config_new"), 1);
665 EXPECT_EQ(get_func_call_count("config_new_empty"), 0);
666 EXPECT_EQ(get_func_call_count("config_set_int"), 0);
667 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
668 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
669 EXPECT_EQ(get_func_call_count("alarm_new"), 1);
670 EXPECT_EQ(get_func_call_count("alarm_free"), 1);
671 EXPECT_EQ(get_func_call_count("future_new_immediate"), 1);
672 }
673
674 test::mock::osi_config::config_new.body = {};
675 test::mock::osi_config::config_new_empty.body = {};
676 }
677
TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest,test_device_iot_config_module_start_up,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))678 TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest, test_device_iot_config_module_start_up,
679 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
680 std::string enable_logging_property_get_value;
681 std::string factory_reset_property_get_value;
682
683 enable_logging_property_get_value = "true";
684
685 device_iot_config_module_init();
686
687 {
688 reset_mock_function_count_map();
689
690 device_iot_config_module_start_up();
691
692 EXPECT_EQ(get_func_call_count("config_new"), 0);
693 EXPECT_EQ(get_func_call_count("config_new_empty"), 0);
694 EXPECT_EQ(get_func_call_count("alarm_free"), 0);
695 EXPECT_EQ(get_func_call_count("future_new_immediate"), 1);
696 }
697
698 test::mock::osi_config::config_new.body = {};
699 test::mock::osi_config::config_new_empty.body = {};
700 }
701
TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest,test_device_iot_config_module_shutdown,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))702 TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest, test_device_iot_config_module_shutdown,
703 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
704 bool return_value;
705 std::string enable_logging_property_get_value;
706 std::string factory_reset_property_get_value;
707
708 test::mock::osi_alarm::alarm_is_scheduled.body = [&](const alarm_t* /*alarm*/) -> bool {
709 return return_value;
710 };
711
712 enable_logging_property_get_value = "true";
713 device_iot_config_module_init();
714
715 {
716 reset_mock_function_count_map();
717
718 return_value = false;
719
720 device_iot_config_module_shut_down();
721
722 EXPECT_EQ(get_func_call_count("alarm_is_scheduled"), 1);
723 EXPECT_EQ(get_func_call_count("alarm_cancel"), 1);
724 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
725 EXPECT_EQ(get_func_call_count("config_save"), 1);
726 EXPECT_EQ(get_func_call_count("future_new_immediate"), 1);
727 }
728
729 {
730 reset_mock_function_count_map();
731
732 return_value = true;
733
734 device_iot_config_module_shut_down();
735
736 EXPECT_EQ(get_func_call_count("alarm_is_scheduled"), 1);
737 EXPECT_EQ(get_func_call_count("alarm_cancel"), 1);
738 EXPECT_EQ(get_func_call_count("config_set_string"), 1);
739 EXPECT_EQ(get_func_call_count("config_save"), 1);
740 EXPECT_EQ(get_func_call_count("future_new_immediate"), 1);
741 }
742
743 test::mock::osi_config::config_new.body = {};
744 test::mock::osi_config::config_new_empty.body = {};
745 test::mock::osi_alarm::alarm_is_scheduled.body = {};
746 }
747
TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest,test_device_iot_config_module_clean_up,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))748 TEST_F_WITH_FLAGS(DeviceIotConfigModuleTest, test_device_iot_config_module_clean_up,
749 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
750 bool return_value;
751 std::string enable_logging_property_get_value;
752 std::string factory_reset_property_get_value;
753
754 test::mock::osi_alarm::alarm_is_scheduled.body = [&](const alarm_t* /*alarm*/) -> bool {
755 return return_value;
756 };
757
758 enable_logging_property_get_value = "true";
759 device_iot_config_module_init();
760
761 {
762 reset_mock_function_count_map();
763
764 return_value = false;
765 device_iot_config_module_clean_up();
766
767 EXPECT_EQ(get_func_call_count("alarm_is_scheduled"), 1);
768 EXPECT_EQ(get_func_call_count("alarm_free"), 1);
769 EXPECT_EQ(get_func_call_count("alarm_cancel"), 0);
770 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
771 EXPECT_EQ(get_func_call_count("config_save"), 0);
772 EXPECT_EQ(get_func_call_count("future_new_immediate"), 1);
773 }
774
775 device_iot_config_module_init();
776
777 {
778 reset_mock_function_count_map();
779
780 return_value = true;
781 device_iot_config_module_clean_up();
782
783 EXPECT_EQ(get_func_call_count("alarm_is_scheduled"), 2);
784 EXPECT_EQ(get_func_call_count("alarm_free"), 1);
785 EXPECT_EQ(get_func_call_count("alarm_cancel"), 1);
786 EXPECT_EQ(get_func_call_count("config_set_string"), 1);
787 EXPECT_EQ(get_func_call_count("config_save"), 1);
788 EXPECT_EQ(get_func_call_count("future_new_immediate"), 1);
789 }
790
791 test::mock::osi_config::config_new.body = {};
792 test::mock::osi_config::config_new_empty.body = {};
793 test::mock::osi_alarm::alarm_is_scheduled.body = {};
794 }
795
796 class DeviceIotConfigTest : public testing::Test {
797 protected:
SetUp()798 void SetUp() override {
799 test::mock::osi_alarm::alarm_new.body = [&](const char* /*name*/) -> alarm_t* {
800 return &placeholder_alarm;
801 };
802
803 test::mock::osi_properties::osi_property_get_bool.body =
804 [&](const char* /*key*/, bool /*default_value*/) -> int { return false; };
805
806 test::mock::osi_alarm::alarm_set.body = [&](alarm_t* /*alarm*/, uint64_t /*interval_ms*/,
807 alarm_callback_t /*cb*/,
808 void* /*data*/) { return; };
809
810 test::mock::osi_alarm::alarm_free.body = [](alarm_t* /*alarm*/) {};
811
812 test::mock::osi_alarm::alarm_is_scheduled.body = [&](const alarm_t* /*alarm*/) -> bool {
813 return false;
814 };
815
816 test::mock::osi_future::future_new_immediate.body = [&](void* /*value*/) -> future_t* {
817 return &placeholder_future;
818 };
819
820 test::mock::osi_config::config_new_empty.body = [&]() -> std::unique_ptr<config_t> {
821 return std::make_unique<config_t>();
822 };
823
824 test::mock::osi_config::config_new.body =
825 [&](const char* /*filename*/) -> std::unique_ptr<config_t> {
826 return std::make_unique<config_t>();
827 };
828
829 test::mock::osi_config::config_get_int.body =
830 [&](const config_t& /*config*/, const std::string& /*section*/,
831 const std::string& /*key*/, int def_value) { return def_value; };
832
833 test::mock::osi_config::config_set_int.body =
834 [&](config_t* /*config*/, const std::string& /*section*/, const std::string& /*key*/,
835 int /*value*/) { return; };
836
837 test::mock::osi_config::config_get_string.body =
838 [&](const config_t& /*config*/, const std::string& /*section*/,
839 const std::string& /*key*/, const std::string* def_value) { return def_value; };
840
841 test::mock::osi_config::config_set_string.body =
842 [&](config_t* /*config*/, const std::string& /*section*/, const std::string& /*key*/,
843 const std::string& /*value*/) { return; };
844
845 test::mock::osi_allocator::osi_free.body = [&](void* /*ptr*/) {};
846
847 device_iot_config_module_init();
848 device_iot_config_module_start_up();
849
850 reset_mock_function_count_map();
851 }
852
TearDown()853 void TearDown() override {
854 test::mock::osi_alarm::alarm_new = {};
855 test::mock::osi_alarm::alarm_set = {};
856 test::mock::osi_alarm::alarm_free = {};
857 test::mock::osi_alarm::alarm_is_scheduled = {};
858 test::mock::osi_future::future_new_immediate = {};
859 test::mock::osi_properties::osi_property_get = {};
860 test::mock::osi_config::config_new_empty = {};
861 test::mock::osi_config::config_new = {};
862 test::mock::osi_config::config_get_int = {};
863 test::mock::osi_config::config_set_int = {};
864 test::mock::osi_config::config_get_string = {};
865 test::mock::osi_config::config_set_string = {};
866 test::mock::osi_allocator::osi_free = {};
867 }
868 };
869
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_sections_sort_by_entry_key,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))870 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_sections_sort_by_entry_key,
871 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
872 {
873 config_t conf;
874 device_iot_config_sections_sort_by_entry_key(conf, NULL);
875 }
876
877 {
878 config_t conf;
879 conf.sections = {
880 section_t{.entries =
881 {
882 entry_t{
883 .key = "a",
884 },
885 entry_t{
886 .key = "b",
887 },
888 entry_t{
889 .key = "c",
890 },
891 entry_t{
892 .key = "d",
893 },
894 }},
895
896 section_t{.entries =
897 {
898 entry_t{
899 .key = "d",
900 },
901 entry_t{
902 .key = "c",
903 },
904 entry_t{
905 .key = "b",
906 },
907 entry_t{
908 .key = "a",
909 },
910 }},
911 };
912 device_iot_config_sections_sort_by_entry_key(conf,
913 [](const entry_t& first, const entry_t& second) {
914 return first.key.compare(second.key) >= 0;
915 });
916
917 auto& sec1 = conf.sections.front();
918 auto& sec2 = conf.sections.back();
919
920 for (auto i = 0; i < 4; ++i) {
921 EXPECT_EQ(sec1.entries.front().key, sec2.entries.front().key);
922 sec1.entries.pop_front();
923 sec2.entries.pop_front();
924 }
925 }
926 }
927
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_has_section,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))928 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_has_section,
929 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
930 std::string actual_section, expected_section = "abc";
931 bool return_value = false;
932
933 test::mock::osi_config::config_has_section.body = [&](const config_t& /*config*/,
934 const std::string& section) {
935 actual_section = section;
936 return return_value;
937 };
938
939 {
940 reset_mock_function_count_map();
941
942 EXPECT_EQ(device_iot_config_has_section(expected_section), return_value);
943 EXPECT_EQ(actual_section, expected_section);
944
945 EXPECT_EQ(get_func_call_count("config_has_section"), 1);
946 }
947
948 {
949 reset_mock_function_count_map();
950
951 return_value = true;
952
953 EXPECT_EQ(device_iot_config_has_section(expected_section), return_value);
954
955 EXPECT_EQ(get_func_call_count("config_has_section"), 1);
956 }
957
958 test::mock::osi_config::config_has_section.body = {};
959 }
960
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_exist,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))961 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_exist,
962 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
963 std::string actual_section, actual_key, expected_section = "abc", expected_key = "def";
964 bool return_value = false;
965
966 test::mock::osi_config::config_has_key.body =
967 [&](const config_t& /*config*/, const std::string& section, const std::string& key) {
968 actual_section = section;
969 actual_key = key;
970 return return_value;
971 };
972
973 {
974 reset_mock_function_count_map();
975
976 EXPECT_EQ(device_iot_config_exist(expected_section, expected_key), return_value);
977 EXPECT_EQ(actual_section, expected_section);
978 EXPECT_EQ(actual_key, expected_key);
979
980 EXPECT_EQ(get_func_call_count("config_has_key"), 1);
981 }
982
983 {
984 reset_mock_function_count_map();
985
986 return_value = true;
987
988 EXPECT_EQ(device_iot_config_exist(expected_section, expected_key), return_value);
989
990 EXPECT_EQ(get_func_call_count("config_has_key"), 1);
991 }
992
993 test::mock::osi_config::config_has_key.body = {};
994 }
995
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_has_key_value,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))996 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_has_key_value,
997 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
998 std::string actual_section, actual_key, expected_section = "abc", expected_key = "def";
999 std::string expected_value_str = "xyz", actual_value_str;
1000 const std::string* actual_def_value = NULL;
1001 const std::string* return_value = NULL;
1002
1003 test::mock::osi_config::config_get_string.body =
1004 [&](const config_t& /*config*/, const std::string& section, const std::string& key,
1005 const std::string* def_value) {
1006 actual_section = section;
1007 actual_key = key;
1008 actual_def_value = def_value;
1009 return return_value;
1010 };
1011
1012 {
1013 reset_mock_function_count_map();
1014
1015 EXPECT_FALSE(
1016 device_iot_config_has_key_value(expected_section, expected_key, expected_value_str));
1017 EXPECT_TRUE(actual_def_value == NULL);
1018 EXPECT_EQ(actual_section, expected_section);
1019 EXPECT_EQ(actual_key, expected_key);
1020
1021 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1022 }
1023
1024 {
1025 reset_mock_function_count_map();
1026
1027 actual_value_str = "xyy";
1028 return_value = &actual_value_str;
1029 EXPECT_FALSE(
1030 device_iot_config_has_key_value(expected_section, expected_key, expected_value_str));
1031 EXPECT_TRUE(actual_def_value == NULL);
1032 EXPECT_EQ(actual_section, expected_section);
1033 EXPECT_EQ(actual_key, expected_key);
1034
1035 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1036 }
1037
1038 {
1039 reset_mock_function_count_map();
1040
1041 actual_value_str = "xy";
1042 return_value = &actual_value_str;
1043 EXPECT_FALSE(
1044 device_iot_config_has_key_value(expected_section, expected_key, expected_value_str));
1045 EXPECT_TRUE(actual_def_value == NULL);
1046 EXPECT_EQ(actual_section, expected_section);
1047 EXPECT_EQ(actual_key, expected_key);
1048
1049 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1050 }
1051
1052 {
1053 reset_mock_function_count_map();
1054
1055 actual_value_str = "xyyy";
1056 return_value = &actual_value_str;
1057 EXPECT_FALSE(
1058 device_iot_config_has_key_value(expected_section, expected_key, expected_value_str));
1059 EXPECT_TRUE(actual_def_value == NULL);
1060 EXPECT_EQ(actual_section, expected_section);
1061 EXPECT_EQ(actual_key, expected_key);
1062
1063 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1064 }
1065
1066 {
1067 reset_mock_function_count_map();
1068
1069 actual_value_str = "xyz";
1070 return_value = &actual_value_str;
1071 EXPECT_TRUE(
1072 device_iot_config_has_key_value(expected_section, expected_key, expected_value_str));
1073 EXPECT_TRUE(actual_def_value == NULL);
1074 EXPECT_EQ(actual_section, expected_section);
1075 EXPECT_EQ(actual_key, expected_key);
1076
1077 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1078 }
1079
1080 test::mock::osi_config::config_get_string.body = {};
1081 }
1082
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_get_int,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))1083 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_get_int,
1084 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
1085 std::string actual_section, actual_key, expected_section = "abc", expected_key = "def";
1086 bool return_value = false;
1087 int int_value = 0, new_value = 0xff;
1088
1089 test::mock::osi_config::config_has_key.body =
1090 [&](const config_t& /*config*/, const std::string& section, const std::string& key) {
1091 actual_section = section;
1092 actual_key = key;
1093 return return_value;
1094 };
1095
1096 test::mock::osi_config::config_get_int.body =
1097 [&](const config_t& /*config*/, const std::string& /*section*/,
1098 const std::string& /*key*/, int /*def_value*/) { return new_value; };
1099
1100 {
1101 reset_mock_function_count_map();
1102
1103 EXPECT_EQ(device_iot_config_get_int(expected_section, expected_key, int_value), return_value);
1104 EXPECT_EQ(actual_section, expected_section);
1105 EXPECT_EQ(actual_key, expected_key);
1106
1107 EXPECT_EQ(get_func_call_count("config_has_key"), 1);
1108 EXPECT_EQ(get_func_call_count("config_get_int"), 0);
1109 }
1110
1111 {
1112 reset_mock_function_count_map();
1113
1114 return_value = true;
1115
1116 EXPECT_EQ(device_iot_config_get_int(expected_section, expected_key, int_value), return_value);
1117 EXPECT_EQ(actual_section, expected_section);
1118 EXPECT_EQ(actual_key, expected_key);
1119 EXPECT_EQ(int_value, new_value);
1120
1121 EXPECT_EQ(get_func_call_count("config_has_key"), 1);
1122 EXPECT_EQ(get_func_call_count("config_get_int"), 1);
1123 }
1124
1125 test::mock::osi_config::config_has_key.body = {};
1126 test::mock::osi_config::config_get_int.body = {};
1127 }
1128
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_addr_get_int,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))1129 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_addr_get_int,
1130 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
1131 const RawAddress peer_addr{};
1132 std::string actual_section, actual_key, expected_section = "00:00:00:00:00:00",
1133 expected_key = "def";
1134 bool return_value = false;
1135 int int_value = 0, new_value = 0xff;
1136
1137 test::mock::osi_config::config_has_key.body =
1138 [&](const config_t& /*config*/, const std::string& section, const std::string& key) {
1139 actual_section = section;
1140 actual_key = key;
1141 return return_value;
1142 };
1143
1144 test::mock::osi_config::config_get_int.body =
1145 [&](const config_t& /*config*/, const std::string& /*section*/,
1146 const std::string& /*key*/, int /*def_value*/) { return new_value; };
1147
1148 {
1149 reset_mock_function_count_map();
1150
1151 EXPECT_EQ(DEVICE_IOT_CONFIG_ADDR_GET_INT(peer_addr, expected_key, int_value), return_value);
1152 EXPECT_EQ(actual_section, expected_section);
1153 EXPECT_EQ(actual_key, expected_key);
1154
1155 EXPECT_EQ(get_func_call_count("config_has_key"), 1);
1156 EXPECT_EQ(get_func_call_count("config_get_int"), 0);
1157 }
1158
1159 {
1160 reset_mock_function_count_map();
1161
1162 return_value = true;
1163
1164 EXPECT_EQ(DEVICE_IOT_CONFIG_ADDR_GET_INT(peer_addr, expected_key, int_value), return_value);
1165 EXPECT_EQ(actual_section, expected_section);
1166 EXPECT_EQ(actual_key, expected_key);
1167 EXPECT_EQ(int_value, new_value);
1168
1169 EXPECT_EQ(get_func_call_count("config_has_key"), 1);
1170 EXPECT_EQ(get_func_call_count("config_get_int"), 1);
1171 }
1172
1173 test::mock::osi_config::config_has_key.body = {};
1174 test::mock::osi_config::config_get_int.body = {};
1175 }
1176
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_set_int,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))1177 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_set_int,
1178 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
1179 std::string actual_section, actual_key, expected_section = "abc", expected_key = "def";
1180 std::string string_return_value = "123456789";
1181 std::string old_string_value = string_return_value;
1182 std::string new_string_value;
1183 int int_value = 123456789;
1184
1185 test::mock::osi_config::config_get_string.body =
1186 [&](const config_t& /*config*/, const std::string& section, const std::string& key,
1187 const std::string* /*def_value*/) {
1188 actual_section = section;
1189 actual_key = key;
1190 return &string_return_value;
1191 };
1192
1193 test::mock::osi_config::config_set_string.body =
1194 [&](config_t* /*config*/, const std::string& /*section*/, const std::string& /*key*/,
1195 const std::string& value) { new_string_value = value; };
1196
1197 test::mock::osi_alarm::alarm_set.body = [&](alarm_t* /*alarm*/, uint64_t /*interval_ms*/,
1198 alarm_callback_t /*cb*/, void* /*data*/) {};
1199
1200 {
1201 reset_mock_function_count_map();
1202
1203 EXPECT_TRUE(device_iot_config_set_int(expected_section, expected_key, int_value));
1204 EXPECT_EQ(actual_section, expected_section);
1205 EXPECT_EQ(actual_key, expected_key);
1206
1207 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1208 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
1209 EXPECT_EQ(get_func_call_count("alarm_set"), 0);
1210 }
1211
1212 {
1213 reset_mock_function_count_map();
1214
1215 string_return_value = "123";
1216
1217 EXPECT_TRUE(device_iot_config_set_int(expected_section, expected_key, int_value));
1218 EXPECT_EQ(actual_section, expected_section);
1219 EXPECT_EQ(actual_key, expected_key);
1220 EXPECT_EQ(new_string_value, old_string_value);
1221
1222 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1223 EXPECT_EQ(get_func_call_count("config_set_string"), 1);
1224 EXPECT_EQ(get_func_call_count("alarm_set"), 1);
1225 }
1226
1227 test::mock::osi_config::config_get_string.body = {};
1228 test::mock::osi_config::config_set_string.body = {};
1229 test::mock::osi_alarm::alarm_set.body = {};
1230 }
1231
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_addr_set_int,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))1232 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_addr_set_int,
1233 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
1234 const RawAddress peer_addr{};
1235 std::string actual_key, expected_key = "def";
1236 std::string actual_section, expected_section = "00:00:00:00:00:00";
1237 std::string string_return_value = "123456789";
1238 std::string old_string_value = string_return_value;
1239 std::string new_string_value;
1240 int int_value = 123456789;
1241
1242 test::mock::osi_config::config_get_string.body =
1243 [&](const config_t& /*config*/, const std::string& section, const std::string& key,
1244 const std::string* /*def_value*/) {
1245 actual_section = section;
1246 actual_key = key;
1247 return &string_return_value;
1248 };
1249
1250 test::mock::osi_config::config_set_string.body =
1251 [&](config_t* /*config*/, const std::string& /*section*/, const std::string& /*key*/,
1252 const std::string& value) { new_string_value = value; };
1253
1254 test::mock::osi_alarm::alarm_set.body = [&](alarm_t* /*alarm*/, uint64_t /*interval_ms*/,
1255 alarm_callback_t /*cb*/, void* /*data*/) {};
1256
1257 {
1258 reset_mock_function_count_map();
1259
1260 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_SET_INT(peer_addr, expected_key, int_value));
1261 EXPECT_EQ(actual_section, expected_section);
1262 EXPECT_EQ(actual_key, expected_key);
1263
1264 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1265 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
1266 EXPECT_EQ(get_func_call_count("alarm_set"), 0);
1267 }
1268
1269 {
1270 reset_mock_function_count_map();
1271
1272 string_return_value = "123";
1273
1274 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_SET_INT(peer_addr, expected_key, int_value));
1275 EXPECT_EQ(actual_section, expected_section);
1276 EXPECT_EQ(actual_key, expected_key);
1277 EXPECT_EQ(new_string_value, old_string_value);
1278
1279 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1280 EXPECT_EQ(get_func_call_count("config_set_string"), 1);
1281 EXPECT_EQ(get_func_call_count("alarm_set"), 1);
1282 }
1283
1284 test::mock::osi_config::config_get_string.body = {};
1285 test::mock::osi_config::config_set_string.body = {};
1286 test::mock::osi_alarm::alarm_set.body = {};
1287 }
1288
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_int_add_one,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))1289 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_int_add_one,
1290 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
1291 std::string actual_section, actual_key, expected_section = "abc", expected_key = "def";
1292 int int_value = 0, get_default_value, set_value;
1293
1294 test::mock::osi_config::config_get_int.body = [&](const config_t& /*config*/,
1295 const std::string& section,
1296 const std::string& key, int def_value) {
1297 actual_section = section;
1298 actual_key = key;
1299 get_default_value = def_value;
1300 return int_value;
1301 };
1302
1303 test::mock::osi_config::config_set_int.body =
1304 [&](config_t* /*config*/, const std::string& /*section*/, const std::string& /*key*/,
1305 int val) { set_value = val; };
1306
1307 test::mock::osi_alarm::alarm_set.body = [&](alarm_t* /*alarm*/, uint64_t /*interval_ms*/,
1308 alarm_callback_t /*cb*/, void* /*data*/) {};
1309
1310 {
1311 reset_mock_function_count_map();
1312
1313 int_value = -1;
1314
1315 EXPECT_TRUE(device_iot_config_int_add_one(expected_section, expected_key));
1316 EXPECT_EQ(actual_section, expected_section);
1317 EXPECT_EQ(actual_key, expected_key);
1318 EXPECT_EQ(get_default_value, 0);
1319 EXPECT_EQ(set_value, 0);
1320
1321 EXPECT_EQ(get_func_call_count("config_get_int"), 1);
1322 EXPECT_EQ(get_func_call_count("config_set_int"), 1);
1323 EXPECT_EQ(get_func_call_count("alarm_set"), 1);
1324 }
1325
1326 {
1327 reset_mock_function_count_map();
1328
1329 int_value = 0;
1330
1331 EXPECT_TRUE(device_iot_config_int_add_one(expected_section, expected_key));
1332 EXPECT_EQ(actual_section, expected_section);
1333 EXPECT_EQ(actual_key, expected_key);
1334 EXPECT_EQ(get_default_value, 0);
1335 EXPECT_EQ(set_value, int_value + 1);
1336
1337 EXPECT_EQ(get_func_call_count("config_get_int"), 1);
1338 EXPECT_EQ(get_func_call_count("config_set_int"), 1);
1339 EXPECT_EQ(get_func_call_count("alarm_set"), 1);
1340 }
1341
1342 {
1343 reset_mock_function_count_map();
1344
1345 int_value = 1;
1346
1347 EXPECT_TRUE(device_iot_config_int_add_one(expected_section, expected_key));
1348 EXPECT_EQ(actual_section, expected_section);
1349 EXPECT_EQ(actual_key, expected_key);
1350 EXPECT_EQ(get_default_value, 0);
1351 EXPECT_EQ(set_value, int_value + 1);
1352
1353 EXPECT_EQ(get_func_call_count("config_get_int"), 1);
1354 EXPECT_EQ(get_func_call_count("config_set_int"), 1);
1355 EXPECT_EQ(get_func_call_count("alarm_set"), 1);
1356 }
1357
1358 {
1359 reset_mock_function_count_map();
1360
1361 int_value = INT_MAX;
1362
1363 EXPECT_TRUE(device_iot_config_int_add_one(expected_section, expected_key));
1364 EXPECT_EQ(actual_section, expected_section);
1365 EXPECT_EQ(actual_key, expected_key);
1366 EXPECT_EQ(get_default_value, 0);
1367 EXPECT_EQ(set_value, int_value + 1);
1368 EXPECT_EQ(set_value, INT_MIN);
1369
1370 EXPECT_EQ(get_func_call_count("config_get_int"), 1);
1371 EXPECT_EQ(get_func_call_count("config_set_int"), 1);
1372 EXPECT_EQ(get_func_call_count("alarm_set"), 1);
1373 }
1374
1375 {
1376 reset_mock_function_count_map();
1377
1378 int_value = INT_MIN;
1379
1380 EXPECT_TRUE(device_iot_config_int_add_one(expected_section, expected_key));
1381 EXPECT_EQ(actual_section, expected_section);
1382 EXPECT_EQ(actual_key, expected_key);
1383 EXPECT_EQ(get_default_value, 0);
1384 EXPECT_EQ(set_value, 0);
1385
1386 EXPECT_EQ(get_func_call_count("config_get_int"), 1);
1387 EXPECT_EQ(get_func_call_count("config_set_int"), 1);
1388 EXPECT_EQ(get_func_call_count("alarm_set"), 1);
1389 }
1390
1391 test::mock::osi_config::config_get_int.body = {};
1392 test::mock::osi_config::config_set_int.body = {};
1393 test::mock::osi_alarm::alarm_set.body = {};
1394 }
1395
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_addr_int_add_one,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))1396 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_addr_int_add_one,
1397 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
1398 const RawAddress peer_addr{};
1399 std::string actual_section, actual_key, expected_section = "00:00:00:00:00:00",
1400 expected_key = "def";
1401 int int_value = 0, get_default_value, set_value;
1402
1403 test::mock::osi_config::config_get_int.body = [&](const config_t& /*config*/,
1404 const std::string& section,
1405 const std::string& key, int def_value) {
1406 actual_section = section;
1407 actual_key = key;
1408 get_default_value = def_value;
1409 return int_value;
1410 };
1411
1412 test::mock::osi_config::config_set_int.body =
1413 [&](config_t* /*config*/, const std::string& /*section*/, const std::string& /*key*/,
1414 int val) { set_value = val; };
1415
1416 test::mock::osi_alarm::alarm_set.body = [&](alarm_t* /*alarm*/, uint64_t /*interval_ms*/,
1417 alarm_callback_t /*cb*/, void* /*data*/) {};
1418
1419 {
1420 reset_mock_function_count_map();
1421
1422 int_value = -1;
1423
1424 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_INT_ADD_ONE(peer_addr, expected_key));
1425 EXPECT_EQ(actual_section, expected_section);
1426 EXPECT_EQ(actual_key, expected_key);
1427 EXPECT_EQ(get_default_value, 0);
1428 EXPECT_EQ(set_value, 0);
1429
1430 EXPECT_EQ(get_func_call_count("config_get_int"), 1);
1431 EXPECT_EQ(get_func_call_count("config_set_int"), 1);
1432 EXPECT_EQ(get_func_call_count("alarm_set"), 1);
1433 }
1434
1435 {
1436 reset_mock_function_count_map();
1437
1438 int_value = 0;
1439
1440 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_INT_ADD_ONE(peer_addr, expected_key));
1441 EXPECT_EQ(actual_section, expected_section);
1442 EXPECT_EQ(actual_key, expected_key);
1443 EXPECT_EQ(get_default_value, 0);
1444 EXPECT_EQ(set_value, int_value + 1);
1445
1446 EXPECT_EQ(get_func_call_count("config_get_int"), 1);
1447 EXPECT_EQ(get_func_call_count("config_set_int"), 1);
1448 EXPECT_EQ(get_func_call_count("alarm_set"), 1);
1449 }
1450
1451 {
1452 reset_mock_function_count_map();
1453
1454 int_value = 1;
1455
1456 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_INT_ADD_ONE(peer_addr, expected_key));
1457 EXPECT_EQ(actual_section, expected_section);
1458 EXPECT_EQ(actual_key, expected_key);
1459 EXPECT_EQ(get_default_value, 0);
1460 EXPECT_EQ(set_value, int_value + 1);
1461
1462 EXPECT_EQ(get_func_call_count("config_get_int"), 1);
1463 EXPECT_EQ(get_func_call_count("config_set_int"), 1);
1464 EXPECT_EQ(get_func_call_count("alarm_set"), 1);
1465 }
1466
1467 {
1468 reset_mock_function_count_map();
1469
1470 int_value = INT_MAX;
1471
1472 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_INT_ADD_ONE(peer_addr, expected_key));
1473 EXPECT_EQ(actual_section, expected_section);
1474 EXPECT_EQ(actual_key, expected_key);
1475 EXPECT_EQ(get_default_value, 0);
1476 EXPECT_EQ(set_value, int_value + 1);
1477 EXPECT_EQ(set_value, INT_MIN);
1478
1479 EXPECT_EQ(get_func_call_count("config_get_int"), 1);
1480 EXPECT_EQ(get_func_call_count("config_set_int"), 1);
1481 EXPECT_EQ(get_func_call_count("alarm_set"), 1);
1482 }
1483
1484 {
1485 reset_mock_function_count_map();
1486
1487 int_value = INT_MIN;
1488
1489 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_INT_ADD_ONE(peer_addr, expected_key));
1490 EXPECT_EQ(actual_section, expected_section);
1491 EXPECT_EQ(actual_key, expected_key);
1492 EXPECT_EQ(get_default_value, 0);
1493 EXPECT_EQ(set_value, 0);
1494
1495 EXPECT_EQ(get_func_call_count("config_get_int"), 1);
1496 EXPECT_EQ(get_func_call_count("config_set_int"), 1);
1497 EXPECT_EQ(get_func_call_count("alarm_set"), 1);
1498 }
1499 test::mock::osi_config::config_get_int.body = {};
1500 test::mock::osi_config::config_set_int.body = {};
1501 test::mock::osi_alarm::alarm_set.body = {};
1502 }
1503
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_get_hex,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))1504 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_get_hex,
1505 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
1506 std::string actual_section, actual_key, expected_section = "00:00:00:00:00:00",
1507 expected_key = "def";
1508 int int_value = 0;
1509 std::string string_value;
1510 std::string* get_string_return_value = NULL;
1511
1512 test::mock::osi_config::config_get_string.body =
1513 [&](const config_t& /*config*/, const std::string& section, const std::string& key,
1514 const std::string* /*def_value*/) {
1515 actual_section = section;
1516 actual_key = key;
1517 return get_string_return_value;
1518 };
1519
1520 {
1521 reset_mock_function_count_map();
1522
1523 EXPECT_FALSE(device_iot_config_get_hex(expected_section, expected_key, int_value));
1524 EXPECT_EQ(actual_section, expected_section);
1525 EXPECT_EQ(actual_key, expected_key);
1526 EXPECT_EQ(int_value, 0);
1527
1528 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1529 }
1530
1531 {
1532 reset_mock_function_count_map();
1533
1534 string_value = "g";
1535 get_string_return_value = &string_value;
1536 EXPECT_FALSE(device_iot_config_get_hex(expected_section, expected_key, int_value));
1537 EXPECT_EQ(actual_section, expected_section);
1538 EXPECT_EQ(actual_key, expected_key);
1539 EXPECT_EQ(int_value, 0);
1540
1541 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1542 }
1543
1544 {
1545 reset_mock_function_count_map();
1546
1547 string_value = "abcg";
1548 get_string_return_value = &string_value;
1549 EXPECT_FALSE(device_iot_config_get_hex(expected_section, expected_key, int_value));
1550 EXPECT_EQ(actual_section, expected_section);
1551 EXPECT_EQ(actual_key, expected_key);
1552 EXPECT_EQ(int_value, 0);
1553
1554 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1555 }
1556
1557 {
1558 reset_mock_function_count_map();
1559
1560 string_value = "f";
1561 get_string_return_value = &string_value;
1562 EXPECT_TRUE(device_iot_config_get_hex(expected_section, expected_key, int_value));
1563 EXPECT_EQ(actual_section, expected_section);
1564 EXPECT_EQ(actual_key, expected_key);
1565 EXPECT_EQ(int_value, 15);
1566
1567 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1568 }
1569
1570 {
1571 reset_mock_function_count_map();
1572
1573 string_value = "0";
1574 get_string_return_value = &string_value;
1575 EXPECT_TRUE(device_iot_config_get_hex(expected_section, expected_key, int_value));
1576 EXPECT_EQ(actual_section, expected_section);
1577 EXPECT_EQ(actual_key, expected_key);
1578 EXPECT_EQ(int_value, 0);
1579
1580 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1581 }
1582
1583 {
1584 reset_mock_function_count_map();
1585
1586 string_value = "1";
1587 get_string_return_value = &string_value;
1588 EXPECT_TRUE(device_iot_config_get_hex(expected_section, expected_key, int_value));
1589 EXPECT_EQ(actual_section, expected_section);
1590 EXPECT_EQ(actual_key, expected_key);
1591 EXPECT_EQ(int_value, 1);
1592
1593 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1594 }
1595
1596 {
1597 reset_mock_function_count_map();
1598
1599 string_value = "-e";
1600 get_string_return_value = &string_value;
1601 EXPECT_TRUE(device_iot_config_get_hex(expected_section, expected_key, int_value));
1602 EXPECT_EQ(actual_section, expected_section);
1603 EXPECT_EQ(actual_key, expected_key);
1604 EXPECT_EQ(int_value, -14);
1605
1606 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1607 }
1608
1609 {
1610 reset_mock_function_count_map();
1611
1612 string_value = "-f";
1613 get_string_return_value = &string_value;
1614 EXPECT_TRUE(device_iot_config_get_hex(expected_section, expected_key, int_value));
1615 EXPECT_EQ(actual_section, expected_section);
1616 EXPECT_EQ(actual_key, expected_key);
1617 EXPECT_EQ(int_value, -15);
1618
1619 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1620 }
1621
1622 {
1623 reset_mock_function_count_map();
1624
1625 string_value = "0x7fffffff";
1626 get_string_return_value = &string_value;
1627 EXPECT_TRUE(device_iot_config_get_hex(expected_section, expected_key, int_value));
1628 EXPECT_EQ(actual_section, expected_section);
1629 EXPECT_EQ(actual_key, expected_key);
1630 EXPECT_EQ(int_value, INT_MAX);
1631
1632 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1633 }
1634
1635 {
1636 reset_mock_function_count_map();
1637
1638 string_value = "-0x80000000";
1639 get_string_return_value = &string_value;
1640 EXPECT_TRUE(device_iot_config_get_hex(expected_section, expected_key, int_value));
1641 EXPECT_EQ(actual_section, expected_section);
1642 EXPECT_EQ(actual_key, expected_key);
1643 EXPECT_EQ(int_value, INT_MIN);
1644
1645 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1646 }
1647
1648 {
1649 reset_mock_function_count_map();
1650
1651 string_value = "0xffffffff";
1652 get_string_return_value = &string_value;
1653 EXPECT_TRUE(device_iot_config_get_hex(expected_section, expected_key, int_value));
1654 EXPECT_EQ(actual_section, expected_section);
1655 EXPECT_EQ(actual_key, expected_key);
1656 EXPECT_EQ(int_value, -1);
1657
1658 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1659 }
1660
1661 test::mock::osi_config::config_get_string.body = {};
1662 }
1663
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_addr_get_hex,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))1664 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_addr_get_hex,
1665 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
1666 const RawAddress peer_addr{};
1667 std::string actual_section, actual_key, expected_section = "00:00:00:00:00:00",
1668 expected_key = "def";
1669 int int_value = 0;
1670 std::string string_value;
1671 std::string* get_string_return_value = NULL;
1672
1673 test::mock::osi_config::config_get_string.body =
1674 [&](const config_t& /*config*/, const std::string& section, const std::string& key,
1675 const std::string* /*def_value*/) {
1676 actual_section = section;
1677 actual_key = key;
1678 return get_string_return_value;
1679 };
1680
1681 {
1682 reset_mock_function_count_map();
1683
1684 EXPECT_FALSE(DEVICE_IOT_CONFIG_ADDR_GET_HEX(peer_addr, expected_key, int_value));
1685 EXPECT_EQ(actual_section, expected_section);
1686 EXPECT_EQ(actual_key, expected_key);
1687 EXPECT_EQ(int_value, 0);
1688
1689 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1690 }
1691
1692 {
1693 reset_mock_function_count_map();
1694
1695 string_value = "g";
1696 get_string_return_value = &string_value;
1697
1698 EXPECT_FALSE(DEVICE_IOT_CONFIG_ADDR_GET_HEX(peer_addr, expected_key, int_value));
1699 EXPECT_EQ(actual_section, expected_section);
1700 EXPECT_EQ(actual_key, expected_key);
1701 EXPECT_EQ(int_value, 0);
1702
1703 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1704 }
1705
1706 {
1707 reset_mock_function_count_map();
1708
1709 string_value = "f";
1710 get_string_return_value = &string_value;
1711
1712 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_GET_HEX(peer_addr, expected_key, int_value));
1713 EXPECT_EQ(actual_section, expected_section);
1714 EXPECT_EQ(actual_key, expected_key);
1715 EXPECT_EQ(int_value, 15);
1716
1717 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1718 }
1719
1720 {
1721 reset_mock_function_count_map();
1722
1723 string_value = "0";
1724 get_string_return_value = &string_value;
1725
1726 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_GET_HEX(peer_addr, expected_key, int_value));
1727 EXPECT_EQ(actual_section, expected_section);
1728 EXPECT_EQ(actual_key, expected_key);
1729 EXPECT_EQ(int_value, 0);
1730
1731 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1732 }
1733
1734 {
1735 reset_mock_function_count_map();
1736
1737 string_value = "1";
1738 get_string_return_value = &string_value;
1739
1740 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_GET_HEX(peer_addr, expected_key, int_value));
1741 EXPECT_EQ(actual_section, expected_section);
1742 EXPECT_EQ(actual_key, expected_key);
1743 EXPECT_EQ(int_value, 1);
1744
1745 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1746 }
1747
1748 {
1749 reset_mock_function_count_map();
1750
1751 string_value = "-e";
1752 get_string_return_value = &string_value;
1753
1754 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_GET_HEX(peer_addr, expected_key, int_value));
1755 EXPECT_EQ(actual_section, expected_section);
1756 EXPECT_EQ(actual_key, expected_key);
1757 EXPECT_EQ(int_value, -14);
1758
1759 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1760 }
1761
1762 {
1763 reset_mock_function_count_map();
1764
1765 string_value = "-f";
1766 get_string_return_value = &string_value;
1767
1768 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_GET_HEX(peer_addr, expected_key, int_value));
1769 EXPECT_EQ(actual_section, expected_section);
1770 EXPECT_EQ(actual_key, expected_key);
1771 EXPECT_EQ(int_value, -15);
1772
1773 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1774 }
1775
1776 {
1777 reset_mock_function_count_map();
1778
1779 string_value = "0x7fffffff";
1780 get_string_return_value = &string_value;
1781
1782 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_GET_HEX(peer_addr, expected_key, int_value));
1783 EXPECT_EQ(actual_section, expected_section);
1784 EXPECT_EQ(actual_key, expected_key);
1785 EXPECT_EQ(int_value, INT_MAX);
1786
1787 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1788 }
1789
1790 {
1791 reset_mock_function_count_map();
1792
1793 string_value = "-0x80000000";
1794 get_string_return_value = &string_value;
1795
1796 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_GET_HEX(peer_addr, expected_key, int_value));
1797 EXPECT_EQ(actual_section, expected_section);
1798 EXPECT_EQ(actual_key, expected_key);
1799 EXPECT_EQ(int_value, INT_MIN);
1800
1801 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1802 }
1803
1804 {
1805 reset_mock_function_count_map();
1806
1807 string_value = "0xffffffff";
1808 get_string_return_value = &string_value;
1809
1810 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_GET_HEX(peer_addr, expected_key, int_value));
1811 EXPECT_EQ(actual_section, expected_section);
1812 EXPECT_EQ(actual_key, expected_key);
1813 EXPECT_EQ(int_value, -1);
1814
1815 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1816 }
1817
1818 test::mock::osi_config::config_get_string.body = {};
1819 }
1820
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_set_hex,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))1821 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_set_hex,
1822 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
1823 std::string actual_key, expected_key = "def";
1824 std::string actual_section, expected_section = "00:00:00:00:00:00";
1825 std::string string_return_value;
1826 std::string new_string_value;
1827 std::string* get_string_return_value = NULL;
1828 int int_value, byte_num;
1829
1830 test::mock::osi_config::config_get_string.body =
1831 [&](const config_t& /*config*/, const std::string& section, const std::string& key,
1832 const std::string* /*def_value*/) {
1833 actual_section = section;
1834 actual_key = key;
1835 return get_string_return_value;
1836 };
1837
1838 test::mock::osi_config::config_set_string.body =
1839 [&](config_t* /*config*/, const std::string& /*section*/, const std::string& /*key*/,
1840 const std::string& value) { new_string_value = value; };
1841
1842 test::mock::osi_alarm::alarm_set.body = [&](alarm_t* /*alarm*/, uint64_t /*interval_ms*/,
1843 alarm_callback_t /*cb*/, void* /*data*/) {};
1844
1845 {
1846 reset_mock_function_count_map();
1847
1848 string_return_value = "01";
1849 int_value = 1;
1850 byte_num = 1;
1851 get_string_return_value = &string_return_value;
1852
1853 EXPECT_TRUE(device_iot_config_set_hex(expected_section, expected_key, int_value, byte_num));
1854 EXPECT_EQ(actual_section, expected_section);
1855 EXPECT_EQ(actual_key, expected_key);
1856
1857 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1858 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
1859 EXPECT_EQ(get_func_call_count("alarm_set"), 0);
1860 }
1861
1862 {
1863 reset_mock_function_count_map();
1864
1865 string_return_value = "0001";
1866 int_value = 1;
1867 byte_num = 2;
1868 get_string_return_value = &string_return_value;
1869 EXPECT_TRUE(device_iot_config_set_hex(expected_section, expected_key, int_value, byte_num));
1870 EXPECT_EQ(actual_section, expected_section);
1871 EXPECT_EQ(actual_key, expected_key);
1872
1873 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1874 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
1875 EXPECT_EQ(get_func_call_count("alarm_set"), 0);
1876 }
1877
1878 {
1879 reset_mock_function_count_map();
1880
1881 string_return_value = "000001";
1882 int_value = 1;
1883 byte_num = 3;
1884 get_string_return_value = &string_return_value;
1885 EXPECT_TRUE(device_iot_config_set_hex(expected_section, expected_key, int_value, byte_num));
1886 EXPECT_EQ(actual_section, expected_section);
1887 EXPECT_EQ(actual_key, expected_key);
1888
1889 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1890 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
1891 EXPECT_EQ(get_func_call_count("alarm_set"), 0);
1892 }
1893
1894 {
1895 reset_mock_function_count_map();
1896
1897 string_return_value = "00000001";
1898 int_value = 1;
1899 byte_num = 4;
1900 get_string_return_value = &string_return_value;
1901
1902 EXPECT_TRUE(device_iot_config_set_hex(expected_section, expected_key, int_value, byte_num));
1903 EXPECT_EQ(actual_section, expected_section);
1904 EXPECT_EQ(actual_key, expected_key);
1905
1906 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1907 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
1908 EXPECT_EQ(get_func_call_count("alarm_set"), 0);
1909 }
1910
1911 {
1912 reset_mock_function_count_map();
1913
1914 string_return_value = "";
1915 int_value = 1;
1916 byte_num = 0;
1917 get_string_return_value = &string_return_value;
1918
1919 EXPECT_TRUE(device_iot_config_set_hex(expected_section, expected_key, int_value, byte_num));
1920 EXPECT_EQ(actual_section, expected_section);
1921 EXPECT_EQ(actual_key, expected_key);
1922
1923 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1924 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
1925 EXPECT_EQ(get_func_call_count("alarm_set"), 0);
1926 }
1927
1928 {
1929 reset_mock_function_count_map();
1930
1931 string_return_value = "";
1932 int_value = 1;
1933 byte_num = 5;
1934 get_string_return_value = &string_return_value;
1935
1936 EXPECT_TRUE(device_iot_config_set_hex(expected_section, expected_key, int_value, byte_num));
1937 EXPECT_EQ(actual_section, expected_section);
1938 EXPECT_EQ(actual_key, expected_key);
1939
1940 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1941 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
1942 EXPECT_EQ(get_func_call_count("alarm_set"), 0);
1943 }
1944
1945 {
1946 reset_mock_function_count_map();
1947
1948 string_return_value = "ff";
1949 int_value = 1;
1950 byte_num = 1;
1951 get_string_return_value = &string_return_value;
1952 std::string expected_string_value = "01";
1953
1954 EXPECT_TRUE(device_iot_config_set_hex(expected_section, expected_key, int_value, byte_num));
1955 EXPECT_EQ(actual_section, expected_section);
1956 EXPECT_EQ(actual_key, expected_key);
1957 EXPECT_EQ(new_string_value, expected_string_value);
1958
1959 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
1960 EXPECT_EQ(get_func_call_count("config_set_string"), 1);
1961 EXPECT_EQ(get_func_call_count("alarm_set"), 1);
1962 }
1963
1964 test::mock::osi_config::config_get_string.body = {};
1965 test::mock::osi_config::config_set_string.body = {};
1966 test::mock::osi_alarm::alarm_set.body = {};
1967 }
1968
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_addr_set_hex,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))1969 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_addr_set_hex,
1970 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
1971 const RawAddress peer_addr{};
1972 std::string actual_key, expected_key = "def";
1973 std::string actual_section, expected_section = "00:00:00:00:00:00";
1974 std::string string_return_value;
1975 std::string old_string_value = string_return_value;
1976 std::string new_string_value;
1977 std::string* get_string_return_value = NULL;
1978 int int_value = 123456789;
1979 int byte_num = 1;
1980
1981 test::mock::osi_config::config_get_string.body =
1982 [&](const config_t& /*config*/, const std::string& section, const std::string& key,
1983 const std::string* /*def_value*/) {
1984 actual_section = section;
1985 actual_key = key;
1986 return get_string_return_value;
1987 };
1988
1989 test::mock::osi_config::config_set_string.body =
1990 [&](config_t* /*config*/, const std::string& /*section*/, const std::string& /*key*/,
1991 const std::string& value) { new_string_value = value; };
1992
1993 test::mock::osi_alarm::alarm_set.body = [&](alarm_t* /*alarm*/, uint64_t /*interval_ms*/,
1994 alarm_callback_t /*cb*/, void* /*data*/) {};
1995
1996 {
1997 reset_mock_function_count_map();
1998
1999 string_return_value = "01";
2000 int_value = 1;
2001 byte_num = 1;
2002 get_string_return_value = &string_return_value;
2003
2004 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_SET_HEX(peer_addr, expected_key, int_value, byte_num));
2005 EXPECT_EQ(actual_section, expected_section);
2006 EXPECT_EQ(actual_key, expected_key);
2007
2008 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2009 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
2010 EXPECT_EQ(get_func_call_count("alarm_set"), 0);
2011 }
2012
2013 {
2014 reset_mock_function_count_map();
2015
2016 string_return_value = "0001";
2017 int_value = 1;
2018 byte_num = 2;
2019 get_string_return_value = &string_return_value;
2020
2021 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_SET_HEX(peer_addr, expected_key, int_value, byte_num));
2022 EXPECT_EQ(actual_section, expected_section);
2023 EXPECT_EQ(actual_key, expected_key);
2024
2025 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2026 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
2027 EXPECT_EQ(get_func_call_count("alarm_set"), 0);
2028 }
2029
2030 {
2031 reset_mock_function_count_map();
2032
2033 string_return_value = "000001";
2034 int_value = 1;
2035 byte_num = 3;
2036 get_string_return_value = &string_return_value;
2037
2038 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_SET_HEX(peer_addr, expected_key, int_value, byte_num));
2039 EXPECT_EQ(actual_section, expected_section);
2040 EXPECT_EQ(actual_key, expected_key);
2041
2042 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2043 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
2044 EXPECT_EQ(get_func_call_count("alarm_set"), 0);
2045 }
2046
2047 {
2048 reset_mock_function_count_map();
2049
2050 string_return_value = "00000001";
2051 int_value = 1;
2052 byte_num = 4;
2053 get_string_return_value = &string_return_value;
2054
2055 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_SET_HEX(peer_addr, expected_key, int_value, byte_num));
2056 EXPECT_EQ(actual_section, expected_section);
2057 EXPECT_EQ(actual_key, expected_key);
2058
2059 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2060 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
2061 EXPECT_EQ(get_func_call_count("alarm_set"), 0);
2062 }
2063
2064 {
2065 reset_mock_function_count_map();
2066
2067 string_return_value = "";
2068 int_value = 1;
2069 byte_num = 0;
2070 get_string_return_value = &string_return_value;
2071
2072 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_SET_HEX(peer_addr, expected_key, int_value, byte_num));
2073 EXPECT_EQ(actual_section, expected_section);
2074 EXPECT_EQ(actual_key, expected_key);
2075
2076 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2077 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
2078 EXPECT_EQ(get_func_call_count("alarm_set"), 0);
2079 }
2080
2081 {
2082 reset_mock_function_count_map();
2083
2084 string_return_value = "";
2085 int_value = 1;
2086 byte_num = 5;
2087 get_string_return_value = &string_return_value;
2088
2089 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_SET_HEX(peer_addr, expected_key, int_value, byte_num));
2090 EXPECT_EQ(actual_section, expected_section);
2091 EXPECT_EQ(actual_key, expected_key);
2092
2093 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2094 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
2095 EXPECT_EQ(get_func_call_count("alarm_set"), 0);
2096 }
2097
2098 {
2099 reset_mock_function_count_map();
2100
2101 string_return_value = "ff";
2102 int_value = 1;
2103 byte_num = 1;
2104 get_string_return_value = &string_return_value;
2105 std::string expected_string_value = "01";
2106
2107 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_SET_HEX(peer_addr, expected_key, int_value, byte_num));
2108 EXPECT_EQ(actual_section, expected_section);
2109 EXPECT_EQ(actual_key, expected_key);
2110 EXPECT_EQ(new_string_value, expected_string_value);
2111
2112 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2113 EXPECT_EQ(get_func_call_count("config_set_string"), 1);
2114 EXPECT_EQ(get_func_call_count("alarm_set"), 1);
2115 }
2116
2117 test::mock::osi_config::config_get_string.body = {};
2118 test::mock::osi_config::config_set_string.body = {};
2119 test::mock::osi_alarm::alarm_set.body = {};
2120 }
2121
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_addr_set_hex_if_greater,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))2122 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_addr_set_hex_if_greater,
2123 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
2124 const RawAddress peer_addr{};
2125 std::string actual_key, expected_key = "def";
2126 std::string actual_section, expected_section = "00:00:00:00:00:00";
2127 std::string string_return_value;
2128 std::string old_string_value = string_return_value;
2129 std::string new_string_value;
2130 std::string* get_string_return_value = NULL;
2131 int int_value = 123456789;
2132 int byte_num = 1;
2133
2134 test::mock::osi_config::config_get_string.body =
2135 [&](const config_t& /*config*/, const std::string& section, const std::string& key,
2136 const std::string* /*def_value*/) {
2137 actual_section = section;
2138 actual_key = key;
2139 return get_string_return_value;
2140 };
2141
2142 test::mock::osi_config::config_set_string.body =
2143 [&](config_t* /*config*/, const std::string& /*section*/, const std::string& /*key*/,
2144 const std::string& value) { new_string_value = value; };
2145
2146 test::mock::osi_alarm::alarm_set.body = [&](alarm_t* /*alarm*/, uint64_t /*interval_ms*/,
2147 alarm_callback_t /*cb*/, void* /*data*/) {};
2148
2149 {
2150 reset_mock_function_count_map();
2151
2152 string_return_value = "00";
2153 int_value = 1;
2154 byte_num = 1;
2155 get_string_return_value = &string_return_value;
2156
2157 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_SET_HEX_IF_GREATER(peer_addr, expected_key, int_value,
2158 byte_num));
2159 EXPECT_EQ(actual_section, expected_section);
2160 EXPECT_EQ(actual_key, expected_key);
2161
2162 EXPECT_EQ(get_func_call_count("config_get_string"), 2);
2163 EXPECT_EQ(get_func_call_count("config_set_string"), 1);
2164 EXPECT_EQ(get_func_call_count("alarm_set"), 1);
2165 }
2166
2167 {
2168 reset_mock_function_count_map();
2169
2170 string_return_value = "01";
2171 int_value = 1;
2172 byte_num = 1;
2173 get_string_return_value = &string_return_value;
2174
2175 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_SET_HEX_IF_GREATER(peer_addr, expected_key, int_value,
2176 byte_num));
2177 EXPECT_EQ(actual_section, expected_section);
2178 EXPECT_EQ(actual_key, expected_key);
2179
2180 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2181 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
2182 EXPECT_EQ(get_func_call_count("alarm_set"), 0);
2183 }
2184
2185 {
2186 reset_mock_function_count_map();
2187
2188 string_return_value = "02";
2189 int_value = 1;
2190 byte_num = 1;
2191 get_string_return_value = &string_return_value;
2192
2193 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_SET_HEX_IF_GREATER(peer_addr, expected_key, int_value,
2194 byte_num));
2195 EXPECT_EQ(actual_section, expected_section);
2196 EXPECT_EQ(actual_key, expected_key);
2197
2198 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2199 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
2200 EXPECT_EQ(get_func_call_count("alarm_set"), 0);
2201 }
2202
2203 test::mock::osi_config::config_get_string.body = {};
2204 test::mock::osi_config::config_set_string.body = {};
2205 test::mock::osi_alarm::alarm_set.body = {};
2206 }
2207
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_get_str,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))2208 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_get_str,
2209 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
2210 std::string actual_section, actual_key, expected_section = "abc", expected_key = "def";
2211 std::string actual_value_str;
2212 const std::string* actual_def_value = NULL;
2213 const std::string* return_value = NULL;
2214
2215 test::mock::osi_config::config_get_string.body =
2216 [&](const config_t& /*config*/, const std::string& section, const std::string& key,
2217 const std::string* def_value) {
2218 actual_section = section;
2219 actual_key = key;
2220 actual_def_value = def_value;
2221 return return_value;
2222 };
2223
2224 {
2225 reset_mock_function_count_map();
2226
2227 int initial_size_bytes = 30;
2228 int size_bytes = initial_size_bytes;
2229 char get_value_str[size_bytes];
2230 EXPECT_FALSE(
2231 device_iot_config_get_str(expected_section, expected_key, get_value_str, &size_bytes));
2232 EXPECT_TRUE(actual_def_value == NULL);
2233 EXPECT_EQ(actual_section, expected_section);
2234 EXPECT_EQ(actual_key, expected_key);
2235 EXPECT_EQ(size_bytes, initial_size_bytes);
2236
2237 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2238 }
2239
2240 {
2241 reset_mock_function_count_map();
2242
2243 int initial_size_bytes = 30;
2244 int size_bytes = initial_size_bytes;
2245 char get_value_str[size_bytes];
2246
2247 actual_value_str = "abc";
2248 return_value = &actual_value_str;
2249 EXPECT_TRUE(
2250 device_iot_config_get_str(expected_section, expected_key, get_value_str, &size_bytes));
2251 EXPECT_TRUE(actual_def_value == NULL);
2252 EXPECT_EQ(actual_section, expected_section);
2253 EXPECT_EQ(actual_key, expected_key);
2254 EXPECT_EQ(size_bytes, (int)actual_value_str.length() + 1);
2255 EXPECT_EQ(0, strncmp(get_value_str, actual_value_str.c_str(), size_bytes));
2256
2257 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2258 }
2259
2260 test::mock::osi_config::config_get_string.body = {};
2261 }
2262
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_set_str,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))2263 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_set_str,
2264 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
2265 std::string actual_key, expected_key = "def";
2266 std::string actual_section, expected_section = "00:00:00:00:00:00";
2267 std::string input_value;
2268 std::string string_return_value;
2269 std::string old_string_value = string_return_value;
2270 std::string new_string_value;
2271 std::string* get_string_return_value = NULL;
2272 std::string str_value;
2273
2274 test::mock::osi_config::config_get_string.body =
2275 [&](const config_t& /*config*/, const std::string& section, const std::string& key,
2276 const std::string* /*def_value*/) {
2277 actual_section = section;
2278 actual_key = key;
2279 return get_string_return_value;
2280 };
2281
2282 test::mock::osi_config::config_set_string.body =
2283 [&](config_t* /*config*/, const std::string& /*section*/, const std::string& /*key*/,
2284 const std::string& value) { new_string_value = value; };
2285
2286 test::mock::osi_alarm::alarm_set.body = [&](alarm_t* /*alarm*/, uint64_t /*interval_ms*/,
2287 alarm_callback_t /*cb*/, void* /*data*/) {};
2288
2289 {
2290 reset_mock_function_count_map();
2291
2292 string_return_value = "01";
2293 get_string_return_value = &string_return_value;
2294
2295 input_value = "01";
2296 EXPECT_TRUE(device_iot_config_set_str(expected_section, expected_key, input_value));
2297 EXPECT_EQ(actual_section, expected_section);
2298 EXPECT_EQ(actual_key, expected_key);
2299
2300 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2301 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
2302 EXPECT_EQ(get_func_call_count("alarm_set"), 0);
2303 }
2304
2305 {
2306 reset_mock_function_count_map();
2307
2308 string_return_value = "02";
2309 get_string_return_value = &string_return_value;
2310
2311 input_value = "01";
2312 EXPECT_TRUE(device_iot_config_set_str(expected_section, expected_key, input_value));
2313 EXPECT_EQ(actual_section, expected_section);
2314 EXPECT_EQ(actual_key, expected_key);
2315 EXPECT_EQ(new_string_value, input_value);
2316
2317 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2318 EXPECT_EQ(get_func_call_count("config_set_string"), 1);
2319 EXPECT_EQ(get_func_call_count("alarm_set"), 1);
2320 }
2321
2322 test::mock::osi_config::config_get_string.body = {};
2323 test::mock::osi_config::config_set_string.body = {};
2324 test::mock::osi_alarm::alarm_set.body = {};
2325 }
2326
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_addr_set_str,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))2327 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_addr_set_str,
2328 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
2329 const RawAddress peer_addr{};
2330 std::string actual_key, expected_key = "def";
2331 std::string actual_section, expected_section = "00:00:00:00:00:00";
2332 std::string input_value;
2333 std::string string_return_value;
2334 std::string old_string_value = string_return_value;
2335 std::string new_string_value;
2336 std::string* get_string_return_value = NULL;
2337 std::string str_value;
2338
2339 test::mock::osi_config::config_get_string.body =
2340 [&](const config_t& /*config*/, const std::string& section, const std::string& key,
2341 const std::string* /*def_value*/) {
2342 actual_section = section;
2343 actual_key = key;
2344 return get_string_return_value;
2345 };
2346
2347 test::mock::osi_config::config_set_string.body =
2348 [&](config_t* /*config*/, const std::string& /*section*/, const std::string& /*key*/,
2349 const std::string& value) { new_string_value = value; };
2350
2351 test::mock::osi_alarm::alarm_set.body = [&](alarm_t* /*alarm*/, uint64_t /*interval_ms*/,
2352 alarm_callback_t /*cb*/, void* /*data*/) {};
2353
2354 {
2355 reset_mock_function_count_map();
2356
2357 string_return_value = "01";
2358 get_string_return_value = &string_return_value;
2359 input_value = "01";
2360
2361 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_SET_STR(peer_addr, expected_key, input_value));
2362 EXPECT_EQ(actual_section, expected_section);
2363 EXPECT_EQ(actual_key, expected_key);
2364
2365 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2366 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
2367 EXPECT_EQ(get_func_call_count("alarm_set"), 0);
2368 }
2369
2370 {
2371 reset_mock_function_count_map();
2372
2373 string_return_value = "02";
2374 get_string_return_value = &string_return_value;
2375 input_value = "01";
2376
2377 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_SET_STR(peer_addr, expected_key, input_value));
2378 EXPECT_EQ(actual_section, expected_section);
2379 EXPECT_EQ(actual_key, expected_key);
2380 EXPECT_EQ(new_string_value, input_value);
2381
2382 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2383 EXPECT_EQ(get_func_call_count("config_set_string"), 1);
2384 EXPECT_EQ(get_func_call_count("alarm_set"), 1);
2385 }
2386
2387 test::mock::osi_config::config_get_string.body = {};
2388 test::mock::osi_config::config_set_string.body = {};
2389 test::mock::osi_alarm::alarm_set.body = {};
2390 }
2391
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_get_bin,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))2392 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_get_bin,
2393 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
2394 std::string actual_section, actual_key, expected_section = "abc", expected_key = "def";
2395 std::string actual_value_str;
2396 const std::string* actual_def_value = NULL;
2397 const std::string* return_value = NULL;
2398
2399 test::mock::osi_config::config_get_string.body =
2400 [&](const config_t& /*config*/, const std::string& section, const std::string& key,
2401 const std::string* def_value) {
2402 actual_section = section;
2403 actual_key = key;
2404 actual_def_value = def_value;
2405 return return_value;
2406 };
2407
2408 {
2409 reset_mock_function_count_map();
2410
2411 size_t initial_size_bytes = 3;
2412 size_t size_bytes = initial_size_bytes;
2413 uint8_t value[size_bytes];
2414
2415 EXPECT_FALSE(device_iot_config_get_bin(expected_section, expected_key, value, &size_bytes));
2416 EXPECT_TRUE(actual_def_value == NULL);
2417 EXPECT_EQ(actual_section, expected_section);
2418 EXPECT_EQ(actual_key, expected_key);
2419 EXPECT_EQ(size_bytes, initial_size_bytes);
2420
2421 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2422 }
2423
2424 {
2425 reset_mock_function_count_map();
2426
2427 size_t initial_size_bytes = 3;
2428 size_t size_bytes = initial_size_bytes;
2429 uint8_t value[size_bytes];
2430 actual_value_str = "abc";
2431 return_value = &actual_value_str;
2432
2433 EXPECT_FALSE(device_iot_config_get_bin(expected_section, expected_key, value, &size_bytes));
2434 EXPECT_TRUE(actual_def_value == NULL);
2435 EXPECT_EQ(actual_section, expected_section);
2436 EXPECT_EQ(actual_key, expected_key);
2437 EXPECT_EQ(size_bytes, initial_size_bytes);
2438
2439 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2440 }
2441
2442 {
2443 reset_mock_function_count_map();
2444
2445 size_t initial_size_bytes = 3;
2446 size_t size_bytes = initial_size_bytes;
2447 uint8_t value[size_bytes];
2448 actual_value_str = "aabbccdd";
2449 return_value = &actual_value_str;
2450
2451 EXPECT_FALSE(device_iot_config_get_bin(expected_section, expected_key, value, &size_bytes));
2452 EXPECT_TRUE(actual_def_value == NULL);
2453 EXPECT_EQ(actual_section, expected_section);
2454 EXPECT_EQ(actual_key, expected_key);
2455 EXPECT_EQ(size_bytes, initial_size_bytes);
2456
2457 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2458 }
2459
2460 {
2461 reset_mock_function_count_map();
2462
2463 size_t initial_size_bytes = 3;
2464 size_t size_bytes = initial_size_bytes;
2465 uint8_t value[size_bytes];
2466 actual_value_str = "abcdefgh";
2467 return_value = &actual_value_str;
2468
2469 EXPECT_FALSE(device_iot_config_get_bin(expected_section, expected_key, value, &size_bytes));
2470 EXPECT_TRUE(actual_def_value == NULL);
2471 EXPECT_EQ(actual_section, expected_section);
2472 EXPECT_EQ(actual_key, expected_key);
2473 EXPECT_EQ(size_bytes, initial_size_bytes);
2474
2475 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2476 }
2477
2478 {
2479 reset_mock_function_count_map();
2480
2481 size_t initial_size_bytes = 3;
2482 size_t size_bytes = initial_size_bytes;
2483 uint8_t value[size_bytes];
2484 actual_value_str = "abcdef";
2485 return_value = &actual_value_str;
2486
2487 EXPECT_TRUE(device_iot_config_get_bin(expected_section, expected_key, value, &size_bytes));
2488 EXPECT_TRUE(actual_def_value == NULL);
2489 EXPECT_EQ(actual_section, expected_section);
2490 EXPECT_EQ(actual_key, expected_key);
2491 EXPECT_EQ(size_bytes, actual_value_str.length() / 2);
2492
2493 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2494 }
2495
2496 test::mock::osi_config::config_get_string.body = {};
2497 }
2498
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_get_bin_length,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))2499 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_get_bin_length,
2500 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
2501 std::string actual_section, actual_key, expected_section = "abc", expected_key = "def";
2502 std::string actual_value_str;
2503 const std::string* actual_def_value = NULL;
2504 const std::string* return_value = NULL;
2505
2506 test::mock::osi_config::config_get_string.body =
2507 [&](const config_t& /*config*/, const std::string& section, const std::string& key,
2508 const std::string* def_value) {
2509 actual_section = section;
2510 actual_key = key;
2511 actual_def_value = def_value;
2512 return return_value;
2513 };
2514
2515 {
2516 reset_mock_function_count_map();
2517 EXPECT_EQ(device_iot_config_get_bin_length(expected_section, expected_key), 0u);
2518 EXPECT_TRUE(actual_def_value == NULL);
2519 EXPECT_EQ(actual_section, expected_section);
2520 EXPECT_EQ(actual_key, expected_key);
2521 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2522 }
2523
2524 {
2525 reset_mock_function_count_map();
2526 actual_value_str = "abc";
2527 return_value = &actual_value_str;
2528
2529 EXPECT_EQ(device_iot_config_get_bin_length(expected_section, expected_key), 0u);
2530 EXPECT_TRUE(actual_def_value == NULL);
2531 EXPECT_EQ(actual_section, expected_section);
2532 EXPECT_EQ(actual_key, expected_key);
2533 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2534 }
2535
2536 {
2537 reset_mock_function_count_map();
2538 actual_value_str = "aabbccdd";
2539 return_value = &actual_value_str;
2540
2541 EXPECT_EQ(device_iot_config_get_bin_length(expected_section, expected_key), 4u);
2542 EXPECT_TRUE(actual_def_value == NULL);
2543 EXPECT_EQ(actual_section, expected_section);
2544 EXPECT_EQ(actual_key, expected_key);
2545 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2546 }
2547
2548 {
2549 reset_mock_function_count_map();
2550 /* does not check if characters are correct*/
2551 actual_value_str = "abcdefgh";
2552 return_value = &actual_value_str;
2553
2554 EXPECT_EQ(device_iot_config_get_bin_length(expected_section, expected_key), 4u);
2555 EXPECT_TRUE(actual_def_value == NULL);
2556 EXPECT_EQ(actual_section, expected_section);
2557 EXPECT_EQ(actual_key, expected_key);
2558 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2559 }
2560
2561 {
2562 reset_mock_function_count_map();
2563 actual_value_str = "abcdef";
2564 return_value = &actual_value_str;
2565
2566 EXPECT_EQ(device_iot_config_get_bin_length(expected_section, expected_key), 3u);
2567 EXPECT_TRUE(actual_def_value == NULL);
2568 EXPECT_EQ(actual_section, expected_section);
2569 EXPECT_EQ(actual_key, expected_key);
2570 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2571 }
2572
2573 test::mock::osi_config::config_get_string.body = {};
2574 }
2575
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_set_bin,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))2576 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_set_bin,
2577 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
2578 std::string actual_key, expected_key = "def";
2579 std::string actual_section, expected_section = "00:00:00:00:00:00";
2580 std::string string_return_value;
2581 std::string old_string_value = string_return_value;
2582 std::string new_string_value;
2583 std::string* get_string_return_value = NULL;
2584 std::string str_value;
2585
2586 test::mock::osi_config::config_get_string.body =
2587 [&](const config_t& /*config*/, const std::string& section, const std::string& key,
2588 const std::string* /*def_value*/) {
2589 actual_section = section;
2590 actual_key = key;
2591 return get_string_return_value;
2592 };
2593
2594 test::mock::osi_config::config_set_string.body =
2595 [&](config_t* /*config*/, const std::string& /*section*/, const std::string& /*key*/,
2596 const std::string& value) { new_string_value = value; };
2597
2598 test::mock::osi_alarm::alarm_set.body = [&](alarm_t* /*alarm*/, uint64_t /*interval_ms*/,
2599 alarm_callback_t /*cb*/, void* /*data*/) {};
2600
2601 test::mock::osi_allocator::osi_calloc.body = [&](size_t size) { return new char[size]; };
2602
2603 {
2604 reset_mock_function_count_map();
2605 string_return_value = "010203";
2606 get_string_return_value = &string_return_value;
2607
2608 uint8_t input_value[] = {0x01, 0x02, 0x03};
2609 size_t length = sizeof(input_value);
2610
2611 EXPECT_TRUE(device_iot_config_set_bin(expected_section, expected_key, input_value, length));
2612 EXPECT_EQ(actual_section, expected_section);
2613 EXPECT_EQ(actual_key, expected_key);
2614
2615 EXPECT_EQ(get_func_call_count("osi_calloc"), 1);
2616 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2617 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
2618 EXPECT_EQ(get_func_call_count("alarm_set"), 0);
2619 EXPECT_EQ(get_func_call_count("osi_free"), 1);
2620 }
2621
2622 {
2623 reset_mock_function_count_map();
2624 string_return_value = "\0";
2625 get_string_return_value = &string_return_value;
2626
2627 uint8_t input_value[] = {0x01, 0x02, 0x03};
2628 size_t length = 0;
2629
2630 EXPECT_TRUE(device_iot_config_set_bin(expected_section, expected_key, input_value, length));
2631 EXPECT_EQ(actual_section, expected_section);
2632 EXPECT_EQ(actual_key, expected_key);
2633
2634 EXPECT_EQ(get_func_call_count("osi_calloc"), 1);
2635 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2636 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
2637 EXPECT_EQ(get_func_call_count("alarm_set"), 0);
2638 EXPECT_EQ(get_func_call_count("osi_free"), 1);
2639 }
2640
2641 {
2642 reset_mock_function_count_map();
2643 string_return_value = "010101";
2644 get_string_return_value = &string_return_value;
2645
2646 uint8_t input_value[] = {0x01, 0x02, 0x03};
2647 size_t length = sizeof(input_value);
2648
2649 EXPECT_TRUE(device_iot_config_set_bin(expected_section, expected_key, input_value, length));
2650 EXPECT_EQ(actual_section, expected_section);
2651 EXPECT_EQ(actual_key, expected_key);
2652
2653 EXPECT_EQ(get_func_call_count("osi_calloc"), 1);
2654 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2655 EXPECT_EQ(get_func_call_count("config_set_string"), 1);
2656 EXPECT_EQ(get_func_call_count("alarm_set"), 1);
2657 EXPECT_EQ(get_func_call_count("osi_free"), 1);
2658 }
2659
2660 {
2661 reset_mock_function_count_map();
2662 test::mock::osi_allocator::osi_calloc.body = [&](size_t /*size*/) { return nullptr; };
2663
2664 uint8_t input_value[] = {0x01, 0x02, 0x03};
2665 size_t length = sizeof(input_value);
2666
2667 EXPECT_FALSE(device_iot_config_set_bin(expected_section, expected_key, input_value, length));
2668
2669 EXPECT_EQ(get_func_call_count("osi_calloc"), 1);
2670 EXPECT_EQ(get_func_call_count("config_get_string"), 0);
2671 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
2672 EXPECT_EQ(get_func_call_count("alarm_set"), 0);
2673 EXPECT_EQ(get_func_call_count("osi_free"), 0);
2674 }
2675
2676 test::mock::osi_allocator::osi_calloc.body = {};
2677 test::mock::osi_allocator::osi_free.body = {};
2678 test::mock::osi_config::config_get_string.body = {};
2679 test::mock::osi_config::config_set_string.body = {};
2680 test::mock::osi_alarm::alarm_set.body = {};
2681 }
2682
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_addr_set_bin,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))2683 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_addr_set_bin,
2684 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
2685 const RawAddress peer_addr{};
2686 std::string actual_key, expected_key = "def";
2687 std::string actual_section, expected_section = "00:00:00:00:00:00";
2688 std::string string_return_value;
2689 std::string old_string_value = string_return_value;
2690 std::string new_string_value;
2691 std::string* get_string_return_value = NULL;
2692 std::string str_value;
2693
2694 test::mock::osi_config::config_get_string.body =
2695 [&](const config_t& /*config*/, const std::string& section, const std::string& key,
2696 const std::string* /*def_value*/) {
2697 actual_section = section;
2698 actual_key = key;
2699 return get_string_return_value;
2700 };
2701
2702 test::mock::osi_config::config_set_string.body =
2703 [&](config_t* /*config*/, const std::string& /*section*/, const std::string& /*key*/,
2704 const std::string& value) { new_string_value = value; };
2705
2706 test::mock::osi_alarm::alarm_set.body = [&](alarm_t* /*alarm*/, uint64_t /*interval_ms*/,
2707 alarm_callback_t /*cb*/, void* /*data*/) {};
2708
2709 test::mock::osi_allocator::osi_calloc.body = [&](size_t size) { return new char[size]; };
2710
2711 {
2712 reset_mock_function_count_map();
2713 string_return_value = "010203";
2714 get_string_return_value = &string_return_value;
2715
2716 uint8_t input_value[] = {0x01, 0x02, 0x03};
2717 size_t length = sizeof(input_value);
2718
2719 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_SET_BIN(peer_addr, expected_key, input_value, length));
2720 EXPECT_EQ(actual_section, expected_section);
2721 EXPECT_EQ(actual_key, expected_key);
2722
2723 EXPECT_EQ(get_func_call_count("osi_calloc"), 1);
2724 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2725 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
2726 EXPECT_EQ(get_func_call_count("alarm_set"), 0);
2727 EXPECT_EQ(get_func_call_count("osi_free"), 1);
2728 }
2729
2730 {
2731 reset_mock_function_count_map();
2732 string_return_value = "\0";
2733 get_string_return_value = &string_return_value;
2734
2735 uint8_t input_value[] = {0x01, 0x02, 0x03};
2736 size_t length = 0;
2737
2738 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_SET_BIN(peer_addr, expected_key, input_value, length));
2739 EXPECT_EQ(actual_section, expected_section);
2740 EXPECT_EQ(actual_key, expected_key);
2741
2742 EXPECT_EQ(get_func_call_count("osi_calloc"), 1);
2743 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2744 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
2745 EXPECT_EQ(get_func_call_count("alarm_set"), 0);
2746 EXPECT_EQ(get_func_call_count("osi_free"), 1);
2747 }
2748
2749 {
2750 reset_mock_function_count_map();
2751 string_return_value = "010101";
2752 get_string_return_value = &string_return_value;
2753
2754 uint8_t input_value[] = {0x01, 0x02, 0x03};
2755 size_t length = sizeof(input_value);
2756
2757 EXPECT_TRUE(DEVICE_IOT_CONFIG_ADDR_SET_BIN(peer_addr, expected_key, input_value, length));
2758 EXPECT_EQ(actual_section, expected_section);
2759 EXPECT_EQ(actual_key, expected_key);
2760
2761 EXPECT_EQ(get_func_call_count("osi_calloc"), 1);
2762 EXPECT_EQ(get_func_call_count("config_get_string"), 1);
2763 EXPECT_EQ(get_func_call_count("config_set_string"), 1);
2764 EXPECT_EQ(get_func_call_count("alarm_set"), 1);
2765 EXPECT_EQ(get_func_call_count("osi_free"), 1);
2766 }
2767
2768 {
2769 reset_mock_function_count_map();
2770 test::mock::osi_allocator::osi_calloc.body = [&](size_t /*size*/) { return nullptr; };
2771
2772 uint8_t input_value[] = {0x01, 0x02, 0x03};
2773 size_t length = sizeof(input_value);
2774
2775 EXPECT_FALSE(DEVICE_IOT_CONFIG_ADDR_SET_BIN(peer_addr, expected_key, input_value, length));
2776
2777 EXPECT_EQ(get_func_call_count("osi_calloc"), 1);
2778 EXPECT_EQ(get_func_call_count("config_get_string"), 0);
2779 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
2780 EXPECT_EQ(get_func_call_count("alarm_set"), 0);
2781 EXPECT_EQ(get_func_call_count("osi_free"), 0);
2782 }
2783
2784 test::mock::osi_allocator::osi_calloc.body = {};
2785 test::mock::osi_allocator::osi_free.body = {};
2786 test::mock::osi_config::config_get_string.body = {};
2787 test::mock::osi_config::config_set_string.body = {};
2788 test::mock::osi_alarm::alarm_set.body = {};
2789 }
2790
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_remove,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))2791 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_remove,
2792 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
2793 std::string actual_key, expected_key = "def";
2794 std::string actual_section, expected_section = "00:00:00:00:00:00";
2795 bool return_value;
2796
2797 test::mock::osi_config::config_remove_key.body =
2798 [&](config_t* /*config*/, const std::string& section, const std::string& key) {
2799 actual_section = section;
2800 actual_key = key;
2801 return return_value;
2802 };
2803
2804 {
2805 reset_mock_function_count_map();
2806
2807 return_value = false;
2808
2809 EXPECT_EQ(device_iot_config_remove(expected_section, expected_key), return_value);
2810 EXPECT_EQ(actual_section, expected_section);
2811 EXPECT_EQ(actual_key, expected_key);
2812
2813 EXPECT_EQ(get_func_call_count("config_remove_key"), 1);
2814 }
2815
2816 {
2817 reset_mock_function_count_map();
2818
2819 return_value = true;
2820
2821 EXPECT_EQ(device_iot_config_remove(expected_section, expected_key), return_value);
2822 EXPECT_EQ(actual_section, expected_section);
2823 EXPECT_EQ(actual_key, expected_key);
2824
2825 EXPECT_EQ(get_func_call_count("config_remove_key"), 1);
2826 }
2827
2828 test::mock::osi_config::config_remove_key.body = {};
2829 }
2830
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_save_async,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))2831 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_save_async,
2832 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
2833 {
2834 reset_mock_function_count_map();
2835
2836 device_iot_config_save_async();
2837
2838 EXPECT_EQ(get_func_call_count("alarm_set"), 1);
2839 }
2840 }
2841
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_flush,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))2842 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_flush,
2843 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
2844 bool return_value;
2845
2846 test::mock::osi_alarm::alarm_is_scheduled.body = [&](const alarm_t* /*alarm*/) -> bool {
2847 return return_value;
2848 };
2849
2850 {
2851 reset_mock_function_count_map();
2852
2853 return_value = false;
2854
2855 device_iot_config_flush();
2856
2857 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
2858 EXPECT_EQ(get_func_call_count("alarm_is_scheduled"), 1);
2859 EXPECT_EQ(get_func_call_count("alarm_cancel"), 1);
2860 EXPECT_EQ(get_func_call_count("config_save"), 1);
2861 }
2862
2863 {
2864 reset_mock_function_count_map();
2865
2866 return_value = true;
2867
2868 device_iot_config_flush();
2869
2870 EXPECT_EQ(get_func_call_count("config_set_string"), 1);
2871 EXPECT_EQ(get_func_call_count("alarm_is_scheduled"), 1);
2872 EXPECT_EQ(get_func_call_count("alarm_cancel"), 1);
2873 EXPECT_EQ(get_func_call_count("config_save"), 1);
2874 }
2875
2876 test::mock::osi_alarm::alarm_is_scheduled.body = {};
2877 }
2878
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_clear,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))2879 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_clear,
2880 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
2881 config_t* config_new_empty_return_value;
2882 bool config_save_return_value;
2883
2884 test::mock::osi_alarm::alarm_cancel.body = [&](alarm_t* /*alarm*/) {};
2885
2886 test::mock::osi_config::config_new_empty.body = [&]() {
2887 return std::unique_ptr<config_t>(config_new_empty_return_value);
2888 };
2889
2890 test::mock::osi_config::config_save.body = [&](const config_t& /*config*/,
2891 const std::string& /*filename*/) -> bool {
2892 return config_save_return_value;
2893 };
2894
2895 {
2896 reset_mock_function_count_map();
2897
2898 config_new_empty_return_value = new config_t();
2899 config_save_return_value = false;
2900
2901 EXPECT_FALSE(device_iot_config_clear());
2902
2903 EXPECT_EQ(get_func_call_count("config_new_empty"), 1);
2904 EXPECT_EQ(get_func_call_count("alarm_cancel"), 1);
2905 EXPECT_EQ(get_func_call_count("config_save"), 1);
2906 }
2907
2908 {
2909 reset_mock_function_count_map();
2910
2911 config_new_empty_return_value = new config_t();
2912 config_save_return_value = true;
2913
2914 EXPECT_TRUE(device_iot_config_clear());
2915
2916 EXPECT_EQ(get_func_call_count("config_new_empty"), 1);
2917 EXPECT_EQ(get_func_call_count("alarm_cancel"), 1);
2918 EXPECT_EQ(get_func_call_count("config_save"), 1);
2919 }
2920
2921 {
2922 reset_mock_function_count_map();
2923
2924 config_new_empty_return_value = NULL;
2925
2926 EXPECT_FALSE(device_iot_config_clear());
2927
2928 EXPECT_EQ(get_func_call_count("config_new_empty"), 1);
2929 EXPECT_EQ(get_func_call_count("alarm_cancel"), 1);
2930 EXPECT_EQ(get_func_call_count("config_save"), 0);
2931 }
2932
2933 test::mock::osi_alarm::alarm_cancel.body = {};
2934 test::mock::osi_config::config_new_empty.body = {};
2935 test::mock::osi_config::config_save.body = {};
2936 }
2937
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_timer_save_cb,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))2938 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_timer_save_cb,
2939 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
2940 {
2941 reset_mock_function_count_map();
2942
2943 device_iot_config_timer_save_cb(NULL);
2944
2945 EXPECT_EQ(get_func_call_count("btif_transfer_context"), 1);
2946 }
2947 }
2948
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_set_modified_time,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))2949 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_set_modified_time,
2950 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
2951 {
2952 reset_mock_function_count_map();
2953
2954 device_iot_config_set_modified_time();
2955
2956 EXPECT_EQ(get_func_call_count("config_set_string"), 1);
2957 }
2958 }
2959
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_get_device_num,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))2960 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_get_device_num,
2961 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
2962 {
2963 config_t config;
2964 auto num = device_iot_config_get_device_num(config);
2965 EXPECT_EQ(num, 0);
2966 }
2967
2968 {
2969 section_t section1 = {.name = "00:01:02:03:04:05"};
2970 section_t section2 = {.name = "01:01:01:01:01:01"};
2971 section_t section3 = {.name = "00:00:00:00:00:00"};
2972 section_t section4 = {.name = ""};
2973 config_t config;
2974 config.sections.push_back(section1);
2975 config.sections.push_back(section2);
2976 config.sections.push_back(section3);
2977 config.sections.push_back(section4);
2978 auto num = device_iot_config_get_device_num(config);
2979 EXPECT_EQ(num, 3);
2980 }
2981 }
2982
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_restrict_device_num,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))2983 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_restrict_device_num,
2984 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
2985 section_t section = {.name = "00:01:02:03:04:05"};
2986
2987 {
2988 config_t config;
2989
2990 EXPECT_EQ(device_iot_config_get_device_num(config), 0);
2991 device_iot_config_restrict_device_num(config);
2992 EXPECT_EQ(device_iot_config_get_device_num(config), 0);
2993 }
2994
2995 {
2996 int section_count = DEVICES_MAX_NUM_IN_IOT_INFO_FILE;
2997 int expected_count = section_count;
2998 config_t config;
2999 for (int i = 0; i < section_count; ++i) {
3000 config.sections.push_back(section);
3001 }
3002
3003 EXPECT_EQ(device_iot_config_get_device_num(config), section_count);
3004 device_iot_config_restrict_device_num(config);
3005 EXPECT_EQ(device_iot_config_get_device_num(config), expected_count);
3006 }
3007
3008 {
3009 int section_count = DEVICES_MAX_NUM_IN_IOT_INFO_FILE + 1;
3010 int expected_count = DEVICES_MAX_NUM_IN_IOT_INFO_FILE - DEVICES_NUM_MARGIN;
3011 config_t config;
3012 for (int i = 0; i < section_count; ++i) {
3013 config.sections.push_back(section);
3014 }
3015
3016 EXPECT_EQ(device_iot_config_get_device_num(config), section_count);
3017 device_iot_config_restrict_device_num(config);
3018 EXPECT_EQ(device_iot_config_get_device_num(config), expected_count);
3019 }
3020
3021 {
3022 int section_count = 2 * DEVICES_MAX_NUM_IN_IOT_INFO_FILE;
3023 int expected_count = DEVICES_MAX_NUM_IN_IOT_INFO_FILE - DEVICES_NUM_MARGIN;
3024 config_t config;
3025 for (int i = 0; i < section_count; ++i) {
3026 config.sections.push_back(section);
3027 }
3028
3029 EXPECT_EQ(device_iot_config_get_device_num(config), section_count);
3030 device_iot_config_restrict_device_num(config);
3031 EXPECT_EQ(device_iot_config_get_device_num(config), expected_count);
3032 }
3033 }
3034
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_compare_key,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))3035 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_compare_key,
3036 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
3037 {
3038 entry_t first =
3039 {
3040 .key = "NotProfile/a",
3041 },
3042 second = {
3043 .key = "NotProfile/b",
3044 };
3045
3046 EXPECT_TRUE(device_iot_config_compare_key(first, second));
3047 }
3048
3049 {
3050 entry_t first =
3051 {
3052 .key = "Profile/a",
3053 },
3054 second = {
3055 .key = "Profile/b",
3056 };
3057
3058 EXPECT_TRUE(device_iot_config_compare_key(first, second));
3059 }
3060
3061 {
3062 entry_t first =
3063 {
3064 .key = "Profile/b",
3065 },
3066 second = {
3067 .key = "Profile/a",
3068 };
3069
3070 EXPECT_FALSE(device_iot_config_compare_key(first, second));
3071 }
3072
3073 {
3074 entry_t first =
3075 {
3076 .key = "Profile/b",
3077 },
3078 second = {
3079 .key = "NotProfile/a",
3080 };
3081
3082 EXPECT_FALSE(device_iot_config_compare_key(first, second));
3083 }
3084
3085 {
3086 entry_t first =
3087 {
3088 .key = "NotProfile/b",
3089 },
3090 second = {
3091 .key = "Profile/a",
3092 };
3093
3094 EXPECT_TRUE(device_iot_config_compare_key(first, second));
3095 }
3096 }
3097
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_write,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))3098 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_write,
3099 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
3100 test::mock::osi_config::config_save.body =
3101 [&](const config_t& /*config*/, const std::string& /*filename*/) -> bool { return true; };
3102
3103 {
3104 reset_mock_function_count_map();
3105
3106 int event = IOT_CONFIG_FLUSH_EVT;
3107 device_iot_config_write(event, NULL);
3108
3109 EXPECT_EQ(get_func_call_count("config_set_string"), 0);
3110 EXPECT_EQ(get_func_call_count("config_save"), 1);
3111 }
3112
3113 {
3114 reset_mock_function_count_map();
3115
3116 int event = IOT_CONFIG_SAVE_TIMER_FIRED_EVT;
3117 device_iot_config_write(event, NULL);
3118
3119 EXPECT_EQ(get_func_call_count("config_set_string"), 1);
3120 EXPECT_EQ(get_func_call_count("config_save"), 1);
3121 }
3122 test::mock::osi_config::config_save.body = {};
3123 }
3124
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_debug_iot_config_dump,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))3125 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_debug_iot_config_dump,
3126 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
3127 {
3128 errno = 0;
3129 int fd = -1;
3130 const int BUF_SIZE = 100;
3131 char buf[BUF_SIZE] = {0};
3132
3133 fd = open(IOT_CONFIG_FILE_PATH, O_CREAT | O_RDWR | O_TRUNC | O_CLOEXEC, S_IRUSR | S_IWUSR);
3134 EXPECT_GT(fd, 0);
3135 EXPECT_EQ(errno, 0);
3136
3137 lseek(fd, 0, SEEK_SET);
3138 auto bytes_read = read(fd, buf, BUF_SIZE);
3139 EXPECT_EQ(bytes_read, 0);
3140 EXPECT_EQ(errno, 0);
3141 lseek(fd, 0, SEEK_SET);
3142
3143 device_debug_iot_config_dump(fd);
3144
3145 lseek(fd, 0, SEEK_SET);
3146 bytes_read = read(fd, buf, BUF_SIZE);
3147 EXPECT_GT(bytes_read, 0);
3148 EXPECT_EQ(errno, 0);
3149 lseek(fd, 0, SEEK_SET);
3150
3151 close(fd);
3152 }
3153 }
3154
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_iot_config_is_factory_reset,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))3155 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_iot_config_is_factory_reset,
3156 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
3157 bool return_value;
3158 test::mock::osi_properties::osi_property_get_bool.body =
3159 [&](const char* /*key*/, bool /*default_value*/) -> bool { return return_value; };
3160
3161 {
3162 return_value = false;
3163 EXPECT_FALSE(device_iot_config_is_factory_reset());
3164 }
3165
3166 {
3167 return_value = true;
3168 EXPECT_TRUE(device_iot_config_is_factory_reset());
3169 }
3170 }
3171
TEST_F_WITH_FLAGS(DeviceIotConfigTest,test_device_debug_iot_config_delete_files,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))3172 TEST_F_WITH_FLAGS(DeviceIotConfigTest, test_device_debug_iot_config_delete_files,
3173 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
3174 {
3175 errno = 0;
3176 int file_fd = -1;
3177 int backup_fd = -1;
3178
3179 file_fd = open(IOT_CONFIG_FILE_PATH, O_CREAT | O_RDWR | O_TRUNC | O_CLOEXEC, S_IRUSR | S_IWUSR);
3180 EXPECT_GT(file_fd, 0);
3181 EXPECT_EQ(errno, 0);
3182
3183 backup_fd =
3184 open(IOT_CONFIG_BACKUP_PATH, O_CREAT | O_RDWR | O_TRUNC | O_CLOEXEC, S_IRUSR | S_IWUSR);
3185 EXPECT_GT(backup_fd, 0);
3186 EXPECT_EQ(errno, 0);
3187
3188 EXPECT_EQ(access(IOT_CONFIG_FILE_PATH, F_OK), 0);
3189 EXPECT_EQ(access(IOT_CONFIG_BACKUP_PATH, F_OK), 0);
3190
3191 device_iot_config_delete_files();
3192
3193 errno = 0;
3194 EXPECT_EQ(access(IOT_CONFIG_FILE_PATH, F_OK), -1);
3195 EXPECT_EQ(errno, ENOENT);
3196
3197 errno = 0;
3198 EXPECT_EQ(access(IOT_CONFIG_BACKUP_PATH, F_OK), -1);
3199 EXPECT_EQ(errno, ENOENT);
3200 }
3201 }
3202 class DeviceIotConfigDisabledTest : public testing::Test {
3203 protected:
SetUp()3204 void SetUp() override {
3205 test::mock::osi_alarm::alarm_new.body = [&](const char* /*name*/) -> alarm_t* {
3206 return &placeholder_alarm;
3207 };
3208
3209 test::mock::osi_alarm::alarm_set.body = [&](alarm_t* /*alarm*/, uint64_t /*interval_ms*/,
3210 alarm_callback_t /*cb*/,
3211 void* /*data*/) { return; };
3212
3213 test::mock::osi_alarm::alarm_free.body = [](alarm_t* /*alarm*/) {};
3214
3215 test::mock::osi_alarm::alarm_is_scheduled.body = [&](const alarm_t* /*alarm*/) -> bool {
3216 return false;
3217 };
3218
3219 test::mock::osi_future::future_new_immediate.body = [&](void* /*value*/) -> future_t* {
3220 return &placeholder_future;
3221 };
3222
3223 test::mock::osi_config::config_new_empty.body = [&]() -> std::unique_ptr<config_t> {
3224 return std::make_unique<config_t>();
3225 };
3226
3227 test::mock::osi_config::config_new.body =
3228 [&](const char* /*filename*/) -> std::unique_ptr<config_t> {
3229 return std::make_unique<config_t>();
3230 };
3231
3232 test::mock::osi_config::config_get_int.body =
3233 [&](const config_t& /*config*/, const std::string& /*section*/,
3234 const std::string& /*key*/, int def_value) { return def_value; };
3235
3236 test::mock::osi_config::config_set_int.body =
3237 [&](config_t* /*config*/, const std::string& /*section*/, const std::string& /*key*/,
3238 int /*value*/) { return; };
3239
3240 test::mock::osi_config::config_get_string.body =
3241 [&](const config_t& /*config*/, const std::string& /*section*/,
3242 const std::string& /*key*/, const std::string* def_value) { return def_value; };
3243
3244 test::mock::osi_config::config_set_string.body =
3245 [&](config_t* /*config*/, const std::string& /*section*/, const std::string& /*key*/,
3246 const std::string& /*value*/) { return; };
3247
3248 test::mock::osi_allocator::osi_free.body = [&](void* /*ptr*/) {};
3249
3250 device_iot_config_module_init();
3251 device_iot_config_module_start_up();
3252
3253 reset_mock_function_count_map();
3254 }
3255
TearDown()3256 void TearDown() override {
3257 test::mock::osi_alarm::alarm_new = {};
3258 test::mock::osi_alarm::alarm_set = {};
3259 test::mock::osi_alarm::alarm_free = {};
3260 test::mock::osi_alarm::alarm_is_scheduled = {};
3261 test::mock::osi_future::future_new_immediate = {};
3262 test::mock::osi_properties::osi_property_get = {};
3263 test::mock::osi_config::config_new_empty = {};
3264 test::mock::osi_config::config_new = {};
3265 test::mock::osi_config::config_get_int = {};
3266 test::mock::osi_config::config_set_int = {};
3267 test::mock::osi_config::config_get_string = {};
3268 test::mock::osi_config::config_set_string = {};
3269 test::mock::osi_allocator::osi_free = {};
3270 }
3271 };
3272
TEST_F_WITH_FLAGS(DeviceIotConfigDisabledTest,test_device_iot_config_disabled,REQUIRES_FLAGS_DISABLED (ACONFIG_FLAG (TEST_BT,device_iot_config_logging)))3273 TEST_F_WITH_FLAGS(DeviceIotConfigDisabledTest, test_device_iot_config_disabled,
3274 REQUIRES_FLAGS_DISABLED(ACONFIG_FLAG(TEST_BT, device_iot_config_logging))) {
3275 const RawAddress peer_addr{};
3276 std::string section, key, value_str;
3277 int value_int{};
3278
3279 {
3280 reset_mock_function_count_map();
3281
3282 EXPECT_FALSE(device_iot_config_has_section(section));
3283 EXPECT_EQ(get_func_call_size(), 0);
3284 }
3285
3286 {
3287 reset_mock_function_count_map();
3288
3289 EXPECT_FALSE(device_iot_config_exist(section, key));
3290 EXPECT_EQ(get_func_call_size(), 0);
3291 }
3292
3293 {
3294 reset_mock_function_count_map();
3295
3296 EXPECT_FALSE(device_iot_config_get_int(section, key, value_int));
3297 EXPECT_EQ(get_func_call_size(), 0);
3298 }
3299
3300 {
3301 reset_mock_function_count_map();
3302
3303 EXPECT_FALSE(DEVICE_IOT_CONFIG_ADDR_GET_INT(peer_addr, key, value_int));
3304 EXPECT_EQ(get_func_call_size(), 0);
3305 }
3306
3307 {
3308 reset_mock_function_count_map();
3309
3310 EXPECT_FALSE(device_iot_config_set_int(section, key, 0));
3311 EXPECT_EQ(get_func_call_size(), 0);
3312 }
3313
3314 {
3315 reset_mock_function_count_map();
3316
3317 EXPECT_FALSE(DEVICE_IOT_CONFIG_ADDR_SET_INT(peer_addr, key, 0));
3318 EXPECT_EQ(get_func_call_size(), 0);
3319 }
3320
3321 {
3322 reset_mock_function_count_map();
3323
3324 EXPECT_FALSE(device_iot_config_int_add_one(section, key));
3325 EXPECT_EQ(get_func_call_size(), 0);
3326 }
3327
3328 {
3329 reset_mock_function_count_map();
3330
3331 EXPECT_FALSE(DEVICE_IOT_CONFIG_ADDR_INT_ADD_ONE(peer_addr, key));
3332 EXPECT_EQ(get_func_call_size(), 0);
3333 }
3334
3335 {
3336 reset_mock_function_count_map();
3337
3338 EXPECT_FALSE(device_iot_config_get_hex(section, key, value_int));
3339 EXPECT_EQ(get_func_call_size(), 0);
3340 }
3341
3342 {
3343 reset_mock_function_count_map();
3344
3345 EXPECT_FALSE(DEVICE_IOT_CONFIG_ADDR_GET_HEX(peer_addr, key, value_int));
3346 EXPECT_EQ(get_func_call_size(), 0);
3347 }
3348
3349 {
3350 reset_mock_function_count_map();
3351
3352 EXPECT_FALSE(device_iot_config_set_hex(section, key, 0, 0));
3353 EXPECT_EQ(get_func_call_size(), 0);
3354 }
3355
3356 {
3357 reset_mock_function_count_map();
3358
3359 EXPECT_FALSE(DEVICE_IOT_CONFIG_ADDR_SET_HEX(peer_addr, key, 0, 0));
3360 EXPECT_EQ(get_func_call_size(), 0);
3361 }
3362
3363 {
3364 reset_mock_function_count_map();
3365
3366 EXPECT_FALSE(DEVICE_IOT_CONFIG_ADDR_SET_HEX_IF_GREATER(peer_addr, key, 0, 0));
3367 EXPECT_EQ(get_func_call_size(), 0);
3368 }
3369
3370 {
3371 reset_mock_function_count_map();
3372
3373 EXPECT_FALSE(device_iot_config_get_str(section, key, NULL, NULL));
3374 EXPECT_EQ(get_func_call_size(), 0);
3375 }
3376
3377 {
3378 reset_mock_function_count_map();
3379
3380 EXPECT_FALSE(device_iot_config_set_str(section, key, value_str));
3381 EXPECT_EQ(get_func_call_size(), 0);
3382 }
3383
3384 {
3385 reset_mock_function_count_map();
3386
3387 EXPECT_FALSE(DEVICE_IOT_CONFIG_ADDR_SET_STR(peer_addr, key, value_str));
3388 EXPECT_EQ(get_func_call_size(), 0);
3389 }
3390
3391 {
3392 reset_mock_function_count_map();
3393
3394 EXPECT_FALSE(device_iot_config_get_bin(section, key, NULL, NULL));
3395 EXPECT_EQ(get_func_call_size(), 0);
3396 }
3397
3398 {
3399 reset_mock_function_count_map();
3400
3401 EXPECT_FALSE(device_iot_config_set_bin(section, key, NULL, 0));
3402 EXPECT_EQ(get_func_call_size(), 0);
3403 }
3404
3405 {
3406 reset_mock_function_count_map();
3407
3408 EXPECT_FALSE(DEVICE_IOT_CONFIG_ADDR_SET_BIN(peer_addr, key, NULL, 0));
3409 EXPECT_EQ(get_func_call_size(), 0);
3410 }
3411
3412 {
3413 reset_mock_function_count_map();
3414
3415 EXPECT_FALSE(device_iot_config_remove(section, key));
3416 EXPECT_EQ(get_func_call_size(), 0);
3417 }
3418
3419 {
3420 reset_mock_function_count_map();
3421
3422 EXPECT_EQ(device_iot_config_get_bin_length(section, key), 0u);
3423 EXPECT_EQ(get_func_call_size(), 0);
3424 }
3425
3426 {
3427 reset_mock_function_count_map();
3428
3429 device_iot_config_flush();
3430 EXPECT_EQ(get_func_call_size(), 0);
3431 }
3432
3433 {
3434 reset_mock_function_count_map();
3435
3436 EXPECT_TRUE(device_iot_config_clear());
3437 EXPECT_EQ(get_func_call_size(), 0);
3438 }
3439
3440 {
3441 reset_mock_function_count_map();
3442
3443 device_debug_iot_config_dump(0);
3444 EXPECT_EQ(get_func_call_size(), 0);
3445 }
3446 }
3447