DNS: Remove trailing newline from summary and descriptions.
authorRichard Mudgett <rmudgett@digium.com>
Wed, 10 Jun 2015 22:51:22 +0000 (17:51 -0500)
committerRichard Mudgett <rmudgett@digium.com>
Wed, 10 Jun 2015 23:06:14 +0000 (18:06 -0500)
Those trailing newlines mess up test formatting.

Change-Id: I5e3f3a55b82c9d7acb9661201d4993d1958f1185

res/res_resolver_unbound.c
tests/test_dns.c
tests/test_dns_query_set.c
tests/test_dns_recurring.c

index a4e86a6..3eeb651 100644 (file)
@@ -823,7 +823,7 @@ AST_TEST_DEFINE(resolve_sync)
        case TEST_INIT:
                info->name = "resolve_sync";
                info->category = "/res/res_resolver_unbound/";
-               info->summary = "Test nominal synchronous resolution using libunbound\n";
+               info->summary = "Test nominal synchronous resolution using libunbound";
                info->description = "This test performs the following:\n"
                        "\t* Set two static A records and one static AAAA record on one domain\n"
                        "\t* Set an A record for a second domain\n"
@@ -832,7 +832,7 @@ AST_TEST_DEFINE(resolve_sync)
                        "\t* Perform an AAAA record lookup on the first domain\n"
                        "\t* Ensure that the AAAA record is returned and no A record is returned\n"
                        "\t* Perform an A record lookup on the second domain\n"
-                       "\t* Ensure that the A record from the second domain is returned\n";
+                       "\t* Ensure that the A record from the second domain is returned";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;
@@ -847,7 +847,7 @@ AST_TEST_DEFINE(resolve_async)
        case TEST_INIT:
                info->name = "resolve_async";
                info->category = "/res/res_resolver_unbound/";
-               info->summary = "Test nominal asynchronous resolution using libunbound\n";
+               info->summary = "Test nominal asynchronous resolution using libunbound";
                info->description = "This test performs the following:\n"
                        "\t* Set two static A records and one static AAAA record on one domain\n"
                        "\t* Set an A record for a second domain\n"
@@ -856,7 +856,7 @@ AST_TEST_DEFINE(resolve_async)
                        "\t* Perform an AAAA record lookup on the first domain\n"
                        "\t* Ensure that the AAAA record is returned and no A record is returned\n"
                        "\t* Perform an A record lookup on the second domain\n"
-                       "\t* Ensure that the A record from the second domain is returned\n";
+                       "\t* Ensure that the A record from the second domain is returned";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;
@@ -1064,11 +1064,11 @@ AST_TEST_DEFINE(resolve_sync_off_nominal)
        case TEST_INIT:
                info->name = "resolve_sync_off_nominal";
                info->category = "/res/res_resolver_unbound/";
-               info->summary = "Test off-nominal synchronous resolution using libunbound\n";
+               info->summary = "Test off-nominal synchronous resolution using libunbound";
                info->description = "This test performs the following:\n"
                        "\t* Attempt a lookup of a non-existent domain\n"
                        "\t* Attempt a lookup of a AAAA record on a domain that contains only A records\n"
-                       "\t* Attempt a lookup of an A record on Chaos-net\n";
+                       "\t* Attempt a lookup of an A record on Chaos-net";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;
@@ -1083,11 +1083,11 @@ AST_TEST_DEFINE(resolve_async_off_nominal)
        case TEST_INIT:
                info->name = "resolve_async_off_nominal";
                info->category = "/res/res_resolver_unbound/";
-               info->summary = "Test off-nominal synchronous resolution using libunbound\n";
+               info->summary = "Test off-nominal synchronous resolution using libunbound";
                info->description = "This test performs the following:\n"
                        "\t* Attempt a lookup of a non-existent domain\n"
                        "\t* Attempt a lookup of a AAAA record on a domain that contains only A records\n"
-                       "\t* Attempt a lookup of an A record on Chaos-net\n";
+                       "\t* Attempt a lookup of an A record on Chaos-net";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;
@@ -1152,10 +1152,10 @@ AST_TEST_DEFINE(resolve_cancel_off_nominal)
        case TEST_INIT:
                info->name = "resolve_cancel_off_nominal";
                info->category = "/res/res_resolver_unbound/";
-               info->summary = "Off nominal cancellation test using libunbound\n";
+               info->summary = "Off nominal cancellation test using libunbound";
                info->description = "This test does the following:\n"
                        "\t* Perform an asynchronous query\n"
-                       "\t* Once the query has completed, attempt to cancel it\n";
+                       "\t* Once the query has completed, attempt to cancel it";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;
@@ -1220,9 +1220,9 @@ AST_TEST_DEFINE(resolve_naptr)
        case TEST_INIT:
                info->name = "resolve_naptr";
                info->category = "/res/res_resolver_unbound/";
-               info->summary = "Attempt resolution of NAPTR record\n";
+               info->summary = "Attempt resolution of NAPTR record";
                info->description = "This test performs a NAPTR lookup and ensures that\n"
-                       "the returned record has the appropriate values set\n";
+                       "the returned record has the appropriate values set";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;
@@ -1319,11 +1319,11 @@ AST_TEST_DEFINE(resolve_srv)
        case TEST_INIT:
                info->name = "resolve_srv";
                info->category = "/res/res_resolver_unbound/";
-               info->summary = "Test synchronous SRV resolution using libunbound\n";
+               info->summary = "Test synchronous SRV resolution using libunbound";
                info->description = "This test performs the following:\n"
                        "\t* Set one SRV record on one domain\n"
                        "\t* Perform an SRV lookup on the domain\n"
-                       "\t* Ensure that the SRV record returned matches the expected value\n";
+                       "\t* Ensure that the SRV record returned matches the expected value";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;
index 13306ad..b27281e 100644 (file)
@@ -62,7 +62,7 @@ AST_TEST_DEFINE(resolver_register_unregister)
                        "The test performs the following steps:\n"
                        "\t* Register a valid resolver.\n"
                        "\t* Unregister the resolver.\n"
-                       "If either step fails, the test fails\n";
+                       "If either step fails, the test fails";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;
@@ -114,7 +114,7 @@ AST_TEST_DEFINE(resolver_register_off_nominal)
                        "\t* Register a duplicate resolver\n"
                        "\t* Register a resolver without a name\n"
                        "\t* Register a resolver without a resolve() method\n"
-                       "\t* Register a resolver without a cancel() method\n";
+                       "\t* Register a resolver without a cancel() method";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;
@@ -174,7 +174,7 @@ AST_TEST_DEFINE(resolver_unregister_off_nominal)
                        "\t* Unregister a resolver that is not registered.\n"
                        "\t* Unregister a NULL pointer.\n"
                        "Because unregistering a resolver does not return an indicator of success, the best\n"
-                       "this test can do is verify that nothing blows up when this is attempted.\n";
+                       "this test can do is verify that nothing blows up when this is attempted.";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;
@@ -210,7 +210,7 @@ AST_TEST_DEFINE(resolver_data)
                        "\t* Ensure that setting resolver data does not result in an error.\n"
                        "\t* Ensure that retrieving the set resolver data returns the data we expect\n"
                        "\t* Ensure that setting new resolver data on the query does not result in an error\n"
-                       "\t* Ensure that retrieving the resolver data returns the new data that we set\n";
+                       "\t* Ensure that retrieving the resolver data returns the new data that we set";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;
@@ -361,13 +361,13 @@ AST_TEST_DEFINE(resolver_set_result_off_nominal)
        case TEST_INIT:
                info->name = "resolver_set_result_off_nominal";
                info->category = "/main/dns/";
-               info->summary = "Test setting off-nominal DNS results\n";
+               info->summary = "Test setting off-nominal DNS results";
                info->description =
                        "This test performs the following:\n"
                        "\t* Attempt to add a DNS result that is both bogus and secure\n"
                        "\t* Attempt to add a DNS result that has no canonical name\n"
                        "\t* Attempt to add a DNS result that has no answer\n"
-                       "\t* Attempt to add a DNS result with a zero answer size\n";
+                       "\t* Attempt to add a DNS result with a zero answer size";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;
@@ -474,7 +474,7 @@ AST_TEST_DEFINE(resolver_add_record)
                        "\t* Ensure a nominal A record can be added to a query result\n"
                        "\t* Ensures that the record can be retrieved\n"
                        "\t* Ensure that a second record can be added to the query result\n"
-                       "\t* Ensures that both records can be retrieved\n";
+                       "\t* Ensures that both records can be retrieved";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;
@@ -585,7 +585,7 @@ AST_TEST_DEFINE(resolver_add_record_off_nominal)
                        "\t* Ensure that an A record with invalid RR classes cannot be added to a query\n"
                        "\t* Ensure that an A record with invalid TTL cannot be added to a query\n"
                        "\t* Ensure that an A record with NULL data cannot be added to a query\n"
-                       "\t* Ensure that an A record with invalid length cannot be added to a query\n";
+                       "\t* Ensure that an A record with invalid length cannot be added to a query";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;
@@ -917,7 +917,7 @@ AST_TEST_DEFINE(resolver_resolve_sync_off_nominal)
                        "\t* Attempt resolution with invalid RR type\n",
                        "\t* Attempt resolution with invalid RR class\n",
                        "\t* Attempt resolution with NULL result pointer\n",
-                       "\t* Attempt resolution with resolver that returns an error\n";
+                       "\t* Attempt resolution with resolver that returns an error";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;
@@ -1174,7 +1174,7 @@ AST_TEST_DEFINE(resolver_resolve_async_off_nominal)
                        "\t* Attempt resolution with invalid RR type\n",
                        "\t* Attempt resolution with invalid RR class\n",
                        "\t* Attempt resolution with NULL callback pointer\n",
-                       "\t* Attempt resolution with resolver that returns an error\n";
+                       "\t* Attempt resolution with resolver that returns an error";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;
@@ -1232,7 +1232,7 @@ AST_TEST_DEFINE(resolver_resolve_async_cancel)
                        "This test performs an asynchronous DNS resolution of a domain and then cancels\n"
                        "the resolution. The goal of this test is to ensure that the cancel() callback of\n"
                        "the resolver is called and that it properly interrupts the resolution such that no\n"
-                       "records are returned.\n";
+                       "records are returned.";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;
index 9acf1bf..2efc881 100644 (file)
@@ -290,14 +290,14 @@ AST_TEST_DEFINE(query_set)
        case TEST_INIT:
                info->name = "query_set";
                info->category = "/main/dns/query_set/";
-               info->summary = "Test nominal asynchronous DNS query set\n";
+               info->summary = "Test nominal asynchronous DNS query set";
                info->description =
                        "This tests nominal query set in the following ways:\n"
                        "\t* Multiple queries are added to a query set\n"
                        "\t* The mock resolver is configured to respond to all queries\n"
                        "\t* Asynchronous resolution of the query set is started\n"
                        "\t* The mock resolver responds to all queries\n"
-                       "\t* We ensure that the query set callback is invoked upon completion\n";
+                       "\t* We ensure that the query set callback is invoked upon completion";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;
@@ -312,13 +312,13 @@ AST_TEST_DEFINE(query_set_nominal_cancel)
        case TEST_INIT:
                info->name = "query_set_nominal_cancel";
                info->category = "/main/dns/query_set/";
-               info->summary = "Test nominal asynchronous DNS query set cancellation\n";
+               info->summary = "Test nominal asynchronous DNS query set cancellation";
                info->description =
                        "This tests nominal query set cancellation in the following ways:\n"
                        "\t* Multiple queries are added to a query set\n"
                        "\t* The mock resolver is configured to NOT respond to any queries\n"
                        "\t* Asynchronous resolution of the query set is started\n"
-                       "\t* The query set is canceled and is confirmed to return with success\n";
+                       "\t* The query set is canceled and is confirmed to return with success";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;
@@ -333,14 +333,14 @@ AST_TEST_DEFINE(query_set_off_nominal_cancel)
        case TEST_INIT:
                info->name = "query_set_off_nominal_cancel";
                info->category = "/main/dns/query_set/";
-               info->summary = "Test off-nominal asynchronous DNS query set cancellation\n";
+               info->summary = "Test off-nominal asynchronous DNS query set cancellation";
                info->description =
                        "This tests nominal query set cancellation in the following ways:\n"
                        "\t* Multiple queries are added to a query set\n"
                        "\t* The mock resolver is configured to respond to half the queries\n"
                        "\t* Asynchronous resolution of the query set is started\n"
                        "\t* The query set is canceled and is confirmed to return failure\n"
-                       "\t* The query set callback is confirmed to run, since it could not be fully canceled\n";
+                       "\t* The query set callback is confirmed to run, since it could not be fully canceled";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;
index 3d38c64..84cd9d4 100644 (file)
@@ -278,7 +278,7 @@ AST_TEST_DEFINE(recurring_query)
        case TEST_INIT:
                info->name = "recurring_query";
                info->category = "/main/dns/recurring/";
-               info->summary = "Test nominal asynchronous recurring DNS queries\n";
+               info->summary = "Test nominal asynchronous recurring DNS queries";
                info->description =
                        "This tests nominal recurring queries in the following ways:\n"
                        "\t* An asynchronous query is sent to a mock resolver\n"
@@ -286,7 +286,7 @@ AST_TEST_DEFINE(recurring_query)
                        "\t* We ensure that the query re-occurs according to the lower of the TTLs\n"
                        "\t* The mock resolver returns two records, this time with different TTLs\n"
                        "\t  from the first time the query was resolved\n"
-                       "\t* We ensure that the query re-occurs according to the new lower TTL\n";
+                       "\t* We ensure that the query re-occurs according to the new lower TTL";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;
@@ -403,8 +403,7 @@ AST_TEST_DEFINE(recurring_query_off_nominal)
                        "\t* Attempt resolution with invalid RR type\n",
                        "\t* Attempt resolution with invalid RR class\n",
                        "\t* Attempt resolution with NULL callback pointer\n",
-                       "\t* Attempt resolution with resolver that returns an error\n";
-
+                       "\t* Attempt resolution with resolver that returns an error";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;
@@ -459,11 +458,11 @@ AST_TEST_DEFINE(recurring_query_cancel_between)
        case TEST_INIT:
                info->name = "recurring_query_cancel_between";
                info->category = "/main/dns/recurring/";
-               info->summary = "Test canceling a recurring DNS query during the downtime between queries\n";
+               info->summary = "Test canceling a recurring DNS query during the downtime between queries";
                info->description = "This test does the following:\n"
                        "\t* Issue a recurring DNS query.\n"
                        "\t* Once results have been returned, cancel the recurring query.\n"
-                       "\t* Wait a while to ensure that no more queries are occurring.\n";
+                       "\t* Wait a while to ensure that no more queries are occurring.";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;
@@ -540,13 +539,13 @@ AST_TEST_DEFINE(recurring_query_cancel_during)
        case TEST_INIT:
                info->name = "recurring_query_cancel_during";
                info->category = "/main/dns/recurring/";
-               info->summary = "Cancel a recurring DNS query while a query is actually happening\n";
+               info->summary = "Cancel a recurring DNS query while a query is actually happening";
                info->description = "This test does the following:\n"
                        "\t* Initiate a recurring DNS query.\n"
                        "\t* Allow the initial query to complete, and a second query to start\n"
                        "\t* Cancel the recurring query while the second query is executing\n"
                        "\t* Ensure that the resolver's cancel() method was called\n"
-                       "\t* Wait a while to make sure that recurring queries are no longer occurring\n";
+                       "\t* Wait a while to make sure that recurring queries are no longer occurring";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;