| 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" |