LCOV - code coverage report
Current view: top level - tests/ctest - test_conversion.c (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 212 212 100.0 %
Date: 2019-09-12 12:28:41 Functions: 4 4 100.0 %

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief
       5             :  *
       6             :  * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
       7             :  */
       8             : 
       9             : #include <kdbease.h>
      10             : 
      11             : #include "tests.h"
      12             : 
      13             : #define TEST_TO_STRING(Type, value, expect)                                                                                                \
      14             :         do                                                                                                                                 \
      15             :         {                                                                                                                                  \
      16             :                 const char * expected = (expect);                                                                                          \
      17             :                 char * actual = elektra##Type##ToString ((value));                                                                         \
      18             :                 succeed_if_same_string (actual, expected);                                                                                 \
      19             :                 elektraFree (actual);                                                                                                      \
      20             :         } while (0)
      21             : 
      22             : #define TEST_FROM_KEY(Type, ctype, val, expect)                                                                                            \
      23             :         do                                                                                                                                 \
      24             :         {                                                                                                                                  \
      25             :                 const char * value = (val);                                                                                                \
      26             :                 Key * k = keyNew ("user/test", KEY_VALUE, value, KEY_END);                                                                 \
      27             :                 ctype expected = (expect);                                                                                                 \
      28             :                 ctype var;                                                                                                                 \
      29             :                 succeed_if (elektraKeyTo##Type (k, &var) == 1, val " couldn't be read");                                                   \
      30             :                 succeed_if (var == expected, val " not read correctly");                                                                   \
      31             :                 keyDel (k);                                                                                                                \
      32             :         } while (0)
      33             : 
      34             : #define TEST_ROUNDTRIP(Type, ctype, strval, val)                                                                                           \
      35             :         do                                                                                                                                 \
      36             :         {                                                                                                                                  \
      37             :                 const char * string = (strval);                                                                                            \
      38             :                 ctype value = (val);                                                                                                       \
      39             :                 {                                                                                                                          \
      40             :                         char * s = elektra##Type##ToString (value);                                                                        \
      41             :                         Key * k = keyNew ("user/test", KEY_VALUE, s, KEY_END);                                                             \
      42             :                         ctype var;                                                                                                         \
      43             :                         succeed_if (elektraKeyTo##Type (k, &var) == 1, strval " couldn't be read back (1)");                               \
      44             :                         succeed_if (var == value, strval " not read back correctly");                                                      \
      45             :                         elektraFree (s);                                                                                                   \
      46             :                         keyDel (k);                                                                                                        \
      47             :                 }                                                                                                                          \
      48             :                                                                                                                                            \
      49             :                 {                                                                                                                          \
      50             :                         Key * k = keyNew ("user/test", KEY_VALUE, string, KEY_END);                                                        \
      51             :                         ctype var;                                                                                                         \
      52             :                         succeed_if (elektraKeyTo##Type (k, &var) == 1, strval " couldn't be read (1)");                                    \
      53             :                         char * s = elektra##Type##ToString (var);                                                                          \
      54             :                         succeed_if (strcmp (s, string) == 0, strval " not read correctly");                                                \
      55             :                         elektraFree (s);                                                                                                   \
      56             :                         keyDel (k);                                                                                                        \
      57             :                 }                                                                                                                          \
      58             :         } while (0)
      59             : 
      60             : #define TEST_DOUBLE_ROUNDTRIP(Type, ctype, strval, val)                                                                                    \
      61             :         do                                                                                                                                 \
      62             :         {                                                                                                                                  \
      63             :                 const char * string = (strval);                                                                                            \
      64             :                 ctype value = (val);                                                                                                       \
      65             :                 {                                                                                                                          \
      66             :                         char * s = elektra##Type##ToString (value);                                                                        \
      67             :                         Key * k = keyNew ("user/test", KEY_VALUE, s, KEY_END);                                                             \
      68             :                         ctype var;                                                                                                         \
      69             :                         succeed_if (elektraKeyTo##Type (k, &var) == 1, strval " couldn't be read back (1)");                               \
      70             :                         char * s1 = elektra##Type##ToString (var);                                                                         \
      71             :                         Key * k1 = keyNew ("user/test", KEY_VALUE, s1, KEY_END);                                                           \
      72             :                         ctype var1;                                                                                                        \
      73             :                         succeed_if (elektraKeyTo##Type (k1, &var1) == 1, strval " couldn't be read back (2)");                             \
      74             :                         succeed_if (var1 == var, strval " not read back correctly");                                                       \
      75             :                         elektraFree (s);                                                                                                   \
      76             :                         elektraFree (s1);                                                                                                  \
      77             :                         keyDel (k);                                                                                                        \
      78             :                         keyDel (k1);                                                                                                       \
      79             :                 }                                                                                                                          \
      80             :                                                                                                                                            \
      81             :                 {                                                                                                                          \
      82             :                         Key * k = keyNew ("user/test", KEY_VALUE, string, KEY_END);                                                        \
      83             :                         ctype var;                                                                                                         \
      84             :                         succeed_if (elektraKeyTo##Type (k, &var) == 1, strval " couldn't be read (1)");                                    \
      85             :                         char * s = elektra##Type##ToString (var);                                                                          \
      86             :                         Key * k1 = keyNew ("user/test", KEY_VALUE, s, KEY_END);                                                            \
      87             :                         ctype var1;                                                                                                        \
      88             :                         succeed_if (elektraKeyTo##Type (k, &var1) == 1, strval " couldn't be read (2)");                                   \
      89             :                         char * s1 = elektra##Type##ToString (var1);                                                                        \
      90             :                         succeed_if (strcmp (s1, s) == 0, strval " not read correctly");                                                    \
      91             :                         elektraFree (s);                                                                                                   \
      92             :                         elektraFree (s1);                                                                                                  \
      93             :                         keyDel (k);                                                                                                        \
      94             :                         keyDel (k1);                                                                                                       \
      95             :                 }                                                                                                                          \
      96             :         } while (0)
      97             : 
      98           2 : static void test_to_string (void)
      99             : {
     100           2 :         TEST_TO_STRING (Boolean, true, "1");
     101           2 :         TEST_TO_STRING (Boolean, false, "0");
     102           2 :         TEST_TO_STRING (Boolean, 1, "1");
     103           2 :         TEST_TO_STRING (Boolean, 0, "0");
     104             : 
     105         514 :         for (int c = -128; c < 128; c++)
     106             :         {
     107         512 :                 const char expect[2] = { (char) c, '\0' };
     108         512 :                 TEST_TO_STRING (Char, (kdb_char_t) c, expect);
     109             :         }
     110             : 
     111           2 :         TEST_TO_STRING (Octet, 15, "15");
     112           2 :         TEST_TO_STRING (Octet, 0, "0");
     113           2 :         TEST_TO_STRING (Octet, 255, "255");
     114             : 
     115           2 :         TEST_TO_STRING (Short, 15, "15");
     116           2 :         TEST_TO_STRING (Short, 0, "0");
     117           2 :         TEST_TO_STRING (Short, 127, "127");
     118           2 :         TEST_TO_STRING (Short, -128, "-128");
     119           2 :         TEST_TO_STRING (Short, 32767, "32767");
     120           2 :         TEST_TO_STRING (Short, -32768, "-32768");
     121             : 
     122           2 :         TEST_TO_STRING (UnsignedShort, 15, "15");
     123           2 :         TEST_TO_STRING (UnsignedShort, 0, "0");
     124           2 :         TEST_TO_STRING (UnsignedShort, 255, "255");
     125           2 :         TEST_TO_STRING (UnsignedShort, 65535, "65535");
     126             : 
     127           2 :         TEST_TO_STRING (Long, 15, "15");
     128           2 :         TEST_TO_STRING (Long, 0, "0");
     129           2 :         TEST_TO_STRING (Long, 127, "127");
     130           2 :         TEST_TO_STRING (Long, -128, "-128");
     131           2 :         TEST_TO_STRING (Long, 32767, "32767");
     132           2 :         TEST_TO_STRING (Long, -32768, "-32768");
     133           2 :         TEST_TO_STRING (Long, 2147483647, "2147483647");
     134           2 :         TEST_TO_STRING (Long, -2147483648, "-2147483648");
     135             : 
     136           2 :         TEST_TO_STRING (UnsignedLong, 15, "15");
     137           2 :         TEST_TO_STRING (UnsignedLong, 0, "0");
     138           2 :         TEST_TO_STRING (UnsignedLong, 255, "255");
     139           2 :         TEST_TO_STRING (UnsignedLong, 65535, "65535");
     140           2 :         TEST_TO_STRING (UnsignedLong, 4294967295, "4294967295");
     141             : 
     142           2 :         TEST_TO_STRING (LongLong, 15, "15");
     143           2 :         TEST_TO_STRING (LongLong, 0, "0");
     144           2 :         TEST_TO_STRING (LongLong, 127, "127");
     145           2 :         TEST_TO_STRING (LongLong, -128, "-128");
     146           2 :         TEST_TO_STRING (LongLong, 32767, "32767");
     147           2 :         TEST_TO_STRING (LongLong, -32768, "-32768");
     148           2 :         TEST_TO_STRING (LongLong, 2147483647, "2147483647");
     149           2 :         TEST_TO_STRING (LongLong, -2147483648, "-2147483648");
     150           2 :         TEST_TO_STRING (LongLong, 9223372036854775807LL, "9223372036854775807");
     151           2 :         TEST_TO_STRING (LongLong, -9223372036854775807LL - 1LL, "-9223372036854775808");
     152             : 
     153           2 :         TEST_TO_STRING (UnsignedLongLong, 15, "15");
     154           2 :         TEST_TO_STRING (UnsignedLongLong, 0, "0");
     155           2 :         TEST_TO_STRING (UnsignedLongLong, 255, "255");
     156           2 :         TEST_TO_STRING (UnsignedLongLong, 65535, "65535");
     157           2 :         TEST_TO_STRING (UnsignedLongLong, 4294967295, "4294967295");
     158           2 :         TEST_TO_STRING (UnsignedLongLong, 18446744073709551615ULL, "18446744073709551615");
     159             : 
     160           2 :         TEST_TO_STRING (Float, 0, "0");
     161           2 :         TEST_TO_STRING (Float, 1, "1");
     162           2 :         TEST_TO_STRING (Float, 2.5, "2.5");
     163           2 :         TEST_TO_STRING (Float, -2.5, "-2.5");
     164           2 :         TEST_TO_STRING (Float, 1.10000002, "1.10000002");
     165           2 :         TEST_TO_STRING (Float, -1.10000002, "-1.10000002");
     166             : 
     167           2 :         TEST_TO_STRING (Double, 0, "0");
     168           2 :         TEST_TO_STRING (Double, 1, "1");
     169           2 :         TEST_TO_STRING (Double, 2.5, "2.5");
     170           2 :         TEST_TO_STRING (Double, -2.5, "-2.5");
     171           2 :         TEST_TO_STRING (Double, 1.1000000000000001, "1.1000000000000001");
     172           2 :         TEST_TO_STRING (Double, -1.1000000000000001, "-1.1000000000000001");
     173             : 
     174             : #ifdef ELEKTRA_HAVE_KDB_LONG_DOUBLE
     175             : 
     176           2 :         TEST_TO_STRING (LongDouble, 0, "0");
     177           2 :         TEST_TO_STRING (LongDouble, 1, "1");
     178           2 :         TEST_TO_STRING (LongDouble, 2.5, "2.5");
     179           2 :         TEST_TO_STRING (LongDouble, -2.5, "-2.5");
     180           2 :         TEST_TO_STRING (LongDouble, 1.10000000000000008882, "1.10000000000000008882");
     181           2 :         TEST_TO_STRING (LongDouble, -1.10000000000000008882, "-1.10000000000000008882");
     182             : 
     183             : #endif // ELEKTRA_HAVE_KDB_LONG_DOUBLE
     184           2 : }
     185             : 
     186           2 : static void test_from_key (void)
     187             : {
     188           2 :         TEST_FROM_KEY (Boolean, kdb_boolean_t, "1", true);
     189           2 :         TEST_FROM_KEY (Boolean, kdb_boolean_t, "0", false);
     190             : 
     191           2 :         TEST_FROM_KEY (Char, kdb_char_t, "a", 'a');
     192           2 :         TEST_FROM_KEY (Char, kdb_char_t, "+", '+');
     193           2 :         TEST_FROM_KEY (Char, kdb_char_t, "\n", '\n');
     194             : 
     195           2 :         TEST_FROM_KEY (Octet, kdb_octet_t, "15", 15);
     196           2 :         TEST_FROM_KEY (Octet, kdb_octet_t, "0", 0);
     197           2 :         TEST_FROM_KEY (Octet, kdb_octet_t, "255", 255);
     198             : 
     199           2 :         TEST_FROM_KEY (Short, kdb_short_t, "15", 15);
     200           2 :         TEST_FROM_KEY (Short, kdb_short_t, "0", 0);
     201           2 :         TEST_FROM_KEY (Short, kdb_short_t, "127", 127);
     202           2 :         TEST_FROM_KEY (Short, kdb_short_t, "-128", -128);
     203           2 :         TEST_FROM_KEY (Short, kdb_short_t, "32767", 32767);
     204           2 :         TEST_FROM_KEY (Short, kdb_short_t, "-32768", -32768);
     205             : 
     206           2 :         TEST_FROM_KEY (UnsignedShort, kdb_unsigned_short_t, "15", 15);
     207           2 :         TEST_FROM_KEY (UnsignedShort, kdb_unsigned_short_t, "0", 0);
     208           2 :         TEST_FROM_KEY (UnsignedShort, kdb_unsigned_short_t, "255", 255);
     209           2 :         TEST_FROM_KEY (UnsignedShort, kdb_unsigned_short_t, "65535", 65535);
     210             : 
     211           2 :         TEST_FROM_KEY (Long, kdb_long_t, "15", 15);
     212           2 :         TEST_FROM_KEY (Long, kdb_long_t, "0", 0);
     213           2 :         TEST_FROM_KEY (Long, kdb_long_t, "127", 127);
     214           2 :         TEST_FROM_KEY (Long, kdb_long_t, "-128", -128);
     215           2 :         TEST_FROM_KEY (Long, kdb_long_t, "32767", 32767);
     216           2 :         TEST_FROM_KEY (Long, kdb_long_t, "-32768", -32768);
     217           2 :         TEST_FROM_KEY (Long, kdb_long_t, "2147483647", 2147483647);
     218           2 :         TEST_FROM_KEY (Long, kdb_long_t, "-2147483648", -2147483648);
     219             : 
     220           2 :         TEST_FROM_KEY (UnsignedLong, kdb_unsigned_long_t, "15", 15);
     221           2 :         TEST_FROM_KEY (UnsignedLong, kdb_unsigned_long_t, "0", 0);
     222           2 :         TEST_FROM_KEY (UnsignedLong, kdb_unsigned_long_t, "255", 255);
     223           2 :         TEST_FROM_KEY (UnsignedLong, kdb_unsigned_long_t, "65535", 65535);
     224           2 :         TEST_FROM_KEY (UnsignedLong, kdb_unsigned_long_t, "4294967295", 4294967295);
     225             : 
     226           2 :         TEST_FROM_KEY (LongLong, kdb_long_long_t, "15", 15);
     227           2 :         TEST_FROM_KEY (LongLong, kdb_long_long_t, "0", 0);
     228           2 :         TEST_FROM_KEY (LongLong, kdb_long_long_t, "127", 127);
     229           2 :         TEST_FROM_KEY (LongLong, kdb_long_long_t, "-128", -128);
     230           2 :         TEST_FROM_KEY (LongLong, kdb_long_long_t, "32767", 32767);
     231           2 :         TEST_FROM_KEY (LongLong, kdb_long_long_t, "-32768", -32768);
     232           2 :         TEST_FROM_KEY (LongLong, kdb_long_long_t, "2147483647", 2147483647);
     233           2 :         TEST_FROM_KEY (LongLong, kdb_long_long_t, "-2147483648", -2147483648);
     234           2 :         TEST_FROM_KEY (LongLong, kdb_long_long_t, "9223372036854775807", 9223372036854775807LL);
     235           2 :         TEST_FROM_KEY (LongLong, kdb_long_long_t, "-9223372036854775808", -9223372036854775807LL - 1LL);
     236             : 
     237           2 :         TEST_FROM_KEY (UnsignedLongLong, kdb_unsigned_long_long_t, "15", 15);
     238           2 :         TEST_FROM_KEY (UnsignedLongLong, kdb_unsigned_long_long_t, "0", 0);
     239           2 :         TEST_FROM_KEY (UnsignedLongLong, kdb_unsigned_long_long_t, "255", 255);
     240           2 :         TEST_FROM_KEY (UnsignedLongLong, kdb_unsigned_long_long_t, "65535", 65535);
     241           2 :         TEST_FROM_KEY (UnsignedLongLong, kdb_unsigned_long_long_t, "4294967295", 4294967295);
     242           2 :         TEST_FROM_KEY (UnsignedLongLong, kdb_unsigned_long_long_t, "18446744073709551615", 18446744073709551615ULL);
     243             : 
     244             :         // disable float-equal warnings
     245             :         // we intentionally compare floats exactly
     246             :         ELEKTRA_DIAG_STORE
     247             :         ELEKTRA_DIAG_OFF_STR ("-Wfloat-equal")
     248             : 
     249           2 :         TEST_FROM_KEY (Float, kdb_float_t, "0", 0);
     250           2 :         TEST_FROM_KEY (Float, kdb_float_t, "1", 1);
     251           2 :         TEST_FROM_KEY (Float, kdb_float_t, "2.5", 2.5);
     252           2 :         TEST_FROM_KEY (Float, kdb_float_t, "2.5", 2.5);
     253           2 :         TEST_FROM_KEY (Float, kdb_float_t, "1.10000002", 1.10000002);
     254           2 :         TEST_FROM_KEY (Float, kdb_float_t, "-1.10000002", -1.10000002);
     255             : 
     256           2 :         TEST_FROM_KEY (Double, kdb_double_t, "0", 0);
     257           2 :         TEST_FROM_KEY (Double, kdb_double_t, "1", 1);
     258           2 :         TEST_FROM_KEY (Double, kdb_double_t, "2.5", 2.5);
     259           2 :         TEST_FROM_KEY (Double, kdb_double_t, "2.5", 2.5);
     260           2 :         TEST_FROM_KEY (Double, kdb_double_t, "1.1000000000000001", 1.1000000000000001);
     261           2 :         TEST_FROM_KEY (Double, kdb_double_t, "-1.1000000000000001", -1.1000000000000001);
     262             : 
     263             : #ifdef ELEKTRA_HAVE_KDB_LONG_DOUBLE
     264             : 
     265           2 :         TEST_FROM_KEY (LongDouble, kdb_long_double_t, "0", 0);
     266           2 :         TEST_FROM_KEY (LongDouble, kdb_long_double_t, "1", 1);
     267           2 :         TEST_FROM_KEY (LongDouble, kdb_long_double_t, "2.5", 2.5);
     268           2 :         TEST_FROM_KEY (LongDouble, kdb_long_double_t, "2.5", 2.5);
     269           2 :         TEST_FROM_KEY (LongDouble, kdb_long_double_t, "1.10000000000000008882", 1.10000000000000008882);
     270           2 :         TEST_FROM_KEY (LongDouble, kdb_long_double_t, "-1.10000000000000008882", -1.10000000000000008882);
     271             : 
     272             : #endif // ELEKTRA_HAVE_KDB_LONG_DOUBLE
     273             : 
     274             :         ELEKTRA_DIAG_RESTORE
     275           2 : }
     276             : 
     277           2 : static void test_roundtrip (void)
     278             : {
     279           2 :         TEST_ROUNDTRIP (Boolean, kdb_boolean_t, "1", true);
     280           2 :         TEST_ROUNDTRIP (Boolean, kdb_boolean_t, "0", false);
     281             : 
     282           2 :         TEST_ROUNDTRIP (Char, kdb_char_t, "a", 'a');
     283           2 :         TEST_ROUNDTRIP (Char, kdb_char_t, "+", '+');
     284           2 :         TEST_ROUNDTRIP (Char, kdb_char_t, "\n", '\n');
     285             : 
     286           2 :         TEST_ROUNDTRIP (Octet, kdb_octet_t, "15", 15);
     287           2 :         TEST_ROUNDTRIP (Octet, kdb_octet_t, "0", 0);
     288           2 :         TEST_ROUNDTRIP (Octet, kdb_octet_t, "255", 255);
     289             : 
     290           2 :         TEST_ROUNDTRIP (Short, kdb_short_t, "15", 15);
     291           2 :         TEST_ROUNDTRIP (Short, kdb_short_t, "0", 0);
     292           2 :         TEST_ROUNDTRIP (Short, kdb_short_t, "127", 127);
     293           2 :         TEST_ROUNDTRIP (Short, kdb_short_t, "-128", -128);
     294           2 :         TEST_ROUNDTRIP (Short, kdb_short_t, "32767", 32767);
     295           2 :         TEST_ROUNDTRIP (Short, kdb_short_t, "-32768", -32768);
     296             : 
     297           2 :         TEST_ROUNDTRIP (UnsignedShort, kdb_unsigned_short_t, "15", 15);
     298           2 :         TEST_ROUNDTRIP (UnsignedShort, kdb_unsigned_short_t, "0", 0);
     299           2 :         TEST_ROUNDTRIP (UnsignedShort, kdb_unsigned_short_t, "255", 255);
     300           2 :         TEST_ROUNDTRIP (UnsignedShort, kdb_unsigned_short_t, "65535", 65535);
     301             : 
     302           2 :         TEST_ROUNDTRIP (Long, kdb_long_t, "15", 15);
     303           2 :         TEST_ROUNDTRIP (Long, kdb_long_t, "0", 0);
     304           2 :         TEST_ROUNDTRIP (Long, kdb_long_t, "127", 127);
     305           2 :         TEST_ROUNDTRIP (Long, kdb_long_t, "-128", -128);
     306           2 :         TEST_ROUNDTRIP (Long, kdb_long_t, "32767", 32767);
     307           2 :         TEST_ROUNDTRIP (Long, kdb_long_t, "-32768", -32768);
     308           2 :         TEST_ROUNDTRIP (Long, kdb_long_t, "2147483647", 2147483647);
     309           2 :         TEST_ROUNDTRIP (Long, kdb_long_t, "-2147483648", -2147483648);
     310             : 
     311           2 :         TEST_ROUNDTRIP (UnsignedLong, kdb_unsigned_long_t, "15", 15);
     312           2 :         TEST_ROUNDTRIP (UnsignedLong, kdb_unsigned_long_t, "0", 0);
     313           2 :         TEST_ROUNDTRIP (UnsignedLong, kdb_unsigned_long_t, "255", 255);
     314           2 :         TEST_ROUNDTRIP (UnsignedLong, kdb_unsigned_long_t, "65535", 65535);
     315           2 :         TEST_ROUNDTRIP (UnsignedLong, kdb_unsigned_long_t, "4294967295", 4294967295);
     316             : 
     317           2 :         TEST_ROUNDTRIP (LongLong, kdb_long_long_t, "15", 15);
     318           2 :         TEST_ROUNDTRIP (LongLong, kdb_long_long_t, "0", 0);
     319           2 :         TEST_ROUNDTRIP (LongLong, kdb_long_long_t, "127", 127);
     320           2 :         TEST_ROUNDTRIP (LongLong, kdb_long_long_t, "-128", -128);
     321           2 :         TEST_ROUNDTRIP (LongLong, kdb_long_long_t, "32767", 32767);
     322           2 :         TEST_ROUNDTRIP (LongLong, kdb_long_long_t, "-32768", -32768);
     323           2 :         TEST_ROUNDTRIP (LongLong, kdb_long_long_t, "2147483647", 2147483647);
     324           2 :         TEST_ROUNDTRIP (LongLong, kdb_long_long_t, "-2147483648", -2147483648);
     325           2 :         TEST_ROUNDTRIP (LongLong, kdb_long_long_t, "9223372036854775807", 9223372036854775807LL);
     326           2 :         TEST_ROUNDTRIP (LongLong, kdb_long_long_t, "-9223372036854775808", -9223372036854775807LL - 1LL);
     327             : 
     328           2 :         TEST_ROUNDTRIP (UnsignedLongLong, kdb_unsigned_long_long_t, "15", 15);
     329           2 :         TEST_ROUNDTRIP (UnsignedLongLong, kdb_unsigned_long_long_t, "0", 0);
     330           2 :         TEST_ROUNDTRIP (UnsignedLongLong, kdb_unsigned_long_long_t, "255", 255);
     331           2 :         TEST_ROUNDTRIP (UnsignedLongLong, kdb_unsigned_long_long_t, "65535", 65535);
     332           2 :         TEST_ROUNDTRIP (UnsignedLongLong, kdb_unsigned_long_long_t, "4294967295", 4294967295);
     333           2 :         TEST_ROUNDTRIP (UnsignedLongLong, kdb_unsigned_long_long_t, "18446744073709551615", 18446744073709551615ULL);
     334             : 
     335             :         // do double roundtrip for floats, because the initial value
     336             :         // may not be exactly representable, after one roundtrip
     337             :         // the value must stay the same for further roundtrips
     338             : 
     339             :         // disable float-equal warnings
     340             :         // we intentionally compare floats exactly
     341             :         ELEKTRA_DIAG_STORE
     342             :         ELEKTRA_DIAG_OFF_STR ("-Wfloat-equal")
     343             : 
     344           2 :         TEST_DOUBLE_ROUNDTRIP (Float, kdb_float_t, "0", 0);
     345           2 :         TEST_DOUBLE_ROUNDTRIP (Float, kdb_float_t, "1", 1);
     346           2 :         TEST_DOUBLE_ROUNDTRIP (Float, kdb_float_t, "2.5", 2.5);
     347           2 :         TEST_DOUBLE_ROUNDTRIP (Float, kdb_float_t, "2.5", 2.5);
     348           2 :         TEST_DOUBLE_ROUNDTRIP (Float, kdb_float_t, "1.1", 1.1);
     349           2 :         TEST_DOUBLE_ROUNDTRIP (Float, kdb_float_t, "-1.1", -1.1);
     350             : 
     351           2 :         TEST_DOUBLE_ROUNDTRIP (Double, kdb_double_t, "0", 0);
     352           2 :         TEST_DOUBLE_ROUNDTRIP (Double, kdb_double_t, "1", 1);
     353           2 :         TEST_DOUBLE_ROUNDTRIP (Double, kdb_double_t, "2.5", 2.5);
     354           2 :         TEST_DOUBLE_ROUNDTRIP (Double, kdb_double_t, "2.5", 2.5);
     355           2 :         TEST_DOUBLE_ROUNDTRIP (Double, kdb_double_t, "1.1", 1.1);
     356           2 :         TEST_DOUBLE_ROUNDTRIP (Double, kdb_double_t, "-1.1", -1.1);
     357             : 
     358             : #ifdef ELEKTRA_HAVE_KDB_LONG_DOUBLE
     359             : 
     360           2 :         TEST_DOUBLE_ROUNDTRIP (LongDouble, kdb_long_double_t, "0", 0);
     361           2 :         TEST_DOUBLE_ROUNDTRIP (LongDouble, kdb_long_double_t, "1", 1);
     362           2 :         TEST_DOUBLE_ROUNDTRIP (LongDouble, kdb_long_double_t, "2.5", 2.5);
     363           2 :         TEST_DOUBLE_ROUNDTRIP (LongDouble, kdb_long_double_t, "2.5", 2.5);
     364           2 :         TEST_DOUBLE_ROUNDTRIP (LongDouble, kdb_long_double_t, "1.1", 1.1);
     365           2 :         TEST_DOUBLE_ROUNDTRIP (LongDouble, kdb_long_double_t, "-1.1", -1.1);
     366             : 
     367             : #endif // ELEKTRA_HAVE_KDB_LONG_DOUBLE
     368             : 
     369             :         ELEKTRA_DIAG_RESTORE
     370           2 : }
     371             : 
     372           2 : int main (int argc, char ** argv)
     373             : {
     374           2 :         printf (" CONVERSION   TESTS\n");
     375           2 :         printf ("==================\n\n");
     376             : 
     377           2 :         init (argc, argv);
     378             : 
     379           2 :         test_to_string ();
     380           2 :         test_from_key ();
     381           2 :         test_roundtrip ();
     382             : 
     383           2 :         print_result ("test_conversion");
     384             : 
     385           2 :         return nbError;
     386             : }

Generated by: LCOV version 1.13