| /* |
| * Copyright 2020 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at: |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "btif/include/btif_config_cache.h" |
| |
| #include <filesystem> |
| |
| #include <gmock/gmock.h> |
| #include <gtest/gtest.h> |
| |
| namespace { |
| |
| const int kCapacity = 3; |
| const int kTestRepeatCount = 30; |
| const std::string kBtAddr1 = "11:22:33:44:55:66"; |
| const std::string kBtAddr2 = "AA:BB:CC:DD:EE:FF"; |
| const std::string kBtAddr3 = "AB:CD:EF:12:34:56"; |
| const std::string kBtAddr4 = "11:AA:22:BB:33:CC"; |
| const std::string kBtAddr5 = "11:AA:22:BB:33:CD"; |
| const std::string kBtLocalAddr = "12:34:56:78:90:AB"; |
| const std::string kBtInfo = "Info"; |
| const std::string kBtMetrics = "Metrics"; |
| const std::string kBtAdapter = "Adapter"; |
| const std::string kBtAddrInvalid1 = "AB:CD:EF:12:34"; |
| const std::string kBtAddrInvalid2 = "AB:CD:EF:12:34:56:78"; |
| const std::string kBtAddrInvalid3 = "ABCDEF123456"; |
| const std::string kBtAddrInvalid4 = "AB-CD-EF-12-34-56"; |
| const std::string kBtSectionInvalid1 = "Invalid Section"; |
| const std::filesystem::path kTestConfigFile = |
| std::filesystem::temp_directory_path() / "config_cache_test.conf"; |
| const char* TEST_CONFIG_FILE = kTestConfigFile.c_str(); |
| |
| } // namespace |
| |
| namespace testing { |
| |
| /* Test to basic btif_config_cache set up |
| * 1. when received Local device sections information, the sections can be put |
| * into btif config cache |
| * 2. the device sections and key-value will be set to Btif config cache when |
| * receiving different device sections |
| * 3. limit the capacity of unpacire devices cache to 3, test the oldest device |
| * section will be ruled out when receiveing 4 different device sections. |
| */ |
| TEST(BtifConfigCacheTest, test_setup_btif_config_cache) { |
| BtifConfigCache test_btif_config_cache(kCapacity); |
| // Info section |
| test_btif_config_cache.SetString(kBtInfo, "FileSource", ""); |
| test_btif_config_cache.SetString(kBtInfo, "TimeCreated", |
| "2020-06-05 12:12:12"); |
| // Metrics section |
| test_btif_config_cache.SetString(kBtMetrics, "Salt256Bit", |
| "92a331174d20f2bb"); |
| // Adapter Section |
| test_btif_config_cache.SetString(kBtAdapter, "Address", kBtLocalAddr); |
| EXPECT_TRUE(test_btif_config_cache.HasSection(kBtAdapter)); |
| |
| // bt_device_1 |
| test_btif_config_cache.SetString(kBtAddr1, "Name", "Headset_1"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "Name")); |
| |
| test_btif_config_cache.SetInt(kBtAddr1, "Property_Int", 1); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "Property_Int")); |
| |
| // bt_device_2 |
| test_btif_config_cache.SetString(kBtAddr2, "Name", "Headset_2"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr2, "Name")); |
| |
| // bt_device_3 |
| test_btif_config_cache.SetString(kBtAddr3, "Name", "Headset_3"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr3, "Name")); |
| |
| // bt_device_4 |
| test_btif_config_cache.SetString(kBtAddr4, "Name", "Headset_4"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr4, "Name")); |
| |
| // out out the capacty of unpair devices cache, the bt_device_1 be ruled out |
| EXPECT_FALSE(test_btif_config_cache.HasSection(kBtAddr1)); |
| EXPECT_TRUE(test_btif_config_cache.HasSection(kBtAddr2)); |
| EXPECT_TRUE(test_btif_config_cache.HasSection(kBtAddr3)); |
| EXPECT_TRUE(test_btif_config_cache.HasSection(kBtAddr4)); |
| } |
| |
| /* Test to set up btif_config_cache with invalid bt address or section name |
| * when received Invalid bt address or section, it's not allowed to put invalid |
| * section to paired devices list section |
| */ |
| TEST(BtifConfigCacheTest, test_set_up_config_cache_with_invalid_section) { |
| BtifConfigCache test_btif_config_cache(kCapacity); |
| |
| // kBtAddrInvalid1 |
| test_btif_config_cache.SetString(kBtAddrInvalid1, "Name", "Headset_1"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddrInvalid1, "Name")); |
| EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddrInvalid1)); |
| // get the LinkKey |
| test_btif_config_cache.SetString(kBtAddrInvalid1, "LinkKey", |
| "1122334455667788"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddrInvalid1, "LinkKey")); |
| EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddrInvalid1)); |
| EXPECT_FALSE(test_btif_config_cache.HasPersistentSection(kBtAddrInvalid1)); |
| |
| // kBtAddrInvalid2 |
| test_btif_config_cache.SetString(kBtAddrInvalid2, "Name", "Headset_1"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddrInvalid2, "Name")); |
| EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddrInvalid2)); |
| // get the LinkKey |
| test_btif_config_cache.SetString(kBtAddrInvalid2, "LinkKey", |
| "1122334455667788"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddrInvalid2, "LinkKey")); |
| EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddrInvalid2)); |
| EXPECT_FALSE(test_btif_config_cache.HasPersistentSection(kBtAddrInvalid2)); |
| |
| // kBtAddrInvalid3 |
| test_btif_config_cache.SetString(kBtAddrInvalid3, "Name", "Headset_1"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddrInvalid3, "Name")); |
| EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddrInvalid3)); |
| // get the LinkKey |
| test_btif_config_cache.SetString(kBtAddrInvalid3, "LinkKey", |
| "1122334455667788"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddrInvalid3, "LinkKey")); |
| EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddrInvalid3)); |
| EXPECT_FALSE(test_btif_config_cache.HasPersistentSection(kBtAddrInvalid3)); |
| |
| // kBtAddrInvalid4 |
| test_btif_config_cache.SetString(kBtAddrInvalid4, "Name", "Headset_1"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddrInvalid4, "Name")); |
| EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddrInvalid4)); |
| // get the LinkKey |
| test_btif_config_cache.SetString(kBtAddrInvalid4, "LinkKey", |
| "1122334455667788"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddrInvalid4, "LinkKey")); |
| EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddrInvalid4)); |
| EXPECT_FALSE(test_btif_config_cache.HasPersistentSection(kBtAddrInvalid4)); |
| |
| // kBtSectionInvalid1 |
| test_btif_config_cache.SetString(kBtSectionInvalid1, "Name", "Headset_1"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtSectionInvalid1, "Name")); |
| EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtSectionInvalid1)); |
| // get the LinkKey |
| test_btif_config_cache.SetString(kBtSectionInvalid1, "LinkKey", |
| "1122334455667788"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtSectionInvalid1, "LinkKey")); |
| EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtSectionInvalid1)); |
| EXPECT_FALSE(test_btif_config_cache.HasPersistentSection(kBtSectionInvalid1)); |
| } |
| |
| /* Stress test to set and get key values |
| * 1. stress test to set different type key value to unpaired device cache and |
| * get the different type key values in the unpaired cache section to check if |
| * we get the key-values the same with we set in unpaired device cache. |
| * 2. stress test to set different type key value to paired device section and |
| * get the different type key values in the paired cache section to check if we |
| * get the key-values the same with we set in paired device cache. |
| */ |
| TEST(BtifConfigCacheTest, test_get_set_key_value_test) { |
| BtifConfigCache test_btif_config_cache(kCapacity); |
| // test in unpaired cache |
| test_btif_config_cache.SetString(kBtAddr1, "Name", "Headset_1"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "Name")); |
| EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr1, "Name"), |
| Optional(StrEq("Headset_1"))); |
| |
| test_btif_config_cache.SetInt(kBtAddr1, "Property_Int", 65536); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "Property_Int")); |
| EXPECT_THAT(test_btif_config_cache.GetInt(kBtAddr1, "Property_Int"), |
| Optional(Eq(65536))); |
| |
| test_btif_config_cache.SetUint64(kBtAddr1, "Property_64", 4294967296); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "Property_64")); |
| EXPECT_THAT(test_btif_config_cache.GetUint64(kBtAddr1, "Property_64"), |
| Optional(Eq(uint64_t(4294967296)))); |
| |
| test_btif_config_cache.SetBool(kBtAddr1, "Property_Bool", true); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "Property_Bool")); |
| EXPECT_THAT(test_btif_config_cache.GetBool(kBtAddr1, "Property_Bool"), |
| Optional(IsTrue())); |
| |
| // empty value |
| test_btif_config_cache.SetString(kBtAddr1, "Name", ""); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "Name")); |
| EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr1, "Name"), |
| Optional(StrEq(""))); |
| |
| // get the LinkKey |
| test_btif_config_cache.SetString(kBtAddr1, "LinkKey", "1122334455667788"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "LinkKey")); |
| EXPECT_FALSE(test_btif_config_cache.HasUnpairedSection(kBtAddr1)); |
| EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(kBtAddr1)); |
| |
| // test in unpaired cache |
| test_btif_config_cache.SetString(kBtAddr1, "Name", "Headset_1"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "Name")); |
| EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr1, "Name"), |
| Optional(StrEq("Headset_1"))); |
| |
| test_btif_config_cache.SetInt(kBtAddr1, "Property_Int", 65536); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "Property_Int")); |
| EXPECT_THAT(test_btif_config_cache.GetInt(kBtAddr1, "Property_Int"), |
| Optional(Eq(65536))); |
| |
| test_btif_config_cache.SetUint64(kBtAddr1, "Property_64", 4294967296); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "Property_64")); |
| EXPECT_THAT(test_btif_config_cache.GetUint64(kBtAddr1, "Property_64"), |
| Optional(Eq(uint64_t(4294967296)))); |
| |
| test_btif_config_cache.SetBool(kBtAddr1, "Property_Bool", true); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "Property_Bool")); |
| EXPECT_THAT(test_btif_config_cache.GetBool(kBtAddr1, "Property_Bool"), |
| Optional(IsTrue())); |
| |
| // empty section is disallowed |
| EXPECT_DEATH({ test_btif_config_cache.SetString("", "name", "Headset_1"); }, |
| "Empty section not allowed"); |
| // empty key is disallowed |
| EXPECT_DEATH({ test_btif_config_cache.SetString(kBtAddr1, "", "Headset_1"); }, |
| "Empty key not allowed"); |
| EXPECT_FALSE(test_btif_config_cache.HasKey(kBtAddr1, "")); |
| // empty value is allowed |
| test_btif_config_cache.SetString(kBtAddr1, "Name", ""); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "Name")); |
| EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr1, "Name"), |
| Optional(StrEq(""))); |
| } |
| |
| /* Test to set values in the same key |
| * Receiving the same key with different values in a section, the new incoming |
| * value will be updated but the key will not be added repeatedly. test this |
| * feature in both unpaired devic cache and paired device list cache |
| */ |
| TEST(BtifConfigCacheTest, test_set_values_in_the_same_key) { |
| BtifConfigCache test_btif_config_cache(kCapacity); |
| // add new a key "Name" |
| test_btif_config_cache.SetString(kBtAddr1, "Name", "Headset_1"); |
| EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr1, "Name"), |
| Optional(StrEq("Headset_1"))); |
| EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddr1)); |
| |
| // add the same key "Name" with different value |
| test_btif_config_cache.SetString(kBtAddr1, "Name", "Headset_1A"); |
| EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr1, "Name"), |
| Optional(StrEq("Headset_1A"))); |
| |
| // add the same key "Name" with different value |
| test_btif_config_cache.SetString(kBtAddr1, "Name", "Headset_2A"); |
| EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr1, "Name"), |
| Optional(StrEq("Headset_2A"))); |
| EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddr1)); |
| |
| // add new a key "Property_Int" |
| test_btif_config_cache.SetInt(kBtAddr1, "Property_Int", 65536); |
| EXPECT_THAT(test_btif_config_cache.GetInt(kBtAddr1, "Property_Int"), |
| Optional(Eq(65536))); |
| |
| // add the same key "Property_Int" with different value |
| test_btif_config_cache.SetInt(kBtAddr1, "Property_Int", 256); |
| EXPECT_THAT(test_btif_config_cache.GetInt(kBtAddr1, "Property_Int"), |
| Optional(Eq(256))); |
| |
| test_btif_config_cache.SetUint64(kBtAddr1, "Property_64", 4294967296); |
| EXPECT_THAT(test_btif_config_cache.GetUint64(kBtAddr1, "Property_64"), |
| Optional(Eq(uint64_t(4294967296)))); |
| |
| // get the LinkKey and set values in the same key in paired device list |
| test_btif_config_cache.SetString(kBtAddr1, "LinkKey", "1122334455667788"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "LinkKey")); |
| EXPECT_FALSE(test_btif_config_cache.HasUnpairedSection(kBtAddr1)); |
| EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(kBtAddr1)); |
| |
| // add the same key "Name" with the different value |
| test_btif_config_cache.SetString(kBtAddr1, "Name", "Headset_1A"); |
| EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr1, "Name"), |
| Optional(StrEq("Headset_1A"))); |
| |
| // add the same key "Name" with the value different |
| test_btif_config_cache.SetString(kBtAddr1, "Name", "Headset_2A"); |
| EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr1, "Name"), |
| Optional(StrEq("Headset_2A"))); |
| |
| test_btif_config_cache.SetInt(kBtAddr1, "Property_Int", 64); |
| EXPECT_THAT(test_btif_config_cache.GetInt(kBtAddr1, "Property_Int"), |
| Optional(Eq(64))); |
| |
| test_btif_config_cache.SetUint64(kBtAddr1, "Property_64", 65537); |
| EXPECT_THAT(test_btif_config_cache.GetUint64(kBtAddr1, "Property_64"), |
| Optional(Eq(uint64_t(65537)))); |
| |
| EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(kBtAddr1)); |
| } |
| |
| /* Stress test to pair with device then unpair device |
| * 1. paired with device by adding a "LinKey" to device and check the device be |
| * moved into paired devices list |
| * 2. unpaired with the device by removing the "LinkKey" and check the device be |
| * moved back to unpaired devices cache |
| * 3. loop for 30 times |
| */ |
| TEST(BtifConfigCacheTest, test_pair_unpair_device_stress_test) { |
| BtifConfigCache test_btif_config_cache(kCapacity); |
| |
| // pair with Headset_1 11:22:33:44:55:66 |
| test_btif_config_cache.SetString(kBtAddr1, "Name", "Headset_1"); |
| EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddr1)); |
| EXPECT_FALSE(test_btif_config_cache.HasPersistentSection(kBtAddr1)); |
| |
| for (int i = 0; i < kTestRepeatCount; ++i) { |
| // get the LinkKey, the device will be moved from the unpaired cache to |
| // paired cache |
| test_btif_config_cache.SetString(kBtAddr1, "LinkKey", "1122334455667788"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "LinkKey")); |
| EXPECT_FALSE(test_btif_config_cache.HasUnpairedSection(kBtAddr1)); |
| EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(kBtAddr1)); |
| |
| // remove the LinkKey, the device will be moved from the paired cache to |
| // unpaired cache |
| test_btif_config_cache.RemoveKey(kBtAddr1, "LinkKey"); |
| EXPECT_FALSE(test_btif_config_cache.HasKey(kBtAddr1, "LinkKey")); |
| EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddr1)); |
| EXPECT_FALSE(test_btif_config_cache.HasPersistentSection(kBtAddr1)); |
| } |
| } |
| |
| /* Stress test to pair with multi-devices and unpair with multi-devices |
| * 1. Pired with 4 devices with Link-Key type key in order, to check these 4 |
| * devices are in the paired devices list cache |
| * 2. unpair with these 4 devices by removed Link-Key type key in order, to |
| * check the fisrt device was ruled-out from unpaired devices cache due to |
| * capacity limitation, and other 3 devices are be moved to unpaired device |
| * cache. |
| */ |
| TEST(BtifConfigCacheTest, test_multi_pair_unpair_with_devices) { |
| BtifConfigCache test_btif_config_cache(kCapacity); |
| // pair with 4 bt address devices by add different type linkkey. |
| test_btif_config_cache.SetString(kBtAddr1, "name", "kBtAddr1"); |
| test_btif_config_cache.SetString(kBtAddr1, "LinkKey", "1122334455667788"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "LinkKey")); |
| |
| test_btif_config_cache.SetString(kBtAddr2, "name", "kBtAddr2"); |
| test_btif_config_cache.SetString(kBtAddr2, "LE_KEY_PENC", "aabbccddeeff9900"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr2, "LE_KEY_PENC")); |
| |
| test_btif_config_cache.SetString(kBtAddr3, "name", "kBtAddr3"); |
| test_btif_config_cache.SetString(kBtAddr3, "LE_KEY_PID", "a1b2c3d4e5feeeee"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr3, "LE_KEY_PID")); |
| |
| test_btif_config_cache.SetString(kBtAddr4, "LE_KEY_PCSRK", |
| "aaaabbbbccccdddd"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr4, "LE_KEY_PCSRK")); |
| |
| test_btif_config_cache.SetString(kBtAddr5, "name", "kBtAddr5"); |
| test_btif_config_cache.SetString(kBtAddr5, "LE_KEY_LENC", "jilkjlkjlkn"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr5, "LE_KEY_LENC")); |
| |
| // checking these 4 devices are in paired list cache and the content are |
| // correct. |
| EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(kBtAddr1)); |
| EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr1, "LinkKey"), |
| Optional(StrEq("1122334455667788"))); |
| EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(kBtAddr2)); |
| EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr2, "LE_KEY_PENC"), |
| Optional(StrEq("aabbccddeeff9900"))); |
| EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(kBtAddr3)); |
| EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr3, "LE_KEY_PID"), |
| Optional(StrEq("a1b2c3d4e5feeeee"))); |
| EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(kBtAddr4)); |
| EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr4, "LE_KEY_PCSRK"), |
| Optional(StrEq("aaaabbbbccccdddd"))); |
| EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(kBtAddr5)); |
| EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr5, "LE_KEY_LENC"), |
| Optional(StrEq("jilkjlkjlkn"))); |
| |
| // unpair with these 4 bt address devices by removed the linkkey. |
| // unpair kBtAddr1 11:22:33:44:55:66 |
| test_btif_config_cache.RemoveKey(kBtAddr1, "LinkKey"); |
| EXPECT_FALSE(test_btif_config_cache.HasKey(kBtAddr1, "LinkKey")); |
| // no empty section is moved to unpaired |
| EXPECT_FALSE(test_btif_config_cache.HasPersistentSection(kBtAddr1)); |
| EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddr1)); |
| EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr1, "name"), |
| Optional(StrEq("kBtAddr1"))); |
| |
| // unpair with kBtAddr2 aa:bb:cc:dd:ee:ff |
| test_btif_config_cache.RemoveKey(kBtAddr2, "LE_KEY_PENC"); |
| EXPECT_FALSE(test_btif_config_cache.HasKey(kBtAddr2, "LE_KEY_PENC")); |
| EXPECT_FALSE(test_btif_config_cache.HasPersistentSection(kBtAddr2)); |
| EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddr2)); |
| EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr2, "name"), |
| Optional(StrEq("kBtAddr2"))); |
| |
| // unpair with kBtAddr3 AB:CD:EF:12:34:56 |
| test_btif_config_cache.RemoveKey(kBtAddr3, "LE_KEY_PID"); |
| EXPECT_FALSE(test_btif_config_cache.HasKey(kBtAddr3, "LE_KEY_PID")); |
| EXPECT_FALSE(test_btif_config_cache.HasPersistentSection(kBtAddr3)); |
| // no empty section is moved to unpaired |
| EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddr3)); |
| EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr3, "name"), |
| Optional(StrEq("kBtAddr3"))); |
| |
| // unpair with kBtAddr4 11:AA:22:BB:33:CC |
| test_btif_config_cache.RemoveKey(kBtAddr4, "LE_KEY_PCSRK"); |
| EXPECT_FALSE(test_btif_config_cache.HasKey(kBtAddr4, "LE_KEY_PCSRK")); |
| EXPECT_FALSE(test_btif_config_cache.HasPersistentSection(kBtAddr4)); |
| // empty section is removed |
| EXPECT_FALSE(test_btif_config_cache.HasUnpairedSection(kBtAddr4)); |
| |
| // unpair with kBtAddr5 11:AA:22:BB:33:CD |
| test_btif_config_cache.RemoveKey(kBtAddr5, "LE_KEY_LENC"); |
| EXPECT_FALSE(test_btif_config_cache.HasKey(kBtAddr5, "LE_KEY_LENC")); |
| EXPECT_FALSE(test_btif_config_cache.HasPersistentSection(kBtAddr5)); |
| // no empty section is moved to unpaired |
| EXPECT_TRUE(test_btif_config_cache.HasUnpairedSection(kBtAddr5)); |
| EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr5, "name"), |
| Optional(StrEq("kBtAddr5"))); |
| |
| // checking the oldest unpaired device kBtAddr1 was ruled out from cache due |
| // to capacity limitation (3) in unpaired cache. |
| EXPECT_FALSE(test_btif_config_cache.HasUnpairedSection(kBtAddr1)); |
| } |
| |
| /* Test to remove sections with the specific key |
| * paired with sections with the specific "Restricted" key and then removed the |
| * "Restricted" key, check if the sections with the specific "Restricted" key |
| * are removed. |
| */ |
| TEST(BtifConfigCacheTest, test_remove_sections_with_key) { |
| BtifConfigCache test_btif_config_cache(kCapacity); |
| // pair with Headset_1 (kBtAddr1), Headset_2 (kBtAddr1), Heasdet_3 (kBtAddr3) |
| // , and Headset_1 (kBtAddr1), Headset_3 (kBtAddr3) have sepcific "Restricted" |
| // key |
| test_btif_config_cache.SetString(kBtAddr1, "Name", "Headset_1"); |
| test_btif_config_cache.SetString(kBtAddr1, "Restricted", "1"); |
| test_btif_config_cache.SetString(kBtAddr1, "LinkKey", "1122334455667788"); |
| test_btif_config_cache.SetString(kBtAddr2, "Name", "Headset_2"); |
| test_btif_config_cache.SetString(kBtAddr2, "LinkKey", "aabbccddeeff9900"); |
| test_btif_config_cache.SetString(kBtAddr3, "Name", "Headset_3"); |
| test_btif_config_cache.SetString(kBtAddr3, "LinkKey", "a1b2c3d4e5feeeee"); |
| test_btif_config_cache.SetString(kBtAddr3, "Restricted", "1"); |
| |
| // remove sections with "Restricted" key |
| test_btif_config_cache.RemovePersistentSectionsWithKey("Restricted"); |
| |
| // checking the kBtAddr1 and kBtAddr3 can not be found in config cache, only |
| // keep kBtAddr2 in config cache. |
| EXPECT_FALSE(test_btif_config_cache.HasSection(kBtAddr1)); |
| EXPECT_TRUE(test_btif_config_cache.HasSection(kBtAddr2)); |
| EXPECT_FALSE(test_btif_config_cache.HasSection(kBtAddr3)); |
| } |
| |
| /* Test PersistentSectionCopy and Init */ |
| TEST(BtifConfigCacheTest, test_PersistentSectionCopy_Init) { |
| BtifConfigCache test_btif_config_cache(kCapacity); |
| config_t config_paired = {}; |
| // pair with 3 bt devices, kBtAddr1, kBtAddr2, kBtAddr3 |
| test_btif_config_cache.SetString(kBtAddr1, "LinkKey", "1122334455667788"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr1, "LinkKey")); |
| EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(kBtAddr1)); |
| EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr1, "LinkKey"), |
| Optional(StrEq("1122334455667788"))); |
| |
| test_btif_config_cache.SetString(kBtAddr2, "LE_KEY_PENC", "aabbccddeeff9900"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr2, "LE_KEY_PENC")); |
| EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(kBtAddr2)); |
| EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr2, "LE_KEY_PENC"), |
| Optional(StrEq("aabbccddeeff9900"))); |
| |
| test_btif_config_cache.SetString(kBtAddr3, "LE_KEY_PID", "a1b2c3d4e5feeeee"); |
| EXPECT_TRUE(test_btif_config_cache.HasKey(kBtAddr3, "LE_KEY_PID")); |
| EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(kBtAddr3)); |
| EXPECT_THAT(test_btif_config_cache.GetString(kBtAddr3, "LE_KEY_PID"), |
| Optional(StrEq("a1b2c3d4e5feeeee"))); |
| |
| // check GetPersistentSections |
| int num_of_paired_devices = 0; |
| for (const section_t& sec : test_btif_config_cache.GetPersistentSections()) { |
| EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(sec.name)); |
| num_of_paired_devices++; |
| } |
| EXPECT_EQ(num_of_paired_devices, 3); |
| |
| // copy persistent sections |
| int num_of_copy_paired_devices = 0; |
| config_paired = test_btif_config_cache.PersistentSectionCopy(); |
| for (const section_t& sec : config_paired.sections) { |
| EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(sec.name)); |
| num_of_copy_paired_devices++; |
| } |
| EXPECT_EQ(num_of_copy_paired_devices, 3); |
| |
| // write persistent sections to temp test config file |
| EXPECT_TRUE(config_save(config_paired, TEST_CONFIG_FILE)); |
| // get persistent sections from temp test config file |
| int num_of_save_paired_devices = 0; |
| std::unique_ptr<config_t> config_source = config_new(TEST_CONFIG_FILE); |
| for (const section_t& sec : config_paired.sections) { |
| EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(sec.name)); |
| num_of_save_paired_devices++; |
| } |
| EXPECT_EQ(num_of_save_paired_devices, 3); |
| |
| // Clear all btif config cache sections |
| test_btif_config_cache.Clear(); |
| |
| // move the persistent sections to btif config paired list |
| int num_of_init_paired_devices = 0; |
| test_btif_config_cache.Init(std::move(config_source)); |
| for (const section_t& sec : config_paired.sections) { |
| EXPECT_TRUE(test_btif_config_cache.HasPersistentSection(sec.name)); |
| num_of_init_paired_devices++; |
| } |
| EXPECT_EQ(num_of_init_paired_devices, 3); |
| |
| EXPECT_TRUE(std::filesystem::remove(kTestConfigFile)); |
| } |
| |
| } // namespace testing |
