nxt_unit_app_test.c: Use strlen(3)

Signed-off-by: Alejandro Colomar <alx@kernel.org>

1 files changed, 39 insertions, 41 deletions

diff --git a/src/nxt_unit_app_test.c b/src/nxt_unit_app_test.c
index 62fef41..886a31d 100644
--- a/src/nxt_unit_app_test.c
+++ b/src/nxt_unit_app_test.c
@@ -14,7 +14,6 @@
 #define nxt_expect(c, x)  __builtin_expect((long) (x), (c))
 #define nxt_fast_path(x)  nxt_expect(1, x)
 #define nxt_slow_path(x)  nxt_expect(0, x)
-#define nxt_length(s)     (sizeof(s) - 1)
 
 
 #define CONTENT_TYPE  "Content-Type"
@@ -157,26 +156,25 @@ greeting_app_request_handler(nxt_unit_request_info_t *req)
 
     rc = nxt_unit_response_init(req, 200 /* Status code. */,
                                 1 /* Number of response headers. */,
-                                nxt_length(CONTENT_TYPE)
-                                + nxt_length(TEXT_PLAIN)
-                                + nxt_length("Hello world\n!"));
+                                strlen(CONTENT_TYPE)
+                                + strlen(TEXT_PLAIN)
+                                + strlen("Hello world\n!"));
     if (nxt_slow_path(rc != NXT_UNIT_OK)) {
         goto fail;
     }
 
     rc = nxt_unit_response_add_field(req,
-                                     CONTENT_TYPE, nxt_length(CONTENT_TYPE),
-                                     TEXT_PLAIN, nxt_length(TEXT_PLAIN));
+                                     CONTENT_TYPE, strlen(CONTENT_TYPE),
+                                     TEXT_PLAIN, strlen(TEXT_PLAIN));
     if (nxt_slow_path(rc != NXT_UNIT_OK)) {
         goto fail;
     }
 
-    rc = nxt_unit_response_add_content(req, "Hello", nxt_length("Hello"));
+    rc = nxt_unit_response_add_content(req, "Hello", strlen("Hello"));
     if (nxt_slow_path(rc != NXT_UNIT_OK)) {
         goto fail;
     }
-    rc = nxt_unit_response_add_content(req, " world!\n",
-                                       nxt_length(" world!\n"));
+    rc = nxt_unit_response_add_content(req, " world!\n", strlen(" world!\n"));
     if (nxt_slow_path(rc != NXT_UNIT_OK)) {
         goto fail;
     }
@@ -190,26 +188,26 @@ greeting_app_request_handler(nxt_unit_request_info_t *req)
 
     buf = nxt_unit_response_buf_alloc(req, (req->request_buf->end
                                             - req->request_buf->start)
-                                      + nxt_length(REQUEST_DATA)
-                                      + nxt_length(METHOD)
-                                      + nxt_length(NEW_LINE)
-                                      + nxt_length(PROTOCOL)
-                                      + nxt_length(NEW_LINE)
-                                      + nxt_length(REMOTE_ADDR)
-                                      + nxt_length(NEW_LINE)
-                                      + nxt_length(LOCAL_ADDR)
-                                      + nxt_length(NEW_LINE)
-                                      + nxt_length(TARGET)
-                                      + nxt_length(NEW_LINE)
-                                      + nxt_length(PATH)
-                                      + nxt_length(NEW_LINE)
-                                      + nxt_length(QUERY)
-                                      + nxt_length(NEW_LINE)
-                                      + nxt_length(FIELDS)
-                                      + r->fields_count * (
-                                          nxt_length(FIELD_PAD)
-                                          + nxt_length(FIELD_SEP))
-                                      + nxt_length(BODY));
+                                           + strlen(REQUEST_DATA)
+                                           + strlen(METHOD)
+                                           + strlen(NEW_LINE)
+                                           + strlen(PROTOCOL)
+                                           + strlen(NEW_LINE)
+                                           + strlen(REMOTE_ADDR)
+                                           + strlen(NEW_LINE)
+                                           + strlen(LOCAL_ADDR)
+                                           + strlen(NEW_LINE)
+                                           + strlen(TARGET)
+                                           + strlen(NEW_LINE)
+                                           + strlen(PATH)
+                                           + strlen(NEW_LINE)
+                                           + strlen(QUERY)
+                                           + strlen(NEW_LINE)
+                                           + strlen(FIELDS)
+                                           + r->fields_count * (
+                                               strlen(FIELD_PAD)
+                                               + strlen(FIELD_SEP))
+                                           + strlen(BODY));
     if (nxt_slow_path(buf == NULL)) {
         rc = NXT_UNIT_ERROR;
 
@@ -218,52 +216,52 @@ greeting_app_request_handler(nxt_unit_request_info_t *req)
 
     p = buf->free;
 
-    p = mempcpy(p, REQUEST_DATA, nxt_length(REQUEST_DATA));
+    p = mempcpy(p, REQUEST_DATA, strlen(REQUEST_DATA));
 
-    p = mempcpy(p, METHOD, nxt_length(METHOD));
+    p = mempcpy(p, METHOD, strlen(METHOD));
     p = mempcpy(p, nxt_unit_sptr_get(&r->method), r->method_length);
     *p++ = '\n';
 
-    p = mempcpy(p, PROTOCOL, nxt_length(PROTOCOL));
+    p = mempcpy(p, PROTOCOL, strlen(PROTOCOL));
     p = mempcpy(p, nxt_unit_sptr_get(&r->version), r->version_length);
     *p++ = '\n';
 
-    p = mempcpy(p, REMOTE_ADDR, nxt_length(REMOTE_ADDR));
+    p = mempcpy(p, REMOTE_ADDR, strlen(REMOTE_ADDR));
     p = mempcpy(p, nxt_unit_sptr_get(&r->remote), r->remote_length);
     *p++ = '\n';
 
-    p = mempcpy(p, LOCAL_ADDR, nxt_length(LOCAL_ADDR));
+    p = mempcpy(p, LOCAL_ADDR, strlen(LOCAL_ADDR));
     p = mempcpy(p, nxt_unit_sptr_get(&r->local_addr), r->local_addr_length);
     *p++ = '\n';
 
-    p = mempcpy(p, TARGET, nxt_length(TARGET));
+    p = mempcpy(p, TARGET, strlen(TARGET));
     p = mempcpy(p, nxt_unit_sptr_get(&r->target), r->target_length);
     *p++ = '\n';
 
-    p = mempcpy(p, PATH, nxt_length(PATH));
+    p = mempcpy(p, PATH, strlen(PATH));
     p = mempcpy(p, nxt_unit_sptr_get(&r->path), r->path_length);
     *p++ = '\n';
 
     if (r->query.offset) {
-        p = mempcpy(p, QUERY, nxt_length(QUERY));
+        p = mempcpy(p, QUERY, strlen(QUERY));
         p = mempcpy(p, nxt_unit_sptr_get(&r->query), r->query_length);
         *p++ = '\n';
     }
 
-    p = mempcpy(p, FIELDS, nxt_length(FIELDS));
+    p = mempcpy(p, FIELDS, strlen(FIELDS));
 
     for (i = 0; i < r->fields_count; i++) {
         f = r->fields + i;
 
-        p = mempcpy(p, FIELD_PAD, nxt_length(FIELD_PAD));
+        p = mempcpy(p, FIELD_PAD, strlen(FIELD_PAD));
         p = mempcpy(p, nxt_unit_sptr_get(&f->name), f->name_length);
-        p = mempcpy(p, FIELD_SEP, nxt_length(FIELD_SEP));
+        p = mempcpy(p, FIELD_SEP, strlen(FIELD_SEP));
         p = mempcpy(p, nxt_unit_sptr_get(&f->value), f->value_length);
         *p++ = '\n';
     }
 
     if (r->content_length > 0) {
-        p = mempcpy(p, BODY, nxt_length(BODY));
+        p = mempcpy(p, BODY, strlen(BODY));
 
         res = nxt_unit_request_read(req, buf->free, buf->end - buf->free);
         buf->free += res;