LCOV - code coverage report
Current view: top level - tests - catch_int128.cpp (source / functions) Hit Total Coverage
Test: coverage.info Lines: 1341 1341 100.0 %
Date: 2022-02-17 19:51:20 Functions: 4 4 100.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13