| // Copyright 2023 The Pigweed Authors |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| // use this file except in compliance with the License. You may obtain a copy of |
| // the License at |
| // |
| // https://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| // License for the specific language governing permissions and limitations under |
| // the License. |
| |
| #include "pw_bluetooth_sapphire/internal/host/common/device_class.h" |
| |
| #include "pw_unit_test/framework.h" |
| |
| namespace bt { |
| namespace { |
| |
| struct TestPayload { |
| uint8_t arg0; |
| DeviceClass class_of_device; |
| } __attribute__((packed)); |
| |
| TEST(DeviceClassTest, CastFromBytes) { |
| std::array<uint8_t, 4> bytes{{10, 0x06, 0x02, 0x02}}; |
| EXPECT_EQ(bytes.size(), sizeof(TestPayload)); |
| |
| auto* test_payload = reinterpret_cast<TestPayload*>(bytes.data()); |
| EXPECT_EQ(10, test_payload->arg0); |
| EXPECT_EQ(DeviceClass::MajorClass::kPhone, |
| test_payload->class_of_device.major_class()); |
| std::unordered_set<DeviceClass::ServiceClass> srvs_expected = { |
| DeviceClass::ServiceClass::kNetworking}; |
| EXPECT_EQ(srvs_expected, test_payload->class_of_device.GetServiceClasses()); |
| |
| // Computer -- Laptop with no Serivces. |
| std::array<uint8_t, 4> no_srv_bytes{{0xBA, 0x0C, 0x01, 0x00}}; |
| EXPECT_EQ(no_srv_bytes.size(), sizeof(TestPayload)); |
| |
| test_payload = reinterpret_cast<TestPayload*>(no_srv_bytes.data()); |
| EXPECT_EQ(0xBA, test_payload->arg0); |
| EXPECT_EQ(DeviceClass::MajorClass::kComputer, |
| test_payload->class_of_device.major_class()); |
| srvs_expected = {}; |
| EXPECT_EQ(srvs_expected, test_payload->class_of_device.GetServiceClasses()); |
| |
| // Wearable -- watch with Location and Audio services |
| std::array<uint8_t, 4> two_srv_bytes{{0xA0, 0x04, 0x07, 0x21}}; |
| EXPECT_EQ(two_srv_bytes.size(), sizeof(TestPayload)); |
| |
| test_payload = reinterpret_cast<TestPayload*>(two_srv_bytes.data()); |
| EXPECT_EQ(0xA0, test_payload->arg0); |
| EXPECT_EQ(DeviceClass::MajorClass::kWearable, |
| test_payload->class_of_device.major_class()); |
| srvs_expected = {DeviceClass::ServiceClass::kAudio, |
| DeviceClass::ServiceClass::kPositioning}; |
| EXPECT_EQ(srvs_expected, test_payload->class_of_device.GetServiceClasses()); |
| } |
| |
| TEST(DeviceClassTest, ConstructFromUInt32) { |
| // AudioVideo -- headset with Rendering and Audio services |
| DeviceClass class_of_device(0x240404); |
| |
| EXPECT_EQ(DeviceClass::MajorClass::kAudioVideo, |
| class_of_device.major_class()); |
| |
| const uint8_t WEARABLE_HEADSET_DEVICE_MINOR_CLASS = 1; |
| EXPECT_EQ(WEARABLE_HEADSET_DEVICE_MINOR_CLASS, class_of_device.minor_class()); |
| |
| std::unordered_set<DeviceClass::ServiceClass> srvs_expected = { |
| DeviceClass::ServiceClass::kAudio, DeviceClass::ServiceClass::kRendering}; |
| EXPECT_EQ(srvs_expected, class_of_device.GetServiceClasses()); |
| } |
| |
| TEST(DeviceClassTest, ConvertToUInt32) { |
| uint32_t raw = 0x240304; |
| DeviceClass class_of_device(raw); |
| EXPECT_EQ(class_of_device.to_int(), raw); |
| } |
| |
| TEST(DeviceClassTest, GetBytes) { |
| DeviceClass class_of_device(0x240404); |
| EXPECT_EQ(class_of_device.bytes(), (DeviceClass::Bytes{{0x04, 0x04, 0x24}})); |
| } |
| |
| TEST(DeviceClassTest, ToString) { |
| DeviceClass device; |
| EXPECT_EQ("Unspecified", device.ToString()); |
| |
| device = DeviceClass({0x06, 0x02, 0x02}); |
| EXPECT_EQ("Phone (Networking)", device.ToString()); |
| |
| device = DeviceClass({0x06, 0x02, 0x60}); |
| EXPECT_EQ("Phone (Telephony, Audio)", device.ToString()); |
| } |
| |
| TEST(DeviceClassTest, Comparison) { |
| DeviceClass class1(DeviceClass::MajorClass::kPhone); |
| DeviceClass class2(DeviceClass::MajorClass::kPhone); |
| DeviceClass class3(DeviceClass::MajorClass::kComputer); |
| EXPECT_EQ(class1, class2); |
| EXPECT_NE(class2, class3); |
| } |
| |
| } // namespace |
| } // namespace bt |