Use cb_assert instead of assert

Change-Id: If6b3170af815c324b26ff44bea3b950deed774fd
Reviewed-on: http://review.couchbase.org/49431
Tested-by: buildbot <[email protected]>
Reviewed-by: Steve Yen <[email protected]>

Author: trondn

conflate/adhoc_commands.c

@@ -1,7 +1,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <assert.h>
+#include <platform/cbassert.h>
 
 #include <libconflate/conflate.h>
 #include "conflate_internal.h"
@@ -66,7 +66,7 @@ static enum conflate_mgmt_cb_result process_set_private(void *opaque,
     (void)r;
 
     /* Only direct stat requests are handled. */
-    assert(direct);
+    cb_assert(direct);
 
     if (key && value) {
         if (conflate_save_private(handle, key, value,
@@ -93,7 +93,7 @@ static enum conflate_mgmt_cb_result process_get_private(void *opaque,
     (void)cmd;
 
     /* Only direct stat requests are handled. */
-    assert(direct);
+    cb_assert(direct);
 
     if (key) {
         /* Initialize the form so there's always one there */
@@ -127,7 +127,7 @@ static enum conflate_mgmt_cb_result process_delete_private(void *opaque,
     (void)r;
 
     /* Only direct stat requests are handled. */
-    assert(direct);
+    cb_assert(direct);
 
     if (key) {
         if (conflate_delete_private(handle, key, handle->conf->save_path)) {

conflate/conflate.c

@@ -1,4 +1,4 @@
-#include <assert.h>
+#include <platform/cbassert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -15,7 +15,7 @@ void run_conflate(void *);
 
 conflate_config_t* dup_conf(conflate_config_t c) {
     conflate_config_t *rv = calloc(sizeof(conflate_config_t), 1);
-    assert(rv);
+    cb_assert(rv);
 
     rv->jid = safe_strdup(c.jid);
     rv->pass = safe_strdup(c.pass);
@@ -36,7 +36,7 @@ conflate_config_t* dup_conf(conflate_config_t c) {
 
 void init_conflate(conflate_config_t *conf)
 {
-    assert(conf);
+    cb_assert(conf);
     memset(conf, 0x00, sizeof(conflate_config_t));
     conf->log = conflate_stderr_logger;
     conf->initialization_marker = (void*)INITIALIZATION_MAGIC;
@@ -48,12 +48,12 @@ bool start_conflate(conflate_config_t conf) {
 
     /* Don't start if we don't believe initialization has occurred. */
     if (conf.initialization_marker != (void*)INITIALIZATION_MAGIC) {
-        assert(conf.initialization_marker == (void*)INITIALIZATION_MAGIC);
+        cb_assert(conf.initialization_marker == (void*)INITIALIZATION_MAGIC);
         return false;
     }
 
     handle = calloc(1, sizeof(conflate_handle_t));
-    assert(handle);
+    cb_assert(handle);
 
     if (strncmp(HTTP_PREFIX, conf.host, strlen(HTTP_PREFIX))) {
         run_func = &run_rest_conflate;

conflate/kvpair.c

@@ -1,14 +1,14 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <assert.h>
+#include <platform/cbassert.h>
 
 #include <libconflate/conflate.h>
 
 kvpair_t* mk_kvpair(const char* k, char** v)
 {
     kvpair_t* rv = calloc(1, sizeof(kvpair_t));
-    assert(rv);
+    cb_assert(rv);
 
     rv->key = safe_strdup(k);
     if (v) {
@@ -19,16 +19,16 @@ kvpair_t* mk_kvpair(const char* k, char** v)
     } else {
         rv->allocated_values = 4;
         rv->values = calloc(4, sizeof(char*));
-        assert(rv->values);
+        cb_assert(rv->values);
     }
 
     return rv;
 }
 
 void add_kvpair_value(kvpair_t* pair, const char* value)
 {
-    assert(pair);
-    assert(value);
+    cb_assert(pair);
+    cb_assert(value);
 
     /* The last item in the values list must be null as it acts a sentinal */
     if (pair->allocated_values == 0 ||
@@ -40,7 +40,7 @@ void add_kvpair_value(kvpair_t* pair, const char* value)
 
         pair->values = realloc(pair->values,
                                sizeof(char*) * pair->allocated_values);
-        assert(pair->values);
+        cb_assert(pair->values);
     }
 
     pair->values[pair->used_values++] = safe_strdup(value);
@@ -70,7 +70,7 @@ void walk_kvpair(kvpair_t *pair, void *opaque, kvpair_visitor_t visitor)
 
 kvpair_t* find_kvpair(kvpair_t* pair, const char* key)
 {
-    assert(key);
+    cb_assert(key);
 
     while (pair && strcmp(pair->key, key) != 0) {
         pair = pair->next;
@@ -83,7 +83,7 @@ char *get_simple_kvpair_val(kvpair_t *pair, const char *key)
 {
     char *rv = NULL;
     kvpair_t *found;
-    assert(key);
+    cb_assert(key);
     found = find_kvpair(pair, key);
 
     if (found) {
@@ -96,7 +96,7 @@ char *get_simple_kvpair_val(kvpair_t *pair, const char *key)
 kvpair_t *dup_kvpair(kvpair_t *pair)
 {
     kvpair_t *copy;
-    assert(pair);
+    cb_assert(pair);
     copy = mk_kvpair(pair->key, pair->values);
     if (pair->next) {
         copy->next = dup_kvpair(pair->next);

conflate/persist.c

@@ -1,7 +1,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <assert.h>
+#include <platform/cbassert.h>
 
 #include <libconflate/conflate.h>
 #include "conflate_internal.h"

conflate/rest.c

@@ -1,4 +1,4 @@
-#include <assert.h>
+#include <platform/cbassert.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <sys/types.h>
@@ -37,9 +37,9 @@ struct response_buffer *cur_response_buffer = NULL;
 static struct response_buffer *mk_response_buffer(size_t size) {
     struct response_buffer *r =
       (struct response_buffer *) calloc(1, sizeof(struct response_buffer));
-    assert(r);
+    cb_assert(r);
     r->data = malloc(size);
-    assert(r->data);
+    cb_assert(r->data);
     r->bytes_used = 0;
     r->buffer_size = size;
     r->next = NULL;
@@ -102,7 +102,7 @@ static char *assemble_complete_response(struct response_buffer *response_head) {
 
     /* create buffer */
     response = malloc(response_size + 1);
-    assert(response);
+    cb_assert(response);
 
     /* populate buffer */
     cur_buffer = response_head;
@@ -120,8 +120,8 @@ static char *assemble_complete_response(struct response_buffer *response_head) {
 
 static bool pattern_ends_with(const char *pattern, const char *target, size_t target_size) {
     size_t pattern_size;
-    assert(target);
-    assert(pattern);
+    cb_assert(target);
+    cb_assert(pattern);
 
     pattern_size = strlen(pattern);
     if (target_size < pattern_size) {
@@ -210,23 +210,23 @@ static void setup_handle(CURL *handle, char *url, char *userpass,
         CURLcode c;
 
         c = curl_easy_setopt(handle, CURLOPT_SOCKOPTFUNCTION, setup_curl_sock);
-        assert(c == CURLE_OK);
+        cb_assert(c == CURLE_OK);
         c = curl_easy_setopt(handle, CURLOPT_WRITEDATA, chandle);
-        assert(c == CURLE_OK);
+        cb_assert(c == CURLE_OK);
         c = curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, response_handler);
-        assert(c == CURLE_OK);
+        cb_assert(c == CURLE_OK);
         c = curl_easy_setopt(handle, CURLOPT_URL, url);
-        assert(c == CURLE_OK);
+        cb_assert(c == CURLE_OK);
 
         if (userpass != NULL) {
             c = curl_easy_setopt(handle, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
-            assert(c == CURLE_OK);
+            cb_assert(c == CURLE_OK);
             c = curl_easy_setopt(handle, CURLOPT_USERPWD, userpass);
-            assert(c == CURLE_OK);
+            cb_assert(c == CURLE_OK);
         }
 
         c = curl_easy_setopt(handle, CURLOPT_HTTPGET, 1);
-        assert(c == CURLE_OK);
+        cb_assert(c == CURLE_OK);
     }
 }
 
@@ -270,10 +270,10 @@ void run_rest_conflate(void *arg) {
 
     /* init curl */
     c = curl_global_init(curl_init_flags);
-    assert(c == CURLE_OK);
+    cb_assert(c == CURLE_OK);
 
     curl_handle = curl_easy_init();
-    assert(curl_handle);
+    cb_assert(curl_handle);
 
     curl_easy_setopt(curl_handle, CURLOPT_ERRORBUFFER, &curl_error_string);
 
@@ -290,7 +290,7 @@ void run_rest_conflate(void *arg) {
             if (handle->conf->jid && strlen(handle->conf->jid)) {
                 size_t buff_size = strlen(handle->conf->jid) + strlen(handle->conf->pass) + 2;
                 userpass = (char *) malloc(buff_size);
-                assert(userpass);
+                cb_assert(userpass);
                 snprintf(userpass, buff_size, "%s:%s", handle->conf->jid, handle->conf->pass);
                 userpass[buff_size - 1] = '\0';
             }

conflate/util.c

@@ -1,14 +1,14 @@
 #include <stdio.h>
 #include <stdlib.h>
-#include <assert.h>
+#include <platform/cbassert.h>
 #include <string.h>
 
 #include <libconflate/conflate.h>
 
 char* safe_strdup(const char* in) {
     int len = strlen(in);
     char *rv = calloc(len + 1, sizeof(char));
-    assert(rv);
+    cb_assert(rv);
     memcpy(rv, in, len);
     return rv;
 }

conflate/xmpp.c

@@ -1,7 +1,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <assert.h>
+#include <platform/cbassert.h>
 
 #include <libconflate/conflate.h>
 #include "conflate_internal.h"
@@ -25,27 +25,27 @@ void conflate_init_form(conflate_form_result *r)
 
 void conflate_next_fieldset(conflate_form_result *r) {
     (void)r;
-    assert(0);
+    cb_assert(0);
 }
 
 void conflate_add_field(conflate_form_result *r, const char *k, const char *v) {
     (void)r;
     (void)k;
     (void)v;
-    assert(0);
+    cb_assert(0);
 }
 
 void conflate_add_field_multi(conflate_form_result *r, const char *k,
                               const char **v) {
     (void)r;
     (void)k;
     (void)v;
-    assert(0);
+    cb_assert(0);
 }
 
 void* run_conflate(void *arg) {
     (void)arg;
-    assert(0);
+    cb_assert(0);
     return NULL;
 }
 
@@ -55,7 +55,7 @@ void conflate_register_mgmt_cb(const char *cmd, const char *desc,
                                conflate_mgmt_cb_t cb)
 {
     struct command_def *c = calloc(1, sizeof(struct command_def));
-    assert(c);
+    cb_assert(c);
 
     c->name = safe_strdup(cmd);
     c->description = safe_strdup(desc);

libmemcached/libhashkit/digest.c

@@ -51,7 +51,7 @@ uint32_t libhashkit_digest(const char *key, size_t key_length, hashkit_hash_algo
 #ifdef HAVE_DEBUG
     fprintf(stderr, "hashkit_hash_t was extended but libhashkit_generate_value was not updated\n");
     fflush(stderr);
-    assert(0);
+    cb_assert(0);
 #endif
     break;
   }