MB-19204: ep_testsuite: Use std::string for last_key/body 07/62907/4
authorDave Rigby <daver@couchbase.com>
Thu, 2 Jul 2015 15:25:10 +0000 (15:25 +0000)
committerChiyoung Seo <chiyoung@couchbase.com>
Sat, 23 Apr 2016 00:44:49 +0000 (00:44 +0000)
Replace the manually-managed char* for last_body and last_key with
std::string. This solves the issue of leaving these two buffers
un-free'd at the end of a test; and gives simplifies managing and
testing the last body & key values.

Change-Id: Ic1c64032e34e7abbe5ba8de3e16c115a78a6632f
Reviewed-on: http://review.couchbase.org/62907
Well-Formed: buildbot <build@couchbase.com>
Tested-by: buildbot <build@couchbase.com>
Reviewed-by: Jim Walker <jim@couchbase.com>
Reviewed-by: Will Gardner <will.gardner@couchbase.com>
tests/ep_test_apis.cc
tests/ep_test_apis.h
tests/ep_testsuite.cc

index ff1913e..c0923da 100644 (file)
@@ -38,9 +38,8 @@ std::map<std::string, std::string> vals;
 bool dump_stats = false;
 protocol_binary_response_status last_status =
     static_cast<protocol_binary_response_status>(0);
-uint32_t last_bodylen = 0;
-char *last_key = NULL;
-char *last_body = NULL;
+std::string last_key;
+std::string last_body;
 bool last_deleted_flag = false;
 uint64_t last_cas = 0;
 uint8_t last_datatype = 0x00;
@@ -64,16 +63,7 @@ ENGINE_ERROR_CODE vb_map_response(const void *cookie,
                                   const void *map,
                                   size_t mapsize) {
     (void)cookie;
-    last_bodylen = mapsize;
-    if (last_body) {
-        free(last_body);
-        last_body = NULL;
-    }
-    if (mapsize > 0) {
-        last_body = static_cast<char*>(malloc(mapsize));
-        cb_assert(last_body);
-        memcpy(last_body, map, mapsize);
-    }
+    last_body.assign(static_cast<const char*>(map), mapsize);
     return ENGINE_SUCCESS;
 }
 
@@ -84,28 +74,9 @@ bool add_response(const void *key, uint16_t keylen, const void *ext,
     (void)ext;
     (void)extlen;
     (void)cookie;
-    last_bodylen = bodylen;
     last_status = static_cast<protocol_binary_response_status>(status);
-    if (last_body) {
-        free(last_body);
-        last_body = NULL;
-    }
-    if (bodylen > 0) {
-        last_body = static_cast<char*>(malloc(bodylen + 1));
-        cb_assert(last_body);
-        memcpy(last_body, body, bodylen);
-        last_body[bodylen] = '\0';
-    }
-    if (last_key) {
-        free(last_key);
-        last_key = NULL;
-    }
-    if (keylen > 0) {
-        last_key = static_cast<char*>(malloc(keylen + 1));
-        cb_assert(last_key);
-        memcpy(last_key, key, keylen);
-        last_key[keylen] = '\0';
-    }
+    last_body.assign(static_cast<const char*>(body), bodylen);
+    last_key.assign(static_cast<const char*>(key), keylen);
     last_cas = cas;
     last_datatype = datatype;
     return true;
@@ -311,7 +282,7 @@ void evict_key(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1, const char *key,
         check(last_status == PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS,
               "Expected exists when evicting key.");
     } else {
-        if (strcmp(last_body, "Already ejected.") != 0) {
+        if (last_body != "Already ejected.") {
             nonResidentItems++;
             numEjectedItems++;
         }
@@ -324,9 +295,9 @@ void evict_key(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1, const char *key,
     check(get_int_stat(h, h1, "ep_num_value_ejects") == numEjectedItems,
           "Incorrect number of ejected items");
 
-    if (msg != NULL && strcmp(last_body, msg) != 0) {
+    if (msg != NULL && last_body != msg) {
         fprintf(stderr, "Expected evict to return ``%s'', but it returned ``%s''\n",
-                msg, last_body);
+                msg, last_body.c_str());
         abort();
     }
 }
@@ -769,13 +740,14 @@ bool verify_vbucket_state(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1, uint16_t vb,
     if (last_status != PROTOCOL_BINARY_RESPONSE_SUCCESS) {
         if (!mute) {
             fprintf(stderr, "Last protocol status was %d (%s)\n",
-                    last_status, last_body ? last_body : "unknown");
+                    last_status,
+                    last_body.size() > 0 ? last_body.c_str() : "unknown");
         }
         return false;
     }
 
     vbucket_state_t state;
-    memcpy(&state, last_body, sizeof(state));
+    memcpy(&state, last_body.data(), sizeof(state));
     state = static_cast<vbucket_state_t>(ntohl(state));
     return state == expected;
 }
@@ -983,7 +955,7 @@ void verify_all_vb_seqnos(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1,
     const int per_vb_resp_size = sizeof(uint16_t) + sizeof(uint64_t);
     const int high_seqno_offset = sizeof(uint16_t);
 
-    std::string seqno_body(last_body, last_bodylen);
+    std::string seqno_body = last_body;
 
     /* Check if the total response length is as expected. We expect 10 bytes
        (2 for vb_id + 8 for seqno) */
index c80257a..36bf4dc 100644 (file)
@@ -62,11 +62,10 @@ ENGINE_ERROR_CODE vb_map_response(const void *cookie, const void *map,
 #endif
 
 extern protocol_binary_response_status last_status;
-extern char *last_key;
-extern char *last_body;
+extern std::string last_key;
+extern std::string last_body;
 extern bool dump_stats;
 extern std::map<std::string, std::string> vals;
-extern uint32_t last_bodylen;
 extern uint64_t last_cas;
 extern uint8_t last_datatype;
 extern bool last_deleted_flag;
index b106ad1..c5dfd15 100644 (file)
@@ -181,7 +181,7 @@ static enum test_result test_getl(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1) {
     getl(h, h1, key, vbucketId, expiration);
     check(last_status == PROTOCOL_BINARY_RESPONSE_KEY_ENOENT,
           "expected the key to be missing...");
-    if (last_body != NULL && (strcmp(last_body, "NOT_FOUND") != 0)) {
+    if (!last_body.empty() && last_body != "NOT_FOUND") {
         fprintf(stderr, "Should have returned NOT_FOUND. Getl Failed");
         abort();
     }
@@ -196,7 +196,7 @@ static enum test_result test_getl(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1) {
     getl(h, h1, key, vbucketId, expiration);
     check(last_status == PROTOCOL_BINARY_RESPONSE_SUCCESS,
           "Expected to be able to getl on first try");
-    check(strcmp("{\"lock\":\"data\"}", last_body) == 0, "Body was malformed.");
+    check(last_body == "{\"lock\":\"data\"}", "Body was malformed.");
     check(last_datatype == PROTOCOL_BINARY_DATATYPE_JSON,
             "Expected datatype to be JSON");
 
@@ -208,7 +208,7 @@ static enum test_result test_getl(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1) {
     check(last_status == PROTOCOL_BINARY_RESPONSE_ETMPFAIL,
           "Expected to fail getl on second try");
 
-    if (last_body != NULL && (strcmp(last_body, "LOCK_ERROR") != 0)) {
+    if (!last_body.empty() && last_body != "LOCK_ERROR") {
         fprintf(stderr, "Should have returned LOCK_ERROR. Getl Failed");
         abort();
     }
@@ -345,7 +345,7 @@ static enum test_result test_unl(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1) {
     check(last_status == PROTOCOL_BINARY_RESPONSE_ETMPFAIL,
           "Expected to fail getl on second try");
 
-    if (last_body != NULL && (strcmp(last_body, "UNLOCK_ERROR") != 0)) {
+    if (!last_body.empty() && last_body != "UNLOCK_ERROR") {
         fprintf(stderr, "Should have returned UNLOCK_ERROR. Unl Failed");
         abort();
     }
@@ -2201,8 +2201,8 @@ static enum test_result test_get_replica(ENGINE_HANDLE *h,
                               "Get Replica Failed");
     check(last_status == PROTOCOL_BINARY_RESPONSE_SUCCESS,
           "Expected PROTOCOL_BINARY_RESPONSE_SUCCESS response.");
-    check(strcmp("replicadata", last_body) == 0,
-                 "Should have returned identical value");
+    check(last_body == "replicadata",
+          "Should have returned identical value");
 
     return SUCCESS;
 }
@@ -2378,7 +2378,8 @@ static enum test_result test_gat(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1) {
     gat(h, h1, "mykey", 0, 10);
     check(last_status == PROTOCOL_BINARY_RESPONSE_SUCCESS, "gat mykey");
     check(last_datatype == PROTOCOL_BINARY_DATATYPE_JSON, "Expected datatype to be JSON");
-    check(memcmp(last_body, "{\"some\":\"value\"}", sizeof("{\"some\":\"value\"}")) == 0,
+    check(last_body.compare(0, sizeof("{\"some\":\"value\"}"),
+                            "{\"some\":\"value\"}") == 0,
           "Invalid data returned");
 
     // time-travel 9 secs..
@@ -2434,7 +2435,8 @@ static enum test_result test_gatq(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1) {
     gat(h, h1, "mykey", 0, 10, true);
     check(last_status == PROTOCOL_BINARY_RESPONSE_SUCCESS, "gat mykey");
     check(last_datatype == PROTOCOL_BINARY_DATATYPE_JSON, "Expected datatype to be JSON");
-    check(memcmp(last_body, "{\"some\":\"value\"}", sizeof("{\"some\":\"value\"}")) == 0,
+    check(last_body.compare(0, sizeof("{\"some\":\"value\"}"),
+                            "{\"some\":\"value\"}") == 0,
           "Invalid data returned");
 
     // time-travel 9 secs..
@@ -7464,7 +7466,8 @@ static enum test_result test_cluster_config(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *
         createPacket(PROTOCOL_BINARY_CMD_GET_CLUSTER_CONFIG, 1, 0, NULL, 0, NULL, 0, NULL, 0);
     check(h1->unknown_command(h, NULL, pkt2, add_response) == ENGINE_SUCCESS,
             "Failed to get cluster configuration");
-    if (memcmp(last_body, &var, 8) != 0) {
+    if (last_body.compare(0, sizeof(var), reinterpret_cast<char*>(&var),
+                          sizeof(var)) != 0) {
         return FAIL;
     } else {
         return SUCCESS;
@@ -7487,7 +7490,8 @@ static enum test_result test_not_my_vbucket_with_cluster_config(ENGINE_HANDLE *h
     ENGINE_ERROR_CODE ret = h1->unknown_command(h, NULL, pkt2,
                                                 add_response);
     check(ret == ENGINE_SUCCESS, "Should've received not_my_vbucket/cluster config");
-    if (memcmp(last_body, &var, 8) != 0) {
+    if (last_body.compare(0, sizeof(var), reinterpret_cast<char*>(&var),
+                          sizeof(var)) != 0) {
         return FAIL;
     } else {
         return SUCCESS;
@@ -7495,7 +7499,8 @@ static enum test_result test_not_my_vbucket_with_cluster_config(ENGINE_HANDLE *h
     check(verify_key(h, h1, "key", 2) == ENGINE_NOT_MY_VBUCKET, "Expected miss");
     check(h1->get_engine_vb_map(h, NULL, vb_map_response) == ENGINE_SUCCESS,
             "Failed to recover cluster configuration");
-    if (memcmp(last_body, &var, 8) != 0) {
+    if (last_body.compare(0, sizeof(var), reinterpret_cast<char*>(&var),
+                          sizeof(var)) != 0) {
         return FAIL;
     } else {
         return SUCCESS;
@@ -7540,14 +7545,14 @@ static enum test_result test_all_keys_api(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1
     size_t offset = 0;
     for (size_t i = 0; i < 5; ++i) {
         uint16_t len;
-        memcpy(&len, last_body + offset, sizeof(uint16_t));
+        memcpy(&len, last_body.data() + offset, sizeof(uint16_t));
         len = ntohs(len);
         check(keylen == len,
               "Key length mismatch in all_docs response");
         std::stringstream ss;
         ss << "key_" << start_num++;
         offset += sizeof(uint16_t);
-        check(memcmp(last_body + offset, ss.str().c_str(), keylen)
+        check(last_body.compare(offset, keylen, ss.str().c_str())
               == 0, "Key mismatch in all_keys response");
         offset += keylen;
     }
@@ -10053,15 +10058,15 @@ static enum test_result test_observe_single_key(ENGINE_HANDLE *h, ENGINE_HANDLE_
     uint8_t persisted;
     uint64_t cas;
 
-    memcpy(&vb, last_body, sizeof(uint16_t));
+    memcpy(&vb, last_body.data(), sizeof(uint16_t));
     check(ntohs(vb) == 0, "Wrong vbucket in result");
-    memcpy(&keylen, last_body + 2, sizeof(uint16_t));
+    memcpy(&keylen, last_body.data() + 2, sizeof(uint16_t));
     check(ntohs(keylen) == 3, "Wrong keylen in result");
-    memcpy(&key, last_body + 4, ntohs(keylen));
+    memcpy(&key, last_body.data() + 4, ntohs(keylen));
     check(strncmp(key, "key", 3) == 0, "Wrong key in result");
-    memcpy(&persisted, last_body + 7, sizeof(uint8_t));
+    memcpy(&persisted, last_body.data() + 7, sizeof(uint8_t));
     check(persisted == OBS_STATE_NOT_PERSISTED, "Expected persisted in result");
-    memcpy(&cas, last_body + 8, sizeof(uint64_t));
+    memcpy(&cas, last_body.data() + 8, sizeof(uint64_t));
     check(ntohll(cas) == cas1, "Wrong cas in result");
 
     return SUCCESS;
@@ -10109,37 +10114,37 @@ static enum test_result test_observe_multi_key(ENGINE_HANDLE *h, ENGINE_HANDLE_V
     uint8_t persisted;
     uint64_t cas;
 
-    memcpy(&vb, last_body, sizeof(uint16_t));
+    memcpy(&vb, last_body.data(), sizeof(uint16_t));
     check(ntohs(vb) == 0, "Wrong vbucket in result");
-    memcpy(&keylen, last_body + 2, sizeof(uint16_t));
+    memcpy(&keylen, last_body.data() + 2, sizeof(uint16_t));
     check(ntohs(keylen) == 4, "Wrong keylen in result");
-    memcpy(&key, last_body + 4, ntohs(keylen));
+    memcpy(&key, last_body.data() + 4, ntohs(keylen));
     check(strncmp(key, "key1", 4) == 0, "Wrong key in result");
-    memcpy(&persisted, last_body + 8, sizeof(uint8_t));
+    memcpy(&persisted, last_body.data() + 8, sizeof(uint8_t));
     check(persisted == OBS_STATE_PERSISTED, "Expected persisted in result");
-    memcpy(&cas, last_body + 9, sizeof(uint64_t));
+    memcpy(&cas, last_body.data() + 9, sizeof(uint64_t));
     check(ntohll(cas) == cas1, "Wrong cas in result");
 
-    memcpy(&vb, last_body + 17, sizeof(uint16_t));
+    memcpy(&vb, last_body.data() + 17, sizeof(uint16_t));
     check(ntohs(vb) == 1, "Wrong vbucket in result");
-    memcpy(&keylen, last_body + 19, sizeof(uint16_t));
+    memcpy(&keylen, last_body.data() + 19, sizeof(uint16_t));
     check(ntohs(keylen) == 4, "Wrong keylen in result");
-    memcpy(&key, last_body + 21, ntohs(keylen));
+    memcpy(&key, last_body.data() + 21, ntohs(keylen));
     check(strncmp(key, "key2", 4) == 0, "Wrong key in result");
-    memcpy(&persisted, last_body + 25, sizeof(uint8_t));
+    memcpy(&persisted, last_body.data() + 25, sizeof(uint8_t));
     check(persisted == OBS_STATE_PERSISTED, "Expected persisted in result");
-    memcpy(&cas, last_body + 26, sizeof(uint64_t));
+    memcpy(&cas, last_body.data() + 26, sizeof(uint64_t));
     check(ntohll(cas) == cas2, "Wrong cas in result");
 
-    memcpy(&vb, last_body + 34, sizeof(uint16_t));
+    memcpy(&vb, last_body.data() + 34, sizeof(uint16_t));
     check(ntohs(vb) == 1, "Wrong vbucket in result");
-    memcpy(&keylen, last_body + 36, sizeof(uint16_t));
+    memcpy(&keylen, last_body.data() + 36, sizeof(uint16_t));
     check(ntohs(keylen) == 4, "Wrong keylen in result");
-    memcpy(&key, last_body + 38, ntohs(keylen));
+    memcpy(&key, last_body.data() + 38, ntohs(keylen));
     check(strncmp(key, "key3", 4) == 0, "Wrong key in result");
-    memcpy(&persisted, last_body + 42, sizeof(uint8_t));
+    memcpy(&persisted, last_body.data() + 42, sizeof(uint8_t));
     check(persisted == OBS_STATE_PERSISTED, "Expected persisted in result");
-    memcpy(&cas, last_body + 43, sizeof(uint64_t));
+    memcpy(&cas, last_body.data() + 43, sizeof(uint64_t));
     check(ntohll(cas) == cas3, "Wrong cas in result");
 
     return SUCCESS;
@@ -10174,17 +10179,17 @@ static enum test_result test_multiple_observes(ENGINE_HANDLE *h, ENGINE_HANDLE_V
     observe(h, h1, obskeys);
     check(last_status == PROTOCOL_BINARY_RESPONSE_SUCCESS, "Expected success");
 
-    memcpy(&vb, last_body, sizeof(uint16_t));
+    memcpy(&vb, last_body.data(), sizeof(uint16_t));
     check(ntohs(vb) == 0, "Wrong vbucket in result");
-    memcpy(&keylen, last_body + 2, sizeof(uint16_t));
+    memcpy(&keylen, last_body.data() + 2, sizeof(uint16_t));
     check(ntohs(keylen) == 4, "Wrong keylen in result");
-    memcpy(&key, last_body + 4, ntohs(keylen));
+    memcpy(&key, last_body.data() + 4, ntohs(keylen));
     check(strncmp(key, "key1", 4) == 0, "Wrong key in result");
-    memcpy(&persisted, last_body + 8, sizeof(uint8_t));
+    memcpy(&persisted, last_body.data() + 8, sizeof(uint8_t));
     check(persisted == OBS_STATE_PERSISTED, "Expected persisted in result");
-    memcpy(&cas, last_body + 9, sizeof(uint64_t));
+    memcpy(&cas, last_body.data() + 9, sizeof(uint64_t));
     check(ntohll(cas) == cas1, "Wrong cas in result");
-    check(last_bodylen == 17, "Incorrect body length");
+    check(last_body.size() == 17, "Incorrect body length");
 
     // Do another observe
     obskeys.clear();
@@ -10192,17 +10197,17 @@ static enum test_result test_multiple_observes(ENGINE_HANDLE *h, ENGINE_HANDLE_V
     observe(h, h1, obskeys);
     check(last_status == PROTOCOL_BINARY_RESPONSE_SUCCESS, "Expected success");
 
-    memcpy(&vb, last_body, sizeof(uint16_t));
+    memcpy(&vb, last_body.data(), sizeof(uint16_t));
     check(ntohs(vb) == 0, "Wrong vbucket in result");
-    memcpy(&keylen, last_body + 2, sizeof(uint16_t));
+    memcpy(&keylen, last_body.data() + 2, sizeof(uint16_t));
     check(ntohs(keylen) == 4, "Wrong keylen in result");
-    memcpy(&key, last_body + 4, ntohs(keylen));
+    memcpy(&key, last_body.data() + 4, ntohs(keylen));
     check(strncmp(key, "key2", 4) == 0, "Wrong key in result");
-    memcpy(&persisted, last_body + 8, sizeof(uint8_t));
+    memcpy(&persisted, last_body.data() + 8, sizeof(uint8_t));
     check(persisted == OBS_STATE_PERSISTED, "Expected persisted in result");
-    memcpy(&cas, last_body + 9, sizeof(uint64_t));
+    memcpy(&cas, last_body.data() + 9, sizeof(uint64_t));
     check(ntohll(cas) == cas2, "Wrong cas in result");
-    check(last_bodylen == 17, "Incorrect body length");
+    check(last_body.size() == 17, "Incorrect body length");
 
     return SUCCESS;
 }
@@ -10244,33 +10249,33 @@ static enum test_result test_observe_with_not_found(ENGINE_HANDLE *h, ENGINE_HAN
     uint8_t persisted;
     uint64_t cas;
 
-    memcpy(&vb, last_body, sizeof(uint16_t));
+    memcpy(&vb, last_body.data(), sizeof(uint16_t));
     check(ntohs(vb) == 0, "Wrong vbucket in result");
-    memcpy(&keylen, last_body + 2, sizeof(uint16_t));
+    memcpy(&keylen, last_body.data() + 2, sizeof(uint16_t));
     check(ntohs(keylen) == 4, "Wrong keylen in result");
-    memcpy(&key, last_body + 4, ntohs(keylen));
+    memcpy(&key, last_body.data() + 4, ntohs(keylen));
     check(strncmp(key, "key1", 4) == 0, "Wrong key in result");
-    memcpy(&persisted, last_body + 8, sizeof(uint8_t));
+    memcpy(&persisted, last_body.data() + 8, sizeof(uint8_t));
     check(persisted == OBS_STATE_PERSISTED, "Expected persisted in result");
-    memcpy(&cas, last_body + 9, sizeof(uint64_t));
+    memcpy(&cas, last_body.data() + 9, sizeof(uint64_t));
     check(ntohll(cas) == cas1, "Wrong cas in result");
 
-    memcpy(&keylen, last_body + 19, sizeof(uint16_t));
+    memcpy(&keylen, last_body.data() + 19, sizeof(uint16_t));
     check(ntohs(keylen) == 4, "Wrong keylen in result");
-    memcpy(&key, last_body + 21, ntohs(keylen));
+    memcpy(&key, last_body.data() + 21, ntohs(keylen));
     check(strncmp(key, "key2", 4) == 0, "Wrong key in result");
-    memcpy(&persisted, last_body + 25, sizeof(uint8_t));
+    memcpy(&persisted, last_body.data() + 25, sizeof(uint8_t));
     check(persisted == OBS_STATE_NOT_FOUND, "Expected key_not_found key status");
 
-    memcpy(&vb, last_body + 34, sizeof(uint16_t));
+    memcpy(&vb, last_body.data() + 34, sizeof(uint16_t));
     check(ntohs(vb) == 1, "Wrong vbucket in result");
-    memcpy(&keylen, last_body + 36, sizeof(uint16_t));
+    memcpy(&keylen, last_body.data() + 36, sizeof(uint16_t));
     check(ntohs(keylen) == 4, "Wrong keylen in result");
-    memcpy(&key, last_body + 38, ntohs(keylen));
+    memcpy(&key, last_body.data() + 38, ntohs(keylen));
     check(strncmp(key, "key3", 4) == 0, "Wrong key in result");
-    memcpy(&persisted, last_body + 42, sizeof(uint8_t));
+    memcpy(&persisted, last_body.data() + 42, sizeof(uint8_t));
     check(persisted == OBS_STATE_LOGICAL_DEL, "Expected persisted in result");
-    memcpy(&cas, last_body + 43, sizeof(uint64_t));
+    memcpy(&cas, last_body.data() + 43, sizeof(uint64_t));
     check(ntohll(cas) == cas3 + 1, "Wrong cas in result");
 
     return SUCCESS;
@@ -10569,7 +10574,7 @@ static enum test_result test_gat_locked(ENGINE_HANDLE *h,
 
     gat(h, h1, "key", 0, 10);
     check(last_status == PROTOCOL_BINARY_RESPONSE_ETMPFAIL, "Expected tmp fail");
-    check(strncmp(last_body, "Lock Error", 10) == 0, "Wrong error message");
+    check(last_body == "Lock Error", "Wrong error message");
 
     testHarness.time_travel(16);
     gat(h, h1, "key", 0, 10);
@@ -10664,7 +10669,7 @@ static enum test_result test_touch_locked(ENGINE_HANDLE *h,
 
     touch(h, h1, "key", 0, 10);
     check(last_status == PROTOCOL_BINARY_RESPONSE_ETMPFAIL, "Expected tmp fail");
-    check(strncmp(last_body, "Lock Error", 10) == 0, "Wrong error message");
+    check(last_body == "Lock Error", "Wrong error message");
 
     testHarness.time_travel(16);
     touch(h, h1, "key", 0, 10);
@@ -11206,8 +11211,7 @@ static enum test_result test_gat_with_item_eviction(ENGINE_HANDLE *h,
 
     gat(h, h1, "mykey", 0, 10); // 10 sec as expiration time
     check(last_status == PROTOCOL_BINARY_RESPONSE_SUCCESS, "gat mykey");
-    check(memcmp(last_body, "somevalue", sizeof("somevalue")) == 0,
-          "Invalid data returned");
+    check(last_body == "somevalue", "Invalid data returned");
 
     // time-travel 9 secs..
     testHarness.time_travel(9);
@@ -11344,37 +11348,37 @@ static enum test_result test_observe_with_item_eviction(ENGINE_HANDLE *h,
     uint8_t persisted;
     uint64_t cas;
 
-    memcpy(&vb, last_body, sizeof(uint16_t));
+    memcpy(&vb, last_body.data(), sizeof(uint16_t));
     check(ntohs(vb) == 0, "Wrong vbucket in result");
-    memcpy(&keylen, last_body + 2, sizeof(uint16_t));
+    memcpy(&keylen, last_body.data() + 2, sizeof(uint16_t));
     check(ntohs(keylen) == 4, "Wrong keylen in result");
-    memcpy(&key, last_body + 4, ntohs(keylen));
+    memcpy(&key, last_body.data() + 4, ntohs(keylen));
     check(strncmp(key, "key1", 4) == 0, "Wrong key in result");
-    memcpy(&persisted, last_body + 8, sizeof(uint8_t));
+    memcpy(&persisted, last_body.data() + 8, sizeof(uint8_t));
     check(persisted == OBS_STATE_PERSISTED, "Expected persisted in result");
-    memcpy(&cas, last_body + 9, sizeof(uint64_t));
+    memcpy(&cas, last_body.data() + 9, sizeof(uint64_t));
     check(ntohll(cas) == cas1, "Wrong cas in result");
 
-    memcpy(&vb, last_body + 17, sizeof(uint16_t));
+    memcpy(&vb, last_body.data() + 17, sizeof(uint16_t));
     check(ntohs(vb) == 1, "Wrong vbucket in result");
-    memcpy(&keylen, last_body + 19, sizeof(uint16_t));
+    memcpy(&keylen, last_body.data() + 19, sizeof(uint16_t));
     check(ntohs(keylen) == 4, "Wrong keylen in result");
-    memcpy(&key, last_body + 21, ntohs(keylen));
+    memcpy(&key, last_body.data() + 21, ntohs(keylen));
     check(strncmp(key, "key2", 4) == 0, "Wrong key in result");
-    memcpy(&persisted, last_body + 25, sizeof(uint8_t));
+    memcpy(&persisted, last_body.data() + 25, sizeof(uint8_t));
     check(persisted == OBS_STATE_PERSISTED, "Expected persisted in result");
-    memcpy(&cas, last_body + 26, sizeof(uint64_t));
+    memcpy(&cas, last_body.data() + 26, sizeof(uint64_t));
     check(ntohll(cas) == cas2, "Wrong cas in result");
 
-    memcpy(&vb, last_body + 34, sizeof(uint16_t));
+    memcpy(&vb, last_body.data() + 34, sizeof(uint16_t));
     check(ntohs(vb) == 1, "Wrong vbucket in result");
-    memcpy(&keylen, last_body + 36, sizeof(uint16_t));
+    memcpy(&keylen, last_body.data() + 36, sizeof(uint16_t));
     check(ntohs(keylen) == 4, "Wrong keylen in result");
-    memcpy(&key, last_body + 38, ntohs(keylen));
+    memcpy(&key, last_body.data() + 38, ntohs(keylen));
     check(strncmp(key, "key3", 4) == 0, "Wrong key in result");
-    memcpy(&persisted, last_body + 42, sizeof(uint8_t));
+    memcpy(&persisted, last_body.data() + 42, sizeof(uint8_t));
     check(persisted == OBS_STATE_PERSISTED, "Expected persisted in result");
-    memcpy(&cas, last_body + 43, sizeof(uint64_t));
+    memcpy(&cas, last_body.data() + 43, sizeof(uint64_t));
     check(ntohll(cas) == cas3, "Wrong cas in result");
 
     return SUCCESS;
@@ -11389,8 +11393,7 @@ static enum test_result test_expired_item_with_item_eviction(ENGINE_HANDLE *h,
     h1->release(h, NULL, itm);
     gat(h, h1, "mykey", 0, 10); // 10 sec as expiration time
     check(last_status == PROTOCOL_BINARY_RESPONSE_SUCCESS, "gat mykey");
-    check(memcmp(last_body, "somevalue", sizeof("somevalue")) == 0,
-          "Invalid data returned");
+    check(last_body == "somevalue", "Invalid data returned");
 
     // Store a dummy item since we do not purge the item with highest seqno
     check(ENGINE_SUCCESS ==