1 /*
2 * Copyright 2020 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at:
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "btif/include/btif_config_cache.h"
18
19 #include <filesystem>
20
21 #include <gmock/gmock.h>
22 #include <gtest/gtest.h>
23
24 namespace {
25
26 const int kCapacity = 3;
27 const int kTestRepeatCount = 30;
28 const std::string kBtAddr1 = "11:22:33:44:55:66";
29 const std::string kBtAddr2 = "AA:BB:CC:DD:EE:FF";
30 const std::string kBtAddr3 = "AB:CD:EF:12:34:56";
31 const std::string kBtAddr4 = "11:AA:22:BB:33:CC";
32 const std::string kBtAddr5 = "11:AA:22:BB:33:CD";
33 const std::string kBtLocalAddr = "12:34:56:78:90:AB";
34 const std::string kBtInfo = "Info";
35 const std::string kBtMetrics = "Metrics";
36 const std::string kBtAdapter = "Adapter";
37 const std::string kBtAddrInvalid1 = "AB:CD:EF:12:34";
38 const std::string kBtAddrInvalid2 = "AB:CD:EF:12:34:56:78";
39 const std::string kBtAddrInvalid3 = "ABCDEF123456";
40 const std::string kBtAddrInvalid4 = "AB-CD-EF-12-34-56";
41 const std::string kBtSectionInvalid1 = "Invalid Section";
42 const std::filesystem::path kTestConfigFile =
43 std::filesystem::temp_directory_path() / "config_cache_test.conf";
44 const char* TEST_CONFIG_FILE = kTestConfigFile.c_str();
45
46 } // namespace
47
48 namespace testing {
49
50 /* Test to basic btif_config_cache set up
51 * 1. when received Local device sections information, the sections can be put
52 * into btif config cache
53 * 2. the device sections and key-value will be set to Btif config cache when
54 * receiving different device sections
55 * 3. limit the capacity of unpacire devices cache to 3, test the oldest device
56 * section will be ruled out when receiveing 4 different device sections.
57 */
TEST(BtifConfigCacheTest,test_setup_btif_config_cache)58 TEST(BtifConfigCacheTest, test_setup_btif_config_cache) {
59 BtifConfigCache test_btif_config_cache(kCapacity);
60 // Info section
61 test_btif_config_cache.SetString(kBtInfo, "FileSource", "");
62 test_btif_config_cache.SetString(kBtInfo, "TimeCreated",
63 "2020-06-05 12:12:12");
64 // Metrics section
65 test_btif_config_cache.SetString(kBtMetrics, "Salt256Bit",
66 "92a331174d20f2bb");
67 // Adapter Section
68 test_btif_config_cache.SetString(kBtAdapter, "Address", kBtLocalAddr);
69 EXPECT_TRUE(test_btif_config_cache.HasSection(kBtAdapter));
70
71 // bt_device_1
72 test_btif_config_cache.SetString(kBtAddr1, "Name", "Headset_1");
73 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "Name"));
74
75 test_btif_config_cache.SetInt(kBtAddr1, "Property_Int", 1);
76 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "Property_Int"));
77
78 // bt_device_2
79 test_btif_config_cache.SetString(kBtAddr2, "Name", "Headset_2");
80 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr2, "Name"));
81
82 // bt_device_3
83 test_btif_config_cache.SetString(kBtAddr3, "Name", "Headset_3");
84 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr3, "Name"));
85
86 // bt_device_4
87 test_btif_config_cache.SetString(kBtAddr4, "Name", "Headset_4");
88 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr4, "Name"));
89
90 // out out the capacty of unpair devices cache, the bt_device_1 be ruled out
91 EXPECT_FALSE(test_btif_config_cache.HasSection(kBtAddr1));
92 EXPECT_TRUE(test_btif_config_cache.HasSection(kBtAddr2));
93 EXPECT_TRUE(test_btif_config_cache.HasSection(kBtAddr3));
94 EXPECT_TRUE(test_btif_config_cache.HasSection(kBtAddr4));
95 }
96
97 /* Test to set up btif_config_cache with invalid bt address or section name
98 * when received Invalid bt address or section, it's not allowed to put invalid
99 * section to paired devices list section
100 */
TEST(BtifConfigCacheTest,test_set_up_config_cache_with_invalid_section)101 TEST(BtifConfigCacheTest, test_set_up_config_cache_with_invalid_section) {
102 BtifConfigCache test_btif_config_cache(kCapacity);
103
104 // kBtAddrInvalid1
105 test_btif_config_cache.SetString(kBtAddrInvalid1, "Name", "Headset_1");
106 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddrInvalid1, "Name"));
107 EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddrInvalid1));
108 // get the LinkKey
109 test_btif_config_cache.SetString(kBtAddrInvalid1, "LinkKey",
110 "1122334455667788");
111 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddrInvalid1, "LinkKey"));
112 EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddrInvalid1));
113 EXPECT_FALSE(test_btif_config_cache.HasPersistentSection(kBtAddrInvalid1));
114
115 // kBtAddrInvalid2
116 test_btif_config_cache.SetString(kBtAddrInvalid2, "Name", "Headset_1");
117 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddrInvalid2, "Name"));
118 EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddrInvalid2));
119 // get the LinkKey
120 test_btif_config_cache.SetString(kBtAddrInvalid2, "LinkKey",
121 "1122334455667788");
122 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddrInvalid2, "LinkKey"));
123 EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddrInvalid2));
124 EXPECT_FALSE(test_btif_config_cache.HasPersistentSection(kBtAddrInvalid2));
125
126 // kBtAddrInvalid3
127 test_btif_config_cache.SetString(kBtAddrInvalid3, "Name", "Headset_1");
128 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddrInvalid3, "Name"));
129 EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddrInvalid3));
130 // get the LinkKey
131 test_btif_config_cache.SetString(kBtAddrInvalid3, "LinkKey",
132 "1122334455667788");
133 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddrInvalid3, "LinkKey"));
134 EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddrInvalid3));
135 EXPECT_FALSE(test_btif_config_cache.HasPersistentSection(kBtAddrInvalid3));
136
137 // kBtAddrInvalid4
138 test_btif_config_cache.SetString(kBtAddrInvalid4, "Name", "Headset_1");
139 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddrInvalid4, "Name"));
140 EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddrInvalid4));
141 // get the LinkKey
142 test_btif_config_cache.SetString(kBtAddrInvalid4, "LinkKey",
143 "1122334455667788");
144 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddrInvalid4, "LinkKey"));
145 EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddrInvalid4));
146 EXPECT_FALSE(test_btif_config_cache.HasPersistentSection(kBtAddrInvalid4));
147
148 // kBtSectionInvalid1
149 test_btif_config_cache.SetString(kBtSectionInvalid1, "Name", "Headset_1");
150 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtSectionInvalid1, "Name"));
151 EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtSectionInvalid1));
152 // get the LinkKey
153 test_btif_config_cache.SetString(kBtSectionInvalid1, "LinkKey",
154 "1122334455667788");
155 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtSectionInvalid1, "LinkKey"));
156 EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtSectionInvalid1));
157 EXPECT_FALSE(test_btif_config_cache.HasPersistentSection(kBtSectionInvalid1));
158 }
159
160 /* Stress test to set and get key values
161 * 1. stress test to set different type key value to unpaired device cache and
162 * get the different type key values in the unpaired cache section to check if
163 * we get the key-values the same with we set in unpaired device cache.
164 * 2. stress test to set different type key value to paired device section and
165 * get the different type key values in the paired cache section to check if we
166 * get the key-values the same with we set in paired device cache.
167 */
TEST(BtifConfigCacheTest,test_get_set_key_value_test)168 TEST(BtifConfigCacheTest, test_get_set_key_value_test) {
169 BtifConfigCache test_btif_config_cache(kCapacity);
170 // test in unpaired cache
171 test_btif_config_cache.SetString(kBtAddr1, "Name", "Headset_1");
172 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "Name"));
173 EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr1, "Name"),
174 Optional(StrEq("Headset_1")));
175
176 test_btif_config_cache.SetInt(kBtAddr1, "Property_Int", 65536);
177 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "Property_Int"));
178 EXPECT_THAT(test_btif_config_cache.GetInt(kBtAddr1, "Property_Int"),
179 Optional(Eq(65536)));
180
181 test_btif_config_cache.SetUint64(kBtAddr1, "Property_64", 4294967296);
182 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "Property_64"));
183 EXPECT_THAT(test_btif_config_cache.GetUint64(kBtAddr1, "Property_64"),
184 Optional(Eq(uint64_t(4294967296))));
185
186 test_btif_config_cache.SetBool(kBtAddr1, "Property_Bool", true);
187 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "Property_Bool"));
188 EXPECT_THAT(test_btif_config_cache.GetBool(kBtAddr1, "Property_Bool"),
189 Optional(IsTrue()));
190
191 // empty value
192 test_btif_config_cache.SetString(kBtAddr1, "Name", "");
193 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "Name"));
194 EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr1, "Name"),
195 Optional(StrEq("")));
196
197 // get the LinkKey
198 test_btif_config_cache.SetString(kBtAddr1, "LinkKey", "1122334455667788");
199 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "LinkKey"));
200 EXPECT_FALSE(test_btif_config_cache.HasUnpairedSection(kBtAddr1));
201 EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(kBtAddr1));
202
203 // test in unpaired cache
204 test_btif_config_cache.SetString(kBtAddr1, "Name", "Headset_1");
205 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "Name"));
206 EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr1, "Name"),
207 Optional(StrEq("Headset_1")));
208
209 test_btif_config_cache.SetInt(kBtAddr1, "Property_Int", 65536);
210 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "Property_Int"));
211 EXPECT_THAT(test_btif_config_cache.GetInt(kBtAddr1, "Property_Int"),
212 Optional(Eq(65536)));
213
214 test_btif_config_cache.SetUint64(kBtAddr1, "Property_64", 4294967296);
215 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "Property_64"));
216 EXPECT_THAT(test_btif_config_cache.GetUint64(kBtAddr1, "Property_64"),
217 Optional(Eq(uint64_t(4294967296))));
218
219 test_btif_config_cache.SetBool(kBtAddr1, "Property_Bool", true);
220 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "Property_Bool"));
221 EXPECT_THAT(test_btif_config_cache.GetBool(kBtAddr1, "Property_Bool"),
222 Optional(IsTrue()));
223
224 // empty section is disallowed
225 EXPECT_DEATH({ test_btif_config_cache.SetString("", "name", "Headset_1"); },
226 "Empty section not allowed");
227 // empty key is disallowed
228 EXPECT_DEATH({ test_btif_config_cache.SetString(kBtAddr1, "", "Headset_1"); },
229 "Empty key not allowed");
230 EXPECT_FALSE(test_btif_config_cache.HasKey(kBtAddr1, ""));
231 // empty value is allowed
232 test_btif_config_cache.SetString(kBtAddr1, "Name", "");
233 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "Name"));
234 EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr1, "Name"),
235 Optional(StrEq("")));
236 }
237
238 /* Test to set values in the same key
239 * Receiving the same key with different values in a section, the new incoming
240 * value will be updated but the key will not be added repeatedly. test this
241 * feature in both unpaired devic cache and paired device list cache
242 */
TEST(BtifConfigCacheTest,test_set_values_in_the_same_key)243 TEST(BtifConfigCacheTest, test_set_values_in_the_same_key) {
244 BtifConfigCache test_btif_config_cache(kCapacity);
245 // add new a key "Name"
246 test_btif_config_cache.SetString(kBtAddr1, "Name", "Headset_1");
247 EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr1, "Name"),
248 Optional(StrEq("Headset_1")));
249 EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddr1));
250
251 // add the same key "Name" with different value
252 test_btif_config_cache.SetString(kBtAddr1, "Name", "Headset_1A");
253 EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr1, "Name"),
254 Optional(StrEq("Headset_1A")));
255
256 // add the same key "Name" with different value
257 test_btif_config_cache.SetString(kBtAddr1, "Name", "Headset_2A");
258 EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr1, "Name"),
259 Optional(StrEq("Headset_2A")));
260 EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddr1));
261
262 // add new a key "Property_Int"
263 test_btif_config_cache.SetInt(kBtAddr1, "Property_Int", 65536);
264 EXPECT_THAT(test_btif_config_cache.GetInt(kBtAddr1, "Property_Int"),
265 Optional(Eq(65536)));
266
267 // add the same key "Property_Int" with different value
268 test_btif_config_cache.SetInt(kBtAddr1, "Property_Int", 256);
269 EXPECT_THAT(test_btif_config_cache.GetInt(kBtAddr1, "Property_Int"),
270 Optional(Eq(256)));
271
272 test_btif_config_cache.SetUint64(kBtAddr1, "Property_64", 4294967296);
273 EXPECT_THAT(test_btif_config_cache.GetUint64(kBtAddr1, "Property_64"),
274 Optional(Eq(uint64_t(4294967296))));
275
276 // get the LinkKey and set values in the same key in paired device list
277 test_btif_config_cache.SetString(kBtAddr1, "LinkKey", "1122334455667788");
278 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "LinkKey"));
279 EXPECT_FALSE(test_btif_config_cache.HasUnpairedSection(kBtAddr1));
280 EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(kBtAddr1));
281
282 // add the same key "Name" with the different value
283 test_btif_config_cache.SetString(kBtAddr1, "Name", "Headset_1A");
284 EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr1, "Name"),
285 Optional(StrEq("Headset_1A")));
286
287 // add the same key "Name" with the value different
288 test_btif_config_cache.SetString(kBtAddr1, "Name", "Headset_2A");
289 EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr1, "Name"),
290 Optional(StrEq("Headset_2A")));
291
292 test_btif_config_cache.SetInt(kBtAddr1, "Property_Int", 64);
293 EXPECT_THAT(test_btif_config_cache.GetInt(kBtAddr1, "Property_Int"),
294 Optional(Eq(64)));
295
296 test_btif_config_cache.SetUint64(kBtAddr1, "Property_64", 65537);
297 EXPECT_THAT(test_btif_config_cache.GetUint64(kBtAddr1, "Property_64"),
298 Optional(Eq(uint64_t(65537))));
299
300 EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(kBtAddr1));
301 }
302
303 /* Stress test to pair with device then unpair device
304 * 1. paired with device by adding a "LinKey" to device and check the device be
305 * moved into paired devices list
306 * 2. unpaired with the device by removing the "LinkKey" and check the device be
307 * moved back to unpaired devices cache
308 * 3. loop for 30 times
309 */
TEST(BtifConfigCacheTest,test_pair_unpair_device_stress_test)310 TEST(BtifConfigCacheTest, test_pair_unpair_device_stress_test) {
311 BtifConfigCache test_btif_config_cache(kCapacity);
312
313 // pair with Headset_1 11:22:33:44:55:66
314 test_btif_config_cache.SetString(kBtAddr1, "Name", "Headset_1");
315 EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddr1));
316 EXPECT_FALSE(test_btif_config_cache.HasPersistentSection(kBtAddr1));
317
318 for (int i = 0; i < kTestRepeatCount; ++i) {
319 // get the LinkKey, the device will be moved from the unpaired cache to
320 // paired cache
321 test_btif_config_cache.SetString(kBtAddr1, "LinkKey", "1122334455667788");
322 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "LinkKey"));
323 EXPECT_FALSE(test_btif_config_cache.HasUnpairedSection(kBtAddr1));
324 EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(kBtAddr1));
325
326 // remove the LinkKey, the device will be moved from the paired cache to
327 // unpaired cache
328 test_btif_config_cache.RemoveKey(kBtAddr1, "LinkKey");
329 EXPECT_FALSE(test_btif_config_cache.HasKey(kBtAddr1, "LinkKey"));
330 EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddr1));
331 EXPECT_FALSE(test_btif_config_cache.HasPersistentSection(kBtAddr1));
332 }
333 }
334
335 /* Stress test to pair with multi-devices and unpair with multi-devices
336 * 1. Pired with 4 devices with Link-Key type key in order, to check these 4
337 * devices are in the paired devices list cache
338 * 2. unpair with these 4 devices by removed Link-Key type key in order, to
339 * check the fisrt device was ruled-out from unpaired devices cache due to
340 * capacity limitation, and other 3 devices are be moved to unpaired device
341 * cache.
342 */
TEST(BtifConfigCacheTest,test_multi_pair_unpair_with_devices)343 TEST(BtifConfigCacheTest, test_multi_pair_unpair_with_devices) {
344 BtifConfigCache test_btif_config_cache(kCapacity);
345 // pair with 4 bt address devices by add different type linkkey.
346 test_btif_config_cache.SetString(kBtAddr1, "name", "kBtAddr1");
347 test_btif_config_cache.SetString(kBtAddr1, "LinkKey", "1122334455667788");
348 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "LinkKey"));
349
350 test_btif_config_cache.SetString(kBtAddr2, "name", "kBtAddr2");
351 test_btif_config_cache.SetString(kBtAddr2, "LE_KEY_PENC", "aabbccddeeff9900");
352 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr2, "LE_KEY_PENC"));
353
354 test_btif_config_cache.SetString(kBtAddr3, "name", "kBtAddr3");
355 test_btif_config_cache.SetString(kBtAddr3, "LE_KEY_PID", "a1b2c3d4e5feeeee");
356 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr3, "LE_KEY_PID"));
357
358 test_btif_config_cache.SetString(kBtAddr4, "LE_KEY_PCSRK",
359 "aaaabbbbccccdddd");
360 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr4, "LE_KEY_PCSRK"));
361
362 test_btif_config_cache.SetString(kBtAddr5, "name", "kBtAddr5");
363 test_btif_config_cache.SetString(kBtAddr5, "LE_KEY_LENC", "jilkjlkjlkn");
364 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr5, "LE_KEY_LENC"));
365
366 // checking these 4 devices are in paired list cache and the content are
367 // correct.
368 EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(kBtAddr1));
369 EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr1, "LinkKey"),
370 Optional(StrEq("1122334455667788")));
371 EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(kBtAddr2));
372 EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr2, "LE_KEY_PENC"),
373 Optional(StrEq("aabbccddeeff9900")));
374 EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(kBtAddr3));
375 EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr3, "LE_KEY_PID"),
376 Optional(StrEq("a1b2c3d4e5feeeee")));
377 EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(kBtAddr4));
378 EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr4, "LE_KEY_PCSRK"),
379 Optional(StrEq("aaaabbbbccccdddd")));
380 EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(kBtAddr5));
381 EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr5, "LE_KEY_LENC"),
382 Optional(StrEq("jilkjlkjlkn")));
383
384 // unpair with these 4 bt address devices by removed the linkkey.
385 // unpair kBtAddr1 11:22:33:44:55:66
386 test_btif_config_cache.RemoveKey(kBtAddr1, "LinkKey");
387 EXPECT_FALSE(test_btif_config_cache.HasKey(kBtAddr1, "LinkKey"));
388 // no empty section is moved to unpaired
389 EXPECT_FALSE(test_btif_config_cache.HasPersistentSection(kBtAddr1));
390 EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddr1));
391 EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr1, "name"),
392 Optional(StrEq("kBtAddr1")));
393
394 // unpair with kBtAddr2 aa:bb:cc:dd:ee:ff
395 test_btif_config_cache.RemoveKey(kBtAddr2, "LE_KEY_PENC");
396 EXPECT_FALSE(test_btif_config_cache.HasKey(kBtAddr2, "LE_KEY_PENC"));
397 EXPECT_FALSE(test_btif_config_cache.HasPersistentSection(kBtAddr2));
398 EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddr2));
399 EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr2, "name"),
400 Optional(StrEq("kBtAddr2")));
401
402 // unpair with kBtAddr3 AB:CD:EF:12:34:56
403 test_btif_config_cache.RemoveKey(kBtAddr3, "LE_KEY_PID");
404 EXPECT_FALSE(test_btif_config_cache.HasKey(kBtAddr3, "LE_KEY_PID"));
405 EXPECT_FALSE(test_btif_config_cache.HasPersistentSection(kBtAddr3));
406 // no empty section is moved to unpaired
407 EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddr3));
408 EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr3, "name"),
409 Optional(StrEq("kBtAddr3")));
410
411 // unpair with kBtAddr4 11:AA:22:BB:33:CC
412 test_btif_config_cache.RemoveKey(kBtAddr4, "LE_KEY_PCSRK");
413 EXPECT_FALSE(test_btif_config_cache.HasKey(kBtAddr4, "LE_KEY_PCSRK"));
414 EXPECT_FALSE(test_btif_config_cache.HasPersistentSection(kBtAddr4));
415 // empty section is removed
416 EXPECT_FALSE(test_btif_config_cache.HasUnpairedSection(kBtAddr4));
417
418 // unpair with kBtAddr5 11:AA:22:BB:33:CD
419 test_btif_config_cache.RemoveKey(kBtAddr5, "LE_KEY_LENC");
420 EXPECT_FALSE(test_btif_config_cache.HasKey(kBtAddr5, "LE_KEY_LENC"));
421 EXPECT_FALSE(test_btif_config_cache.HasPersistentSection(kBtAddr5));
422 // no empty section is moved to unpaired
423 EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddr5));
424 EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr5, "name"),
425 Optional(StrEq("kBtAddr5")));
426
427 // checking the oldest unpaired device kBtAddr1 was ruled out from cache due
428 // to capacity limitation (3) in unpaired cache.
429 EXPECT_FALSE(test_btif_config_cache.HasUnpairedSection(kBtAddr1));
430 }
431
432 /* Test to remove sections with the specific key
433 * paired with sections with the specific "Restricted" key and then removed the
434 * "Restricted" key, check if the sections with the specific "Restricted" key
435 * are removed.
436 */
TEST(BtifConfigCacheTest,test_remove_sections_with_key)437 TEST(BtifConfigCacheTest, test_remove_sections_with_key) {
438 BtifConfigCache test_btif_config_cache(kCapacity);
439 // pair with Headset_1 (kBtAddr1), Headset_2 (kBtAddr1), Heasdet_3 (kBtAddr3)
440 // , and Headset_1 (kBtAddr1), Headset_3 (kBtAddr3) have sepcific "Restricted"
441 // key
442 test_btif_config_cache.SetString(kBtAddr1, "Name", "Headset_1");
443 test_btif_config_cache.SetString(kBtAddr1, "Restricted", "1");
444 test_btif_config_cache.SetString(kBtAddr1, "LinkKey", "1122334455667788");
445 test_btif_config_cache.SetString(kBtAddr2, "Name", "Headset_2");
446 test_btif_config_cache.SetString(kBtAddr2, "LinkKey", "aabbccddeeff9900");
447 test_btif_config_cache.SetString(kBtAddr3, "Name", "Headset_3");
448 test_btif_config_cache.SetString(kBtAddr3, "LinkKey", "a1b2c3d4e5feeeee");
449 test_btif_config_cache.SetString(kBtAddr3, "Restricted", "1");
450
451 // remove sections with "Restricted" key
452 test_btif_config_cache.RemovePersistentSectionsWithKey("Restricted");
453
454 // checking the kBtAddr1 and kBtAddr3 can not be found in config cache, only
455 // keep kBtAddr2 in config cache.
456 EXPECT_FALSE(test_btif_config_cache.HasSection(kBtAddr1));
457 EXPECT_TRUE(test_btif_config_cache.HasSection(kBtAddr2));
458 EXPECT_FALSE(test_btif_config_cache.HasSection(kBtAddr3));
459 }
460
461 /* Test PersistentSectionCopy and Init */
TEST(BtifConfigCacheTest,test_PersistentSectionCopy_Init)462 TEST(BtifConfigCacheTest, test_PersistentSectionCopy_Init) {
463 BtifConfigCache test_btif_config_cache(kCapacity);
464 config_t config_paired = {};
465 // pair with 3 bt devices, kBtAddr1, kBtAddr2, kBtAddr3
466 test_btif_config_cache.SetString(kBtAddr1, "LinkKey", "1122334455667788");
467 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "LinkKey"));
468 EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(kBtAddr1));
469 EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr1, "LinkKey"),
470 Optional(StrEq("1122334455667788")));
471
472 test_btif_config_cache.SetString(kBtAddr2, "LE_KEY_PENC", "aabbccddeeff9900");
473 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr2, "LE_KEY_PENC"));
474 EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(kBtAddr2));
475 EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr2, "LE_KEY_PENC"),
476 Optional(StrEq("aabbccddeeff9900")));
477
478 test_btif_config_cache.SetString(kBtAddr3, "LE_KEY_PID", "a1b2c3d4e5feeeee");
479 EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr3, "LE_KEY_PID"));
480 EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(kBtAddr3));
481 EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr3, "LE_KEY_PID"),
482 Optional(StrEq("a1b2c3d4e5feeeee")));
483
484 // check GetPersistentSections
485 int num_of_paired_devices = 0;
486 for (const auto& sec_name :
487 test_btif_config_cache.GetPersistentSectionNames()) {
488 EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(sec_name));
489 num_of_paired_devices++;
490 }
491 EXPECT_EQ(num_of_paired_devices, 3);
492
493 // copy persistent sections
494 int num_of_copy_paired_devices = 0;
495 config_paired = test_btif_config_cache.PersistentSectionCopy();
496 for (const section_t& sec : config_paired.sections) {
497 EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(sec.name));
498 num_of_copy_paired_devices++;
499 }
500 EXPECT_EQ(num_of_copy_paired_devices, 3);
501
502 // write persistent sections to temp test config file
503 EXPECT_TRUE(config_save(config_paired, TEST_CONFIG_FILE));
504 // get persistent sections from temp test config file
505 int num_of_save_paired_devices = 0;
506 std::unique_ptr<config_t> config_source = config_new(TEST_CONFIG_FILE);
507 for (const section_t& sec : config_paired.sections) {
508 EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(sec.name));
509 num_of_save_paired_devices++;
510 }
511 EXPECT_EQ(num_of_save_paired_devices, 3);
512
513 // Clear all btif config cache sections
514 test_btif_config_cache.Clear();
515
516 // move the persistent sections to btif config paired list
517 int num_of_init_paired_devices = 0;
518 test_btif_config_cache.Init(std::move(config_source));
519 for (const section_t& sec : config_paired.sections) {
520 EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(sec.name));
521 num_of_init_paired_devices++;
522 }
523 EXPECT_EQ(num_of_init_paired_devices, 3);
524
525 EXPECT_TRUE(std::filesystem::remove(kTestConfigFile));
526 }
527
528 } // namespace testing
529