1 /******************************************************************************
2 *
3 * Copyright 2019 The Android Open Source Project
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 <unordered_map>
20
21 #include <gmock/gmock.h>
22 #include <gtest/gtest.h>
23
24 #include "hci/address.h"
25
26 using bluetooth::hci::Address;
27
28 static const char* test_addr = "bc:9a:78:56:34:12";
29 static const char* test_addr2 = "21:43:65:87:a9:cb";
30
TEST(AddressUnittest,test_constructor_array)31 TEST(AddressUnittest, test_constructor_array) {
32 Address bdaddr({0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc});
33
34 ASSERT_EQ(0x12, bdaddr.address[0]);
35 ASSERT_EQ(0x34, bdaddr.address[1]);
36 ASSERT_EQ(0x56, bdaddr.address[2]);
37 ASSERT_EQ(0x78, bdaddr.address[3]);
38 ASSERT_EQ(0x9A, bdaddr.address[4]);
39 ASSERT_EQ(0xBC, bdaddr.address[5]);
40
41 std::string ret = bdaddr.ToString();
42
43 ASSERT_STREQ(test_addr, ret.c_str());
44 }
45
TEST(AddressUnittest,test_is_empty)46 TEST(AddressUnittest, test_is_empty) {
47 Address empty;
48 Address::FromString("00:00:00:00:00:00", empty);
49 ASSERT_TRUE(empty.IsEmpty());
50
51 Address not_empty;
52 Address::FromString("00:00:00:00:00:01", not_empty);
53 ASSERT_FALSE(not_empty.IsEmpty());
54 }
55
TEST(AddressUnittest,test_to_from_str)56 TEST(AddressUnittest, test_to_from_str) {
57 Address bdaddr;
58 Address::FromString(test_addr, bdaddr);
59
60 ASSERT_EQ(0x12, bdaddr.address[0]);
61 ASSERT_EQ(0x34, bdaddr.address[1]);
62 ASSERT_EQ(0x56, bdaddr.address[2]);
63 ASSERT_EQ(0x78, bdaddr.address[3]);
64 ASSERT_EQ(0x9A, bdaddr.address[4]);
65 ASSERT_EQ(0xBC, bdaddr.address[5]);
66
67 std::string ret = bdaddr.ToString();
68
69 ASSERT_STREQ(test_addr, ret.c_str());
70 }
71
TEST(AddressUnittest,test_from_octets)72 TEST(AddressUnittest, test_from_octets) {
73 static const uint8_t test_addr_array[] = {0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc};
74
75 Address bdaddr;
76 size_t expected_result = Address::kLength;
77 ASSERT_EQ(expected_result, bdaddr.FromOctets(test_addr_array));
78
79 ASSERT_EQ(0x12, bdaddr.address[0]);
80 ASSERT_EQ(0x34, bdaddr.address[1]);
81 ASSERT_EQ(0x56, bdaddr.address[2]);
82 ASSERT_EQ(0x78, bdaddr.address[3]);
83 ASSERT_EQ(0x9A, bdaddr.address[4]);
84 ASSERT_EQ(0xBC, bdaddr.address[5]);
85
86 std::string ret = bdaddr.ToString();
87
88 ASSERT_STREQ(test_addr, ret.c_str());
89 }
90
TEST(AddressTest,test_equals)91 TEST(AddressTest, test_equals) {
92 Address bdaddr1;
93 Address bdaddr2;
94 Address bdaddr3;
95 Address::FromString(test_addr, bdaddr1);
96 Address::FromString(test_addr, bdaddr2);
97 ASSERT_TRUE(bdaddr1 == bdaddr2);
98 ASSERT_FALSE(bdaddr1 != bdaddr2);
99 ASSERT_TRUE(bdaddr1 == bdaddr1);
100 ASSERT_FALSE(bdaddr1 != bdaddr1);
101
102 Address::FromString(test_addr2, bdaddr3);
103 ASSERT_FALSE(bdaddr2 == bdaddr3);
104 ASSERT_TRUE(bdaddr2 != bdaddr3);
105 }
106
TEST(AddressTest,test_less_than)107 TEST(AddressTest, test_less_than) {
108 Address bdaddr1;
109 Address bdaddr2;
110 Address bdaddr3;
111 Address::FromString(test_addr, bdaddr1);
112 Address::FromString(test_addr, bdaddr2);
113 ASSERT_FALSE(bdaddr1 < bdaddr2);
114 ASSERT_FALSE(bdaddr1 < bdaddr1);
115
116 Address::FromString(test_addr2, bdaddr3);
117 ASSERT_TRUE(bdaddr2 < bdaddr3);
118 ASSERT_FALSE(bdaddr3 < bdaddr2);
119 }
120
TEST(AddressTest,test_more_than)121 TEST(AddressTest, test_more_than) {
122 Address bdaddr1;
123 Address bdaddr2;
124 Address bdaddr3;
125 Address::FromString(test_addr, bdaddr1);
126 Address::FromString(test_addr, bdaddr2);
127 ASSERT_FALSE(bdaddr1 > bdaddr2);
128 ASSERT_FALSE(bdaddr1 > bdaddr1);
129
130 Address::FromString(test_addr2, bdaddr3);
131 ASSERT_FALSE(bdaddr2 > bdaddr3);
132 ASSERT_TRUE(bdaddr3 > bdaddr2);
133 }
134
TEST(AddressTest,test_less_than_or_equal)135 TEST(AddressTest, test_less_than_or_equal) {
136 Address bdaddr1;
137 Address bdaddr2;
138 Address bdaddr3;
139 Address::FromString(test_addr, bdaddr1);
140 Address::FromString(test_addr, bdaddr2);
141 ASSERT_TRUE(bdaddr1 <= bdaddr2);
142 ASSERT_TRUE(bdaddr1 <= bdaddr1);
143
144 Address::FromString(test_addr2, bdaddr3);
145 ASSERT_TRUE(bdaddr2 <= bdaddr3);
146 ASSERT_FALSE(bdaddr3 <= bdaddr2);
147 }
148
TEST(AddressTest,test_more_than_or_equal)149 TEST(AddressTest, test_more_than_or_equal) {
150 Address bdaddr1;
151 Address bdaddr2;
152 Address bdaddr3;
153 Address::FromString(test_addr, bdaddr1);
154 Address::FromString(test_addr, bdaddr2);
155 ASSERT_TRUE(bdaddr1 >= bdaddr2);
156 ASSERT_TRUE(bdaddr1 >= bdaddr1);
157
158 Address::FromString(test_addr2, bdaddr3);
159 ASSERT_FALSE(bdaddr2 >= bdaddr3);
160 ASSERT_TRUE(bdaddr3 >= bdaddr2);
161 }
162
TEST(AddressTest,test_copy)163 TEST(AddressTest, test_copy) {
164 Address bdaddr1;
165 Address bdaddr2;
166 Address::FromString(test_addr, bdaddr1);
167 bdaddr2 = bdaddr1;
168
169 ASSERT_TRUE(bdaddr1 == bdaddr2);
170 }
171
TEST(AddressTest,IsValidAddress)172 TEST(AddressTest, IsValidAddress) {
173 ASSERT_FALSE(Address::IsValidAddress(""));
174 ASSERT_FALSE(Address::IsValidAddress("000000000000"));
175 ASSERT_FALSE(Address::IsValidAddress("00:00:00:00:0000"));
176 ASSERT_FALSE(Address::IsValidAddress("00:00:00:00:00:0"));
177 ASSERT_FALSE(Address::IsValidAddress("00:00:00:00:00:0;"));
178 ASSERT_TRUE(Address::IsValidAddress("00:00:00:00:00:00"));
179 ASSERT_TRUE(Address::IsValidAddress("AB:cd:00:00:00:00"));
180 ASSERT_FALSE(Address::IsValidAddress("aB:cD:eF:Gh:iJ:Kl"));
181 }
182
TEST(AddressTest,BdAddrFromString)183 TEST(AddressTest, BdAddrFromString) {
184 Address addr = {};
185
186 ASSERT_TRUE(Address::FromString("00:00:00:00:00:00", addr));
187 const Address result0 = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}};
188 ASSERT_EQ(0, memcmp(addr.data(), result0.data(), Address::kLength));
189
190 ASSERT_TRUE(Address::FromString("ab:01:4C:d5:21:9f", addr));
191 const Address result1 = {{0x9f, 0x21, 0xd5, 0x4c, 0x01, 0xab}};
192 ASSERT_EQ("ab:01:4c:d5:21:9f", addr.ToString());
193 ASSERT_EQ("ab:01:4c:d5:21:9f", result1.ToString());
194 ASSERT_THAT(addr.address, testing::ElementsAre(0x9f, 0x21, 0xd5, 0x4c, 0x01, 0xab));
195 ASSERT_EQ(0, memcmp(addr.data(), result1.data(), Address::kLength));
196 }
197
TEST(AddressTest,BdAddrFromStringToStringEquivalent)198 TEST(AddressTest, BdAddrFromStringToStringEquivalent) {
199 std::string address = "c1:c2:c3:d1:d2:d3";
200 Address addr;
201
202 ASSERT_TRUE(Address::FromString(address, addr));
203 ASSERT_EQ(addr.ToString(), address);
204 }
205
TEST(AddressTest,BdAddrSameValueSameOrder)206 TEST(AddressTest, BdAddrSameValueSameOrder) {
207 Address addr1{{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}};
208 Address addr2{{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}};
209 // Test if two addresses with same byte value have the same hash
210 struct std::hash<bluetooth::hci::Address> hasher;
211 ASSERT_EQ(hasher(addr1), hasher(addr2));
212 // Test if two addresses with the same hash and the same value, they will
213 // still map to the same value
214 std::unordered_map<Address, int> data = {};
215 data[addr1] = 5;
216 data[addr2] = 8;
217 ASSERT_EQ(data[addr1], data[addr2]);
218 }
219
TEST(AddressTest,BdAddrHashDifferentForDifferentAddressesZeroAddr)220 TEST(AddressTest, BdAddrHashDifferentForDifferentAddressesZeroAddr) {
221 Address addr1{{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}};
222 struct std::hash<Address> hasher;
223 ASSERT_NE(hasher(addr1), hasher(Address::kEmpty));
224 }
225
TEST(AddressTest,BdAddrHashDifferentForDifferentAddressesFullAddr)226 TEST(AddressTest, BdAddrHashDifferentForDifferentAddressesFullAddr) {
227 Address addr1{{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}};
228 struct std::hash<Address> hasher;
229 ASSERT_NE(hasher(addr1), hasher(Address::kAny));
230 }
231
TEST(AddressTest,BdAddrHashDifferentForDifferentAddressesZeroAndFullAddr)232 TEST(AddressTest, BdAddrHashDifferentForDifferentAddressesZeroAndFullAddr) {
233 struct std::hash<Address> hasher;
234 ASSERT_NE(hasher(Address::kEmpty), hasher(Address::kAny));
235 }
236