Line data    Source code

       1             : // Copyright (c) 2011-2023  Made to Order Software Corp.  All Rights Reserved
       2             : //
       3             : // https://snapwebsites.org/project/as2js
       4             : // contact@m2osw.com
       5             : //
       6             : // This program is free software: you can redistribute it and/or modify
       7             : // it under the terms of the GNU General Public License as published by
       8             : // the Free Software Foundation, either version 3 of the License, or
       9             : // (at your option) any later version.
      10             : //
      11             : // This program is distributed in the hope that it will be useful,
      12             : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14             : // GNU General Public License for more details.
      15             : //
      16             : // You should have received a copy of the GNU General Public License
      17             : // along with this program.  If not, see <https://www.gnu.org/licenses/>.
      18             : 
      19             : // as2js
      20             : //
      21             : #include    <as2js/integer.h>
      22             : 
      23             : 
      24             : // self
      25             : //
      26             : #include    "catch_main.h"
      27             : 
      28             : 
      29             : // C
      30             : //
      31             : #include    <cstring>
      32             : #include    <algorithm>
      33             : 
      34             : 
      35             : // last include
      36             : //
      37             : #include    <snapdev/poison.h>
      38             : 
      39             : 
      40             : 
      41             : 
      42             : 
      43             : 
      44             : 
      45           9 : CATCH_TEST_CASE("integer", "[number][integer][type]")
      46             : {
      47           9 :     CATCH_START_SECTION("integer: default constructor")
      48             :     {
      49             :         // default constructor gives us zero
      50             :         //
      51           1 :         as2js::integer zero;
      52           1 :         CATCH_REQUIRE(zero.get() == 0);
      53             :     }
      54           9 :     CATCH_END_SECTION()
      55             : 
      56           9 :     CATCH_START_SECTION("integer: int8_t")
      57             :     {
      58             :         // int8_t constructor, copy constructor, copy assignment
      59             :         //
      60        1001 :         for(int i(0); i < 1000; ++i)
      61             :         {
      62             :             // generate a random 8 bit number
      63             :             //
      64        1000 :             std::int8_t r(0);
      65        1000 :             SNAP_CATCH2_NAMESPACE::random(r);
      66             : 
      67             :             // sign extends properly?
      68             :             //
      69        1000 :             as2js::integer random(r);
      70        1000 :             CATCH_REQUIRE(random.get() == r);
      71             : 
      72             :             // copy works as expected?
      73             :             //
      74        1000 :             as2js::integer copy(random);
      75        1000 :             CATCH_REQUIRE(copy.get() == r);
      76             : 
      77        1000 :             std::int8_t q(0);
      78        1000 :             SNAP_CATCH2_NAMESPACE::random(q);
      79             : 
      80        1000 :             random = q;
      81        1000 :             CATCH_REQUIRE(random.get() == q);
      82             : 
      83        1000 :             CATCH_REQUIRE(as2js::compare_utils::is_ordered(random.compare(copy)));
      84        1000 :             CATCH_REQUIRE(as2js::compare_utils::is_ordered(copy.compare(random)));
      85        1000 :             if(q < r)
      86             :             {
      87         518 :                 CATCH_REQUIRE(random.compare(copy) == as2js::compare_t::COMPARE_LESS);
      88         518 :                 CATCH_REQUIRE(copy.compare(random) == as2js::compare_t::COMPARE_GREATER);
      89             :             }
      90         482 :             else if(q > r)
      91             :             {
      92         475 :                 CATCH_REQUIRE(random.compare(copy) == as2js::compare_t::COMPARE_GREATER);
      93         475 :                 CATCH_REQUIRE(copy.compare(random) == as2js::compare_t::COMPARE_LESS);
      94             :             }
      95             :             else
      96             :             {
      97           7 :                 CATCH_REQUIRE(random.compare(copy) == as2js::compare_t::COMPARE_EQUAL);
      98           7 :                 CATCH_REQUIRE(copy.compare(random) == as2js::compare_t::COMPARE_EQUAL);
      99             :             }
     100             : 
     101        1000 :             std::int8_t p(0);
     102        1000 :             SNAP_CATCH2_NAMESPACE::random(p);
     103             : 
     104        1000 :             random.set(p);
     105        1000 :             CATCH_REQUIRE(random.get() == p);
     106             :         }
     107             :     }
     108           9 :     CATCH_END_SECTION()
     109             : 
     110           9 :     CATCH_START_SECTION("integer: uint8_t")
     111             :     {
     112             :         // uint8_t constructor, copy constructor, copy assignment
     113             :         //
     114        1001 :         for(int i(0); i < 1000; ++i)
     115             :         {
     116             :             // generate a random 8 bit number
     117             :             //
     118        1000 :             std::uint8_t r(0);
     119        1000 :             SNAP_CATCH2_NAMESPACE::random(r);
     120             : 
     121             :             // sign extends properly?
     122             :             //
     123        1000 :             as2js::integer random(r);
     124        1000 :             CATCH_REQUIRE(random.get() == r);
     125             : 
     126             :             // copy works as expected?
     127             :             //
     128        1000 :             as2js::integer copy(random);
     129        1000 :             CATCH_REQUIRE(copy.get() == r);
     130             : 
     131        1000 :             std::uint8_t q(0);
     132        1000 :             SNAP_CATCH2_NAMESPACE::random(q);
     133             : 
     134        1000 :             random = q;
     135        1000 :             CATCH_REQUIRE(random.get() == q);
     136             : 
     137        1000 :             CATCH_REQUIRE(as2js::compare_utils::is_ordered(random.compare(copy)));
     138        1000 :             CATCH_REQUIRE(as2js::compare_utils::is_ordered(copy.compare(random)));
     139        1000 :             if(q < r)
     140             :             {
     141         485 :                 CATCH_REQUIRE(random.compare(copy) == as2js::compare_t::COMPARE_LESS);
     142         485 :                 CATCH_REQUIRE(copy.compare(random) == as2js::compare_t::COMPARE_GREATER);
     143             :             }
     144         515 :             else if(q > r)
     145             :             {
     146         513 :                 CATCH_REQUIRE(random.compare(copy) == as2js::compare_t::COMPARE_GREATER);
     147         513 :                 CATCH_REQUIRE(copy.compare(random) == as2js::compare_t::COMPARE_LESS);
     148             :             }
     149             :             else
     150             :             {
     151           2 :                 CATCH_REQUIRE(random.compare(copy) == as2js::compare_t::COMPARE_EQUAL);
     152           2 :                 CATCH_REQUIRE(copy.compare(random) == as2js::compare_t::COMPARE_EQUAL);
     153             :             }
     154             : 
     155        1000 :             std::uint8_t p(0);
     156        1000 :             SNAP_CATCH2_NAMESPACE::random(p);
     157             : 
     158        1000 :             random.set(p);
     159        1000 :             CATCH_REQUIRE(random.get() == p);
     160             :         }
     161             :     }
     162           9 :     CATCH_END_SECTION()
     163             : 
     164           9 :     CATCH_START_SECTION("integer: int16_t")
     165             :     {
     166             :         // int16_t constructor, copy constructor, copy assignment
     167             :         //
     168        1001 :         for(int i(0); i < 1000; ++i)
     169             :         {
     170             :             // generate a random 16 bit number
     171             :             //
     172        1000 :             std::int16_t r(0);
     173        1000 :             SNAP_CATCH2_NAMESPACE::random(r);
     174             : 
     175             :             // sign extends properly?
     176             :             //
     177        1000 :             as2js::integer random(r);
     178        1000 :             CATCH_REQUIRE(random.get() == r);
     179             : 
     180             :             // copy works as expected?
     181             :             //
     182        1000 :             as2js::integer copy(random);
     183        1000 :             CATCH_REQUIRE(copy.get() == r);
     184             : 
     185        1000 :             std::int16_t q(0);
     186        1000 :             SNAP_CATCH2_NAMESPACE::random(q);
     187             : 
     188        1000 :             random = q;
     189        1000 :             CATCH_REQUIRE(random.get() == q);
     190             : 
     191        1000 :             CATCH_REQUIRE(as2js::compare_utils::is_ordered(random.compare(copy)));
     192        1000 :             CATCH_REQUIRE(as2js::compare_utils::is_ordered(copy.compare(random)));
     193        1000 :             if(q < r)
     194             :             {
     195         477 :                 CATCH_REQUIRE(random.compare(copy) == as2js::compare_t::COMPARE_LESS);
     196         477 :                 CATCH_REQUIRE(copy.compare(random) == as2js::compare_t::COMPARE_GREATER);
     197             :             }
     198         523 :             else if(q > r)
     199             :             {
     200         523 :                 CATCH_REQUIRE(random.compare(copy) == as2js::compare_t::COMPARE_GREATER);
     201         523 :                 CATCH_REQUIRE(copy.compare(random) == as2js::compare_t::COMPARE_LESS);
     202             :             }
     203             :             else
     204             :             {
     205           0 :                 CATCH_REQUIRE(random.compare(copy) == as2js::compare_t::COMPARE_EQUAL);
     206           0 :                 CATCH_REQUIRE(copy.compare(random) == as2js::compare_t::COMPARE_EQUAL);
     207             :             }
     208             : 
     209        1000 :             std::int16_t p(0);
     210        1000 :             SNAP_CATCH2_NAMESPACE::random(p);
     211             : 
     212        1000 :             random.set(p);
     213        1000 :             CATCH_REQUIRE(random.get() == p);
     214             :         }
     215             :     }
     216           9 :     CATCH_END_SECTION()
     217             : 
     218           9 :     CATCH_START_SECTION("integer: uint16_t")
     219             :     {
     220             :         // uint16_t constructor, copy constructor, copy assignment
     221             :         //
     222        1001 :         for(int i(0); i < 1000; ++i)
     223             :         {
     224             :             // generate a random 16 bit number
     225             :             //
     226        1000 :             std::uint16_t r(0);
     227        1000 :             SNAP_CATCH2_NAMESPACE::random(r);
     228             : 
     229             :             // sign extends properly?
     230             :             //
     231        1000 :             as2js::integer random(r);
     232        1000 :             CATCH_REQUIRE(random.get() == r);
     233             : 
     234             :             // copy works as expected?
     235             :             //
     236        1000 :             as2js::integer copy(random);
     237        1000 :             CATCH_REQUIRE(copy.get() == r);
     238             : 
     239        1000 :             std::uint16_t q(0);
     240        1000 :             SNAP_CATCH2_NAMESPACE::random(q);
     241             : 
     242        1000 :             random = q;
     243        1000 :             CATCH_REQUIRE(random.get() == q);
     244             : 
     245        1000 :             CATCH_REQUIRE(as2js::compare_utils::is_ordered(random.compare(copy)));
     246        1000 :             CATCH_REQUIRE(as2js::compare_utils::is_ordered(copy.compare(random)));
     247        1000 :             if(q < r)
     248             :             {
     249         509 :                 CATCH_REQUIRE(random.compare(copy) == as2js::compare_t::COMPARE_LESS);
     250         509 :                 CATCH_REQUIRE(copy.compare(random) == as2js::compare_t::COMPARE_GREATER);
     251             :             }
     252         491 :             else if(q > r)
     253             :             {
     254         491 :                 CATCH_REQUIRE(random.compare(copy) == as2js::compare_t::COMPARE_GREATER);
     255         491 :                 CATCH_REQUIRE(copy.compare(random) == as2js::compare_t::COMPARE_LESS);
     256             :             }
     257             :             else
     258             :             {
     259           0 :                 CATCH_REQUIRE(random.compare(copy) == as2js::compare_t::COMPARE_EQUAL);
     260           0 :                 CATCH_REQUIRE(copy.compare(random) == as2js::compare_t::COMPARE_EQUAL);
     261             :             }
     262             : 
     263        1000 :             std::uint16_t p(0);
     264        1000 :             SNAP_CATCH2_NAMESPACE::random(p);
     265             : 
     266        1000 :             random.set(p);
     267        1000 :             CATCH_REQUIRE(random.get() == p);
     268             :         }
     269             :     }
     270           9 :     CATCH_END_SECTION()
     271             : 
     272           9 :     CATCH_START_SECTION("integer: int32_t")
     273             :     {
     274             :         // int32_t constructor, copy constructor, copy assignment
     275             :         //
     276        1001 :         for(int i(0); i < 1000; ++i)
     277             :         {
     278             :             // generate a random 32 bit number
     279             :             //
     280        1000 :             std::int32_t r(0);
     281        1000 :             SNAP_CATCH2_NAMESPACE::random(r);
     282             : 
     283             :             // sign extends properly?
     284        1000 :             as2js::integer random(r);
     285        1000 :             CATCH_REQUIRE(random.get() == r);
     286             : 
     287             :             // copy works as expected?
     288        1000 :             as2js::integer copy(random);
     289        1000 :             CATCH_REQUIRE(copy.get() == r);
     290             : 
     291        1000 :             std::int32_t q(0);
     292        1000 :             SNAP_CATCH2_NAMESPACE::random(q);
     293             : 
     294        1000 :             random = q;
     295        1000 :             CATCH_REQUIRE(random.get() == q);
     296             : 
     297        1000 :             CATCH_REQUIRE(as2js::compare_utils::is_ordered(random.compare(copy)));
     298        1000 :             CATCH_REQUIRE(as2js::compare_utils::is_ordered(copy.compare(random)));
     299        1000 :             if(q < r)
     300             :             {
     301         523 :                 CATCH_REQUIRE(random.compare(copy) == as2js::compare_t::COMPARE_LESS);
     302         523 :                 CATCH_REQUIRE(copy.compare(random) == as2js::compare_t::COMPARE_GREATER);
     303             :             }
     304         477 :             else if(q > r)
     305             :             {
     306         477 :                 CATCH_REQUIRE(random.compare(copy) == as2js::compare_t::COMPARE_GREATER);
     307         477 :                 CATCH_REQUIRE(copy.compare(random) == as2js::compare_t::COMPARE_LESS);
     308             :             }
     309             :             else
     310             :             {
     311           0 :                 CATCH_REQUIRE(random.compare(copy) == as2js::compare_t::COMPARE_EQUAL);
     312           0 :                 CATCH_REQUIRE(copy.compare(random) == as2js::compare_t::COMPARE_EQUAL);
     313             :             }
     314             : 
     315        1000 :             int32_t p(0);
     316        1000 :             SNAP_CATCH2_NAMESPACE::random(p);
     317             : 
     318        1000 :             random.set(p);
     319        1000 :             CATCH_REQUIRE(random.get() == p);
     320             :         }
     321             :     }
     322           9 :     CATCH_END_SECTION()
     323             : 
     324           9 :     CATCH_START_SECTION("integer: uint32_t")
     325             :     {
     326             :         // uint32_t constructor, copy constructor, copy assignment
     327        1001 :         for(int i(0); i < 1000; ++i)
     328             :         {
     329             :             // generate a random 32 bit number
     330        1000 :             std::uint32_t r(0);
     331        1000 :             SNAP_CATCH2_NAMESPACE::random(r);
     332             : 
     333             :             // sign extends properly?
     334        1000 :             as2js::integer random(r);
     335        1000 :             CATCH_REQUIRE(random.get() == r);
     336             : 
     337             :             // copy works as expected?
     338        1000 :             as2js::integer copy(random);
     339        1000 :             CATCH_REQUIRE(copy.get() == r);
     340             : 
     341        1000 :             std::uint32_t q(0);
     342        1000 :             SNAP_CATCH2_NAMESPACE::random(q);
     343             : 
     344        1000 :             random = q;
     345        1000 :             CATCH_REQUIRE(random.get() == q);
     346             : 
     347        1000 :             CATCH_REQUIRE(as2js::compare_utils::is_ordered(random.compare(copy)));
     348        1000 :             CATCH_REQUIRE(as2js::compare_utils::is_ordered(copy.compare(random)));
     349        1000 :             if(q < r)
     350             :             {
     351         512 :                 CATCH_REQUIRE(random.compare(copy) == as2js::compare_t::COMPARE_LESS);
     352         512 :                 CATCH_REQUIRE(copy.compare(random) == as2js::compare_t::COMPARE_GREATER);
     353             :             }
     354         488 :             else if(q > r)
     355             :             {
     356         488 :                 CATCH_REQUIRE(random.compare(copy) == as2js::compare_t::COMPARE_GREATER);
     357         488 :                 CATCH_REQUIRE(copy.compare(random) == as2js::compare_t::COMPARE_LESS);
     358             :             }
     359             :             else
     360             :             {
     361           0 :                 CATCH_REQUIRE(random.compare(copy) == as2js::compare_t::COMPARE_EQUAL);
     362           0 :                 CATCH_REQUIRE(copy.compare(random) == as2js::compare_t::COMPARE_EQUAL);
     363             :             }
     364             : 
     365        1000 :             std::uint32_t p(0);
     366        1000 :             SNAP_CATCH2_NAMESPACE::random(p);
     367             : 
     368        1000 :             random.set(p);
     369        1000 :             CATCH_REQUIRE(random.get() == p);
     370             :         }
     371             :     }
     372           9 :     CATCH_END_SECTION()
     373             : 
     374           9 :     CATCH_START_SECTION("integer: int64_t")
     375             :     {
     376             :         // int64_t constructor, copy constructor, copy assignment
     377             :         //
     378        1001 :         for(int i(0); i < 1000; ++i)
     379             :         {
     380             :             // generate a random 64 bit number
     381             :             //
     382        1000 :             std::int64_t r;
     383        1000 :             SNAP_CATCH2_NAMESPACE::random(r);
     384        1000 :             as2js::integer random(r);
     385        1000 :             CATCH_REQUIRE(random.get() == r);
     386             : 
     387        1000 :             as2js::integer copy(random);
     388        1000 :             CATCH_REQUIRE(copy.get() == r);
     389             : 
     390        1000 :             std::int64_t q(0);
     391        1000 :             SNAP_CATCH2_NAMESPACE::random(q);
     392             : 
     393        1000 :             random = q;
     394        1000 :             CATCH_REQUIRE(random.get() == q);
     395             : 
     396        1000 :             CATCH_REQUIRE(as2js::compare_utils::is_ordered(random.compare(copy)));
     397        1000 :             CATCH_REQUIRE(as2js::compare_utils::is_ordered(copy.compare(random)));
     398        1000 :             if(q < r)
     399             :             {
     400         516 :                 CATCH_REQUIRE(random.compare(copy) == as2js::compare_t::COMPARE_LESS);
     401         516 :                 CATCH_REQUIRE(copy.compare(random) == as2js::compare_t::COMPARE_GREATER);
     402             :             }
     403         484 :             else if(q > r)
     404             :             {
     405         484 :                 CATCH_REQUIRE(random.compare(copy) == as2js::compare_t::COMPARE_GREATER);
     406         484 :                 CATCH_REQUIRE(copy.compare(random) == as2js::compare_t::COMPARE_LESS);
     407             :             }
     408             :             else
     409             :             {
     410           0 :                 CATCH_REQUIRE(random.compare(copy) == as2js::compare_t::COMPARE_EQUAL);
     411           0 :                 CATCH_REQUIRE(copy.compare(random) == as2js::compare_t::COMPARE_EQUAL);
     412             :             }
     413             : 
     414        1000 :             std::int64_t p(0);
     415        1000 :             SNAP_CATCH2_NAMESPACE::random(p);
     416             : 
     417        1000 :             random.set(p);
     418        1000 :             CATCH_REQUIRE(random.get() == p);
     419             :         }
     420             :     }
     421           9 :     CATCH_END_SECTION()
     422             : 
     423           9 :     CATCH_START_SECTION("integer: uint64_t")
     424             :     {
     425             :         // uint64_t constructor, copy constructor, copy assignment
     426             :         //
     427        1001 :         for(int i(0); i < 1000; ++i)
     428             :         {
     429             :             // generate a random 64 bit number
     430             :             //
     431        1000 :             std::uint64_t r(0);
     432        1000 :             SNAP_CATCH2_NAMESPACE::random(r);
     433        1000 :             as2js::integer random(r);
     434        1000 :             CATCH_REQUIRE(random.get() == static_cast<decltype(random)::value_type>(r));
     435             : 
     436        1000 :             as2js::integer copy(random);
     437        1000 :             CATCH_REQUIRE(copy.get() == static_cast<decltype(copy)::value_type>(r));
     438             : 
     439        1000 :             std::uint64_t q(0);
     440        1000 :             SNAP_CATCH2_NAMESPACE::random(q);
     441             : 
     442        1000 :             random = q;
     443        1000 :             CATCH_REQUIRE(random.get() == static_cast<decltype(random)::value_type>(q));
     444             : 
     445             :             // Here the compare expects the signed int64_t...
     446        1000 :             CATCH_REQUIRE(as2js::compare_utils::is_ordered(random.compare(copy)));
     447        1000 :             CATCH_REQUIRE(as2js::compare_utils::is_ordered(copy.compare(random)));
     448        1000 :             if(static_cast<as2js::integer::value_type>(q) < static_cast<as2js::integer::value_type>(r))
     449             :             {
     450         503 :                 CATCH_REQUIRE(random.compare(copy) == as2js::compare_t::COMPARE_LESS);
     451         503 :                 CATCH_REQUIRE(copy.compare(random) == as2js::compare_t::COMPARE_GREATER);
     452             :             }
     453         497 :             else if(static_cast<as2js::integer::value_type>(q) > static_cast<as2js::integer::value_type>(r))
     454             :             {
     455         497 :                 CATCH_REQUIRE(random.compare(copy) == as2js::compare_t::COMPARE_GREATER);
     456         497 :                 CATCH_REQUIRE(copy.compare(random) == as2js::compare_t::COMPARE_LESS);
     457             :             }
     458             :             else
     459             :             {
     460           0 :                 CATCH_REQUIRE(random.compare(copy) == as2js::compare_t::COMPARE_EQUAL);
     461           0 :                 CATCH_REQUIRE(copy.compare(random) == as2js::compare_t::COMPARE_EQUAL);
     462             :             }
     463             : 
     464        1000 :             std::uint64_t p(0);
     465        1000 :             SNAP_CATCH2_NAMESPACE::random(p);
     466             : 
     467        1000 :             random.set(p);
     468        1000 :             CATCH_REQUIRE(random.get() == static_cast<decltype(random)::value_type>(p));
     469             :         }
     470             :     }
     471           9 :     CATCH_END_SECTION()
     472           9 : }
     473             : 
     474             : 
     475             : 
     476             : 
     477             : // vim: ts=4 sw=4 et