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);
143   EXPECT_EQ(uint8_t(0x11), value);
144 }
145 
146 TEST(swapByteOrder, uint16_t) {
147   uint16_t value = 0x2211;
148   sys::swapByteOrder(value);
149   EXPECT_EQ(uint16_t(0x1122), value);
150 }
151 
152 TEST(swapByteOrder, uint32_t) {
153   uint32_t value = 0x44332211;
154   sys::swapByteOrder(value);
155   EXPECT_EQ(uint32_t(0x11223344), value);
156 }
157 
158 TEST(swapByteOrder, uint64_t) {
159   uint64_t value = 0x8877665544332211ULL;
160   sys::swapByteOrder(value);
161   EXPECT_EQ(uint64_t(0x1122334455667788ULL), value);
162 }
163 
164 TEST(swapByteOrder, int8_t) {
165   int8_t value = 0x11;
166   sys::swapByteOrder(value);
167   EXPECT_EQ(int8_t(0x11), value);
168 }
169 
170 TEST(swapByteOrder, int16_t) {
171   int16_t value = 0x2211;
172   sys::swapByteOrder(value);
173   EXPECT_EQ(int16_t(0x1122), value);
174 }
175 
176 TEST(swapByteOrder, int32_t) {
177   int32_t value = 0x44332211;
178   sys::swapByteOrder(value);
179   EXPECT_EQ(int32_t(0x11223344), value);
180 }
181 
182 TEST(swapByteOrder, int64_t) {
183   int64_t value = 0x8877665544332211LL;
184   sys::swapByteOrder(value);
185   EXPECT_EQ(int64_t(0x1122334455667788LL), value);
186 }
187 
188 TEST(swapByteOrder, float) {
189   float value = 7.1653228759765625e2f; // 0x44332211
190   sys::swapByteOrder(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);
197   EXPECT_EQ(3.84141202447173065923064450234e-226, value);
198 }
199 
200 }
201