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