add tests for string and qstring

diff --git a/lib/isc/tests/lex_test.c b/lib/isc/tests/lex_test.c
index a4b27606e5d339ea340029744ecd3352ecda01ab..f712d7e276d2b249d41821fadbdc21818b9b40ef 100644 (file)
--- a/lib/isc/tests/lex_test.c
+++ b/lib/isc/tests/lex_test.c
@@ -29,6 +29,8 @@
 
 #include "isctest.h"
 
+#define AS_STR(x) (x).value.as_textregion.base
+
 static bool debug = false;
 
 static int
@@ -121,6 +123,217 @@ lex_setline(void **state) {
        isc_lex_destroy(&lex);
 }
 
+static struct {
+       const char *text;
+       const char *string_value;
+       isc_result_t string_result;
+       isc_tokentype_t string_type;
+       const char *qstring_value;
+       isc_result_t qstring_result;
+       isc_tokentype_t qstring_type;
+       const char *qvpair_value;
+       isc_result_t qvpair_result;
+       isc_tokentype_t qvpair_type;
+} parse_tests[] = {
+       { "", "", ISC_R_SUCCESS, isc_tokentype_eof, "", ISC_R_SUCCESS,
+         isc_tokentype_eof, "", ISC_R_SUCCESS, isc_tokentype_eof },
+       { "1234", "1234", ISC_R_SUCCESS, isc_tokentype_string, "1234",
+         ISC_R_SUCCESS, isc_tokentype_string, "1234", ISC_R_SUCCESS,
+         isc_tokentype_string },
+       { "1234=", "1234=", ISC_R_SUCCESS, isc_tokentype_string,
+         "1234=", ISC_R_SUCCESS, isc_tokentype_string, "1234=", ISC_R_SUCCESS,
+         isc_tokentype_vpair },
+       { "1234=foo", "1234=foo", ISC_R_SUCCESS, isc_tokentype_string,
+         "1234=foo", ISC_R_SUCCESS, isc_tokentype_string, "1234=foo",
+         ISC_R_SUCCESS, isc_tokentype_vpair },
+       { "1234=\"foo", "1234=\"foo", ISC_R_SUCCESS, isc_tokentype_string,
+         "1234=\"foo", ISC_R_SUCCESS, isc_tokentype_string, NULL,
+         ISC_R_UNEXPECTEDEND, 0 },
+       { "1234=\"foo\"", "1234=\"foo\"", ISC_R_SUCCESS, isc_tokentype_string,
+         "1234=\"foo\"", ISC_R_SUCCESS, isc_tokentype_string, "1234=foo",
+         ISC_R_SUCCESS, isc_tokentype_qvpair },
+       { "key", "key", ISC_R_SUCCESS, isc_tokentype_string, "key",
+         ISC_R_SUCCESS, isc_tokentype_string, "key", ISC_R_SUCCESS,
+         isc_tokentype_string },
+       { "\"key=", "\"key=", ISC_R_SUCCESS, isc_tokentype_string, NULL,
+         ISC_R_UNEXPECTEDEND, 0, "\"key=", ISC_R_SUCCESS,
+         isc_tokentype_vpair },
+       { "\"key=\"", "\"key=\"", ISC_R_SUCCESS, isc_tokentype_string, "key=",
+         ISC_R_SUCCESS, isc_tokentype_qstring, NULL, ISC_R_UNEXPECTEDEND, 0 },
+       { "key=\"\"", "key=\"\"", ISC_R_SUCCESS, isc_tokentype_string,
+         "key=\"\"", ISC_R_SUCCESS, isc_tokentype_string,
+         "key=", ISC_R_SUCCESS, isc_tokentype_qvpair },
+       { "key=\"a b\"", "key=\"a", ISC_R_SUCCESS, isc_tokentype_string,
+         "key=\"a", ISC_R_SUCCESS, isc_tokentype_string, "key=a b",
+         ISC_R_SUCCESS, isc_tokentype_qvpair },
+       { "key=\"a\tb\"", "key=\"a", ISC_R_SUCCESS, isc_tokentype_string,
+         "key=\"a", ISC_R_SUCCESS, isc_tokentype_string, "key=a\tb",
+         ISC_R_SUCCESS, isc_tokentype_qvpair },
+       /* double quote not immediately after '=' is not special. */
+       { "key=c\"a b\"", "key=c\"a", ISC_R_SUCCESS, isc_tokentype_string,
+         "key=c\"a", ISC_R_SUCCESS, isc_tokentype_string, "key=c\"a",
+         ISC_R_SUCCESS, isc_tokentype_vpair },
+       /* remove special meaning for '=' by escaping */
+       { "key\\=", "key\\=", ISC_R_SUCCESS, isc_tokentype_string,
+         "key\\=", ISC_R_SUCCESS, isc_tokentype_string,
+         "key\\=", ISC_R_SUCCESS, isc_tokentype_string },
+       { "key\\=\"a\"", "key\\=\"a\"", ISC_R_SUCCESS, isc_tokentype_string,
+         "key\\=\"a\"", ISC_R_SUCCESS, isc_tokentype_string, "key\\=\"a\"",
+         ISC_R_SUCCESS, isc_tokentype_string },
+       { "key\\=\"a \"", "key\\=\"a", ISC_R_SUCCESS, isc_tokentype_string,
+         "key\\=\"a", ISC_R_SUCCESS, isc_tokentype_string, "key\\=\"a",
+         ISC_R_SUCCESS, isc_tokentype_string },
+       /* vpair with a key of 'key\=' (would need to be deescaped) */
+       { "key\\==", "key\\==", ISC_R_SUCCESS, isc_tokentype_string,
+         "key\\==", ISC_R_SUCCESS, isc_tokentype_string,
+         "key\\==", ISC_R_SUCCESS, isc_tokentype_vpair },
+       { "key\\==\"\"", "key\\==\"\"", ISC_R_SUCCESS, isc_tokentype_string,
+         "key\\==\"\"", ISC_R_SUCCESS, isc_tokentype_string,
+         "key\\==", ISC_R_SUCCESS, isc_tokentype_qvpair },
+       { "key=\\\\\\\\", "key=\\\\\\\\", ISC_R_SUCCESS, isc_tokentype_string,
+         "key=\\\\\\\\", ISC_R_SUCCESS, isc_tokentype_string, "key=\\\\\\\\",
+         ISC_R_SUCCESS, isc_tokentype_vpair },
+       { "key=\\\\\\\"", "key=\\\\\\\"", ISC_R_SUCCESS, isc_tokentype_string,
+         "key=\\\\\\\"", ISC_R_SUCCESS, isc_tokentype_string, "key=\\\\\\\"",
+         ISC_R_SUCCESS, isc_tokentype_vpair },
+       /* incomplete escape sequence */
+       { "key=\\\"\\", NULL, ISC_R_UNEXPECTEDEND, isc_tokentype_string, NULL,
+         ISC_R_UNEXPECTEDEND, 0, NULL, ISC_R_UNEXPECTEDEND, 0 },
+       /* incomplete escape sequence */
+       { "key=\\", NULL, ISC_R_UNEXPECTEDEND, isc_tokentype_string, NULL,
+         ISC_R_UNEXPECTEDEND, 0, NULL, ISC_R_UNEXPECTEDEND, 0 },
+};
+
+/*%
+ * string
+ */
+static void
+lex_string(void **state) {
+       isc_buffer_t buf;
+       isc_lex_t *lex = NULL;
+       isc_result_t result;
+       isc_token_t token;
+       size_t i;
+
+       UNUSED(state);
+
+       for (i = 0; i < ARRAY_SIZE(parse_tests); i++) {
+               result = isc_lex_create(test_mctx, 1024, &lex);
+               assert_int_equal(result, ISC_R_SUCCESS);
+
+               isc_buffer_constinit(&buf, parse_tests[i].text,
+                                    strlen(parse_tests[i].text));
+               isc_buffer_add(&buf, strlen(parse_tests[i].text));
+
+               result = isc_lex_openbuffer(lex, &buf);
+               assert_int_equal(result, ISC_R_SUCCESS);
+
+               result = isc_lex_setsourceline(lex, 100);
+               assert_int_equal(result, ISC_R_SUCCESS);
+
+               memset(&token, 0, sizeof(token));
+               result = isc_lex_getmastertoken(lex, &token,
+                                               isc_tokentype_string, true);
+               if (debug) {
+                       fprintf(stdout, "# '%s' -> result=%s/%s, type=%u/%u\n",
+                               parse_tests[i].text, isc_result_toid(result),
+                               isc_result_toid(parse_tests[i].string_result),
+                               token.type, parse_tests[i].string_type);
+               }
+
+               assert_int_equal(result, parse_tests[i].string_result);
+               if (result == ISC_R_SUCCESS) {
+                       switch (token.type) {
+                       case isc_tokentype_string:
+                       case isc_tokentype_qstring:
+                       case isc_tokentype_vpair:
+                       case isc_tokentype_qvpair:
+                               if (debug) {
+                                       fprintf(stdout, "# value='%s'\n",
+                                               AS_STR(token));
+                               }
+                               assert_int_equal(token.type,
+                                                parse_tests[i].string_type);
+                               assert_string_equal(
+                                       AS_STR(token),
+                                       parse_tests[i].string_value);
+                               break;
+                       default:
+                               assert_int_equal(token.type,
+                                                parse_tests[i].string_type);
+                               break;
+                       }
+               }
+
+               isc_lex_destroy(&lex);
+       }
+}
+
+/*%
+ * qstring
+ */
+static void
+lex_qstring(void **state) {
+       isc_buffer_t buf;
+       isc_lex_t *lex = NULL;
+       isc_result_t result;
+       isc_token_t token;
+       size_t i;
+
+       UNUSED(state);
+
+       for (i = 0; i < ARRAY_SIZE(parse_tests); i++) {
+               result = isc_lex_create(test_mctx, 1024, &lex);
+               assert_int_equal(result, ISC_R_SUCCESS);
+
+               isc_buffer_constinit(&buf, parse_tests[i].text,
+                                    strlen(parse_tests[i].text));
+               isc_buffer_add(&buf, strlen(parse_tests[i].text));
+
+               result = isc_lex_openbuffer(lex, &buf);
+               assert_int_equal(result, ISC_R_SUCCESS);
+
+               result = isc_lex_setsourceline(lex, 100);
+               assert_int_equal(result, ISC_R_SUCCESS);
+
+               memset(&token, 0, sizeof(token));
+               result = isc_lex_getmastertoken(lex, &token,
+                                               isc_tokentype_qstring, true);
+               if (debug) {
+                       fprintf(stdout, "# '%s' -> result=%s/%s, type=%u/%u\n",
+                               parse_tests[i].text, isc_result_toid(result),
+                               isc_result_toid(parse_tests[i].qstring_result),
+                               token.type, parse_tests[i].qstring_type);
+               }
+
+               assert_int_equal(result, parse_tests[i].qstring_result);
+               if (result == ISC_R_SUCCESS) {
+                       switch (token.type) {
+                       case isc_tokentype_string:
+                       case isc_tokentype_qstring:
+                       case isc_tokentype_vpair:
+                       case isc_tokentype_qvpair:
+                               if (debug) {
+                                       fprintf(stdout, "# value='%s'\n",
+                                               AS_STR(token));
+                               }
+                               assert_int_equal(token.type,
+                                                parse_tests[i].qstring_type);
+                               assert_string_equal(
+                                       AS_STR(token),
+                                       parse_tests[i].qstring_value);
+                               break;
+                       default:
+                               assert_int_equal(token.type,
+                                                parse_tests[i].qstring_type);
+                               break;
+                       }
+               }
+
+               isc_lex_destroy(&lex);
+       }
+}
+
 /*%
  * keypair is <string>=<qstring>.  This has implications double quotes
  * in key names.
@@ -133,52 +346,15 @@ lex_keypair(void **state) {
        isc_token_t token;
        size_t i;
 
-       struct {
-               const char *text;
-               const char *value;
-               isc_result_t result;
-               isc_tokentype_t type;
-       } tests[] = {
-               { "", "", ISC_R_SUCCESS, isc_tokentype_eof },
-               { "1234", "1234", ISC_R_SUCCESS, isc_tokentype_string },
-               { "1234=", "1234=", ISC_R_SUCCESS, isc_tokentype_vpair },
-               { "1234=foo", "1234=foo", ISC_R_SUCCESS, isc_tokentype_vpair },
-               { "1234=\"foo", NULL, ISC_R_UNEXPECTEDEND, 0 },
-               { "1234=\"foo\"", "1234=foo", ISC_R_SUCCESS,
-                 isc_tokentype_qvpair },
-               { "key", "key", ISC_R_SUCCESS, isc_tokentype_string },
-               { "\"key=", "\"key=", ISC_R_SUCCESS, isc_tokentype_vpair },
-               { "\"key=\"", NULL, ISC_R_UNEXPECTEDEND, 0 },
-               { "key=\"\"", "key=", ISC_R_SUCCESS, isc_tokentype_qvpair },
-               { "key=\"a b\"", "key=a b", ISC_R_SUCCESS,
-                 isc_tokentype_qvpair },
-               { "key=\"a\tb\"", "key=a\tb", ISC_R_SUCCESS,
-                 isc_tokentype_qvpair },
-               /* double quote not immediately after '=' is not special. */
-               { "key=c\"a b\"", "key=c\"a", ISC_R_SUCCESS,
-                 isc_tokentype_vpair },
-               /* remove special meaning for '=' by escaping */
-               { "key\\=", "key\\=", ISC_R_SUCCESS, isc_tokentype_string },
-               { "key\\=\"a\"", "key\\=\"a\"", ISC_R_SUCCESS,
-                 isc_tokentype_string },
-               { "key\\=\"a \"", "key\\=\"a", ISC_R_SUCCESS,
-                 isc_tokentype_string },
-               /* vpair with a key of 'key\=' (would need to be deescaped) */
-               { "key\\==", "key\\==", ISC_R_SUCCESS, isc_tokentype_vpair },
-               /* qvpair with a key of 'key\=' (would need to be deescaped) */
-               { "key\\==\"\"", "key\\==", ISC_R_SUCCESS,
-                 isc_tokentype_qvpair },
-       };
-
        UNUSED(state);
 
-       for (i = 0; i < ARRAY_SIZE(tests); i++) {
+       for (i = 0; i < ARRAY_SIZE(parse_tests); i++) {
                result = isc_lex_create(test_mctx, 1024, &lex);
                assert_int_equal(result, ISC_R_SUCCESS);
 
-               isc_buffer_constinit(&buf, tests[i].text,
-                                    strlen(tests[i].text));
-               isc_buffer_add(&buf, strlen(tests[i].text));
+               isc_buffer_constinit(&buf, parse_tests[i].text,
+                                    strlen(parse_tests[i].text));
+               isc_buffer_add(&buf, strlen(parse_tests[i].text));
 
                result = isc_lex_openbuffer(lex, &buf);
                assert_int_equal(result, ISC_R_SUCCESS);
@@ -191,12 +367,12 @@ lex_keypair(void **state) {
                                                isc_tokentype_qvpair, true);
                if (debug) {
                        fprintf(stdout, "# '%s' -> result=%s/%s, type=%u/%u\n",
-                               tests[i].text, isc_result_toid(result),
-                               isc_result_toid(tests[i].result), token.type,
-                               tests[i].type);
+                               parse_tests[i].text, isc_result_toid(result),
+                               isc_result_toid(parse_tests[i].qvpair_result),
+                               token.type, parse_tests[i].qvpair_type);
                }
 
-               assert_int_equal(result, tests[i].result);
+               assert_int_equal(result, parse_tests[i].qvpair_result);
                if (result == ISC_R_SUCCESS) {
                        switch (token.type) {
                        case isc_tokentype_string:
@@ -204,16 +380,18 @@ lex_keypair(void **state) {
                        case isc_tokentype_vpair:
                        case isc_tokentype_qvpair:
                                if (debug) {
-#define AS_STR(x) (x).value.as_textregion.base
                                        fprintf(stdout, "# value='%s'\n",
                                                AS_STR(token));
                                }
-                               assert_int_equal(token.type, tests[i].type);
-                               assert_string_equal(AS_STR(token),
-                                                   tests[i].value);
+                               assert_int_equal(token.type,
+                                                parse_tests[i].qvpair_type);
+                               assert_string_equal(
+                                       AS_STR(token),
+                                       parse_tests[i].qvpair_value);
                                break;
                        default:
-                               assert_int_equal(token.type, tests[i].type);
+                               assert_int_equal(token.type,
+                                                parse_tests[i].qvpair_type);
                                break;
                        }
                }
@@ -225,9 +403,9 @@ lex_keypair(void **state) {
 int
 main(int argc, char *argv[]) {
        const struct CMUnitTest tests[] = {
-               cmocka_unit_test(lex_0xff),
-               cmocka_unit_test(lex_keypair),
-               cmocka_unit_test(lex_setline),
+               cmocka_unit_test(lex_0xff),    cmocka_unit_test(lex_keypair),
+               cmocka_unit_test(lex_setline), cmocka_unit_test(lex_string),
+               cmocka_unit_test(lex_qstring),
        };
 
        UNUSED(argv);