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