src/test/test-udev-util.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <stdlib.h>
   4 #include <string.h>
   5
   6 #include "macro.h"
   7 #include "string-util.h"
   8 #include "udev-util.h"
   9
  10 static void test_udev_rule_parse_value_one(const char *in, const char *expected_value, int expected_retval) {
  11         _cleanup_free_ char *str = NULL;
  12         char *value = UINT_TO_PTR(0x12345678U);
  13         char *endpos = UINT_TO_PTR(0x87654321U);
  14
  15         assert_se(str = strdup(in));
  16         assert_se(udev_rule_parse_value(str, &value, &endpos) == expected_retval);
  17         if (expected_retval < 0) {
  18                 /* not modified on failure */
  19                 assert_se(value == UINT_TO_PTR(0x12345678U));
  20                 assert_se(endpos == UINT_TO_PTR(0x87654321U));
  21         } else {
  22                 assert_se(streq_ptr(value, expected_value));
  23                 assert_se(endpos == str + strlen(in));
  24         }
  25 }
  26
  27 static void test_parse_value(void) {
  28         /* input: "valid operand"
  29          * parsed: valid operand
  30          * use the following command to help generate textual C strings:
  31          * python3 -c 'import json; print(json.dumps(input()))' */
  32         test_udev_rule_parse_value_one(
  33                 "\"valid operand\"",
  34                 "valid operand",
  35                 0
  36         );
  37 }
  38
  39 static void test_parse_value_with_backslashes(void) {
  40         /* input: "va'l\'id\"op\"erand"
  41          * parsed: va'l\'id"op"erand */
  42         test_udev_rule_parse_value_one(
  43                 "\"va'l\\'id\\\"op\\\"erand\"",
  44                 "va'l\\'id\"op\"erand",
  45                 0
  46         );
  47 }
  48
  49 static void test_parse_value_no_quotes(void) {
  50         test_udev_rule_parse_value_one(
  51                 "no quotes",
  52                 0,
  53                 -EINVAL
  54         );
  55 }
  56
  57 static void test_parse_value_noescape(void) {
  58         test_udev_rule_parse_value_one(
  59                 "\"\\\\a\\b\\x\\y\"",
  60                 "\\\\a\\b\\x\\y",
  61                 0
  62         );
  63 }
  64
  65 static void test_parse_value_nul(void) {
  66         test_udev_rule_parse_value_one(
  67                 "\"reject\0nul\"",
  68                 0,
  69                 -EINVAL
  70         );
  71 }
  72
  73 static void test_parse_value_escape_nothing(void) {
  74         /* input: e"" */
  75         test_udev_rule_parse_value_one(
  76                 "e\"\"",
  77                 "",
  78                 0
  79         );
  80 }
  81
  82 static void test_parse_value_escape_nothing2(void) {
  83         /* input: e"1234" */
  84         test_udev_rule_parse_value_one(
  85                 "e\"1234\"",
  86                 "1234",
  87                 0
  88         );
  89 }
  90
  91 static void test_parse_value_escape_double_quote(void) {
  92         /* input: e"\"" */
  93         test_udev_rule_parse_value_one(
  94                 "e\"\\\"\"",
  95                 "\"",
  96                 0
  97         );
  98 }
  99
 100 static void test_parse_value_escape_backslash(void) {
 101         /* input: e"\ */
 102         test_udev_rule_parse_value_one(
 103                 "e\"\\",
 104                 0,
 105                 -EINVAL
 106         );
 107         /* input: e"\" */
 108         test_udev_rule_parse_value_one(
 109                 "e\"\\\"",
 110                 0,
 111                 -EINVAL
 112         );
 113         /* input: e"\\" */
 114         test_udev_rule_parse_value_one(
 115                 "e\"\\\\\"",
 116                 "\\",
 117                 0
 118         );
 119         /* input: e"\\\" */
 120         test_udev_rule_parse_value_one(
 121                 "e\"\\\\\\\"",
 122                 0,
 123                 -EINVAL
 124         );
 125         /* input: e"\\\"" */
 126         test_udev_rule_parse_value_one(
 127                 "e\"\\\\\\\"\"",
 128                 "\\\"",
 129                 0
 130         );
 131         /* input: e"\\\\" */
 132         test_udev_rule_parse_value_one(
 133                 "e\"\\\\\\\\\"",
 134                 "\\\\",
 135                 0
 136         );
 137 }
 138
 139 static void test_parse_value_newline(void) {
 140         /* input: e"operand with newline\n" */
 141         test_udev_rule_parse_value_one(
 142                 "e\"operand with newline\\n\"",
 143                 "operand with newline\n",
 144                 0
 145         );
 146 }
 147
 148 static void test_parse_value_escaped(void) {
 149         /* input: e"single\rcharacter\t\aescape\bsequence" */
 150         test_udev_rule_parse_value_one(
 151                 "e\"single\\rcharacter\\t\\aescape\\bsequence\"",
 152                 "single\rcharacter\t\aescape\bsequence",
 153                 0
 154         );
 155 }
 156
 157 static void test_parse_value_invalid_escape(void) {
 158         /* input: e"reject\invalid escape sequence" */
 159         test_udev_rule_parse_value_one(
 160                 "e\"reject\\invalid escape sequence",
 161                 0,
 162                 -EINVAL
 163         );
 164 }
 165
 166 static void test_parse_value_invalid_termination(void) {
 167         /* input: e"\ */
 168         test_udev_rule_parse_value_one(
 169                 "e\"\\",
 170                 0,
 171                 -EINVAL
 172         );
 173 }
 174
 175 static void test_parse_value_unicode(void) {
 176         /* input: "s\u1d1c\u1d04\u029c \u1d1c\u0274\u026a\u1d04\u1d0f\u1d05\u1d07 \U0001d568\U0001d560\U0001d568" */
 177         test_udev_rule_parse_value_one(
 178                 "e\"s\\u1d1c\\u1d04\\u029c \\u1d1c\\u0274\\u026a\\u1d04\\u1d0f\\u1d05\\u1d07 \\U0001d568\\U0001d560\\U0001d568\"",
 179                 "s\xe1\xb4\x9c\xe1\xb4\x84\xca\x9c \xe1\xb4\x9c\xc9\xb4\xc9\xaa\xe1\xb4\x84\xe1\xb4\x8f\xe1\xb4\x85\xe1\xb4\x87 \xf0\x9d\x95\xa8\xf0\x9d\x95\xa0\xf0\x9d\x95\xa8",
 180                 0
 181         );
 182 }
 183
 184 int main(int argc, char **argv) {
 185         test_parse_value();
 186         test_parse_value_with_backslashes();
 187         test_parse_value_no_quotes();
 188         test_parse_value_nul();
 189         test_parse_value_noescape();
 190
 191         test_parse_value_escape_nothing();
 192         test_parse_value_escape_nothing2();
 193         test_parse_value_escape_double_quote();
 194         test_parse_value_escape_backslash();
 195         test_parse_value_newline();
 196         test_parse_value_escaped();
 197         test_parse_value_invalid_escape();
 198         test_parse_value_invalid_termination();
 199         test_parse_value_unicode();
 200
 201         return EXIT_SUCCESS;
 202 }