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> |
13 | using namespace llvm; |
14 | |
15 | #undef max |
16 | |
17 | namespace { |
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 | |
22 | TEST(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 | |
47 | TEST(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 | |
93 | TEST(getSwappedBytes, uint8_t) { |
94 | EXPECT_EQ(uint8_t(0x11), sys::getSwappedBytes(uint8_t(0x11))); |
95 | } |
96 | |
97 | TEST(getSwappedBytes, uint16_t) { |
98 | EXPECT_EQ(uint16_t(0x1122), sys::getSwappedBytes(uint16_t(0x2211))); |
99 | } |
100 | |
101 | TEST(getSwappedBytes, uint32_t) { |
102 | EXPECT_EQ(uint32_t(0x11223344), sys::getSwappedBytes(uint32_t(0x44332211))); |
103 | } |
104 | |
105 | TEST(getSwappedBytes, uint64_t) { |
106 | EXPECT_EQ(uint64_t(0x1122334455667788ULL), |
107 | sys::getSwappedBytes(uint64_t(0x8877665544332211ULL))); |
108 | } |
109 | |
110 | TEST(getSwappedBytes, int8_t) { |
111 | EXPECT_EQ(int8_t(0x11), sys::getSwappedBytes(int8_t(0x11))); |
112 | } |
113 | |
114 | TEST(getSwappedBytes, int16_t) { |
115 | EXPECT_EQ(int16_t(0x1122), sys::getSwappedBytes(int16_t(0x2211))); |
116 | } |
117 | |
118 | TEST(getSwappedBytes, int32_t) { |
119 | EXPECT_EQ(int32_t(0x11223344), sys::getSwappedBytes(int32_t(0x44332211))); |
120 | } |
121 | |
122 | TEST(getSwappedBytes, int64_t) { |
123 | EXPECT_EQ(int64_t(0x1122334455667788LL), |
124 | sys::getSwappedBytes(int64_t(0x8877665544332211LL))); |
125 | } |
126 | |
127 | TEST(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 | |
133 | TEST(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 | |
140 | TEST(swapByteOrder, uint8_t) { |
141 | uint8_t value = 0x11; |
142 | sys::swapByteOrder(Value&: value); |
143 | EXPECT_EQ(uint8_t(0x11), value); |
144 | } |
145 | |
146 | TEST(swapByteOrder, uint16_t) { |
147 | uint16_t value = 0x2211; |
148 | sys::swapByteOrder(Value&: value); |
149 | EXPECT_EQ(uint16_t(0x1122), value); |
150 | } |
151 | |
152 | TEST(swapByteOrder, uint32_t) { |
153 | uint32_t value = 0x44332211; |
154 | sys::swapByteOrder(Value&: value); |
155 | EXPECT_EQ(uint32_t(0x11223344), value); |
156 | } |
157 | |
158 | TEST(swapByteOrder, uint64_t) { |
159 | uint64_t value = 0x8877665544332211ULL; |
160 | sys::swapByteOrder(Value&: value); |
161 | EXPECT_EQ(uint64_t(0x1122334455667788ULL), value); |
162 | } |
163 | |
164 | TEST(swapByteOrder, int8_t) { |
165 | int8_t value = 0x11; |
166 | sys::swapByteOrder(Value&: value); |
167 | EXPECT_EQ(int8_t(0x11), value); |
168 | } |
169 | |
170 | TEST(swapByteOrder, int16_t) { |
171 | int16_t value = 0x2211; |
172 | sys::swapByteOrder(Value&: value); |
173 | EXPECT_EQ(int16_t(0x1122), value); |
174 | } |
175 | |
176 | TEST(swapByteOrder, int32_t) { |
177 | int32_t value = 0x44332211; |
178 | sys::swapByteOrder(Value&: value); |
179 | EXPECT_EQ(int32_t(0x11223344), value); |
180 | } |
181 | |
182 | TEST(swapByteOrder, int64_t) { |
183 | int64_t value = 0x8877665544332211LL; |
184 | sys::swapByteOrder(Value&: value); |
185 | EXPECT_EQ(int64_t(0x1122334455667788LL), value); |
186 | } |
187 | |
188 | TEST(swapByteOrder, float) { |
189 | float value = 7.1653228759765625e2f; // 0x44332211 |
190 | sys::swapByteOrder(Value&: value); |
191 | EXPECT_EQ(1.2795344e-28f, value); |
192 | } |
193 | |
194 | TEST(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 | |