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

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief Test suite for internal data structures.
       5             :  *
       6             :  * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
       7             :  */
       8             : 
       9             : #include <tests_internal.h>
      10             : 
      11           2 : static void test_elektraMalloc (void)
      12             : {
      13           2 :         char * buffer = 0;
      14           2 :         buffer = elektraMalloc (50);
      15           2 :         exit_if_fail (buffer, "buffer must not be 0 after allocation");
      16           2 :         elektraRealloc ((void **) &buffer, 100);
      17           2 :         exit_if_fail (buffer, "buffer must not be 0 after reallocation");
      18           2 :         elektraRealloc ((void **) &buffer, 20);
      19           2 :         exit_if_fail (buffer, "buffer must not be 0 after reallocation");
      20           2 :         elektraFree (buffer);
      21             : 
      22           2 :         buffer = elektraCalloc (50);
      23           2 :         exit_if_fail (buffer, "buffer must not be 0 after allocation");
      24         100 :         for (int i = 0; i < 50; ++i)
      25             :         {
      26         100 :                 succeed_if (buffer[i] == 0, "elektraCalloc did not initialize buffer with zeros");
      27             :         }
      28           2 :         elektraRealloc ((void **) &buffer, 100);
      29           2 :         exit_if_fail (buffer, "buffer must not be 0 after reallocation");
      30           2 :         elektraRealloc ((void **) &buffer, 20);
      31           2 :         exit_if_fail (buffer, "buffer must not be 0 after reallocation");
      32             : 
      33           2 :         char * dup = elektraStrNDup (buffer, 20);
      34           2 :         exit_if_fail (dup, "could not duplicate buffer");
      35           2 :         elektraFree (buffer);
      36           2 :         buffer = 0;
      37          42 :         for (int i = 0; i < 20; ++i)
      38             :         {
      39          40 :                 succeed_if (dup[i] == 0, "elektraStrNDup did not correctly copy zero-buffer");
      40             :         }
      41           2 :         elektraFree (dup);
      42           2 : }
      43             : 
      44           2 : static void test_elektraStrLen (void)
      45             : {
      46             :         char charSeq[5];
      47             : 
      48           2 :         printf ("Test elektraStrLen\n");
      49         510 :         for (int i = 1; i < 255; ++i)
      50             :         {
      51         508 :                 charSeq[0] = '\33';
      52         508 :                 charSeq[1] = 'a';
      53         508 :                 charSeq[2] = i;       // 1..254
      54         508 :                 charSeq[3] = 256 - i; // 255..2
      55         508 :                 charSeq[4] = '\0';
      56             : 
      57             :                 // printf ("%s %d %d\n", charSeq, elektraStrLen (charSeq), strlen(charSeq));
      58         508 :                 succeed_if (elektraStrLen ((char *) charSeq) == 5, "could not deduce correct multichar sequence length");
      59             :         }
      60           2 : }
      61             : 
      62             : #define TEST_VALIDATE_NAME_OK(NAME, MSG) succeed_if (elektraValidateKeyName (NAME, sizeof (NAME)), MSG " ok");
      63             : 
      64             : #define TEST_VALIDATE_NAME_NOK(NAME, MSG) succeed_if (!elektraValidateKeyName (NAME, sizeof (NAME)), MSG " not ok");
      65             : 
      66           2 : static void test_elektraValidateKeyName (void)
      67             : {
      68           2 :         printf ("test validate key name\n");
      69             : 
      70           2 :         TEST_VALIDATE_NAME_OK ("normalKey", "normal key");
      71           2 :         TEST_VALIDATE_NAME_OK ("nor\\malKey", "stray escape");
      72           2 :         TEST_VALIDATE_NAME_OK ("nor\\\\malKey", "stray escape");
      73           2 :         TEST_VALIDATE_NAME_OK ("nor\\\\mal\\Key", "stray escape");
      74           2 :         TEST_VALIDATE_NAME_NOK ("tanglingKey\\", "tangling escape");
      75           2 :         TEST_VALIDATE_NAME_OK ("escapedEKey\\\\", "escape at end");
      76           2 :         TEST_VALIDATE_NAME_NOK ("tanglingKey\\\\\\", "tangling escape");
      77           2 :         TEST_VALIDATE_NAME_OK ("escapedEKey\\\\\\\\", "escape at end");
      78           2 :         TEST_VALIDATE_NAME_NOK ("tanglingKey\\\\\\\\\\", "tangling escape");
      79           2 :         TEST_VALIDATE_NAME_OK ("escapedEKey\\\\\\\\\\\\", "escape at end");
      80           2 :         TEST_VALIDATE_NAME_NOK ("tanglingKey\\\\\\\\\\\\\\", "tangling escape");
      81           2 : }
      82             : 
      83           2 : static void test_elektraEscapeKeyNamePart (void)
      84             : {
      85           2 :         printf ("test escape key name part\n");
      86             : 
      87             :         char dest[2000];
      88           2 :         succeed_if_same_string (elektraEscapeKeyNamePart ("abc", dest), "abc");
      89           2 :         succeed_if_same_string (elektraEscapeKeyNamePart (".", dest), "\\.");
      90           2 :         succeed_if_same_string (elektraEscapeKeyNamePart ("..", dest), "\\..");
      91           2 :         succeed_if_same_string (elektraEscapeKeyNamePart ("%", dest), "\\%");
      92           2 :         succeed_if_same_string (elektraEscapeKeyNamePart ("", dest), "%");
      93           2 :         succeed_if_same_string (elektraEscapeKeyNamePart ("///", dest), "\\/\\/\\/");
      94           2 :         succeed_if_same_string (elektraEscapeKeyNamePart ("a/b", dest), "a\\/b");
      95           2 :         succeed_if_same_string (elektraEscapeKeyNamePart ("a//b", dest), "a\\/\\/b");
      96           2 :         succeed_if_same_string (elektraEscapeKeyNamePart ("a/./b", dest), "a\\/.\\/b");
      97           2 :         succeed_if_same_string (elektraEscapeKeyNamePart ("a/../b", dest), "a\\/..\\/b");
      98           2 :         succeed_if_same_string (elektraEscapeKeyNamePart ("a/%/b", dest), "a\\/%\\/b");
      99           2 :         succeed_if_same_string (elektraEscapeKeyNamePart ("a/x/b", dest), "a\\/x\\/b");
     100           2 :         succeed_if_same_string (elektraEscapeKeyNamePart ("a\\.", dest), "a\\.");
     101           2 :         succeed_if_same_string (elektraEscapeKeyNamePart ("\\.", dest), "\\\\.");
     102           2 :         succeed_if_same_string (elektraEscapeKeyNamePart ("\\\\.", dest), "\\\\\\.");
     103           2 :         succeed_if_same_string (elektraEscapeKeyNamePart ("\\..", dest), "\\\\..");
     104           2 :         succeed_if_same_string (elektraEscapeKeyNamePart ("\\\\..", dest), "\\\\\\..");
     105           2 :         succeed_if_same_string (elektraEscapeKeyNamePart ("\\\\\\..", dest), "\\\\\\\\..");
     106           2 :         succeed_if_same_string (elektraEscapeKeyNamePart ("/", dest), "\\/");
     107           2 :         succeed_if_same_string (elektraEscapeKeyNamePart ("\\/", dest), "\\\\\\/");           // 1 -> 3
     108           2 :         succeed_if_same_string (elektraEscapeKeyNamePart ("\\\\/", dest), "\\\\\\\\\\/");    // 2 -> 5
     109           2 :         succeed_if_same_string (elektraEscapeKeyNamePart ("ab\\\\/", dest), "ab\\\\\\\\\\/");     // 2 -> 5
     110           2 :         succeed_if_same_string (elektraEscapeKeyNamePart ("ab\\\\/de", dest), "ab\\\\\\\\\\/de"); // 2 -> 5
     111           2 :         succeed_if_same_string (elektraEscapeKeyNamePart ("\\", dest), "\\\\");                       // 1 -> 2
     112           2 :         succeed_if_same_string (elektraEscapeKeyNamePart ("\\\\", dest), "\\\\\\\\");                 // 2 -> 4
     113           2 :         succeed_if_same_string (elektraEscapeKeyNamePart ("\\\\\\", dest), "\\\\\\\\\\\\");       // 3 -> 6
     114           2 : }
     115             : 
     116           2 : static void test_elektraUnescapeKeyName (void)
     117             : {
     118           2 :         printf ("test unescape key name \n");
     119             : 
     120             :         char dest[2000];
     121           2 :         char * p = NULL;
     122             : 
     123           2 :         succeed_if (elektraUnescapeKeyName ("abc", dest) == 4, "size of unescaping wrong");
     124           2 :         succeed_if_same_string ("abc", dest);
     125             : 
     126           2 :         succeed_if (elektraUnescapeKeyName ("\\\\.", dest) == 3, "size of unescaping wrong");
     127           2 :         succeed_if_same_string ("\\.", dest);
     128             : 
     129           2 :         succeed_if (elektraUnescapeKeyName ("abc/def", dest) == 8, "size of unescaping wrong");
     130           2 :         p = dest;
     131           2 :         succeed_if_same_string ("abc", p);
     132           2 :         p += 4;
     133           2 :         succeed_if_same_string ("def", p);
     134             : 
     135           2 :         succeed_if (elektraUnescapeKeyName ("abc\\/def", dest) == 8, "size of unescaping wrong");
     136           2 :         p = dest;
     137           2 :         succeed_if_same_string ("abc/def", p);
     138             : 
     139           2 :         succeed_if (elektraUnescapeKeyName ("abc/%/def", dest) == 9, "size of unescaping wrong");
     140           2 :         p = dest;
     141           2 :         succeed_if_same_string ("abc", p);
     142           2 :         p += 4;
     143           2 :         succeed_if_same_string ("", p);
     144           2 :         p += 1;
     145           2 :         succeed_if_same_string ("def", p);
     146             : 
     147           2 :         succeed_if (elektraUnescapeKeyName ("abc/\\%/def", dest) == 10, "size of unescaping wrong");
     148           2 :         p = dest;
     149           2 :         succeed_if_same_string ("abc", p);
     150           2 :         p += 4;
     151           2 :         succeed_if_same_string ("%", p);
     152           2 :         p += 2;
     153           2 :         succeed_if_same_string ("def", p);
     154             : 
     155           2 :         succeed_if (elektraUnescapeKeyName ("abc/\\./def", dest) == 10, "size of unescaping wrong");
     156           2 :         p = dest;
     157           2 :         succeed_if_same_string ("abc", p);
     158           2 :         p += 4;
     159           2 :         succeed_if_same_string (".", p);
     160           2 :         p += 2;
     161           2 :         succeed_if_same_string ("def", p);
     162             : 
     163           2 :         succeed_if (elektraUnescapeKeyName ("abc/\\../def", dest) == 11, "size of unescaping wrong");
     164           2 :         p = dest;
     165           2 :         succeed_if_same_string ("abc", p);
     166           2 :         p += 4;
     167           2 :         succeed_if_same_string ("..", p);
     168           2 :         p += 3;
     169           2 :         succeed_if_same_string ("def", p);
     170             : 
     171           2 :         succeed_if (elektraUnescapeKeyName ("abc/\\\\../def", dest) == 12, "size of unescaping wrong");
     172           2 :         p = dest;
     173           2 :         succeed_if_same_string ("abc", p);
     174           2 :         p += 4;
     175           2 :         succeed_if_same_string ("\\..", p);
     176           2 :         p += 4;
     177           2 :         succeed_if_same_string ("def", p);
     178             : 
     179           2 :         succeed_if (elektraUnescapeKeyName ("a\\c/\\../d\\f", dest) == 11, "size of unescaping wrong");
     180           2 :         p = dest;
     181           2 :         succeed_if_same_string ("a\\c", p);
     182           2 :         p += 4;
     183           2 :         succeed_if_same_string ("..", p);
     184           2 :         p += 3;
     185           2 :         succeed_if_same_string ("d\\f", p);
     186             : 
     187           2 :         succeed_if (elektraUnescapeKeyName ("\\bc/\\%/\\ef", dest) == 10, "size of unescaping wrong");
     188           2 :         p = dest;
     189           2 :         succeed_if_same_string ("\\bc", p);
     190           2 :         p += 4;
     191           2 :         succeed_if_same_string ("%", p);
     192           2 :         p += 2;
     193           2 :         succeed_if_same_string ("\\ef", p);
     194             : 
     195           2 :         succeed_if (elektraUnescapeKeyName ("\\b/\\%/\\e", dest) == 8, "size of unescaping wrong");
     196           2 :         p = dest;
     197           2 :         succeed_if_same_string ("\\b", p);
     198           2 :         p += 3;
     199           2 :         succeed_if_same_string ("%", p);
     200           2 :         p += 2;
     201           2 :         succeed_if_same_string ("\\e", p);
     202             : 
     203           2 :         succeed_if (elektraUnescapeKeyName ("\\b/\\\\%/\\e", dest) == 9, "size of unescaping wrong");
     204           2 :         p = dest;
     205           2 :         succeed_if_same_string ("\\b", p);
     206           2 :         p += 3;
     207           2 :         succeed_if_same_string ("\\%", p);
     208           2 :         p += 3;
     209           2 :         succeed_if_same_string ("\\e", p);
     210             : 
     211           2 :         succeed_if (elektraUnescapeKeyName ("a\\/\\/def", dest) == 7, "size of unescaping wrong");
     212           2 :         p = dest;
     213           2 :         succeed_if_same_string ("a//def", p);
     214             : 
     215           2 :         succeed_if (elektraUnescapeKeyName ("\\/\\/\\/def", dest) == 7, "size of unescaping wrong");
     216           2 :         p = dest;
     217           2 :         succeed_if_same_string ("///def", p);
     218             : 
     219           2 :         succeed_if (elektraUnescapeKeyName ("\\/\\/\\/def", dest) == 7, "size of unescaping wrong");
     220           2 :         p = dest;
     221           2 :         succeed_if_same_string ("///def", p);
     222             : 
     223           2 :         succeed_if (elektraUnescapeKeyName ("\\/\\/\\/\\/\\/\\/", dest) == 7, "size of unescaping wrong");
     224           2 :         p = dest;
     225           2 :         succeed_if_same_string ("//////", p);
     226             : 
     227           2 :         succeed_if (elektraUnescapeKeyName ("\\/\\/%\\/\\/\\/", dest) == 7, "size of unescaping wrong");
     228           2 :         p = dest;
     229           2 :         succeed_if_same_string ("//%///", p);
     230             : 
     231           2 :         succeed_if (elektraUnescapeKeyName ("\\/\\/..\\/\\/", dest) == 7, "size of unescaping wrong");
     232           2 :         p = dest;
     233           2 :         succeed_if_same_string ("//..//", p);
     234             : 
     235           2 :         succeed_if (elektraUnescapeKeyName ("bar\\/foo_bar\\/", dest) == sizeof ("bar/foo_bar/"), "size of unescaping wrong");
     236           2 :         p = dest;
     237           2 :         succeed_if_same_string ("bar/foo_bar/", p);
     238           2 : }
     239             : 
     240           2 : static void test_keyNameGetOneLevel (void)
     241             : {
     242           2 :         printf ("test keyNameGetOneLevel\n");
     243             : 
     244           2 :         size_t size = 0;
     245           2 :         char buffer[] = "a\\/\\/def";
     246           2 :         char * p = keyNameGetOneLevel (buffer, &size);
     247           2 :         succeed_if (p == buffer, "p not at start of buffer");
     248           2 :         succeed_if (size == sizeof (buffer) - 1, "size not set correctly");
     249           2 : }
     250             : 
     251           2 : int main (int argc, char ** argv)
     252             : {
     253           2 :         printf ("INTERNALS    TESTS\n");
     254           2 :         printf ("==================\n\n");
     255             : 
     256           2 :         init (argc, argv);
     257             : 
     258           2 :         test_elektraMalloc ();
     259           2 :         test_elektraStrLen ();
     260           2 :         test_elektraValidateKeyName ();
     261           2 :         test_elektraEscapeKeyNamePart ();
     262           2 :         test_elektraUnescapeKeyName ();
     263           2 :         test_keyNameGetOneLevel ();
     264             : 
     265           2 :         printf ("\ntest_internals RESULTS: %d test(s) done. %d error(s).\n", nbTest, nbError);
     266             : 
     267           2 :         return nbError;
     268             : }

Generated by: LCOV version 1.13