Blender V5.3
BLI_generic_array_test.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5#include "testing/testing.h"
6
7#include "MEM_guardedalloc.h"
8
9#include "BLI_array.hh"
10#include "BLI_generic_array.hh"
11
12namespace blender::tests {
13
14class GenericArrayTest : public testing::Test {
15 public:
16 static void SetUpTestSuite()
17 {
19 }
20};
21
22TEST_F(GenericArrayTest, TypeConstructor)
23{
25 EXPECT_TRUE(array.data() == nullptr);
26 EXPECT_EQ(array.size(), 0);
27 EXPECT_EQ(array.as_span().typed<float>().size(), 0);
28 EXPECT_TRUE(array.is_empty());
29}
30
31TEST_F(GenericArrayTest, MoveConstructor)
32{
33 GArray array_a(CPPType::get<int32_t>(), int64_t(10));
34 GMutableSpan span_a = array_a.as_mutable_span();
35 MutableSpan<int32_t> typed_span_a = span_a.typed<int32_t>();
36 typed_span_a.fill(42);
37
38 const GArray array_b = std::move(array_a);
39 Span<int32_t> typed_span_b = array_b.as_span().typed<int32_t>();
40 EXPECT_FALSE(array_b.data() == nullptr);
41 EXPECT_EQ(array_b.size(), 10);
42 EXPECT_EQ(typed_span_b[4], 42);
43
44 /* Make sure the copy constructor cleaned up the original, but it shouldn't clear the type. */
45 EXPECT_TRUE(array_a.data() == nullptr); /* NOLINT: bugprone-use-after-move */
46 EXPECT_EQ(array_a.size(), 0); /* NOLINT: bugprone-use-after-move */
47 EXPECT_TRUE(array_a.is_empty()); /* NOLINT: bugprone-use-after-move */
48 EXPECT_EQ(array_b.type(), array_a.type()); /* NOLINT: bugprone-use-after-move */
49}
50
51TEST_F(GenericArrayTest, CopyConstructor)
52{
53 GArray array_a(CPPType::get<int32_t>(), int64_t(10));
54 GMutableSpan span_a = array_a.as_mutable_span();
55 MutableSpan<int32_t> typed_span_a = span_a.typed<int32_t>();
56 typed_span_a.fill(42);
57
58 /* From span directly. */
59 const GArray array_b = array_a.as_span();
60 Span<int32_t> typed_span_b = array_b.as_span().typed<int32_t>();
61 EXPECT_FALSE(array_b.data() == nullptr);
62 EXPECT_EQ(array_b.size(), 10);
63 EXPECT_EQ(typed_span_b[4], 42);
64 EXPECT_FALSE(array_a.is_empty());
65
66 /* From array. */
67 const GArray array_c = array_a;
68 Span<int32_t> typed_span_c = array_c.as_span().typed<int32_t>();
69 EXPECT_FALSE(array_c.data() == nullptr);
70 EXPECT_EQ(array_c.size(), 10);
71 EXPECT_EQ(typed_span_c[4], 42);
72 EXPECT_FALSE(array_a.is_empty());
73}
74
75TEST_F(GenericArrayTest, BufferAndSizeConstructor)
76{
77 int32_t *values = MEM_new_array_uninitialized<int32_t>(12, __func__);
78 void *buffer = static_cast<void *>(values);
80 EXPECT_FALSE(array.data() == nullptr);
81 EXPECT_EQ(array.size(), 4);
82 EXPECT_FALSE(array.is_empty());
83 EXPECT_EQ(array.as_span().typed<int>().size(), 4);
84 EXPECT_EQ(array[0], &values[0]);
85 EXPECT_EQ(array[1], &values[1]);
86 EXPECT_EQ(array[2], &values[2]);
87 EXPECT_EQ(array[3], &values[3]);
88}
89
91{
93 EXPECT_FALSE(array.data() == nullptr);
94 GMutableSpan span = array.as_mutable_span();
95 MutableSpan<int32_t> typed_span = span.typed<int32_t>();
96 typed_span.fill(77);
97 EXPECT_FALSE(typed_span.data() == nullptr);
98 typed_span[2] = 8;
99 EXPECT_EQ(array[2], &typed_span[2]);
100 EXPECT_EQ(typed_span[0], 77);
101 EXPECT_EQ(typed_span[1], 77);
102
103 array.reinitialize(10);
104 EXPECT_EQ(array.size(), 10);
105 span = array.as_mutable_span();
106 EXPECT_EQ(span.size(), 10);
107
108 typed_span = span.typed<int32_t>();
109 EXPECT_FALSE(typed_span.data() == nullptr);
110
111 array.reinitialize(0);
112 EXPECT_EQ(array.size(), 0);
113}
114
116{
117 Array<GArray<>> arrays;
118 for (GArray<> &array : arrays) {
120 array.as_mutable_span().typed<int32_t>().fill(55);
121 }
122 for (GArray<> &array : arrays) {
123 EXPECT_EQ(array.as_span().typed<int32_t>()[3], 55);
124 }
125}
126
128{
130 array.reinitialize(10);
131 array.as_mutable_span().typed<int>()[9] = 7;
132 EXPECT_EQ(array.size(), 10);
133 EXPECT_EQ(array.as_span().typed<int>()[9], 7);
134}
135
137{
139 array = {};
140 EXPECT_EQ(array.size(), 0);
141 EXPECT_EQ(array.data(), nullptr);
142}
143
144TEST_F(GenericArrayTest, DefaultConstructor)
145{
147
148 EXPECT_TRUE(array.is_empty());
149 EXPECT_TRUE(array.as_mutable_span().is_empty());
150 EXPECT_TRUE(array.as_span().is_empty());
151}
152
153} // namespace blender::tests
Read Blender memory allocation and freeing.
size_t size() const
static const CPPType & get()
GMutableSpan as_mutable_span()
const CPPType & type() const
int64_t size() const
GArray(Allocator allocator={}) noexcept
GSpan as_span() const
const void * data() const
MutableSpan< T > typed() const
Span< T > typed() const
constexpr T * data() const
Definition BLI_span.hh:545
constexpr void fill(const T &value) const
Definition BLI_span.hh:523
#define EXPECT_FALSE(result)
#define EXPECT_TRUE(result)
TEST_F(BlfLoadTest, load)
Definition BLF_tests.cc:37
__int64 int64_t
Definition BKE_text.h:90
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
signed int int32_t
Definition BKE_text.h:78