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 "osi/include/config.h"
18 
19 #include <base/files/file_util.h>
20 #include <gtest/gtest.h>
21 
22 #include <filesystem>
23 
24 static const std::filesystem::path kConfigFile =
25     std::filesystem::temp_directory_path() / "config_test.conf";
26 static const char* CONFIG_FILE = kConfigFile.c_str();
27 static const char CONFIG_FILE_CONTENT[] =
28     "                                                                                \n\
29 first_key=value                                                                      \n\
30                                                                                      \n\
31 # Device ID (DID) configuration                                                      \n\
32 [DID]                                                                                \n\
33                                                                                      \n\
34 # Record Number: 1, 2 or 3 - maximum of 3 records                                    \n\
35 recordNumber = 1                                                                     \n\
36                                                                                      \n\
37 # Primary Record - true or false (default)                                           \n\
38 # There can be only one primary record                                               \n\
39 primaryRecord = true                                                                 \n\
40                                                                                      \n\
41 # Vendor ID '0xFFFF' indicates no Device ID Service Record is present in the device  \n\
42 # 0x000F = Broadcom Corporation (default)                                            \n\
43 #vendorId = 0x000F                                                                   \n\
44                                                                                      \n\
45 # Vendor ID Source                                                                   \n\
46 # 0x0001 = Bluetooth SIG assigned Device ID Vendor ID value (default)                \n\
47 # 0x0002 = USB Implementer's Forum assigned Device ID Vendor ID value                \n\
48 #vendorIdSource = 0x0001                                                             \n\
49                                                                                      \n\
50 # Product ID & Product Version                                                       \n\
51 # Per spec DID v1.3 0xJJMN for version is interpreted as JJ.M.N                      \n\
52 # JJ: major version number, M: minor version number, N: sub-minor version number     \n\
53 # For example: 1200, v14.3.6                                                         \n\
54 productId = 0x1200                                                                   \n\
55 version = 0x1111                                                                     \n\
56                                                                                      \n\
57 # Optional attributes                                                                \n\
58 #clientExecutableURL =                                                               \n\
59 #serviceDescription =                                                                \n\
60 #documentationURL =                                                                  \n\
61                                                                                      \n\
62 # Additional optional DID records. Bluedroid supports up to 3 records.               \n\
63 [DID]                                                                                \n\
64 [DID]                                                                                \n\
65 version = 0x1436                                                                     \n\
66                                                                                      \n\
67 HiSyncId = 18446744073709551615                                                      \n\
68 HiSyncId2 = 15001900                                                                 \n\
69 ";
70 
71 class ConfigTest : public ::testing::Test {
72  protected:
SetUp()73   void SetUp() override {
74     FILE* fp = fopen(CONFIG_FILE, "wt");
75     ASSERT_NE(fp, nullptr);
76     ASSERT_EQ(fwrite(CONFIG_FILE_CONTENT, 1, sizeof(CONFIG_FILE_CONTENT), fp),
77               sizeof(CONFIG_FILE_CONTENT));
78     ASSERT_EQ(fclose(fp), 0);
79   }
80 
TearDown()81   void TearDown() override {
82     EXPECT_TRUE(std::filesystem::remove(kConfigFile));
83   }
84 };
85 
TEST_F(ConfigTest,config_find)86 TEST_F(ConfigTest, config_find) {
87   std::unique_ptr<config_t> config = config_new(CONFIG_FILE);
88   ASSERT_NE(config, nullptr);
89   EXPECT_TRUE(config->Has("DID"));
90   auto section_iter = config->Find("DID");
91   ASSERT_NE(section_iter, config->sections.end());
92   EXPECT_FALSE(config->Has("random"));
93   EXPECT_EQ(config->Find("random"), config->sections.end());
94 }
95 
TEST_F(ConfigTest,section_find)96 TEST_F(ConfigTest, section_find) {
97   std::unique_ptr<config_t> config = config_new(CONFIG_FILE);
98   ASSERT_NE(config, nullptr);
99   EXPECT_TRUE(config->Has("DID"));
100   auto section_iter = config->Find("DID");
101   ASSERT_NE(section_iter, config->sections.end());
102   EXPECT_EQ(section_iter->name, "DID");
103   EXPECT_TRUE(section_iter->Has("version"));
104   auto entry_iter = section_iter->Find("version");
105   ASSERT_NE(entry_iter, section_iter->entries.end());
106   EXPECT_EQ(entry_iter->key, "version");
107   EXPECT_EQ(entry_iter->value, "0x1436");
108   EXPECT_EQ(section_iter->Find("random"), section_iter->entries.end());
109   EXPECT_FALSE(section_iter->Has("random"));
110 }
111 
TEST_F(ConfigTest,section_set)112 TEST_F(ConfigTest, section_set) {
113   std::unique_ptr<config_t> config = config_new(CONFIG_FILE);
114   ASSERT_NE(config, nullptr);
115   EXPECT_TRUE(config->Has("DID"));
116   auto section_iter = config->Find("DID");
117   ASSERT_NE(section_iter, config->sections.end());
118   EXPECT_EQ(section_iter->name, "DID");
119   EXPECT_FALSE(section_iter->Has("random"));
120   section_iter->Set("random", "foo");
121   EXPECT_TRUE(section_iter->Has("random"));
122   auto entry_iter = section_iter->Find("random");
123   ASSERT_NE(entry_iter, section_iter->entries.end());
124   EXPECT_EQ(entry_iter->key, "random");
125   EXPECT_EQ(entry_iter->value, "foo");
126   section_iter->Set("random", "bar");
127   EXPECT_EQ(entry_iter->value, "bar");
128   entry_iter = section_iter->Find("random");
129   ASSERT_NE(entry_iter, section_iter->entries.end());
130   EXPECT_EQ(entry_iter->value, "bar");
131 }
132 
TEST_F(ConfigTest,config_new_empty)133 TEST_F(ConfigTest, config_new_empty) {
134   std::unique_ptr<config_t> config = config_new_empty();
135   EXPECT_TRUE(config.get() != NULL);
136 }
137 
TEST_F(ConfigTest,config_new_no_file)138 TEST_F(ConfigTest, config_new_no_file) {
139   std::unique_ptr<config_t> config = config_new("/meow");
140   EXPECT_TRUE(config.get() == NULL);
141 }
142 
TEST_F(ConfigTest,config_new)143 TEST_F(ConfigTest, config_new) {
144   std::unique_ptr<config_t> config = config_new(CONFIG_FILE);
145   EXPECT_TRUE(config.get() != NULL);
146 }
147 
TEST_F(ConfigTest,config_new_clone)148 TEST_F(ConfigTest, config_new_clone) {
149   std::unique_ptr<config_t> config = config_new(CONFIG_FILE);
150   std::unique_ptr<config_t> clone = config_new_clone(*config);
151 
152   config_set_string(clone.get(), CONFIG_DEFAULT_SECTION, "first_key",
153                     "not_value");
154 
155   std::string one = std::string("one");
156   EXPECT_STRNE(
157       config_get_string(*config, CONFIG_DEFAULT_SECTION, "first_key", &one)
158           ->c_str(),
159       config_get_string(*clone, CONFIG_DEFAULT_SECTION, "first_key", &one)
160           ->c_str());
161 }
162 
TEST_F(ConfigTest,config_has_section)163 TEST_F(ConfigTest, config_has_section) {
164   std::unique_ptr<config_t> config = config_new(CONFIG_FILE);
165   EXPECT_TRUE(config_has_section(*config, "DID"));
166 }
167 
TEST_F(ConfigTest,config_has_key_in_default_section)168 TEST_F(ConfigTest, config_has_key_in_default_section) {
169   std::unique_ptr<config_t> config = config_new(CONFIG_FILE);
170   EXPECT_TRUE(config_has_key(*config, CONFIG_DEFAULT_SECTION, "first_key"));
171   EXPECT_STREQ(
172       config_get_string(*config, CONFIG_DEFAULT_SECTION, "first_key", nullptr)
173           ->c_str(),
174       "value");
175 }
176 
TEST_F(ConfigTest,config_has_keys)177 TEST_F(ConfigTest, config_has_keys) {
178   std::unique_ptr<config_t> config = config_new(CONFIG_FILE);
179   EXPECT_TRUE(config_has_key(*config, "DID", "recordNumber"));
180   EXPECT_TRUE(config_has_key(*config, "DID", "primaryRecord"));
181   EXPECT_TRUE(config_has_key(*config, "DID", "productId"));
182   EXPECT_TRUE(config_has_key(*config, "DID", "version"));
183 }
184 
TEST_F(ConfigTest,config_no_bad_keys)185 TEST_F(ConfigTest, config_no_bad_keys) {
186   std::unique_ptr<config_t> config = config_new(CONFIG_FILE);
187   EXPECT_FALSE(config_has_key(*config, "DID_BAD", "primaryRecord"));
188   EXPECT_FALSE(config_has_key(*config, "DID", "primaryRecord_BAD"));
189   EXPECT_FALSE(
190       config_has_key(*config, CONFIG_DEFAULT_SECTION, "primaryRecord"));
191 }
192 
TEST_F(ConfigTest,config_get_int_version)193 TEST_F(ConfigTest, config_get_int_version) {
194   std::unique_ptr<config_t> config = config_new(CONFIG_FILE);
195   EXPECT_EQ(config_get_int(*config, "DID", "version", 0), 0x1436);
196 }
197 
TEST_F(ConfigTest,config_get_int_default)198 TEST_F(ConfigTest, config_get_int_default) {
199   std::unique_ptr<config_t> config = config_new(CONFIG_FILE);
200   EXPECT_EQ(config_get_int(*config, "DID", "primaryRecord", 123), 123);
201 }
202 
TEST_F(ConfigTest,config_get_uint64)203 TEST_F(ConfigTest, config_get_uint64) {
204   std::unique_ptr<config_t> config = config_new(CONFIG_FILE);
205   EXPECT_EQ(config_get_uint64(*config, "DID", "HiSyncId", 0),
206             0xFFFFFFFFFFFFFFFF);
207   EXPECT_EQ(config_get_uint64(*config, "DID", "HiSyncId2", 0),
208             uint64_t(15001900));
209 }
210 
TEST_F(ConfigTest,config_get_uint64_default)211 TEST_F(ConfigTest, config_get_uint64_default) {
212   std::unique_ptr<config_t> config = config_new(CONFIG_FILE);
213   EXPECT_EQ(config_get_uint64(*config, "DID", "primaryRecord", 123),
214             uint64_t(123));
215 }
216 
TEST_F(ConfigTest,config_remove_section)217 TEST_F(ConfigTest, config_remove_section) {
218   std::unique_ptr<config_t> config = config_new(CONFIG_FILE);
219   EXPECT_TRUE(config_remove_section(config.get(), "DID"));
220   EXPECT_FALSE(config_has_section(*config, "DID"));
221   EXPECT_FALSE(config_has_key(*config, "DID", "productId"));
222 }
223 
TEST_F(ConfigTest,config_remove_section_missing)224 TEST_F(ConfigTest, config_remove_section_missing) {
225   std::unique_ptr<config_t> config = config_new(CONFIG_FILE);
226   EXPECT_FALSE(config_remove_section(config.get(), "not a section"));
227 }
228 
TEST_F(ConfigTest,config_remove_key)229 TEST_F(ConfigTest, config_remove_key) {
230   std::unique_ptr<config_t> config = config_new(CONFIG_FILE);
231   EXPECT_EQ(config_get_int(*config, "DID", "productId", 999), 0x1200);
232   EXPECT_TRUE(config_remove_key(config.get(), "DID", "productId"));
233   EXPECT_FALSE(config_has_key(*config, "DID", "productId"));
234 }
235 
TEST_F(ConfigTest,config_remove_key_missing)236 TEST_F(ConfigTest, config_remove_key_missing) {
237   std::unique_ptr<config_t> config = config_new(CONFIG_FILE);
238   EXPECT_EQ(config_get_int(*config, "DID", "productId", 999), 0x1200);
239   EXPECT_TRUE(config_remove_key(config.get(), "DID", "productId"));
240   EXPECT_EQ(config_get_int(*config, "DID", "productId", 999), 999);
241 }
242 
TEST_F(ConfigTest,config_save_basic)243 TEST_F(ConfigTest, config_save_basic) {
244   std::unique_ptr<config_t> config = config_new(CONFIG_FILE);
245   EXPECT_TRUE(config_save(*config, CONFIG_FILE));
246 }
247 
TEST_F(ConfigTest,checksum_read)248 TEST_F(ConfigTest, checksum_read) {
249   auto tmp_dir = std::filesystem::temp_directory_path();
250   auto filename = tmp_dir / "test.checksum";
251   std::string checksum = "0x1234";
252   base::FilePath file_path(filename.string());
253 
254   EXPECT_EQ(base::WriteFile(file_path, checksum.data(), checksum.size()),
255             (int)checksum.size());
256 
257   EXPECT_EQ(checksum_read(filename.c_str()), checksum.c_str());
258 
259   EXPECT_TRUE(std::filesystem::remove(filename));
260 }
261 
TEST_F(ConfigTest,checksum_save)262 TEST_F(ConfigTest, checksum_save) {
263   auto tmp_dir = std::filesystem::temp_directory_path();
264   auto filename = tmp_dir / "test.checksum";
265   std::string checksum = "0x1234";
266   base::FilePath file_path(filename.string());
267 
268   EXPECT_TRUE(checksum_save(checksum, filename));
269 
270   EXPECT_TRUE(base::PathExists(file_path));
271 
272   EXPECT_TRUE(std::filesystem::remove(filename));
273 }
274