1//===- unittests/Support/SwapByteOrderTest.cpp - swap byte order test -----===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "llvm/Support/SwapByteOrder.h"
10#include "gtest/gtest.h"
11#include <cstdlib>
12#include <ctime>
13using namespace llvm;
14
15#undef max
16
17namespace {
18
19// In these first two tests all of the original_uintx values are truncated
20// except for 64. We could avoid this, but there's really no point.
21
22TEST(getSwappedBytes, UnsignedRoundTrip) {
23 // The point of the bit twiddling of magic is to test with and without bits
24 // in every byte.
25 uint64_t value = 1;
26 for (std::size_t i = 0; i <= sizeof(value); ++i) {
27 uint8_t original_uint8 = static_cast<uint8_t>(value);
28 EXPECT_EQ(original_uint8,
29 sys::getSwappedBytes(sys::getSwappedBytes(original_uint8)));
30
31 uint16_t original_uint16 = static_cast<uint16_t>(value);
32 EXPECT_EQ(original_uint16,
33 sys::getSwappedBytes(sys::getSwappedBytes(original_uint16)));
34
35 uint32_t original_uint32 = static_cast<uint32_t>(value);
36 EXPECT_EQ(original_uint32,
37 sys::getSwappedBytes(sys::getSwappedBytes(original_uint32)));
38
39 uint64_t original_uint64 = static_cast<uint64_t>(value);
40 EXPECT_EQ(original_uint64,
41 sys::getSwappedBytes(sys::getSwappedBytes(original_uint64)));
42
43 value = (value << 8) | 0x55; // binary 0101 0101.
44 }
45}
46
47TEST(getSwappedBytes, SignedRoundTrip) {
48 // The point of the bit twiddling of magic is to test with and without bits
49 // in every byte.
50 uint64_t value = 1;
51 for (std::size_t i = 0; i <= sizeof(value); ++i) {
52 int8_t original_int8 = static_cast<int8_t>(value);
53 EXPECT_EQ(original_int8,
54 sys::getSwappedBytes(sys::getSwappedBytes(original_int8)));
55
56 int16_t original_int16 = static_cast<int16_t>(value);
57 EXPECT_EQ(original_int16,
58 sys::getSwappedBytes(sys::getSwappedBytes(original_int16)));
59
60 int32_t original_int32 = static_cast<int32_t>(value);
61 EXPECT_EQ(original_int32,
62 sys::getSwappedBytes(sys::getSwappedBytes(original_int32)));
63
64 int64_t original_int64 = static_cast<int64_t>(value);
65 EXPECT_EQ(original_int64,
66 sys::getSwappedBytes(sys::getSwappedBytes(original_int64)));
67
68 // Test other sign.
69 value *= -1;
70
71 original_int8 = static_cast<int8_t>(value);
72 EXPECT_EQ(original_int8,
73 sys::getSwappedBytes(sys::getSwappedBytes(original_int8)));
74
75 original_int16 = static_cast<int16_t>(value);
76 EXPECT_EQ(original_int16,
77 sys::getSwappedBytes(sys::getSwappedBytes(original_int16)));
78
79 original_int32 = static_cast<int32_t>(value);
80 EXPECT_EQ(original_int32,
81 sys::getSwappedBytes(sys::getSwappedBytes(original_int32)));
82
83 original_int64 = static_cast<int64_t>(value);
84 EXPECT_EQ(original_int64,
85 sys::getSwappedBytes(sys::getSwappedBytes(original_int64)));
86
87 // Return to normal sign and twiddle.
88 value *= -1;
89 value = (value << 8) | 0x55; // binary 0101 0101.
90 }
91}
92
93TEST(getSwappedBytes, uint8_t) {
94 EXPECT_EQ(uint8_t(0x11), sys::getSwappedBytes(uint8_t(0x11)));
95}
96
97TEST(getSwappedBytes, uint16_t) {
98 EXPECT_EQ(uint16_t(0x1122), sys::getSwappedBytes(uint16_t(0x2211)));
99}
100
101TEST(getSwappedBytes, uint32_t) {
102 EXPECT_EQ(uint32_t(0x11223344), sys::getSwappedBytes(uint32_t(0x44332211)));
103}
104
105TEST(getSwappedBytes, uint64_t) {
106 EXPECT_EQ(uint64_t(0x1122334455667788ULL),
107 sys::getSwappedBytes(uint64_t(0x8877665544332211ULL)));
108}
109
110TEST(getSwappedBytes, int8_t) {
111 EXPECT_EQ(int8_t(0x11), sys::getSwappedBytes(int8_t(0x11)));
112}
113
114TEST(getSwappedBytes, int16_t) {
115 EXPECT_EQ(int16_t(0x1122), sys::getSwappedBytes(int16_t(0x2211)));
116}
117
118TEST(getSwappedBytes, int32_t) {
119 EXPECT_EQ(int32_t(0x11223344), sys::getSwappedBytes(int32_t(0x44332211)));
120}
121
122TEST(getSwappedBytes, int64_t) {
123 EXPECT_EQ(int64_t(0x1122334455667788LL),
124 sys::getSwappedBytes(int64_t(0x8877665544332211LL)));
125}
126
127TEST(getSwappedBytes, float) {
128 EXPECT_EQ(1.79366203433576585078237386661e-43f, sys::getSwappedBytes(-0.0f));
129 // 0x11223344
130 EXPECT_EQ(7.1653228759765625e2f, sys::getSwappedBytes(1.2795344e-28f));
131}
132
133TEST(getSwappedBytes, double) {
134 EXPECT_EQ(6.32404026676795576546008054871e-322, sys::getSwappedBytes(-0.0));
135 // 0x1122334455667788
136 EXPECT_EQ(-7.08687663657301358331704585496e-268,
137 sys::getSwappedBytes(3.84141202447173065923064450234e-226));
138}
139
140TEST(swapByteOrder, uint8_t) {
141 uint8_t value = 0x11;
142 sys::swapByteOrder(Value&: value);
143 EXPECT_EQ(uint8_t(0x11), value);
144}
145
146TEST(swapByteOrder, uint16_t) {
147 uint16_t value = 0x2211;
148 sys::swapByteOrder(Value&: value);
149 EXPECT_EQ(uint16_t(0x1122), value);
150}
151
152TEST(swapByteOrder, uint32_t) {
153 uint32_t value = 0x44332211;
154 sys::swapByteOrder(Value&: value);
155 EXPECT_EQ(uint32_t(0x11223344), value);
156}
157
158TEST(swapByteOrder, uint64_t) {
159 uint64_t value = 0x8877665544332211ULL;
160 sys::swapByteOrder(Value&: value);
161 EXPECT_EQ(uint64_t(0x1122334455667788ULL), value);
162}
163
164TEST(swapByteOrder, int8_t) {
165 int8_t value = 0x11;
166 sys::swapByteOrder(Value&: value);
167 EXPECT_EQ(int8_t(0x11), value);
168}
169
170TEST(swapByteOrder, int16_t) {
171 int16_t value = 0x2211;
172 sys::swapByteOrder(Value&: value);
173 EXPECT_EQ(int16_t(0x1122), value);
174}
175
176TEST(swapByteOrder, int32_t) {
177 int32_t value = 0x44332211;
178 sys::swapByteOrder(Value&: value);
179 EXPECT_EQ(int32_t(0x11223344), value);
180}
181
182TEST(swapByteOrder, int64_t) {
183 int64_t value = 0x8877665544332211LL;
184 sys::swapByteOrder(Value&: value);
185 EXPECT_EQ(int64_t(0x1122334455667788LL), value);
186}
187
188TEST(swapByteOrder, float) {
189 float value = 7.1653228759765625e2f; // 0x44332211
190 sys::swapByteOrder(Value&: value);
191 EXPECT_EQ(1.2795344e-28f, value);
192}
193
194TEST(swapByteOrder, double) {
195 double value = -7.08687663657301358331704585496e-268; // 0x8877665544332211
196 sys::swapByteOrder(Value&: value);
197 EXPECT_EQ(3.84141202447173065923064450234e-226, value);
198}
199
200}
201

source code of llvm/unittests/Support/SwapByteOrderTest.cpp