Debian Codegraph @

src/SPERR/test_scripts/sperr_helper_unit_test.cpp

raw
1
2 #include <random>
3 #include "gtest/gtest.h"
4 #include "sperr_helper.h"
5
6 namespace {
7
8 TEST(sperr_helper, dyadic)
9 {
10 EXPECT_EQ(sperr::can_use_dyadic({64, 1, 1}), std::nullopt); // 1D
11 EXPECT_EQ(sperr::can_use_dyadic({64, 64, 1}), std::nullopt); // 2D
12 EXPECT_EQ(sperr::can_use_dyadic({64, 64, 64}), 3);
13 EXPECT_EQ(sperr::can_use_dyadic({128, 128, 128}), 4);
14 EXPECT_EQ(sperr::can_use_dyadic({256, 256, 256}), 5);
15 EXPECT_EQ(sperr::can_use_dyadic({288, 288, 288}), 6);
16 EXPECT_EQ(sperr::can_use_dyadic({256, 256, 300}), 5);
17 EXPECT_EQ(sperr::can_use_dyadic({300, 300, 256}), 5);
18 EXPECT_EQ(sperr::can_use_dyadic({256, 300, 256}), 5);
19 }
20
21 TEST(sperr_helper, lod_2d)
22 {
23 // Very basic case
24 auto dims = sperr::dims_type{64, 64, 1};
25 auto lod = sperr::coarsened_resolutions(dims);
26 EXPECT_EQ(lod.size(), 3);
27 EXPECT_EQ(lod[0], (sperr::dims_type{8, 8, 1}));
28 EXPECT_EQ(lod[2], (sperr::dims_type{32, 32, 1}));
29
30 // 2D is simpler, because it's always dyadic!
31 dims = {80, 200, 1};
32 lod = sperr::coarsened_resolutions(dims);
33 EXPECT_EQ(lod.size(), 4);
34 EXPECT_EQ(lod[0], (sperr::dims_type{5, 13, 1}));
35 EXPECT_EQ(lod[2], (sperr::dims_type{20, 50, 1}));
36 }
37
38 TEST(sperr_helper, lod_3d)
39 {
40 // Very basic case
41 auto dims = sperr::dims_type{64, 64, 64};
42 auto lod = sperr::coarsened_resolutions(dims);
43 EXPECT_EQ(lod.size(), 3);
44 EXPECT_EQ(lod[0], (sperr::dims_type{8, 8, 8}));
45 EXPECT_EQ(lod[2], (sperr::dims_type{32, 32, 32}));
46
47 // XY has 5 levels, and Z has 6 levels, the overall is 5 levels.
48 dims = {144, 144, 288};
49 lod = sperr::coarsened_resolutions(dims);
50 EXPECT_EQ(lod.size(), 5);
51 EXPECT_EQ(lod[0], (sperr::dims_type{5, 5, 9}));
52 EXPECT_EQ(lod[2], (sperr::dims_type{18, 18, 36}));
53 EXPECT_EQ(lod[4], (sperr::dims_type{72, 72, 144}));
54
55 // Another test
56 dims = {300, 300, 160};
57 lod = sperr::coarsened_resolutions(dims);
58 EXPECT_EQ(lod.size(), 5);
59 EXPECT_EQ(lod[0], (sperr::dims_type{10, 10, 5}));
60 EXPECT_EQ(lod[2], (sperr::dims_type{38, 38, 20}));
61 EXPECT_EQ(lod[4], (sperr::dims_type{150, 150, 80}));
62
63 // Dyadic will not be used, so no coarsened levels.
64 dims = {128, 128, 60};
65 lod = sperr::coarsened_resolutions(dims);
66 EXPECT_EQ(lod.size(), 0);
67 }
68
69 TEST(sperr_helper, lod_3d_multi_chunk)
70 {
71 using sperr::dims_type;
72
73 // If chunk dim is not divisible, there's no available resolution.
74 auto vdim = dims_type{90, 90, 90};
75 auto cdim = dims_type{60, 60, 60};
76 auto res = sperr::coarsened_resolutions(vdim, cdim);
77 EXPECT_EQ(res.size(), 0);
78
79 // If the chunk itself doesn't support multi-resolution, then the whole volume doesn't too.
80 vdim = {40, 40, 80};
81 cdim = {20, 20, 40};
82 res = sperr::coarsened_resolutions(vdim, cdim);
83 EXPECT_EQ(res.size(), 0);
84
85 // An obvious case.
86 vdim = {128, 128, 128};
87 cdim = {64, 64, 64};
88 res = sperr::coarsened_resolutions(vdim, cdim);
89 EXPECT_EQ(res.size(), 3);
90 EXPECT_EQ(res[0], (dims_type{16, 16, 16}));
91 EXPECT_EQ(res[1], (dims_type{32, 32, 32}));
92 EXPECT_EQ(res[2], (dims_type{64, 64, 64}));
93
94 // A case with odd numbers.
95 vdim = {156, 147, 177};
96 cdim = {39, 49, 59}; // Should result in (4, 3, 3) small chunks.
97 res = sperr::coarsened_resolutions(vdim, cdim);
98 EXPECT_EQ(res.size(), 3);
99 EXPECT_EQ(res[0], (dims_type{20, 21, 24}));
100 EXPECT_EQ(res[1], (dims_type{40, 39, 45}));
101 EXPECT_EQ(res[2], (dims_type{80, 75, 90}));
102 }
103
104 TEST(sperr_helper, approx_detail_len)
105 {
106 auto len = sperr::calc_approx_detail_len(7, 0);
107 EXPECT_EQ(len[0], 7);
108 EXPECT_EQ(len[1], 0);
109 len = sperr::calc_approx_detail_len(7, 1);
110 EXPECT_EQ(len[0], 4);
111 EXPECT_EQ(len[1], 3);
112 len = sperr::calc_approx_detail_len(8, 1);
113 EXPECT_EQ(len[0], 4);
114 EXPECT_EQ(len[1], 4);
115 len = sperr::calc_approx_detail_len(8, 2);
116 EXPECT_EQ(len[0], 2);
117 EXPECT_EQ(len[1], 2);
118 len = sperr::calc_approx_detail_len(16, 2);
119 EXPECT_EQ(len[0], 4);
120 EXPECT_EQ(len[1], 4);
121 }
122
123 TEST(sperr_helper, bit_packing)
124 {
125 const size_t num_of_bytes = 11;
126 const size_t byte_offset = 1;
127 std::vector<bool> input{true, true, true, true, true, true, true, true, // 1st byte
128 false, false, false, false, false, false, false, false, // 2nd byte
129 true, false, true, false, true, false, true, false, // 3rd byte
130 false, true, false, true, false, true, false, true, // 4th byte
131 true, true, false, false, true, true, false, false, // 5th byte
132 false, false, true, true, false, false, true, true, // 6th byte
133 false, false, true, true, false, false, true, false, // 7th byte
134 true, false, false, false, true, true, true, false, // 8th byte
135 false, false, false, true, false, false, false, true, // 9th byte
136 true, true, true, false, true, true, true, false, // 10th byte
137 false, false, true, true, true, false, false, true}; // 11th byte
138
139 auto bytes = sperr::vec8_type(num_of_bytes + byte_offset);
140
141 // Pack booleans
142 auto rtn1 = sperr::pack_booleans(bytes, input, byte_offset);
143 EXPECT_EQ(rtn1, sperr::RTNType::Good);
144 // Unpack booleans
145 auto output = std::vector<bool>(num_of_bytes * 8);
146 auto rtn2 = sperr::unpack_booleans(output, bytes.data(), bytes.size(), byte_offset);
147 EXPECT_EQ(rtn2, sperr::RTNType::Good);
148
149 if (rtn1 == sperr::RTNType::Good && rtn1 == rtn2) {
150 for (size_t i = 0; i < input.size(); i++)
151 EXPECT_EQ(input[i], output[i]);
152 }
153 }
154
155 TEST(sperr_helper, bit_packing_one_byte)
156 {
157 // All true
158 auto input = std::array<bool, 8>{true, true, true, true, true, true, true, true};
159 // Pack booleans
160 auto byte = sperr::pack_8_booleans(input);
161 // Unpack booleans
162 auto output = sperr::unpack_8_booleans(byte);
163 for (size_t i = 0; i < 8; i++)
164 EXPECT_EQ(input[i], output[i]);
165
166 // Odd locations false
167 for (size_t i = 1; i < 8; i += 2)
168 input[i] = false;
169 byte = sperr::pack_8_booleans(input);
170 output = sperr::unpack_8_booleans(byte);
171 for (size_t i = 0; i < 8; i++)
172 EXPECT_EQ(input[i], output[i]);
173
174 // All false
175 for (bool& val : input)
176 val = false;
177 byte = sperr::pack_8_booleans(input);
178 output = sperr::unpack_8_booleans(byte);
179 for (size_t i = 0; i < 8; i++)
180 EXPECT_EQ(input[i], output[i]);
181
182 // Odd locations true
183 for (size_t i = 1; i < 8; i += 2)
184 input[i] = true;
185 byte = sperr::pack_8_booleans(input);
186 output = sperr::unpack_8_booleans(byte);
187 for (size_t i = 0; i < 8; i++)
188 EXPECT_EQ(input[i], output[i]);
189 }
190
191 TEST(sperr_helper, bit_packing_1032_bools)
192 {
193 const size_t num_of_bits = 1032; // 1024 + 8, so the last stride is partial.
194 const size_t num_of_bytes = num_of_bits / 8;
195 const size_t byte_offset = 23;
196
197 std::random_device rd; // Will be used to obtain a seed for the random number engine
198 std::mt19937 gen(rd()); // Standard mersenne_twister_engine seeded with rd()
199 std::uniform_int_distribution<> distrib(0, 2);
200 auto input = std::vector<bool>(num_of_bits);
201 auto bytes = sperr::vec8_type(num_of_bytes + byte_offset);
202 for (size_t i = 0; i < num_of_bits; i++)
203 input[i] = distrib(gen);
204
205 // Pack booleans
206 auto rtn1 = sperr::pack_booleans(bytes, input, byte_offset);
207 EXPECT_EQ(rtn1, sperr::RTNType::Good);
208 // Unpack booleans
209 auto output = std::vector<bool>(num_of_bits);
210 auto rtn2 = sperr::unpack_booleans(output, bytes.data(), bytes.size(), byte_offset);
211 EXPECT_EQ(rtn2, sperr::RTNType::Good);
212
213 if (rtn1 == sperr::RTNType::Good && rtn1 == rtn2) {
214 for (size_t i = 0; i < input.size(); i++)
215 EXPECT_EQ(input[i], output[i]);
216 }
217 }
218
219 TEST(sperr_helper, domain_decomposition)
220 {
221 using sperr::dims_type;
222 using cdef = std::array<size_t, 6>; // chunk definition
223
224 auto vol = dims_type{4, 4, 4};
225 auto subd = dims_type{1, 2, 3};
226
227 auto chunks = sperr::chunk_volume(vol, subd);
228 EXPECT_EQ(chunks.size(), 8);
229 EXPECT_EQ(chunks[0], (cdef{0, 1, 0, 2, 0, 4}));
230 EXPECT_EQ(chunks[1], (cdef{1, 1, 0, 2, 0, 4}));
231 EXPECT_EQ(chunks[2], (cdef{2, 1, 0, 2, 0, 4}));
232 EXPECT_EQ(chunks[3], (cdef{3, 1, 0, 2, 0, 4}));
233
234 EXPECT_EQ(chunks[4], (cdef{0, 1, 2, 2, 0, 4}));
235 EXPECT_EQ(chunks[5], (cdef{1, 1, 2, 2, 0, 4}));
236 EXPECT_EQ(chunks[6], (cdef{2, 1, 2, 2, 0, 4}));
237 EXPECT_EQ(chunks[7], (cdef{3, 1, 2, 2, 0, 4}));
238
239 vol = dims_type{4, 4, 1}; // will essentially require a decomposition on a 2D plane.
240 chunks = sperr::chunk_volume(vol, subd);
241 EXPECT_EQ(chunks.size(), 8);
242 EXPECT_EQ(chunks[0], (cdef{0, 1, 0, 2, 0, 1}));
243 EXPECT_EQ(chunks[1], (cdef{1, 1, 0, 2, 0, 1}));
244 EXPECT_EQ(chunks[2], (cdef{2, 1, 0, 2, 0, 1}));
245 EXPECT_EQ(chunks[3], (cdef{3, 1, 0, 2, 0, 1}));
246
247 EXPECT_EQ(chunks[4], (cdef{0, 1, 2, 2, 0, 1}));
248 EXPECT_EQ(chunks[5], (cdef{1, 1, 2, 2, 0, 1}));
249 EXPECT_EQ(chunks[6], (cdef{2, 1, 2, 2, 0, 1}));
250 EXPECT_EQ(chunks[7], (cdef{3, 1, 2, 2, 0, 1}));
251 }
252
253 TEST(sperr_helper, read_sections)
254 {
255 // Create an array, and write to disk.
256 auto vec = std::vector<uint8_t>(256, 0);
257 std::iota(vec.begin(), vec.end(), 0);
258 sperr::write_n_bytes("test.tmp", 256, vec.data());
259 auto buf = sperr::vec8_type();
260
261 // Create a section that exceeds the file size.
262 auto secs = std::vector<size_t>(2, 0);
263 secs.insert(secs.end(), {200, 56});
264 secs.insert(secs.end(), {101, 156});
265 auto rtn = sperr::read_sections("test.tmp", secs, buf);
266 EXPECT_EQ(rtn, sperr::RTNType::WrongLength);
267
268 // Pop out the offending section requests.
269 secs.pop_back();
270 secs.pop_back();
271 rtn = sperr::read_sections("test.tmp", secs, buf);
272 EXPECT_EQ(rtn, sperr::RTNType::Good);
273
274 // Add another section, and try reading them.
275 secs.insert(secs.end(), {30, 5});
276 buf.assign(10, 1);
277 sperr::read_sections("test.tmp", secs, buf);
278 EXPECT_EQ(buf.size(), 71);
279 for (size_t i = 0; i < 10; i++) // First 10 elements should remain the same.
280 EXPECT_EQ(buf[i], 1);
281 for (size_t i = 0; i < 56; i++) // Next 56 elements should start from 200.
282 EXPECT_EQ(buf[i + 10], i + 200);
283 for (size_t i = 0; i < 5; i++) // Next 5 elements should start from 30.
284 EXPECT_EQ(buf[i + 66], i + 30);
285
286 // Test the extract version too. Read and extract should give the same results.
287 buf.clear();
288 sperr::read_sections("test.tmp", secs, buf);
289 auto full_input = sperr::read_whole_file<uint8_t>("test.tmp");
290 auto buf2 = sperr::vec8_type();
291 auto rtn2 = sperr::extract_sections(full_input.data(), full_input.size(), secs, buf2);
292 EXPECT_EQ(rtn, sperr::RTNType::Good);
293 EXPECT_EQ(buf, buf2);
294 }
295
296 } // namespace