Debian Codegraph @

src/mpt/io/tests/tests_io.hpp

raw
1 /* SPDX-License-Identifier: BSL-1.0 OR BSD-3-Clause */
2
3 #ifndef MPT_IO_TESTS_IO_HPP
4 #define MPT_IO_TESTS_IO_HPP
5
6
7
8 #include "mpt/base/alloc.hpp"
9 #include "mpt/base/integer.hpp"
10 #include "mpt/base/namespace.hpp"
11 #include "mpt/base/utility.hpp"
12 #include "mpt/endian/integer.hpp"
13 #include "mpt/io/base.hpp"
14 #include "mpt/io/io.hpp"
15 #include "mpt/io/io_stdstream.hpp"
16 #include "mpt/test/test.hpp"
17 #include "mpt/test/test_macros.hpp"
18
19 #include <ios>
20 #include <sstream>
21 #include <string>
22 #include <vector>
23
24 #include <cstddef>
25
26
27
28 namespace mpt {
29 inline namespace MPT_INLINE_NS {
30
31
32
33 namespace tests {
34 namespace io {
35
36 #if MPT_COMPILER_CLANG
37 #pragma clang diagnostic push
38 #pragma clang diagnostic ignored "-Wglobal-constructors"
39 #endif
40 MPT_TEST_GROUP_INLINE("mpt/io")
41 #if MPT_COMPILER_CLANG
42 #pragma clang diagnostic pop
43 #endif
44 {
45
46 // check that empty stringstream behaves correctly with our MSVC workarounds when using iostream interface directly
47
48 {
49 std::ostringstream ss;
50 MPT_TEST_EXPECT_EQUAL(static_cast<std::streamoff>(ss.tellp()), std::streamoff(0));
51 }
52 {
53 std::ostringstream ss;
54 ss.seekp(0);
55 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekAbsolute(ss, 0), true);
56 }
57 {
58 std::ostringstream ss;
59 ss.seekp(0, std::ios_base::beg);
60 MPT_TEST_EXPECT_EQUAL(!ss.fail(), true);
61 }
62 {
63 std::ostringstream ss;
64 ss.seekp(0, std::ios_base::cur);
65 MPT_TEST_EXPECT_EQUAL(!ss.fail(), true);
66 }
67 {
68 std::istringstream ss;
69 MPT_TEST_EXPECT_EQUAL(static_cast<std::streamoff>(ss.tellg()), std::streamoff(0));
70 }
71 {
72 std::istringstream ss;
73 ss.seekg(0, std::ios::beg);
74 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekAbsolute(ss, 0), true);
75 }
76 {
77 std::istringstream ss;
78 ss.seekg(0, std::ios_base::beg);
79 MPT_TEST_EXPECT_EQUAL(!ss.fail(), true);
80 }
81 {
82 std::istringstream ss;
83 ss.seekg(0, std::ios_base::cur);
84 MPT_TEST_EXPECT_EQUAL(!ss.fail(), true);
85 }
86
87 {
88 std::ostringstream s;
89 char b = 23;
90 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
91 MPT_TEST_EXPECT_EQUAL(static_cast<std::streamoff>(s.tellp()), std::streamoff(0));
92 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
93 s.seekp(0, std::ios_base::beg);
94 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
95 MPT_TEST_EXPECT_EQUAL(static_cast<std::streamoff>(s.tellp()), std::streamoff(0));
96 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
97 s.write(&b, 1);
98 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
99 MPT_TEST_EXPECT_EQUAL(static_cast<std::streamoff>(s.tellp()), std::streamoff(1));
100 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
101 s.seekp(0, std::ios_base::beg);
102 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
103 MPT_TEST_EXPECT_EQUAL(static_cast<std::streamoff>(s.tellp()), std::streamoff(0));
104 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
105 s.seekp(0, std::ios_base::end);
106 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
107 MPT_TEST_EXPECT_EQUAL(static_cast<std::streamoff>(s.tellp()), std::streamoff(1));
108 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
109 MPT_TEST_EXPECT_EQUAL(s.str(), std::string(1, b));
110 }
111
112 {
113 std::istringstream s;
114 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
115 MPT_TEST_EXPECT_EQUAL(static_cast<std::streamoff>(s.tellg()), std::streamoff(0));
116 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
117 s.seekg(0, std::ios_base::beg);
118 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
119 MPT_TEST_EXPECT_EQUAL(static_cast<std::streamoff>(s.tellg()), std::streamoff(0));
120 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
121 s.seekg(0, std::ios_base::end);
122 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
123 MPT_TEST_EXPECT_EQUAL(static_cast<std::streamoff>(s.tellg()), std::streamoff(0));
124 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
125 }
126
127 {
128 std::istringstream s("a");
129 char a = 0;
130 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
131 MPT_TEST_EXPECT_EQUAL(static_cast<std::streamoff>(s.tellg()), std::streamoff(0));
132 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
133 s.seekg(0, std::ios_base::beg);
134 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
135 MPT_TEST_EXPECT_EQUAL(static_cast<std::streamoff>(s.tellg()), std::streamoff(0));
136 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
137 s.read(&a, 1);
138 MPT_TEST_EXPECT_EQUAL(a, 'a');
139 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
140 MPT_TEST_EXPECT_EQUAL(static_cast<std::streamoff>(s.tellg()), std::streamoff(1));
141 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
142 s.seekg(0, std::ios_base::beg);
143 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
144 MPT_TEST_EXPECT_EQUAL(static_cast<std::streamoff>(s.tellg()), std::streamoff(0));
145 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
146 s.seekg(0, std::ios_base::end);
147 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
148 MPT_TEST_EXPECT_EQUAL(static_cast<std::streamoff>(s.tellg()), std::streamoff(1));
149 MPT_TEST_EXPECT_EQUAL(!s.fail(), true);
150 MPT_TEST_EXPECT_EQUAL(std::string(1, a), std::string(1, 'a'));
151 }
152
153 // check that empty native and fixed stringstream both behaves correctly with out IO functions
154
155 {
156 std::ostringstream ss;
157 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellWrite(ss), 0);
158 }
159 {
160 std::ostringstream ss;
161 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekBegin(ss), true);
162 }
163 {
164 std::ostringstream ss;
165 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekAbsolute(ss, 0), true);
166 }
167 {
168 std::ostringstream ss;
169 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekRelative(ss, 0), true);
170 }
171 {
172 std::istringstream ss;
173 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellRead(ss), 0);
174 }
175 {
176 std::istringstream ss;
177 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekBegin(ss), true);
178 }
179 {
180 std::istringstream ss;
181 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekAbsolute(ss, 0), true);
182 }
183 {
184 std::istringstream ss;
185 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekRelative(ss, 0), true);
186 }
187
188 {
189 std::ostringstream ss;
190 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellWrite(ss), 0);
191 }
192 {
193 std::ostringstream ss;
194 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekBegin(ss), true);
195 }
196 {
197 std::ostringstream ss;
198 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekAbsolute(ss, 0), true);
199 }
200 {
201 std::ostringstream ss;
202 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekRelative(ss, 0), true);
203 }
204 {
205 std::istringstream ss;
206 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellRead(ss), 0);
207 }
208 {
209 std::istringstream ss;
210 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekBegin(ss), true);
211 }
212 {
213 std::istringstream ss;
214 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekAbsolute(ss, 0), true);
215 }
216 {
217 std::istringstream ss;
218 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekRelative(ss, 0), true);
219 }
220
221 {
222 std::ostringstream s;
223 char b = 23;
224 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
225 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellWrite(s), 0);
226 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
227 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekBegin(s), true);
228 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
229 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellWrite(s), 0);
230 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
231 MPT_TEST_EXPECT_EQUAL(mpt::IO::WriteRaw(s, &b, 1), true);
232 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
233 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellWrite(s), 1);
234 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
235 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekBegin(s), true);
236 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
237 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellWrite(s), 0);
238 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
239 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekEnd(s), true);
240 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
241 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellWrite(s), 1);
242 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
243 MPT_TEST_EXPECT_EQUAL(s.str(), std::string(1, b));
244 }
245
246 {
247 std::istringstream s;
248 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
249 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellRead(s), 0);
250 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
251 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekBegin(s), true);
252 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
253 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellRead(s), 0);
254 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
255 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekEnd(s), true);
256 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
257 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellRead(s), 0);
258 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
259 }
260
261 {
262 std::istringstream s("a");
263 char a = 0;
264 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
265 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellRead(s), 0);
266 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
267 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekBegin(s), true);
268 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
269 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellRead(s), 0);
270 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
271 MPT_TEST_EXPECT_EQUAL(mpt::IO::ReadRaw(s, &a, 1).size(), 1u);
272 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
273 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellRead(s), 1);
274 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
275 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekBegin(s), true);
276 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
277 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellRead(s), 0);
278 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
279 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekEnd(s), true);
280 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
281 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellRead(s), 1);
282 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
283 MPT_TEST_EXPECT_EQUAL(std::string(1, a), std::string(1, 'a'));
284 }
285
286 {
287 std::ostringstream s;
288 char b = 23;
289 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
290 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellWrite(s), 0);
291 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
292 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekBegin(s), true);
293 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
294 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellWrite(s), 0);
295 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
296 MPT_TEST_EXPECT_EQUAL(mpt::IO::WriteRaw(s, &b, 1), true);
297 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
298 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellWrite(s), 1);
299 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
300 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekBegin(s), true);
301 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
302 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellWrite(s), 0);
303 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
304 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekEnd(s), true);
305 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
306 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellWrite(s), 1);
307 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
308 MPT_TEST_EXPECT_EQUAL(s.str(), std::string(1, b));
309 }
310
311 {
312 std::istringstream s;
313 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
314 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellRead(s), 0);
315 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
316 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekBegin(s), true);
317 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
318 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellRead(s), 0);
319 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
320 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekEnd(s), true);
321 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
322 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellRead(s), 0);
323 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
324 }
325
326 {
327 std::istringstream s("a");
328 char a = 0;
329 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
330 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellRead(s), 0);
331 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
332 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekBegin(s), true);
333 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
334 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellRead(s), 0);
335 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
336 MPT_TEST_EXPECT_EQUAL(mpt::IO::ReadRaw(s, &a, 1).size(), 1u);
337 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
338 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellRead(s), 1);
339 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
340 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekBegin(s), true);
341 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
342 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellRead(s), 0);
343 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
344 MPT_TEST_EXPECT_EQUAL(mpt::IO::SeekEnd(s), true);
345 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
346 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellRead(s), 1);
347 MPT_TEST_EXPECT_EQUAL(mpt::IO::IsValid(s), true);
348 MPT_TEST_EXPECT_EQUAL(std::string(1, a), std::string(1, 'a'));
349 }
350
351 // General file I/O tests
352 {
353 // Verify that writing arrays does not confuse the compiler.
354 // This is both, compile-time and run-time cheking.
355 // Run-time in case some weird compiler gets confused by our templates
356 // and only writes the first array element.
357 std::ostringstream f;
358 mpt::uint16be data[2];
359 mpt::reset(data);
360 data[0] = 0x1234;
361 data[1] = 0x5678;
362 mpt::IO::Write(f, data);
363 MPT_TEST_EXPECT_EQUAL(f.str(), std::string("\x12\x34\x56\x78"));
364 }
365 {
366 std::ostringstream f;
367 std::vector<mpt::int16be> data;
368 data.resize(3);
369 data[0] = 0x1234;
370 data[1] = 0x5678;
371 data[2] = 0x1234;
372 mpt::IO::Write(f, data);
373 MPT_TEST_EXPECT_EQUAL(f.str(), std::string("\x12\x34\x56\x78\x12\x34"));
374 }
375 {
376 std::ostringstream f;
377 mpt::int16be data[3];
378 mpt::reset(data);
379 data[0] = 0x1234;
380 data[1] = 0x5678;
381 data[2] = 0x1234;
382 mpt::IO::Write(f, data);
383 MPT_TEST_EXPECT_EQUAL(f.str(), std::string("\x12\x34\x56\x78\x12\x34"));
384 }
385
386 {
387 auto TestAdaptive16 = [&](uint16 value, mpt::IO::Offset expected_size, std::size_t fixedSize, const char * bytes) {
388 std::stringstream f;
389 MPT_TEST_EXPECT_EQUAL(mpt::IO::WriteAdaptiveInt16LE(f, value, fixedSize), true);
390 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellWrite(f), expected_size);
391 if (bytes) {
392 mpt::IO::SeekBegin(f);
393 for (mpt::IO::Offset i = 0; i < expected_size; ++i) {
394 uint8 val = 0;
395 mpt::IO::ReadIntLE<uint8>(f, val);
396 MPT_TEST_EXPECT_EQUAL(val, static_cast<uint8>(bytes[i]));
397 }
398 }
399 mpt::IO::SeekBegin(f);
400 uint16 result = 0;
401 MPT_TEST_EXPECT_EQUAL(mpt::IO::ReadAdaptiveInt16LE(f, result), true);
402 MPT_TEST_EXPECT_EQUAL(result, value);
403 };
404 auto TestAdaptive32 = [&](uint32 value, mpt::IO::Offset expected_size, std::size_t fixedSize, const char * bytes) {
405 std::stringstream f;
406 MPT_TEST_EXPECT_EQUAL(mpt::IO::WriteAdaptiveInt32LE(f, value, fixedSize), true);
407 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellWrite(f), expected_size);
408 if (bytes) {
409 mpt::IO::SeekBegin(f);
410 for (mpt::IO::Offset i = 0; i < expected_size; ++i) {
411 uint8 val = 0;
412 mpt::IO::ReadIntLE<uint8>(f, val);
413 MPT_TEST_EXPECT_EQUAL(val, static_cast<uint8>(bytes[i]));
414 }
415 }
416 mpt::IO::SeekBegin(f);
417 uint32 result = 0;
418 MPT_TEST_EXPECT_EQUAL(mpt::IO::ReadAdaptiveInt32LE(f, result), true);
419 MPT_TEST_EXPECT_EQUAL(result, value);
420 };
421 auto TestAdaptive64 = [&](uint64 value, mpt::IO::Offset expected_size, std::size_t fixedSize, const char * bytes) {
422 std::stringstream f;
423 MPT_TEST_EXPECT_EQUAL(mpt::IO::WriteAdaptiveInt64LE(f, value, fixedSize), true);
424 MPT_TEST_EXPECT_EQUAL(mpt::IO::TellWrite(f), expected_size);
425 if (bytes) {
426 mpt::IO::SeekBegin(f);
427 for (mpt::IO::Offset i = 0; i < expected_size; ++i) {
428 uint8 val = 0;
429 mpt::IO::ReadIntLE<uint8>(f, val);
430 MPT_TEST_EXPECT_EQUAL(val, static_cast<uint8>(bytes[i]));
431 }
432 }
433 mpt::IO::SeekBegin(f);
434 uint64 result = 0;
435 MPT_TEST_EXPECT_EQUAL(mpt::IO::ReadAdaptiveInt64LE(f, result), true);
436 MPT_TEST_EXPECT_EQUAL(result, value);
437 };
438 TestAdaptive16(0, 1, 0, "\x00");
439 TestAdaptive16(1, 1, 0, "\x02");
440 TestAdaptive16(2, 1, 0, nullptr);
441 TestAdaptive16(0x7f, 1, 0, nullptr);
442 TestAdaptive16(0x80, 2, 0, "\x01\x01");
443 TestAdaptive16(0x81, 2, 0, "\x03\x01");
444 TestAdaptive16(0x7fff, 2, 0, "\xff\xff");
445 TestAdaptive16(0, 1, 1, nullptr);
446 TestAdaptive16(1, 1, 1, nullptr);
447 TestAdaptive16(2, 1, 1, nullptr);
448 TestAdaptive16(0x7f, 1, 1, nullptr);
449 TestAdaptive16(0x80, 2, 0, nullptr);
450 TestAdaptive16(0x81, 2, 0, nullptr);
451 TestAdaptive16(0x7fff, 2, 0, nullptr);
452 TestAdaptive16(0, 2, 2, "\x01\x00");
453 TestAdaptive16(1, 2, 2, "\x03\x00");
454 TestAdaptive16(2, 2, 2, nullptr);
455 TestAdaptive16(0x7f, 2, 2, nullptr);
456 TestAdaptive16(0x80, 2, 2, nullptr);
457 TestAdaptive16(0x81, 2, 2, nullptr);
458 TestAdaptive16(0x7fff, 2, 2, nullptr);
459
460 TestAdaptive32(0, 1, 0, "\x00");
461 TestAdaptive32(1, 1, 0, nullptr);
462 TestAdaptive32(2, 1, 0, nullptr);
463 TestAdaptive32(0x3f, 1, 0, nullptr);
464 TestAdaptive32(0x40, 2, 0, "\x01\x01");
465 TestAdaptive32(0x41, 2, 0, "\x05\x01");
466 TestAdaptive32(0x7f, 2, 0, nullptr);
467 TestAdaptive32(0x80, 2, 0, nullptr);
468 TestAdaptive32(0x3fff, 2, 0, nullptr);
469 TestAdaptive32(0x4000, 3, 0, "\x02\x00\x01");
470 TestAdaptive32(0x4001, 3, 0, nullptr);
471 TestAdaptive32(0x3fffff, 3, 0, nullptr);
472 TestAdaptive32(0x400000, 4, 0, "\x03\x00\x00\x01");
473 TestAdaptive32(0x400001, 4, 0, nullptr);
474 TestAdaptive32(0x3fffffff, 4, 0, "\xff\xff\xff\xff");
475 TestAdaptive32(0, 2, 2, nullptr);
476 TestAdaptive32(1, 2, 2, nullptr);
477 TestAdaptive32(2, 2, 2, nullptr);
478 TestAdaptive32(0x3f, 2, 2, nullptr);
479 TestAdaptive32(0x40, 2, 2, nullptr);
480 TestAdaptive32(0x41, 2, 2, nullptr);
481 TestAdaptive32(0x7f, 2, 2, nullptr);
482 TestAdaptive32(0x80, 2, 2, nullptr);
483 TestAdaptive32(0x3fff, 2, 2, nullptr);
484 TestAdaptive32(0, 3, 3, nullptr);
485 TestAdaptive32(1, 3, 3, nullptr);
486 TestAdaptive32(2, 3, 3, nullptr);
487 TestAdaptive32(0x3f, 3, 3, nullptr);
488 TestAdaptive32(0x40, 3, 3, nullptr);
489 TestAdaptive32(0x41, 3, 3, nullptr);
490 TestAdaptive32(0x7f, 3, 3, nullptr);
491 TestAdaptive32(0x80, 3, 3, nullptr);
492 TestAdaptive32(0x3fff, 3, 3, nullptr);
493 TestAdaptive32(0x4000, 3, 3, nullptr);
494 TestAdaptive32(0x4001, 3, 3, nullptr);
495 TestAdaptive32(0x3fffff, 3, 3, nullptr);
496 TestAdaptive32(0, 4, 4, nullptr);
497 TestAdaptive32(1, 4, 4, nullptr);
498 TestAdaptive32(2, 4, 4, nullptr);
499 TestAdaptive32(0x3f, 4, 4, nullptr);
500 TestAdaptive32(0x40, 4, 4, nullptr);
501 TestAdaptive32(0x41, 4, 4, nullptr);
502 TestAdaptive32(0x7f, 4, 4, nullptr);
503 TestAdaptive32(0x80, 4, 4, nullptr);
504 TestAdaptive32(0x3fff, 4, 4, nullptr);
505 TestAdaptive32(0x4000, 4, 4, nullptr);
506 TestAdaptive32(0x4001, 4, 4, nullptr);
507 TestAdaptive32(0x3fffff, 4, 4, nullptr);
508 TestAdaptive32(0x400000, 4, 4, nullptr);
509 TestAdaptive32(0x400001, 4, 4, nullptr);
510 TestAdaptive32(0x3fffffff, 4, 4, nullptr);
511
512 TestAdaptive64(0, 1, 0, nullptr);
513 TestAdaptive64(1, 1, 0, nullptr);
514 TestAdaptive64(2, 1, 0, nullptr);
515 TestAdaptive64(0x3f, 1, 0, nullptr);
516 TestAdaptive64(0x40, 2, 0, nullptr);
517 TestAdaptive64(0x41, 2, 0, nullptr);
518 TestAdaptive64(0x7f, 2, 0, nullptr);
519 TestAdaptive64(0x80, 2, 0, nullptr);
520 TestAdaptive64(0x3fff, 2, 0, nullptr);
521 TestAdaptive64(0x4000, 4, 0, nullptr);
522 TestAdaptive64(0x4001, 4, 0, nullptr);
523 TestAdaptive64(0x3fffff, 4, 0, nullptr);
524 TestAdaptive64(0x400000, 4, 0, nullptr);
525 TestAdaptive64(0x400001, 4, 0, nullptr);
526 TestAdaptive64(0x3fffffff, 4, 0, nullptr);
527 TestAdaptive64(0x40000000, 8, 0, nullptr);
528 TestAdaptive64(0x40000001, 8, 0, nullptr);
529 TestAdaptive64(0x3fffffffffffffffull, 8, 0, nullptr);
530 TestAdaptive64(0, 2, 2, nullptr);
531 TestAdaptive64(1, 2, 2, nullptr);
532 TestAdaptive64(2, 2, 2, nullptr);
533 TestAdaptive64(0x3f, 2, 2, nullptr);
534 TestAdaptive64(0, 4, 4, nullptr);
535 TestAdaptive64(1, 4, 4, nullptr);
536 TestAdaptive64(2, 4, 4, nullptr);
537 TestAdaptive64(0x3f, 4, 4, nullptr);
538 TestAdaptive64(0x40, 4, 4, nullptr);
539 TestAdaptive64(0x41, 4, 4, nullptr);
540 TestAdaptive64(0x7f, 4, 4, nullptr);
541 TestAdaptive64(0x80, 4, 4, nullptr);
542 TestAdaptive64(0x3fff, 4, 4, nullptr);
543 TestAdaptive64(0, 8, 8, nullptr);
544 TestAdaptive64(1, 8, 8, nullptr);
545 TestAdaptive64(2, 8, 8, nullptr);
546 TestAdaptive64(0x3f, 8, 8, nullptr);
547 TestAdaptive64(0x40, 8, 8, nullptr);
548 TestAdaptive64(0x41, 8, 8, nullptr);
549 TestAdaptive64(0x7f, 8, 8, nullptr);
550 TestAdaptive64(0x80, 8, 8, nullptr);
551 TestAdaptive64(0x3fff, 8, 8, nullptr);
552 TestAdaptive64(0x4000, 8, 8, nullptr);
553 TestAdaptive64(0x4001, 8, 8, nullptr);
554 TestAdaptive64(0x3fffff, 8, 8, nullptr);
555 TestAdaptive64(0x400000, 8, 8, nullptr);
556 TestAdaptive64(0x400001, 8, 8, nullptr);
557 TestAdaptive64(0x3fffffff, 8, 8, nullptr);
558 TestAdaptive64(0x40000000, 8, 8, nullptr);
559 TestAdaptive64(0x40000001, 8, 8, nullptr);
560 TestAdaptive64(0x3fffffffffffffffull, 8, 8, nullptr);
561 }
562 }
563
564 } // namespace io
565 } // namespace tests
566
567
568
569 } // namespace MPT_INLINE_NS
570 } // namespace mpt
571
572
573
574 #endif // MPT_IO_TESTS_IO_HPP