1 // Copyright 2024 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/numerics/byte_conversions.h"
6 #include "testing/gtest/include/gtest/gtest.h"
7
8 namespace base::numerics {
9
TEST(NumericsTest,FromNativeEndian)10 TEST(NumericsTest, FromNativeEndian) {
11 // The implementation of FromNativeEndian and FromLittleEndian assumes the
12 // native endian is little. If support of big endian is desired, compile-time
13 // branches will need to be added to the implementation, and the test results
14 // will differ there (they would match FromBigEndian in this test).
15 static_assert(std::endian::native == std::endian::little);
16 {
17 constexpr uint8_t bytes[] = {0x12u};
18 EXPECT_EQ(U8FromNativeEndian(bytes), 0x12u);
19 static_assert(std::same_as<uint8_t, decltype(U8FromNativeEndian(bytes))>);
20 static_assert(U8FromNativeEndian(bytes) == 0x12u);
21 }
22 {
23 constexpr uint8_t bytes[] = {0x12u, 0x34u};
24 EXPECT_EQ(U16FromNativeEndian(bytes), 0x34'12u);
25 static_assert(std::same_as<uint16_t, decltype(U16FromNativeEndian(bytes))>);
26 static_assert(U16FromNativeEndian(bytes) == 0x34'12u);
27 }
28 {
29 constexpr uint8_t bytes[] = {0x12u, 0x34u, 0x56u, 0x78u};
30 EXPECT_EQ(U32FromNativeEndian(bytes), 0x78'56'34'12u);
31 static_assert(std::same_as<uint32_t, decltype(U32FromNativeEndian(bytes))>);
32 static_assert(U32FromNativeEndian(bytes) == 0x78'56'34'12u);
33 }
34 {
35 constexpr uint8_t bytes[] = {0x12u, 0x34u, 0x56u, 0x78u,
36 0x90u, 0x12u, 0x34u, 0x56u};
37 EXPECT_EQ(U64FromNativeEndian(bytes), 0x56'34'12'90'78'56'34'12u);
38 static_assert(std::same_as<uint64_t, decltype(U64FromNativeEndian(bytes))>);
39 static_assert(U64FromNativeEndian(bytes) == 0x56'34'12'90'78'56'34'12u);
40 }
41
42 {
43 constexpr uint8_t bytes[] = {0x12u};
44 EXPECT_EQ(I8FromNativeEndian(bytes), 0x12);
45 static_assert(std::same_as<int8_t, decltype(I8FromNativeEndian(bytes))>);
46 static_assert(U8FromNativeEndian(bytes) == 0x12);
47 }
48 {
49 constexpr uint8_t bytes[] = {0x12u, 0x34u};
50 EXPECT_EQ(I16FromNativeEndian(bytes), 0x34'12);
51 static_assert(std::same_as<int16_t, decltype(I16FromNativeEndian(bytes))>);
52 static_assert(U16FromNativeEndian(bytes) == 0x34'12);
53 }
54 {
55 constexpr uint8_t bytes[] = {0x12u, 0x34u, 0x56u, 0x78u};
56 EXPECT_EQ(I32FromNativeEndian(bytes), 0x78'56'34'12);
57 static_assert(std::same_as<int32_t, decltype(I32FromNativeEndian(bytes))>);
58 static_assert(U32FromNativeEndian(bytes) == 0x78'56'34'12);
59 }
60 {
61 constexpr uint8_t bytes[] = {0x12u, 0x34u, 0x56u, 0x78u,
62 0x90u, 0x12u, 0x34u, 0x56u};
63 EXPECT_EQ(I64FromNativeEndian(bytes), 0x56'34'12'90'78'56'34'12);
64 static_assert(std::same_as<int64_t, decltype(I64FromNativeEndian(bytes))>);
65 static_assert(I64FromNativeEndian(bytes) == 0x56'34'12'90'78'56'34'12);
66 }
67
68 {
69 constexpr uint8_t bytes[] = {0x12u, 0x34u, 0x56u, 0x78u};
70 EXPECT_EQ(FloatFromNativeEndian(bytes), 1.73782443614e+34f);
71 EXPECT_EQ(std::bit_cast<uint32_t>(FloatFromNativeEndian(bytes)),
72 0x78'56'34'12u);
73 static_assert(std::same_as<float, decltype(FloatFromNativeEndian(bytes))>);
74 static_assert(FloatFromNativeEndian(bytes) == 1.73782443614e+34f);
75 static_assert(std::bit_cast<uint32_t>(FloatFromNativeEndian(bytes)) ==
76 0x78'56'34'12u);
77 }
78
79 {
80 constexpr uint8_t bytes[] = {0x12u, 0x34u, 0x56u, 0x78u,
81 0x90u, 0x12u, 0x34u, 0x56u};
82 EXPECT_EQ(DoubleFromNativeEndian(bytes),
83 1.84145159269283616391989849435e107);
84 EXPECT_EQ(std::bit_cast<uint64_t>(DoubleFromNativeEndian(bytes)),
85 0x56'34'12'90'78'56'34'12u);
86 static_assert(
87 std::same_as<double, decltype(DoubleFromNativeEndian(bytes))>);
88 static_assert(DoubleFromNativeEndian(bytes) ==
89 1.84145159269283616391989849435e107);
90 static_assert(std::bit_cast<uint64_t>(DoubleFromNativeEndian(bytes)) ==
91 0x56'34'12'90'78'56'34'12u);
92 }
93 }
94
TEST(NumericsTest,FromLittleEndian)95 TEST(NumericsTest, FromLittleEndian) {
96 // The implementation of FromNativeEndian and FromLittleEndian assumes the
97 // native endian is little. If support of big endian is desired, compile-time
98 // branches will need to be added to the implementation, and the test results
99 // will differ there (they would match FromBigEndian in this test).
100 static_assert(std::endian::native == std::endian::little);
101 {
102 constexpr uint8_t bytes[] = {0x12u};
103 EXPECT_EQ(U8FromLittleEndian(bytes), 0x12u);
104 static_assert(std::same_as<uint8_t, decltype(U8FromLittleEndian(bytes))>);
105 static_assert(U8FromLittleEndian(bytes) == 0x12u);
106 }
107 {
108 constexpr uint8_t bytes[] = {0x12u, 0x34u};
109 EXPECT_EQ(U16FromLittleEndian(bytes), 0x34'12u);
110 static_assert(std::same_as<uint16_t, decltype(U16FromLittleEndian(bytes))>);
111 static_assert(U16FromLittleEndian(bytes) == 0x34'12u);
112 }
113 {
114 constexpr uint8_t bytes[] = {0x12u, 0x34u, 0x56u, 0x78u};
115 EXPECT_EQ(U32FromLittleEndian(bytes), 0x78'56'34'12u);
116 static_assert(std::same_as<uint32_t, decltype(U32FromLittleEndian(bytes))>);
117 static_assert(U32FromLittleEndian(bytes) == 0x78'56'34'12u);
118 }
119 {
120 constexpr uint8_t bytes[] = {0x12u, 0x34u, 0x56u, 0x78u,
121 0x90u, 0x12u, 0x34u, 0x56u};
122 EXPECT_EQ(U64FromLittleEndian(bytes), 0x56'34'12'90'78'56'34'12u);
123 static_assert(std::same_as<uint64_t, decltype(U64FromLittleEndian(bytes))>);
124 static_assert(U64FromLittleEndian(bytes) == 0x56'34'12'90'78'56'34'12u);
125 }
126
127 {
128 constexpr uint8_t bytes[] = {0x12u};
129 EXPECT_EQ(I8FromLittleEndian(bytes), 0x12);
130 static_assert(std::same_as<int8_t, decltype(I8FromLittleEndian(bytes))>);
131 static_assert(I8FromLittleEndian(bytes) == 0x12);
132 }
133 {
134 constexpr uint8_t bytes[] = {0x12u, 0x34u};
135 EXPECT_EQ(I16FromLittleEndian(bytes), 0x34'12);
136 static_assert(std::same_as<int16_t, decltype(I16FromLittleEndian(bytes))>);
137 static_assert(I16FromLittleEndian(bytes) == 0x34'12);
138 }
139 {
140 constexpr uint8_t bytes[] = {0x12u, 0x34u, 0x56u, 0x78u};
141 EXPECT_EQ(I32FromLittleEndian(bytes), 0x78'56'34'12);
142 static_assert(std::same_as<int32_t, decltype(I32FromLittleEndian(bytes))>);
143 static_assert(I32FromLittleEndian(bytes) == 0x78'56'34'12);
144 }
145 {
146 constexpr uint8_t bytes[] = {0x12u, 0x34u, 0x56u, 0x78u,
147 0x90u, 0x12u, 0x34u, 0x56u};
148 EXPECT_EQ(I64FromLittleEndian(bytes), 0x56'34'12'90'78'56'34'12);
149 static_assert(std::same_as<int64_t, decltype(I64FromLittleEndian(bytes))>);
150 static_assert(I64FromLittleEndian(bytes) == 0x56'34'12'90'78'56'34'12);
151 }
152
153 {
154 constexpr uint8_t bytes[] = {0x12u, 0x34u, 0x56u, 0x78u};
155 EXPECT_EQ(FloatFromLittleEndian(bytes), 1.73782443614e+34f);
156 EXPECT_EQ(std::bit_cast<uint32_t>(FloatFromLittleEndian(bytes)),
157 0x78'56'34'12u);
158 static_assert(std::same_as<float, decltype(FloatFromLittleEndian(bytes))>);
159 static_assert(FloatFromLittleEndian(bytes) == 1.73782443614e+34f);
160 static_assert(std::bit_cast<uint32_t>(FloatFromLittleEndian(bytes)) ==
161 0x78'56'34'12u);
162 }
163
164 {
165 constexpr uint8_t bytes[] = {0x12u, 0x34u, 0x56u, 0x78u,
166 0x90u, 0x12u, 0x34u, 0x56u};
167 EXPECT_EQ(DoubleFromLittleEndian(bytes),
168 1.84145159269283616391989849435e107);
169 EXPECT_EQ(std::bit_cast<uint64_t>(DoubleFromLittleEndian(bytes)),
170 0x56'34'12'90'78'56'34'12u);
171 static_assert(
172 std::same_as<double, decltype(DoubleFromLittleEndian(bytes))>);
173 static_assert(DoubleFromLittleEndian(bytes) ==
174 1.84145159269283616391989849435e107);
175 static_assert(std::bit_cast<uint64_t>(DoubleFromLittleEndian(bytes)) ==
176 0x56'34'12'90'78'56'34'12u);
177 }
178 }
179
TEST(NumericsTest,FromBigEndian)180 TEST(NumericsTest, FromBigEndian) {
181 // The implementation of FromNativeEndian and FromLittleEndian assumes the
182 // native endian is little. If support of big endian is desired, compile-time
183 // branches will need to be added to the implementation, and the test results
184 // will differ there (they would match FromLittleEndian in this test).
185 static_assert(std::endian::native == std::endian::little);
186 {
187 constexpr uint8_t bytes[] = {0x12u};
188 EXPECT_EQ(U8FromBigEndian(bytes), 0x12u);
189 static_assert(U8FromBigEndian(bytes) == 0x12u);
190 static_assert(std::same_as<uint8_t, decltype(U8FromBigEndian(bytes))>);
191 }
192 {
193 constexpr uint8_t bytes[] = {0x12u, 0x34u};
194 EXPECT_EQ(U16FromBigEndian(bytes), 0x12'34u);
195 static_assert(U16FromBigEndian(bytes) == 0x12'34u);
196 static_assert(std::same_as<uint16_t, decltype(U16FromBigEndian(bytes))>);
197 }
198 {
199 constexpr uint8_t bytes[] = {0x12u, 0x34u, 0x56u, 0x78u};
200 EXPECT_EQ(U32FromBigEndian(bytes), 0x12'34'56'78u);
201 static_assert(U32FromBigEndian(bytes) == 0x12'34'56'78u);
202 static_assert(std::same_as<uint32_t, decltype(U32FromBigEndian(bytes))>);
203 }
204 {
205 constexpr uint8_t bytes[] = {0x12u, 0x34u, 0x56u, 0x78u,
206 0x90u, 0x12u, 0x34u, 0x56u};
207 EXPECT_EQ(U64FromBigEndian(bytes), 0x12'34'56'78'90'12'34'56u);
208 static_assert(U64FromBigEndian(bytes) == 0x12'34'56'78'90'12'34'56u);
209 static_assert(std::same_as<uint64_t, decltype(U64FromBigEndian(bytes))>);
210 }
211
212 {
213 constexpr uint8_t bytes[] = {0x12u};
214 EXPECT_EQ(I8FromBigEndian(bytes), 0x12);
215 static_assert(I8FromBigEndian(bytes) == 0x12);
216 static_assert(std::same_as<int8_t, decltype(I8FromBigEndian(bytes))>);
217 }
218 {
219 constexpr uint8_t bytes[] = {0x12u, 0x34u};
220 EXPECT_EQ(I16FromBigEndian(bytes), 0x12'34);
221 static_assert(I16FromBigEndian(bytes) == 0x12'34);
222 static_assert(std::same_as<int16_t, decltype(I16FromBigEndian(bytes))>);
223 }
224 {
225 constexpr uint8_t bytes[] = {0x12u, 0x34u, 0x56u, 0x78u};
226 EXPECT_EQ(I32FromBigEndian(bytes), 0x12'34'56'78);
227 static_assert(I32FromBigEndian(bytes) == 0x12'34'56'78);
228 static_assert(std::same_as<int32_t, decltype(I32FromBigEndian(bytes))>);
229 }
230 {
231 constexpr uint8_t bytes[] = {0x12u, 0x34u, 0x56u, 0x78u,
232 0x90u, 0x12u, 0x34u, 0x56u};
233 EXPECT_EQ(I64FromBigEndian(bytes), 0x12'34'56'78'90'12'34'56);
234 static_assert(I64FromBigEndian(bytes) == 0x12'34'56'78'90'12'34'56);
235 static_assert(std::same_as<int64_t, decltype(I64FromBigEndian(bytes))>);
236 }
237
238 {
239 constexpr uint8_t bytes[] = {0x12u, 0x34u, 0x56u, 0x78u};
240 EXPECT_EQ(FloatFromBigEndian(bytes), 5.6904566139e-28f);
241 EXPECT_EQ(std::bit_cast<uint32_t>(FloatFromBigEndian(bytes)),
242 0x12'34'56'78u);
243 static_assert(std::same_as<float, decltype(FloatFromBigEndian(bytes))>);
244 static_assert(FloatFromBigEndian(bytes) == 5.6904566139e-28f);
245 static_assert(std::bit_cast<uint32_t>(FloatFromBigEndian(bytes)) ==
246 0x12'34'56'78u);
247 }
248 {
249 constexpr uint8_t bytes[] = {0x12u, 0x34u, 0x56u, 0x78u,
250 0x90u, 0x12u, 0x34u, 0x56u};
251 EXPECT_EQ(DoubleFromBigEndian(bytes), 5.62634909901491201382066931077e-221);
252 EXPECT_EQ(std::bit_cast<uint64_t>(DoubleFromBigEndian(bytes)),
253 0x12'34'56'78'90'12'34'56u);
254 static_assert(std::same_as<double, decltype(DoubleFromBigEndian(bytes))>);
255 static_assert(DoubleFromBigEndian(bytes) ==
256 5.62634909901491201382066931077e-221);
257 static_assert(std::bit_cast<uint64_t>(DoubleFromBigEndian(bytes)) ==
258 0x12'34'56'78'90'12'34'56u);
259 }
260 }
261
TEST(NumericsTest,ToNativeEndian)262 TEST(NumericsTest, ToNativeEndian) {
263 // The implementation of ToNativeEndian and ToLittleEndian assumes the native
264 // endian is little. If support of big endian is desired, compile-time
265 // branches will need to be added to the implementation, and the test results
266 // will differ there (they would match ToBigEndian in this test).
267 static_assert(std::endian::native == std::endian::little);
268 {
269 constexpr std::array<uint8_t, 1u> bytes = {0x12u};
270 constexpr auto val = uint8_t{0x12u};
271 EXPECT_EQ(U8ToNativeEndian(val), bytes);
272 static_assert(
273 std::same_as<std::array<uint8_t, 1u>, decltype(U8ToNativeEndian(val))>);
274 static_assert(U8ToNativeEndian(val) == bytes);
275 }
276 {
277 constexpr std::array<uint8_t, 2u> bytes = {0x12u, 0x34u};
278 constexpr auto val = uint16_t{0x34'12u};
279 EXPECT_EQ(U16ToNativeEndian(val), bytes);
280 static_assert(std::same_as<std::array<uint8_t, 2u>,
281 decltype(U16ToNativeEndian(val))>);
282 static_assert(U16ToNativeEndian(val) == bytes);
283 }
284 {
285 constexpr std::array<uint8_t, 4u> bytes = {0x12u, 0x34u, 0x56u, 0x78u};
286 constexpr auto val = uint32_t{0x78'56'34'12u};
287 EXPECT_EQ(U32ToNativeEndian(val), bytes);
288 static_assert(std::same_as<std::array<uint8_t, 4u>,
289 decltype(U32ToNativeEndian(val))>);
290 static_assert(U32ToNativeEndian(val) == bytes);
291 }
292 {
293 constexpr std::array<uint8_t, 8u> bytes = {0x12u, 0x34u, 0x56u, 0x78u,
294 0x90u, 0x12u, 0x34u, 0x56u};
295 constexpr auto val = uint64_t{0x56'34'12'90'78'56'34'12u};
296 EXPECT_EQ(U64ToNativeEndian(val), bytes);
297 static_assert(std::same_as<std::array<uint8_t, 8u>,
298 decltype(U64ToNativeEndian(val))>);
299 static_assert(U64ToNativeEndian(val) == bytes);
300 }
301
302 {
303 constexpr std::array<uint8_t, 1u> bytes = {0x12u};
304 constexpr auto val = int8_t{0x12};
305 EXPECT_EQ(I8ToNativeEndian(val), bytes);
306 static_assert(
307 std::same_as<std::array<uint8_t, 1u>, decltype(I8ToNativeEndian(val))>);
308 static_assert(I8ToNativeEndian(val) == bytes);
309 }
310 {
311 constexpr std::array<uint8_t, 2u> bytes = {0x12u, 0x34u};
312 constexpr auto val = int16_t{0x34'12};
313 EXPECT_EQ(I16ToNativeEndian(val), bytes);
314 static_assert(std::same_as<std::array<uint8_t, 2u>,
315 decltype(I16ToNativeEndian(val))>);
316 static_assert(I16ToNativeEndian(val) == bytes);
317 }
318 {
319 constexpr std::array<uint8_t, 4u> bytes = {0x12u, 0x34u, 0x56u, 0x78u};
320 constexpr auto val = int32_t{0x78'56'34'12};
321 EXPECT_EQ(I32ToNativeEndian(val), bytes);
322 static_assert(std::same_as<std::array<uint8_t, 4u>,
323 decltype(I32ToNativeEndian(val))>);
324 static_assert(I32ToNativeEndian(val) == bytes);
325 }
326 {
327 constexpr std::array<uint8_t, 8u> bytes = {0x12u, 0x34u, 0x56u, 0x78u,
328 0x90u, 0x12u, 0x34u, 0x56u};
329 constexpr auto val = int64_t{0x56'34'12'90'78'56'34'12};
330 EXPECT_EQ(I64ToNativeEndian(val), bytes);
331 static_assert(std::same_as<std::array<uint8_t, 8u>,
332 decltype(I64ToNativeEndian(val))>);
333 static_assert(I64ToNativeEndian(val) == bytes);
334 }
335
336 {
337 constexpr std::array<uint8_t, 4u> bytes = {0x12u, 0x34u, 0x56u, 0x78u};
338 constexpr float val = 1.73782443614e+34f;
339 EXPECT_EQ(FloatToNativeEndian(val), bytes);
340 static_assert(std::same_as<std::array<uint8_t, 4u>,
341 decltype(FloatToNativeEndian(val))>);
342 static_assert(FloatToNativeEndian(val) == bytes);
343 }
344
345 {
346 constexpr std::array<uint8_t, 8u> bytes = {0x12u, 0x34u, 0x56u, 0x78u,
347 0x90u, 0x12u, 0x34u, 0x56u};
348 constexpr double val = 1.84145159269283616391989849435e107;
349 EXPECT_EQ(DoubleToNativeEndian(val), bytes);
350 static_assert(std::same_as<std::array<uint8_t, 8u>,
351 decltype(DoubleToNativeEndian(val))>);
352 static_assert(DoubleToNativeEndian(val) == bytes);
353 }
354 }
355
TEST(NumericsTest,ToLittleEndian)356 TEST(NumericsTest, ToLittleEndian) {
357 // The implementation of ToNativeEndian and ToLittleEndian assumes the native
358 // endian is little. If support of big endian is desired, compile-time
359 // branches will need to be added to the implementation, and the test results
360 // will differ there (they would match ToBigEndian in this test).
361 static_assert(std::endian::native == std::endian::little);
362 {
363 constexpr std::array<uint8_t, 1u> bytes = {0x12u};
364 constexpr auto val = uint8_t{0x12u};
365 EXPECT_EQ(U8ToLittleEndian(val), bytes);
366 static_assert(
367 std::same_as<std::array<uint8_t, 1u>, decltype(U8ToLittleEndian(val))>);
368 static_assert(U8ToLittleEndian(val) == bytes);
369 }
370 {
371 constexpr std::array<uint8_t, 2u> bytes = {0x12u, 0x34u};
372 constexpr auto val = uint16_t{0x34'12u};
373 EXPECT_EQ(U16ToLittleEndian(val), bytes);
374 static_assert(std::same_as<std::array<uint8_t, 2u>,
375 decltype(U16ToLittleEndian(val))>);
376 static_assert(U16ToLittleEndian(val) == bytes);
377 }
378 {
379 constexpr std::array<uint8_t, 4u> bytes = {0x12u, 0x34u, 0x56u, 0x78u};
380 constexpr auto val = uint32_t{0x78'56'34'12u};
381 EXPECT_EQ(U32ToLittleEndian(val), bytes);
382 static_assert(std::same_as<std::array<uint8_t, 4u>,
383 decltype(U32ToLittleEndian(val))>);
384 static_assert(U32ToLittleEndian(val) == bytes);
385 }
386 {
387 constexpr std::array<uint8_t, 8u> bytes = {0x12u, 0x34u, 0x56u, 0x78u,
388 0x90u, 0x12u, 0x34u, 0x56u};
389 constexpr auto val = uint64_t{0x56'34'12'90'78'56'34'12u};
390 EXPECT_EQ(U64ToLittleEndian(val), bytes);
391 static_assert(std::same_as<std::array<uint8_t, 8u>,
392 decltype(U64ToLittleEndian(val))>);
393 static_assert(U64ToLittleEndian(val) == bytes);
394 }
395
396 {
397 constexpr std::array<uint8_t, 1u> bytes = {0x12u};
398 constexpr auto val = int8_t{0x12};
399 EXPECT_EQ(I8ToLittleEndian(val), bytes);
400 static_assert(
401 std::same_as<std::array<uint8_t, 1u>, decltype(I8ToLittleEndian(val))>);
402 static_assert(I8ToLittleEndian(val) == bytes);
403 }
404 {
405 constexpr std::array<uint8_t, 2u> bytes = {0x12u, 0x34u};
406 constexpr auto val = int16_t{0x34'12};
407 EXPECT_EQ(I16ToLittleEndian(val), bytes);
408 static_assert(std::same_as<std::array<uint8_t, 2u>,
409 decltype(I16ToLittleEndian(val))>);
410 static_assert(I16ToLittleEndian(val) == bytes);
411 }
412 {
413 constexpr std::array<uint8_t, 4u> bytes = {0x12u, 0x34u, 0x56u, 0x78u};
414 constexpr auto val = int32_t{0x78'56'34'12};
415 EXPECT_EQ(I32ToLittleEndian(val), bytes);
416 static_assert(std::same_as<std::array<uint8_t, 4u>,
417 decltype(I32ToLittleEndian(val))>);
418 static_assert(I32ToLittleEndian(val) == bytes);
419 }
420 {
421 constexpr std::array<uint8_t, 8u> bytes = {0x12u, 0x34u, 0x56u, 0x78u,
422 0x90u, 0x12u, 0x34u, 0x56u};
423 constexpr auto val = int64_t{0x56'34'12'90'78'56'34'12};
424 EXPECT_EQ(I64ToLittleEndian(val), bytes);
425 static_assert(std::same_as<std::array<uint8_t, 8u>,
426 decltype(I64ToLittleEndian(val))>);
427 static_assert(I64ToLittleEndian(val) == bytes);
428 }
429
430 {
431 constexpr std::array<uint8_t, 4u> bytes = {0x12u, 0x34u, 0x56u, 0x78u};
432 constexpr float val = 1.73782443614e+34f;
433 EXPECT_EQ(FloatToLittleEndian(val), bytes);
434 static_assert(std::same_as<std::array<uint8_t, 4u>,
435 decltype(FloatToLittleEndian(val))>);
436 static_assert(FloatToLittleEndian(val) == bytes);
437 }
438
439 {
440 constexpr std::array<uint8_t, 8u> bytes = {0x12u, 0x34u, 0x56u, 0x78u,
441 0x90u, 0x12u, 0x34u, 0x56u};
442 constexpr double val = 1.84145159269283616391989849435e107;
443 EXPECT_EQ(DoubleToLittleEndian(val), bytes);
444 static_assert(std::same_as<std::array<uint8_t, 8u>,
445 decltype(DoubleToLittleEndian(val))>);
446 static_assert(DoubleToLittleEndian(val) == bytes);
447 }
448 }
449
TEST(NumericsTest,ToBigEndian)450 TEST(NumericsTest, ToBigEndian) {
451 // The implementation of ToBigEndian assumes the native endian is little. If
452 // support of big endian is desired, compile-time branches will need to be
453 // added to the implementation, and the test results will differ there (they
454 // would match ToLittleEndian in this test).
455 static_assert(std::endian::native == std::endian::little);
456 {
457 constexpr std::array<uint8_t, 1u> bytes = {0x12u};
458 constexpr auto val = uint8_t{0x12u};
459 EXPECT_EQ(U8ToBigEndian(val), bytes);
460 static_assert(
461 std::same_as<std::array<uint8_t, 1u>, decltype(U8ToBigEndian(val))>);
462 static_assert(U8ToBigEndian(val) == bytes);
463 }
464 {
465 constexpr std::array<uint8_t, 2u> bytes = {0x12u, 0x34u};
466 constexpr auto val = uint16_t{0x12'34u};
467 EXPECT_EQ(U16ToBigEndian(val), bytes);
468 static_assert(
469 std::same_as<std::array<uint8_t, 2u>, decltype(U16ToBigEndian(val))>);
470 static_assert(U16ToBigEndian(val) == bytes);
471 }
472 {
473 constexpr std::array<uint8_t, 4u> bytes = {0x12u, 0x34u, 0x56u, 0x78u};
474 constexpr auto val = uint32_t{0x12'34'56'78u};
475 EXPECT_EQ(U32ToBigEndian(val), bytes);
476 static_assert(
477 std::same_as<std::array<uint8_t, 4u>, decltype(U32ToBigEndian(val))>);
478 static_assert(U32ToBigEndian(val) == bytes);
479 }
480 {
481 constexpr std::array<uint8_t, 8u> bytes = {0x12u, 0x34u, 0x56u, 0x78u,
482 0x90u, 0x12u, 0x34u, 0x56u};
483 constexpr auto val = uint64_t{0x12'34'56'78'90'12'34'56u};
484 EXPECT_EQ(U64ToBigEndian(val), bytes);
485 static_assert(
486 std::same_as<std::array<uint8_t, 8u>, decltype(U64ToBigEndian(val))>);
487 static_assert(U64ToBigEndian(val) == bytes);
488 }
489
490 {
491 constexpr std::array<uint8_t, 1u> bytes = {0x12u};
492 constexpr auto val = int8_t{0x12u};
493 EXPECT_EQ(I8ToBigEndian(val), bytes);
494 static_assert(
495 std::same_as<std::array<uint8_t, 1u>, decltype(I8ToBigEndian(val))>);
496 static_assert(I8ToBigEndian(val) == bytes);
497 }
498 {
499 constexpr std::array<uint8_t, 2u> bytes = {0x12u, 0x34u};
500 constexpr auto val = int16_t{0x12'34u};
501 EXPECT_EQ(I16ToBigEndian(val), bytes);
502 static_assert(
503 std::same_as<std::array<uint8_t, 2u>, decltype(I16ToBigEndian(val))>);
504 static_assert(I16ToBigEndian(val) == bytes);
505 }
506 {
507 constexpr std::array<uint8_t, 4u> bytes = {0x12u, 0x34u, 0x56u, 0x78u};
508 constexpr auto val = int32_t{0x12'34'56'78u};
509 EXPECT_EQ(I32ToBigEndian(val), bytes);
510 static_assert(
511 std::same_as<std::array<uint8_t, 4u>, decltype(I32ToBigEndian(val))>);
512 static_assert(I32ToBigEndian(val) == bytes);
513 }
514 {
515 constexpr std::array<uint8_t, 8u> bytes = {0x12u, 0x34u, 0x56u, 0x78u,
516 0x90u, 0x12u, 0x34u, 0x56u};
517 constexpr auto val = int64_t{0x12'34'56'78'90'12'34'56u};
518 EXPECT_EQ(I64ToBigEndian(val), bytes);
519 static_assert(
520 std::same_as<std::array<uint8_t, 8u>, decltype(I64ToBigEndian(val))>);
521 static_assert(I64ToBigEndian(val) == bytes);
522 }
523
524 {
525 constexpr std::array<uint8_t, 4u> bytes = {0x12u, 0x34u, 0x56u, 0x78u};
526 constexpr float val = 5.6904566139e-28f;
527 EXPECT_EQ(FloatToBigEndian(val), bytes);
528 static_assert(
529 std::same_as<std::array<uint8_t, 4u>, decltype(FloatToBigEndian(val))>);
530 static_assert(FloatToBigEndian(val) == bytes);
531 }
532
533 {
534 constexpr std::array<uint8_t, 8u> bytes = {0x12u, 0x34u, 0x56u, 0x78u,
535 0x90u, 0x12u, 0x34u, 0x56u};
536 constexpr double val = 5.62634909901491201382066931077e-221;
537 EXPECT_EQ(DoubleToBigEndian(val), bytes);
538 static_assert(std::same_as<std::array<uint8_t, 8u>,
539 decltype(DoubleToBigEndian(val))>);
540 static_assert(DoubleToBigEndian(val) == bytes);
541 }
542 }
543
544 } // namespace base::numerics
545