| // Copyright 2018 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "chromecast/device/bluetooth/le/le_scan_result.h" |
| |
| #include "base/stl_util.h" |
| #include "chromecast/device/bluetooth/bluetooth_util.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace chromecast { |
| namespace bluetooth { |
| |
| TEST(LeScanResultTest, SetAdvData) { |
| static const uint8_t kBadData[] = {0x3, 0x2}; |
| |
| LeScanResult scan_result; |
| |
| // Setting invalid data should not change the object. |
| EXPECT_FALSE(scan_result.SetAdvData({kBadData})); |
| EXPECT_TRUE(scan_result.adv_data.empty()); |
| EXPECT_TRUE(scan_result.type_to_data.empty()); |
| |
| const std::vector<uint8_t> kFlags = {0x47}; |
| const std::vector<uint8_t> kName = {0x41, 0x42, 0x43}; |
| const std::vector<uint8_t> kService = {0x12, 0x34}; |
| |
| std::vector<uint8_t> adv_data; |
| adv_data.push_back(kFlags.size() + 1); |
| adv_data.push_back(LeScanResult::kGapFlags); |
| adv_data.insert(adv_data.end(), kFlags.begin(), kFlags.end()); |
| adv_data.push_back(kName.size() + 1); |
| adv_data.push_back(LeScanResult::kGapCompleteName); |
| adv_data.insert(adv_data.end(), kName.begin(), kName.end()); |
| adv_data.push_back(kService.size() + 1); |
| adv_data.push_back(LeScanResult::kGapComplete16BitServiceUuids); |
| adv_data.insert(adv_data.end(), kService.begin(), kService.end()); |
| |
| EXPECT_TRUE(scan_result.SetAdvData(adv_data)); |
| EXPECT_EQ(adv_data, scan_result.adv_data); |
| ASSERT_EQ(1ul, scan_result.type_to_data[LeScanResult::kGapFlags].size()); |
| EXPECT_EQ(kFlags, scan_result.type_to_data[LeScanResult::kGapFlags][0]); |
| ASSERT_EQ(1ul, |
| scan_result.type_to_data[LeScanResult::kGapCompleteName].size()); |
| EXPECT_EQ(kName, scan_result.type_to_data[LeScanResult::kGapCompleteName][0]); |
| ASSERT_EQ( |
| 1ul, scan_result.type_to_data[LeScanResult::kGapComplete16BitServiceUuids] |
| .size()); |
| EXPECT_EQ( |
| kService, |
| scan_result.type_to_data[LeScanResult::kGapComplete16BitServiceUuids][0]); |
| } |
| |
| TEST(LeScanResultTest, Name) { |
| LeScanResult scan_result; |
| EXPECT_FALSE(scan_result.Name()); |
| |
| static const char kName1[] = "foo"; |
| static const char kName2[] = "foobar"; |
| |
| scan_result.type_to_data[LeScanResult::kGapShortName].push_back( |
| std::vector<uint8_t>( |
| reinterpret_cast<const uint8_t*>(kName1), |
| reinterpret_cast<const uint8_t*>(kName1) + strlen(kName1))); |
| base::Optional<std::string> name = scan_result.Name(); |
| ASSERT_TRUE(name); |
| EXPECT_EQ(kName1, *name); |
| |
| scan_result.type_to_data[LeScanResult::kGapCompleteName].push_back( |
| std::vector<uint8_t>( |
| reinterpret_cast<const uint8_t*>(kName2), |
| reinterpret_cast<const uint8_t*>(kName2) + strlen(kName2))); |
| |
| name = scan_result.Name(); |
| ASSERT_TRUE(name); |
| EXPECT_EQ(kName2, *name); |
| } |
| |
| TEST(LeScanResultTest, Flags) { |
| static const uint8_t kFlags = 0x42; |
| |
| LeScanResult scan_result; |
| EXPECT_FALSE(scan_result.Flags()); |
| scan_result.type_to_data[LeScanResult::kGapFlags].push_back({kFlags}); |
| auto flags = scan_result.Flags(); |
| ASSERT_TRUE(flags); |
| EXPECT_EQ(kFlags, *flags); |
| } |
| |
| TEST(LeScanResultTest, AllUuids) { |
| static const uint16_t kIncompleteUuid16 = 0x1234; |
| const std::vector<uint8_t> kIncompleteUuid16Bytes = {0x34, 0x12}; |
| static const uint16_t kCompleteUuid16 = 0x5678; |
| const std::vector<uint8_t> kCompleteUuid16Bytes = {0x78, 0x56}; |
| static const uint32_t kIncompleteUuid32 = 0x12345678; |
| const std::vector<uint8_t> kIncompleteUuid32Bytes = {0x78, 0x56, 0x34, 0x12}; |
| static const uint32_t kCompleteUuid32 = 0xabcdef01; |
| const std::vector<uint8_t> kCompleteUuid32Bytes = {0x1, 0xef, 0xcd, 0xab}; |
| static const bluetooth_v2_shlib::Uuid kIncompleteUuid128 = { |
| {0x12, 0x3e, 0x45, 0x67, 0xe8, 0x9b, 0x12, 0xd3, 0xa4, 0x56, 0x42, 0x66, |
| 0x55, 0x44, 0x00, 0x00}}; |
| static const bluetooth_v2_shlib::Uuid kCompleteUuid128 = { |
| {0xa8, 0x22, 0xc8, 0x85, 0xaf, 0x02, 0xc7, 0x80, 0x9d, 0x4d, 0xbd, 0x9a, |
| 0x1f, 0xa0, 0x6d, 0x93}}; |
| LeScanResult scan_result; |
| scan_result.type_to_data[LeScanResult::kGapIncomplete16BitServiceUuids] |
| .push_back(kIncompleteUuid16Bytes); |
| scan_result.type_to_data[LeScanResult::kGapComplete16BitServiceUuids] |
| .push_back(kCompleteUuid16Bytes); |
| scan_result.type_to_data[LeScanResult::kGapIncomplete32BitServiceUuids] |
| .push_back(kIncompleteUuid32Bytes); |
| scan_result.type_to_data[LeScanResult::kGapComplete32BitServiceUuids] |
| .push_back(kCompleteUuid32Bytes); |
| scan_result.type_to_data[LeScanResult::kGapIncomplete128BitServiceUuids] |
| .emplace_back(kIncompleteUuid128.rbegin(), kIncompleteUuid128.rend()); |
| scan_result.type_to_data[LeScanResult::kGapComplete128BitServiceUuids] |
| .emplace_back(kCompleteUuid128.rbegin(), kCompleteUuid128.rend()); |
| |
| auto all_uuids = scan_result.AllServiceUuids(); |
| ASSERT_TRUE(all_uuids); |
| ASSERT_EQ(6ul, all_uuids->size()); |
| |
| auto exists = [&all_uuids](const bluetooth_v2_shlib::Uuid& uuid) { |
| return base::ContainsValue(*all_uuids, uuid); |
| }; |
| |
| EXPECT_TRUE(exists(util::UuidFromInt16(kIncompleteUuid16))); |
| EXPECT_TRUE(exists(util::UuidFromInt16(kCompleteUuid16))); |
| EXPECT_TRUE(exists(util::UuidFromInt32(kIncompleteUuid32))); |
| EXPECT_TRUE(exists(util::UuidFromInt32(kCompleteUuid32))); |
| EXPECT_TRUE(exists(kIncompleteUuid128)); |
| EXPECT_TRUE(exists(kCompleteUuid128)); |
| } |
| |
| TEST(LeScanResultTest, IncompleteListOf16BitServiceUuid) { |
| static const uint16_t kUuid1 = 0x1234; |
| const std::vector<uint8_t> kUuid1Bytes = {0x34, 0x12}; |
| |
| static const uint16_t kUuid2 = 0x5678; |
| const std::vector<uint8_t> kUuid2Bytes = {0x78, 0x56}; |
| |
| LeScanResult scan_result; |
| scan_result.type_to_data[LeScanResult::kGapIncomplete16BitServiceUuids] |
| .push_back(kUuid1Bytes); |
| scan_result.type_to_data[LeScanResult::kGapIncomplete16BitServiceUuids] |
| .push_back(kUuid2Bytes); |
| |
| auto uuids = scan_result.IncompleteListOf16BitServiceUuids(); |
| ASSERT_TRUE(uuids); |
| ASSERT_EQ(2ul, uuids->size()); |
| EXPECT_EQ(util::UuidFromInt16(kUuid1), (*uuids)[0]); |
| EXPECT_EQ(util::UuidFromInt16(kUuid2), (*uuids)[1]); |
| } |
| |
| TEST(LeScanResultTest, CompleteListOf16BitServiceUuid) { |
| static const uint16_t kUuid1 = 0x1234; |
| const std::vector<uint8_t> kUuid1Bytes = {0x34, 0x12}; |
| |
| static const uint16_t kUuid2 = 0x5678; |
| const std::vector<uint8_t> kUuid2Bytes = {0x78, 0x56}; |
| |
| LeScanResult scan_result; |
| scan_result.type_to_data[LeScanResult::kGapComplete16BitServiceUuids] |
| .push_back(kUuid1Bytes); |
| scan_result.type_to_data[LeScanResult::kGapComplete16BitServiceUuids] |
| .push_back(kUuid2Bytes); |
| |
| auto uuids = scan_result.CompleteListOf16BitServiceUuids(); |
| ASSERT_TRUE(uuids); |
| ASSERT_EQ(2ul, uuids->size()); |
| EXPECT_EQ(util::UuidFromInt16(kUuid1), (*uuids)[0]); |
| EXPECT_EQ(util::UuidFromInt16(kUuid2), (*uuids)[1]); |
| } |
| |
| TEST(LeScanResultTest, IncompleteListOf32BitServiceUuid) { |
| static const uint32_t kUuid1 = 0x12345678; |
| const std::vector<uint8_t> kUuid1Bytes = {0x78, 0x56, 0x34, 0x12}; |
| |
| static const uint32_t kUuid2 = 0xabcdef01; |
| const std::vector<uint8_t> kUuid2Bytes = {0x1, 0xef, 0xcd, 0xab}; |
| |
| LeScanResult scan_result; |
| scan_result.type_to_data[LeScanResult::kGapIncomplete32BitServiceUuids] |
| .push_back(kUuid1Bytes); |
| scan_result.type_to_data[LeScanResult::kGapIncomplete32BitServiceUuids] |
| .push_back(kUuid2Bytes); |
| |
| auto uuids = scan_result.IncompleteListOf32BitServiceUuids(); |
| ASSERT_TRUE(uuids); |
| ASSERT_EQ(2ul, uuids->size()); |
| EXPECT_EQ(util::UuidFromInt32(kUuid1), (*uuids)[0]); |
| EXPECT_EQ(util::UuidFromInt32(kUuid2), (*uuids)[1]); |
| } |
| |
| TEST(LeScanResultTest, CompleteListOf32BitServiceUuid) { |
| static const uint32_t kUuid1 = 0x12345678; |
| const std::vector<uint8_t> kUuid1Bytes = {0x78, 0x56, 0x34, 0x12}; |
| |
| static const uint32_t kUuid2 = 0xabcdef01; |
| const std::vector<uint8_t> kUuid2Bytes = {0x1, 0xef, 0xcd, 0xab}; |
| |
| LeScanResult scan_result; |
| scan_result.type_to_data[LeScanResult::kGapComplete32BitServiceUuids] |
| .push_back(kUuid1Bytes); |
| scan_result.type_to_data[LeScanResult::kGapComplete32BitServiceUuids] |
| .push_back(kUuid2Bytes); |
| |
| auto uuids = scan_result.CompleteListOf32BitServiceUuids(); |
| ASSERT_TRUE(uuids); |
| ASSERT_EQ(2ul, uuids->size()); |
| EXPECT_EQ(util::UuidFromInt32(kUuid1), (*uuids)[0]); |
| EXPECT_EQ(util::UuidFromInt32(kUuid2), (*uuids)[1]); |
| } |
| |
| TEST(LeScanResultTest, IncompleteListOf128BitServiceUuid) { |
| static const bluetooth_v2_shlib::Uuid kUuid1 = { |
| {0x12, 0x3e, 0x45, 0x67, 0xe8, 0x9b, 0x12, 0xd3, 0xa4, 0x56, 0x42, 0x66, |
| 0x55, 0x44, 0x00, 0x00}}; |
| static const bluetooth_v2_shlib::Uuid kUuid2 = { |
| {0xa8, 0x22, 0xc8, 0x85, 0xaf, 0x02, 0xc7, 0x80, 0x9d, 0x4d, 0xbd, 0x9a, |
| 0x1f, 0xa0, 0x6d, 0x93}}; |
| |
| LeScanResult scan_result; |
| scan_result.type_to_data[LeScanResult::kGapIncomplete128BitServiceUuids] |
| .emplace_back(kUuid1.rbegin(), kUuid1.rend()); |
| scan_result.type_to_data[LeScanResult::kGapIncomplete128BitServiceUuids] |
| .emplace_back(kUuid2.rbegin(), kUuid2.rend()); |
| |
| auto uuids = scan_result.IncompleteListOf128BitServiceUuids(); |
| ASSERT_TRUE(uuids); |
| ASSERT_EQ(2ul, uuids->size()); |
| EXPECT_EQ(kUuid1, (*uuids)[0]); |
| EXPECT_EQ(kUuid2, (*uuids)[1]); |
| } |
| |
| TEST(LeScanResultTest, CompleteListOf128BitServiceUuid) { |
| static const bluetooth_v2_shlib::Uuid kUuid1 = { |
| {0x12, 0x3e, 0x45, 0x67, 0xe8, 0x9b, 0x12, 0xd3, 0xa4, 0x56, 0x42, 0x66, |
| 0x55, 0x44, 0x00, 0x00}}; |
| static const bluetooth_v2_shlib::Uuid kUuid2 = { |
| {0xa8, 0x22, 0xc8, 0x85, 0xaf, 0x02, 0xc7, 0x80, 0x9d, 0x4d, 0xbd, 0x9a, |
| 0x1f, 0xa0, 0x6d, 0x93}}; |
| static const bluetooth_v2_shlib::Uuid kUuid3 = { |
| {0xaa, 0x22, 0xc8, 0x85, 0xaf, 0x02, 0xc7, 0x80, 0x9d, 0x4d, 0xbd, 0x9a, |
| 0x1f, 0xa0, 0x6d, 0x93}}; |
| |
| LeScanResult scan_result; |
| scan_result.type_to_data[LeScanResult::kGapComplete128BitServiceUuids] |
| .emplace_back(kUuid1.rbegin(), kUuid1.rend()); |
| scan_result.type_to_data[LeScanResult::kGapComplete128BitServiceUuids] |
| .emplace_back(kUuid2.rbegin(), kUuid2.rend()); |
| auto& end = |
| scan_result.type_to_data[LeScanResult::kGapComplete128BitServiceUuids] |
| .back(); |
| end.insert(end.end(), kUuid3.rbegin(), kUuid3.rend()); |
| |
| auto uuids = scan_result.CompleteListOf128BitServiceUuids(); |
| ASSERT_TRUE(uuids); |
| ASSERT_EQ(3ul, uuids->size()); |
| EXPECT_EQ(kUuid1, (*uuids)[0]); |
| EXPECT_EQ(kUuid2, (*uuids)[1]); |
| EXPECT_EQ(kUuid3, (*uuids)[2]); |
| } |
| |
| TEST(LeScanResultTest, AllServiceData) { |
| static const uint16_t kUuid16 = 0x1234; |
| const std::vector<uint8_t> kUuid16Bytes = {0x34, 0x12, 0xab, 0xcd, 0xef}; |
| |
| static const uint32_t kUuid32 = 0x12345678; |
| const std::vector<uint8_t> kUuid32Bytes = {0x78, 0x56, 0x34, 0x12, |
| 0xab, 0xcd, 0xef}; |
| |
| static const bluetooth_v2_shlib::Uuid kUuid128 = { |
| {0x12, 0x3e, 0x45, 0x67, 0xe8, 0x9b, 0x12, 0xd3, 0xa4, 0x56, 0x42, 0x66, |
| 0x55, 0x44, 0x00, 0x00}}; |
| const std::vector<uint8_t> kUuid128Data = {0x78, 0x56, 0x34, 0x12, |
| 0xab, 0xcd, 0xef}; |
| std::vector<uint8_t> uuid128_bytes(kUuid128.rbegin(), kUuid128.rend()); |
| uuid128_bytes.insert(uuid128_bytes.end(), kUuid128Data.begin(), |
| kUuid128Data.end()); |
| |
| LeScanResult scan_result; |
| scan_result.type_to_data[LeScanResult::kGapServicesData16bit].push_back( |
| kUuid16Bytes); |
| scan_result.type_to_data[LeScanResult::kGapServicesData32bit].push_back( |
| kUuid32Bytes); |
| scan_result.type_to_data[LeScanResult::kGapServicesData128bit].push_back( |
| uuid128_bytes); |
| |
| auto sd = scan_result.AllServiceData(); |
| EXPECT_EQ(3ul, sd.size()); |
| EXPECT_EQ(sd[util::UuidFromInt16(kUuid16)], |
| std::vector<uint8_t>(kUuid16Bytes.begin() + sizeof(kUuid16), |
| kUuid16Bytes.end())); |
| EXPECT_EQ(sd[util::UuidFromInt32(kUuid32)], |
| std::vector<uint8_t>(kUuid32Bytes.begin() + sizeof(kUuid32), |
| kUuid32Bytes.end())); |
| EXPECT_EQ(sd[kUuid128], kUuid128Data); |
| } |
| |
| TEST(LeScanResultTest, ServiceData16Bit) { |
| static const uint16_t kUuid1 = 0x1234; |
| const std::vector<uint8_t> kUuid1Bytes = {0x34, 0x12, 0xab, 0xcd, 0xef}; |
| |
| static const uint16_t kUuid2 = 0x5678; |
| const std::vector<uint8_t> kUuid2Bytes = {0x78, 0x56, 0xa1, 0x0d, 0xe1}; |
| |
| LeScanResult scan_result; |
| scan_result.type_to_data[LeScanResult::kGapServicesData16bit].push_back( |
| kUuid1Bytes); |
| scan_result.type_to_data[LeScanResult::kGapServicesData16bit].push_back( |
| kUuid2Bytes); |
| |
| auto sd = scan_result.ServiceData16Bit(); |
| ASSERT_EQ(2ul, sd.size()); |
| EXPECT_EQ(sd[util::UuidFromInt16(kUuid1)], |
| std::vector<uint8_t>(kUuid1Bytes.begin() + sizeof(kUuid1), |
| kUuid1Bytes.end())); |
| EXPECT_EQ(sd[util::UuidFromInt16(kUuid2)], |
| std::vector<uint8_t>(kUuid2Bytes.begin() + sizeof(kUuid2), |
| kUuid2Bytes.end())); |
| } |
| |
| TEST(LeScanResultTest, ServiceData32Bit) { |
| static const uint32_t kUuid1 = 0x12345678; |
| const std::vector<uint8_t> kUuid1Bytes = {0x78, 0x56, 0x34, 0x12, |
| 0xab, 0xcd, 0xef}; |
| |
| static const uint32_t kUuid2 = 0xabcdef01; |
| const std::vector<uint8_t> kUuid2Bytes = {0x01, 0xef, 0xcd, 0xab, |
| 0xa1, 0x0d, 0xe1}; |
| |
| LeScanResult scan_result; |
| scan_result.type_to_data[LeScanResult::kGapServicesData32bit].push_back( |
| kUuid1Bytes); |
| scan_result.type_to_data[LeScanResult::kGapServicesData32bit].push_back( |
| kUuid2Bytes); |
| |
| auto sd = scan_result.ServiceData32Bit(); |
| ASSERT_EQ(2ul, sd.size()); |
| EXPECT_EQ(sd[util::UuidFromInt32(kUuid1)], |
| std::vector<uint8_t>(kUuid1Bytes.begin() + sizeof(kUuid1), |
| kUuid1Bytes.end())); |
| EXPECT_EQ(sd[util::UuidFromInt32(kUuid2)], |
| std::vector<uint8_t>(kUuid2Bytes.begin() + sizeof(kUuid2), |
| kUuid2Bytes.end())); |
| } |
| |
| TEST(LeScanResultTest, ServiceData128Bit) { |
| static const bluetooth_v2_shlib::Uuid kUuid1 = { |
| {0x12, 0x3e, 0x45, 0x67, 0xe8, 0x9b, 0x12, 0xd3, 0xa4, 0x56, 0x42, 0x66, |
| 0x55, 0x44, 0x00, 0x00}}; |
| const std::vector<uint8_t> kUuid1Data = {0x78, 0x56, 0x34, 0x12, |
| 0xab, 0xcd, 0xef}; |
| std::vector<uint8_t> uuid1_bytes(kUuid1.rbegin(), kUuid1.rend()); |
| uuid1_bytes.insert(uuid1_bytes.end(), kUuid1Data.begin(), kUuid1Data.end()); |
| |
| static const bluetooth_v2_shlib::Uuid kUuid2 = { |
| {0xa8, 0x22, 0xc8, 0x85, 0xaf, 0x02, 0xc7, 0x80, 0x9d, 0x4d, 0xbd, 0x9a, |
| 0x1f, 0xa0, 0x6d, 0x93}}; |
| const std::vector<uint8_t> kUuid2Data = {0x01, 0xef, 0xcd, 0xab, |
| 0xa1, 0x0d, 0xe1}; |
| std::vector<uint8_t> uuid2_bytes(kUuid2.rbegin(), kUuid2.rend()); |
| uuid2_bytes.insert(uuid2_bytes.end(), kUuid2Data.begin(), kUuid2Data.end()); |
| |
| LeScanResult scan_result; |
| scan_result.type_to_data[LeScanResult::kGapServicesData128bit].push_back( |
| uuid1_bytes); |
| scan_result.type_to_data[LeScanResult::kGapServicesData128bit].push_back( |
| uuid2_bytes); |
| |
| auto sd = scan_result.ServiceData128Bit(); |
| ASSERT_EQ(2ul, sd.size()); |
| EXPECT_EQ(sd[kUuid1], kUuid1Data); |
| EXPECT_EQ(sd[kUuid2], kUuid2Data); |
| } |
| |
| TEST(LeScanResultTest, ManufacturerData) { |
| static const uint16_t kManufacturer1 = 0x1234; |
| const std::vector<uint8_t> kManufacturer1Bytes = {0x34, 0x12, 0xab, 0xcd, |
| 0xef}; |
| |
| static const uint16_t kManufacturer2 = 0x5678; |
| const std::vector<uint8_t> kManufacturer2Bytes = {0x78, 0x56, 0xa1, 0x0d, |
| 0xe1}; |
| |
| LeScanResult scan_result; |
| scan_result.type_to_data[LeScanResult::kGapManufacturerData].push_back( |
| kManufacturer1Bytes); |
| scan_result.type_to_data[LeScanResult::kGapManufacturerData].push_back( |
| kManufacturer2Bytes); |
| |
| auto md = scan_result.ManufacturerData(); |
| ASSERT_EQ(2ul, md.size()); |
| EXPECT_EQ( |
| md[kManufacturer1], |
| std::vector<uint8_t>(kManufacturer1Bytes.begin() + sizeof(kManufacturer1), |
| kManufacturer1Bytes.end())); |
| EXPECT_EQ( |
| md[kManufacturer2], |
| std::vector<uint8_t>(kManufacturer2Bytes.begin() + sizeof(kManufacturer2), |
| kManufacturer2Bytes.end())); |
| } |
| |
| } // namespace bluetooth |
| } // namespace chromecast |
