1 /******************************************************************************
2 *
3 * Copyright (C) 2014 Google, Inc.
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 <arpa/inet.h>
20 #include <gtest/gtest.h>
21 #include "osi/test/AllocationTestHarness.h"
22
23 #include "btcore/include/property.h"
24
25 class PropertyTest : public AllocationTestHarness {};
26
TEST_F(PropertyTest,addr)27 TEST_F(PropertyTest, addr) {
28 bt_bdaddr_t addr0 = {{0x1, 0x2, 0x3, 0x4, 0x5, 0x6}};
29 bt_property_t* property = property_new_addr(&addr0);
30
31 EXPECT_EQ(addr0.address[0], ((uint8_t*)property->val)[0]);
32 EXPECT_EQ(addr0.address[1], ((uint8_t*)property->val)[1]);
33 EXPECT_EQ(addr0.address[2], ((uint8_t*)property->val)[2]);
34 EXPECT_EQ(addr0.address[3], ((uint8_t*)property->val)[3]);
35 EXPECT_EQ(addr0.address[4], ((uint8_t*)property->val)[4]);
36 EXPECT_EQ(addr0.address[5], ((uint8_t*)property->val)[5]);
37 EXPECT_EQ(BT_PROPERTY_BDADDR, property->type);
38 EXPECT_EQ((int)sizeof(bt_bdaddr_t), property->len);
39
40 const bt_bdaddr_t* addr1 = property_as_addr(property);
41 EXPECT_EQ(addr0.address[0], addr1->address[0]);
42
43 property_free(property);
44 }
45
TEST_F(PropertyTest,device_class)46 TEST_F(PropertyTest, device_class) {
47 bt_device_class_t dc0 = {{0x01, 0x23, 0x45}};
48 bt_property_t* property = property_new_device_class(&dc0);
49
50 EXPECT_EQ(dc0._[0], ((uint8_t*)property->val)[0]);
51 EXPECT_EQ(dc0._[1], ((uint8_t*)property->val)[1]);
52 EXPECT_EQ(dc0._[2], ((uint8_t*)property->val)[2]);
53 EXPECT_EQ(BT_PROPERTY_CLASS_OF_DEVICE, property->type);
54 EXPECT_EQ((int)sizeof(bt_device_class_t), property->len);
55
56 const bt_device_class_t* dc1 = property_as_device_class(property);
57 int dc_int = device_class_to_int(dc1);
58 EXPECT_EQ(0x452301, dc_int);
59
60 property_free(property);
61 }
62
TEST_F(PropertyTest,device_type)63 TEST_F(PropertyTest, device_type) {
64 bt_device_type_t dt0 = (bt_device_type_t)1;
65 bt_property_t* property = property_new_device_type(dt0);
66
67 EXPECT_EQ((int)dt0, *(int*)property->val);
68 EXPECT_EQ(BT_PROPERTY_TYPE_OF_DEVICE, property->type);
69 EXPECT_EQ((int)sizeof(bt_device_type_t), property->len);
70
71 bt_device_type_t dt1 = property_as_device_type(property);
72 EXPECT_EQ(1, (int)dt1);
73
74 property_free(property);
75 }
76
TEST_F(PropertyTest,discovery_timeout)77 TEST_F(PropertyTest, discovery_timeout) {
78 uint32_t timeout0 = 12345;
79 bt_property_t* property = property_new_discovery_timeout(timeout0);
80
81 EXPECT_EQ(timeout0, *(uint32_t*)property->val);
82 EXPECT_EQ(BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT, property->type);
83 EXPECT_EQ((int)sizeof(uint32_t), property->len);
84
85 uint32_t timeout1 = property_as_discovery_timeout(property);
86 EXPECT_EQ(timeout0, timeout1);
87
88 property_free(property);
89 }
90
TEST_F(PropertyTest,name)91 TEST_F(PropertyTest, name) {
92 const char* name0 = "My btcore name";
93 bt_property_t* property = property_new_name(name0);
94
95 EXPECT_EQ(0, strcmp((char*)name0, (char*)property->val));
96 EXPECT_EQ(BT_PROPERTY_BDNAME, property->type);
97 EXPECT_EQ((int)sizeof(bt_bdname_t), property->len);
98
99 const bt_bdname_t* name1 = property_as_name(property);
100 EXPECT_EQ(0, strcmp((char*)name0, (char*)name1->name));
101
102 property_free(property);
103 }
104
TEST_F(PropertyTest,rssi)105 TEST_F(PropertyTest, rssi) {
106 int8_t rssi0 = -56;
107 bt_property_t* property = property_new_rssi(rssi0);
108
109 EXPECT_EQ(*(int8_t*)property->val, rssi0);
110 EXPECT_EQ(BT_PROPERTY_REMOTE_RSSI, property->type);
111 EXPECT_EQ((int)sizeof(int8_t), property->len);
112
113 int8_t rss1 = property_as_rssi(property);
114 EXPECT_EQ(rssi0, rss1);
115
116 property_free(property);
117 }
118
TEST_F(PropertyTest,scan_mode)119 TEST_F(PropertyTest, scan_mode) {
120 bt_scan_mode_t mode0 = (bt_scan_mode_t)3;
121 bt_property_t* property = property_new_scan_mode(mode0);
122
123 EXPECT_EQ(*(int*)property->val, mode0);
124 EXPECT_EQ(BT_PROPERTY_ADAPTER_SCAN_MODE, property->type);
125 EXPECT_EQ((int)sizeof(int), property->len);
126
127 bt_scan_mode_t mode1 = property_as_scan_mode(property);
128 EXPECT_EQ((int)mode0, (int)mode1);
129
130 property_free(property);
131 }
132
TEST_F(PropertyTest,uuids)133 TEST_F(PropertyTest, uuids) {
134 bt_uuid_t uuid0 = {{
135 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
136 0xcc, 0xdd, 0xee, 0xff,
137 }};
138 bt_property_t* property = property_new_uuids(&uuid0, 1);
139
140 EXPECT_EQ(0, strcmp((const char*)uuid0.uu, (char*)property->val));
141 EXPECT_EQ(BT_PROPERTY_UUIDS, property->type);
142 EXPECT_EQ((int)sizeof(bt_uuid_t), property->len);
143
144 size_t uuid_cnt1;
145 const bt_uuid_t* uuid1 = property_as_uuids(property, &uuid_cnt1);
146 EXPECT_EQ(0, memcmp(uuid1->uu, uuid1->uu, sizeof(bt_uuid_t)));
147
148 property_free(property);
149 }
150
TEST_F(PropertyTest,copy)151 TEST_F(PropertyTest, copy) {
152 {
153 bt_uuid_t uuids[] = {
154 {{
155 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa,
156 0xbb, 0xcc, 0xdd, 0xee, 0xff,
157 }},
158 {{
159 0xf0, 0xe1, 0xd2, 0xc3, 0xf4, 0xe5, 0xd6, 0xc7, 0xf8, 0xe9, 0xda,
160 0xcb, 0xfc, 0xed, 0xde, 0xcf,
161 }},
162 };
163
164 bt_property_t* property0 =
165 property_new_uuids(uuids, sizeof(bt_uuid_t) / sizeof(uuids));
166
167 bt_property_t property1;
168 property_copy(&property1, property0);
169 EXPECT_TRUE(property_equals(property0, &property1));
170
171 property_free(property0);
172 }
173 }
174
TEST_F(PropertyTest,equals)175 TEST_F(PropertyTest, equals) {
176 {
177 bt_bdaddr_t addr0 = {{0x1, 0x2, 0x3, 0x4, 0x5, 0x6}};
178 bt_property_t* property0 = property_new_addr(&addr0);
179
180 bt_device_class_t dc0 = {{0x01, 0x23, 0x45}};
181 bt_property_t* property1 = property_new_device_class(&dc0);
182
183 EXPECT_FALSE(property_equals(property0, property1));
184
185 property_free(property0);
186 property_free(property1);
187 }
188
189 {
190 bt_bdaddr_t addr = {{0x1, 0x2, 0x3, 0x4, 0x5, 0x6}};
191 bt_property_t* property0 = property_new_addr(&addr);
192 bt_property_t* property1 = property_new_addr(&addr);
193
194 EXPECT_TRUE(property_equals(property0, property1));
195
196 property_free(property0);
197 property_free(property1);
198 }
199
200 {
201 bt_bdaddr_t addr0 = {{0x1, 0x2, 0x3, 0x4, 0x5, 0x6}};
202 bt_property_t* property0 = property_new_addr(&addr0);
203
204 bt_bdaddr_t addr1 = {{0x1, 0x2, 0x3, 0x4, 0x5, 0xff}};
205 bt_property_t* property1 = property_new_addr(&addr1);
206
207 EXPECT_FALSE(property_equals(property0, property1));
208
209 property_free(property0);
210 property_free(property1);
211 }
212
213 {
214 const char* name0 = "My btcore name";
215 bt_property_t* property0 = property_new_name(name0);
216
217 const char* name1 = "My btcore name";
218 bt_property_t* property1 = property_new_name(name1);
219
220 EXPECT_TRUE(property_equals(property0, property1));
221
222 property_free(property0);
223 property_free(property1);
224 }
225
226 {
227 const char* name0 = "My btcore name";
228 bt_property_t* property0 = property_new_name(name0);
229
230 const char* name1 = "My btcore name ";
231 bt_property_t* property1 = property_new_name(name1);
232
233 EXPECT_FALSE(property_equals(property0, property1));
234
235 property_free(property0);
236 property_free(property1);
237 }
238 }
239