Line data    Source code

       1              : #define CLOVE_SUITE_NAME UtilSuite
       2              : 
       3              : #include "clove-unit.h"
       4              : 
       5              : #include "../src/util/globals.h"
       6              : #include "../src/util/int.h"
       7              : #include "../src/util/strings.h"
       8              : 
       9              : // ====================== lengthInt() ========================//
      10            2 : CLOVE_TEST(lengthIntZero)
      11              : {
      12            1 :   uint32_t length = lengthInt(0);
      13            1 :   CLOVE_UINT_EQ(1, length);
      14              : }
      15              : 
      16            2 : CLOVE_TEST(lengthIntPositive)
      17              : {
      18            1 :   uint32_t length = lengthInt(12890);
      19            1 :   CLOVE_UINT_EQ(5, length);
      20              : }
      21              : 
      22            2 : CLOVE_TEST(lengthIntNegative)
      23              : {
      24            1 :   uint32_t length = lengthInt(-870);
      25            1 :   CLOVE_UINT_EQ(3, length);
      26              : }
      27              : 
      28            2 : CLOVE_TEST(lengthIntNonIntParameter)
      29              : {
      30            1 :   uint32_t length4 = lengthInt(0.0);
      31            1 :   CLOVE_INT_EQ(1, length4);
      32              : 
      33            1 :   uint32_t length5 = lengthInt(12.1099);
      34            1 :   CLOVE_INT_EQ(2, length5);
      35              : 
      36            1 :   uint32_t length6 = lengthInt(-780.001);
      37            1 :   CLOVE_INT_EQ(3, length6);
      38              : 
      39            1 :   uint32_t length7 = lengthInt(.012);
      40            1 :   CLOVE_INT_EQ(1, length7);
      41              : 
      42            1 :   uint32_t length = lengthInt(0x0);
      43            1 :   CLOVE_INT_EQ(PARAMETER_IS_HEX, length);
      44              : 
      45            1 :   uint32_t length2 = lengthInt(0xF12);
      46            1 :   CLOVE_INT_EQ(PARAMETER_IS_HEX, length2);
      47              : 
      48            0 :   uint32_t length3 = lengthInt(0X109);
      49            0 :   CLOVE_INT_EQ(PARAMETER_IS_HEX, length3);
      50              : }
      51              : 
      52              : // ====================== abs() ========================//
      53            2 : CLOVE_TEST(absZero)
      54              : {
      55            1 :   uint32_t value = abs(0);
      56            1 :   CLOVE_UINT_EQ(0, value);
      57              : }
      58              : 
      59            2 : CLOVE_TEST(absNegative)
      60              : {
      61            1 :   uint32_t value = abs(-872);
      62            1 :   CLOVE_UINT_EQ(872, value);
      63              : }
      64              : 
      65            2 : CLOVE_TEST(absPositive)
      66              : {
      67            1 :   uint32_t value = abs(103);
      68            1 :   CLOVE_UINT_EQ(103, value);
      69              : }
      70              : 
      71            2 : CLOVE_TEST(absNonIntParameter)
      72              : {
      73            1 :   uint32_t value1= abs(0x0);
      74            1 :   CLOVE_UINT_EQ(PARAMETER_IS_HEX, value1);
      75              : 
      76            1 :   uint32_t value2 = abs(0xF1);
      77            1 :   CLOVE_UINT_EQ(PARAMETER_IS_HEX, value2);
      78              : 
      79            0 :   uint32_t value3 = abs(12.1);
      80            0 :   CLOVE_UINT_EQ(PARAMETER_IS_HEX, value3);
      81              : }
      82              : 
      83              : // ====================== stringToInt() ========================//
      84            2 : CLOVE_TEST(stringToIntNULL)
      85              : {
      86            1 :   int32_t value1 = stringToInt(NULL);
      87            1 :   CLOVE_UINT_EQ(STRING_IS_NULL, value1);
      88              : 
      89            1 :   int32_t value2 = stringToInt("");
      90            1 :   CLOVE_UINT_EQ(STRING_IS_NULL, value2);
      91              : 
      92            0 :   int32_t value3 = stringToInt("  ");
      93            0 :   CLOVE_UINT_EQ(STRING_IS_NULL, value3);
      94              : }
      95              : 
      96            2 : CLOVE_TEST(stringToIntContainsNonDigits)
      97              : {
      98            1 :   uint32_t value1 = stringToInt("str1ng");
      99            1 :   CLOVE_UINT_EQ(STRING_CONTAINS_NON_DIGITS, value1);
     100              : 
     101            1 :   uint32_t value2 = stringToInt("12test");
     102            1 :   CLOVE_UINT_EQ(STRING_CONTAINS_NON_DIGITS, value2);
     103              : 
     104            0 :   uint32_t value3 = stringToInt("!86:_");
     105            0 :   CLOVE_UINT_EQ(STRING_CONTAINS_NON_DIGITS, value3);
     106              : 
     107            0 :   uint32_t value4 = stringToInt("0.1");
     108            0 :   CLOVE_UINT_EQ(STRING_IS_FLOAT, value4);
     109              : 
     110            0 :   uint32_t value5 = stringToInt("12.07");
     111            0 :   CLOVE_UINT_EQ(STRING_IS_FLOAT, value5);
     112              : 
     113            0 :   uint32_t value6 = stringToInt(".0");
     114            0 :   CLOVE_UINT_EQ(STRING_IS_FLOAT, value6);
     115              : 
     116            0 :   uint32_t value7 = stringToInt("0xF1");
     117            0 :   CLOVE_UINT_EQ(STRING_IS_HEX, value7);
     118              : 
     119            0 :   uint32_t value8 = stringToInt("0x23");
     120            0 :   CLOVE_UINT_EQ(STRING_IS_HEX, value8);
     121              : }
     122              : 
     123            2 : CLOVE_TEST(stringToIntAllDigits)
     124              : {
     125            1 :   uint32_t value1 = stringToInt("0");
     126            1 :   CLOVE_UINT_EQ(0, value1);
     127              : 
     128            1 :   uint32_t value2 = stringToInt("123");
     129            1 :   CLOVE_UINT_EQ(123, value2);
     130              : 
     131            1 :   uint32_t value3 = stringToInt("0078900");
     132            1 :   CLOVE_UINT_EQ(78900, value3);
     133              : }
     134              : 
     135              : // ====================== hexToDecimal() ========================//
     136            2 : CLOVE_TEST(hexToDecimalNULL)
     137              : {
     138            1 :   uint32_t value = hexToDecimal(NULL);
     139            1 :   CLOVE_UINT_EQ(0, value);
     140              : }
     141              : 
     142            2 : CLOVE_TEST(hexToDecimalInputHex)
     143              : {
     144            1 :   uint32_t value1 = hexToDecimal(0xFF);
     145            1 :   CLOVE_UINT_EQ(255, value1);
     146              : 
     147            1 :   uint32_t value2 = hexToDecimal(0x0);
     148            1 :   CLOVE_UINT_EQ(0, value2);
     149              : 
     150            0 :   uint32_t value3 = hexToDecimal(0XA12);
     151            0 :   CLOVE_UINT_EQ(2578, value3);
     152              : }
     153              : 
     154            2 : CLOVE_TEST(hexToDecimalInputNonHex)
     155              : {
     156            1 :   uint32_t value1 = hexToDecimal(0);
     157            1 :   CLOVE_UINT_EQ(PARAMETER_SHOULD_BE_HEX, value1);
     158              : 
     159            1 :   uint32_t value2 = hexToDecimal(12);
     160            1 :   CLOVE_UINT_EQ(PARAMETER_SHOULD_BE_HEX, value2);
     161              : 
     162            0 :   uint32_t value3 = hexToDecimal(13.1);
     163            0 :   CLOVE_UINT_EQ(PARAMETER_SHOULD_BE_HEX, value3);
     164              : 
     165            0 :   uint32_t value4 = hexToDecimal(.1);
     166            0 :   CLOVE_UINT_EQ(PARAMETER_SHOULD_BE_HEX, value3);
     167              : 
     168            0 :   uint32_t value5 = hexToDecimal(-0.012);
     169            0 :   CLOVE_UINT_EQ(PARAMETER_SHOULD_BE_HEX, value5);
     170              : 
     171            0 :   uint32_t value6 = hexToDecimal(-0.0);
     172            0 :   CLOVE_UINT_EQ(PARAMETER_SHOULD_BE_HEX, value6);
     173              : }