Barretenberg
The ZK-SNARK library at the core of Aztec
Loading...
Searching...
No Matches
uint128.test.cpp
Go to the documentation of this file.
1#include "uint128.hpp"
2#include "../random/engine.hpp"
3#include <gtest/gtest.h>
4#ifdef __i386__
5
6using namespace bb;
7using namespace bb::numeric;
8
9namespace {
10auto& engine = numeric::get_debug_randomness();
11}
12
13TEST(uint128, GetBit)
14{
15 constexpr uint128_t a{ 0b0110011001110010011001100,
16 0b1001011101101010101010100,
17 0b0101010010010101111100001,
18 0b0101011010101010100010001 };
19
20 uint128_t res;
21 for (size_t i = 0; i < 128; ++i) {
22 res += a.get_bit(i) ? (uint128_t(1) << i) : 0;
23 }
24
25 EXPECT_EQ(a, res);
26}
27
28TEST(uint128, Add)
29{
30 constexpr uint128_t a{ 1, 2, 3, 4 };
31 constexpr uint128_t b{ 5, 6, 7, 8 };
32
33 constexpr uint128_t c = a + b;
34 uint128_t d = a;
35 d += b;
36 EXPECT_EQ(c.data[0], 6ULL);
37 EXPECT_EQ(c.data[1], 8ULL);
38 EXPECT_EQ(c.data[2], 10ULL);
39 EXPECT_EQ(c.data[3], 12ULL);
40 EXPECT_EQ(d.data[0], 6ULL);
41 EXPECT_EQ(d.data[1], 8ULL);
42 EXPECT_EQ(d.data[2], 10ULL);
43 EXPECT_EQ(d.data[3], 12ULL);
44}
45
46TEST(uint128, GetMsb)
47{
48 uint128_t a{ 0, 0, 1, 1 };
49 uint128_t b{ 1, 0, 1, 0 };
50 uint128_t c{ 0, 1, 0, 0 };
51 uint128_t d{ 1, 0, 0, 0 };
52
53 EXPECT_EQ(a.get_msb(), 96ULL);
54 EXPECT_EQ(b.get_msb(), 64ULL);
55 EXPECT_EQ(c.get_msb(), 32ULL);
56 EXPECT_EQ(d.get_msb(), 0ULL);
57}
58
59TEST(uint128, Mul)
60{
61 uint128_t a = engine.get_random_uint128();
62 uint128_t b = engine.get_random_uint128();
63
64 uint128_t c = (a + b) * (a + b);
65 uint128_t d = (a * a) + (b * b) + (a * b) + (a * b);
66 EXPECT_EQ(c.data[0], d.data[0]);
67 EXPECT_EQ(c.data[1], d.data[1]);
68 EXPECT_EQ(c.data[2], d.data[2]);
69 EXPECT_EQ(c.data[3], d.data[3]);
70}
71
72TEST(uint128, DivAndMod)
73{
74 for (size_t i = 0; i < 128; ++i) {
75 uint128_t a = engine.get_random_uint128();
76 uint128_t b = engine.get_random_uint128();
77
78 b.data[3] = (i > 0) ? 0 : b.data[3];
79 b.data[2] = (i > 1) ? 0 : b.data[2];
80 b.data[1] = (i > 2) ? 0 : b.data[1];
81 uint128_t q = a / b;
82 uint128_t r = a % b;
83
84 uint128_t c = q * b + r;
85 EXPECT_EQ(c.data[0], a.data[0]);
86 EXPECT_EQ(c.data[1], a.data[1]);
87 EXPECT_EQ(c.data[2], a.data[2]);
88 EXPECT_EQ(c.data[3], a.data[3]);
89 }
90
91 uint128_t a = engine.get_random_uint128();
92 uint128_t b = 0;
93
94 uint128_t q = a / b;
95 uint128_t r = a % b;
96
97 EXPECT_EQ(q, uint128_t(0));
98 EXPECT_EQ(r, uint128_t(0));
99
100 b = a;
101 q = a / b;
102 r = a % b;
103
104 EXPECT_EQ(q, uint128_t(1));
105 EXPECT_EQ(r, uint128_t(0));
106}
107
108TEST(uint128, Sub)
109{
110 uint128_t a = engine.get_random_uint128();
111 uint128_t b = engine.get_random_uint128();
112
113 uint128_t c = (a - b) * (a + b);
114 uint128_t d = (a * a) - (b * b);
115
116 EXPECT_EQ(c.data[0], d.data[0]);
117 EXPECT_EQ(c.data[1], d.data[1]);
118 EXPECT_EQ(c.data[2], d.data[2]);
119 EXPECT_EQ(c.data[3], d.data[3]);
120
121 uint128_t e = 0;
122 e = e - 1;
123
124 EXPECT_EQ(e.data[0], UINT32_MAX);
125 EXPECT_EQ(e.data[1], UINT32_MAX);
126 EXPECT_EQ(e.data[2], UINT32_MAX);
127 EXPECT_EQ(e.data[3], UINT32_MAX);
128}
129
130TEST(uint128, RightShift)
131{
132 constexpr uint128_t a{ 0xaaaaaaaa, 0xbbbbbbbb, 0xcccccccc, 0xdddddddd };
133
134 constexpr uint128_t b = a >> 128;
135 EXPECT_EQ(b, uint128_t(0));
136
137 constexpr uint128_t c = a >> 0;
138 EXPECT_EQ(a, c);
139
140 constexpr uint128_t d = a >> 32;
141 EXPECT_EQ(d, uint128_t(0xbbbbbbbb, 0xcccccccc, 0xdddddddd, 0));
142
143 constexpr uint128_t e = a >> 59;
144 constexpr uint128_t f = e * (uint128_t{ 0, 1ULL << 27ULL, 0, 0 });
145 EXPECT_EQ(f, uint128_t(0, 0xb8000000, 0xcccccccc, 0xdddddddd));
146}
147
148TEST(uint128, LeftShift)
149{
150 uint128_t a{ 0xaaaaaaaa, 0xbbbbbbbb, 0xcccccccc, 0xdddddddd };
151
152 uint128_t b = a << 128;
153 EXPECT_EQ(b, uint128_t(0));
154
155 uint128_t c = a << 0;
156 EXPECT_EQ(a, c);
157
158 uint128_t d = a << 32;
159 EXPECT_EQ(d, uint128_t(0, 0xaaaaaaaa, 0xbbbbbbbb, 0xcccccccc));
160
161 uint128_t e = a << 123;
162 e = e >> 123;
163 EXPECT_EQ(e, uint128_t(0xa, 0, 0, 0));
164
165 uint128_t large_shift = uint128_t(1) << 64;
166 uint128_t f = a << large_shift;
167 EXPECT_EQ(f, uint128_t(0));
168}
169
170TEST(uint128, And)
171{
172 uint128_t a = engine.get_random_uint128();
173 uint128_t b = engine.get_random_uint128();
174
175 uint128_t c = a & b;
176
177 EXPECT_EQ(c.data[0], a.data[0] & b.data[0]);
178 EXPECT_EQ(c.data[1], a.data[1] & b.data[1]);
179 EXPECT_EQ(c.data[2], a.data[2] & b.data[2]);
180 EXPECT_EQ(c.data[3], a.data[3] & b.data[3]);
181}
182
183TEST(uint128, Or)
184{
185 uint128_t a = engine.get_random_uint128();
186 uint128_t b = engine.get_random_uint128();
187
188 uint128_t c = a | b;
189
190 EXPECT_EQ(c.data[0], a.data[0] | b.data[0]);
191 EXPECT_EQ(c.data[1], a.data[1] | b.data[1]);
192 EXPECT_EQ(c.data[2], a.data[2] | b.data[2]);
193 EXPECT_EQ(c.data[3], a.data[3] | b.data[3]);
194}
195
196TEST(uint128, Xor)
197{
198 uint128_t a = engine.get_random_uint128();
199 uint128_t b = engine.get_random_uint128();
200
201 uint128_t c = a ^ b;
202
203 EXPECT_EQ(c.data[0], a.data[0] ^ b.data[0]);
204 EXPECT_EQ(c.data[1], a.data[1] ^ b.data[1]);
205 EXPECT_EQ(c.data[2], a.data[2] ^ b.data[2]);
206 EXPECT_EQ(c.data[3], a.data[3] ^ b.data[3]);
207}
208
209TEST(uint128, BitNot)
210{
211 uint128_t a = engine.get_random_uint128();
212
213 uint128_t c = ~a;
214
215 EXPECT_EQ(c.data[0], ~a.data[0]);
216 EXPECT_EQ(c.data[1], ~a.data[1]);
217 EXPECT_EQ(c.data[2], ~a.data[2]);
218 EXPECT_EQ(c.data[3], ~a.data[3]);
219}
220
221TEST(uint128, LogicNot)
222{
223 uint128_t a{ 1, 0, 0, 0 };
224
225 bool b = !a;
226
227 EXPECT_EQ(b, false);
228
229 uint128_t c{ 0, 0, 0, 0 };
230
231 EXPECT_EQ(!c, true);
232}
233
234TEST(uint128, Equality)
235{
236 uint128_t a{ 1, 0, 0, 0 };
237 uint128_t b{ 1, 0, 0, 0 };
238 EXPECT_EQ(a == b, true);
239
240 a = uint128_t{ 0, 1, 0, 0 };
241 EXPECT_EQ(a == b, false);
242
243 a = uint128_t{ 0, 0, 1, 0 };
244 EXPECT_EQ(a == b, false);
245
246 a = uint128_t{ 0, 0, 0, 1 };
247 EXPECT_EQ(a == b, false);
248
249 a = uint128_t{ 555, 0, 0, 1 };
250 b = uint128_t{ 535, 0, 0, 1 };
251 EXPECT_EQ(a == b, false);
252}
253
254TEST(uint128, NotEqual)
255{
256 uint128_t a{ 1, 0, 0, 0 };
257 uint128_t b{ 1, 0, 0, 0 };
258 EXPECT_EQ(a != b, false);
259
260 a = uint128_t{ 0, 1, 0, 0 };
261 EXPECT_EQ(a != b, true);
262
263 a = uint128_t{ 0, 0, 1, 0 };
264 EXPECT_EQ(a != b, true);
265
266 a = uint128_t{ 0, 0, 0, 1 };
267 EXPECT_EQ(a != b, true);
268
269 a = uint128_t{ 555, 0, 0, 1 };
270 b = uint128_t{ 535, 0, 0, 1 };
271 EXPECT_EQ(a != b, true);
272}
273
274TEST(uint128, GreaterThan)
275{
276 constexpr uint128_t a{ UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX };
277 constexpr uint128_t b{ UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX };
278 EXPECT_EQ(a > b, false);
279
280 constexpr uint128_t c = uint128_t{ UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX - 1 };
281 EXPECT_EQ(a > c, true);
282
283 constexpr uint128_t d = uint128_t{ UINT32_MAX, UINT32_MAX, UINT32_MAX - 1, UINT32_MAX };
284 EXPECT_EQ(a > d, true);
285
286 constexpr uint128_t e = uint128_t{ UINT32_MAX, UINT32_MAX - 1, UINT32_MAX, UINT32_MAX };
287 EXPECT_EQ(a > e, true);
288
289 constexpr uint128_t f = uint128_t{ UINT32_MAX - 1, UINT32_MAX, UINT32_MAX, UINT32_MAX };
290 EXPECT_EQ(a > f, true);
291}
292
293TEST(uint128, GeaterThanOrEqual)
294{
295 uint128_t a{ UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX - 1 };
296 uint128_t b{ UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX };
297 EXPECT_EQ(a >= b, false);
298
299 b = uint128_t{ UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX - 1 };
300 EXPECT_EQ(a > b, false);
301 EXPECT_EQ(a >= b, true);
302
303 b = uint128_t{ UINT32_MAX, UINT32_MAX, UINT32_MAX - 1, UINT32_MAX };
304 EXPECT_EQ(a >= b, false);
305
306 a = uint128_t{ UINT32_MAX, UINT32_MAX - 1, UINT32_MAX - 1, UINT32_MAX };
307 EXPECT_EQ(a >= b, false);
308
309 b = uint128_t{ UINT32_MAX - 1, UINT32_MAX, UINT32_MAX, UINT32_MAX };
310 EXPECT_EQ(a >= b, false);
311}
312
313TEST(uint128, ToFromBuffer)
314{
315 uint128_t a{ 1, 2, 3, 4 };
316 auto buf = to_buffer(a);
317 auto b = from_buffer<uint128_t>(buf);
318 EXPECT_EQ(a, b);
319}
320#endif
TEST
TEST(acir_formal_proofs, uint_terms_add)
Tests 127-bit unsigned addition Verifies that the ACIR implementation of addition is correct Executio...
Definition acir_loader.test.cpp:65
data
const std::vector< FF > data
Definition data_copy.test.cpp:61
a
FF a
Definition field_gt.test.cpp:51
b
FF b
Definition field_gt.test.cpp:52
buf
uint8_t const * buf
Definition data_store.hpp:9
engine
numeric::RNG & engine
Definition eccvm_transcript.test.cpp:282
bb
Entry point for Barretenberg command-line interface.
Definition acir_format_getters.cpp:6
to_buffer
std::vector< uint8_t > to_buffer(T const &value)
Definition serialize.hpp:425
uint128_t
unsigned __int128 uint128_t
Definition serialize.hpp:44