tests/unit_tests/openvpn/test_argv.c

   1 #include "config.h"
   2 #include "syshead.h"
   3
   4 #include <stdio.h>
   5 #include <unistd.h>
   6 #include <stdlib.h>
   7 #include <stdarg.h>
   8 #include <string.h>
   9 #include <setjmp.h>
  10 #include <cmocka.h>
  11 #include <assert.h>
  12
  13 #include "argv.h"
  14 #include "buffer.h"
  15
  16 /*
  17  * This is defined here to prevent #include'ing misc.h
  18  * which makes things difficult beyond any recognition
  19  */
  20 size_t
  21 adjust_power_of_2(size_t u)
  22 {
  23     size_t ret = 1;
  24
  25     while (ret < u)
  26     {
  27         ret <<= 1;
  28         assert(ret > 0);
  29     }
  30
  31     return ret;
  32 }
  33
  34 /* Defines for use in the tests and the mock parse_line() */
  35 #define PATH1       "/s p a c e"
  36 #define PATH2       "/foo bar/baz"
  37 #define PARAM1      "param1"
  38 #define PARAM2      "param two"
  39 #define SCRIPT_CMD  "\"" PATH1 PATH2 "\"" PARAM1 "\"" PARAM2 "\""
  40
  41 int
  42 __wrap_parse_line(const char *line, char **p, const int n, const char *file,
  43                   const int line_num, int msglevel, struct gc_arena *gc)
  44 {
  45     p[0] = PATH1 PATH2;
  46     p[1] = PARAM1;
  47     p[2] = PARAM2;
  48     return 3;
  49 }
  50
  51 static void
  52 argv_printf__multiple_spaces_in_format__parsed_as_one(void **state)
  53 {
  54     struct argv a = argv_new();
  55
  56     argv_printf(&a, "    %s     %s  %d   ", PATH1, PATH2, 42);
  57     assert_int_equal(a.argc, 3);
  58
  59     argv_reset(&a);
  60 }
  61
  62 static void
  63 argv_printf_cat__multiple_spaces_in_format__parsed_as_one(void **state)
  64 {
  65     struct argv a = argv_new();
  66
  67     argv_printf(&a, "%s ", PATH1);
  68     argv_printf_cat(&a, " %s  %s", PATH2, PARAM1);
  69     assert_int_equal(a.argc, 3);
  70
  71     argv_reset(&a);
  72 }
  73
  74 static void
  75 argv_printf__combined_path_with_spaces__argc_correct(void **state)
  76 {
  77     struct argv a = argv_new();
  78
  79     argv_printf(&a, "%s%sc", PATH1, PATH2);
  80     assert_int_equal(a.argc, 1);
  81
  82     argv_printf(&a, "%s%sc %d", PATH1, PATH2, 42);
  83     assert_int_equal(a.argc, 2);
  84
  85     argv_printf(&a, "foo %s%sc %s x y", PATH2, PATH1, "foo");
  86     assert_int_equal(a.argc, 5);
  87
  88     argv_reset(&a);
  89 }
  90
  91 static void
  92 argv_parse_cmd__command_string__argc_correct(void **state)
  93 {
  94     struct argv a = argv_new();
  95
  96     argv_parse_cmd(&a, SCRIPT_CMD);
  97     assert_int_equal(a.argc, 3);
  98
  99     argv_reset(&a);
 100 }
 101
 102 static void
 103 argv_parse_cmd__command_and_extra_options__argc_correct(void **state)
 104 {
 105     struct argv a = argv_new();
 106
 107     argv_parse_cmd(&a, SCRIPT_CMD);
 108     argv_printf_cat(&a, "bar baz %d %s", 42, PATH1);
 109     assert_int_equal(a.argc, 7);
 110
 111     argv_reset(&a);
 112 }
 113
 114 static void
 115 argv_printf_cat__used_twice__argc_correct(void **state)
 116 {
 117     struct argv a = argv_new();
 118
 119     argv_printf(&a, "%s %s %s", PATH1, PATH2, PARAM1);
 120     argv_printf_cat(&a, "%s", PARAM2);
 121     argv_printf_cat(&a, "foo");
 122     assert_int_equal(a.argc, 5);
 123
 124     argv_reset(&a);
 125 }
 126
 127 static void
 128 argv_str__multiple_argv__correct_output(void **state)
 129 {
 130     struct argv a = argv_new();
 131     struct gc_arena gc = gc_new();
 132     const char *output;
 133
 134     argv_printf(&a, "%s%sc", PATH1, PATH2);
 135     argv_printf_cat(&a, "%s", PARAM1);
 136     argv_printf_cat(&a, "%s", PARAM2);
 137     output = argv_str(&a, &gc, PA_BRACKET);
 138     assert_string_equal(output, "[" PATH1 PATH2 "] [" PARAM1 "] [" PARAM2 "]");
 139
 140     argv_reset(&a);
 141     gc_free(&gc);
 142 }
 143
 144 static void
 145 argv_insert_head__empty_argv__head_only(void **state)
 146 {
 147     struct argv a = argv_new();
 148     struct argv b;
 149
 150     b = argv_insert_head(&a, PATH1);
 151     assert_int_equal(b.argc, 1);
 152     assert_string_equal(b.argv[0], PATH1);
 153     argv_reset(&b);
 154
 155     argv_reset(&a);
 156 }
 157
 158 static void
 159 argv_insert_head__non_empty_argv__head_added(void **state)
 160 {
 161     struct argv a = argv_new();
 162     struct argv b;
 163     int i;
 164
 165     argv_printf(&a, "%s", PATH2);
 166     b = argv_insert_head(&a, PATH1);
 167     assert_int_equal(b.argc, a.argc + 1);
 168     for (i = 0; i < b.argc; i++) {
 169         if (i == 0)
 170         {
 171             assert_string_equal(b.argv[i], PATH1);
 172         }
 173         else
 174         {
 175             assert_string_equal(b.argv[i], a.argv[i - 1]);
 176         }
 177     }
 178     argv_reset(&b);
 179
 180     argv_reset(&a);
 181 }
 182
 183 int
 184 main(void)
 185 {
 186     const struct CMUnitTest tests[] = {
 187         cmocka_unit_test(argv_printf__multiple_spaces_in_format__parsed_as_one),
 188         cmocka_unit_test(argv_printf_cat__multiple_spaces_in_format__parsed_as_one),
 189         cmocka_unit_test(argv_printf__combined_path_with_spaces__argc_correct),
 190         cmocka_unit_test(argv_parse_cmd__command_string__argc_correct),
 191         cmocka_unit_test(argv_parse_cmd__command_and_extra_options__argc_correct),
 192         cmocka_unit_test(argv_printf_cat__used_twice__argc_correct),
 193         cmocka_unit_test(argv_str__multiple_argv__correct_output),
 194         cmocka_unit_test(argv_insert_head__non_empty_argv__head_added),
 195     };
 196
 197     return cmocka_run_group_tests_name("argv", tests, NULL, NULL);
 198 }