1 // Copyright 2023 The Pigweed Authors
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
4 // use this file except in compliance with the License. You may obtain a copy of
5 // the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
11 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12 // License for the specific language governing permissions and limitations under
13 // the License.
14
15 #include "pw_bluetooth_sapphire/internal/host/common/device_address.h"
16
17 #include <map>
18 #include <unordered_map>
19
20 #include "pw_unit_test/framework.h"
21
22 namespace bt {
23 namespace {
24
25 // Initialize from bytes.
26 const DeviceAddress kClassic(DeviceAddress::Type::kBREDR,
27 {0x55, 0x44, 0x33, 0x22, 0x11, 0x41});
28 const DeviceAddress kPublic(DeviceAddress::Type::kLEPublic,
29 {0x42, 0x11, 0x22, 0x33, 0x44, 0x55});
30 const DeviceAddress kNonResolvable(DeviceAddress::Type::kLERandom,
31 {0x55, 0x44, 0x33, 0x22, 0x11, 0x00});
32 const DeviceAddress kResolvable(DeviceAddress::Type::kLERandom,
33 {0x55, 0x44, 0x33, 0x22, 0x11, 0x43});
34 const DeviceAddress kStatic(DeviceAddress::Type::kLERandom,
35 {0x55, 0x44, 0x33, 0x22, 0x11, 0xC3});
36
37 struct TestPayload {
38 uint8_t arg0;
39 DeviceAddressBytes bdaddr;
40 } __attribute__((packed));
41
TEST(DeviceAddressBytesTest,ToString)42 TEST(DeviceAddressBytesTest, ToString) {
43 DeviceAddressBytes bdaddr({1, 15, 2, 255, 127, 3});
44 EXPECT_EQ("03:7F:FF:02:0F:01", bdaddr.ToString());
45
46 bdaddr = DeviceAddressBytes();
47 EXPECT_EQ("00:00:00:00:00:00", bdaddr.ToString());
48 }
49
TEST(DeviceAddressBytesTest,CastFromBytes)50 TEST(DeviceAddressBytesTest, CastFromBytes) {
51 std::array<uint8_t, 7> bytes{{10, 1, 15, 2, 255, 127, 3}};
52 EXPECT_EQ(bytes.size(), sizeof(TestPayload));
53
54 auto* bdaddr = reinterpret_cast<DeviceAddressBytes*>(bytes.data());
55 EXPECT_EQ("7F:FF:02:0F:01:0A", bdaddr->ToString());
56
57 auto* test_payload = reinterpret_cast<TestPayload*>(bytes.data());
58 EXPECT_EQ(10, test_payload->arg0);
59 EXPECT_EQ("03:7F:FF:02:0F:01", test_payload->bdaddr.ToString());
60 }
61
TEST(DeviceAddressBytesTest,FromView)62 TEST(DeviceAddressBytesTest, FromView) {
63 std::array<uint8_t, 6> buffer = {0xfe, 0xff, 0xff, 0xff, 0xff, 0xAA};
64 auto bdaddr_view = pw::bluetooth::emboss::MakeBdAddrView(&buffer);
65 DeviceAddressBytes addr(bdaddr_view);
66 EXPECT_EQ("AA:FF:FF:FF:FF:FE", addr.ToString());
67 }
68
TEST(DeviceAddressBytesTest,ToView)69 TEST(DeviceAddressBytesTest, ToView) {
70 DeviceAddressBytes addr = DeviceAddressBytes({0, 0, 0, 0, 0, 0});
71 EXPECT_EQ(addr.view().bd_addr().Read(), 0u);
72
73 addr = DeviceAddressBytes({0xfe, 0xff, 0xff, 0xff, 0xff, 0xff});
74 EXPECT_EQ(addr.view().bd_addr().Read(), 0xfffffffffffelu);
75 }
76
TEST(DeviceAddressBytesTest,Comparison)77 TEST(DeviceAddressBytesTest, Comparison) {
78 DeviceAddressBytes bdaddr0, bdaddr1;
79 EXPECT_EQ(bdaddr0, bdaddr1);
80
81 bdaddr0 = DeviceAddressBytes({1, 2, 3, 4, 5, 6});
82 EXPECT_NE(bdaddr0, bdaddr1);
83
84 bdaddr1 = bdaddr0;
85 EXPECT_EQ(bdaddr0, bdaddr1);
86 }
87
TEST(DeviceAddressTest,Comparison)88 TEST(DeviceAddressTest, Comparison) {
89 DeviceAddress addr0, addr1;
90 EXPECT_EQ(addr0, addr1);
91
92 addr0 = DeviceAddress(DeviceAddress::Type::kBREDR, {1, 2, 3, 4, 5, 6});
93 EXPECT_NE(addr0, addr1);
94
95 addr1 = DeviceAddress(DeviceAddress::Type::kLEPublic, addr0.value());
96 EXPECT_EQ(addr0, addr1);
97
98 addr0 = DeviceAddress(DeviceAddress::Type::kLERandom, addr0.value());
99 EXPECT_NE(addr0, addr1);
100 }
101
TEST(DeviceAddressTest,Map)102 TEST(DeviceAddressTest, Map) {
103 std::map<DeviceAddress, int> map;
104
105 DeviceAddress address1;
106 DeviceAddress address2(address1);
107 DeviceAddress address3(DeviceAddress::Type::kLEPublic, address1.value());
108 DeviceAddress address4(DeviceAddress::Type::kLEPublic, {1});
109
110 map[address1] = 1;
111
112 auto iter = map.find(address1);
113 EXPECT_NE(map.end(), iter);
114 EXPECT_EQ(1, iter->second);
115
116 iter = map.find(address2);
117 EXPECT_NE(map.end(), iter);
118 EXPECT_EQ(1, iter->second);
119
120 iter = map.find(address3);
121 EXPECT_NE(map.end(), iter);
122 EXPECT_EQ(1, iter->second);
123
124 iter = map.find(address4);
125 EXPECT_EQ(map.end(), iter);
126
127 map[address3] = 2;
128 map[address4] = 3;
129
130 EXPECT_EQ(2u, map.size());
131 EXPECT_EQ(2, map[address1]);
132 EXPECT_EQ(2, map[address2]);
133 EXPECT_EQ(2, map[address3]);
134 EXPECT_EQ(3, map[address4]);
135 }
136
TEST(DeviceAddressTest,UnorderedMap)137 TEST(DeviceAddressTest, UnorderedMap) {
138 std::unordered_map<DeviceAddress, int> map;
139
140 DeviceAddress address1;
141 DeviceAddress address2(address1);
142 DeviceAddress address3(DeviceAddress::Type::kLEPublic, address1.value());
143 DeviceAddress address4(DeviceAddress::Type::kLEPublic, {1});
144
145 map[address1] = 1;
146
147 auto iter = map.find(address1);
148 EXPECT_NE(map.end(), iter);
149 EXPECT_EQ(1, iter->second);
150
151 iter = map.find(address2);
152 EXPECT_NE(map.end(), iter);
153 EXPECT_EQ(1, iter->second);
154
155 iter = map.find(address3);
156 EXPECT_NE(map.end(), iter);
157 EXPECT_EQ(1, iter->second);
158
159 iter = map.find(address4);
160 EXPECT_EQ(map.end(), iter);
161
162 map[address3] = 2;
163 map[address4] = 3;
164
165 EXPECT_EQ(2u, map.size());
166 EXPECT_EQ(2, map[address1]);
167 EXPECT_EQ(2, map[address2]);
168 EXPECT_EQ(2, map[address3]);
169 EXPECT_EQ(3, map[address4]);
170 }
171
TEST(DeviceAddressTest,IsResolvablePrivate)172 TEST(DeviceAddressTest, IsResolvablePrivate) {
173 EXPECT_FALSE(kClassic.IsResolvablePrivate());
174 EXPECT_FALSE(kPublic.IsResolvablePrivate());
175 EXPECT_FALSE(kNonResolvable.IsResolvablePrivate());
176 EXPECT_TRUE(kResolvable.IsResolvablePrivate());
177 EXPECT_FALSE(kStatic.IsResolvablePrivate());
178 }
179
TEST(DeviceAddressTest,IsNonResolvablePrivate)180 TEST(DeviceAddressTest, IsNonResolvablePrivate) {
181 EXPECT_FALSE(kClassic.IsNonResolvablePrivate());
182 EXPECT_FALSE(kPublic.IsNonResolvablePrivate());
183 EXPECT_TRUE(kNonResolvable.IsNonResolvablePrivate());
184 EXPECT_FALSE(kResolvable.IsNonResolvablePrivate());
185 EXPECT_FALSE(kStatic.IsNonResolvablePrivate());
186 }
187
TEST(DeviceAddressTest,IsStatic)188 TEST(DeviceAddressTest, IsStatic) {
189 EXPECT_FALSE(kClassic.IsStaticRandom());
190 EXPECT_FALSE(kPublic.IsStaticRandom());
191 EXPECT_FALSE(kNonResolvable.IsStaticRandom());
192 EXPECT_FALSE(kResolvable.IsStaticRandom());
193 EXPECT_TRUE(kStatic.IsStaticRandom());
194 }
195
TEST(DeviceAddressTest,IsPublic)196 TEST(DeviceAddressTest, IsPublic) {
197 EXPECT_TRUE(kClassic.IsPublic());
198 EXPECT_TRUE(kPublic.IsPublic());
199 EXPECT_FALSE(kNonResolvable.IsPublic());
200 EXPECT_FALSE(kResolvable.IsPublic());
201 EXPECT_FALSE(kStatic.IsPublic());
202 }
203
204 } // namespace
205 } // namespace bt
206