Line data Source code
1 : // Copyright (c) 2021-2022 Made to Order Software Corp. All Rights Reserved
2 : //
3 : // https://snapwebsites.org/project/snapdev
4 : // contact@m2osw.com
5 : //
6 : // This program is free software; you can redistribute it and/or modify
7 : // it under the terms of the GNU General Public License as published by
8 : // the Free Software Foundation; either version 2 of the License, or
9 : // (at your option) any later version.
10 : //
11 : // This program is distributed in the hope that it will be useful,
12 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : // GNU General Public License for more details.
15 : //
16 : // You should have received a copy of the GNU General Public License along
17 : // with this program; if not, write to the Free Software Foundation, Inc.,
18 : // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 :
20 : /** \file
21 : * \brief Verify the various __int128 extension functions.
22 : *
23 : * This file implements tests to verify:
24 : *
25 : * * support printing out 128 bit numbers
26 : * * support of 128 bit literals
27 : * * support of 128 bit powers
28 : */
29 :
30 : // self
31 : //
32 : #include "catch_main.h"
33 :
34 :
35 :
36 : // snapdev lib
37 : //
38 : #include <snapdev/ostream_int128.h>
39 : #include <snapdev/int128_literal.h>
40 : #include <snapdev/math.h>
41 :
42 :
43 : // last include
44 : //
45 : #include <snapdev/poison.h>
46 :
47 :
48 : // __int128 is not ISO C++ yet
49 : #pragma GCC diagnostic ignored "-Wpedantic"
50 :
51 :
52 7 : CATCH_TEST_CASE("ostream_int128", "[ostream][int128]")
53 : {
54 10 : CATCH_START_SECTION("ostream_int128: small numbers (-10 to +10)")
55 : {
56 22 : for(int i(-10); i <= 10; ++i)
57 : {
58 21 : __int128 l(i);
59 42 : std::stringstream vd; // decimal
60 21 : vd << l;
61 21 : CATCH_REQUIRE(vd.str() == std::to_string(i));
62 :
63 42 : std::stringstream vh, evh; // hexadecimal
64 21 : vh << std::hex << l;
65 21 : evh << (i < 0 ? "ffffffffffffffffffffffff" : "") << std::hex << i;
66 21 : CATCH_REQUIRE(vh.str() == evh.str());
67 :
68 42 : std::stringstream vu, evu; // hexadecimal in uppercase
69 21 : vu << std::hex << std::uppercase << l;
70 21 : evu << (i < 0 ? "FFFFFFFFFFFFFFFFFFFFFFFF" : "") << std::hex << std::uppercase << i;
71 21 : CATCH_REQUIRE(vu.str() == evu.str());
72 :
73 42 : std::stringstream vi, evi; // hexadecimal with base
74 21 : vi << std::hex << std::showbase << l;
75 21 : evi << (i < 0 ? "0xffffffffffffffffffffffff" : "0x") << std::hex << i;
76 21 : CATCH_REQUIRE(vi.str() == evi.str());
77 :
78 42 : std::stringstream va, eva; // hexadecimal all
79 21 : va << std::hex << std::showbase << std::uppercase << l;
80 21 : eva << (i < 0 ? "0XFFFFFFFFFFFFFFFFFFFFFFFF" : "0X") << std::hex << std::uppercase << i;
81 21 : CATCH_REQUIRE(va.str() == eva.str());
82 :
83 42 : std::stringstream vo, evo; // octal
84 21 : vo << std::oct << l;
85 21 : evo << (i < 0 ? "37777777777777777777777777777777" : "") << std::oct << (i & 0x1FFFFFFFF);
86 21 : CATCH_REQUIRE(vo.str() == evo.str());
87 :
88 42 : std::stringstream vb, evb; // octal with base
89 21 : vb << std::oct << std::showbase << l;
90 21 : evb << (i < 0 ? "037777777777777777777777777777777" : "0") << std::oct << (i & 0x1FFFFFFFF);
91 21 : CATCH_REQUIRE(vb.str() == evb.str());
92 : }
93 : }
94 : CATCH_END_SECTION()
95 :
96 10 : CATCH_START_SECTION("ostream_int128: positive numbers")
97 : {
98 1001 : for(int i(0); i < 1000; ++i)
99 : {
100 1000 : std::int32_t v((rand() & 0x7FFFFFFF));
101 1000 : __int128 l(v);
102 2000 : std::stringstream ss;
103 1000 : ss << l;
104 1000 : CATCH_REQUIRE(ss.str() == std::to_string(v));
105 : }
106 : }
107 : CATCH_END_SECTION()
108 :
109 10 : CATCH_START_SECTION("ostream_int128: negative numbers")
110 : {
111 1001 : for(int i(0); i < 1000; ++i)
112 : {
113 1000 : std::int32_t v(-(rand() & 0x7FFFFFFF));
114 1000 : __int128 l(v);
115 2000 : std::stringstream ss;
116 1000 : ss << l;
117 1000 : CATCH_REQUIRE(ss.str() == std::to_string(v));
118 : }
119 : }
120 : CATCH_END_SECTION()
121 :
122 10 : CATCH_START_SECTION("ostream_int128: most positive number")
123 : {
124 1 : unsigned __int128 l(0);
125 1 : l = ~l;
126 : {
127 2 : std::stringstream ss;
128 1 : ss << l;
129 1 : CATCH_REQUIRE(ss.str() == "340282366920938463463374607431768211455");
130 : }
131 : {
132 2 : std::stringstream ss;
133 1 : ss << std::hex << l;
134 1 : CATCH_REQUIRE(ss.str() == "ffffffffffffffffffffffffffffffff");
135 : }
136 : {
137 2 : std::stringstream ss;
138 1 : ss << std::hex << std::uppercase << l;
139 1 : CATCH_REQUIRE(ss.str() == "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
140 : }
141 : {
142 2 : std::stringstream ss;
143 1 : ss << std::hex << std::showbase << l;
144 1 : CATCH_REQUIRE(ss.str() == "0xffffffffffffffffffffffffffffffff");
145 : }
146 : {
147 2 : std::stringstream ss;
148 1 : ss << std::hex << std::uppercase << std::showbase << l;
149 1 : CATCH_REQUIRE(ss.str() == "0XFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
150 : }
151 : }
152 : CATCH_END_SECTION()
153 :
154 10 : CATCH_START_SECTION("ostream_int128: most negative number")
155 : {
156 1 : __int128 l(1);
157 1 : l <<= 127;
158 : {
159 2 : std::stringstream ss;
160 1 : ss << l;
161 1 : CATCH_REQUIRE(ss.str() == "-170141183460469231731687303715884105728");
162 : }
163 : {
164 2 : std::stringstream ss;
165 1 : ss << std::hex << l;
166 1 : CATCH_REQUIRE(ss.str() == "80000000000000000000000000000000");
167 : }
168 : }
169 : CATCH_END_SECTION()
170 5 : }
171 :
172 :
173 5 : CATCH_TEST_CASE("int128_literal", "[literal][int128]")
174 : {
175 6 : CATCH_START_SECTION("int128_literal: zero and powers of two")
176 : {
177 : using namespace snapdev::literals;
178 :
179 1 : __int128 m0(0_int128);
180 1 : CATCH_REQUIRE(m0 == 0);
181 :
182 1 : __int128 v(1);
183 : {
184 1 : __int128 l(1_int128);
185 1 : CATCH_REQUIRE(l == v);
186 : }
187 : {
188 1 : __int128 l("1"_int128);
189 1 : CATCH_REQUIRE(l == v);
190 : }
191 1 : v <<= 1;
192 : {
193 1 : __int128 l(2_int128);
194 1 : CATCH_REQUIRE(l == v);
195 : }
196 : {
197 1 : __int128 l("2"_int128);
198 1 : CATCH_REQUIRE(l == v);
199 : }
200 1 : v <<= 1;
201 : {
202 1 : __int128 l(4_int128);
203 1 : CATCH_REQUIRE(l == v);
204 : }
205 : {
206 1 : __int128 l("4"_int128);
207 1 : CATCH_REQUIRE(l == v);
208 : }
209 1 : v <<= 1;
210 : {
211 1 : __int128 l(8_int128);
212 1 : CATCH_REQUIRE(l == v);
213 : }
214 : {
215 1 : __int128 l("8"_int128);
216 1 : CATCH_REQUIRE(l == v);
217 : }
218 1 : v <<= 1;
219 : {
220 1 : __int128 l(16_int128);
221 1 : CATCH_REQUIRE(l == v);
222 : }
223 : {
224 1 : __int128 l("16"_int128);
225 1 : CATCH_REQUIRE(l == v);
226 : }
227 1 : v <<= 1;
228 : {
229 1 : __int128 l(32_int128);
230 1 : CATCH_REQUIRE(l == v);
231 : }
232 : {
233 1 : __int128 l("32"_int128);
234 1 : CATCH_REQUIRE(l == v);
235 : }
236 1 : v <<= 1;
237 : {
238 1 : __int128 l(64_int128);
239 1 : CATCH_REQUIRE(l == v);
240 : }
241 : {
242 1 : __int128 l("64"_int128);
243 1 : CATCH_REQUIRE(l == v);
244 : }
245 1 : v <<= 1;
246 : {
247 1 : __int128 l(128_int128);
248 1 : CATCH_REQUIRE(l == v);
249 : }
250 : {
251 1 : __int128 l("128"_int128);
252 1 : CATCH_REQUIRE(l == v);
253 : }
254 1 : v <<= 1;
255 : {
256 1 : __int128 l(256_int128);
257 1 : CATCH_REQUIRE(l == v);
258 : }
259 : {
260 1 : __int128 l("256"_int128);
261 1 : CATCH_REQUIRE(l == v);
262 : }
263 1 : v <<= 1;
264 : {
265 1 : __int128 l(512_int128);
266 1 : CATCH_REQUIRE(l == v);
267 : }
268 : {
269 1 : __int128 l("512"_int128);
270 1 : CATCH_REQUIRE(l == v);
271 : }
272 1 : v <<= 1;
273 : {
274 1 : __int128 l(1024_int128);
275 1 : CATCH_REQUIRE(l == v);
276 : }
277 : {
278 1 : __int128 l("1024"_int128);
279 1 : CATCH_REQUIRE(l == v);
280 : }
281 1 : v <<= 1;
282 : {
283 1 : __int128 l(2048_int128);
284 1 : CATCH_REQUIRE(l == v);
285 : }
286 : {
287 1 : __int128 l("2048"_int128);
288 1 : CATCH_REQUIRE(l == v);
289 : }
290 1 : v <<= 1;
291 : {
292 1 : __int128 l(4096_int128);
293 1 : CATCH_REQUIRE(l == v);
294 : }
295 : {
296 1 : __int128 l("4096"_int128);
297 1 : CATCH_REQUIRE(l == v);
298 : }
299 1 : v <<= 1;
300 : {
301 1 : __int128 l(8192_int128);
302 1 : CATCH_REQUIRE(l == v);
303 : }
304 : {
305 1 : __int128 l("8192"_int128);
306 1 : CATCH_REQUIRE(l == v);
307 : }
308 1 : v <<= 1;
309 : {
310 1 : __int128 l(16384_int128);
311 1 : CATCH_REQUIRE(l == v);
312 : }
313 : {
314 1 : __int128 l("16384"_int128);
315 1 : CATCH_REQUIRE(l == v);
316 : }
317 1 : v <<= 1;
318 : {
319 1 : __int128 l(32768_int128);
320 1 : CATCH_REQUIRE(l == v);
321 : }
322 : {
323 1 : __int128 l("32768"_int128);
324 1 : CATCH_REQUIRE(l == v);
325 : }
326 1 : v <<= 1;
327 : {
328 1 : __int128 l(65536_int128);
329 1 : CATCH_REQUIRE(l == v);
330 : }
331 : {
332 1 : __int128 l("65536"_int128);
333 1 : CATCH_REQUIRE(l == v);
334 : }
335 1 : v <<= 1;
336 : {
337 1 : __int128 l(131072_int128);
338 1 : CATCH_REQUIRE(l == v);
339 : }
340 : {
341 1 : __int128 l("131072"_int128);
342 1 : CATCH_REQUIRE(l == v);
343 : }
344 1 : v <<= 1;
345 : {
346 1 : __int128 l(262144_int128);
347 1 : CATCH_REQUIRE(l == v);
348 : }
349 : {
350 1 : __int128 l("262144"_int128);
351 1 : CATCH_REQUIRE(l == v);
352 : }
353 1 : v <<= 1;
354 : {
355 1 : __int128 l(524288_int128);
356 1 : CATCH_REQUIRE(l == v);
357 : }
358 : {
359 1 : __int128 l("524288"_int128);
360 1 : CATCH_REQUIRE(l == v);
361 : }
362 1 : v <<= 1;
363 : {
364 1 : __int128 l(1048576_int128);
365 1 : CATCH_REQUIRE(l == v);
366 : }
367 : {
368 1 : __int128 l("1048576"_int128);
369 1 : CATCH_REQUIRE(l == v);
370 : }
371 1 : v <<= 1;
372 : {
373 1 : __int128 l(2097152_int128);
374 1 : CATCH_REQUIRE(l == v);
375 : }
376 : {
377 1 : __int128 l("2097152"_int128);
378 1 : CATCH_REQUIRE(l == v);
379 : }
380 1 : v <<= 1;
381 : {
382 1 : __int128 l(4194304_int128);
383 1 : CATCH_REQUIRE(l == v);
384 : }
385 : {
386 1 : __int128 l("4194304"_int128);
387 1 : CATCH_REQUIRE(l == v);
388 : }
389 1 : v <<= 1;
390 : {
391 1 : __int128 l(8388608_int128);
392 1 : CATCH_REQUIRE(l == v);
393 : }
394 : {
395 1 : __int128 l("8388608"_int128);
396 1 : CATCH_REQUIRE(l == v);
397 : }
398 1 : v <<= 1;
399 : {
400 1 : __int128 l(16777216_int128);
401 1 : CATCH_REQUIRE(l == v);
402 : }
403 : {
404 1 : __int128 l("16777216"_int128);
405 1 : CATCH_REQUIRE(l == v);
406 : }
407 1 : v <<= 1;
408 : {
409 1 : __int128 l(33554432_int128);
410 1 : CATCH_REQUIRE(l == v);
411 : }
412 : {
413 1 : __int128 l("33554432"_int128);
414 1 : CATCH_REQUIRE(l == v);
415 : }
416 1 : v <<= 1;
417 : {
418 1 : __int128 l(67108864_int128);
419 1 : CATCH_REQUIRE(l == v);
420 : }
421 : {
422 1 : __int128 l("67108864"_int128);
423 1 : CATCH_REQUIRE(l == v);
424 : }
425 1 : v <<= 1;
426 : {
427 1 : __int128 l(134217728_int128);
428 1 : CATCH_REQUIRE(l == v);
429 : }
430 : {
431 1 : __int128 l("134217728"_int128);
432 1 : CATCH_REQUIRE(l == v);
433 : }
434 1 : v <<= 1;
435 : {
436 1 : __int128 l(268435456_int128);
437 1 : CATCH_REQUIRE(l == v);
438 : }
439 : {
440 1 : __int128 l("268435456"_int128);
441 1 : CATCH_REQUIRE(l == v);
442 : }
443 1 : v <<= 1;
444 : {
445 1 : __int128 l(536870912_int128);
446 1 : CATCH_REQUIRE(l == v);
447 : }
448 : {
449 1 : __int128 l("536870912"_int128);
450 1 : CATCH_REQUIRE(l == v);
451 : }
452 1 : v <<= 1;
453 : {
454 1 : __int128 l(1073741824_int128);
455 1 : CATCH_REQUIRE(l == v);
456 : }
457 : {
458 1 : __int128 l("1073741824"_int128);
459 1 : CATCH_REQUIRE(l == v);
460 : }
461 1 : v <<= 1;
462 : {
463 1 : __int128 l(2147483648_int128);
464 1 : CATCH_REQUIRE(l == v);
465 : }
466 : {
467 1 : __int128 l("2147483648"_int128);
468 1 : CATCH_REQUIRE(l == v);
469 : }
470 1 : v <<= 1;
471 : {
472 1 : __int128 l(4294967296_int128);
473 1 : CATCH_REQUIRE(l == v);
474 : }
475 : {
476 1 : __int128 l("4294967296"_int128);
477 1 : CATCH_REQUIRE(l == v);
478 : }
479 1 : v <<= 1;
480 : {
481 1 : __int128 l(8589934592_int128);
482 1 : CATCH_REQUIRE(l == v);
483 : }
484 : {
485 1 : __int128 l("8589934592"_int128);
486 1 : CATCH_REQUIRE(l == v);
487 : }
488 1 : v <<= 1;
489 : {
490 1 : __int128 l(17179869184_int128);
491 1 : CATCH_REQUIRE(l == v);
492 : }
493 : {
494 1 : __int128 l("17179869184"_int128);
495 1 : CATCH_REQUIRE(l == v);
496 : }
497 1 : v <<= 1;
498 : {
499 1 : __int128 l(34359738368_int128);
500 1 : CATCH_REQUIRE(l == v);
501 : }
502 : {
503 1 : __int128 l("34359738368"_int128);
504 1 : CATCH_REQUIRE(l == v);
505 : }
506 1 : v <<= 1;
507 : {
508 1 : __int128 l(68719476736_int128);
509 1 : CATCH_REQUIRE(l == v);
510 : }
511 : {
512 1 : __int128 l("68719476736"_int128);
513 1 : CATCH_REQUIRE(l == v);
514 : }
515 1 : v <<= 1;
516 : {
517 1 : __int128 l(137438953472_int128);
518 1 : CATCH_REQUIRE(l == v);
519 : }
520 : {
521 1 : __int128 l("137438953472"_int128);
522 1 : CATCH_REQUIRE(l == v);
523 : }
524 1 : v <<= 1;
525 : {
526 1 : __int128 l(274877906944_int128);
527 1 : CATCH_REQUIRE(l == v);
528 : }
529 : {
530 1 : __int128 l("274877906944"_int128);
531 1 : CATCH_REQUIRE(l == v);
532 : }
533 1 : v <<= 1;
534 : {
535 1 : __int128 l(549755813888_int128);
536 1 : CATCH_REQUIRE(l == v);
537 : }
538 : {
539 1 : __int128 l("549755813888"_int128);
540 1 : CATCH_REQUIRE(l == v);
541 : }
542 1 : v <<= 1;
543 : {
544 1 : __int128 l(1099511627776_int128);
545 1 : CATCH_REQUIRE(l == v);
546 : }
547 : {
548 1 : __int128 l("1099511627776"_int128);
549 1 : CATCH_REQUIRE(l == v);
550 : }
551 1 : v <<= 1;
552 : {
553 1 : __int128 l(2199023255552_int128);
554 1 : CATCH_REQUIRE(l == v);
555 : }
556 : {
557 1 : __int128 l("2199023255552"_int128);
558 1 : CATCH_REQUIRE(l == v);
559 : }
560 1 : v <<= 1;
561 : {
562 1 : __int128 l(4398046511104_int128);
563 1 : CATCH_REQUIRE(l == v);
564 : }
565 : {
566 1 : __int128 l("4398046511104"_int128);
567 1 : CATCH_REQUIRE(l == v);
568 : }
569 1 : v <<= 1;
570 : {
571 1 : __int128 l(8796093022208_int128);
572 1 : CATCH_REQUIRE(l == v);
573 : }
574 : {
575 1 : __int128 l("8796093022208"_int128);
576 1 : CATCH_REQUIRE(l == v);
577 : }
578 1 : v <<= 1;
579 : {
580 1 : __int128 l(17592186044416_int128);
581 1 : CATCH_REQUIRE(l == v);
582 : }
583 : {
584 1 : __int128 l("17592186044416"_int128);
585 1 : CATCH_REQUIRE(l == v);
586 : }
587 1 : v <<= 1;
588 : {
589 1 : __int128 l(35184372088832_int128);
590 1 : CATCH_REQUIRE(l == v);
591 : }
592 : {
593 1 : __int128 l("35184372088832"_int128);
594 1 : CATCH_REQUIRE(l == v);
595 : }
596 1 : v <<= 1;
597 : {
598 1 : __int128 l(70368744177664_int128);
599 1 : CATCH_REQUIRE(l == v);
600 : }
601 : {
602 1 : __int128 l("70368744177664"_int128);
603 1 : CATCH_REQUIRE(l == v);
604 : }
605 1 : v <<= 1;
606 : {
607 1 : __int128 l(140737488355328_int128);
608 1 : CATCH_REQUIRE(l == v);
609 : }
610 : {
611 1 : __int128 l("140737488355328"_int128);
612 1 : CATCH_REQUIRE(l == v);
613 : }
614 1 : v <<= 1;
615 : {
616 1 : __int128 l(281474976710656_int128);
617 1 : CATCH_REQUIRE(l == v);
618 : }
619 : {
620 1 : __int128 l("281474976710656"_int128);
621 1 : CATCH_REQUIRE(l == v);
622 : }
623 1 : v <<= 1;
624 : {
625 1 : __int128 l(562949953421312_int128);
626 1 : CATCH_REQUIRE(l == v);
627 : }
628 : {
629 1 : __int128 l("562949953421312"_int128);
630 1 : CATCH_REQUIRE(l == v);
631 : }
632 1 : v <<= 1;
633 : {
634 1 : __int128 l(1125899906842624_int128);
635 1 : CATCH_REQUIRE(l == v);
636 : }
637 : {
638 1 : __int128 l("1125899906842624"_int128);
639 1 : CATCH_REQUIRE(l == v);
640 : }
641 1 : v <<= 1;
642 : {
643 1 : __int128 l(2251799813685248_int128);
644 1 : CATCH_REQUIRE(l == v);
645 : }
646 : {
647 1 : __int128 l("2251799813685248"_int128);
648 1 : CATCH_REQUIRE(l == v);
649 : }
650 1 : v <<= 1;
651 : {
652 1 : __int128 l(4503599627370496_int128);
653 1 : CATCH_REQUIRE(l == v);
654 : }
655 : {
656 1 : __int128 l("4503599627370496"_int128);
657 1 : CATCH_REQUIRE(l == v);
658 : }
659 1 : v <<= 1;
660 : {
661 1 : __int128 l(9007199254740992_int128);
662 1 : CATCH_REQUIRE(l == v);
663 : }
664 : {
665 1 : __int128 l("9007199254740992"_int128);
666 1 : CATCH_REQUIRE(l == v);
667 : }
668 1 : v <<= 1;
669 : {
670 1 : __int128 l(18014398509481984_int128);
671 1 : CATCH_REQUIRE(l == v);
672 : }
673 : {
674 1 : __int128 l("18014398509481984"_int128);
675 1 : CATCH_REQUIRE(l == v);
676 : }
677 1 : v <<= 1;
678 : {
679 1 : __int128 l(36028797018963968_int128);
680 1 : CATCH_REQUIRE(l == v);
681 : }
682 : {
683 1 : __int128 l("36028797018963968"_int128);
684 1 : CATCH_REQUIRE(l == v);
685 : }
686 1 : v <<= 1;
687 : {
688 1 : __int128 l(72057594037927936_int128);
689 1 : CATCH_REQUIRE(l == v);
690 : }
691 : {
692 1 : __int128 l("72057594037927936"_int128);
693 1 : CATCH_REQUIRE(l == v);
694 : }
695 1 : v <<= 1;
696 : {
697 1 : __int128 l(144115188075855872_int128);
698 1 : CATCH_REQUIRE(l == v);
699 : }
700 : {
701 1 : __int128 l("144115188075855872"_int128);
702 1 : CATCH_REQUIRE(l == v);
703 : }
704 1 : v <<= 1;
705 : {
706 1 : __int128 l(288230376151711744_int128);
707 1 : CATCH_REQUIRE(l == v);
708 : }
709 : {
710 1 : __int128 l("288230376151711744"_int128);
711 1 : CATCH_REQUIRE(l == v);
712 : }
713 1 : v <<= 1;
714 : {
715 1 : __int128 l(576460752303423488_int128);
716 1 : CATCH_REQUIRE(l == v);
717 : }
718 : {
719 1 : __int128 l("576460752303423488"_int128);
720 1 : CATCH_REQUIRE(l == v);
721 : }
722 1 : v <<= 1;
723 : {
724 1 : __int128 l(1152921504606846976_int128);
725 1 : CATCH_REQUIRE(l == v);
726 : }
727 : {
728 1 : __int128 l("1152921504606846976"_int128);
729 1 : CATCH_REQUIRE(l == v);
730 : }
731 1 : v <<= 1;
732 : {
733 1 : __int128 l(2305843009213693952_int128);
734 1 : CATCH_REQUIRE(l == v);
735 : }
736 : {
737 1 : __int128 l("2305843009213693952"_int128);
738 1 : CATCH_REQUIRE(l == v);
739 : }
740 1 : v <<= 1;
741 : {
742 1 : __int128 l(4611686018427387904_int128);
743 1 : CATCH_REQUIRE(l == v);
744 : }
745 : {
746 1 : __int128 l("4611686018427387904"_int128);
747 1 : CATCH_REQUIRE(l == v);
748 : }
749 1 : v <<= 1;
750 : {
751 1 : __int128 l(9223372036854775808_int128);
752 1 : CATCH_REQUIRE(l == v);
753 : }
754 : {
755 1 : __int128 l("9223372036854775808"_int128);
756 1 : CATCH_REQUIRE(l == v);
757 : }
758 1 : v <<= 1;
759 : {
760 1 : __int128 l(18446744073709551616_int128);
761 1 : CATCH_REQUIRE(l == v);
762 : }
763 : {
764 1 : __int128 l("18446744073709551616"_int128);
765 1 : CATCH_REQUIRE(l == v);
766 : }
767 1 : v <<= 1;
768 : {
769 1 : __int128 l(36893488147419103232_int128);
770 1 : CATCH_REQUIRE(l == v);
771 : }
772 : {
773 1 : __int128 l("36893488147419103232"_int128);
774 1 : CATCH_REQUIRE(l == v);
775 : }
776 1 : v <<= 1;
777 : {
778 1 : __int128 l(73786976294838206464_int128);
779 1 : CATCH_REQUIRE(l == v);
780 : }
781 : {
782 1 : __int128 l("73786976294838206464"_int128);
783 1 : CATCH_REQUIRE(l == v);
784 : }
785 1 : v <<= 1;
786 : {
787 1 : __int128 l(147573952589676412928_int128);
788 1 : CATCH_REQUIRE(l == v);
789 : }
790 : {
791 1 : __int128 l("147573952589676412928"_int128);
792 1 : CATCH_REQUIRE(l == v);
793 : }
794 1 : v <<= 1;
795 : {
796 1 : __int128 l(295147905179352825856_int128);
797 1 : CATCH_REQUIRE(l == v);
798 : }
799 : {
800 1 : __int128 l("295147905179352825856"_int128);
801 1 : CATCH_REQUIRE(l == v);
802 : }
803 1 : v <<= 1;
804 : {
805 1 : __int128 l(590295810358705651712_int128);
806 1 : CATCH_REQUIRE(l == v);
807 : }
808 : {
809 1 : __int128 l("590295810358705651712"_int128);
810 1 : CATCH_REQUIRE(l == v);
811 : }
812 1 : v <<= 1;
813 : {
814 1 : __int128 l(1180591620717411303424_int128);
815 1 : CATCH_REQUIRE(l == v);
816 : }
817 : {
818 1 : __int128 l("1180591620717411303424"_int128);
819 1 : CATCH_REQUIRE(l == v);
820 : }
821 1 : v <<= 1;
822 : {
823 1 : __int128 l(2361183241434822606848_int128);
824 1 : CATCH_REQUIRE(l == v);
825 : }
826 : {
827 1 : __int128 l("2361183241434822606848"_int128);
828 1 : CATCH_REQUIRE(l == v);
829 : }
830 1 : v <<= 1;
831 : {
832 1 : __int128 l(4722366482869645213696_int128);
833 1 : CATCH_REQUIRE(l == v);
834 : }
835 : {
836 1 : __int128 l("4722366482869645213696"_int128);
837 1 : CATCH_REQUIRE(l == v);
838 : }
839 1 : v <<= 1;
840 : {
841 1 : __int128 l(9444732965739290427392_int128);
842 1 : CATCH_REQUIRE(l == v);
843 : }
844 : {
845 1 : __int128 l("9444732965739290427392"_int128);
846 1 : CATCH_REQUIRE(l == v);
847 : }
848 1 : v <<= 1;
849 : {
850 1 : __int128 l(18889465931478580854784_int128);
851 1 : CATCH_REQUIRE(l == v);
852 : }
853 : {
854 1 : __int128 l("18889465931478580854784"_int128);
855 1 : CATCH_REQUIRE(l == v);
856 : }
857 1 : v <<= 1;
858 : {
859 1 : __int128 l(37778931862957161709568_int128);
860 1 : CATCH_REQUIRE(l == v);
861 : }
862 : {
863 1 : __int128 l("37778931862957161709568"_int128);
864 1 : CATCH_REQUIRE(l == v);
865 : }
866 1 : v <<= 1;
867 : {
868 1 : __int128 l(75557863725914323419136_int128);
869 1 : CATCH_REQUIRE(l == v);
870 : }
871 : {
872 1 : __int128 l("75557863725914323419136"_int128);
873 1 : CATCH_REQUIRE(l == v);
874 : }
875 1 : v <<= 1;
876 : {
877 1 : __int128 l(151115727451828646838272_int128);
878 1 : CATCH_REQUIRE(l == v);
879 : }
880 : {
881 1 : __int128 l("151115727451828646838272"_int128);
882 1 : CATCH_REQUIRE(l == v);
883 : }
884 1 : v <<= 1;
885 : {
886 1 : __int128 l(302231454903657293676544_int128);
887 1 : CATCH_REQUIRE(l == v);
888 : }
889 : {
890 1 : __int128 l("302231454903657293676544"_int128);
891 1 : CATCH_REQUIRE(l == v);
892 : }
893 1 : v <<= 1;
894 : {
895 1 : __int128 l(604462909807314587353088_int128);
896 1 : CATCH_REQUIRE(l == v);
897 : }
898 : {
899 1 : __int128 l("604462909807314587353088"_int128);
900 1 : CATCH_REQUIRE(l == v);
901 : }
902 1 : v <<= 1;
903 : {
904 1 : __int128 l(1208925819614629174706176_int128);
905 1 : CATCH_REQUIRE(l == v);
906 : }
907 : {
908 1 : __int128 l("1208925819614629174706176"_int128);
909 1 : CATCH_REQUIRE(l == v);
910 : }
911 1 : v <<= 1;
912 : {
913 1 : __int128 l(2417851639229258349412352_int128);
914 1 : CATCH_REQUIRE(l == v);
915 : }
916 : {
917 1 : __int128 l("2417851639229258349412352"_int128);
918 1 : CATCH_REQUIRE(l == v);
919 : }
920 1 : v <<= 1;
921 : {
922 1 : __int128 l(4835703278458516698824704_int128);
923 1 : CATCH_REQUIRE(l == v);
924 : }
925 : {
926 1 : __int128 l("4835703278458516698824704"_int128);
927 1 : CATCH_REQUIRE(l == v);
928 : }
929 1 : v <<= 1;
930 : {
931 1 : __int128 l(9671406556917033397649408_int128);
932 1 : CATCH_REQUIRE(l == v);
933 : }
934 : {
935 1 : __int128 l("9671406556917033397649408"_int128);
936 1 : CATCH_REQUIRE(l == v);
937 : }
938 1 : v <<= 1;
939 : {
940 1 : __int128 l(19342813113834066795298816_int128);
941 1 : CATCH_REQUIRE(l == v);
942 : }
943 : {
944 1 : __int128 l("19342813113834066795298816"_int128);
945 1 : CATCH_REQUIRE(l == v);
946 : }
947 1 : v <<= 1;
948 : {
949 1 : __int128 l(38685626227668133590597632_int128);
950 1 : CATCH_REQUIRE(l == v);
951 : }
952 : {
953 1 : __int128 l("38685626227668133590597632"_int128);
954 1 : CATCH_REQUIRE(l == v);
955 : }
956 1 : v <<= 1;
957 : {
958 1 : __int128 l(77371252455336267181195264_int128);
959 1 : CATCH_REQUIRE(l == v);
960 : }
961 : {
962 1 : __int128 l("77371252455336267181195264"_int128);
963 1 : CATCH_REQUIRE(l == v);
964 : }
965 1 : v <<= 1;
966 : {
967 1 : __int128 l(154742504910672534362390528_int128);
968 1 : CATCH_REQUIRE(l == v);
969 : }
970 : {
971 1 : __int128 l("154742504910672534362390528"_int128);
972 1 : CATCH_REQUIRE(l == v);
973 : }
974 1 : v <<= 1;
975 : {
976 1 : __int128 l(309485009821345068724781056_int128);
977 1 : CATCH_REQUIRE(l == v);
978 : }
979 : {
980 1 : __int128 l("309485009821345068724781056"_int128);
981 1 : CATCH_REQUIRE(l == v);
982 : }
983 1 : v <<= 1;
984 : {
985 1 : __int128 l(618970019642690137449562112_int128);
986 1 : CATCH_REQUIRE(l == v);
987 : }
988 : {
989 1 : __int128 l("618970019642690137449562112"_int128);
990 1 : CATCH_REQUIRE(l == v);
991 : }
992 1 : v <<= 1;
993 : {
994 1 : __int128 l(1237940039285380274899124224_int128);
995 1 : CATCH_REQUIRE(l == v);
996 : }
997 : {
998 1 : __int128 l("1237940039285380274899124224"_int128);
999 1 : CATCH_REQUIRE(l == v);
1000 : }
1001 1 : v <<= 1;
1002 : {
1003 1 : __int128 l(2475880078570760549798248448_int128);
1004 1 : CATCH_REQUIRE(l == v);
1005 : }
1006 : {
1007 1 : __int128 l("2475880078570760549798248448"_int128);
1008 1 : CATCH_REQUIRE(l == v);
1009 : }
1010 1 : v <<= 1;
1011 : {
1012 1 : __int128 l(4951760157141521099596496896_int128);
1013 1 : CATCH_REQUIRE(l == v);
1014 : }
1015 : {
1016 1 : __int128 l("4951760157141521099596496896"_int128);
1017 1 : CATCH_REQUIRE(l == v);
1018 : }
1019 1 : v <<= 1;
1020 : {
1021 1 : __int128 l(9903520314283042199192993792_int128);
1022 1 : CATCH_REQUIRE(l == v);
1023 : }
1024 : {
1025 1 : __int128 l("9903520314283042199192993792"_int128);
1026 1 : CATCH_REQUIRE(l == v);
1027 : }
1028 1 : v <<= 1;
1029 : {
1030 1 : __int128 l(19807040628566084398385987584_int128);
1031 1 : CATCH_REQUIRE(l == v);
1032 : }
1033 : {
1034 1 : __int128 l("19807040628566084398385987584"_int128);
1035 1 : CATCH_REQUIRE(l == v);
1036 : }
1037 1 : v <<= 1;
1038 : {
1039 1 : __int128 l(39614081257132168796771975168_int128);
1040 1 : CATCH_REQUIRE(l == v);
1041 : }
1042 : {
1043 1 : __int128 l("39614081257132168796771975168"_int128);
1044 1 : CATCH_REQUIRE(l == v);
1045 : }
1046 1 : v <<= 1;
1047 : {
1048 1 : __int128 l(79228162514264337593543950336_int128);
1049 1 : CATCH_REQUIRE(l == v);
1050 : }
1051 : {
1052 1 : __int128 l("79228162514264337593543950336"_int128);
1053 1 : CATCH_REQUIRE(l == v);
1054 : }
1055 1 : v <<= 1;
1056 : {
1057 1 : __int128 l(158456325028528675187087900672_int128);
1058 1 : CATCH_REQUIRE(l == v);
1059 : }
1060 : {
1061 1 : __int128 l("158456325028528675187087900672"_int128);
1062 1 : CATCH_REQUIRE(l == v);
1063 : }
1064 1 : v <<= 1;
1065 : {
1066 1 : __int128 l(316912650057057350374175801344_int128);
1067 1 : CATCH_REQUIRE(l == v);
1068 : }
1069 : {
1070 1 : __int128 l("316912650057057350374175801344"_int128);
1071 1 : CATCH_REQUIRE(l == v);
1072 : }
1073 1 : v <<= 1;
1074 : {
1075 1 : __int128 l(633825300114114700748351602688_int128);
1076 1 : CATCH_REQUIRE(l == v);
1077 : }
1078 : {
1079 1 : __int128 l("633825300114114700748351602688"_int128);
1080 1 : CATCH_REQUIRE(l == v);
1081 : }
1082 1 : v <<= 1;
1083 : {
1084 1 : __int128 l(1267650600228229401496703205376_int128);
1085 1 : CATCH_REQUIRE(l == v);
1086 : }
1087 : {
1088 1 : __int128 l("1267650600228229401496703205376"_int128);
1089 1 : CATCH_REQUIRE(l == v);
1090 : }
1091 1 : v <<= 1;
1092 : {
1093 1 : __int128 l(2535301200456458802993406410752_int128);
1094 1 : CATCH_REQUIRE(l == v);
1095 : }
1096 : {
1097 1 : __int128 l("2535301200456458802993406410752"_int128);
1098 1 : CATCH_REQUIRE(l == v);
1099 : }
1100 1 : v <<= 1;
1101 : {
1102 1 : __int128 l(5070602400912917605986812821504_int128);
1103 1 : CATCH_REQUIRE(l == v);
1104 : }
1105 : {
1106 1 : __int128 l("5070602400912917605986812821504"_int128);
1107 1 : CATCH_REQUIRE(l == v);
1108 : }
1109 1 : v <<= 1;
1110 : {
1111 1 : __int128 l(10141204801825835211973625643008_int128);
1112 1 : CATCH_REQUIRE(l == v);
1113 : }
1114 : {
1115 1 : __int128 l("10141204801825835211973625643008"_int128);
1116 1 : CATCH_REQUIRE(l == v);
1117 : }
1118 1 : v <<= 1;
1119 : {
1120 1 : __int128 l(20282409603651670423947251286016_int128);
1121 1 : CATCH_REQUIRE(l == v);
1122 : }
1123 : {
1124 1 : __int128 l("20282409603651670423947251286016"_int128);
1125 1 : CATCH_REQUIRE(l == v);
1126 : }
1127 1 : v <<= 1;
1128 : {
1129 1 : __int128 l(40564819207303340847894502572032_int128);
1130 1 : CATCH_REQUIRE(l == v);
1131 : }
1132 : {
1133 1 : __int128 l("40564819207303340847894502572032"_int128);
1134 1 : CATCH_REQUIRE(l == v);
1135 : }
1136 1 : v <<= 1;
1137 : {
1138 1 : __int128 l(81129638414606681695789005144064_int128);
1139 1 : CATCH_REQUIRE(l == v);
1140 : }
1141 : {
1142 1 : __int128 l("81129638414606681695789005144064"_int128);
1143 1 : CATCH_REQUIRE(l == v);
1144 : }
1145 1 : v <<= 1;
1146 : {
1147 1 : __int128 l(162259276829213363391578010288128_int128);
1148 1 : CATCH_REQUIRE(l == v);
1149 : }
1150 : {
1151 1 : __int128 l("162259276829213363391578010288128"_int128);
1152 1 : CATCH_REQUIRE(l == v);
1153 : }
1154 1 : v <<= 1;
1155 : {
1156 1 : __int128 l(324518553658426726783156020576256_int128);
1157 1 : CATCH_REQUIRE(l == v);
1158 : }
1159 : {
1160 1 : __int128 l("324518553658426726783156020576256"_int128);
1161 1 : CATCH_REQUIRE(l == v);
1162 : }
1163 1 : v <<= 1;
1164 : {
1165 1 : __int128 l(649037107316853453566312041152512_int128);
1166 1 : CATCH_REQUIRE(l == v);
1167 : }
1168 : {
1169 1 : __int128 l("649037107316853453566312041152512"_int128);
1170 1 : CATCH_REQUIRE(l == v);
1171 : }
1172 1 : v <<= 1;
1173 : {
1174 1 : __int128 l(1298074214633706907132624082305024_int128);
1175 1 : CATCH_REQUIRE(l == v);
1176 : }
1177 : {
1178 1 : __int128 l("1298074214633706907132624082305024"_int128);
1179 1 : CATCH_REQUIRE(l == v);
1180 : }
1181 1 : v <<= 1;
1182 : {
1183 1 : __int128 l(2596148429267413814265248164610048_int128);
1184 1 : CATCH_REQUIRE(l == v);
1185 : }
1186 : {
1187 1 : __int128 l("2596148429267413814265248164610048"_int128);
1188 1 : CATCH_REQUIRE(l == v);
1189 : }
1190 1 : v <<= 1;
1191 : {
1192 1 : __int128 l(5192296858534827628530496329220096_int128);
1193 1 : CATCH_REQUIRE(l == v);
1194 : }
1195 : {
1196 1 : __int128 l("5192296858534827628530496329220096"_int128);
1197 1 : CATCH_REQUIRE(l == v);
1198 : }
1199 1 : v <<= 1;
1200 : {
1201 1 : __int128 l(10384593717069655257060992658440192_int128);
1202 1 : CATCH_REQUIRE(l == v);
1203 : }
1204 : {
1205 1 : __int128 l("10384593717069655257060992658440192"_int128);
1206 1 : CATCH_REQUIRE(l == v);
1207 : }
1208 1 : v <<= 1;
1209 : {
1210 1 : __int128 l(20769187434139310514121985316880384_int128);
1211 1 : CATCH_REQUIRE(l == v);
1212 : }
1213 : {
1214 1 : __int128 l("20769187434139310514121985316880384"_int128);
1215 1 : CATCH_REQUIRE(l == v);
1216 : }
1217 1 : v <<= 1;
1218 : {
1219 1 : __int128 l(41538374868278621028243970633760768_int128);
1220 1 : CATCH_REQUIRE(l == v);
1221 : }
1222 : {
1223 1 : __int128 l("41538374868278621028243970633760768"_int128);
1224 1 : CATCH_REQUIRE(l == v);
1225 : }
1226 1 : v <<= 1;
1227 : {
1228 1 : __int128 l(83076749736557242056487941267521536_int128);
1229 1 : CATCH_REQUIRE(l == v);
1230 : }
1231 : {
1232 1 : __int128 l("83076749736557242056487941267521536"_int128);
1233 1 : CATCH_REQUIRE(l == v);
1234 : }
1235 1 : v <<= 1;
1236 : {
1237 1 : __int128 l(166153499473114484112975882535043072_int128);
1238 1 : CATCH_REQUIRE(l == v);
1239 : }
1240 : {
1241 1 : __int128 l("166153499473114484112975882535043072"_int128);
1242 1 : CATCH_REQUIRE(l == v);
1243 : }
1244 1 : v <<= 1;
1245 : {
1246 1 : __int128 l(332306998946228968225951765070086144_int128);
1247 1 : CATCH_REQUIRE(l == v);
1248 : }
1249 : {
1250 1 : __int128 l("332306998946228968225951765070086144"_int128);
1251 1 : CATCH_REQUIRE(l == v);
1252 : }
1253 1 : v <<= 1;
1254 : {
1255 1 : __int128 l(664613997892457936451903530140172288_int128);
1256 1 : CATCH_REQUIRE(l == v);
1257 : }
1258 : {
1259 1 : __int128 l("664613997892457936451903530140172288"_int128);
1260 1 : CATCH_REQUIRE(l == v);
1261 : }
1262 1 : v <<= 1;
1263 : {
1264 1 : __int128 l(1329227995784915872903807060280344576_int128);
1265 1 : CATCH_REQUIRE(l == v);
1266 : }
1267 : {
1268 1 : __int128 l("1329227995784915872903807060280344576"_int128);
1269 1 : CATCH_REQUIRE(l == v);
1270 : }
1271 1 : v <<= 1;
1272 : {
1273 1 : __int128 l(2658455991569831745807614120560689152_int128);
1274 1 : CATCH_REQUIRE(l == v);
1275 : }
1276 : {
1277 1 : __int128 l("2658455991569831745807614120560689152"_int128);
1278 1 : CATCH_REQUIRE(l == v);
1279 : }
1280 1 : v <<= 1;
1281 : {
1282 1 : __int128 l(5316911983139663491615228241121378304_int128);
1283 1 : CATCH_REQUIRE(l == v);
1284 : }
1285 : {
1286 1 : __int128 l("5316911983139663491615228241121378304"_int128);
1287 1 : CATCH_REQUIRE(l == v);
1288 : }
1289 1 : v <<= 1;
1290 : {
1291 1 : __int128 l(10633823966279326983230456482242756608_int128);
1292 1 : CATCH_REQUIRE(l == v);
1293 : }
1294 : {
1295 1 : __int128 l("10633823966279326983230456482242756608"_int128);
1296 1 : CATCH_REQUIRE(l == v);
1297 : }
1298 1 : v <<= 1;
1299 : {
1300 1 : __int128 l(21267647932558653966460912964485513216_int128);
1301 1 : CATCH_REQUIRE(l == v);
1302 : }
1303 : {
1304 1 : __int128 l("21267647932558653966460912964485513216"_int128);
1305 1 : CATCH_REQUIRE(l == v);
1306 : }
1307 1 : v <<= 1;
1308 : {
1309 1 : __int128 l(42535295865117307932921825928971026432_int128);
1310 1 : CATCH_REQUIRE(l == v);
1311 : }
1312 : {
1313 1 : __int128 l("42535295865117307932921825928971026432"_int128);
1314 1 : CATCH_REQUIRE(l == v);
1315 : }
1316 1 : v <<= 1;
1317 : {
1318 1 : __int128 l(85070591730234615865843651857942052864_int128);
1319 1 : CATCH_REQUIRE(l == v);
1320 : }
1321 : {
1322 1 : __int128 l("85070591730234615865843651857942052864"_int128);
1323 1 : CATCH_REQUIRE(l == v);
1324 : }
1325 : }
1326 : CATCH_END_SECTION()
1327 :
1328 6 : CATCH_START_SECTION("uint128_literal: unsigned zero and powers of two")
1329 : {
1330 : using namespace snapdev::literals;
1331 :
1332 1 : unsigned __int128 m0(0_uint128);
1333 1 : CATCH_REQUIRE(m0 == 0);
1334 :
1335 1 : unsigned __int128 v(1);
1336 : {
1337 1 : unsigned __int128 l(1_uint128);
1338 1 : CATCH_REQUIRE(l == v);
1339 : }
1340 : {
1341 1 : unsigned __int128 l("1"_uint128);
1342 1 : CATCH_REQUIRE(l == v);
1343 : }
1344 1 : v <<= 1;
1345 : {
1346 1 : unsigned __int128 l(2_uint128);
1347 1 : CATCH_REQUIRE(l == v);
1348 : }
1349 : {
1350 1 : unsigned __int128 l("2"_uint128);
1351 1 : CATCH_REQUIRE(l == v);
1352 : }
1353 1 : v <<= 1;
1354 : {
1355 1 : unsigned __int128 l(4_uint128);
1356 1 : CATCH_REQUIRE(l == v);
1357 : }
1358 : {
1359 1 : unsigned __int128 l("4"_uint128);
1360 1 : CATCH_REQUIRE(l == v);
1361 : }
1362 1 : v <<= 1;
1363 : {
1364 1 : unsigned __int128 l(8_uint128);
1365 1 : CATCH_REQUIRE(l == v);
1366 : }
1367 : {
1368 1 : unsigned __int128 l("8"_uint128);
1369 1 : CATCH_REQUIRE(l == v);
1370 : }
1371 1 : v <<= 1;
1372 : {
1373 1 : unsigned __int128 l(16_uint128);
1374 1 : CATCH_REQUIRE(l == v);
1375 : }
1376 : {
1377 1 : unsigned __int128 l("16"_uint128);
1378 1 : CATCH_REQUIRE(l == v);
1379 : }
1380 1 : v <<= 1;
1381 : {
1382 1 : unsigned __int128 l(32_uint128);
1383 1 : CATCH_REQUIRE(l == v);
1384 : }
1385 : {
1386 1 : unsigned __int128 l("32"_uint128);
1387 1 : CATCH_REQUIRE(l == v);
1388 : }
1389 1 : v <<= 1;
1390 : {
1391 1 : unsigned __int128 l(64_uint128);
1392 1 : CATCH_REQUIRE(l == v);
1393 : }
1394 : {
1395 1 : unsigned __int128 l("64"_uint128);
1396 1 : CATCH_REQUIRE(l == v);
1397 : }
1398 1 : v <<= 1;
1399 : {
1400 1 : unsigned __int128 l(128_uint128);
1401 1 : CATCH_REQUIRE(l == v);
1402 : }
1403 : {
1404 1 : unsigned __int128 l("128"_uint128);
1405 1 : CATCH_REQUIRE(l == v);
1406 : }
1407 1 : v <<= 1;
1408 : {
1409 1 : unsigned __int128 l(256_uint128);
1410 1 : CATCH_REQUIRE(l == v);
1411 : }
1412 : {
1413 1 : unsigned __int128 l("256"_uint128);
1414 1 : CATCH_REQUIRE(l == v);
1415 : }
1416 1 : v <<= 1;
1417 : {
1418 1 : unsigned __int128 l(512_uint128);
1419 1 : CATCH_REQUIRE(l == v);
1420 : }
1421 : {
1422 1 : unsigned __int128 l("512"_uint128);
1423 1 : CATCH_REQUIRE(l == v);
1424 : }
1425 1 : v <<= 1;
1426 : {
1427 1 : unsigned __int128 l(1024_uint128);
1428 1 : CATCH_REQUIRE(l == v);
1429 : }
1430 : {
1431 1 : unsigned __int128 l("1024"_uint128);
1432 1 : CATCH_REQUIRE(l == v);
1433 : }
1434 1 : v <<= 1;
1435 : {
1436 1 : unsigned __int128 l(2048_uint128);
1437 1 : CATCH_REQUIRE(l == v);
1438 : }
1439 : {
1440 1 : unsigned __int128 l("2048"_uint128);
1441 1 : CATCH_REQUIRE(l == v);
1442 : }
1443 1 : v <<= 1;
1444 : {
1445 1 : unsigned __int128 l(4096_uint128);
1446 1 : CATCH_REQUIRE(l == v);
1447 : }
1448 : {
1449 1 : unsigned __int128 l("4096"_uint128);
1450 1 : CATCH_REQUIRE(l == v);
1451 : }
1452 1 : v <<= 1;
1453 : {
1454 1 : unsigned __int128 l(8192_uint128);
1455 1 : CATCH_REQUIRE(l == v);
1456 : }
1457 : {
1458 1 : unsigned __int128 l("8192"_uint128);
1459 1 : CATCH_REQUIRE(l == v);
1460 : }
1461 1 : v <<= 1;
1462 : {
1463 1 : unsigned __int128 l(16384_uint128);
1464 1 : CATCH_REQUIRE(l == v);
1465 : }
1466 : {
1467 1 : unsigned __int128 l("16384"_uint128);
1468 1 : CATCH_REQUIRE(l == v);
1469 : }
1470 1 : v <<= 1;
1471 : {
1472 1 : unsigned __int128 l(32768_uint128);
1473 1 : CATCH_REQUIRE(l == v);
1474 : }
1475 : {
1476 1 : unsigned __int128 l("32768"_uint128);
1477 1 : CATCH_REQUIRE(l == v);
1478 : }
1479 1 : v <<= 1;
1480 : {
1481 1 : unsigned __int128 l(65536_uint128);
1482 1 : CATCH_REQUIRE(l == v);
1483 : }
1484 : {
1485 1 : unsigned __int128 l("65536"_uint128);
1486 1 : CATCH_REQUIRE(l == v);
1487 : }
1488 1 : v <<= 1;
1489 : {
1490 1 : unsigned __int128 l(131072_uint128);
1491 1 : CATCH_REQUIRE(l == v);
1492 : }
1493 : {
1494 1 : unsigned __int128 l("131072"_uint128);
1495 1 : CATCH_REQUIRE(l == v);
1496 : }
1497 1 : v <<= 1;
1498 : {
1499 1 : unsigned __int128 l(262144_uint128);
1500 1 : CATCH_REQUIRE(l == v);
1501 : }
1502 : {
1503 1 : unsigned __int128 l("262144"_uint128);
1504 1 : CATCH_REQUIRE(l == v);
1505 : }
1506 1 : v <<= 1;
1507 : {
1508 1 : unsigned __int128 l(524288_uint128);
1509 1 : CATCH_REQUIRE(l == v);
1510 : }
1511 : {
1512 1 : unsigned __int128 l("524288"_uint128);
1513 1 : CATCH_REQUIRE(l == v);
1514 : }
1515 1 : v <<= 1;
1516 : {
1517 1 : unsigned __int128 l(1048576_uint128);
1518 1 : CATCH_REQUIRE(l == v);
1519 : }
1520 : {
1521 1 : unsigned __int128 l("1048576"_uint128);
1522 1 : CATCH_REQUIRE(l == v);
1523 : }
1524 1 : v <<= 1;
1525 : {
1526 1 : unsigned __int128 l(2097152_uint128);
1527 1 : CATCH_REQUIRE(l == v);
1528 : }
1529 : {
1530 1 : unsigned __int128 l("2097152"_uint128);
1531 1 : CATCH_REQUIRE(l == v);
1532 : }
1533 1 : v <<= 1;
1534 : {
1535 1 : unsigned __int128 l(4194304_uint128);
1536 1 : CATCH_REQUIRE(l == v);
1537 : }
1538 : {
1539 1 : unsigned __int128 l("4194304"_uint128);
1540 1 : CATCH_REQUIRE(l == v);
1541 : }
1542 1 : v <<= 1;
1543 : {
1544 1 : unsigned __int128 l(8388608_uint128);
1545 1 : CATCH_REQUIRE(l == v);
1546 : }
1547 : {
1548 1 : unsigned __int128 l("8388608"_uint128);
1549 1 : CATCH_REQUIRE(l == v);
1550 : }
1551 1 : v <<= 1;
1552 : {
1553 1 : unsigned __int128 l(16777216_uint128);
1554 1 : CATCH_REQUIRE(l == v);
1555 : }
1556 : {
1557 1 : unsigned __int128 l("16777216"_uint128);
1558 1 : CATCH_REQUIRE(l == v);
1559 : }
1560 1 : v <<= 1;
1561 : {
1562 1 : unsigned __int128 l(33554432_uint128);
1563 1 : CATCH_REQUIRE(l == v);
1564 : }
1565 : {
1566 1 : unsigned __int128 l("33554432"_uint128);
1567 1 : CATCH_REQUIRE(l == v);
1568 : }
1569 1 : v <<= 1;
1570 : {
1571 1 : unsigned __int128 l(67108864_uint128);
1572 1 : CATCH_REQUIRE(l == v);
1573 : }
1574 : {
1575 1 : unsigned __int128 l("67108864"_uint128);
1576 1 : CATCH_REQUIRE(l == v);
1577 : }
1578 1 : v <<= 1;
1579 : {
1580 1 : unsigned __int128 l(134217728_uint128);
1581 1 : CATCH_REQUIRE(l == v);
1582 : }
1583 : {
1584 1 : unsigned __int128 l("134217728"_uint128);
1585 1 : CATCH_REQUIRE(l == v);
1586 : }
1587 1 : v <<= 1;
1588 : {
1589 1 : unsigned __int128 l(268435456_uint128);
1590 1 : CATCH_REQUIRE(l == v);
1591 : }
1592 : {
1593 1 : unsigned __int128 l("268435456"_uint128);
1594 1 : CATCH_REQUIRE(l == v);
1595 : }
1596 1 : v <<= 1;
1597 : {
1598 1 : unsigned __int128 l(536870912_uint128);
1599 1 : CATCH_REQUIRE(l == v);
1600 : }
1601 : {
1602 1 : unsigned __int128 l("536870912"_uint128);
1603 1 : CATCH_REQUIRE(l == v);
1604 : }
1605 1 : v <<= 1;
1606 : {
1607 1 : unsigned __int128 l(1073741824_uint128);
1608 1 : CATCH_REQUIRE(l == v);
1609 : }
1610 : {
1611 1 : unsigned __int128 l("1073741824"_uint128);
1612 1 : CATCH_REQUIRE(l == v);
1613 : }
1614 1 : v <<= 1;
1615 : {
1616 1 : unsigned __int128 l(2147483648_uint128);
1617 1 : CATCH_REQUIRE(l == v);
1618 : }
1619 : {
1620 1 : unsigned __int128 l("2147483648"_uint128);
1621 1 : CATCH_REQUIRE(l == v);
1622 : }
1623 1 : v <<= 1;
1624 : {
1625 1 : unsigned __int128 l(4294967296_uint128);
1626 1 : CATCH_REQUIRE(l == v);
1627 : }
1628 : {
1629 1 : unsigned __int128 l("4294967296"_uint128);
1630 1 : CATCH_REQUIRE(l == v);
1631 : }
1632 1 : v <<= 1;
1633 : {
1634 1 : unsigned __int128 l(8589934592_uint128);
1635 1 : CATCH_REQUIRE(l == v);
1636 : }
1637 : {
1638 1 : unsigned __int128 l("8589934592"_uint128);
1639 1 : CATCH_REQUIRE(l == v);
1640 : }
1641 1 : v <<= 1;
1642 : {
1643 1 : unsigned __int128 l(17179869184_uint128);
1644 1 : CATCH_REQUIRE(l == v);
1645 : }
1646 : {
1647 1 : unsigned __int128 l("17179869184"_uint128);
1648 1 : CATCH_REQUIRE(l == v);
1649 : }
1650 1 : v <<= 1;
1651 : {
1652 1 : unsigned __int128 l(34359738368_uint128);
1653 1 : CATCH_REQUIRE(l == v);
1654 : }
1655 : {
1656 1 : unsigned __int128 l("34359738368"_uint128);
1657 1 : CATCH_REQUIRE(l == v);
1658 : }
1659 1 : v <<= 1;
1660 : {
1661 1 : unsigned __int128 l(68719476736_uint128);
1662 1 : CATCH_REQUIRE(l == v);
1663 : }
1664 : {
1665 1 : unsigned __int128 l("68719476736"_uint128);
1666 1 : CATCH_REQUIRE(l == v);
1667 : }
1668 1 : v <<= 1;
1669 : {
1670 1 : unsigned __int128 l(137438953472_uint128);
1671 1 : CATCH_REQUIRE(l == v);
1672 : }
1673 : {
1674 1 : unsigned __int128 l("137438953472"_uint128);
1675 1 : CATCH_REQUIRE(l == v);
1676 : }
1677 1 : v <<= 1;
1678 : {
1679 1 : unsigned __int128 l(274877906944_uint128);
1680 1 : CATCH_REQUIRE(l == v);
1681 : }
1682 : {
1683 1 : unsigned __int128 l("274877906944"_uint128);
1684 1 : CATCH_REQUIRE(l == v);
1685 : }
1686 1 : v <<= 1;
1687 : {
1688 1 : unsigned __int128 l(549755813888_uint128);
1689 1 : CATCH_REQUIRE(l == v);
1690 : }
1691 : {
1692 1 : unsigned __int128 l("549755813888"_uint128);
1693 1 : CATCH_REQUIRE(l == v);
1694 : }
1695 1 : v <<= 1;
1696 : {
1697 1 : unsigned __int128 l(1099511627776_uint128);
1698 1 : CATCH_REQUIRE(l == v);
1699 : }
1700 : {
1701 1 : unsigned __int128 l("1099511627776"_uint128);
1702 1 : CATCH_REQUIRE(l == v);
1703 : }
1704 1 : v <<= 1;
1705 : {
1706 1 : unsigned __int128 l(2199023255552_uint128);
1707 1 : CATCH_REQUIRE(l == v);
1708 : }
1709 : {
1710 1 : unsigned __int128 l("2199023255552"_uint128);
1711 1 : CATCH_REQUIRE(l == v);
1712 : }
1713 1 : v <<= 1;
1714 : {
1715 1 : unsigned __int128 l(4398046511104_uint128);
1716 1 : CATCH_REQUIRE(l == v);
1717 : }
1718 : {
1719 1 : unsigned __int128 l("4398046511104"_uint128);
1720 1 : CATCH_REQUIRE(l == v);
1721 : }
1722 1 : v <<= 1;
1723 : {
1724 1 : unsigned __int128 l(8796093022208_uint128);
1725 1 : CATCH_REQUIRE(l == v);
1726 : }
1727 : {
1728 1 : unsigned __int128 l("8796093022208"_uint128);
1729 1 : CATCH_REQUIRE(l == v);
1730 : }
1731 1 : v <<= 1;
1732 : {
1733 1 : unsigned __int128 l(17592186044416_uint128);
1734 1 : CATCH_REQUIRE(l == v);
1735 : }
1736 : {
1737 1 : unsigned __int128 l("17592186044416"_uint128);
1738 1 : CATCH_REQUIRE(l == v);
1739 : }
1740 1 : v <<= 1;
1741 : {
1742 1 : unsigned __int128 l(35184372088832_uint128);
1743 1 : CATCH_REQUIRE(l == v);
1744 : }
1745 : {
1746 1 : unsigned __int128 l("35184372088832"_uint128);
1747 1 : CATCH_REQUIRE(l == v);
1748 : }
1749 1 : v <<= 1;
1750 : {
1751 1 : unsigned __int128 l(70368744177664_uint128);
1752 1 : CATCH_REQUIRE(l == v);
1753 : }
1754 : {
1755 1 : unsigned __int128 l("70368744177664"_uint128);
1756 1 : CATCH_REQUIRE(l == v);
1757 : }
1758 1 : v <<= 1;
1759 : {
1760 1 : unsigned __int128 l(140737488355328_uint128);
1761 1 : CATCH_REQUIRE(l == v);
1762 : }
1763 : {
1764 1 : unsigned __int128 l("140737488355328"_uint128);
1765 1 : CATCH_REQUIRE(l == v);
1766 : }
1767 1 : v <<= 1;
1768 : {
1769 1 : unsigned __int128 l(281474976710656_uint128);
1770 1 : CATCH_REQUIRE(l == v);
1771 : }
1772 : {
1773 1 : unsigned __int128 l("281474976710656"_uint128);
1774 1 : CATCH_REQUIRE(l == v);
1775 : }
1776 1 : v <<= 1;
1777 : {
1778 1 : unsigned __int128 l(562949953421312_uint128);
1779 1 : CATCH_REQUIRE(l == v);
1780 : }
1781 : {
1782 1 : unsigned __int128 l("562949953421312"_uint128);
1783 1 : CATCH_REQUIRE(l == v);
1784 : }
1785 1 : v <<= 1;
1786 : {
1787 1 : unsigned __int128 l(1125899906842624_uint128);
1788 1 : CATCH_REQUIRE(l == v);
1789 : }
1790 : {
1791 1 : unsigned __int128 l("1125899906842624"_uint128);
1792 1 : CATCH_REQUIRE(l == v);
1793 : }
1794 1 : v <<= 1;
1795 : {
1796 1 : unsigned __int128 l(2251799813685248_uint128);
1797 1 : CATCH_REQUIRE(l == v);
1798 : }
1799 : {
1800 1 : unsigned __int128 l("2251799813685248"_uint128);
1801 1 : CATCH_REQUIRE(l == v);
1802 : }
1803 1 : v <<= 1;
1804 : {
1805 1 : unsigned __int128 l(4503599627370496_uint128);
1806 1 : CATCH_REQUIRE(l == v);
1807 : }
1808 : {
1809 1 : unsigned __int128 l("4503599627370496"_uint128);
1810 1 : CATCH_REQUIRE(l == v);
1811 : }
1812 1 : v <<= 1;
1813 : {
1814 1 : unsigned __int128 l(9007199254740992_uint128);
1815 1 : CATCH_REQUIRE(l == v);
1816 : }
1817 : {
1818 1 : unsigned __int128 l("9007199254740992"_uint128);
1819 1 : CATCH_REQUIRE(l == v);
1820 : }
1821 1 : v <<= 1;
1822 : {
1823 1 : unsigned __int128 l(18014398509481984_uint128);
1824 1 : CATCH_REQUIRE(l == v);
1825 : }
1826 : {
1827 1 : unsigned __int128 l("18014398509481984"_uint128);
1828 1 : CATCH_REQUIRE(l == v);
1829 : }
1830 1 : v <<= 1;
1831 : {
1832 1 : unsigned __int128 l(36028797018963968_uint128);
1833 1 : CATCH_REQUIRE(l == v);
1834 : }
1835 : {
1836 1 : unsigned __int128 l("36028797018963968"_uint128);
1837 1 : CATCH_REQUIRE(l == v);
1838 : }
1839 1 : v <<= 1;
1840 : {
1841 1 : unsigned __int128 l(72057594037927936_uint128);
1842 1 : CATCH_REQUIRE(l == v);
1843 : }
1844 : {
1845 1 : unsigned __int128 l("72057594037927936"_uint128);
1846 1 : CATCH_REQUIRE(l == v);
1847 : }
1848 1 : v <<= 1;
1849 : {
1850 1 : unsigned __int128 l(144115188075855872_uint128);
1851 1 : CATCH_REQUIRE(l == v);
1852 : }
1853 : {
1854 1 : unsigned __int128 l("144115188075855872"_uint128);
1855 1 : CATCH_REQUIRE(l == v);
1856 : }
1857 1 : v <<= 1;
1858 : {
1859 1 : unsigned __int128 l(288230376151711744_uint128);
1860 1 : CATCH_REQUIRE(l == v);
1861 : }
1862 : {
1863 1 : unsigned __int128 l("288230376151711744"_uint128);
1864 1 : CATCH_REQUIRE(l == v);
1865 : }
1866 1 : v <<= 1;
1867 : {
1868 1 : unsigned __int128 l(576460752303423488_uint128);
1869 1 : CATCH_REQUIRE(l == v);
1870 : }
1871 : {
1872 1 : unsigned __int128 l("576460752303423488"_uint128);
1873 1 : CATCH_REQUIRE(l == v);
1874 : }
1875 1 : v <<= 1;
1876 : {
1877 1 : unsigned __int128 l(1152921504606846976_uint128);
1878 1 : CATCH_REQUIRE(l == v);
1879 : }
1880 : {
1881 1 : unsigned __int128 l("1152921504606846976"_uint128);
1882 1 : CATCH_REQUIRE(l == v);
1883 : }
1884 1 : v <<= 1;
1885 : {
1886 1 : unsigned __int128 l(2305843009213693952_uint128);
1887 1 : CATCH_REQUIRE(l == v);
1888 : }
1889 : {
1890 1 : unsigned __int128 l("2305843009213693952"_uint128);
1891 1 : CATCH_REQUIRE(l == v);
1892 : }
1893 1 : v <<= 1;
1894 : {
1895 1 : unsigned __int128 l(4611686018427387904_uint128);
1896 1 : CATCH_REQUIRE(l == v);
1897 : }
1898 : {
1899 1 : unsigned __int128 l("4611686018427387904"_uint128);
1900 1 : CATCH_REQUIRE(l == v);
1901 : }
1902 1 : v <<= 1;
1903 : {
1904 1 : unsigned __int128 l(9223372036854775808_uint128);
1905 1 : CATCH_REQUIRE(l == v);
1906 : }
1907 : {
1908 1 : unsigned __int128 l("9223372036854775808"_uint128);
1909 1 : CATCH_REQUIRE(l == v);
1910 : }
1911 1 : v <<= 1;
1912 : {
1913 1 : unsigned __int128 l(18446744073709551616_uint128);
1914 1 : CATCH_REQUIRE(l == v);
1915 : }
1916 : {
1917 1 : unsigned __int128 l("18446744073709551616"_uint128);
1918 1 : CATCH_REQUIRE(l == v);
1919 : }
1920 1 : v <<= 1;
1921 : {
1922 1 : unsigned __int128 l(36893488147419103232_uint128);
1923 1 : CATCH_REQUIRE(l == v);
1924 : }
1925 : {
1926 1 : unsigned __int128 l("36893488147419103232"_uint128);
1927 1 : CATCH_REQUIRE(l == v);
1928 : }
1929 1 : v <<= 1;
1930 : {
1931 1 : unsigned __int128 l(73786976294838206464_uint128);
1932 1 : CATCH_REQUIRE(l == v);
1933 : }
1934 : {
1935 1 : unsigned __int128 l("73786976294838206464"_uint128);
1936 1 : CATCH_REQUIRE(l == v);
1937 : }
1938 1 : v <<= 1;
1939 : {
1940 1 : unsigned __int128 l(147573952589676412928_uint128);
1941 1 : CATCH_REQUIRE(l == v);
1942 : }
1943 : {
1944 1 : unsigned __int128 l("147573952589676412928"_uint128);
1945 1 : CATCH_REQUIRE(l == v);
1946 : }
1947 1 : v <<= 1;
1948 : {
1949 1 : unsigned __int128 l(295147905179352825856_uint128);
1950 1 : CATCH_REQUIRE(l == v);
1951 : }
1952 : {
1953 1 : unsigned __int128 l("295147905179352825856"_uint128);
1954 1 : CATCH_REQUIRE(l == v);
1955 : }
1956 1 : v <<= 1;
1957 : {
1958 1 : unsigned __int128 l(590295810358705651712_uint128);
1959 1 : CATCH_REQUIRE(l == v);
1960 : }
1961 : {
1962 1 : unsigned __int128 l("590295810358705651712"_uint128);
1963 1 : CATCH_REQUIRE(l == v);
1964 : }
1965 1 : v <<= 1;
1966 : {
1967 1 : unsigned __int128 l(1180591620717411303424_uint128);
1968 1 : CATCH_REQUIRE(l == v);
1969 : }
1970 : {
1971 1 : unsigned __int128 l("1180591620717411303424"_uint128);
1972 1 : CATCH_REQUIRE(l == v);
1973 : }
1974 1 : v <<= 1;
1975 : {
1976 1 : unsigned __int128 l(2361183241434822606848_uint128);
1977 1 : CATCH_REQUIRE(l == v);
1978 : }
1979 : {
1980 1 : unsigned __int128 l("2361183241434822606848"_uint128);
1981 1 : CATCH_REQUIRE(l == v);
1982 : }
1983 1 : v <<= 1;
1984 : {
1985 1 : unsigned __int128 l(4722366482869645213696_uint128);
1986 1 : CATCH_REQUIRE(l == v);
1987 : }
1988 : {
1989 1 : unsigned __int128 l("4722366482869645213696"_uint128);
1990 1 : CATCH_REQUIRE(l == v);
1991 : }
1992 1 : v <<= 1;
1993 : {
1994 1 : unsigned __int128 l(9444732965739290427392_uint128);
1995 1 : CATCH_REQUIRE(l == v);
1996 : }
1997 : {
1998 1 : unsigned __int128 l("9444732965739290427392"_uint128);
1999 1 : CATCH_REQUIRE(l == v);
2000 : }
2001 1 : v <<= 1;
2002 : {
2003 1 : unsigned __int128 l(18889465931478580854784_uint128);
2004 1 : CATCH_REQUIRE(l == v);
2005 : }
2006 : {
2007 1 : unsigned __int128 l("18889465931478580854784"_uint128);
2008 1 : CATCH_REQUIRE(l == v);
2009 : }
2010 1 : v <<= 1;
2011 : {
2012 1 : unsigned __int128 l(37778931862957161709568_uint128);
2013 1 : CATCH_REQUIRE(l == v);
2014 : }
2015 : {
2016 1 : unsigned __int128 l("37778931862957161709568"_uint128);
2017 1 : CATCH_REQUIRE(l == v);
2018 : }
2019 1 : v <<= 1;
2020 : {
2021 1 : unsigned __int128 l(75557863725914323419136_uint128);
2022 1 : CATCH_REQUIRE(l == v);
2023 : }
2024 : {
2025 1 : unsigned __int128 l("75557863725914323419136"_uint128);
2026 1 : CATCH_REQUIRE(l == v);
2027 : }
2028 1 : v <<= 1;
2029 : {
2030 1 : unsigned __int128 l(151115727451828646838272_uint128);
2031 1 : CATCH_REQUIRE(l == v);
2032 : }
2033 : {
2034 1 : unsigned __int128 l("151115727451828646838272"_uint128);
2035 1 : CATCH_REQUIRE(l == v);
2036 : }
2037 1 : v <<= 1;
2038 : {
2039 1 : unsigned __int128 l(302231454903657293676544_uint128);
2040 1 : CATCH_REQUIRE(l == v);
2041 : }
2042 : {
2043 1 : unsigned __int128 l("302231454903657293676544"_uint128);
2044 1 : CATCH_REQUIRE(l == v);
2045 : }
2046 1 : v <<= 1;
2047 : {
2048 1 : unsigned __int128 l(604462909807314587353088_uint128);
2049 1 : CATCH_REQUIRE(l == v);
2050 : }
2051 : {
2052 1 : unsigned __int128 l("604462909807314587353088"_uint128);
2053 1 : CATCH_REQUIRE(l == v);
2054 : }
2055 1 : v <<= 1;
2056 : {
2057 1 : unsigned __int128 l(1208925819614629174706176_uint128);
2058 1 : CATCH_REQUIRE(l == v);
2059 : }
2060 : {
2061 1 : unsigned __int128 l("1208925819614629174706176"_uint128);
2062 1 : CATCH_REQUIRE(l == v);
2063 : }
2064 1 : v <<= 1;
2065 : {
2066 1 : unsigned __int128 l(2417851639229258349412352_uint128);
2067 1 : CATCH_REQUIRE(l == v);
2068 : }
2069 : {
2070 1 : unsigned __int128 l("2417851639229258349412352"_uint128);
2071 1 : CATCH_REQUIRE(l == v);
2072 : }
2073 1 : v <<= 1;
2074 : {
2075 1 : unsigned __int128 l(4835703278458516698824704_uint128);
2076 1 : CATCH_REQUIRE(l == v);
2077 : }
2078 : {
2079 1 : unsigned __int128 l("4835703278458516698824704"_uint128);
2080 1 : CATCH_REQUIRE(l == v);
2081 : }
2082 1 : v <<= 1;
2083 : {
2084 1 : unsigned __int128 l(9671406556917033397649408_uint128);
2085 1 : CATCH_REQUIRE(l == v);
2086 : }
2087 : {
2088 1 : unsigned __int128 l("9671406556917033397649408"_uint128);
2089 1 : CATCH_REQUIRE(l == v);
2090 : }
2091 1 : v <<= 1;
2092 : {
2093 1 : unsigned __int128 l(19342813113834066795298816_uint128);
2094 1 : CATCH_REQUIRE(l == v);
2095 : }
2096 : {
2097 1 : unsigned __int128 l("19342813113834066795298816"_uint128);
2098 1 : CATCH_REQUIRE(l == v);
2099 : }
2100 1 : v <<= 1;
2101 : {
2102 1 : unsigned __int128 l(38685626227668133590597632_uint128);
2103 1 : CATCH_REQUIRE(l == v);
2104 : }
2105 : {
2106 1 : unsigned __int128 l("38685626227668133590597632"_uint128);
2107 1 : CATCH_REQUIRE(l == v);
2108 : }
2109 1 : v <<= 1;
2110 : {
2111 1 : unsigned __int128 l(77371252455336267181195264_uint128);
2112 1 : CATCH_REQUIRE(l == v);
2113 : }
2114 : {
2115 1 : unsigned __int128 l("77371252455336267181195264"_uint128);
2116 1 : CATCH_REQUIRE(l == v);
2117 : }
2118 1 : v <<= 1;
2119 : {
2120 1 : unsigned __int128 l(154742504910672534362390528_uint128);
2121 1 : CATCH_REQUIRE(l == v);
2122 : }
2123 : {
2124 1 : unsigned __int128 l("154742504910672534362390528"_uint128);
2125 1 : CATCH_REQUIRE(l == v);
2126 : }
2127 1 : v <<= 1;
2128 : {
2129 1 : unsigned __int128 l(309485009821345068724781056_uint128);
2130 1 : CATCH_REQUIRE(l == v);
2131 : }
2132 : {
2133 1 : unsigned __int128 l("309485009821345068724781056"_uint128);
2134 1 : CATCH_REQUIRE(l == v);
2135 : }
2136 1 : v <<= 1;
2137 : {
2138 1 : unsigned __int128 l(618970019642690137449562112_uint128);
2139 1 : CATCH_REQUIRE(l == v);
2140 : }
2141 : {
2142 1 : unsigned __int128 l("618970019642690137449562112"_uint128);
2143 1 : CATCH_REQUIRE(l == v);
2144 : }
2145 1 : v <<= 1;
2146 : {
2147 1 : unsigned __int128 l(1237940039285380274899124224_uint128);
2148 1 : CATCH_REQUIRE(l == v);
2149 : }
2150 : {
2151 1 : unsigned __int128 l("1237940039285380274899124224"_uint128);
2152 1 : CATCH_REQUIRE(l == v);
2153 : }
2154 1 : v <<= 1;
2155 : {
2156 1 : unsigned __int128 l(2475880078570760549798248448_uint128);
2157 1 : CATCH_REQUIRE(l == v);
2158 : }
2159 : {
2160 1 : unsigned __int128 l("2475880078570760549798248448"_uint128);
2161 1 : CATCH_REQUIRE(l == v);
2162 : }
2163 1 : v <<= 1;
2164 : {
2165 1 : unsigned __int128 l(4951760157141521099596496896_uint128);
2166 1 : CATCH_REQUIRE(l == v);
2167 : }
2168 : {
2169 1 : unsigned __int128 l("4951760157141521099596496896"_uint128);
2170 1 : CATCH_REQUIRE(l == v);
2171 : }
2172 1 : v <<= 1;
2173 : {
2174 1 : unsigned __int128 l(9903520314283042199192993792_uint128);
2175 1 : CATCH_REQUIRE(l == v);
2176 : }
2177 : {
2178 1 : unsigned __int128 l("9903520314283042199192993792"_uint128);
2179 1 : CATCH_REQUIRE(l == v);
2180 : }
2181 1 : v <<= 1;
2182 : {
2183 1 : unsigned __int128 l(19807040628566084398385987584_uint128);
2184 1 : CATCH_REQUIRE(l == v);
2185 : }
2186 : {
2187 1 : unsigned __int128 l("19807040628566084398385987584"_uint128);
2188 1 : CATCH_REQUIRE(l == v);
2189 : }
2190 1 : v <<= 1;
2191 : {
2192 1 : unsigned __int128 l(39614081257132168796771975168_uint128);
2193 1 : CATCH_REQUIRE(l == v);
2194 : }
2195 : {
2196 1 : unsigned __int128 l("39614081257132168796771975168"_uint128);
2197 1 : CATCH_REQUIRE(l == v);
2198 : }
2199 1 : v <<= 1;
2200 : {
2201 1 : unsigned __int128 l(79228162514264337593543950336_uint128);
2202 1 : CATCH_REQUIRE(l == v);
2203 : }
2204 : {
2205 1 : unsigned __int128 l("79228162514264337593543950336"_uint128);
2206 1 : CATCH_REQUIRE(l == v);
2207 : }
2208 1 : v <<= 1;
2209 : {
2210 1 : unsigned __int128 l(158456325028528675187087900672_uint128);
2211 1 : CATCH_REQUIRE(l == v);
2212 : }
2213 : {
2214 1 : unsigned __int128 l("158456325028528675187087900672"_uint128);
2215 1 : CATCH_REQUIRE(l == v);
2216 : }
2217 1 : v <<= 1;
2218 : {
2219 1 : unsigned __int128 l(316912650057057350374175801344_uint128);
2220 1 : CATCH_REQUIRE(l == v);
2221 : }
2222 : {
2223 1 : unsigned __int128 l("316912650057057350374175801344"_uint128);
2224 1 : CATCH_REQUIRE(l == v);
2225 : }
2226 1 : v <<= 1;
2227 : {
2228 1 : unsigned __int128 l(633825300114114700748351602688_uint128);
2229 1 : CATCH_REQUIRE(l == v);
2230 : }
2231 : {
2232 1 : unsigned __int128 l("633825300114114700748351602688"_uint128);
2233 1 : CATCH_REQUIRE(l == v);
2234 : }
2235 1 : v <<= 1;
2236 : {
2237 1 : unsigned __int128 l(1267650600228229401496703205376_uint128);
2238 1 : CATCH_REQUIRE(l == v);
2239 : }
2240 : {
2241 1 : unsigned __int128 l("1267650600228229401496703205376"_uint128);
2242 1 : CATCH_REQUIRE(l == v);
2243 : }
2244 1 : v <<= 1;
2245 : {
2246 1 : unsigned __int128 l(2535301200456458802993406410752_uint128);
2247 1 : CATCH_REQUIRE(l == v);
2248 : }
2249 : {
2250 1 : unsigned __int128 l("2535301200456458802993406410752"_uint128);
2251 1 : CATCH_REQUIRE(l == v);
2252 : }
2253 1 : v <<= 1;
2254 : {
2255 1 : unsigned __int128 l(5070602400912917605986812821504_uint128);
2256 1 : CATCH_REQUIRE(l == v);
2257 : }
2258 : {
2259 1 : unsigned __int128 l("5070602400912917605986812821504"_uint128);
2260 1 : CATCH_REQUIRE(l == v);
2261 : }
2262 1 : v <<= 1;
2263 : {
2264 1 : unsigned __int128 l(10141204801825835211973625643008_uint128);
2265 1 : CATCH_REQUIRE(l == v);
2266 : }
2267 : {
2268 1 : unsigned __int128 l("10141204801825835211973625643008"_uint128);
2269 1 : CATCH_REQUIRE(l == v);
2270 : }
2271 1 : v <<= 1;
2272 : {
2273 1 : unsigned __int128 l(20282409603651670423947251286016_uint128);
2274 1 : CATCH_REQUIRE(l == v);
2275 : }
2276 : {
2277 1 : unsigned __int128 l("20282409603651670423947251286016"_uint128);
2278 1 : CATCH_REQUIRE(l == v);
2279 : }
2280 1 : v <<= 1;
2281 : {
2282 1 : unsigned __int128 l(40564819207303340847894502572032_uint128);
2283 1 : CATCH_REQUIRE(l == v);
2284 : }
2285 : {
2286 1 : unsigned __int128 l("40564819207303340847894502572032"_uint128);
2287 1 : CATCH_REQUIRE(l == v);
2288 : }
2289 1 : v <<= 1;
2290 : {
2291 1 : unsigned __int128 l(81129638414606681695789005144064_uint128);
2292 1 : CATCH_REQUIRE(l == v);
2293 : }
2294 : {
2295 1 : unsigned __int128 l("81129638414606681695789005144064"_uint128);
2296 1 : CATCH_REQUIRE(l == v);
2297 : }
2298 1 : v <<= 1;
2299 : {
2300 1 : unsigned __int128 l(162259276829213363391578010288128_uint128);
2301 1 : CATCH_REQUIRE(l == v);
2302 : }
2303 : {
2304 1 : unsigned __int128 l("162259276829213363391578010288128"_uint128);
2305 1 : CATCH_REQUIRE(l == v);
2306 : }
2307 1 : v <<= 1;
2308 : {
2309 1 : unsigned __int128 l(324518553658426726783156020576256_uint128);
2310 1 : CATCH_REQUIRE(l == v);
2311 : }
2312 : {
2313 1 : unsigned __int128 l("324518553658426726783156020576256"_uint128);
2314 1 : CATCH_REQUIRE(l == v);
2315 : }
2316 1 : v <<= 1;
2317 : {
2318 1 : unsigned __int128 l(649037107316853453566312041152512_uint128);
2319 1 : CATCH_REQUIRE(l == v);
2320 : }
2321 : {
2322 1 : unsigned __int128 l("649037107316853453566312041152512"_uint128);
2323 1 : CATCH_REQUIRE(l == v);
2324 : }
2325 1 : v <<= 1;
2326 : {
2327 1 : unsigned __int128 l(1298074214633706907132624082305024_uint128);
2328 1 : CATCH_REQUIRE(l == v);
2329 : }
2330 : {
2331 1 : unsigned __int128 l("1298074214633706907132624082305024"_uint128);
2332 1 : CATCH_REQUIRE(l == v);
2333 : }
2334 1 : v <<= 1;
2335 : {
2336 1 : unsigned __int128 l(2596148429267413814265248164610048_uint128);
2337 1 : CATCH_REQUIRE(l == v);
2338 : }
2339 : {
2340 1 : unsigned __int128 l("2596148429267413814265248164610048"_uint128);
2341 1 : CATCH_REQUIRE(l == v);
2342 : }
2343 1 : v <<= 1;
2344 : {
2345 1 : unsigned __int128 l(5192296858534827628530496329220096_uint128);
2346 1 : CATCH_REQUIRE(l == v);
2347 : }
2348 : {
2349 1 : unsigned __int128 l("5192296858534827628530496329220096"_uint128);
2350 1 : CATCH_REQUIRE(l == v);
2351 : }
2352 1 : v <<= 1;
2353 : {
2354 1 : unsigned __int128 l(10384593717069655257060992658440192_uint128);
2355 1 : CATCH_REQUIRE(l == v);
2356 : }
2357 : {
2358 1 : unsigned __int128 l("10384593717069655257060992658440192"_uint128);
2359 1 : CATCH_REQUIRE(l == v);
2360 : }
2361 1 : v <<= 1;
2362 : {
2363 1 : unsigned __int128 l(20769187434139310514121985316880384_uint128);
2364 1 : CATCH_REQUIRE(l == v);
2365 : }
2366 : {
2367 1 : unsigned __int128 l("20769187434139310514121985316880384"_uint128);
2368 1 : CATCH_REQUIRE(l == v);
2369 : }
2370 1 : v <<= 1;
2371 : {
2372 1 : unsigned __int128 l(41538374868278621028243970633760768_uint128);
2373 1 : CATCH_REQUIRE(l == v);
2374 : }
2375 : {
2376 1 : unsigned __int128 l("41538374868278621028243970633760768"_uint128);
2377 1 : CATCH_REQUIRE(l == v);
2378 : }
2379 1 : v <<= 1;
2380 : {
2381 1 : unsigned __int128 l(83076749736557242056487941267521536_uint128);
2382 1 : CATCH_REQUIRE(l == v);
2383 : }
2384 : {
2385 1 : unsigned __int128 l("83076749736557242056487941267521536"_uint128);
2386 1 : CATCH_REQUIRE(l == v);
2387 : }
2388 1 : v <<= 1;
2389 : {
2390 1 : unsigned __int128 l(166153499473114484112975882535043072_uint128);
2391 1 : CATCH_REQUIRE(l == v);
2392 : }
2393 : {
2394 1 : unsigned __int128 l("166153499473114484112975882535043072"_uint128);
2395 1 : CATCH_REQUIRE(l == v);
2396 : }
2397 1 : v <<= 1;
2398 : {
2399 1 : unsigned __int128 l(332306998946228968225951765070086144_uint128);
2400 1 : CATCH_REQUIRE(l == v);
2401 : }
2402 : {
2403 1 : unsigned __int128 l("332306998946228968225951765070086144"_uint128);
2404 1 : CATCH_REQUIRE(l == v);
2405 : }
2406 1 : v <<= 1;
2407 : {
2408 1 : unsigned __int128 l(664613997892457936451903530140172288_uint128);
2409 1 : CATCH_REQUIRE(l == v);
2410 : }
2411 : {
2412 1 : unsigned __int128 l("664613997892457936451903530140172288"_uint128);
2413 1 : CATCH_REQUIRE(l == v);
2414 : }
2415 1 : v <<= 1;
2416 : {
2417 1 : unsigned __int128 l(1329227995784915872903807060280344576_uint128);
2418 1 : CATCH_REQUIRE(l == v);
2419 : }
2420 : {
2421 1 : unsigned __int128 l("1329227995784915872903807060280344576"_uint128);
2422 1 : CATCH_REQUIRE(l == v);
2423 : }
2424 1 : v <<= 1;
2425 : {
2426 1 : unsigned __int128 l(2658455991569831745807614120560689152_uint128);
2427 1 : CATCH_REQUIRE(l == v);
2428 : }
2429 : {
2430 1 : unsigned __int128 l("2658455991569831745807614120560689152"_uint128);
2431 1 : CATCH_REQUIRE(l == v);
2432 : }
2433 1 : v <<= 1;
2434 : {
2435 1 : unsigned __int128 l(5316911983139663491615228241121378304_uint128);
2436 1 : CATCH_REQUIRE(l == v);
2437 : }
2438 : {
2439 1 : unsigned __int128 l("5316911983139663491615228241121378304"_uint128);
2440 1 : CATCH_REQUIRE(l == v);
2441 : }
2442 1 : v <<= 1;
2443 : {
2444 1 : unsigned __int128 l(10633823966279326983230456482242756608_uint128);
2445 1 : CATCH_REQUIRE(l == v);
2446 : }
2447 : {
2448 1 : unsigned __int128 l("10633823966279326983230456482242756608"_uint128);
2449 1 : CATCH_REQUIRE(l == v);
2450 : }
2451 1 : v <<= 1;
2452 : {
2453 1 : unsigned __int128 l(21267647932558653966460912964485513216_uint128);
2454 1 : CATCH_REQUIRE(l == v);
2455 : }
2456 : {
2457 1 : unsigned __int128 l("21267647932558653966460912964485513216"_uint128);
2458 1 : CATCH_REQUIRE(l == v);
2459 : }
2460 1 : v <<= 1;
2461 : {
2462 1 : unsigned __int128 l(42535295865117307932921825928971026432_uint128);
2463 1 : CATCH_REQUIRE(l == v);
2464 : }
2465 : {
2466 1 : unsigned __int128 l("42535295865117307932921825928971026432"_uint128);
2467 1 : CATCH_REQUIRE(l == v);
2468 : }
2469 1 : v <<= 1;
2470 : {
2471 1 : unsigned __int128 l(85070591730234615865843651857942052864_uint128);
2472 1 : CATCH_REQUIRE(l == v);
2473 : }
2474 : {
2475 1 : unsigned __int128 l("85070591730234615865843651857942052864"_uint128);
2476 1 : CATCH_REQUIRE(l == v);
2477 : }
2478 : }
2479 : CATCH_END_SECTION()
2480 :
2481 6 : CATCH_START_SECTION("[u]int128_literal: large numbers in decimal, hexadecimal, octal and binary")
2482 : {
2483 : using namespace snapdev::literals;
2484 :
2485 : // test a negative decimal number of 128 bits
2486 : // (the minus is arithmetic in the compiler, not part of the literal)
2487 : {
2488 1 : __int128 const top(0x1485B9AD5F387C22);
2489 1 : __int128 const bottom(0x1A94732C11DA7DAF);
2490 1 : __int128 const v((top << 64UL) | bottom);
2491 1 : __int128 l(-27278901379601602040904188621408075183_int128);
2492 1 : CATCH_REQUIRE(l == -v);
2493 1 : __int128 s(-"27278901379601602040904188621408075183"_int128);
2494 1 : CATCH_REQUIRE(s == -v);
2495 : }
2496 :
2497 : // test an hexadecimal number of 128 bits
2498 : {
2499 1 : unsigned __int128 const top(0xFA83B93D5C387C22);
2500 1 : unsigned __int128 const bottom(0x1A94C329111A73AF);
2501 1 : unsigned __int128 const v((top << 64UL) | bottom);
2502 1 : unsigned __int128 l(0xFA83B93D5C387c221A94C329111a73AF_uint128);
2503 1 : CATCH_REQUIRE(l == v);
2504 1 : unsigned __int128 s("0xFA83B93D5C387c221A94C329111a73AF"_uint128);
2505 1 : CATCH_REQUIRE(s == v);
2506 : }
2507 :
2508 : // test an octal number of 126 bits
2509 : {
2510 1 : unsigned __int128 const top(0352035623653416076042); // this is only 63 bits (21 digits each representing 3 bits)
2511 1 : unsigned __int128 const bottom(0152246062442106471657);
2512 1 : unsigned __int128 const v((top << 63UL) | bottom);
2513 1 : unsigned __int128 l(0352035623653416076042152246062442106471657_uint128);
2514 1 : CATCH_REQUIRE(l == v);
2515 1 : unsigned __int128 s("0352035623653416076042152246062442106471657"_uint128);
2516 1 : CATCH_REQUIRE(s == v);
2517 : }
2518 :
2519 : // test a binary number of 126 bits
2520 : {
2521 1 : unsigned __int128 const top(0352535624657416076142); // this is only 63 bits (21 digits each representing 3 bits)
2522 1 : unsigned __int128 const bottom(0132245062742106471635);
2523 1 : unsigned __int128 const v((top << 63UL) | bottom);
2524 1 : unsigned __int128 l(0b11101010101011101110010100110101111100001110000111110001100010001011010010100101000110010111100010001000110100111001110011101_uint128);
2525 1 : CATCH_REQUIRE(l == v);
2526 1 : unsigned __int128 s("0b11101010101011101110010100110101111100001110000111110001100010001011010010100101000110010111100010001000110100111001110011101"_uint128);
2527 1 : CATCH_REQUIRE(s == v);
2528 : }
2529 : }
2530 : CATCH_END_SECTION()
2531 3 : }
2532 :
2533 :
2534 7 : CATCH_TEST_CASE("int128_powers", "[math][int128]")
2535 : {
2536 10 : CATCH_START_SECTION("int128: 2^n with n from 0 to 127")
2537 : {
2538 : using namespace snapdev::literals;
2539 :
2540 1 : __int128 v(1);
2541 129 : for(int p(0); p < 128; ++p, v *= 2)
2542 : {
2543 128 : CATCH_REQUIRE(snapdev::pow(2_int128, p) == v);
2544 : }
2545 : }
2546 : CATCH_END_SECTION()
2547 :
2548 10 : CATCH_START_SECTION("uint128: 2^n with n from 0 to 127")
2549 : {
2550 : using namespace snapdev::literals;
2551 :
2552 1 : unsigned __int128 v(1);
2553 129 : for(int p(0); p < 128; ++p, v *= 2)
2554 : {
2555 128 : CATCH_REQUIRE(snapdev::pow(2_uint128, p) == v);
2556 : }
2557 : }
2558 : CATCH_END_SECTION()
2559 :
2560 10 : CATCH_START_SECTION("[u]int128: n^0 where n is a random number")
2561 : {
2562 : using namespace snapdev::literals;
2563 :
2564 11 : for(int repeat(0); repeat < 10; ++repeat)
2565 : {
2566 10 : unsigned __int128 u(0_uint128);
2567 170 : for(int p(0); p < 16; ++p)
2568 : {
2569 160 : u <<= 8;
2570 160 : u |= rand() & 0x00FF;
2571 : }
2572 10 : CATCH_REQUIRE(snapdev::pow(u, 0) == 1);
2573 :
2574 10 : __int128 v(0_uint128);
2575 170 : for(int p(0); p < 16; ++p)
2576 : {
2577 160 : v <<= 8;
2578 160 : v |= rand() & 0x00FF;
2579 : }
2580 10 : if((repeat & 1) == 0 && v > 0)
2581 : {
2582 : // make sure the value is negative at times
2583 : //
2584 3 : v = -v;
2585 : }
2586 10 : CATCH_REQUIRE(snapdev::pow(v, 0) == 1);
2587 : }
2588 : }
2589 : CATCH_END_SECTION()
2590 :
2591 10 : CATCH_START_SECTION("int128: 1^n with n < 0")
2592 : {
2593 : using namespace snapdev::literals;
2594 :
2595 129 : for(int p(-128); p < 0; ++p)
2596 : {
2597 128 : CATCH_REQUIRE(snapdev::pow(1_int128, p) == 1);
2598 128 : CATCH_REQUIRE(snapdev::pow(1_uint128, p) == 1);
2599 :
2600 : // for any other number, it becomes 0
2601 : //
2602 128 : CATCH_REQUIRE(snapdev::pow(2_int128, p) == 0);
2603 128 : CATCH_REQUIRE(snapdev::pow(2_uint128, p) == 0);
2604 128 : CATCH_REQUIRE(snapdev::pow(3_int128, p) == 0);
2605 128 : CATCH_REQUIRE(snapdev::pow(3_uint128, p) == 0);
2606 128 : CATCH_REQUIRE(snapdev::pow(4_int128, p) == 0);
2607 128 : CATCH_REQUIRE(snapdev::pow(4_uint128, p) == 0);
2608 128 : CATCH_REQUIRE(snapdev::pow(5_int128, p) == 0);
2609 128 : CATCH_REQUIRE(snapdev::pow(5_uint128, p) == 0);
2610 : }
2611 : }
2612 : CATCH_END_SECTION()
2613 :
2614 10 : CATCH_START_SECTION("int128: -1^n with n < 0")
2615 : {
2616 : using namespace snapdev::literals;
2617 :
2618 129 : for(int p(-128); p < 0; ++p)
2619 : {
2620 128 : if((p & 1) == 0)
2621 : {
2622 64 : CATCH_REQUIRE(snapdev::pow(-1_int128, p) == 1);
2623 : }
2624 : else
2625 : {
2626 64 : CATCH_REQUIRE(snapdev::pow(-1_int128, p) == -1);
2627 : }
2628 :
2629 : // for any other number, it becomes 0
2630 : //
2631 128 : CATCH_REQUIRE(snapdev::pow(-2_int128, p) == 0);
2632 128 : CATCH_REQUIRE(snapdev::pow(-3_int128, p) == 0);
2633 128 : CATCH_REQUIRE(snapdev::pow(-4_int128, p) == 0);
2634 128 : CATCH_REQUIRE(snapdev::pow(-5_int128, p) == 0);
2635 : }
2636 : }
2637 : CATCH_END_SECTION()
2638 11 : }
2639 :
2640 :
2641 :
2642 : // vim: ts=4 sw=4 et
|
