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 if (b == 0) {
82 b = 1;
83 }
84 uint128_t q = a / b;
85 uint128_t r = a % b;
86
87 uint128_t c = q * b + r;
88 EXPECT_EQ(c.data[0], a.data[0]);
89 EXPECT_EQ(c.data[1], a.data[1]);
90 EXPECT_EQ(c.data[2], a.data[2]);
91 EXPECT_EQ(c.data[3], a.data[3]);
92 }
93
94 uint128_t a = engine.get_random_uint128();
95 uint128_t b = a;
96 uint128_t q = a / b;
97 uint128_t r = a % b;
98
99 EXPECT_EQ(q, uint128_t(1));
100 EXPECT_EQ(r, uint128_t(0));
101}
102
103TEST(uint128, Sub)
104{
105 uint128_t a = engine.get_random_uint128();
106 uint128_t b = engine.get_random_uint128();
107
108 uint128_t c = (a - b) * (a + b);
109 uint128_t d = (a * a) - (b * b);
110
111 EXPECT_EQ(c.data[0], d.data[0]);
112 EXPECT_EQ(c.data[1], d.data[1]);
113 EXPECT_EQ(c.data[2], d.data[2]);
114 EXPECT_EQ(c.data[3], d.data[3]);
115
116 uint128_t e = 0;
117 e = e - 1;
118
119 EXPECT_EQ(e.data[0], UINT32_MAX);
120 EXPECT_EQ(e.data[1], UINT32_MAX);
121 EXPECT_EQ(e.data[2], UINT32_MAX);
122 EXPECT_EQ(e.data[3], UINT32_MAX);
123}
124
125TEST(uint128, RightShift)
126{
127 constexpr uint128_t a{ 0xaaaaaaaa, 0xbbbbbbbb, 0xcccccccc, 0xdddddddd };
128
129 constexpr uint128_t b = a >> 128;
130 EXPECT_EQ(b, uint128_t(0));
131
132 constexpr uint128_t c = a >> 0;
133 EXPECT_EQ(a, c);
134
135 constexpr uint128_t d = a >> 32;
136 EXPECT_EQ(d, uint128_t(0xbbbbbbbb, 0xcccccccc, 0xdddddddd, 0));
137
138 constexpr uint128_t e = a >> 59;
139 constexpr uint128_t f = e * (uint128_t{ 0, 1ULL << 27ULL, 0, 0 });
140 EXPECT_EQ(f, uint128_t(0, 0xb8000000, 0xcccccccc, 0xdddddddd));
141}
142
143TEST(uint128, LeftShift)
144{
145 uint128_t a{ 0xaaaaaaaa, 0xbbbbbbbb, 0xcccccccc, 0xdddddddd };
146
147 uint128_t b = a << 128;
148 EXPECT_EQ(b, uint128_t(0));
149
150 uint128_t c = a << 0;
151 EXPECT_EQ(a, c);
152
153 uint128_t d = a << 32;
154 EXPECT_EQ(d, uint128_t(0, 0xaaaaaaaa, 0xbbbbbbbb, 0xcccccccc));
155
156 uint128_t e = a << 123;
157 e = e >> 123;
158 EXPECT_EQ(e, uint128_t(0xa, 0, 0, 0));
159
160 uint128_t large_shift = uint128_t(1) << 64;
161 uint128_t f = a << large_shift;
162 EXPECT_EQ(f, uint128_t(0));
163}
164
165TEST(uint128, And)
166{
167 uint128_t a = engine.get_random_uint128();
168 uint128_t b = engine.get_random_uint128();
169
170 uint128_t c = a & b;
171
172 EXPECT_EQ(c.data[0], a.data[0] & b.data[0]);
173 EXPECT_EQ(c.data[1], a.data[1] & b.data[1]);
174 EXPECT_EQ(c.data[2], a.data[2] & b.data[2]);
175 EXPECT_EQ(c.data[3], a.data[3] & b.data[3]);
176}
177
178TEST(uint128, Or)
179{
180 uint128_t a = engine.get_random_uint128();
181 uint128_t b = engine.get_random_uint128();
182
183 uint128_t c = a | b;
184
185 EXPECT_EQ(c.data[0], a.data[0] | b.data[0]);
186 EXPECT_EQ(c.data[1], a.data[1] | b.data[1]);
187 EXPECT_EQ(c.data[2], a.data[2] | b.data[2]);
188 EXPECT_EQ(c.data[3], a.data[3] | b.data[3]);
189}
190
191TEST(uint128, Xor)
192{
193 uint128_t a = engine.get_random_uint128();
194 uint128_t b = engine.get_random_uint128();
195
196 uint128_t c = a ^ b;
197
198 EXPECT_EQ(c.data[0], a.data[0] ^ b.data[0]);
199 EXPECT_EQ(c.data[1], a.data[1] ^ b.data[1]);
200 EXPECT_EQ(c.data[2], a.data[2] ^ b.data[2]);
201 EXPECT_EQ(c.data[3], a.data[3] ^ b.data[3]);
202}
203
204TEST(uint128, BitNot)
205{
206 uint128_t a = engine.get_random_uint128();
207
208 uint128_t c = ~a;
209
210 EXPECT_EQ(c.data[0], ~a.data[0]);
211 EXPECT_EQ(c.data[1], ~a.data[1]);
212 EXPECT_EQ(c.data[2], ~a.data[2]);
213 EXPECT_EQ(c.data[3], ~a.data[3]);
214}
215
216TEST(uint128, LogicNot)
217{
218 uint128_t a{ 1, 0, 0, 0 };
219
220 bool b = !a;
221
222 EXPECT_EQ(b, false);
223
224 uint128_t c{ 0, 0, 0, 0 };
225
226 EXPECT_EQ(!c, true);
227}
228
229TEST(uint128, Equality)
230{
231 uint128_t a{ 1, 0, 0, 0 };
232 uint128_t b{ 1, 0, 0, 0 };
233 EXPECT_EQ(a == b, true);
234
235 a = uint128_t{ 0, 1, 0, 0 };
236 EXPECT_EQ(a == b, false);
237
238 a = uint128_t{ 0, 0, 1, 0 };
239 EXPECT_EQ(a == b, false);
240
241 a = uint128_t{ 0, 0, 0, 1 };
242 EXPECT_EQ(a == b, false);
243
244 a = uint128_t{ 555, 0, 0, 1 };
245 b = uint128_t{ 535, 0, 0, 1 };
246 EXPECT_EQ(a == b, false);
247}
248
249TEST(uint128, NotEqual)
250{
251 uint128_t a{ 1, 0, 0, 0 };
252 uint128_t b{ 1, 0, 0, 0 };
253 EXPECT_EQ(a != b, false);
254
255 a = uint128_t{ 0, 1, 0, 0 };
256 EXPECT_EQ(a != b, true);
257
258 a = uint128_t{ 0, 0, 1, 0 };
259 EXPECT_EQ(a != b, true);
260
261 a = uint128_t{ 0, 0, 0, 1 };
262 EXPECT_EQ(a != b, true);
263
264 a = uint128_t{ 555, 0, 0, 1 };
265 b = uint128_t{ 535, 0, 0, 1 };
266 EXPECT_EQ(a != b, true);
267}
268
269TEST(uint128, GreaterThan)
270{
271 constexpr uint128_t a{ UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX };
272 constexpr uint128_t b{ UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX };
273 EXPECT_EQ(a > b, false);
274
275 constexpr uint128_t c = uint128_t{ UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX - 1 };
276 EXPECT_EQ(a > c, true);
277
278 constexpr uint128_t d = uint128_t{ UINT32_MAX, UINT32_MAX, UINT32_MAX - 1, UINT32_MAX };
279 EXPECT_EQ(a > d, true);
280
281 constexpr uint128_t e = uint128_t{ UINT32_MAX, UINT32_MAX - 1, UINT32_MAX, UINT32_MAX };
282 EXPECT_EQ(a > e, true);
283
284 constexpr uint128_t f = uint128_t{ UINT32_MAX - 1, UINT32_MAX, UINT32_MAX, UINT32_MAX };
285 EXPECT_EQ(a > f, true);
286}
287
288TEST(uint128, GeaterThanOrEqual)
289{
290 uint128_t a{ UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX - 1 };
291 uint128_t b{ UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX };
292 EXPECT_EQ(a >= b, false);
293
294 b = uint128_t{ UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX - 1 };
295 EXPECT_EQ(a > b, false);
296 EXPECT_EQ(a >= b, true);
297
298 b = uint128_t{ UINT32_MAX, UINT32_MAX, UINT32_MAX - 1, UINT32_MAX };
299 EXPECT_EQ(a >= b, false);
300
301 a = uint128_t{ UINT32_MAX, UINT32_MAX - 1, UINT32_MAX - 1, UINT32_MAX };
302 EXPECT_EQ(a >= b, false);
303
304 b = uint128_t{ UINT32_MAX - 1, UINT32_MAX, UINT32_MAX, UINT32_MAX };
305 EXPECT_EQ(a >= b, false);
306}
307
308TEST(uint128, ToFromBuffer)
309{
310 uint128_t a{ 1, 2, 3, 4 };
311 auto buf = to_buffer(a);
312 auto b = from_buffer<uint128_t>(buf);
313 EXPECT_EQ(a, b);
314}
315#endif
TEST
TEST(acir_formal_proofs, uint_terms_add)
Tests 128-bit unsigned addition Verifies that the ACIR implementation of addition is correct Executio...
Definition acir_loader.test.cpp:65
data
const std::vector< MemoryValue > data
Definition data_copy.test.cpp:70
a
FF a
Definition field_gt.test.cpp:52
b
FF b
Definition field_gt.test.cpp:53
engine
numeric::RNG & engine
Definition eccvm_transcript.test.cpp:282
bb
Entry point for Barretenberg command-line interface.
Definition api.hpp:5
to_buffer
std::vector< uint8_t > to_buffer(T const &value)
Definition serialize.hpp:414
uint128_t
unsigned __int128 uint128_t
Definition serialize.hpp:45
EnqueuedCallMutation::Add
@ Add