Blender V5.3
spz_header_test.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2026 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#include "testing/testing.h"
6
7#include <climits>
8#include <cstdint>
9#include <limits>
10
11#include "spz_header.hh"
12
14
15/* -------------------------------------------------------------------- */
18
19template<class Header> Header make_default_valid_header();
20
21template<class Header> static void run_magic_tests()
22{
23 auto make_header_with_magic = [](const uint32_t magic) {
25 header.magic = magic;
26 return header;
27 };
28
29 EXPECT_EQ(check_header_for_errors(make_header_with_magic(0xDEADBEEF)),
30 "Unexpected SPZ header magic 0xDEADBEEF");
31}
32
33template<class Header> static void run_num_points_tests()
34{
35 auto make_header_with_num_points = [](const uint32_t num_points) {
37 header.num_points = num_points;
38 return header;
39 };
40
41 EXPECT_EQ(check_header_for_errors(make_header_with_num_points(0)), std::nullopt);
42 EXPECT_EQ(check_header_for_errors(make_header_with_num_points(uint32_t(INT_MAX))), std::nullopt);
43 EXPECT_EQ(check_header_for_errors(make_header_with_num_points(uint32_t(INT_MAX) + 1)),
44 "Too many points");
45 EXPECT_EQ(check_header_for_errors(make_header_with_num_points(UINT32_MAX)), "Too many points");
46}
47
48template<class Header> static void run_sh_degrees_tests()
49{
50 auto make_header_with_sh_degree = [](const uint8_t sh_degree) {
52 header.sh_degree = sh_degree;
53 return header;
54 };
55
56 EXPECT_EQ(check_header_for_errors(make_header_with_sh_degree(0)), std::nullopt);
57 EXPECT_EQ(check_header_for_errors(make_header_with_sh_degree(1)), std::nullopt);
58 EXPECT_EQ(check_header_for_errors(make_header_with_sh_degree(2)), std::nullopt);
59 EXPECT_EQ(check_header_for_errors(make_header_with_sh_degree(3)), std::nullopt);
60 EXPECT_EQ(check_header_for_errors(make_header_with_sh_degree(4)), std::nullopt);
61
62 for (int sh_degree = 5; sh_degree <= std::numeric_limits<uint8_t>::max(); ++sh_degree) {
63 EXPECT_EQ(check_header_for_errors(make_header_with_sh_degree(sh_degree)),
64 "Unsupported SH degree " + std::to_string(sh_degree))
65 << "Unexpected result for sh_degree=" << int(sh_degree);
66 }
67}
68
69template<class Header> static void run_fractional_bits_tests()
70{
71 auto make_header_with_fractional_bits = [](const uint8_t fractional_bits) {
73 header.fractional_bits = fractional_bits;
74 return header;
75 };
76
77 for (uint8_t bits = 0; bits < 24; ++bits) {
78 EXPECT_EQ(check_header_for_errors(make_header_with_fractional_bits(bits)), std::nullopt)
79 << "Unexpected result for bits=" << int(bits);
80 }
81
82 for (int bits = 24; bits <= std::numeric_limits<uint8_t>::max(); ++bits) {
83 EXPECT_EQ(check_header_for_errors(make_header_with_fractional_bits(bits)),
84 "Unsupported number of position fractional bits " + std::to_string(bits))
85 << "Unexpected result for bits=" << int(bits);
86 }
87}
88
89template<class Header> static void run_flags_tests()
90{
91 auto make_header_with_flags = [](const uint8_t flags) {
93 header.flags = flags;
94 return header;
95 };
96
97 /* Flags are handled separately by the importer and do not make the header invalid. */
99 make_header_with_flags(SPZ_HEADER_ANTIALIASED | SPZ_HEADER_HAS_EXTENSIONS)),
100 std::nullopt);
101}
102
104
105/* -------------------------------------------------------------------- */
108
110{
111 return {
112 .magic = SPZ_HEADER_MAGIC,
113 .version = 3,
114 .num_points = 1,
115 .sh_degree = 3,
116 .fractional_bits = 12,
117 };
118}
119
125
126TEST(PackedGaussiansHeader, check_for_errors_magic)
127{
129}
130
131TEST(PackedGaussiansHeader, check_for_errors_version)
132{
133 auto make_header_with_version = [](const uint32_t version) {
135 header.version = version;
136 return header;
137 };
138
139 EXPECT_EQ(check_header_for_errors(make_header_with_version(0)), "Unsupported SPZ version 0");
140 EXPECT_EQ(check_header_for_errors(make_header_with_version(1)), "Unsupported SPZ version 1");
141 EXPECT_EQ(check_header_for_errors(make_header_with_version(2)), std::nullopt);
142 EXPECT_EQ(check_header_for_errors(make_header_with_version(3)), std::nullopt);
143 EXPECT_EQ(check_header_for_errors(make_header_with_version(4)), "Unsupported SPZ version 4");
144 EXPECT_EQ(check_header_for_errors(make_header_with_version(5)), "Unsupported SPZ version 5");
145 EXPECT_EQ(check_header_for_errors(make_header_with_version(UINT32_MAX)),
146 "Unsupported SPZ version 4294967295");
147}
148
149TEST(PackedGaussiansHeader, check_for_errors_num_points)
150{
152}
153
154TEST(PackedGaussiansHeader, check_for_errors_sh_degree)
155{
157}
158
159TEST(PackedGaussiansHeader, check_for_errors_fractional_bits)
160{
162}
163
164TEST(PackedGaussiansHeader, check_for_errors_flags)
165{
167}
168
170
171/* -------------------------------------------------------------------- */
174
176{
177 return {
178 .magic = SPZ_HEADER_MAGIC,
179 .version = 4,
180 .num_points = 1,
181 .sh_degree = 3,
182 .fractional_bits = 12,
183 .num_streams = 6,
184 .toc_byte_offset = sizeof(NgspFileHeader),
185 };
186}
187
192
193TEST(NgspFileHeader, check_for_errors_magic)
194{
196}
197
198TEST(NgspFileHeader, check_for_errors_version)
199{
200 auto make_header_with_version = [](const uint32_t version) {
202 header.version = version;
203 return header;
204 };
205
206 EXPECT_EQ(check_header_for_errors(make_header_with_version(0)), "Unsupported SPZ version 0");
207 EXPECT_EQ(check_header_for_errors(make_header_with_version(1)), "Unsupported SPZ version 1");
208 EXPECT_EQ(check_header_for_errors(make_header_with_version(2)), "Unsupported SPZ version 2");
209 EXPECT_EQ(check_header_for_errors(make_header_with_version(3)), "Unsupported SPZ version 3");
210 EXPECT_EQ(check_header_for_errors(make_header_with_version(4)), std::nullopt);
211 EXPECT_EQ(check_header_for_errors(make_header_with_version(5)), "Unsupported SPZ version 5");
212 EXPECT_EQ(check_header_for_errors(make_header_with_version(UINT32_MAX)),
213 "Unsupported SPZ version 4294967295");
214}
215
216TEST(NgspFileHeader, check_for_errors_num_points)
217{
219}
220
221TEST(NgspFileHeader, check_for_errors_sh_degree)
222{
224}
225
226TEST(NgspFileHeader, check_for_errors_fractional_bits)
227{
229}
230
231TEST(NgspFileHeader, check_for_errors_flags)
232{
234}
235
236TEST(NgspFileHeader, check_for_errors_num_streams)
237{
238 auto make_header_with_num_streams = [](const uint8_t num_streams) {
240 header.num_streams = num_streams;
241 return header;
242 };
243
244 for (uint8_t num_streams = 0; num_streams < 6; ++num_streams) {
245 EXPECT_EQ(check_header_for_errors(make_header_with_num_streams(num_streams)),
246 "Unexpected number of Zstd streams")
247 << "Unexpected result for num_streams=" << int(num_streams);
248 }
249
250 for (int num_streams = 6; num_streams <= std::numeric_limits<uint8_t>::max(); ++num_streams) {
251 EXPECT_EQ(check_header_for_errors(make_header_with_num_streams(num_streams)), std::nullopt)
252 << "Unexpected result for num_streams=" << int(num_streams);
253 }
254}
255
256TEST(NgspFileHeader, check_for_errors_toc_byte_offset)
257{
258 auto make_header_with_toc_byte_offset = [](const uint32_t toc_byte_offset) {
260 header.toc_byte_offset = toc_byte_offset;
261 return header;
262 };
263
264 EXPECT_EQ(check_header_for_errors(make_header_with_toc_byte_offset(0)),
265 "TOC byte offset is less than the size of the header");
266 EXPECT_EQ(check_header_for_errors(make_header_with_toc_byte_offset(31)),
267 "TOC byte offset is less than the size of the header");
268 EXPECT_EQ(check_header_for_errors(make_header_with_toc_byte_offset(32)), std::nullopt);
269 EXPECT_EQ(check_header_for_errors(make_header_with_toc_byte_offset(33)), std::nullopt);
270 EXPECT_EQ(check_header_for_errors(make_header_with_toc_byte_offset(UINT32_MAX)), std::nullopt);
271}
272
274
275} // namespace blender::io::spz::tests
#define UINT32_MAX
#define INT_MAX
static void run_num_points_tests()
static void run_fractional_bits_tests()
Header make_default_valid_header()
TEST(PackedGaussiansHeader, check_for_errors_valid)
static void run_sh_degrees_tests()
std::optional< std::string > check_header_for_errors(const PackedGaussiansHeader &header)
Definition spz_header.cc:41
constexpr uint32_t SPZ_HEADER_MAGIC
Definition spz_header.hh:14
unsigned int uint32_t
Definition BKE_text.h:81
unsigned char uint8_t
Definition BKE_text.h:79
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)