lib-smtp: Reformat test-smtp-command-parser.c.

diff --git a/src/lib-smtp/test-smtp-command-parser.c b/src/lib-smtp/test-smtp-command-parser.c
index ab3a1a0c8f86ec00c5da211bf4f022f0bddce3f6..0f897822c1e01b306647e21100d570410c97c423 100644 (file)
--- a/src/lib-smtp/test-smtp-command-parser.c
+++ b/src/lib-smtp/test-smtp-command-parser.c
@@ -30,37 +30,44 @@ valid_command_parse_tests[] = {
        {
                .command = "RSET\r\n",
                .cmd_name = "RSET",
-               .cmd_params = ""
-       }, {
+               .cmd_params = "",
+       },
+       {
                .command = "RSET    \r\n",
                .cmd_name = "RSET",
-               .cmd_params = ""
-       }, {
+               .cmd_params = "",
+       },
+       {
                .command = "EHLO example.com\r\n",
                .cmd_name = "EHLO",
-               .cmd_params = "example.com"
-       }, {
+               .cmd_params = "example.com",
+       },
+       {
                .command = "EHLO example.com     \r\n",
                .cmd_name = "EHLO",
-               .cmd_params = "example.com"
-       }, {
+               .cmd_params = "example.com",
+       },
+       {
                .command = "MAIL FROM:<sender@example.com> ENVID=frop\r\n",
                .cmd_name = "MAIL",
-               .cmd_params = "FROM:<sender@example.com> ENVID=frop"
-       }, {
+               .cmd_params = "FROM:<sender@example.com> ENVID=frop",
+       },
+       {
                .command = "VRFY \"Sherlock Holmes\"\r\n",
                .cmd_name = "VRFY",
-               .cmd_params = "\"Sherlock Holmes\""
-       }, {
+               .cmd_params = "\"Sherlock Holmes\"",
+       },
+       {
                .command = "RCPT TO:<recipient@example.com> NOTIFY=NEVER\r\n",
                .limits = { .max_parameters_size = 39 },
                .cmd_name = "RCPT",
-               .cmd_params = "TO:<recipient@example.com> NOTIFY=NEVER"
-       }, {
+               .cmd_params = "TO:<recipient@example.com> NOTIFY=NEVER",
+       },
+       {
                .command = "MAIL FROM:<f\xc3\xb6\xc3\xa4@\xc3\xb6\xc3\xa4>\r\n",
                .cmd_name = "MAIL",
-               .cmd_params = "FROM:<f\xc3\xb6\xc3\xa4@\xc3\xb6\xc3\xa4>"
-       }
+               .cmd_params = "FROM:<f\xc3\xb6\xc3\xa4@\xc3\xb6\xc3\xa4>",
+       },
 };
 
 unsigned int valid_command_parse_test_count =
@@ -86,19 +93,22 @@ static void test_smtp_command_parse_valid(void)
 
                test_begin(t_strdup_printf("smtp command valid [%d]", i));
 
-               while ((ret=smtp_command_parse_next(parser,
-                       &cmd_name, &cmd_params, &error_code, &error)) > 0);
+               while ((ret = smtp_command_parse_next(
+                       parser, &cmd_name, &cmd_params,
+                       &error_code, &error)) > 0);
 
                test_out_reason("parse success", ret == -2, error);
 
                if (ret == 0) {
-                       /* verify last response only */
+                       /* Verify last command only */
                        test_out(t_strdup_printf("command name = `%s'",
-                               test->cmd_name),
-                               null_strcmp(cmd_name, test->cmd_name) == 0);
+                                                test->cmd_name),
+                                null_strcmp(cmd_name, test->cmd_name) == 0);
                        test_out(t_strdup_printf("command params = `%s'",
-                               str_sanitize(test->cmd_params, 24)),
-                               null_strcmp(cmd_params, test->cmd_params) == 0);
+                                                str_sanitize(test->cmd_params,
+                                                             24)),
+                                null_strcmp(cmd_params,
+                                            test->cmd_params) == 0);
                }
                test_end();
                smtp_command_parser_deinit(&parser);
@@ -121,36 +131,45 @@ static const struct smtp_command_parse_invalid_test
        invalid_command_parse_tests[] = {
        {
                .command = "B52\r\n",
-               .error_code = SMTP_COMMAND_PARSE_ERROR_BAD_COMMAND
-       }, {
+               .error_code = SMTP_COMMAND_PARSE_ERROR_BAD_COMMAND,
+       },
+       {
                .command = "BELL\x08\r\n",
-               .error_code = SMTP_COMMAND_PARSE_ERROR_BAD_COMMAND
-       }, {
+               .error_code = SMTP_COMMAND_PARSE_ERROR_BAD_COMMAND,
+       },
+       {
                .command = "EHLO  example.com\r\n",
-               .error_code = SMTP_COMMAND_PARSE_ERROR_BAD_COMMAND
-       }, {
+               .error_code = SMTP_COMMAND_PARSE_ERROR_BAD_COMMAND,
+       },
+       {
                .command = "NOOP \"\x01\x02\x03\"\r\n",
-               .error_code = SMTP_COMMAND_PARSE_ERROR_BAD_COMMAND
-       }, {
+               .error_code = SMTP_COMMAND_PARSE_ERROR_BAD_COMMAND,
+       },
+       {
                .command = "RSET\rQUIT\r\n",
-               .error_code = SMTP_COMMAND_PARSE_ERROR_BAD_COMMAND
-       }, {
+               .error_code = SMTP_COMMAND_PARSE_ERROR_BAD_COMMAND,
+       },
+       {
                .command = "INSANELYREDICULOUSLYLONGCOMMANDNAME\r\n",
-               .error_code = SMTP_COMMAND_PARSE_ERROR_BAD_COMMAND
-       }, {
+               .error_code = SMTP_COMMAND_PARSE_ERROR_BAD_COMMAND,
+       },
+       {
                .command = "RCPT TO:<recipient@example.com> NOTIFY=NEVER\r\n",
                .limits = { .max_parameters_size = 38 },
-               .error_code = SMTP_COMMAND_PARSE_ERROR_LINE_TOO_LONG
-       }, {
+               .error_code = SMTP_COMMAND_PARSE_ERROR_LINE_TOO_LONG,
+       },
+       {
                .command = "MAIL FROM:<f\xc3\xb6\xc3\xa4@\xc3\xb6\xc3>\r\n",
                .error_code = SMTP_COMMAND_PARSE_ERROR_BAD_COMMAND,
-       }, {
+       },
+       {
                .command = "MAIL FROM:f\xc3\xb6\xc3\xa4@\xc3\xb6\xc3\r\n",
                .error_code = SMTP_COMMAND_PARSE_ERROR_BAD_COMMAND,
-       }, {
+       },
+       {
                .command = "MAIL FROM:f\xc3\xb6\xc3\xa4@\xc3\xb6\xc3",
                .error_code = SMTP_COMMAND_PARSE_ERROR_BROKEN_COMMAND,
-       }
+       },
 };
 
 unsigned int invalid_command_parse_test_count =
@@ -177,12 +196,13 @@ static void test_smtp_command_parse_invalid(void)
 
                test_begin(t_strdup_printf("smtp command invalid [%d]", i));
 
-               while ((ret=smtp_command_parse_next(parser,
-                       &cmd_name, &cmd_params, &error_code, &error)) > 0);
+               while ((ret = smtp_command_parse_next(
+                       parser, &cmd_name, &cmd_params,
+                       &error_code, &error)) > 0);
                test_out_reason(t_strdup_printf("parse(\"%s\")",
-                       str_sanitize(command_text, 28)), ret == -1, error);
-               test_out_quiet("error code",
-                       error_code == test->error_code);
+                                               str_sanitize(command_text, 28)),
+                               ret == -1, error);
+               test_out_quiet("error code", error_code == test->error_code);
 
                test_end();
                smtp_command_parser_deinit(&parser);
@@ -205,18 +225,20 @@ static const struct smtp_auth_response_parse_valid_test
 valid_auth_response_parse_tests[] = {
        {
                .auth_response = "U3R1cGlkIEJhc2U2NCB0ZXN0\r\n",
-               .line = "U3R1cGlkIEJhc2U2NCB0ZXN0"
-       }, {
+               .line = "U3R1cGlkIEJhc2U2NCB0ZXN0",
+       },
+       {
                .auth_response = "U3R1cGlkIEJhc2U2NCB0ZXN0    \r\n",
-               .line = "U3R1cGlkIEJhc2U2NCB0ZXN0"
-       }, {
+               .line = "U3R1cGlkIEJhc2U2NCB0ZXN0",
+       },
+       {
                .auth_response =
                        "U3R1cGlkIHZlcnkgdmVyeSB2ZXJ5IHZlcnkgdmVyeS"
                        "B2ZXJ5IHZlcnkgdmVyeSBsb25nIEJhc2U2NCB0ZXN0\r\n",
                .limits = { .max_auth_size = 84 },
                .line = "U3R1cGlkIHZlcnkgdmVyeSB2ZXJ5IHZlcnkgdmVyeS"
-                       "B2ZXJ5IHZlcnkgdmVyeSBsb25nIEJhc2U2NCB0ZXN0"
-       }
+                       "B2ZXJ5IHZlcnkgdmVyeSBsb25nIEJhc2U2NCB0ZXN0",
+       },
 };
 
 unsigned int valid_auth_response_parse_test_count =
@@ -242,16 +264,16 @@ static void test_smtp_auth_response_parse_valid(void)
 
                test_begin(t_strdup_printf("smtp auth_response valid [%d]", i));
 
-               while ((ret=smtp_command_parse_auth_response(parser,
-                       &line, &error_code, &error)) > 0);
+               while ((ret = smtp_command_parse_auth_response(
+                       parser, &line, &error_code, &error)) > 0);
 
                test_out_reason("parse success", ret == -2, error);
 
                if (ret == 0) {
                        /* verify last response only */
                        test_out(t_strdup_printf("line = `%s'",
-                               str_sanitize(test->line, 24)),
-                               null_strcmp(line, test->line) == 0);
+                                                str_sanitize(test->line, 24)),
+                                null_strcmp(line, test->line) == 0);
                }
                test_end();
                smtp_command_parser_deinit(&parser);
@@ -274,20 +296,23 @@ static const struct smtp_auth_response_parse_invalid_test
        invalid_auth_response_parse_tests[] = {
        {
                .auth_response = "\x01\x02\x03\r\n",
-               .error_code = SMTP_COMMAND_PARSE_ERROR_BAD_COMMAND
-       }, {
+               .error_code = SMTP_COMMAND_PARSE_ERROR_BAD_COMMAND,
+       },
+       {
                .auth_response = "U3R1cGlkIEJhc\r2U2NCB0ZXN0\r\n",
-               .error_code = SMTP_COMMAND_PARSE_ERROR_BAD_COMMAND
-       }, {
+               .error_code = SMTP_COMMAND_PARSE_ERROR_BAD_COMMAND,
+       },
+       {
                .auth_response =
                        "U3R1cGlkIHZlcnkgdmVyeSB2ZXJ5IHZlcnkgdmVyeS"
                        "B2ZXJ5IHZlcnkgdmVyeSBsb25nIEJhc2U2NCB0ZXN0\r\n",
                .limits = { .max_auth_size = 83 },
-               .error_code = SMTP_COMMAND_PARSE_ERROR_LINE_TOO_LONG
-       }, {
+               .error_code = SMTP_COMMAND_PARSE_ERROR_LINE_TOO_LONG,
+       },
+       {
                .auth_response = "\xc3\xb6\xc3\xa4\xc3\xb6\xc3\xa4\r\n",
                .error_code = SMTP_COMMAND_PARSE_ERROR_BAD_COMMAND,
-       }
+       },
 };
 
 unsigned int invalid_auth_response_parse_test_count =
@@ -312,15 +337,16 @@ static void test_smtp_auth_response_parse_invalid(void)
                parser = smtp_command_parser_init(input, &test->limits);
                i_stream_unref(&input);
 
-               test_begin(t_strdup_printf(
-                       "smtp auth response invalid [%d]", i));
+               test_begin(
+                       t_strdup_printf("smtp auth response invalid [%d]", i));
 
-               while ((ret=smtp_command_parse_auth_response(parser,
-                       &line, &error_code, &error)) > 0);
+               while ((ret = smtp_command_parse_auth_response(
+                       parser, &line, &error_code, &error)) > 0);
                test_out_reason(t_strdup_printf("parse(\"%s\")",
-                       str_sanitize(response_text, 28)), ret == -1, error);
-               test_out_quiet("error code",
-                       error_code == test->error_code);
+                                               str_sanitize(response_text,
+                                                            28)),
+                               ret == -1, error);
+               test_out_quiet("error code", error_code == test->error_code);
 
                test_end();
                smtp_command_parser_deinit(&parser);