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