blob: a16f6712f80b4501353cc0977506c48cb1d610d7 [file] [log] [blame]
// 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