Branch data     Line data    Source code

       1                 :            : // Copyright 2019-2021 David Robillard <d@drobilla.net>
       2                 :            : // SPDX-License-Identifier: ISC
       3                 :            : 
       4                 :            : #undef NDEBUG
       5                 :            : 
       6                 :            : #include "../src/int_math.h"
       7                 :            : 
       8                 :            : #include <assert.h>
       9                 :            : #include <stdint.h>
      10                 :            : 
      11                 :            : static void
      12                 :          1 : test_clz32(void)
      13                 :            : {
      14         [ +  + ]:         33 :   for (unsigned i = 0; i < 32; ++i) {
      15         [ -  + ]:         32 :     assert(exess_clz32(1U << i) == 32U - i - 1U);
      16                 :            :   }
      17                 :          1 : }
      18                 :            : 
      19                 :            : static void
      20                 :          1 : test_clz64(void)
      21                 :            : {
      22         [ +  + ]:         65 :   for (unsigned i = 0; i < 64; ++i) {
      23         [ -  + ]:         64 :     assert(exess_clz64(1ULL << i) == 64U - i - 1U);
      24                 :            :   }
      25                 :          1 : }
      26                 :            : 
      27                 :            : static void
      28                 :          1 : test_ilog2(void)
      29                 :            : {
      30         [ +  + ]:         65 :   for (unsigned i = 0; i < 64; ++i) {
      31         [ -  + ]:         64 :     assert(exess_ilog2(1ULL << i) == i);
      32                 :            :   }
      33                 :          1 : }
      34                 :            : 
      35                 :            : static void
      36                 :          1 : test_ilog10(void)
      37                 :            : {
      38                 :          1 :   uint64_t power = 1;
      39         [ +  + ]:         21 :   for (unsigned i = 0; i < 20; ++i, power *= 10) {
      40         [ -  + ]:         20 :     assert(exess_ilog10(power) == i);
      41                 :            :   }
      42                 :          1 : }
      43                 :            : 
      44                 :            : static void
      45                 :          1 : test_num_digits(void)
      46                 :            : {
      47         [ -  + ]:          1 :   assert(1 == exess_num_digits(0));
      48         [ -  + ]:          1 :   assert(1 == exess_num_digits(1));
      49         [ -  + ]:          1 :   assert(1 == exess_num_digits(9));
      50         [ -  + ]:          1 :   assert(2 == exess_num_digits(10));
      51         [ -  + ]:          1 :   assert(2 == exess_num_digits(99ULL));
      52         [ -  + ]:          1 :   assert(3 == exess_num_digits(999ULL));
      53         [ -  + ]:          1 :   assert(4 == exess_num_digits(9999ULL));
      54         [ -  + ]:          1 :   assert(5 == exess_num_digits(99999ULL));
      55         [ -  + ]:          1 :   assert(6 == exess_num_digits(999999ULL));
      56         [ -  + ]:          1 :   assert(7 == exess_num_digits(9999999ULL));
      57         [ -  + ]:          1 :   assert(8 == exess_num_digits(99999999ULL));
      58         [ -  + ]:          1 :   assert(9 == exess_num_digits(999999999ULL));
      59         [ -  + ]:          1 :   assert(10 == exess_num_digits(9999999999ULL));
      60         [ -  + ]:          1 :   assert(11 == exess_num_digits(99999999999ULL));
      61         [ -  + ]:          1 :   assert(12 == exess_num_digits(999999999999ULL));
      62         [ -  + ]:          1 :   assert(13 == exess_num_digits(9999999999999ULL));
      63         [ -  + ]:          1 :   assert(14 == exess_num_digits(99999999999999ULL));
      64         [ -  + ]:          1 :   assert(15 == exess_num_digits(999999999999999ULL));
      65         [ -  + ]:          1 :   assert(16 == exess_num_digits(9999999999999999ULL));
      66         [ -  + ]:          1 :   assert(17 == exess_num_digits(99999999999999999ULL));
      67         [ -  + ]:          1 :   assert(18 == exess_num_digits(999999999999999999ULL));
      68         [ -  + ]:          1 :   assert(19 == exess_num_digits(9999999999999999999ULL));
      69         [ -  + ]:          1 :   assert(20 == exess_num_digits(18446744073709551615ULL));
      70                 :          1 : }
      71                 :            : 
      72                 :            : int
      73                 :          1 : main(void)
      74                 :            : {
      75                 :          1 :   test_clz32();
      76                 :          1 :   test_clz64();
      77                 :          1 :   test_ilog2();
      78                 :          1 :   test_ilog10();
      79                 :          1 :   test_num_digits();
      80                 :            : 
      81                 :          1 :   return 0;
      82                 :            : }