Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: LGPL-2.1+ */
       2                 :            : 
       3                 :            : #include <stdio.h>
       4                 :            : #include <string.h>
       5                 :            : 
       6                 :            : #include "string-util.h"
       7                 :            : #include "strxcpyx.h"
       8                 :            : #include "util.h"
       9                 :            : 
      10                 :          4 : static void test_strpcpy(void) {
      11                 :            :         char target[25];
      12                 :          4 :         char *s = target;
      13                 :            :         size_t space_left;
      14                 :            : 
      15                 :          4 :         space_left = sizeof(target);
      16                 :          4 :         space_left = strpcpy(&s, space_left, "12345");
      17                 :          4 :         space_left = strpcpy(&s, space_left, "hey hey hey");
      18                 :          4 :         space_left = strpcpy(&s, space_left, "waldo");
      19                 :          4 :         space_left = strpcpy(&s, space_left, "ba");
      20                 :          4 :         space_left = strpcpy(&s, space_left, "r");
      21                 :          4 :         space_left = strpcpy(&s, space_left, "foo");
      22                 :            : 
      23         [ -  + ]:          4 :         assert_se(streq(target, "12345hey hey heywaldobar"));
      24         [ -  + ]:          4 :         assert_se(space_left == 0);
      25                 :          4 : }
      26                 :            : 
      27                 :          4 : static void test_strpcpyf(void) {
      28                 :            :         char target[25];
      29                 :          4 :         char *s = target;
      30                 :            :         size_t space_left;
      31                 :            : 
      32                 :          4 :         space_left = sizeof(target);
      33                 :          4 :         space_left = strpcpyf(&s, space_left, "space left: %zu. ", space_left);
      34                 :          4 :         space_left = strpcpyf(&s, space_left, "foo%s", "bar");
      35                 :            : 
      36         [ -  + ]:          4 :         assert_se(streq(target, "space left: 25. foobar"));
      37         [ -  + ]:          4 :         assert_se(space_left == 3);
      38                 :            : 
      39                 :            :         /* test overflow */
      40                 :          4 :         s = target;
      41                 :          4 :         space_left = strpcpyf(&s, 12, "00 left: %i. ", 999);
      42         [ -  + ]:          4 :         assert_se(streq(target, "00 left: 99"));
      43         [ -  + ]:          4 :         assert_se(space_left == 0);
      44         [ -  + ]:          4 :         assert_se(target[12] == '2');
      45                 :          4 : }
      46                 :            : 
      47                 :          4 : static void test_strpcpyl(void) {
      48                 :            :         char target[25];
      49                 :          4 :         char *s = target;
      50                 :            :         size_t space_left;
      51                 :            : 
      52                 :          4 :         space_left = sizeof(target);
      53                 :          4 :         space_left = strpcpyl(&s, space_left, "waldo", " test", " waldo. ", NULL);
      54                 :          4 :         space_left = strpcpyl(&s, space_left, "Banana", NULL);
      55                 :            : 
      56         [ -  + ]:          4 :         assert_se(streq(target, "waldo test waldo. Banana"));
      57         [ -  + ]:          4 :         assert_se(space_left == 1);
      58                 :          4 : }
      59                 :            : 
      60                 :          4 : static void test_strscpy(void) {
      61                 :            :         char target[25];
      62                 :            :         size_t space_left;
      63                 :            : 
      64                 :          4 :         space_left = sizeof(target);
      65                 :          4 :         space_left = strscpy(target, space_left, "12345");
      66                 :            : 
      67         [ -  + ]:          4 :         assert_se(streq(target, "12345"));
      68         [ -  + ]:          4 :         assert_se(space_left == 20);
      69                 :          4 : }
      70                 :            : 
      71                 :          4 : static void test_strscpyl(void) {
      72                 :            :         char target[25];
      73                 :            :         size_t space_left;
      74                 :            : 
      75                 :          4 :         space_left = sizeof(target);
      76                 :          4 :         space_left = strscpyl(target, space_left, "12345", "waldo", "waldo", NULL);
      77                 :            : 
      78         [ -  + ]:          4 :         assert_se(streq(target, "12345waldowaldo"));
      79         [ -  + ]:          4 :         assert_se(space_left == 10);
      80                 :          4 : }
      81                 :            : 
      82                 :          4 : static void test_sd_event_code_migration(void) {
      83                 :            :         char b[100 * DECIMAL_STR_MAX(unsigned) + 1];
      84                 :            :         char c[100 * DECIMAL_STR_MAX(unsigned) + 1], *p;
      85                 :            :         unsigned i;
      86                 :            :         size_t l;
      87                 :            :         int o;
      88                 :            : 
      89         [ +  + ]:        404 :         for (i = o = 0; i < 100; i++)
      90                 :        400 :                 o += snprintf(&b[o], sizeof(b) - o, "%u ", i);
      91                 :            : 
      92                 :          4 :         p = c;
      93                 :          4 :         l = sizeof(c);
      94         [ +  + ]:        404 :         for (i = 0; i < 100; i++)
      95                 :        400 :                 l = strpcpyf(&p, l, "%u ", i);
      96                 :            : 
      97         [ -  + ]:          4 :         assert_se(streq(b, c));
      98                 :          4 : }
      99                 :            : 
     100                 :          4 : int main(int argc, char *argv[]) {
     101                 :          4 :         test_strpcpy();
     102                 :          4 :         test_strpcpyf();
     103                 :          4 :         test_strpcpyl();
     104                 :          4 :         test_strscpy();
     105                 :          4 :         test_strscpyl();
     106                 :            : 
     107                 :          4 :         test_sd_event_code_migration();
     108                 :            : 
     109                 :          4 :         return 0;
     110                 :            : }