1//===-- Unittests for MemorySize ------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "src/__support/macros/config.h"
10#include "src/__support/memory_size.h"
11#include "test/UnitTest/Test.h"
12
13namespace LIBC_NAMESPACE_DECL {
14namespace internal {
15static inline constexpr size_t SAFE_MEM_SIZE_TEST_LIMIT =
16 static_cast<size_t>(cpp::numeric_limits<cpp::make_signed_t<size_t>>::max());
17
18TEST(LlvmLibcMemSizeTest, Constuction) {
19 ASSERT_FALSE(SafeMemSize{static_cast<size_t>(-1)}.valid());
20 ASSERT_FALSE(SafeMemSize{static_cast<size_t>(-2)}.valid());
21 ASSERT_FALSE(SafeMemSize{static_cast<size_t>(-1024 + 33)}.valid());
22 ASSERT_FALSE(SafeMemSize{static_cast<size_t>(-1024 + 66)}.valid());
23 ASSERT_FALSE(SafeMemSize{SAFE_MEM_SIZE_TEST_LIMIT + 1}.valid());
24 ASSERT_FALSE(SafeMemSize{SAFE_MEM_SIZE_TEST_LIMIT + 13}.valid());
25
26 ASSERT_TRUE(SafeMemSize{static_cast<size_t>(1)}.valid());
27 ASSERT_TRUE(SafeMemSize{static_cast<size_t>(1024 + 13)}.valid());
28 ASSERT_TRUE(SafeMemSize{static_cast<size_t>(2048 - 13)}.valid());
29 ASSERT_TRUE(SafeMemSize{static_cast<size_t>(4096 + 1)}.valid());
30 ASSERT_TRUE(SafeMemSize{static_cast<size_t>(8192 - 1)}.valid());
31 ASSERT_TRUE(SafeMemSize{static_cast<size_t>(16384 + 15)}.valid());
32 ASSERT_TRUE(SafeMemSize{static_cast<size_t>(32768 * 3)}.valid());
33 ASSERT_TRUE(SafeMemSize{static_cast<size_t>(65536 * 13)}.valid());
34 ASSERT_TRUE(SafeMemSize{SAFE_MEM_SIZE_TEST_LIMIT}.valid());
35 ASSERT_TRUE(SafeMemSize{SAFE_MEM_SIZE_TEST_LIMIT - 1}.valid());
36 ASSERT_TRUE(SafeMemSize{SAFE_MEM_SIZE_TEST_LIMIT - 13}.valid());
37}
38
39TEST(LlvmLibcMemSizeTest, Addition) {
40 auto max = SafeMemSize{SAFE_MEM_SIZE_TEST_LIMIT};
41 auto half = SafeMemSize{SAFE_MEM_SIZE_TEST_LIMIT / 2};
42 auto third = SafeMemSize{SAFE_MEM_SIZE_TEST_LIMIT / 3};
43
44 ASSERT_TRUE(half.valid());
45 ASSERT_TRUE(third.valid());
46 ASSERT_TRUE((half + half).valid());
47 ASSERT_TRUE((third + third + third).valid());
48 ASSERT_TRUE((half + third).valid());
49
50 ASSERT_FALSE((max + SafeMemSize{static_cast<size_t>(1)}).valid());
51 ASSERT_FALSE((third + third + third + third).valid());
52 ASSERT_FALSE((half + half + half).valid());
53
54 ASSERT_FALSE((SafeMemSize{static_cast<size_t>(-1)} +
55 SafeMemSize{static_cast<size_t>(2)})
56 .valid());
57 ASSERT_FALSE((SafeMemSize{static_cast<size_t>(2)} +
58 SafeMemSize{static_cast<size_t>(-1)})
59 .valid());
60}
61
62TEST(LlvmLibcMemSizeTest, Multiplication) {
63 auto max = SafeMemSize{SAFE_MEM_SIZE_TEST_LIMIT};
64 auto half = SafeMemSize{SAFE_MEM_SIZE_TEST_LIMIT / 2};
65 auto third = SafeMemSize{SAFE_MEM_SIZE_TEST_LIMIT / 3};
66
67 ASSERT_TRUE((max * SafeMemSize{static_cast<size_t>(1)}).valid());
68 ASSERT_TRUE((max * SafeMemSize{static_cast<size_t>(0)}).valid());
69
70 ASSERT_FALSE((max * SafeMemSize{static_cast<size_t>(2)}).valid());
71 ASSERT_FALSE((half * half).valid());
72 ASSERT_FALSE((half * SafeMemSize{static_cast<size_t>(3)}).valid());
73 ASSERT_FALSE((third * SafeMemSize{static_cast<size_t>(4)}).valid());
74}
75
76TEST(LlvmLibcMemSizeTest, AlignUp) {
77 size_t sizes[] = {
78 0, 1, 8, 13, 60, 97, 128, 1024, 5124, 5120,
79 };
80 for (size_t i = 2; i <= 16; ++i) {
81 size_t alignment = 1 << i;
82 for (size_t size : sizes) {
83 auto safe_size = SafeMemSize{size};
84 auto safe_aligned_size = safe_size.align_up(alignment);
85 ASSERT_TRUE(safe_aligned_size.valid());
86 ASSERT_EQ(static_cast<size_t>(safe_aligned_size) % alignment, size_t(0));
87 }
88 }
89 auto max = SafeMemSize{SAFE_MEM_SIZE_TEST_LIMIT};
90 ASSERT_FALSE(max.align_up(8).valid());
91}
92
93TEST(LlvmLibcBlockBitTest, OffsetTo) {
94 ASSERT_EQ(SafeMemSize::offset_to(0, 512), size_t(0));
95 ASSERT_EQ(SafeMemSize::offset_to(1, 512), size_t(511));
96 ASSERT_EQ(SafeMemSize::offset_to(2, 512), size_t(510));
97 ASSERT_EQ(SafeMemSize::offset_to(13, 1), size_t(0));
98 ASSERT_EQ(SafeMemSize::offset_to(13, 4), size_t(3));
99 for (unsigned int i = 0; i < 31; ++i) {
100 ASSERT_EQ((SafeMemSize::offset_to(i, 1u << i) + i) % (1u << i), size_t(0));
101 }
102}
103} // namespace internal
104} // namespace LIBC_NAMESPACE_DECL
105

source code of libc/test/src/__support/memory_size_test.cpp