Re-enabling errors on warning, disabling unused parameter warning, and fixing all subsequent errors.

Makefile

@@ -122,7 +122,7 @@ LDFLAGS += $(LDFLAGS_$(CONFIG))
 
 CFLAGS += -std=c89 -pedantic
 CXXFLAGS += -std=c++11
-CPPFLAGS += -g -fPIC -Wall -Wextra -Wno-long-long
+CPPFLAGS += -g -fPIC -Wall -Wextra -Werror -Wno-long-long -Wno-unused-parameter
 LDFLAGS += -g -fPIC
 
 INCLUDES = . include gens

include/grpc/byte_buffer_reader.h

@@ -42,7 +42,7 @@ struct grpc_byte_buffer_reader {
   /* Different current objects correspond to different types of byte buffers */
   union {
     /* Index into a slice buffer's array of slices */
-    int index;
+    unsigned index;
   } current;
 };
 

include/grpc/support/port_platform.h

@@ -155,7 +155,7 @@ typedef uintmax_t gpr_uintmax;
 typedef uintptr_t gpr_uintptr;
 
 /* INT64_MAX is unavailable on some platforms. */
-#define GPR_INT64_MAX (~(gpr_uint64)0 >> 1)
+#define GPR_INT64_MAX (gpr_int64)(~(gpr_uint64)0 >> 1)
 
 /* maximum alignment needed for any type on this platform, rounded up to a
    power of two */

include/grpc/support/slice_buffer.h

@@ -73,7 +73,7 @@ size_t gpr_slice_buffer_add_indexed(gpr_slice_buffer *sb, gpr_slice slice);
 void gpr_slice_buffer_addn(gpr_slice_buffer *sb, gpr_slice *slices, size_t n);
 /* add a very small (less than 8 bytes) amount of data to the end of a slice
    buffer: returns a pointer into which to add the data */
-gpr_uint8 *gpr_slice_buffer_tiny_add(gpr_slice_buffer *sb, int len);
+gpr_uint8 *gpr_slice_buffer_tiny_add(gpr_slice_buffer *sb, unsigned len);
 /* clear a slice buffer, unref all elements */
 void gpr_slice_buffer_reset_and_unref(gpr_slice_buffer *sb);
 

src/core/channel/channel_args.c

@@ -105,7 +105,7 @@ void grpc_channel_args_destroy(grpc_channel_args *a) {
 }
 
 int grpc_channel_args_is_census_enabled(const grpc_channel_args *a) {
-  int i;
+  unsigned i;
   if (a == NULL) return 0;
   for (i = 0; i < a->num_args; i++) {
     if (0 == strcmp(a->args[i].key, GRPC_ARG_ENABLE_CENSUS)) {

src/core/channel/channel_stack.c

@@ -125,7 +125,8 @@ void grpc_channel_stack_init(const grpc_channel_filter **filters,
     call_size += ROUND_UP_TO_ALIGNMENT_SIZE(filters[i]->sizeof_call_data);
   }
 
-  GPR_ASSERT(user_data - (char *)stack ==
+  GPR_ASSERT(user_data > (char *)stack);
+  GPR_ASSERT((gpr_uintptr)(user_data - (char *)stack) ==
              grpc_channel_stack_size(filters, filter_count));
 
   stack->call_stack_size = call_size;

src/core/channel/http_client_filter.c

@@ -134,7 +134,7 @@ static void destroy_call_elem(grpc_call_element *elem) {
 }
 
 static const char *scheme_from_args(const grpc_channel_args *args) {
-  int i;
+  unsigned i;
   if (args != NULL) {
     for (i = 0; i < args->num_args; ++i) {
       if (args->args[i].type == GRPC_ARG_STRING &&

src/core/iomgr/tcp_server.h

@@ -68,7 +68,7 @@ int grpc_tcp_server_add_port(grpc_tcp_server *s, const void *addr,
 
    The file descriptor remains owned by the server, and will be cleaned
    up when grpc_tcp_server_destroy is called. */
-int grpc_tcp_server_get_fd(grpc_tcp_server *s, int index);
+int grpc_tcp_server_get_fd(grpc_tcp_server *s, unsigned index);
 
 void grpc_tcp_server_destroy(grpc_tcp_server *server);
 

src/core/iomgr/tcp_server_posix.c

@@ -272,7 +272,7 @@ int grpc_tcp_server_add_port(grpc_tcp_server *s, const void *addr,
                              int addr_len) {
   int allocated_port1 = -1;
   int allocated_port2 = -1;
-  int i;
+  unsigned i;
   int fd;
   grpc_dualstack_mode dsmode;
   struct sockaddr_in6 addr6_v4mapped;
@@ -345,8 +345,8 @@ done:
   return allocated_port1 >= 0 ? allocated_port1 : allocated_port2;
 }
 
-int grpc_tcp_server_get_fd(grpc_tcp_server *s, int index) {
-  return (0 <= index && index < s->nports) ? s->ports[index].fd : -1;
+int grpc_tcp_server_get_fd(grpc_tcp_server *s, unsigned index) {
+  return (index < s->nports) ? s->ports[index].fd : -1;
 }
 
 void grpc_tcp_server_start(grpc_tcp_server *s, grpc_pollset *pollset,

src/core/json/json_writer.c

@@ -66,7 +66,7 @@ static void json_writer_output_indent(
       "                "
       "                ";
 
-  int spaces = writer->depth * writer->indent;
+  unsigned spaces = writer->depth * writer->indent;
 
   if (writer->indent == 0) return;
 

src/core/security/base64.c

@@ -113,7 +113,8 @@ char *grpc_base64_encode(const void *vdata, size_t data_size, int url_safe,
     *current++ = GRPC_BASE64_PAD_CHAR;
   }
 
-  GPR_ASSERT((current - result) < result_projected_size);
+  GPR_ASSERT(current >= result);
+  GPR_ASSERT((gpr_uintptr)(current - result) < result_projected_size);
   result[current - result] = '\0';
   return result;
 }

src/core/security/credentials.c

@@ -173,7 +173,9 @@ static void ssl_server_destroy(grpc_server_credentials *creds) {
   gpr_free(creds);
 }
 
-static int ssl_has_request_metadata(const grpc_credentials *creds) { return 0; }
+static int ssl_has_request_metadata(const grpc_credentials *creds) {
+  return 0;
+}
 
 static int ssl_has_request_metadata_only(const grpc_credentials *creds) {
   return 0;
@@ -903,7 +905,9 @@ static void iam_destroy(grpc_credentials *creds) {
   gpr_free(c);
 }
 
-static int iam_has_request_metadata(const grpc_credentials *creds) { return 1; }
+static int iam_has_request_metadata(const grpc_credentials *creds) {
+  return 1;
+}
 
 static int iam_has_request_metadata_only(const grpc_credentials *creds) {
   return 1;

src/core/security/json_token.c

@@ -127,7 +127,8 @@ grpc_auth_json_key grpc_auth_json_key_create_from_string(
     goto end;
   }
   bio = BIO_new(BIO_s_mem());
-  if (BIO_puts(bio, prop_value) != strlen(prop_value)) {
+  success = BIO_puts(bio, prop_value);
+  if ((success < 0) || ((size_t)success != strlen(prop_value))) {
     gpr_log(GPR_ERROR, "Could not write into openssl BIO.");
     goto end;
   }
@@ -240,7 +241,8 @@ static char *dot_concat_and_free_strings(char *str1, char *str2) {
   *(current++) = '.';
   memcpy(current, str2, str2_len);
   current += str2_len;
-  GPR_ASSERT((current - result) == result_len);
+  GPR_ASSERT(current >= result);
+  GPR_ASSERT((gpr_uintptr)(current - result) == result_len);
   *current = '\0';
   gpr_free(str1);
   gpr_free(str2);

src/core/security/secure_endpoint.c

@@ -111,7 +111,7 @@ static void call_read_cb(secure_endpoint *ep, gpr_slice *slices, size_t nslices,
 
 static void on_read(void *user_data, gpr_slice *slices, size_t nslices,
                     grpc_endpoint_cb_status error) {
-  int i = 0;
+  unsigned i;
   gpr_uint8 keep_looping = 0;
   int input_buffer_count = 0;
   tsi_result result = TSI_OK;
@@ -221,7 +221,7 @@ static grpc_endpoint_write_status endpoint_write(grpc_endpoint *secure_ep,
                                                  size_t nslices,
                                                  grpc_endpoint_write_cb cb,
                                                  void *user_data) {
-  int i = 0;
+  unsigned i;
   int output_buffer_count = 0;
   tsi_result result = TSI_OK;
   secure_endpoint *ep = (secure_endpoint *)secure_ep;

src/core/security/server_secure_chttp2.c

@@ -92,7 +92,7 @@ int grpc_server_add_secure_http2_port(grpc_server *server, const char *addr) {
   grpc_resolved_addresses *resolved = NULL;
   grpc_tcp_server *tcp = NULL;
   size_t i;
-  int count = 0;
+  unsigned count = 0;
   int port_num = -1;
   int port_temp;
 
@@ -127,6 +127,7 @@ int grpc_server_add_secure_http2_port(grpc_server *server, const char *addr) {
   if (count != resolved->naddrs) {
     gpr_log(GPR_ERROR, "Only %d addresses added out of total %d resolved",
             count, resolved->naddrs);
+    /* if it's an error, don't we want to goto error; here ? */
   }
   grpc_resolved_addresses_destroy(resolved);
 

src/core/statistics/census_log.c

@@ -173,7 +173,7 @@ typedef struct census_log_core_local_block {
 struct census_log {
   int discard_old_records;
   /* Number of cores (aka hardware-contexts) */
-  int num_cores;
+  unsigned num_cores;
   /* number of CENSUS_LOG_2_MAX_RECORD_SIZE blocks in log */
   gpr_int32 num_blocks;
   cl_block* blocks;                       /* Block metadata. */
@@ -183,7 +183,7 @@ struct census_log {
   /* Keeps the state of the reader iterator. A value of 0 indicates that
      iterator has reached the end. census_log_init_reader() resets the
      value to num_core to restart iteration. */
-  gpr_int32 read_iterator_state;
+  gpr_uint32 read_iterator_state;
   /* Points to the block being read. If non-NULL, the block is locked for
      reading (block_being_read_->reader_lock is held). */
   cl_block* block_being_read;

src/core/statistics/census_rpc_stats.c

@@ -184,7 +184,7 @@ static void get_stats(census_ht* store, census_aggregated_rpc_stats* data) {
   gpr_mu_lock(&g_mu);
   if (store != NULL) {
     size_t n;
-    int i, j;
+    unsigned i, j;
     gpr_timespec now = gpr_now();
     census_ht_kv* kv = census_ht_get_all_elements(store, &n);
     if (kv != NULL) {

src/core/statistics/hash_table.c

@@ -292,7 +292,7 @@ static void ht_delete_entry_chain(const census_ht_option* options,
 }
 
 void census_ht_destroy(census_ht* ht) {
-  int i;
+  unsigned i;
   for (i = 0; i < ht->num_buckets; ++i) {
     ht_delete_entry_chain(&ht->options, ht->buckets[i].next);
   }

src/core/statistics/window_stats.c

@@ -150,7 +150,7 @@ window_stats* census_window_stats_create(int nintervals,
     is->width = size_ns / granularity;
     /* Check for possible overflow issues, and maximize interval size if the
        user requested something large enough. */
-    if (GPR_INT64_MAX - is->width > size_ns) {
+    if ((GPR_INT64_MAX - is->width) > size_ns) {
       is->top = size_ns + is->width;
     } else {
       is->top = GPR_INT64_MAX;

src/core/support/cpu.h

@@ -38,12 +38,12 @@
 
 /* Return the number of CPU cores on the current system. Will return 0 if
    if information is not available. */
-int gpr_cpu_num_cores(void);
+unsigned gpr_cpu_num_cores(void);
 
 /* Return the CPU on which the current thread is executing; N.B. This should
    be considered advisory only - it is possible that the thread is switched
    to a different CPU at any time. Returns a value in range
    [0, gpr_cpu_num_cores() - 1] */
-int gpr_cpu_current_cpu(void);
+unsigned gpr_cpu_current_cpu(void);
 
 #endif /* __GRPC_INTERNAL_SUPPORT_CPU_H__ */

src/core/support/cpu_linux.c

@@ -75,8 +75,9 @@
 
 #include <grpc/support/log.h>
 
-int gpr_cpu_num_cores(void) {
+unsigned gpr_cpu_num_cores(void) {
   static int ncpus = 0;
+  /* FIXME: !threadsafe */
   if (ncpus == 0) {
     ncpus = sysconf(_SC_NPROCESSORS_ONLN);
     if (ncpus < 1) {
@@ -87,7 +88,7 @@ int gpr_cpu_num_cores(void) {
   return ncpus;
 }
 
-int gpr_cpu_current_cpu(void) {
+unsigned gpr_cpu_current_cpu(void) {
   int cpu = sched_getcpu();
   if (cpu < 0) {
     gpr_log(GPR_ERROR, "Error determining current CPU: %s\n", strerror(errno));

src/core/support/cpu_posix.c

@@ -45,7 +45,7 @@
 
 static __thread char magic_thread_local;
 
-int gpr_cpu_num_cores(void) {
+unsigned gpr_cpu_num_cores(void) {
   static int ncpus = 0;
   if (ncpus == 0) {
     ncpus = sysconf(_SC_NPROCESSORS_ONLN);
@@ -63,7 +63,7 @@ static size_t shard_ptr(const void *info) {
   return ((x >> 4) ^ (x >> 9) ^ (x >> 14)) % gpr_cpu_num_cores();
 }
 
-int gpr_cpu_current_cpu(void) {
+unsigned gpr_cpu_current_cpu(void) {
   /* NOTE: there's no way I know to return the actual cpu index portably...
      most code that's using this is using it to shard across work queues though,
      so here we use thread identity instead to achieve a similar though not

src/core/support/histogram.c

@@ -77,7 +77,6 @@ static size_t bucket_for_unchecked(gpr_histogram *h, double x) {
 /* bounds checked version of the above */
 static size_t bucket_for(gpr_histogram *h, double x) {
   size_t bucket = bucket_for_unchecked(h, GPR_CLAMP(x, 0, h->max_possible));
-  GPR_ASSERT(bucket >= 0);
   GPR_ASSERT(bucket < h->num_buckets);
   return bucket;
 }

src/core/support/slice_buffer.c

@@ -55,7 +55,7 @@ void gpr_slice_buffer_destroy(gpr_slice_buffer *sb) {
   gpr_free(sb->slices);
 }
 
-gpr_uint8 *gpr_slice_buffer_tiny_add(gpr_slice_buffer *sb, int n) {
+gpr_uint8 *gpr_slice_buffer_tiny_add(gpr_slice_buffer *sb, unsigned n) {
   gpr_slice *back;
   gpr_uint8 *out;
 
@@ -64,7 +64,7 @@ gpr_uint8 *gpr_slice_buffer_tiny_add(gpr_slice_buffer *sb, int n) {
   if (sb->count == 0) goto add_new;
   back = &sb->slices[sb->count - 1];
   if (back->refcount) goto add_new;
-  if (back->data.inlined.length + n > sizeof(back->data.inlined.bytes))
+  if ((back->data.inlined.length + n) > sizeof(back->data.inlined.bytes))
     goto add_new;
   out = back->data.inlined.bytes + back->data.inlined.length;
   back->data.inlined.length += n;

src/core/support/string_posix.c

@@ -57,7 +57,7 @@ int gpr_asprintf(char **strp, const char *format, ...) {
   va_start(args, format);
   ret = vsnprintf(buf, sizeof(buf), format, args);
   va_end(args);
-  if (!(0 <= ret && ret < ~(size_t)0)) {
+  if (!(0 <= ret)) {
     *strp = NULL;
     return -1;
   }
@@ -79,7 +79,7 @@ int gpr_asprintf(char **strp, const char *format, ...) {
   va_start(args, format);
   ret = vsnprintf(*strp, strp_buflen, format, args);
   va_end(args);
-  if (ret == strp_buflen - 1) {
+  if ((size_t)ret == strp_buflen - 1) {
     return ret;
   }
 

src/core/support/thd_posix.c

@@ -43,6 +43,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/thd.h>
+#include <grpc/support/useful.h>
 
 struct thd_arg {
   void (*body)(void *arg); /* body of a thread */

src/core/surface/server_chttp2.c

@@ -75,7 +75,7 @@ int grpc_server_add_http2_port(grpc_server *server, const char *addr) {
   grpc_resolved_addresses *resolved = NULL;
   grpc_tcp_server *tcp = NULL;
   size_t i;
-  int count = 0;
+  unsigned count = 0;
   int port_num = -1;
   int port_temp;
 

src/core/tsi/fake_transport_security.c

@@ -38,6 +38,7 @@
 
 #include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
+#include <grpc/support/useful.h>
 #include "src/core/tsi/transport_security.h"
 
 /* --- Constants. ---*/
@@ -412,7 +413,7 @@ static tsi_result fake_handshaker_process_bytes_from_peer(
     tsi_handshaker* self, const unsigned char* bytes, size_t* bytes_size) {
   tsi_result result = TSI_OK;
   tsi_fake_handshaker* impl = (tsi_fake_handshaker*)self;
-  int expected_msg = impl->next_message_to_send - 1;
+  tsi_fake_handshake_message expected_msg = impl->next_message_to_send - 1;
   tsi_fake_handshake_message received_msg;
 
   if (!impl->needs_incoming_message || impl->result == TSI_OK) {

src/core/tsi/ssl_transport_security.c

@@ -37,6 +37,7 @@
 
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
+#include <grpc/support/useful.h>
 #include "src/core/tsi/transport_security.h"
 
 #include <openssl/bio.h>
@@ -565,7 +566,8 @@ static tsi_result build_alpn_protocol_name_list(
     current += alpn_protocols_lengths[i];
   }
   /* Safety check. */
-  if ((current - *protocol_name_list) != *protocol_name_list_length) {
+  if ((current < *protocol_name_list) ||
+      ((gpr_uintptr)(current - *protocol_name_list) != *protocol_name_list_length)) {
     return TSI_INTERNAL_ERROR;
   }
   return TSI_OK;
@@ -1063,7 +1065,8 @@ static int server_handshaker_factory_alpn_callback(
   while ((client_current - in) < inlen) {
     unsigned char client_current_len = *(client_current++);
     const unsigned char* server_current = factory->alpn_protocol_list;
-    while ((server_current - factory->alpn_protocol_list) <
+    while ((server_current >= factory->alpn_protocol_list) &&
+           (gpr_uintptr)(server_current - factory->alpn_protocol_list) <
            factory->alpn_protocol_list_length) {
       unsigned char server_current_len = *(server_current++);
       if ((client_current_len == server_current_len) &&

templates/Makefile.template

@@ -139,7 +139,7 @@ LDFLAGS += $(LDFLAGS_$(CONFIG))
 
 CFLAGS += -std=c89 -pedantic
 CXXFLAGS += -std=c++11
-CPPFLAGS += -g -fPIC -Wall -Wextra -Wno-long-long
+CPPFLAGS += -g -fPIC -Wall -Wextra -Werror -Wno-long-long -Wno-unused-parameter
 LDFLAGS += -g -fPIC
 
 INCLUDES = . include gens

test/core/channel/channel_stack_test.c

@@ -80,7 +80,7 @@ static void test_create_channel_stack(void) {
   const grpc_channel_filter
       filter = {call_func,         channel_func,         sizeof(int),
                 call_init_func,    call_destroy_func,    sizeof(int),
-                channel_init_func, channel_destroy_func, };
+                channel_init_func, channel_destroy_func, "some_test_filter" };
   const grpc_channel_filter *filters = &filter;
   grpc_channel_stack *channel_stack;
   grpc_call_stack *call_stack;

test/core/channel/metadata_buffer_test.c

@@ -112,12 +112,12 @@ static void destroy_channel_elem(grpc_channel_element *elem) {}
 static const grpc_channel_filter top_filter = {
     fail_call_op,      fail_channel_op,     sizeof(size_t),
     init_call_elem,    destroy_call_elem,   sizeof(channel_data),
-    init_channel_elem, destroy_channel_elem};
+    init_channel_elem, destroy_channel_elem, "top_filter" };
 
 static const grpc_channel_filter bottom_filter = {
     expect_call_op,    fail_channel_op,     sizeof(size_t),
     init_call_elem,    destroy_call_elem,   sizeof(channel_data),
-    init_channel_elem, destroy_channel_elem};
+    init_channel_elem, destroy_channel_elem, "bottom_filter" };
 
 static const grpc_channel_filter *filters[2] = {&top_filter, &bottom_filter};
 

test/core/compression/message_compress_test.c

@@ -166,7 +166,7 @@ static void test_bad_data(void) {
 }
 
 int main(int argc, char **argv) {
-  int i, j, k, m;
+  unsigned i, j, k, m;
   grpc_slice_split_mode uncompressed_split_modes[] = {
       GRPC_SLICE_SPLIT_IDENTITY, GRPC_SLICE_SPLIT_ONE_BYTE};
   grpc_slice_split_mode compressed_split_modes[] = {GRPC_SLICE_SPLIT_MERGE_ALL,

test/core/echo/client.c

@@ -66,7 +66,7 @@ int main(int argc, char **argv) {
   grpc_completion_queue *cq = NULL;
   int bytes_written = 0;
   int bytes_read = 0;
-  int i = 0;
+  unsigned i = 0;
   int waiting_finishes;
   gpr_slice read_slice;
 

test/core/echo/server.c

@@ -70,7 +70,7 @@ static void request_call(void) {
 static void assert_read_ok(call_state *s, grpc_byte_buffer *b) {
   grpc_byte_buffer_reader *bb_reader = NULL;
   gpr_slice read_slice;
-  int i;
+  unsigned i;
 
   bb_reader = grpc_byte_buffer_reader_create(b);
   while (grpc_byte_buffer_reader_next(bb_reader, &read_slice)) {

test/core/end2end/tests/cancel_after_accept.c

@@ -149,7 +149,7 @@ static void test_cancel_after_accept(grpc_end2end_test_config config,
 }
 
 void grpc_end2end_tests(grpc_end2end_test_config config) {
-  int i;
+  unsigned i;
 
   for (i = 0; i < GPR_ARRAY_SIZE(cancellation_modes); i++) {
     test_cancel_after_accept(config, cancellation_modes[i]);

test/core/end2end/tests/cancel_after_accept_and_writes_closed.c

@@ -157,7 +157,7 @@ static void test_cancel_after_accept_and_writes_closed(
 }
 
 void grpc_end2end_tests(grpc_end2end_test_config config) {
-  int i;
+  unsigned i;
 
   for (i = 0; i < GPR_ARRAY_SIZE(cancellation_modes); i++) {
     test_cancel_after_accept_and_writes_closed(config, cancellation_modes[i]);

test/core/end2end/tests/cancel_after_invoke.c

@@ -132,7 +132,7 @@ static void test_cancel_after_invoke(grpc_end2end_test_config config,
 }
 
 void grpc_end2end_tests(grpc_end2end_test_config config) {
-  int i;
+  unsigned i;
 
   for (i = 0; i < GPR_ARRAY_SIZE(cancellation_modes); i++) {
     test_cancel_after_invoke(config, cancellation_modes[i]);

test/core/end2end/tests/cancel_in_a_vacuum.c

@@ -122,7 +122,7 @@ static void test_cancel_in_a_vacuum(grpc_end2end_test_config config,
 }
 
 void grpc_end2end_tests(grpc_end2end_test_config config) {
-  int i;
+  unsigned i;
 
   for (i = 0; i < GPR_ARRAY_SIZE(cancellation_modes); i++) {
     test_cancel_in_a_vacuum(config, cancellation_modes[i]);

test/core/fling/client.c

@@ -103,7 +103,7 @@ static const scenario scenarios[] = {
 int main(int argc, char **argv) {
   gpr_slice slice = gpr_slice_from_copied_string("x");
   double start, stop;
-  int i;
+  unsigned i;
 
   char *fake_argv[1];
 

test/core/iomgr/resolve_address_test.c

@@ -85,7 +85,7 @@ static void test_ipv6_with_port(void) {
 static void test_ipv6_without_port(void) {
   const char* const kCases[] = {"2001:db8::1", "2001:db8::1.2.3.4",
                                 "[2001:db8::1]", };
-  int i;
+  unsigned i;
   for (i = 0; i < sizeof(kCases) / sizeof(*kCases); i++) {
     gpr_event ev;
     gpr_event_init(&ev);
@@ -96,7 +96,7 @@ static void test_ipv6_without_port(void) {
 
 static void test_invalid_ip_addresses(void) {
   const char* const kCases[] = {"293.283.1238.3:1", "[2001:db8::11111]:1", };
-  int i;
+  unsigned i;
   for (i = 0; i < sizeof(kCases) / sizeof(*kCases); i++) {
     gpr_event ev;
     gpr_event_init(&ev);
@@ -108,7 +108,7 @@ static void test_invalid_ip_addresses(void) {
 static void test_unparseable_hostports(void) {
   const char* const kCases[] = {"[",         "[::1",        "[::1]bad",
                                 "[1.2.3.4]", "[localhost]", "[localhost]:1", };
-  int i;
+  unsigned i;
   for (i = 0; i < sizeof(kCases) / sizeof(*kCases); i++) {
     gpr_event ev;
     gpr_event_init(&ev);

test/core/iomgr/sockaddr_utils_test.c

@@ -182,7 +182,8 @@ static void expect_sockaddr_str(const char *expected, void *addr,
   gpr_log(GPR_INFO, "  expect_sockaddr_str(%s)", expected);
   result = grpc_sockaddr_to_string(&str, (struct sockaddr *)addr, normalize);
   GPR_ASSERT(str != NULL);
-  GPR_ASSERT(result == strlen(str));
+  GPR_ASSERT(result >= 0);
+  GPR_ASSERT((size_t)result == strlen(str));
   GPR_ASSERT(strcmp(expected, str) == 0);
   gpr_free(str);
 }
@@ -194,7 +195,7 @@ static void test_sockaddr_to_string(void) {
 
   gpr_log(GPR_INFO, "%s", __FUNCTION__);
 
-  errno = 0xDEADBEEF;
+  errno = 0x7EADBEEF;
 
   input4 = make_addr4(kIPv4, sizeof(kIPv4));
   expect_sockaddr_str("192.0.2.1:12345", &input4, 0);
@@ -217,7 +218,7 @@ static void test_sockaddr_to_string(void) {
   expect_sockaddr_str("(sockaddr family=123)", &dummy, 0);
   expect_sockaddr_str("(sockaddr family=123)", &dummy, 1);
 
-  GPR_ASSERT(errno == 0xDEADBEEF);
+  GPR_ASSERT(errno == 0x7EADBEEF);
 }
 
 int main(int argc, char **argv) {

test/core/iomgr/tcp_posix_test.c

@@ -94,7 +94,7 @@ static size_t fill_socket_partial(int fd, size_t bytes) {
   ssize_t write_bytes;
   size_t total_bytes = 0;
   unsigned char *buf = malloc(bytes);
-  int i;
+  unsigned i;
   for (i = 0; i < bytes; ++i) {
     buf[i] = i % 256;
   }
@@ -115,15 +115,14 @@ struct read_socket_state {
   grpc_endpoint *ep;
   gpr_mu mu;
   gpr_cv cv;
-  size_t read_bytes;
+  ssize_t read_bytes;
   ssize_t target_read_bytes;
 };
 
 static ssize_t count_and_unref_slices(gpr_slice *slices, size_t nslices,
                                       int *current_data) {
   ssize_t num_bytes = 0;
-  int i;
-  int j;
+  unsigned i, j;
   unsigned char *buf;
   for (i = 0; i < nslices; ++i) {
     buf = GPR_SLICE_START_PTR(slices[i]);
@@ -254,8 +253,7 @@ static gpr_slice *allocate_blocks(ssize_t num_bytes, ssize_t slice_size,
   ssize_t nslices = num_bytes / slice_size + (num_bytes % slice_size ? 1 : 0);
   gpr_slice *slices = gpr_malloc(sizeof(gpr_slice) * nslices);
   ssize_t num_bytes_left = num_bytes;
-  int i;
-  int j;
+  unsigned i, j;
   unsigned char *buf;
   *num_blocks = nslices;
 

test/core/json/json_rewrite.c

@@ -131,7 +131,7 @@ static void json_reader_string_add_utf32(void* userdata, gpr_uint32 c) {
 }
 
 static gpr_uint32 json_reader_read_char(void* userdata) {
-  gpr_uint32 r;
+  int r;
   json_reader_userdata* state = userdata;
 
   r = fgetc(state->in);

test/core/json/json_rewrite_test.c

@@ -138,7 +138,7 @@ static void json_reader_string_add_utf32(void* userdata, gpr_uint32 c) {
 }
 
 static gpr_uint32 json_reader_read_char(void* userdata) {
-  gpr_uint32 r;
+  int r;
   json_reader_userdata* state = userdata;
 
   if (!state->did_eagain) {
@@ -298,7 +298,7 @@ static test_file test_files[] = {
 };
 
 void test_rewrites() {
-  int i;
+  unsigned i;
 
   for (i = 0; i < GPR_ARRAY_SIZE(test_files); i++) {
     test_file* test = test_files + i;

test/core/json/json_test.c

@@ -124,7 +124,7 @@ static testing_pair testing_pairs[] = {
 };
 
 static void test_pairs() {
-  int i;
+  unsigned i;
 
   for (i = 0; i < GPR_ARRAY_SIZE(testing_pairs); i++) {
     testing_pair* pair = testing_pairs + i;

test/core/security/secure_endpoint_test.c

@@ -59,7 +59,7 @@ static grpc_endpoint_test_fixture secure_endpoint_create_fixture_tcp_socketpair(
     f.client_ep =
         grpc_secure_endpoint_create(fake_read_protector, tcp.client, NULL, 0);
   } else {
-    int i;
+    unsigned i;
     tsi_result result;
     size_t still_pending_size;
     size_t total_buffer_size = 8192;
@@ -81,9 +81,8 @@ static grpc_endpoint_test_fixture secure_endpoint_create_fixture_tcp_socketpair(
         message_bytes += processed_message_size;
         message_size -= processed_message_size;
         cur += protected_buffer_size_to_send;
+        GPR_ASSERT(buffer_size >= protected_buffer_size_to_send);
         buffer_size -= protected_buffer_size_to_send;
-
-        GPR_ASSERT(buffer_size >= 0);
       }
       gpr_slice_unref(plain);
     }
@@ -94,8 +93,8 @@ static grpc_endpoint_test_fixture secure_endpoint_create_fixture_tcp_socketpair(
                                                  &still_pending_size);
       GPR_ASSERT(result == TSI_OK);
       cur += protected_buffer_size_to_send;
+      GPR_ASSERT(buffer_size >= protected_buffer_size_to_send);
       buffer_size -= protected_buffer_size_to_send;
-      GPR_ASSERT(buffer_size >= 0);
     } while (still_pending_size > 0);
     encrypted_leftover = gpr_slice_from_copied_buffer(
         (const char *)encrypted_buffer, total_buffer_size - buffer_size);

test/core/statistics/census_log_tests.c

@@ -415,8 +415,8 @@ void test_read_pending_record(void) {
 /* Tries reading beyond pending write. */
 void test_read_beyond_pending_record(void) {
   /* Start a write. */
-  gpr_int32 incomplete_record_size = 10;
-  gpr_int32 complete_record_size = 20;
+  gpr_uint32 incomplete_record_size = 10;
+  gpr_uint32 complete_record_size = 20;
   size_t bytes_available;
   void* complete_record;
   const void* record_read;
@@ -457,7 +457,7 @@ void test_detached_while_reading(void) {
   size_t bytes_available;
   const void* record_read;
   void* record_written;
-  gpr_int32 block_read = 0;
+  gpr_uint32 block_read = 0;
   printf("Starting test: detached while reading\n");
   setup_test(0);
   /* Start a write. */

test/core/statistics/hash_table_test.c

@@ -190,7 +190,7 @@ static void test_insertion_and_deletion_with_high_collision_rate(void) {
   census_ht* ht = census_ht_create(&opt);
   char key_str[1000][GPR_LTOA_MIN_BUFSIZE];
   gpr_uint64 val = 0;
-  int i = 0;
+  unsigned i = 0;
   for (i = 0; i < 1000; i++) {
     census_ht_key key;
     key.ptr = key_str[i];

test/core/support/host_port_test.c

@@ -43,7 +43,8 @@ static void join_host_port_expect(const char *host, int port,
   char *buf;
   int len;
   len = gpr_join_host_port(&buf, host, port);
-  GPR_ASSERT(strlen(expected) == len);
+  GPR_ASSERT(len >= 0);
+  GPR_ASSERT(strlen(expected) == (size_t)len);
   GPR_ASSERT(strcmp(expected, buf) == 0);
   gpr_free(buf);
 }

test/core/support/slice_test.c

@@ -103,10 +103,10 @@ static void test_slice_new_with_len_returns_something_sensible(void) {
   GPR_ASSERT(do_nothing_with_len_1_calls == 1);
 }
 
-static void test_slice_sub_works(int length) {
+static void test_slice_sub_works(unsigned length) {
   gpr_slice slice;
   gpr_slice sub;
-  int i, j, k;
+  unsigned i, j, k;
 
   LOG_TEST_NAME();
   gpr_log(GPR_INFO, "length=%d", length);
@@ -212,7 +212,7 @@ static void test_slice_from_copied_string_works(void) {
 }
 
 int main(int argc, char **argv) {
-  int length;
+  unsigned length;
   grpc_test_init(argc, argv);
   test_slice_malloc_returns_something_sensible();
   test_slice_new_returns_something_sensible();

test/core/surface/completion_queue_test.c

@@ -214,7 +214,7 @@ static void test_pluck(void) {
   grpc_event *ev;
   grpc_completion_queue *cc;
   void *tags[128];
-  int i, j;
+  unsigned i, j;
   int on_finish_called = 0;
 
   LOG_TEST();

test/core/transport/chttp2/timeout_encoding_test.c

@@ -94,7 +94,7 @@ void decode_suite(char ext, gpr_timespec (*answer)(long x)) {
   long test_vals[] = {1,       12,       123,       1234,     12345,   123456,
                       1234567, 12345678, 123456789, 98765432, 9876543, 987654,
                       98765,   9876,     987,       98,       9};
-  int i;
+  unsigned i;
   char *input;
   for (i = 0; i < GPR_ARRAY_SIZE(test_vals); i++) {
     gpr_asprintf(&input, "%ld%c", test_vals[i], ext);

test/core/transport/stream_op_test.c

@@ -61,7 +61,7 @@ int main(int argc, char **argv) {
   gpr_slice test_slice_3 = gpr_slice_malloc(3);
   gpr_slice test_slice_4 = gpr_slice_malloc(4);
   char x;
-  int i;
+  unsigned i;
 
   grpc_stream_op_buffer buf;
   grpc_stream_op_buffer buf2;

test/core/transport/transport_end2end_tests.c

@@ -913,7 +913,7 @@ static const size_t interesting_message_lengths[] = {1,      100,     10000,
                                                      100000, 1000000, };
 
 void grpc_transport_end2end_tests(grpc_transport_test_config *config) {
-  int i;
+  unsigned i;
 
   g_metadata_context = grpc_mdctx_create();