Blender V5.3
guardedalloc_safe_multiply_test.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2026 Blender Authors
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5#include "testing/testing.h"
6
7#include "MEM_safe_multiply.h"
8
9namespace {
10
11template<typename T> void expect_ok(T a, T b, T expected)
12{
13 T result = T(123);
15 EXPECT_EQ(result, expected);
16}
17
18template<typename T> void expect_overflow(T a, T b)
19{
20 T result = T(123);
22 EXPECT_EQ(result, T(0));
23}
24
25} // namespace
26
27TEST(safe_multiply, SizeT)
28{
29 /* Value near overflow that should just fit. */
30 const size_t near_overflow = (size_t(1) << (sizeof(size_t) * 8 / 2)) - 1;
31
32 expect_ok<size_t>(0, 0, 0);
33 expect_ok<size_t>(0, 42, 0);
34 expect_ok<size_t>(42, 0, 0);
35 expect_ok<size_t>(0, SIZE_MAX, 0);
36 expect_ok<size_t>(SIZE_MAX, 0, 0);
37 expect_ok<size_t>(1, 1, 1);
38 expect_ok<size_t>(123, 456, 123 * 456);
39 expect_ok<size_t>(1, SIZE_MAX, SIZE_MAX);
40 expect_ok<size_t>(SIZE_MAX, 1, SIZE_MAX);
41 expect_ok<size_t>(near_overflow, near_overflow, near_overflow * near_overflow);
42 expect_ok<size_t>(near_overflow + 1, 2, (near_overflow + 1) * 2);
43 expect_ok<size_t>(SIZE_MAX / 2, 2, (SIZE_MAX / 2) * 2);
44 expect_ok<size_t>(SIZE_MAX / 1234567, 1234567, (SIZE_MAX / 1234567) * 1234567);
45
46 expect_overflow<size_t>(SIZE_MAX, 2);
47 expect_overflow<size_t>(2, SIZE_MAX);
48 expect_overflow<size_t>(SIZE_MAX, SIZE_MAX);
49 expect_overflow<size_t>(SIZE_MAX / 2 + 1, 2);
50 expect_overflow<size_t>(SIZE_MAX, 12345567);
51}
52
53TEST(safe_multiply, Int64)
54{
55 expect_ok<int64_t>(0, 0, 0);
56 expect_ok<int64_t>(0, 42, 0);
57 expect_ok<int64_t>(42, 0, 0);
58 expect_ok<int64_t>(1, 1, 1);
59 expect_ok<int64_t>(123, 456, 123 * 456);
60 expect_ok<int64_t>(2147483647, 2147483647, int64_t(2147483647) * 2147483647);
61
62 if constexpr (sizeof(size_t) >= sizeof(int64_t)) {
63 /* OK on 64 bit. */
64 expect_ok<int64_t>(1, INT64_MAX, INT64_MAX);
65 expect_ok<int64_t>(int64_t(1) << 31, 2, int64_t(1) << 32);
66 expect_ok<int64_t>(INT64_MAX / 2, 2, (INT64_MAX / 2) * 2);
67 }
68 else {
69 /* Overflow on 32 bit. */
70 expect_overflow<int64_t>(1, INT64_MAX);
71 expect_overflow<int64_t>(int64_t(1) << 31, 2);
72 expect_overflow<int64_t>(INT64_MAX / 2, 2);
73 }
74
75 expect_overflow<int64_t>(-1, 1);
76 expect_overflow<int64_t>(1, -1);
77 expect_overflow<int64_t>(-5, -5);
78 expect_overflow<int64_t>(INT64_MIN, 1);
79 expect_overflow<int64_t>(-1000000, 1000000);
80 expect_overflow<int64_t>(INT64_MAX, 2);
81 expect_overflow<int64_t>(2, INT64_MAX);
82 expect_overflow<int64_t>(INT64_MAX, INT64_MAX);
83 expect_overflow<int64_t>(INT64_MAX / 2 + 1, 2);
84}
#define SIZE_MAX
#define INT64_MIN
#define INT64_MAX
bool MEM_size_safe_multiply(size_t a, size_t b, size_t *result)
long long int int64_t
#define EXPECT_FALSE(result)
#define TEST(a, b)
#define EXPECT_TRUE(result)
#define EXPECT_EQ(result, expect)
#define T