| // 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/att/attribute.h" |
| |
| #include "pw_bluetooth_sapphire/internal/host/testing/test_helpers.h" |
| #include "pw_unit_test/framework.h" |
| |
| namespace bt::att { |
| namespace { |
| |
| constexpr PeerId kTestPeerId(1); |
| constexpr Handle kTestHandle = 0x0001; |
| constexpr UUID kTestType1(uint16_t{0x0001}); |
| constexpr UUID kTestType2(uint16_t{0x0002}); |
| constexpr UUID kTestType3(uint16_t{0x0003}); |
| constexpr UUID kTestType4(uint16_t{0x0004}); |
| |
| const StaticByteBuffer kTestValue('t', 'e', 's', 't'); |
| |
| TEST(AttributeDeathTest, OverflowingMaxHandleOnAttributeGroupDies) { |
| ASSERT_DEATH_IF_SUPPORTED( |
| { |
| AttributeGrouping A(kTestType1, kHandleMax - 1, size_t{2}, kTestValue); |
| }, |
| ".*attr_count.*"); |
| } |
| |
| TEST(AttributeTest, AccessRequirementsDefault) { |
| AccessRequirements reqs; |
| EXPECT_FALSE(reqs.allowed()); |
| EXPECT_FALSE(reqs.encryption_required()); |
| EXPECT_FALSE(reqs.authentication_required()); |
| EXPECT_FALSE(reqs.authorization_required()); |
| } |
| |
| TEST(AttributeTest, AccessRequirements) { |
| AccessRequirements reqs0( |
| /*encryption=*/true, /*authentication=*/false, /*authorization=*/false); |
| EXPECT_TRUE(reqs0.allowed()); |
| EXPECT_TRUE(reqs0.encryption_required()); |
| EXPECT_FALSE(reqs0.authentication_required()); |
| EXPECT_FALSE(reqs0.authorization_required()); |
| EXPECT_EQ(reqs0.min_enc_key_size(), sm::kMaxEncryptionKeySize); |
| |
| AccessRequirements reqs1(/*encryption=*/true, |
| /*authentication=*/false, |
| /*authorization=*/false, |
| 8); |
| EXPECT_TRUE(reqs1.allowed()); |
| EXPECT_TRUE(reqs1.encryption_required()); |
| EXPECT_FALSE(reqs1.authentication_required()); |
| EXPECT_FALSE(reqs1.authorization_required()); |
| EXPECT_EQ(reqs1.min_enc_key_size(), 8u); |
| |
| AccessRequirements reqs2( |
| /*encryption=*/false, /*authentication=*/true, /*authorization=*/false); |
| EXPECT_TRUE(reqs2.allowed()); |
| EXPECT_FALSE(reqs2.encryption_required()); |
| EXPECT_TRUE(reqs2.authentication_required()); |
| EXPECT_FALSE(reqs2.authorization_required()); |
| |
| AccessRequirements reqs3( |
| /*encryption=*/false, /*authentication=*/false, /*authorization=*/true); |
| EXPECT_TRUE(reqs3.allowed()); |
| EXPECT_FALSE(reqs3.encryption_required()); |
| EXPECT_FALSE(reqs3.authentication_required()); |
| EXPECT_TRUE(reqs3.authorization_required()); |
| |
| AccessRequirements reqs4( |
| /*encryption=*/false, /*authentication=*/false, /*authorization=*/false); |
| EXPECT_TRUE(reqs4.allowed()); |
| EXPECT_FALSE(reqs4.encryption_required()); |
| EXPECT_FALSE(reqs4.authentication_required()); |
| EXPECT_FALSE(reqs4.authorization_required()); |
| } |
| |
| TEST(AttributeTest, GroupingDeclAttr) { |
| constexpr size_t kAttrCount = 0u; |
| |
| AttributeGrouping group(kTestType1, kTestHandle, kAttrCount, kTestValue); |
| |
| // The grouping consists of just the group declaration and is thus complete. |
| EXPECT_TRUE(group.complete()); |
| EXPECT_EQ(kTestType1, group.group_type()); |
| EXPECT_EQ(kTestHandle, group.start_handle()); |
| EXPECT_EQ(kTestHandle, group.end_handle()); |
| EXPECT_EQ(1u, group.attributes().size()); |
| |
| // The grouping is already complete. |
| EXPECT_FALSE(group.AddAttribute( |
| kTestType2, AccessRequirements(), AccessRequirements())); |
| |
| const Attribute& decl_attr = group.attributes()[0]; |
| EXPECT_EQ(kTestHandle, decl_attr.handle()); |
| EXPECT_EQ(kTestType1, decl_attr.type()); |
| ASSERT_TRUE(decl_attr.value()); |
| EXPECT_TRUE(ContainersEqual(kTestValue, *decl_attr.value())); |
| EXPECT_TRUE(decl_attr.read_reqs().allowed()); |
| EXPECT_FALSE(decl_attr.read_reqs().encryption_required()); |
| EXPECT_FALSE(decl_attr.read_reqs().authentication_required()); |
| EXPECT_FALSE(decl_attr.read_reqs().authorization_required()); |
| EXPECT_FALSE(decl_attr.write_reqs().allowed()); |
| EXPECT_EQ(&group, &decl_attr.group()); |
| } |
| |
| TEST(AttributeTest, GroupingAddAttribute) { |
| constexpr size_t kAttrCount = 2; |
| |
| AttributeGrouping group(kTestType1, kTestHandle, kAttrCount, kTestValue); |
| EXPECT_FALSE(group.complete()); |
| EXPECT_EQ(kTestHandle, group.start_handle()); |
| EXPECT_EQ(kTestHandle + kAttrCount, group.end_handle()); |
| |
| Attribute* attr = group.AddAttribute( |
| kTestType2, AccessRequirements(), AccessRequirements()); |
| ASSERT_TRUE(attr); |
| EXPECT_EQ(kTestType2, attr->type()); |
| EXPECT_EQ(kTestHandle + 1, attr->handle()); |
| EXPECT_EQ(&group, &attr->group()); |
| |
| // The attribute should have no value until assigned. |
| EXPECT_FALSE(attr->value()); |
| attr->SetValue(kTestValue); |
| ASSERT_TRUE(attr->value()); |
| EXPECT_TRUE(ContainersEqual(kTestValue, *attr->value())); |
| |
| // The group is not complete until |kAttrCount| attributes have been added. |
| EXPECT_FALSE(group.complete()); |
| EXPECT_EQ(2u, group.attributes().size()); |
| |
| attr = group.AddAttribute( |
| kTestType3, AccessRequirements(), AccessRequirements()); |
| ASSERT_TRUE(attr); |
| EXPECT_EQ(kTestType3, attr->type()); |
| |
| EXPECT_TRUE(group.complete()); |
| EXPECT_EQ(group.end_handle(), attr->handle()); |
| EXPECT_EQ(3u, group.attributes().size()); |
| |
| EXPECT_FALSE(group.AddAttribute( |
| kTestType4, AccessRequirements(), AccessRequirements())); |
| } |
| |
| TEST(AttributeTest, ReadAsyncReadNotAllowed) { |
| AttributeGrouping group(kTestType1, kTestHandle, 1, kTestValue); |
| Attribute* attr = group.AddAttribute( |
| kTestType2, AccessRequirements(), AccessRequirements()); |
| EXPECT_FALSE(attr->ReadAsync(kTestPeerId, 0, [](auto, const auto&) {})); |
| } |
| |
| TEST(AttributeTest, ReadAsyncReadNoHandler) { |
| AttributeGrouping group(kTestType1, kTestHandle, 1, kTestValue); |
| Attribute* attr = group.AddAttribute( |
| kTestType2, |
| AccessRequirements(/*encryption=*/false, |
| /*authentication=*/false, |
| /*authorization=*/false), // read (no security) |
| AccessRequirements()); // write not allowed |
| EXPECT_FALSE(attr->ReadAsync(kTestPeerId, 0, [](auto, const auto&) {})); |
| } |
| |
| TEST(AttributeTest, ReadAsync) { |
| constexpr uint16_t kTestOffset = 5; |
| |
| AttributeGrouping group(kTestType1, kTestHandle, 1, kTestValue); |
| Attribute* attr = group.AddAttribute( |
| kTestType2, |
| AccessRequirements(/*encryption=*/false, |
| /*authentication=*/false, |
| /*authorization=*/false), // read (no security) |
| AccessRequirements()); // write not allowed |
| |
| bool callback_called = false; |
| auto callback = [&](fit::result<ErrorCode> status, const auto& value) { |
| EXPECT_EQ(fit::ok(), status); |
| EXPECT_TRUE(ContainersEqual(StaticByteBuffer('h', 'i'), value)); |
| callback_called = true; |
| }; |
| |
| auto handler = |
| [&](PeerId peer_id, Handle handle, uint16_t offset, auto result_cb) { |
| EXPECT_EQ(kTestPeerId, peer_id); |
| EXPECT_EQ(attr->handle(), handle); |
| EXPECT_EQ(kTestOffset, offset); |
| EXPECT_TRUE(result_cb); |
| |
| result_cb(fit::ok(), StaticByteBuffer('h', 'i')); |
| }; |
| |
| attr->set_read_handler(handler); |
| EXPECT_TRUE(attr->ReadAsync(kTestPeerId, kTestOffset, callback)); |
| EXPECT_TRUE(callback_called); |
| } |
| |
| TEST(AttributeTest, WriteAsyncWriteNotAllowed) { |
| AttributeGrouping group(kTestType1, kTestHandle, 1, kTestValue); |
| Attribute* attr = group.AddAttribute( |
| kTestType2, AccessRequirements(), AccessRequirements()); |
| EXPECT_FALSE(attr->WriteAsync(kTestPeerId, 0, BufferView(), [](auto) {})); |
| } |
| |
| TEST(AttributeTest, WriteAsyncWriteNoHandler) { |
| AttributeGrouping group(kTestType1, kTestHandle, 1, kTestValue); |
| Attribute* attr = group.AddAttribute( |
| kTestType2, |
| AccessRequirements(), // read not allowed |
| AccessRequirements(/*encryption=*/false, |
| /*authentication=*/false, |
| /*authorization=*/false)); // write no security |
| EXPECT_FALSE(attr->WriteAsync(kTestPeerId, 0, BufferView(), [](auto) {})); |
| } |
| |
| TEST(AttributeTest, WriteAsync) { |
| constexpr uint16_t kTestOffset = 5; |
| |
| AttributeGrouping group(kTestType1, kTestHandle, 1, kTestValue); |
| Attribute* attr = group.AddAttribute( |
| kTestType2, |
| AccessRequirements(), // read not allowed |
| AccessRequirements(/*encryption=*/false, |
| /*authentication=*/false, |
| /*authorization=*/false)); // write no security |
| |
| bool callback_called = false; |
| auto callback = [&](fit::result<ErrorCode> status) { |
| EXPECT_EQ(fit::ok(), status); |
| callback_called = true; |
| }; |
| |
| auto handler = [&](PeerId peer_id, |
| Handle handle, |
| uint16_t offset, |
| const auto& value, |
| auto result_cb) { |
| EXPECT_EQ(kTestPeerId, peer_id); |
| EXPECT_EQ(attr->handle(), handle); |
| EXPECT_EQ(kTestOffset, offset); |
| EXPECT_TRUE(ContainersEqual(StaticByteBuffer('h', 'i'), value)); |
| EXPECT_TRUE(result_cb); |
| |
| result_cb(fit::ok()); |
| }; |
| |
| attr->set_write_handler(handler); |
| EXPECT_TRUE(attr->WriteAsync( |
| kTestPeerId, kTestOffset, StaticByteBuffer('h', 'i'), callback)); |
| EXPECT_TRUE(callback_called); |
| } |
| |
| } // namespace |
| } // namespace bt::att |