1//===-- Unittests for the FXBits class ------------------------------------===//
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 "include/llvm-libc-macros/stdfix-macros.h"
10
11#include "src/__support/fixed_point/fx_bits.h"
12#include "src/__support/integer_literals.h"
13#include "test/UnitTest/Test.h"
14
15using LIBC_NAMESPACE::fixed_point::FXBits;
16using LIBC_NAMESPACE::fixed_point::FXRep;
17
18using LIBC_NAMESPACE::operator""_u8;
19using LIBC_NAMESPACE::operator""_u16;
20using LIBC_NAMESPACE::operator""_u32;
21using LIBC_NAMESPACE::operator""_u64;
22
23class LlvmLibcFxBitsTest : public LIBC_NAMESPACE::testing::Test {
24public:
25 template <typename T> void testBitwiseOps() {
26 EXPECT_EQ(LIBC_NAMESPACE::fixed_point::bit_and(T(0.75), T(0.375)), T(0.25));
27 EXPECT_EQ(LIBC_NAMESPACE::fixed_point::bit_or(T(0.75), T(0.375)), T(0.875));
28 using StorageType = typename FXRep<T>::StorageType;
29 StorageType a = LIBC_NAMESPACE::cpp::bit_cast<StorageType>(T(0.75));
30 a = static_cast<StorageType>(~a);
31 EXPECT_EQ(LIBC_NAMESPACE::fixed_point::bit_not(T(0.75)),
32 FXBits<T>(a).get_val());
33 }
34};
35
36// -------------------------------- SHORT TESTS --------------------------------
37
38TEST_F(LlvmLibcFxBitsTest, FXBits_UnsignedShortFract) {
39 auto bits_var = FXBits<unsigned short fract>(0b00000000_u8);
40
41 EXPECT_EQ(bits_var.get_sign(), false);
42 EXPECT_EQ(bits_var.get_integral(), 0x00_u8);
43 EXPECT_EQ(bits_var.get_fraction(), 0x00_u8);
44
45 // Since an unsigned fract has no sign or integral components, setting either
46 // should have no effect.
47
48 bits_var.set_sign(true);
49
50 EXPECT_EQ(bits_var.get_sign(), false);
51 EXPECT_EQ(bits_var.get_integral(), 0x00_u8);
52 EXPECT_EQ(bits_var.get_fraction(), 0x00_u8);
53
54 bits_var.set_integral(0xab);
55
56 EXPECT_EQ(bits_var.get_sign(), false);
57 EXPECT_EQ(bits_var.get_integral(), 0x00_u8);
58 EXPECT_EQ(bits_var.get_fraction(), 0x00_u8);
59
60 // but setting the fraction should work
61
62 bits_var.set_fraction(0xcd);
63
64 EXPECT_EQ(bits_var.get_sign(), false);
65 EXPECT_EQ(bits_var.get_integral(), 0x00_u8);
66 EXPECT_EQ(bits_var.get_fraction(), 0xcd_u8);
67
68 // Bitwise ops
69 testBitwiseOps<unsigned short fract>();
70}
71
72TEST_F(LlvmLibcFxBitsTest, FXBits_UnsignedShortAccum) {
73 auto bits_var = FXBits<unsigned short accum>(0b00000000'00000000_u16);
74
75 EXPECT_EQ(bits_var.get_sign(), false);
76 EXPECT_EQ(bits_var.get_integral(), 0x0000_u16);
77 EXPECT_EQ(bits_var.get_fraction(), 0x0000_u16);
78
79 bits_var.set_sign(true); // 0 sign bits used
80
81 EXPECT_EQ(bits_var.get_sign(), false);
82 EXPECT_EQ(bits_var.get_integral(), 0x0000_u16);
83 EXPECT_EQ(bits_var.get_fraction(), 0x0000_u16);
84
85 bits_var.set_integral(0xabcd); // 8 integral bits used
86
87 EXPECT_EQ(bits_var.get_sign(), false);
88 EXPECT_EQ(bits_var.get_integral(), 0x00cd_u16);
89 EXPECT_EQ(bits_var.get_fraction(), 0x0000_u16);
90
91 bits_var.set_fraction(0x21fe); // 8 fractional bits used
92
93 EXPECT_EQ(bits_var.get_sign(), false);
94 EXPECT_EQ(bits_var.get_integral(), 0x00cd_u16);
95 EXPECT_EQ(bits_var.get_fraction(), 0x00fe_u16);
96
97 // Bitwise ops
98 testBitwiseOps<unsigned short accum>();
99}
100
101TEST_F(LlvmLibcFxBitsTest, FXBits_ShortFract) {
102 auto bits_var = FXBits<short fract>(0b0'0000000_u8);
103
104 EXPECT_EQ(bits_var.get_sign(), false);
105 EXPECT_EQ(bits_var.get_integral(), 0x00_u8);
106 EXPECT_EQ(bits_var.get_fraction(), 0x00_u8);
107
108 bits_var.set_sign(true); // 1 sign bit used
109
110 EXPECT_EQ(bits_var.get_sign(), true);
111 EXPECT_EQ(bits_var.get_integral(), 0x00_u8);
112 EXPECT_EQ(bits_var.get_fraction(), 0x00_u8);
113
114 bits_var.set_integral(0xab); // 0 integral bits used
115
116 EXPECT_EQ(bits_var.get_sign(), true);
117 EXPECT_EQ(bits_var.get_integral(), 0x00_u8);
118 EXPECT_EQ(bits_var.get_fraction(), 0x00_u8);
119
120 bits_var.set_fraction(0xcd); // 7 fractional bits used
121
122 EXPECT_EQ(bits_var.get_sign(), true);
123 EXPECT_EQ(bits_var.get_integral(), 0x00_u8);
124 EXPECT_EQ(bits_var.get_fraction(), 0x4d_u8);
125
126 // Bitwise ops
127 testBitwiseOps<short fract>();
128}
129
130TEST_F(LlvmLibcFxBitsTest, FXBits_ShortAccum) {
131 auto bits_var = FXBits<short accum>(0b0'00000000'0000000_u16);
132
133 EXPECT_EQ(bits_var.get_sign(), false);
134 EXPECT_EQ(bits_var.get_integral(), 0x0000_u16);
135 EXPECT_EQ(bits_var.get_fraction(), 0x0000_u16);
136
137 bits_var.set_sign(true); // 1 sign bit used
138
139 EXPECT_EQ(bits_var.get_sign(), true);
140 EXPECT_EQ(bits_var.get_integral(), 0x0000_u16);
141 EXPECT_EQ(bits_var.get_fraction(), 0x0000_u16);
142
143 bits_var.set_integral(0xabcd); // 8 integral bits used
144
145 EXPECT_EQ(bits_var.get_sign(), true);
146 EXPECT_EQ(bits_var.get_integral(), 0x00cd_u16);
147 EXPECT_EQ(bits_var.get_fraction(), 0x0000_u16);
148
149 bits_var.set_fraction(0x21fe); // 7 fractional bits used
150
151 EXPECT_EQ(bits_var.get_sign(), true);
152 EXPECT_EQ(bits_var.get_integral(), 0x00cd_u16);
153 EXPECT_EQ(bits_var.get_fraction(), 0x007e_u16);
154
155 // Bitwise ops
156 testBitwiseOps<short accum>();
157}
158
159// -------------------------------- NORMAL TESTS -------------------------------
160
161TEST_F(LlvmLibcFxBitsTest, FXBits_UnsignedFract) {
162 auto bits_var = FXBits<unsigned fract>(0b0000000000000000_u16);
163
164 EXPECT_EQ(bits_var.get_sign(), false);
165 EXPECT_EQ(bits_var.get_integral(), 0x0000_u16);
166 EXPECT_EQ(bits_var.get_fraction(), 0x0000_u16);
167
168 bits_var.set_sign(true); // 0 sign bits used
169
170 EXPECT_EQ(bits_var.get_sign(), false);
171 EXPECT_EQ(bits_var.get_integral(), 0x0000_u16);
172 EXPECT_EQ(bits_var.get_fraction(), 0x0000_u16);
173
174 bits_var.set_integral(0xabcd); // 0 integral bits used
175
176 EXPECT_EQ(bits_var.get_sign(), false);
177 EXPECT_EQ(bits_var.get_integral(), 0x0000_u16);
178 EXPECT_EQ(bits_var.get_fraction(), 0x0000_u16);
179
180 bits_var.set_fraction(0xef12); // 16 fractional bits used
181
182 EXPECT_EQ(bits_var.get_sign(), false);
183 EXPECT_EQ(bits_var.get_integral(), 0x0000_u16);
184 EXPECT_EQ(bits_var.get_fraction(), 0xef12_u16);
185
186 // Bitwise ops
187 testBitwiseOps<unsigned fract>();
188}
189
190TEST_F(LlvmLibcFxBitsTest, FXBits_UnsignedAccum) {
191 auto bits_var =
192 FXBits<unsigned accum>(0b0000000000000000'0000000000000000_u32);
193
194 EXPECT_EQ(bits_var.get_sign(), false);
195 EXPECT_EQ(bits_var.get_integral(), 0x00000000_u32);
196 EXPECT_EQ(bits_var.get_fraction(), 0x00000000_u32);
197
198 bits_var.set_sign(true); // 0 sign bits used
199
200 EXPECT_EQ(bits_var.get_sign(), false);
201 EXPECT_EQ(bits_var.get_integral(), 0x00000000_u32);
202 EXPECT_EQ(bits_var.get_fraction(), 0x00000000_u32);
203
204 bits_var.set_integral(0xabcd); // 16 integral bits used
205
206 EXPECT_EQ(bits_var.get_sign(), false);
207 EXPECT_EQ(bits_var.get_integral(), 0x0000abcd_u32);
208 EXPECT_EQ(bits_var.get_fraction(), 0x00000000_u32);
209
210 bits_var.set_fraction(0xef12); // 16 fractional bits used
211
212 EXPECT_EQ(bits_var.get_sign(), false);
213 EXPECT_EQ(bits_var.get_integral(), 0x0000abcd_u32);
214 EXPECT_EQ(bits_var.get_fraction(), 0x0000ef12_u32);
215
216 // Bitwise ops
217 testBitwiseOps<unsigned accum>();
218}
219
220TEST_F(LlvmLibcFxBitsTest, FXBits_Fract) {
221 auto bits_var = FXBits<fract>(0b0'000000000000000_u16);
222
223 EXPECT_EQ(bits_var.get_sign(), false);
224 EXPECT_EQ(bits_var.get_integral(), 0x0000_u16);
225 EXPECT_EQ(bits_var.get_fraction(), 0x0000_u16);
226
227 bits_var.set_sign(true); // 1 sign bit used
228
229 EXPECT_EQ(bits_var.get_sign(), true);
230 EXPECT_EQ(bits_var.get_integral(), 0x0000_u16);
231 EXPECT_EQ(bits_var.get_fraction(), 0x0000_u16);
232
233 bits_var.set_integral(0xabcd); // 0 integral bits used
234
235 EXPECT_EQ(bits_var.get_sign(), true);
236 EXPECT_EQ(bits_var.get_integral(), 0x0000_u16);
237 EXPECT_EQ(bits_var.get_fraction(), 0x0000_u16);
238
239 bits_var.set_fraction(0xef12); // 15 fractional bits used
240
241 EXPECT_EQ(bits_var.get_sign(), true);
242 EXPECT_EQ(bits_var.get_integral(), 0x0000_u16);
243 EXPECT_EQ(bits_var.get_fraction(), 0x6f12_u16);
244
245 // Bitwise ops
246 testBitwiseOps<fract>();
247}
248
249TEST_F(LlvmLibcFxBitsTest, FXBits_Accum) {
250 auto bits_var = FXBits<accum>(0b0'0000000000000000'000000000000000_u32);
251
252 EXPECT_EQ(bits_var.get_sign(), false);
253 EXPECT_EQ(bits_var.get_integral(), 0x00000000_u32);
254 EXPECT_EQ(bits_var.get_fraction(), 0x00000000_u32);
255
256 bits_var.set_sign(true); // 1 sign bit used
257
258 EXPECT_EQ(bits_var.get_sign(), true);
259 EXPECT_EQ(bits_var.get_integral(), 0x00000000_u32);
260 EXPECT_EQ(bits_var.get_fraction(), 0x00000000_u32);
261
262 bits_var.set_integral(0xabcd); // 16 integral bits used
263
264 EXPECT_EQ(bits_var.get_sign(), true);
265 EXPECT_EQ(bits_var.get_integral(), 0x0000abcd_u32);
266 EXPECT_EQ(bits_var.get_fraction(), 0x00000000_u32);
267
268 bits_var.set_fraction(0xef12); // 15 fractional bits used
269
270 EXPECT_EQ(bits_var.get_sign(), true);
271 EXPECT_EQ(bits_var.get_integral(), 0x0000abcd_u32);
272 EXPECT_EQ(bits_var.get_fraction(), 0x00006f12_u32);
273
274 // Bitwise ops
275 testBitwiseOps<accum>();
276}
277
278// --------------------------------- LONG TESTS --------------------------------
279
280TEST_F(LlvmLibcFxBitsTest, FXBits_UnsignedLongFract) {
281 auto bits_var =
282 FXBits<unsigned long fract>(0b00000000000000000000000000000000_u32);
283
284 EXPECT_EQ(bits_var.get_sign(), false);
285 EXPECT_EQ(bits_var.get_integral(), 0x00000000_u32);
286 EXPECT_EQ(bits_var.get_fraction(), 0x00000000_u32);
287
288 bits_var.set_sign(true); // 0 sign bits used
289
290 EXPECT_EQ(bits_var.get_sign(), false);
291 EXPECT_EQ(bits_var.get_integral(), 0x00000000_u32);
292 EXPECT_EQ(bits_var.get_fraction(), 0x00000000_u32);
293
294 bits_var.set_integral(0xabcdef12); // 0 integral bits used
295
296 EXPECT_EQ(bits_var.get_sign(), false);
297 EXPECT_EQ(bits_var.get_integral(), 0x00000000_u32);
298 EXPECT_EQ(bits_var.get_fraction(), 0x00000000_u32);
299
300 bits_var.set_fraction(0xfedcba98); // 32 integral bits used
301
302 EXPECT_EQ(bits_var.get_sign(), false);
303 EXPECT_EQ(bits_var.get_integral(), 0x00000000_u32);
304 EXPECT_EQ(bits_var.get_fraction(), 0xfedcba98_u32);
305
306 // Bitwise ops
307 testBitwiseOps<unsigned long fract>();
308}
309
310TEST_F(LlvmLibcFxBitsTest, FXBits_UnsignedLongAccum) {
311 auto bits_var = FXBits<unsigned long accum>(
312 0b00000000000000000000000000000000'00000000000000000000000000000000_u64);
313
314 EXPECT_EQ(bits_var.get_sign(), false);
315 EXPECT_EQ(bits_var.get_integral(), 0x0000000000000000_u64);
316 EXPECT_EQ(bits_var.get_fraction(), 0x0000000000000000_u64);
317
318 bits_var.set_sign(true); // 0 sign bits used
319
320 EXPECT_EQ(bits_var.get_sign(), false);
321 EXPECT_EQ(bits_var.get_integral(), 0x0000000000000000_u64);
322 EXPECT_EQ(bits_var.get_fraction(), 0x0000000000000000_u64);
323
324 bits_var.set_integral(0xabcdef12); // 32 integral bits used
325
326 EXPECT_EQ(bits_var.get_sign(), false);
327 EXPECT_EQ(bits_var.get_integral(), 0x00000000abcdef12_u64);
328 EXPECT_EQ(bits_var.get_fraction(), 0x0000000000000000_u64);
329
330 bits_var.set_fraction(0xfedcba98); // 32 fractional bits used
331
332 EXPECT_EQ(bits_var.get_sign(), false);
333 EXPECT_EQ(bits_var.get_integral(), 0x00000000abcdef12_u64);
334 EXPECT_EQ(bits_var.get_fraction(), 0x00000000fedcba98_u64);
335
336 // Bitwise ops
337 testBitwiseOps<unsigned long accum>();
338}
339
340TEST_F(LlvmLibcFxBitsTest, FXBits_LongFract) {
341 auto bits_var = FXBits<long fract>(0b0'0000000000000000000000000000000_u32);
342
343 EXPECT_EQ(bits_var.get_sign(), false);
344 EXPECT_EQ(bits_var.get_integral(), 0x00000000_u32);
345 EXPECT_EQ(bits_var.get_fraction(), 0x00000000_u32);
346
347 bits_var.set_sign(true); // 1 sign bit used
348
349 EXPECT_EQ(bits_var.get_sign(), true);
350 EXPECT_EQ(bits_var.get_integral(), 0x00000000_u32);
351 EXPECT_EQ(bits_var.get_fraction(), 0x00000000_u32);
352
353 bits_var.set_integral(0xabcdef12); // 0 integral bits used
354
355 EXPECT_EQ(bits_var.get_sign(), true);
356 EXPECT_EQ(bits_var.get_integral(), 0x00000000_u32);
357 EXPECT_EQ(bits_var.get_fraction(), 0x00000000_u32);
358
359 bits_var.set_fraction(0xfedcba98); // 31 fractional bits used
360
361 EXPECT_EQ(bits_var.get_sign(), true);
362 EXPECT_EQ(bits_var.get_integral(), 0x00000000_u32);
363 EXPECT_EQ(bits_var.get_fraction(), 0x7edcba98_u32);
364
365 // Bitwise ops
366 testBitwiseOps<long fract>();
367}
368
369TEST_F(LlvmLibcFxBitsTest, FXBits_LongAccum) {
370 auto bits_var = FXBits<long accum>(
371 0b0'00000000000000000000000000000000'0000000000000000000000000000000_u64);
372
373 EXPECT_EQ(bits_var.get_sign(), false);
374 EXPECT_EQ(bits_var.get_integral(), 0x0000000000000000_u64);
375 EXPECT_EQ(bits_var.get_fraction(), 0x0000000000000000_u64);
376
377 bits_var.set_sign(true); // 1 sign bit used
378
379 EXPECT_EQ(bits_var.get_sign(), true);
380 EXPECT_EQ(bits_var.get_integral(), 0x0000000000000000_u64);
381 EXPECT_EQ(bits_var.get_fraction(), 0x0000000000000000_u64);
382
383 bits_var.set_integral(0xabcdef12); // 32 integral bits used
384
385 EXPECT_EQ(bits_var.get_sign(), true);
386 EXPECT_EQ(bits_var.get_integral(), 0x00000000abcdef12_u64);
387 EXPECT_EQ(bits_var.get_fraction(), 0x0000000000000000_u64);
388
389 bits_var.set_fraction(0xfedcba98); // 31 fractional bits used
390
391 EXPECT_EQ(bits_var.get_sign(), true);
392 EXPECT_EQ(bits_var.get_integral(), 0x00000000abcdef12_u64);
393 EXPECT_EQ(bits_var.get_fraction(), 0x000000007edcba98_u64);
394
395 // Bitwise ops
396 testBitwiseOps<long accum>();
397}
398

source code of libc/test/src/__support/fixed_point/fx_bits_test.cpp