Debian Codegraph @

tests/auto/corelib/global/qtendian/tst_qtendian.cpp

raw
1 // Copyright (C) 2021 The Qt Company Ltd.
2 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
3
4
5 #include <QTest>
6 #include <QtCore/qendian.h>
7 #include <QtCore/private/qendian_p.h>
8 #include <QtCore/qsysinfo.h>
9
10 #ifdef QT_SUPPORTS_INT128
11 #define ONLY_INT128(...) __VA_ARGS__
12 #else
13 #define ONLY_INT128(...)
14 #endif
15
16 class tst_QtEndian: public QObject
17 {
18 Q_OBJECT
19 public:
20 enum Signedness {
21 Unsigned,
22 Signed
23 };
24 Q_ENUM(Signedness);
25
26 private slots:
27 void fromBigEndian();
28 void fromLittleEndian();
29 void fromBigEndianRegion_data();
30 void fromBigEndianRegion();
31 void fromLittleEndianRegion_data() { fromBigEndianRegion_data(); }
32 void fromLittleEndianRegion();
33
34 void toBigEndian();
35 void toLittleEndian();
36 void toBigEndianRegion_data() { fromBigEndianRegion_data(); }
37 void toBigEndianRegion();
38 void toLittleEndianRegion_data() { fromBigEndianRegion_data(); }
39 void toLittleEndianRegion();
40
41 void endianIntegers_data();
42 void endianIntegers();
43
44 void endianBitfieldUnions_data();
45 void endianBitfieldUnions();
46 };
47
48 struct TestData
49 {
50 ONLY_INT128(
51 quint128 data128;
52 )
53 quint64 data64;
54 quint32 data32;
55 quint16 data16;
56 quint8 data8;
57
58 float dataFloat;
59 double dataDouble;
60
61 quint8 reserved;
62 };
63
64 template <typename T> T getData(const TestData &d);
65 template <> quint8 getData(const TestData &d) { return d.data8; }
66 template <> quint16 getData(const TestData &d) { return d.data16; }
67 template <> quint32 getData(const TestData &d) { return d.data32; }
68 template <> quint64 getData(const TestData &d) { return d.data64; }
69 ONLY_INT128(
70 template <> quint128 getData(const TestData &d) { return d.data128; }
71 )
72 template <> float getData(const TestData &d) { return d.dataFloat; }
73
74 union RawTestData
75 {
76 uchar rawData[sizeof(TestData)];
77 TestData data;
78 };
79
80 template <typename Float>
81 Float int2Float(typename QIntegerForSizeof<Float>::Unsigned i)
82 {
83 Float result = 0;
84 memcpy(reinterpret_cast<char *>(&result), reinterpret_cast<const char *>(&i), sizeof (Float));
85 return result;
86 }
87
88 static const TestData inNativeEndian = {
89 ONLY_INT128(
90 Q_UINT128_C(0x0123'4567'89ab'cdef'18ba'df00'd1da'cafe),
91 )
92 Q_UINT64_C(0x0123456789abcdef),
93 0x00c0ffee,
94 0xcafe,
95 0xcf,
96 int2Float<float>(0x00c0ffeeU),
97 int2Float<double>(Q_UINT64_C(0x0123456789abcdef)),
98 '\0'
99 };
100 static const RawTestData inBigEndian = {
101 ONLY_INT128(
102 "\x01\x23\x45\x67\x89\xab\xcd\xef\x18\xba\xdf\x00\xd1\xda\xca\xfe"
103 )
104 "\x01\x23\x45\x67\x89\xab\xcd\xef"
105 "\x00\xc0\xff\xee"
106 "\xca\xfe"
107 "\xcf"
108 "\x00\xc0\xff\xee"
109 "\x01\x23\x45\x67\x89\xab\xcd\xef"
110 };
111 static const RawTestData inLittleEndian = {
112 ONLY_INT128(
113 "\xfe\xca\xda\xd1\x00\xdf\xba\x18\xef\xcd\xab\x89\x67\x45\x23\x01"
114 )
115 "\xef\xcd\xab\x89\x67\x45\x23\x01"
116 "\xee\xff\xc0\x00"
117 "\xfe\xca"
118 "\xcf"
119 "\xee\xff\xc0\x00"
120 "\xef\xcd\xab\x89\x67\x45\x23\x01"
121 };
122
123 #define EXPAND_ENDIAN_TEST(endian) \
124 do { \
125 /* Unsigned tests */ \
126 ONLY_INT128( \
127 ENDIAN_TEST_INT(endian, ui, 128); \
128 ) \
129 ENDIAN_TEST_INT(endian, ui, 64); \
130 ENDIAN_TEST_INT(endian, ui, 32); \
131 ENDIAN_TEST_INT(endian, ui, 16); \
132 ENDIAN_TEST_INT(endian, ui, 8); \
133 \
134 /* Signed tests */ \
135 ONLY_INT128( \
136 ENDIAN_TEST_INT(endian, i, 128); \
137 ) \
138 ENDIAN_TEST_INT(endian, i, 64); \
139 ENDIAN_TEST_INT(endian, i, 32); \
140 ENDIAN_TEST_INT(endian, i, 16); \
141 ENDIAN_TEST_INT(endian, i, 8); \
142 } while (false) \
143 /**/
144
145 #define ENDIAN_TEST_INT(Endian, Uns, Size) \
146 ENDIAN_TEST(Endian, q ## Uns ## nt ## Size, data ## Size)
147
148 #define ENDIAN_TEST(endian, Type, Data) \
149 do { \
150 static_assert(std::is_same_v<decltype(qbswap(std::declval<Type>())), Type>); \
151 QCOMPARE(qFrom ## endian ## Endian( \
152 (Type)(in ## endian ## Endian.data.Data)), \
153 (Type)(inNativeEndian.Data)); \
154 QCOMPARE(qFrom ## endian ## Endian<Type>( \
155 in ## endian ## Endian.rawData + offsetof(TestData, Data)), \
156 (Type)(inNativeEndian.Data)); \
157 } while (false) \
158 /**/
159
160 void tst_QtEndian::fromBigEndian()
161 {
162 EXPAND_ENDIAN_TEST(Big);
163 }
164
165 void tst_QtEndian::fromLittleEndian()
166 {
167 EXPAND_ENDIAN_TEST(Little);
168 }
169
170 #undef ENDIAN_TEST
171
172 QT_WARNING_PUSH
173 QT_WARNING_DISABLE_GCC("-Wmemset-elt-size")
174
175 template <typename T>
176 void transformRegion_template(T (*transformOne)(T), void (*transformRegion)(const void *, qsizetype, void *))
177 {
178 enum { Size = 64 };
179 T source[Size];
180 T dest[Size];
181 T expected = transformOne(getData<T>(inNativeEndian));
182 std::fill_n(source, +Size, getData<T>(inNativeEndian));
183 memset(dest, 0, sizeof(dest));
184
185 auto checkBounds = [&](int from) {
186 for ( ; from < Size; ++from)
187 QCOMPARE(dest[from], T(0));
188 };
189
190 transformRegion(source, 1, dest);
191 QCOMPARE(dest[0], expected);
192 checkBounds(1);
193 memset(dest, 0, sizeof(T));
194
195 transformRegion(source, 2, dest);
196 QCOMPARE(dest[0], expected);
197 QCOMPARE(dest[1], expected);
198 checkBounds(2);
199 memset(dest, 0, sizeof(T) * 2);
200
201 transformRegion(source, 3, dest);
202 QCOMPARE(dest[0], expected);
203 QCOMPARE(dest[1], expected);
204 QCOMPARE(dest[2], expected);
205 checkBounds(3);
206 memset(dest, 0, sizeof(T) * 3);
207
208 transformRegion(source, 4, dest);
209 QCOMPARE(dest[0], expected);
210 QCOMPARE(dest[1], expected);
211 QCOMPARE(dest[2], expected);
212 QCOMPARE(dest[3], expected);
213 checkBounds(4);
214 memset(dest, 0, sizeof(T) * 4);
215
216 transformRegion(source, 8, dest);
217 for (int i = 0; i < 8; ++i)
218 QCOMPARE(dest[i], expected);
219 checkBounds(8);
220 memset(dest, 0, sizeof(T) * 8);
221
222 transformRegion(source, 16, dest);
223 for (int i = 0; i < 16; ++i)
224 QCOMPARE(dest[i], expected);
225 checkBounds(16);
226 memset(dest, 0, sizeof(T) * 16);
227
228 transformRegion(source, 32, dest);
229 for (int i = 0; i < 32; ++i)
230 QCOMPARE(dest[i], expected);
231 checkBounds(32);
232 memset(dest, 0, sizeof(T) * 32);
233
234 transformRegion(source, 64, dest);
235 for (int i = 0; i < 64; ++i)
236 QCOMPARE(dest[i], expected);
237
238 // check transforming in-place
239 memcpy(dest, source, sizeof(dest));
240 transformRegion(dest, 64, dest);
241 for (int i = 0; i < 64; ++i)
242 QCOMPARE(dest[i], expected);
243 }
244 QT_WARNING_POP
245
246 void tst_QtEndian::fromBigEndianRegion_data()
247 {
248 QTest::addColumn<int>("size");
249 QTest::newRow("1") << 1;
250 QTest::newRow("2") << 2;
251 QTest::newRow("4") << 4;
252 QTest::newRow("8") << 8;
253 }
254
255 void tst_QtEndian::fromBigEndianRegion()
256 {
257 QFETCH(int, size);
258 switch (size) {
259 case 1: return transformRegion_template<quint8>(qFromBigEndian<quint8>, qFromBigEndian<quint8>);
260 case 2: return transformRegion_template<quint16>(qFromBigEndian<quint16>, qFromBigEndian<quint16>);
261 case 4: return transformRegion_template<quint32>(qFromBigEndian<quint32>, qFromBigEndian<quint32>);
262 case 8: return transformRegion_template<quint64>(qFromBigEndian<quint64>, qFromBigEndian<quint64>);
263 }
264 }
265
266 void tst_QtEndian::fromLittleEndianRegion()
267 {
268 QFETCH(int, size);
269 switch (size) {
270 case 1: return transformRegion_template<quint8>(qFromLittleEndian<quint8>, qFromLittleEndian<quint8>);
271 case 2: return transformRegion_template<quint16>(qFromLittleEndian<quint16>, qFromLittleEndian<quint16>);
272 case 4: return transformRegion_template<quint32>(qFromLittleEndian<quint32>, qFromLittleEndian<quint32>);
273 case 8: return transformRegion_template<quint64>(qFromLittleEndian<quint64>, qFromLittleEndian<quint64>);
274 }
275 }
276
277 #define ENDIAN_TEST(endian, Type, Data) \
278 do { \
279 QCOMPARE(qTo ## endian ## Endian( \
280 (Type)(inNativeEndian.Data)), \
281 (Type)(in ## endian ## Endian.data.Data)); \
282 \
283 RawTestData test; \
284 qTo ## endian ## Endian( \
285 (Type)(inNativeEndian.Data), \
286 test.rawData + offsetof(TestData, Data)); \
287 QCOMPARE(test.data.Data, in ## endian ## Endian.data.Data ); \
288 } while (false) \
289 /**/
290
291 void tst_QtEndian::toBigEndian()
292 {
293 EXPAND_ENDIAN_TEST(Big);
294 }
295
296 void tst_QtEndian::toLittleEndian()
297 {
298 EXPAND_ENDIAN_TEST(Little);
299 }
300
301 #undef ENDIAN_TEST
302
303 void tst_QtEndian::toBigEndianRegion()
304 {
305 QFETCH(int, size);
306 switch (size) {
307 case 1: return transformRegion_template<quint8>(qToBigEndian<quint8>, qToBigEndian<quint8>);
308 case 2: return transformRegion_template<quint16>(qToBigEndian<quint16>, qToBigEndian<quint16>);
309 case 4: return transformRegion_template<quint32>(qToBigEndian<quint32>, qToBigEndian<quint32>);
310 case 8: return transformRegion_template<quint64>(qToBigEndian<quint64>, qToBigEndian<quint64>);
311 }
312 }
313
314 void tst_QtEndian::toLittleEndianRegion()
315 {
316 QFETCH(int, size);
317 switch (size) {
318 case 1: return transformRegion_template<quint8>(qToLittleEndian<quint8>, qToLittleEndian<quint8>);
319 case 2: return transformRegion_template<quint16>(qToLittleEndian<quint16>, qToLittleEndian<quint16>);
320 case 4: return transformRegion_template<quint32>(qToLittleEndian<quint32>, qToLittleEndian<quint32>);
321 case 8: return transformRegion_template<quint64>(qToLittleEndian<quint64>, qToLittleEndian<quint64>);
322 }
323 }
324
325 void tst_QtEndian::endianIntegers_data()
326 {
327 QTest::addColumn<int>("val");
328
329 QTest::newRow("-30000") << -30000;
330 QTest::newRow("-1") << -1;
331 QTest::newRow("0") << 0;
332 QTest::newRow("1020") << 1020;
333 QTest::newRow("16385") << 16385;
334 }
335
336 void tst_QtEndian::endianIntegers()
337 {
338 QFETCH(int, val);
339
340 qint16 vi16 = val;
341 qint32 vi32 = val;
342 qint64 vi64 = val;
343 quint16 vu16 = val;
344 quint32 vu32 = val;
345 quint64 vu64 = val;
346
347 #if Q_BYTE_ORDER == Q_BIG_ENDIAN
348 QCOMPARE(*reinterpret_cast<qint16_be*>(&vi16), vi16);
349 QCOMPARE(*reinterpret_cast<qint32_be*>(&vi32), vi32);
350 QCOMPARE(*reinterpret_cast<qint64_be*>(&vi64), vi64);
351 QCOMPARE(*reinterpret_cast<qint16_le*>(&vi16), qbswap(vi16));
352 QCOMPARE(*reinterpret_cast<qint32_le*>(&vi32), qbswap(vi32));
353 QCOMPARE(*reinterpret_cast<qint64_le*>(&vi64), qbswap(vi64));
354 QCOMPARE(*reinterpret_cast<quint16_be*>(&vu16), vu16);
355 QCOMPARE(*reinterpret_cast<quint32_be*>(&vu32), vu32);
356 QCOMPARE(*reinterpret_cast<quint64_be*>(&vu64), vu64);
357 QCOMPARE(*reinterpret_cast<quint16_le*>(&vu16), qbswap(vu16));
358 QCOMPARE(*reinterpret_cast<quint32_le*>(&vu32), qbswap(vu32));
359 QCOMPARE(*reinterpret_cast<quint64_le*>(&vu64), qbswap(vu64));
360 #else
361 QCOMPARE(*reinterpret_cast<qint16_be*>(&vi16), qbswap(vi16));
362 QCOMPARE(*reinterpret_cast<qint32_be*>(&vi32), qbswap(vi32));
363 QCOMPARE(*reinterpret_cast<qint64_be*>(&vi64), qbswap(vi64));
364 QCOMPARE(*reinterpret_cast<qint16_le*>(&vi16), vi16);
365 QCOMPARE(*reinterpret_cast<qint32_le*>(&vi32), vi32);
366 QCOMPARE(*reinterpret_cast<qint64_le*>(&vi64), vi64);
367 QCOMPARE(*reinterpret_cast<quint16_be*>(&vu16), qbswap(vu16));
368 QCOMPARE(*reinterpret_cast<quint32_be*>(&vu32), qbswap(vu32));
369 QCOMPARE(*reinterpret_cast<quint64_be*>(&vu64), qbswap(vu64));
370 QCOMPARE(*reinterpret_cast<quint16_le*>(&vu16), vu16);
371 QCOMPARE(*reinterpret_cast<quint32_le*>(&vu32), vu32);
372 QCOMPARE(*reinterpret_cast<quint64_le*>(&vu64), vu64);
373 #endif
374 }
375
376 template<template<typename... Accessors> typename Union, template<int, int, typename> typename Member>
377 void testBitfieldUnion()
378 {
379 using upper = Member<21, 11, uint>;
380 using lower = Member<10, 11, uint>;
381 using bottom = Member<0, 10, int>;
382 using all = Member<0, 32, uint>;
383
384 using UnionType = Union<upper, lower, bottom, all>;
385 UnionType u;
386
387 u.template set<upper>(200);
388 QCOMPARE(u.template get<upper>(), 200U);
389 u.template set<lower>(1000);
390 u.template set<bottom>(-8);
391 QCOMPARE(u.template get<lower>(), 1000U);
392 QCOMPARE(u.template get<upper>(), 200U);
393
394 u.template set<lower>(u.template get<lower>() + u.template get<upper>());
395 QCOMPARE(u.template get<upper>(), 200U);
396 QCOMPARE(u.template get<lower>(), 1200U);
397
398 u.template set<upper>(65536 + 7);
399 u.template set<lower>(65535);
400 QCOMPARE(u.template get<lower>(), 65535U & ((1<<11) - 1));
401 QCOMPARE(u.template get<upper>(), 7U);
402
403 QCOMPARE(u.template get<bottom>(), -8);
404
405 UnionType u2(QSpecialIntegerBitfieldZero);
406 QCOMPARE(u2.data(), 0U);
407
408 u2.template set<all>(std::numeric_limits<uint>::max());
409 QCOMPARE(u2.template get<all>(), std::numeric_limits<uint>::max());
410
411 u2.template set<all>(453);
412 QCOMPARE(u2.template get<all>(), 453U);
413
414 u2.template set<all>(0);
415 QCOMPARE(u2.template get<all>(), 0U);
416
417 UnionType u3(42U);
418 QCOMPARE(u3.data(), 42U);
419
420 using BEUintAccessor = QSpecialIntegerAccessor<QBigEndianStorageType<uint>, 21, 11>;
421 using LEUintAccessor = QSpecialIntegerAccessor<QLittleEndianStorageType<uint>, 21, 11>;
422 using BEIntAccessor = QSpecialIntegerAccessor<QBigEndianStorageType<int>, 0, 10>;
423 using LEIntAccessor = QSpecialIntegerAccessor<QLittleEndianStorageType<int>, 0, 10>;
424
425 if constexpr (std::is_same_v<BEUintAccessor, upper>) {
426 QCOMPARE(u.template get<BEUintAccessor>(), 7U);
427 } else if constexpr (std::is_same_v<LEUintAccessor, upper>) {
428 QCOMPARE(u.template get<LEUintAccessor>(), 7U);
429 } else if constexpr (std::is_same_v<BEIntAccessor, bottom>) {
430 QCOMPARE(u.template get<BEIntAccessor>(), -8);
431 } else if constexpr (std::is_same_v<LEIntAccessor, bottom>) {
432 QCOMPARE(u.template get<LEIntAccessor>(), -8);
433 } else {
434 QFAIL("none of the manually defined accessors match");
435 }
436 }
437
438 void tst_QtEndian::endianBitfieldUnions_data()
439 {
440 QTest::addColumn<QSysInfo::Endian>("byteOrder");
441 QTest::addColumn<Signedness>("signedness");
442
443 QTest::addRow("little endian unsigned") << QSysInfo::LittleEndian << Unsigned;
444 QTest::addRow("little endian signed") << QSysInfo::LittleEndian << Signed;
445 QTest::addRow("big endian unsigned") << QSysInfo::BigEndian << Unsigned;
446 QTest::addRow("big endian signed") << QSysInfo::BigEndian << Signed;
447 }
448
449 void tst_QtEndian::endianBitfieldUnions()
450 {
451 QFETCH(QSysInfo::Endian, byteOrder);
452 QFETCH(Signedness, signedness);
453
454 switch (byteOrder) {
455 case QSysInfo::LittleEndian:
456 switch (signedness) {
457 case Unsigned:
458 testBitfieldUnion<quint32_le_bitfield_union, quint32_le_bitfield_member>();
459 return;
460 case Signed:
461 testBitfieldUnion<qint32_le_bitfield_union, qint32_le_bitfield_member>();
462 return;
463 }
464 Q_UNREACHABLE_RETURN();
465 case QSysInfo::BigEndian:
466 switch (signedness) {
467 case Unsigned:
468 testBitfieldUnion<quint32_be_bitfield_union, quint32_be_bitfield_member>();
469 return;
470 case Signed:
471 testBitfieldUnion<qint32_be_bitfield_union, qint32_be_bitfield_member>();
472 return;
473 }
474 Q_UNREACHABLE_RETURN();
475 }
476 }
477
478
479 QTEST_MAIN(tst_QtEndian)
480 #include "tst_qtendian.moc"