1 // Copyright 2023 The Pigweed Authors
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
4 // use this file except in compliance with the License. You may obtain a copy of
5 // the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
11 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12 // License for the specific language governing permissions and limitations under
13 // the License.
14
15 #include "pw_bytes/alignment.h"
16
17 #include "lib/stdcompat/bit.h"
18 #include "pw_unit_test/framework.h"
19
20 namespace pw {
21 namespace {
22
23 template <typename T>
TestIsAlignedAs()24 void TestIsAlignedAs() {
25 T t{};
26 auto* ptr = reinterpret_cast<const std::byte*>(&t);
27 EXPECT_TRUE(IsAlignedAs<T>(&t));
28 if constexpr (alignof(T) != 1U) {
29 EXPECT_FALSE(IsAlignedAs<T>(ptr + 1));
30 EXPECT_FALSE(IsAlignedAs<T>(ptr + alignof(T) - 1));
31 }
32 EXPECT_TRUE(IsAlignedAs<T>(ptr + alignof(T)));
33 }
34
TEST(IsAlignedAs,Scalar)35 TEST(IsAlignedAs, Scalar) {
36 TestIsAlignedAs<int8_t>();
37 TestIsAlignedAs<uint16_t>();
38 TestIsAlignedAs<int32_t>();
39 TestIsAlignedAs<size_t>();
40 TestIsAlignedAs<intptr_t>();
41 }
42
TEST(IsAlignedAs,Object)43 TEST(IsAlignedAs, Object) {
44 struct Foo {
45 uint8_t a;
46 uint16_t b;
47 };
48 TestIsAlignedAs<Foo>();
49 }
50
TEST(AlignUp,Zero)51 TEST(AlignUp, Zero) {
52 EXPECT_EQ(0u, AlignUp(0, 1));
53 EXPECT_EQ(0u, AlignUp(0, 2));
54 EXPECT_EQ(0u, AlignUp(0, 15));
55 }
56
TEST(AlignUp,Aligned)57 TEST(AlignUp, Aligned) {
58 for (size_t i = 1; i < 130; ++i) {
59 EXPECT_EQ(i, AlignUp(i, i));
60 EXPECT_EQ(2 * i, AlignUp(2 * i, i));
61 EXPECT_EQ(3 * i, AlignUp(3 * i, i));
62 }
63 }
64
TEST(AlignUp,NonAligned_PowerOf2)65 TEST(AlignUp, NonAligned_PowerOf2) {
66 EXPECT_EQ(32u, AlignUp(1, 32));
67 EXPECT_EQ(32u, AlignUp(31, 32));
68 EXPECT_EQ(64u, AlignUp(33, 32));
69 EXPECT_EQ(64u, AlignUp(45, 32));
70 EXPECT_EQ(64u, AlignUp(63, 32));
71 EXPECT_EQ(128u, AlignUp(127, 32));
72 }
73
TEST(AlignUp,NonAligned_NonPowerOf2)74 TEST(AlignUp, NonAligned_NonPowerOf2) {
75 EXPECT_EQ(2u, AlignUp(1, 2));
76
77 EXPECT_EQ(15u, AlignUp(1, 15));
78 EXPECT_EQ(15u, AlignUp(14, 15));
79 EXPECT_EQ(30u, AlignUp(16, 15));
80 }
81
TEST(AlignDown,Zero)82 TEST(AlignDown, Zero) {
83 EXPECT_EQ(0u, AlignDown(0, 1));
84 EXPECT_EQ(0u, AlignDown(0, 2));
85 EXPECT_EQ(0u, AlignDown(0, 15));
86 }
87
TEST(AlignDown,Aligned)88 TEST(AlignDown, Aligned) {
89 for (size_t i = 1; i < 130; ++i) {
90 EXPECT_EQ(i, AlignDown(i, i));
91 EXPECT_EQ(2 * i, AlignDown(2 * i, i));
92 EXPECT_EQ(3 * i, AlignDown(3 * i, i));
93 }
94 }
95
TEST(AlignDown,NonAligned_PowerOf2)96 TEST(AlignDown, NonAligned_PowerOf2) {
97 EXPECT_EQ(0u, AlignDown(1, 32));
98 EXPECT_EQ(0u, AlignDown(31, 32));
99 EXPECT_EQ(32u, AlignDown(33, 32));
100 EXPECT_EQ(32u, AlignDown(45, 32));
101 EXPECT_EQ(32u, AlignDown(63, 32));
102 EXPECT_EQ(96u, AlignDown(127, 32));
103 }
104
TEST(AlignDown,NonAligned_NonPowerOf2)105 TEST(AlignDown, NonAligned_NonPowerOf2) {
106 EXPECT_EQ(0u, AlignDown(1, 2));
107
108 EXPECT_EQ(0u, AlignDown(1, 15));
109 EXPECT_EQ(0u, AlignDown(14, 15));
110 EXPECT_EQ(15u, AlignDown(16, 15));
111 }
112
TEST(Padding,Zero)113 TEST(Padding, Zero) {
114 EXPECT_EQ(0u, Padding(0, 1));
115 EXPECT_EQ(0u, Padding(0, 2));
116 EXPECT_EQ(0u, Padding(0, 15));
117 }
118
TEST(Padding,Aligned)119 TEST(Padding, Aligned) {
120 for (size_t i = 1; i < 130; ++i) {
121 EXPECT_EQ(0u, Padding(i, i));
122 EXPECT_EQ(0u, Padding(2 * i, i));
123 EXPECT_EQ(0u, Padding(3 * i, i));
124 }
125 }
126
TEST(Padding,NonAligned_PowerOf2)127 TEST(Padding, NonAligned_PowerOf2) {
128 EXPECT_EQ(31u, Padding(1, 32));
129 EXPECT_EQ(1u, Padding(31, 32));
130 EXPECT_EQ(31u, Padding(33, 32));
131 EXPECT_EQ(19u, Padding(45, 32));
132 EXPECT_EQ(1u, Padding(63, 32));
133 EXPECT_EQ(1u, Padding(127, 32));
134 }
135
TEST(Padding,NonAligned_NonPowerOf2)136 TEST(Padding, NonAligned_NonPowerOf2) {
137 EXPECT_EQ(1u, Padding(1, 2));
138
139 EXPECT_EQ(14u, Padding(1, 15));
140 EXPECT_EQ(1u, Padding(14, 15));
141 EXPECT_EQ(14u, Padding(16, 15));
142 }
143
TEST(GetAlignedSubspan,AlignedSpanIsUnchanged)144 TEST(GetAlignedSubspan, AlignedSpanIsUnchanged) {
145 alignas(16) std::array<std::byte, 256> bytes{};
146 pw::ByteSpan aligned = GetAlignedSubspan(bytes, 16);
147 EXPECT_EQ(bytes.data(), aligned.data());
148 EXPECT_EQ(bytes.size(), aligned.size());
149 }
150
TEST(GetAlignedSubspan,UnalignedSpanIsAdvanced)151 TEST(GetAlignedSubspan, UnalignedSpanIsAdvanced) {
152 alignas(16) std::array<std::byte, 256> buffer{};
153 pw::ByteSpan bytes(buffer);
154 bytes = bytes.subspan(1);
155 pw::ByteSpan aligned = GetAlignedSubspan(bytes, 16);
156 EXPECT_EQ(bytes.data() + 15, aligned.data());
157 EXPECT_EQ(bytes.size() - 15, aligned.size());
158 }
159
TEST(GetAlignedSubspan,EmptySpanReturnsEmpty)160 TEST(GetAlignedSubspan, EmptySpanReturnsEmpty) {
161 pw::ByteSpan bytes;
162 pw::ByteSpan aligned = GetAlignedSubspan(bytes, 16);
163 EXPECT_EQ(aligned.size(), 0u);
164 }
165
TEST(GetAlignedSubspan,SpanTooSmallForAlignmentReturnsEmptySpan)166 TEST(GetAlignedSubspan, SpanTooSmallForAlignmentReturnsEmptySpan) {
167 alignas(16) std::array<std::byte, 16> buffer{};
168 pw::ByteSpan bytes(buffer);
169 bytes = bytes.subspan(1);
170 pw::ByteSpan aligned = GetAlignedSubspan(bytes, 16);
171 EXPECT_EQ(aligned.size(), 0u);
172 }
173
174 } // namespace
175 } // namespace pw
176