Merge with master

26 files changed, 312 insertions, 324 deletions

diff --git a/test/core/util/BUILD b/test/core/util/BUILD
index 5844a17728..bc6fe9dd64 100644
--- a/test/core/util/BUILD
+++ b/test/core/util/BUILD
@@ -21,8 +21,8 @@ grpc_package(name = "test/core/util", visibility = "public")
 grpc_cc_library(
     name = "gpr_test_util",
     srcs = [
-        "memory_counters.c",
-        "test_config.c",
+        "memory_counters.cc",
+        "test_config.cc",
     ],
     hdrs = [
         "memory_counters.h",
@@ -48,16 +48,16 @@ grpc_cc_library(
 grpc_cc_library(
     name = "grpc_test_util_base",
     srcs = [
-        "grpc_profiler.c",
-        "mock_endpoint.c",
-        "parse_hexstring.c",
-        "passthru_endpoint.c",
-        "port.c",
-        "port_server_client.c",
-        "reconnect_server.c",
-        "slice_splitter.c",
-        "test_tcp_server.c",
-        "trickle_endpoint.c",
+        "grpc_profiler.cc",
+        "mock_endpoint.cc",
+        "parse_hexstring.cc",
+        "passthru_endpoint.cc",
+        "port.cc",
+        "port_server_client.cc",
+        "reconnect_server.cc",
+        "slice_splitter.cc",
+        "test_tcp_server.cc",
+        "trickle_endpoint.cc",
     ],
     hdrs = [
         "grpc_profiler.h",
@@ -71,7 +71,7 @@ grpc_cc_library(
         "test_tcp_server.h",
         "trickle_endpoint.h",
     ],
-    language = "C",
+    language = "C++",
     deps = [
         ":gpr_test_util",
         "//:grpc_common",
@@ -83,7 +83,7 @@ grpc_cc_library(
     name = "grpc_test_util",
     srcs = [],
     hdrs = [],
-    language = "C",
+    language = "C++",
     deps = [
         ":grpc_test_util_base",
         "//:grpc",
@@ -94,7 +94,7 @@ grpc_cc_library(
     name = "grpc_test_util_unsecure",
     srcs = [],
     hdrs = [],
-    language = "C",
+    language = "C++",
     deps = [
         ":grpc_test_util_base",
         "//:grpc_unsecure",
diff --git a/test/core/util/debugger_macros.cc b/test/core/util/debugger_macros.cc
index 72384f2dd7..d344c3fb74 100644
--- a/test/core/util/debugger_macros.cc
+++ b/test/core/util/debugger_macros.cc
@@ -29,14 +29,14 @@
 #include "src/core/lib/channel/connected_channel.h"
 #include "src/core/lib/surface/call.h"
 
-extern "C" void grpc_summon_debugger_macros() {}
+void grpc_summon_debugger_macros() {}
 
-grpc_stream *grpc_transport_stream_from_call(grpc_call *call) {
-  grpc_call_stack *cs = grpc_call_get_call_stack(call);
+grpc_stream* grpc_transport_stream_from_call(grpc_call* call) {
+  grpc_call_stack* cs = grpc_call_get_call_stack(call);
   for (;;) {
-    grpc_call_element *el = grpc_call_stack_element(cs, cs->count - 1);
+    grpc_call_element* el = grpc_call_stack_element(cs, cs->count - 1);
     if (el->filter == &grpc_client_channel_filter) {
-      grpc_subchannel_call *scc = grpc_client_channel_get_subchannel_call(el);
+      grpc_subchannel_call* scc = grpc_client_channel_get_subchannel_call(el);
       if (scc == NULL) {
         fprintf(stderr, "No subchannel-call");
         return NULL;
@@ -51,6 +51,6 @@ grpc_stream *grpc_transport_stream_from_call(grpc_call *call) {
   }
 }
 
-grpc_chttp2_stream *grpc_chttp2_stream_from_call(grpc_call *call) {
-  return (grpc_chttp2_stream *)grpc_transport_stream_from_call(call);
+grpc_chttp2_stream* grpc_chttp2_stream_from_call(grpc_call* call) {
+  return (grpc_chttp2_stream*)grpc_transport_stream_from_call(call);
 }
diff --git a/test/core/util/debugger_macros.h b/test/core/util/debugger_macros.h
index 24718d9307..c6b3720c5a 100644
--- a/test/core/util/debugger_macros.h
+++ b/test/core/util/debugger_macros.h
@@ -19,14 +19,6 @@
 #ifndef GRPC_TEST_CORE_UTIL_DEBUGGER_MACROS_H
 #define GRPC_TEST_CORE_UTIL_DEBUGGER_MACROS_H
 
-#ifdef __cplusplus
-extern "C" {
-#endif /*  __cplusplus */
-
 void grpc_summon_debugger_macros();
 
-#ifdef __cplusplus
-}
-#endif /*  __cplusplus */
-
 #endif /* GRPC_TEST_CORE_UTIL_DEBUGGER_MACROS_H */
diff --git a/test/core/util/grpc_profiler.c b/test/core/util/grpc_profiler.cc
index 47b0270e29..88f233598b 100644
--- a/test/core/util/grpc_profiler.c
+++ b/test/core/util/grpc_profiler.cc
@@ -21,13 +21,13 @@
 #if GRPC_HAVE_PERFTOOLS
 #include <gperftools/profiler.h>
 
-void grpc_profiler_start(const char *filename) { ProfilerStart(filename); }
+void grpc_profiler_start(const char* filename) { ProfilerStart(filename); }
 
 void grpc_profiler_stop() { ProfilerStop(); }
 #else
 #include <grpc/support/log.h>
 
-void grpc_profiler_start(const char *filename) {
+void grpc_profiler_start(const char* filename) {
   static int printed_warning = 0;
   if (!printed_warning) {
     gpr_log(GPR_DEBUG,
diff --git a/test/core/util/grpc_profiler.h b/test/core/util/grpc_profiler.h
index 8809f55207..f9ddd2242e 100644
--- a/test/core/util/grpc_profiler.h
+++ b/test/core/util/grpc_profiler.h
@@ -19,15 +19,7 @@
 #ifndef GRPC_TEST_CORE_UTIL_GRPC_PROFILER_H
 #define GRPC_TEST_CORE_UTIL_GRPC_PROFILER_H
 
-#ifdef __cplusplus
-extern "C" {
-#endif /*  __cplusplus */
-
-void grpc_profiler_start(const char *filename);
+void grpc_profiler_start(const char* filename);
 void grpc_profiler_stop();
 
-#ifdef __cplusplus
-}
-#endif /*  __cplusplus */
-
 #endif /* GRPC_TEST_CORE_UTIL_GRPC_PROFILER_H */
diff --git a/test/core/util/memory_counters.c b/test/core/util/memory_counters.cc
index 9fb3ffe095..ff85a63803 100644
--- a/test/core/util/memory_counters.c
+++ b/test/core/util/memory_counters.cc
@@ -27,9 +27,9 @@
 static struct grpc_memory_counters g_memory_counters;
 static gpr_allocation_functions g_old_allocs;
 
-static void *guard_malloc(size_t size);
-static void *guard_realloc(void *vptr, size_t size);
-static void guard_free(void *vptr);
+static void* guard_malloc(size_t size);
+static void* guard_realloc(void* vptr, size_t size);
+static void guard_free(void* vptr);
 
 #ifdef GPR_LOW_LEVEL_COUNTERS
 /* hide these from the microbenchmark atomic stats */
@@ -41,20 +41,20 @@ static void guard_free(void *vptr);
 #define NO_BARRIER_LOAD(x) gpr_atm_no_barrier_load(x)
 #endif
 
-static void *guard_malloc(size_t size) {
-  size_t *ptr;
+static void* guard_malloc(size_t size) {
+  size_t* ptr;
   if (!size) return NULL;
   NO_BARRIER_FETCH_ADD(&g_memory_counters.total_size_absolute, (gpr_atm)size);
   NO_BARRIER_FETCH_ADD(&g_memory_counters.total_size_relative, (gpr_atm)size);
   NO_BARRIER_FETCH_ADD(&g_memory_counters.total_allocs_absolute, (gpr_atm)1);
   NO_BARRIER_FETCH_ADD(&g_memory_counters.total_allocs_relative, (gpr_atm)1);
-  ptr = (size_t *)g_old_allocs.malloc_fn(size + sizeof(size));
+  ptr = (size_t*)g_old_allocs.malloc_fn(size + sizeof(size));
   *ptr++ = size;
   return ptr;
 }
 
-static void *guard_realloc(void *vptr, size_t size) {
-  size_t *ptr = (size_t *)vptr;
+static void* guard_realloc(void* vptr, size_t size) {
+  size_t* ptr = (size_t*)vptr;
   if (vptr == NULL) {
     return guard_malloc(size);
   }
@@ -67,13 +67,13 @@ static void *guard_realloc(void *vptr, size_t size) {
   NO_BARRIER_FETCH_ADD(&g_memory_counters.total_size_relative, -(gpr_atm)*ptr);
   NO_BARRIER_FETCH_ADD(&g_memory_counters.total_size_relative, (gpr_atm)size);
   NO_BARRIER_FETCH_ADD(&g_memory_counters.total_allocs_absolute, (gpr_atm)1);
-  ptr = (size_t *)g_old_allocs.realloc_fn(ptr, size + sizeof(size));
+  ptr = (size_t*)g_old_allocs.realloc_fn(ptr, size + sizeof(size));
   *ptr++ = size;
   return ptr;
 }
 
-static void guard_free(void *vptr) {
-  size_t *ptr = (size_t *)vptr;
+static void guard_free(void* vptr) {
+  size_t* ptr = (size_t*)vptr;
   if (!vptr) return;
   --ptr;
   NO_BARRIER_FETCH_ADD(&g_memory_counters.total_size_relative, -(gpr_atm)*ptr);
diff --git a/test/core/util/mock_endpoint.cc b/test/core/util/mock_endpoint.cc
index b7017057b0..fd9e82c30b 100644
--- a/test/core/util/mock_endpoint.cc
+++ b/test/core/util/mock_endpoint.cc
@@ -35,14 +35,14 @@ typedef struct grpc_mock_endpoint {
   gpr_mu mu;
   void (*on_write)(grpc_slice slice);
   grpc_slice_buffer read_buffer;
-  grpc_slice_buffer *on_read_out;
-  grpc_closure *on_read;
-  grpc_resource_user *resource_user;
+  grpc_slice_buffer* on_read_out;
+  grpc_closure* on_read;
+  grpc_resource_user* resource_user;
 } grpc_mock_endpoint;
 
-static void me_read(grpc_endpoint *ep, grpc_slice_buffer *slices,
-                    grpc_closure *cb) {
-  grpc_mock_endpoint *m = (grpc_mock_endpoint *)ep;
+static void me_read(grpc_endpoint* ep, grpc_slice_buffer* slices,
+                    grpc_closure* cb) {
+  grpc_mock_endpoint* m = (grpc_mock_endpoint*)ep;
   gpr_mu_lock(&m->mu);
   if (m->read_buffer.count > 0) {
     grpc_slice_buffer_swap(&m->read_buffer, slices);
@@ -54,22 +54,25 @@ static void me_read(grpc_endpoint *ep, grpc_slice_buffer *slices,
   gpr_mu_unlock(&m->mu);
 }
 
-static void me_write(grpc_endpoint *ep, grpc_slice_buffer *slices,
-                     grpc_closure *cb) {
-  grpc_mock_endpoint *m = (grpc_mock_endpoint *)ep;
+static void me_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
+                     grpc_closure* cb) {
+  grpc_mock_endpoint* m = (grpc_mock_endpoint*)ep;
   for (size_t i = 0; i < slices->count; i++) {
     m->on_write(slices->slices[i]);
   }
   GRPC_CLOSURE_SCHED(cb, GRPC_ERROR_NONE);
 }
 
-static void me_add_to_pollset(grpc_endpoint *ep, grpc_pollset *pollset) {}
+static void me_add_to_pollset(grpc_endpoint* ep, grpc_pollset* pollset) {}
 
-static void me_add_to_pollset_set(grpc_endpoint *ep,
-                                  grpc_pollset_set *pollset) {}
+static void me_add_to_pollset_set(grpc_endpoint* ep,
+                                  grpc_pollset_set* pollset) {}
 
-static void me_shutdown(grpc_endpoint *ep, grpc_error *why) {
-  grpc_mock_endpoint *m = (grpc_mock_endpoint *)ep;
+static void me_delete_from_pollset_set(grpc_endpoint* ep,
+                                       grpc_pollset_set* pollset) {}
+
+static void me_shutdown(grpc_endpoint* ep, grpc_error* why) {
+  grpc_mock_endpoint* m = (grpc_mock_endpoint*)ep;
   gpr_mu_lock(&m->mu);
   if (m->on_read) {
     GRPC_CLOSURE_SCHED(m->on_read,
@@ -82,35 +85,42 @@ static void me_shutdown(grpc_endpoint *ep, grpc_error *why) {
   GRPC_ERROR_UNREF(why);
 }
 
-static void me_destroy(grpc_endpoint *ep) {
-  grpc_mock_endpoint *m = (grpc_mock_endpoint *)ep;
+static void me_destroy(grpc_endpoint* ep) {
+  grpc_mock_endpoint* m = (grpc_mock_endpoint*)ep;
   grpc_slice_buffer_destroy(&m->read_buffer);
   grpc_resource_user_unref(m->resource_user);
   gpr_free(m);
 }
 
-static char *me_get_peer(grpc_endpoint *ep) {
+static char* me_get_peer(grpc_endpoint* ep) {
   return gpr_strdup("fake:mock_endpoint");
 }
 
-static grpc_resource_user *me_get_resource_user(grpc_endpoint *ep) {
-  grpc_mock_endpoint *m = (grpc_mock_endpoint *)ep;
+static grpc_resource_user* me_get_resource_user(grpc_endpoint* ep) {
+  grpc_mock_endpoint* m = (grpc_mock_endpoint*)ep;
   return m->resource_user;
 }
 
-static int me_get_fd(grpc_endpoint *ep) { return -1; }
+static int me_get_fd(grpc_endpoint* ep) { return -1; }
 
 static const grpc_endpoint_vtable vtable = {
-    me_read,     me_write,   me_add_to_pollset,    me_add_to_pollset_set,
-    me_shutdown, me_destroy, me_get_resource_user, me_get_peer,
+    me_read,
+    me_write,
+    me_add_to_pollset,
+    me_add_to_pollset_set,
+    me_delete_from_pollset_set,
+    me_shutdown,
+    me_destroy,
+    me_get_resource_user,
+    me_get_peer,
     me_get_fd,
 };
 
-grpc_endpoint *grpc_mock_endpoint_create(void (*on_write)(grpc_slice slice),
-                                         grpc_resource_quota *resource_quota) {
-  grpc_mock_endpoint *m = (grpc_mock_endpoint *)gpr_malloc(sizeof(*m));
+grpc_endpoint* grpc_mock_endpoint_create(void (*on_write)(grpc_slice slice),
+                                         grpc_resource_quota* resource_quota) {
+  grpc_mock_endpoint* m = (grpc_mock_endpoint*)gpr_malloc(sizeof(*m));
   m->base.vtable = &vtable;
-  char *name;
+  char* name;
   gpr_asprintf(&name, "mock_endpoint_%" PRIxPTR, (intptr_t)m);
   m->resource_user = grpc_resource_user_create(resource_quota, name);
   gpr_free(name);
@@ -121,8 +131,8 @@ grpc_endpoint *grpc_mock_endpoint_create(void (*on_write)(grpc_slice slice),
   return &m->base;
 }
 
-void grpc_mock_endpoint_put_read(grpc_endpoint *ep, grpc_slice slice) {
-  grpc_mock_endpoint *m = (grpc_mock_endpoint *)ep;
+void grpc_mock_endpoint_put_read(grpc_endpoint* ep, grpc_slice slice) {
+  grpc_mock_endpoint* m = (grpc_mock_endpoint*)ep;
   gpr_mu_lock(&m->mu);
   if (m->on_read != NULL) {
     grpc_slice_buffer_add(m->on_read_out, slice);
diff --git a/test/core/util/mock_endpoint.h b/test/core/util/mock_endpoint.h
index b59d67733b..6521d3e8e8 100644
--- a/test/core/util/mock_endpoint.h
+++ b/test/core/util/mock_endpoint.h
@@ -21,9 +21,9 @@
 
 #include "src/core/lib/iomgr/endpoint.h"
 
-grpc_endpoint *grpc_mock_endpoint_create(void (*on_write)(grpc_slice slice),
-                                         grpc_resource_quota *resource_quota);
-void grpc_mock_endpoint_put_read(grpc_endpoint *mock_endpoint,
+grpc_endpoint* grpc_mock_endpoint_create(void (*on_write)(grpc_slice slice),
+                                         grpc_resource_quota* resource_quota);
+void grpc_mock_endpoint_put_read(grpc_endpoint* mock_endpoint,
                                  grpc_slice slice);
 
 #endif
diff --git a/test/core/util/one_corpus_entry_fuzzer.c b/test/core/util/one_corpus_entry_fuzzer.cc
index 42467390f2..c0b67da1e2 100644
--- a/test/core/util/one_corpus_entry_fuzzer.c
+++ b/test/core/util/one_corpus_entry_fuzzer.cc
@@ -21,12 +21,12 @@
 #include <grpc/support/log.h>
 #include "src/core/lib/iomgr/load_file.h"
 
-extern int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size);
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size);
 
 extern bool squelch;
 extern bool leak_check;
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_slice buffer;
   squelch = false;
   leak_check = false;
diff --git a/test/core/util/parse_hexstring.c b/test/core/util/parse_hexstring.cc
index 346b871b67..6dee0f163a 100644
--- a/test/core/util/parse_hexstring.c
+++ b/test/core/util/parse_hexstring.cc
@@ -19,10 +19,10 @@
 #include "test/core/util/parse_hexstring.h"
 #include <grpc/support/log.h>
 
-grpc_slice parse_hexstring(const char *hexstring) {
+grpc_slice parse_hexstring(const char* hexstring) {
   size_t nibbles = 0;
-  const char *p = 0;
-  uint8_t *out;
+  const char* p = 0;
+  uint8_t* out;
   uint8_t temp;
   grpc_slice slice;
 
diff --git a/test/core/util/parse_hexstring.h b/test/core/util/parse_hexstring.h
index deab747dd1..b7d54c1711 100644
--- a/test/core/util/parse_hexstring.h
+++ b/test/core/util/parse_hexstring.h
@@ -21,6 +21,6 @@
 
 #include <grpc/slice.h>
 
-grpc_slice parse_hexstring(const char *hexstring);
+grpc_slice parse_hexstring(const char* hexstring);
 
 #endif /* GRPC_TEST_CORE_UTIL_PARSE_HEXSTRING_H */
diff --git a/test/core/util/passthru_endpoint.cc b/test/core/util/passthru_endpoint.cc
index 4fcae991eb..bb8cbb62bf 100644
--- a/test/core/util/passthru_endpoint.cc
+++ b/test/core/util/passthru_endpoint.cc
@@ -37,17 +37,17 @@ typedef struct passthru_endpoint passthru_endpoint;
 
 typedef struct {
   grpc_endpoint base;
-  passthru_endpoint *parent;
+  passthru_endpoint* parent;
   grpc_slice_buffer read_buffer;
-  grpc_slice_buffer *on_read_out;
-  grpc_closure *on_read;
-  grpc_resource_user *resource_user;
+  grpc_slice_buffer* on_read_out;
+  grpc_closure* on_read;
+  grpc_resource_user* resource_user;
 } half;
 
 struct passthru_endpoint {
   gpr_mu mu;
   int halves;
-  grpc_passthru_endpoint_stats *stats;
+  grpc_passthru_endpoint_stats* stats;
   grpc_passthru_endpoint_stats
       dummy_stats;  // used if constructor stats == NULL
   bool shutdown;
@@ -55,9 +55,9 @@ struct passthru_endpoint {
   half server;
 };
 
-static void me_read(grpc_endpoint *ep, grpc_slice_buffer *slices,
-                    grpc_closure *cb) {
-  half *m = (half *)ep;
+static void me_read(grpc_endpoint* ep, grpc_slice_buffer* slices,
+                    grpc_closure* cb) {
+  half* m = (half*)ep;
   gpr_mu_lock(&m->parent->mu);
   if (m->parent->shutdown) {
     GRPC_CLOSURE_SCHED(
@@ -72,17 +72,17 @@ static void me_read(grpc_endpoint *ep, grpc_slice_buffer *slices,
   gpr_mu_unlock(&m->parent->mu);
 }
 
-static half *other_half(half *h) {
+static half* other_half(half* h) {
   if (h == &h->parent->client) return &h->parent->server;
   return &h->parent->client;
 }
 
-static void me_write(grpc_endpoint *ep, grpc_slice_buffer *slices,
-                     grpc_closure *cb) {
-  half *m = other_half((half *)ep);
+static void me_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
+                     grpc_closure* cb) {
+  half* m = other_half((half*)ep);
   gpr_mu_lock(&m->parent->mu);
-  grpc_error *error = GRPC_ERROR_NONE;
-  m->parent->stats->num_writes++;
+  grpc_error* error = GRPC_ERROR_NONE;
+  gpr_atm_no_barrier_fetch_add(&m->parent->stats->num_writes, (gpr_atm)1);
   if (m->parent->shutdown) {
     error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Endpoint already shutdown");
   } else if (m->on_read != NULL) {
@@ -101,13 +101,16 @@ static void me_write(grpc_endpoint *ep, grpc_slice_buffer *slices,
   GRPC_CLOSURE_SCHED(cb, error);
 }
 
-static void me_add_to_pollset(grpc_endpoint *ep, grpc_pollset *pollset) {}
+static void me_add_to_pollset(grpc_endpoint* ep, grpc_pollset* pollset) {}
 
-static void me_add_to_pollset_set(grpc_endpoint *ep,
-                                  grpc_pollset_set *pollset) {}
+static void me_add_to_pollset_set(grpc_endpoint* ep,
+                                  grpc_pollset_set* pollset) {}
 
-static void me_shutdown(grpc_endpoint *ep, grpc_error *why) {
-  half *m = (half *)ep;
+static void me_delete_from_pollset_set(grpc_endpoint* ep,
+                                       grpc_pollset_set* pollset) {}
+
+static void me_shutdown(grpc_endpoint* ep, grpc_error* why) {
+  half* m = (half*)ep;
   gpr_mu_lock(&m->parent->mu);
   m->parent->shutdown = true;
   if (m->on_read) {
@@ -128,8 +131,8 @@ static void me_shutdown(grpc_endpoint *ep, grpc_error *why) {
   GRPC_ERROR_UNREF(why);
 }
 
-static void me_destroy(grpc_endpoint *ep) {
-  passthru_endpoint *p = ((half *)ep)->parent;
+static void me_destroy(grpc_endpoint* ep) {
+  passthru_endpoint* p = ((half*)ep)->parent;
   gpr_mu_lock(&p->mu);
   if (0 == --p->halves) {
     gpr_mu_unlock(&p->mu);
@@ -144,44 +147,51 @@ static void me_destroy(grpc_endpoint *ep) {
   }
 }
 
-static char *me_get_peer(grpc_endpoint *ep) {
-  passthru_endpoint *p = ((half *)ep)->parent;
-  return ((half *)ep) == &p->client ? gpr_strdup("fake:mock_client_endpoint")
-                                    : gpr_strdup("fake:mock_server_endpoint");
+static char* me_get_peer(grpc_endpoint* ep) {
+  passthru_endpoint* p = ((half*)ep)->parent;
+  return ((half*)ep) == &p->client ? gpr_strdup("fake:mock_client_endpoint")
+                                   : gpr_strdup("fake:mock_server_endpoint");
 }
 
-static int me_get_fd(grpc_endpoint *ep) { return -1; }
+static int me_get_fd(grpc_endpoint* ep) { return -1; }
 
-static grpc_resource_user *me_get_resource_user(grpc_endpoint *ep) {
-  half *m = (half *)ep;
+static grpc_resource_user* me_get_resource_user(grpc_endpoint* ep) {
+  half* m = (half*)ep;
   return m->resource_user;
 }
 
 static const grpc_endpoint_vtable vtable = {
-    me_read,     me_write,   me_add_to_pollset,    me_add_to_pollset_set,
-    me_shutdown, me_destroy, me_get_resource_user, me_get_peer,
+    me_read,
+    me_write,
+    me_add_to_pollset,
+    me_add_to_pollset_set,
+    me_delete_from_pollset_set,
+    me_shutdown,
+    me_destroy,
+    me_get_resource_user,
+    me_get_peer,
     me_get_fd,
 };
 
-static void half_init(half *m, passthru_endpoint *parent,
-                      grpc_resource_quota *resource_quota,
-                      const char *half_name) {
+static void half_init(half* m, passthru_endpoint* parent,
+                      grpc_resource_quota* resource_quota,
+                      const char* half_name) {
   m->base.vtable = &vtable;
   m->parent = parent;
   grpc_slice_buffer_init(&m->read_buffer);
   m->on_read = NULL;
-  char *name;
+  char* name;
   gpr_asprintf(&name, "passthru_endpoint_%s_%" PRIxPTR, half_name,
                (intptr_t)parent);
   m->resource_user = grpc_resource_user_create(resource_quota, name);
   gpr_free(name);
 }
 
-void grpc_passthru_endpoint_create(grpc_endpoint **client,
-                                   grpc_endpoint **server,
-                                   grpc_resource_quota *resource_quota,
-                                   grpc_passthru_endpoint_stats *stats) {
-  passthru_endpoint *m = (passthru_endpoint *)gpr_malloc(sizeof(*m));
+void grpc_passthru_endpoint_create(grpc_endpoint** client,
+                                   grpc_endpoint** server,
+                                   grpc_resource_quota* resource_quota,
+                                   grpc_passthru_endpoint_stats* stats) {
+  passthru_endpoint* m = (passthru_endpoint*)gpr_malloc(sizeof(*m));
   m->halves = 2;
   m->shutdown = 0;
   m->stats = stats == NULL ? &m->dummy_stats : stats;
diff --git a/test/core/util/passthru_endpoint.h b/test/core/util/passthru_endpoint.h
index 6d28c2cbcd..bddd8ea6a2 100644
--- a/test/core/util/passthru_endpoint.h
+++ b/test/core/util/passthru_endpoint.h
@@ -19,21 +19,17 @@
 #ifndef MOCK_ENDPOINT_H
 #define MOCK_ENDPOINT_H
 
-#include "src/core/lib/iomgr/endpoint.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
+#include <grpc/support/atm.h>
 
-typedef struct { int num_writes; } grpc_passthru_endpoint_stats;
+#include "src/core/lib/iomgr/endpoint.h"
 
-void grpc_passthru_endpoint_create(grpc_endpoint **client,
-                                   grpc_endpoint **server,
-                                   grpc_resource_quota *resource_quota,
-                                   grpc_passthru_endpoint_stats *stats);
+typedef struct {
+  gpr_atm num_writes;
+} grpc_passthru_endpoint_stats;
 
-#ifdef __cplusplus
-}
-#endif
+void grpc_passthru_endpoint_create(grpc_endpoint** client,
+                                   grpc_endpoint** server,
+                                   grpc_resource_quota* resource_quota,
+                                   grpc_passthru_endpoint_stats* stats);
 
 #endif
diff --git a/test/core/util/port.cc b/test/core/util/port.cc
index 61f2e5018f..c5bebe08e7 100644
--- a/test/core/util/port.cc
+++ b/test/core/util/port.cc
@@ -36,7 +36,7 @@
 #include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "test/core/util/port_server_client.h"
 
-static int *chosen_ports = NULL;
+static int* chosen_ports = NULL;
 static size_t num_chosen_ports = 0;
 
 static int free_chosen_port(int port) {
@@ -76,7 +76,7 @@ static void chose_port(int port) {
   }
   num_chosen_ports++;
   chosen_ports =
-      (int *)gpr_realloc(chosen_ports, sizeof(int) * num_chosen_ports);
+      (int*)gpr_realloc(chosen_ports, sizeof(int) * num_chosen_ports);
   chosen_ports[num_chosen_ports - 1] = port;
 }
 
diff --git a/test/core/util/port_server_client.cc b/test/core/util/port_server_client.cc
index 253a1df29e..2cabd560ee 100644
--- a/test/core/util/port_server_client.cc
+++ b/test/core/util/port_server_client.cc
@@ -35,19 +35,19 @@
 #include "src/core/lib/http/httpcli.h"
 
 typedef struct freereq {
-  gpr_mu *mu;
+  gpr_mu* mu;
   grpc_polling_entity pops;
   int done;
 } freereq;
 
-static void destroy_pops_and_shutdown(void *p, grpc_error *error) {
-  grpc_pollset *pollset = grpc_polling_entity_pollset((grpc_polling_entity *)p);
+static void destroy_pops_and_shutdown(void* p, grpc_error* error) {
+  grpc_pollset* pollset = grpc_polling_entity_pollset((grpc_polling_entity*)p);
   grpc_pollset_destroy(pollset);
   gpr_free(pollset);
 }
 
-static void freed_port_from_server(void *arg, grpc_error *error) {
-  freereq *pr = (freereq *)arg;
+static void freed_port_from_server(void* arg, grpc_error* error) {
+  freereq* pr = (freereq*)arg;
   gpr_mu_lock(pr->mu);
   pr->done = 1;
   GRPC_LOG_IF_ERROR(
@@ -61,9 +61,9 @@ void grpc_free_port_using_server(int port) {
   grpc_httpcli_request req;
   grpc_httpcli_response rsp;
   freereq pr;
-  char *path;
+  char* path;
   ExecCtx _local_exec_ctx;
-  grpc_closure *shutdown_closure;
+  grpc_closure* shutdown_closure;
 
   grpc_init();
 
@@ -71,18 +71,18 @@ void grpc_free_port_using_server(int port) {
   memset(&req, 0, sizeof(req));
   memset(&rsp, 0, sizeof(rsp));
 
-  grpc_pollset *pollset = (grpc_pollset *)gpr_zalloc(grpc_pollset_size());
+  grpc_pollset* pollset = (grpc_pollset*)gpr_zalloc(grpc_pollset_size());
   grpc_pollset_init(pollset, &pr.mu);
   pr.pops = grpc_polling_entity_create_from_pollset(pollset);
   shutdown_closure = GRPC_CLOSURE_CREATE(destroy_pops_and_shutdown, &pr.pops,
                                          grpc_schedule_on_exec_ctx);
 
-  req.host = (char *)GRPC_PORT_SERVER_ADDRESS;
+  req.host = const_cast<char*>(GRPC_PORT_SERVER_ADDRESS);
   gpr_asprintf(&path, "/drop/%d", port);
   req.http.path = path;
 
   grpc_httpcli_context_init(&context);
-  grpc_resource_quota *resource_quota =
+  grpc_resource_quota* resource_quota =
       grpc_resource_quota_create("port_server_client/free");
   grpc_httpcli_get(&context, &pr.pops, resource_quota, &req,
                    grpc_exec_ctx_now() + 30 * GPR_MS_PER_SEC,
@@ -93,7 +93,7 @@ void grpc_free_port_using_server(int port) {
   grpc_exec_ctx_flush();
   gpr_mu_lock(pr.mu);
   while (!pr.done) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = NULL;
     if (!GRPC_LOG_IF_ERROR(
             "pollset_work",
             grpc_pollset_work(grpc_polling_entity_pollset(&pr.pops), &worker,
@@ -114,25 +114,25 @@ void grpc_free_port_using_server(int port) {
 }
 
 typedef struct portreq {
-  gpr_mu *mu;
+  gpr_mu* mu;
   grpc_polling_entity pops;
   int port;
   int retries;
-  char *server;
-  grpc_httpcli_context *ctx;
+  char* server;
+  grpc_httpcli_context* ctx;
   grpc_httpcli_response response;
 } portreq;
 
-static void got_port_from_server(void *arg, grpc_error *error) {
+static void got_port_from_server(void* arg, grpc_error* error) {
   size_t i;
   int port = 0;
-  portreq *pr = (portreq *)arg;
+  portreq* pr = (portreq*)arg;
   int failed = 0;
-  grpc_httpcli_response *response = &pr->response;
+  grpc_httpcli_response* response = &pr->response;
 
   if (error != GRPC_ERROR_NONE) {
     failed = 1;
-    const char *msg = grpc_error_string(error);
+    const char* msg = grpc_error_string(error);
     gpr_log(GPR_DEBUG, "failed port pick from server: retrying [%s]", msg);
 
   } else if (response->status != 200) {
@@ -161,10 +161,10 @@ static void got_port_from_server(void *arg, grpc_error *error) {
             GPR_TIMESPAN)));
     pr->retries++;
     req.host = pr->server;
-    req.http.path = (char *)"/get";
+    req.http.path = const_cast<char*>("/get");
     grpc_http_response_destroy(&pr->response);
     memset(&pr->response, 0, sizeof(pr->response));
-    grpc_resource_quota *resource_quota =
+    grpc_resource_quota* resource_quota =
         grpc_resource_quota_create("port_server_client/pick_retry");
     grpc_httpcli_get(pr->ctx, &pr->pops, resource_quota, &req,
                      grpc_exec_ctx_now() + 30 * GPR_MS_PER_SEC,
@@ -194,26 +194,26 @@ int grpc_pick_port_using_server(void) {
   grpc_httpcli_request req;
   portreq pr;
   ExecCtx _local_exec_ctx;
-  grpc_closure *shutdown_closure;
+  grpc_closure* shutdown_closure;
 
   grpc_init();
 
   memset(&pr, 0, sizeof(pr));
   memset(&req, 0, sizeof(req));
-  grpc_pollset *pollset = (grpc_pollset *)gpr_zalloc(grpc_pollset_size());
+  grpc_pollset* pollset = (grpc_pollset*)gpr_zalloc(grpc_pollset_size());
   grpc_pollset_init(pollset, &pr.mu);
   pr.pops = grpc_polling_entity_create_from_pollset(pollset);
   shutdown_closure = GRPC_CLOSURE_CREATE(destroy_pops_and_shutdown, &pr.pops,
                                          grpc_schedule_on_exec_ctx);
   pr.port = -1;
-  pr.server = (char *)GRPC_PORT_SERVER_ADDRESS;
+  pr.server = const_cast<char*>(GRPC_PORT_SERVER_ADDRESS);
   pr.ctx = &context;
 
-  req.host = (char *)GRPC_PORT_SERVER_ADDRESS;
-  req.http.path = (char *)"/get";
+  req.host = const_cast<char*>(GRPC_PORT_SERVER_ADDRESS);
+  req.http.path = const_cast<char*>("/get");
 
   grpc_httpcli_context_init(&context);
-  grpc_resource_quota *resource_quota =
+  grpc_resource_quota* resource_quota =
       grpc_resource_quota_create("port_server_client/pick");
   grpc_httpcli_get(
       &context, &pr.pops, resource_quota, &req,
@@ -224,7 +224,7 @@ int grpc_pick_port_using_server(void) {
   grpc_exec_ctx_flush();
   gpr_mu_lock(pr.mu);
   while (pr.port == -1) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = NULL;
     if (!GRPC_LOG_IF_ERROR(
             "pollset_work",
             grpc_pollset_work(grpc_polling_entity_pollset(&pr.pops), &worker,
diff --git a/test/core/util/port_server_client.h b/test/core/util/port_server_client.h
index a88026ebe8..86dd7018ff 100644
--- a/test/core/util/port_server_client.h
+++ b/test/core/util/port_server_client.h
@@ -24,15 +24,7 @@
 // must be synchronized with tools/run_tests/python_utils/start_port_server.py
 #define GRPC_PORT_SERVER_ADDRESS "localhost:32766"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 int grpc_pick_port_using_server(void);
 void grpc_free_port_using_server(int port);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif  // GRPC_TEST_CORE_UTIL_PORT_SERVER_CLIENT_H
diff --git a/test/core/util/reconnect_server.c b/test/core/util/reconnect_server.cc
index ef4b5e01cd..0e4145831c 100644
--- a/test/core/util/reconnect_server.c
+++ b/test/core/util/reconnect_server.cc
@@ -31,11 +31,11 @@
 #include "test/core/util/port.h"
 #include "test/core/util/test_tcp_server.h"
 
-static void pretty_print_backoffs(reconnect_server *server) {
+static void pretty_print_backoffs(reconnect_server* server) {
   gpr_timespec diff;
   int i = 1;
   double expected_backoff = 1000.0, backoff;
-  timestamp_list *head = server->head;
+  timestamp_list* head = server->head;
   gpr_log(GPR_INFO, "reconnect server: new connection");
   for (head = server->head; head && head->next; head = head->next, i++) {
     diff = gpr_time_sub(head->next->timestamp, head->timestamp);
@@ -55,15 +55,15 @@ static void pretty_print_backoffs(reconnect_server *server) {
   }
 }
 
-static void on_connect(void *arg, grpc_endpoint *tcp,
-                       grpc_pollset *accepting_pollset,
-                       grpc_tcp_server_acceptor *acceptor) {
+static void on_connect(void* arg, grpc_endpoint* tcp,
+                       grpc_pollset* accepting_pollset,
+                       grpc_tcp_server_acceptor* acceptor) {
   gpr_free(acceptor);
-  char *peer;
-  char *last_colon;
-  reconnect_server *server = (reconnect_server *)arg;
+  char* peer;
+  char* last_colon;
+  reconnect_server* server = (reconnect_server*)arg;
   gpr_timespec now = gpr_now(GPR_CLOCK_REALTIME);
-  timestamp_list *new_tail;
+  timestamp_list* new_tail;
   peer = grpc_endpoint_get_peer(tcp);
   grpc_endpoint_shutdown(tcp,
                          GRPC_ERROR_CREATE_FROM_STATIC_STRING("Connected"));
@@ -82,7 +82,7 @@ static void on_connect(void *arg, grpc_endpoint *tcp,
       gpr_free(peer);
     }
   }
-  new_tail = gpr_malloc(sizeof(timestamp_list));
+  new_tail = static_cast<timestamp_list*>(gpr_malloc(sizeof(timestamp_list)));
   new_tail->timestamp = now;
   new_tail->next = NULL;
   if (server->tail == NULL) {
@@ -95,7 +95,7 @@ static void on_connect(void *arg, grpc_endpoint *tcp,
   pretty_print_backoffs(server);
 }
 
-void reconnect_server_init(reconnect_server *server) {
+void reconnect_server_init(reconnect_server* server) {
   test_tcp_server_init(&server->tcp_server, on_connect, server);
   server->head = NULL;
   server->tail = NULL;
@@ -103,16 +103,16 @@ void reconnect_server_init(reconnect_server *server) {
   server->max_reconnect_backoff_ms = 0;
 }
 
-void reconnect_server_start(reconnect_server *server, int port) {
+void reconnect_server_start(reconnect_server* server, int port) {
   test_tcp_server_start(&server->tcp_server, port);
 }
 
-void reconnect_server_poll(reconnect_server *server, int seconds) {
+void reconnect_server_poll(reconnect_server* server, int seconds) {
   test_tcp_server_poll(&server->tcp_server, seconds);
 }
 
-void reconnect_server_clear_timestamps(reconnect_server *server) {
-  timestamp_list *new_head = server->head;
+void reconnect_server_clear_timestamps(reconnect_server* server) {
+  timestamp_list* new_head = server->head;
   while (server->head) {
     new_head = server->head->next;
     gpr_free(server->head);
@@ -123,7 +123,7 @@ void reconnect_server_clear_timestamps(reconnect_server *server) {
   server->peer = NULL;
 }
 
-void reconnect_server_destroy(reconnect_server *server) {
+void reconnect_server_destroy(reconnect_server* server) {
   reconnect_server_clear_timestamps(server);
   test_tcp_server_destroy(&server->tcp_server);
 }
diff --git a/test/core/util/reconnect_server.h b/test/core/util/reconnect_server.h
index 38db729108..d15abe529d 100644
--- a/test/core/util/reconnect_server.h
+++ b/test/core/util/reconnect_server.h
@@ -23,31 +23,23 @@
 #include <grpc/support/time.h>
 #include "test/core/util/test_tcp_server.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 typedef struct timestamp_list {
   gpr_timespec timestamp;
-  struct timestamp_list *next;
+  struct timestamp_list* next;
 } timestamp_list;
 
 typedef struct reconnect_server {
   test_tcp_server tcp_server;
-  timestamp_list *head;
-  timestamp_list *tail;
-  char *peer;
+  timestamp_list* head;
+  timestamp_list* tail;
+  char* peer;
   int max_reconnect_backoff_ms;
 } reconnect_server;
 
-void reconnect_server_init(reconnect_server *server);
-void reconnect_server_start(reconnect_server *server, int port);
-void reconnect_server_poll(reconnect_server *server, int seconds);
-void reconnect_server_destroy(reconnect_server *server);
-void reconnect_server_clear_timestamps(reconnect_server *server);
-
-#ifdef __cplusplus
-}
-#endif
+void reconnect_server_init(reconnect_server* server);
+void reconnect_server_start(reconnect_server* server, int port);
+void reconnect_server_poll(reconnect_server* server, int seconds);
+void reconnect_server_destroy(reconnect_server* server);
+void reconnect_server_clear_timestamps(reconnect_server* server);
 
 #endif /* GRPC_TEST_CORE_UTIL_RECONNECT_SERVER_H */
diff --git a/test/core/util/slice_splitter.c b/test/core/util/slice_splitter.cc
index 6fcef9acce..e25e1d862a 100644
--- a/test/core/util/slice_splitter.c
+++ b/test/core/util/slice_splitter.cc
@@ -23,7 +23,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/useful.h>
 
-const char *grpc_slice_split_mode_name(grpc_slice_split_mode mode) {
+const char* grpc_slice_split_mode_name(grpc_slice_split_mode mode) {
   switch (mode) {
     case GRPC_SLICE_SPLIT_IDENTITY:
       return "identity";
@@ -35,9 +35,9 @@ const char *grpc_slice_split_mode_name(grpc_slice_split_mode mode) {
   return "error";
 }
 
-void grpc_split_slices(grpc_slice_split_mode mode, grpc_slice *src_slices,
-                       size_t src_slice_count, grpc_slice **dst_slices,
-                       size_t *dst_slice_count) {
+void grpc_split_slices(grpc_slice_split_mode mode, grpc_slice* src_slices,
+                       size_t src_slice_count, grpc_slice** dst_slices,
+                       size_t* dst_slice_count) {
   size_t i, j;
   size_t length;
 
@@ -45,7 +45,7 @@ void grpc_split_slices(grpc_slice_split_mode mode, grpc_slice *src_slices,
     case GRPC_SLICE_SPLIT_IDENTITY:
       *dst_slice_count = src_slice_count;
       *dst_slices =
-          (grpc_slice *)gpr_malloc(sizeof(grpc_slice) * src_slice_count);
+          (grpc_slice*)gpr_malloc(sizeof(grpc_slice) * src_slice_count);
       for (i = 0; i < src_slice_count; i++) {
         (*dst_slices)[i] = src_slices[i];
         grpc_slice_ref((*dst_slices)[i]);
@@ -57,7 +57,7 @@ void grpc_split_slices(grpc_slice_split_mode mode, grpc_slice *src_slices,
       for (i = 0; i < src_slice_count; i++) {
         length += GRPC_SLICE_LENGTH(src_slices[i]);
       }
-      *dst_slices = (grpc_slice *)gpr_malloc(sizeof(grpc_slice));
+      *dst_slices = (grpc_slice*)gpr_malloc(sizeof(grpc_slice));
       **dst_slices = grpc_slice_malloc(length);
       length = 0;
       for (i = 0; i < src_slice_count; i++) {
@@ -73,7 +73,7 @@ void grpc_split_slices(grpc_slice_split_mode mode, grpc_slice *src_slices,
         length += GRPC_SLICE_LENGTH(src_slices[i]);
       }
       *dst_slice_count = length;
-      *dst_slices = (grpc_slice *)gpr_malloc(sizeof(grpc_slice) * length);
+      *dst_slices = (grpc_slice*)gpr_malloc(sizeof(grpc_slice) * length);
       length = 0;
       for (i = 0; i < src_slice_count; i++) {
         for (j = 0; j < GRPC_SLICE_LENGTH(src_slices[i]); j++) {
@@ -86,9 +86,9 @@ void grpc_split_slices(grpc_slice_split_mode mode, grpc_slice *src_slices,
 }
 
 void grpc_split_slices_to_buffer(grpc_slice_split_mode mode,
-                                 grpc_slice *src_slices, size_t src_slice_count,
-                                 grpc_slice_buffer *dst) {
-  grpc_slice *slices;
+                                 grpc_slice* src_slices, size_t src_slice_count,
+                                 grpc_slice_buffer* dst) {
+  grpc_slice* slices;
   size_t nslices;
   size_t i;
   grpc_split_slices(mode, src_slices, src_slice_count, &slices, &nslices);
@@ -99,13 +99,13 @@ void grpc_split_slices_to_buffer(grpc_slice_split_mode mode,
   gpr_free(slices);
 }
 
-void grpc_split_slice_buffer(grpc_slice_split_mode mode, grpc_slice_buffer *src,
-                             grpc_slice_buffer *dst) {
+void grpc_split_slice_buffer(grpc_slice_split_mode mode, grpc_slice_buffer* src,
+                             grpc_slice_buffer* dst) {
   grpc_split_slices_to_buffer(mode, src->slices, src->count, dst);
 }
 
-grpc_slice grpc_slice_merge(grpc_slice *slices, size_t nslices) {
-  uint8_t *out = NULL;
+grpc_slice grpc_slice_merge(grpc_slice* slices, size_t nslices) {
+  uint8_t* out = NULL;
   size_t length = 0;
   size_t capacity = 0;
   size_t i;
@@ -113,7 +113,7 @@ grpc_slice grpc_slice_merge(grpc_slice *slices, size_t nslices) {
   for (i = 0; i < nslices; i++) {
     if (GRPC_SLICE_LENGTH(slices[i]) + length > capacity) {
       capacity = GPR_MAX(capacity * 2, GRPC_SLICE_LENGTH(slices[i]) + length);
-      out = (uint8_t *)gpr_realloc(out, capacity);
+      out = (uint8_t*)gpr_realloc(out, capacity);
     }
     memcpy(out + length, GRPC_SLICE_START_PTR(slices[i]),
            GRPC_SLICE_LENGTH(slices[i]));
diff --git a/test/core/util/slice_splitter.h b/test/core/util/slice_splitter.h
index 713eca93d2..65b9f6f7df 100644
--- a/test/core/util/slice_splitter.h
+++ b/test/core/util/slice_splitter.h
@@ -36,18 +36,18 @@ typedef enum {
 
 /* allocates *dst_slices; caller must unref all slices in dst_slices then free
    it */
-void grpc_split_slices(grpc_slice_split_mode mode, grpc_slice *src_slices,
-                       size_t src_slice_count, grpc_slice **dst_slices,
-                       size_t *dst_slice_count);
+void grpc_split_slices(grpc_slice_split_mode mode, grpc_slice* src_slices,
+                       size_t src_slice_count, grpc_slice** dst_slices,
+                       size_t* dst_slice_count);
 
 void grpc_split_slices_to_buffer(grpc_slice_split_mode mode,
-                                 grpc_slice *src_slices, size_t src_slice_count,
-                                 grpc_slice_buffer *dst);
-void grpc_split_slice_buffer(grpc_slice_split_mode mode, grpc_slice_buffer *src,
-                             grpc_slice_buffer *dst);
+                                 grpc_slice* src_slices, size_t src_slice_count,
+                                 grpc_slice_buffer* dst);
+void grpc_split_slice_buffer(grpc_slice_split_mode mode, grpc_slice_buffer* src,
+                             grpc_slice_buffer* dst);
 
-grpc_slice grpc_slice_merge(grpc_slice *slices, size_t nslices);
+grpc_slice grpc_slice_merge(grpc_slice* slices, size_t nslices);
 
-const char *grpc_slice_split_mode_name(grpc_slice_split_mode mode);
+const char* grpc_slice_split_mode_name(grpc_slice_split_mode mode);
 
 #endif /* GRPC_TEST_CORE_UTIL_SLICE_SPLITTER_H */
diff --git a/test/core/util/test_config.c b/test/core/util/test_config.cc
index 536045e1c3..3106fb01ea 100644
--- a/test/core/util/test_config.c
+++ b/test/core/util/test_config.cc
@@ -59,7 +59,7 @@ static unsigned seed(void) { return (unsigned)_getpid(); }
 
 static void print_current_stack() {
   typedef USHORT(WINAPI * CaptureStackBackTraceType)(
-      __in ULONG, __in ULONG, __out PVOID *, __out_opt PULONG);
+      __in ULONG, __in ULONG, __out PVOID*, __out_opt PULONG);
   CaptureStackBackTraceType func = (CaptureStackBackTraceType)(GetProcAddress(
       LoadLibrary(_T("kernel32.dll")), "RtlCaptureStackBackTrace"));
 
@@ -71,15 +71,15 @@ static void print_current_stack() {
 // than 63.
 #define MAX_CALLERS 62
 
-  void *callers_stack[MAX_CALLERS];
+  void* callers_stack[MAX_CALLERS];
   unsigned short frames;
-  SYMBOL_INFOW *symbol;
+  SYMBOL_INFOW* symbol;
   HANDLE process;
   process = GetCurrentProcess();
   SymInitialize(process, NULL, TRUE);
   frames = (func)(0, MAX_CALLERS, callers_stack, NULL);
   symbol =
-      (SYMBOL_INFOW *)calloc(sizeof(SYMBOL_INFOW) + 256 * sizeof(wchar_t), 1);
+      (SYMBOL_INFOW*)calloc(sizeof(SYMBOL_INFOW) + 256 * sizeof(wchar_t), 1);
   symbol->MaxNameLen = 255;
   symbol->SizeOfStruct = sizeof(SYMBOL_INFOW);
 
@@ -133,8 +133,8 @@ static void print_stack_from_context(CONTEXT c) {
   HANDLE process = GetCurrentProcess();
   HANDLE thread = GetCurrentThread();
 
-  SYMBOL_INFOW *symbol =
-      (SYMBOL_INFOW *)calloc(sizeof(SYMBOL_INFOW) + 256 * sizeof(wchar_t), 1);
+  SYMBOL_INFOW* symbol =
+      (SYMBOL_INFOW*)calloc(sizeof(SYMBOL_INFOW) + 256 * sizeof(wchar_t), 1);
   symbol->MaxNameLen = 255;
   symbol->SizeOfStruct = sizeof(SYMBOL_INFOW);
 
@@ -151,7 +151,7 @@ static void print_stack_from_context(CONTEXT c) {
   free(symbol);
 }
 
-static LONG crash_handler(struct _EXCEPTION_POINTERS *ex_info) {
+static LONG crash_handler(struct _EXCEPTION_POINTERS* ex_info) {
   fprintf(stderr, "Exception handler called, dumping information\n");
   bool try_to_print_stack = true;
   PEXCEPTION_RECORD exrec = ex_info->ExceptionRecord;
@@ -176,7 +176,7 @@ static LONG crash_handler(struct _EXCEPTION_POINTERS *ex_info) {
 
 static void abort_handler(int sig) {
   fprintf(stderr, "Abort handler called.\n");
-  print_current_stack(NULL);
+  print_current_stack();
   if (IsDebuggerPresent()) {
     __debugbreak();
   } else {
@@ -202,7 +202,7 @@ static void install_crash_handler() {
 
 #define SIGNAL_NAMES_LENGTH 32
 
-static const char *const signal_names[] = {
+static const char* const signal_names[] = {
     NULL,      "SIGHUP",  "SIGINT",    "SIGQUIT", "SIGILL",    "SIGTRAP",
     "SIGABRT", "SIGBUS",  "SIGFPE",    "SIGKILL", "SIGUSR1",   "SIGSEGV",
     "SIGUSR2", "SIGPIPE", "SIGALRM",   "SIGTERM", "SIGSTKFLT", "SIGCHLD",
@@ -215,7 +215,7 @@ static char g_alt_stack[GPR_MAX(MINSIGSTKSZ, 65536)];
 #define MAX_FRAMES 32
 
 /* signal safe output */
-static void output_string(const char *string) {
+static void output_string(const char* string) {
   size_t len = strlen(string);
   ssize_t r;
 
@@ -230,8 +230,8 @@ static void output_num(long num) {
   output_string(buf);
 }
 
-static void crash_handler(int signum, siginfo_t *info, void *data) {
-  void *addrlist[MAX_FRAMES + 1];
+static void crash_handler(int signum, siginfo_t* info, void* data) {
+  void* addrlist[MAX_FRAMES + 1];
   int addrlen;
 
   output_string("\n\n\n*******************************\nCaught signal ");
@@ -376,10 +376,10 @@ gpr_timespec grpc_timeout_milliseconds_to_deadline(int64_t time_ms) {
                            GPR_TIMESPAN));
 }
 
-void grpc_test_init(int argc, char **argv) {
+void grpc_test_init(int argc, char** argv) {
   install_crash_handler();
   { /* poll-cv poll strategy runs much more slowly than anything else */
-    char *s = gpr_getenv("GRPC_POLL_STRATEGY");
+    char* s = gpr_getenv("GRPC_POLL_STRATEGY");
     if (s != NULL && 0 == strcmp(s, "poll-cv")) {
       g_poller_slowdown_factor = 5;
     }
diff --git a/test/core/util/test_config.h b/test/core/util/test_config.h
index 051d7e9a3d..4383fbfce8 100644
--- a/test/core/util/test_config.h
+++ b/test/core/util/test_config.h
@@ -23,7 +23,7 @@
 
 #ifdef __cplusplus
 extern "C" {
-#endif /*  __cplusplus */
+#endif
 
 extern int64_t g_fixture_slowdown_factor;
 extern int64_t g_poller_slowdown_factor;
@@ -41,10 +41,10 @@ gpr_timespec grpc_timeout_milliseconds_to_deadline(int64_t time_ms);
 #define GRPC_TEST_PICK_PORT
 #endif
 
-void grpc_test_init(int argc, char **argv);
+void grpc_test_init(int argc, char** argv);
 
 #ifdef __cplusplus
 }
-#endif /*  __cplusplus */
+#endif
 
 #endif /* GRPC_TEST_CORE_UTIL_TEST_CONFIG_H */
diff --git a/test/core/util/test_tcp_server.cc b/test/core/util/test_tcp_server.cc
index 8b482b36e0..79178a7cbd 100644
--- a/test/core/util/test_tcp_server.cc
+++ b/test/core/util/test_tcp_server.cc
@@ -33,27 +33,27 @@
 #include "test/core/util/port.h"
 #include "test/core/util/test_config.h"
 
-static void on_server_destroyed(void *data, grpc_error *error) {
-  test_tcp_server *server = (test_tcp_server *)data;
+static void on_server_destroyed(void* data, grpc_error* error) {
+  test_tcp_server* server = static_cast<test_tcp_server*>(data);
   server->shutdown = 1;
 }
 
-void test_tcp_server_init(test_tcp_server *server,
-                          grpc_tcp_server_cb on_connect, void *user_data) {
+void test_tcp_server_init(test_tcp_server* server,
+                          grpc_tcp_server_cb on_connect, void* user_data) {
   grpc_init();
   server->tcp_server = NULL;
   GRPC_CLOSURE_INIT(&server->shutdown_complete, on_server_destroyed, server,
                     grpc_schedule_on_exec_ctx);
   server->shutdown = 0;
-  server->pollset = (grpc_pollset *)gpr_zalloc(grpc_pollset_size());
+  server->pollset = static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
   grpc_pollset_init(server->pollset, &server->mu);
   server->on_connect = on_connect;
   server->cb_data = user_data;
 }
 
-void test_tcp_server_start(test_tcp_server *server, int port) {
+void test_tcp_server_start(test_tcp_server* server, int port) {
   grpc_resolved_address resolved_addr;
-  struct sockaddr_in *addr = (struct sockaddr_in *)resolved_addr.addr;
+  struct sockaddr_in* addr = (struct sockaddr_in*)resolved_addr.addr;
   int port_added;
   ExecCtx _local_exec_ctx;
 
@@ -61,7 +61,7 @@ void test_tcp_server_start(test_tcp_server *server, int port) {
   addr->sin_port = htons((uint16_t)port);
   memset(&addr->sin_addr, 0, sizeof(addr->sin_addr));
 
-  grpc_error *error = grpc_tcp_server_create(&server->shutdown_complete, NULL,
+  grpc_error* error = grpc_tcp_server_create(&server->shutdown_complete, NULL,
                                              &server->tcp_server);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   error =
@@ -76,8 +76,8 @@ void test_tcp_server_start(test_tcp_server *server, int port) {
   grpc_exec_ctx_finish();
 }
 
-void test_tcp_server_poll(test_tcp_server *server, int seconds) {
-  grpc_pollset_worker *worker = NULL;
+void test_tcp_server_poll(test_tcp_server* server, int seconds) {
+  grpc_pollset_worker* worker = NULL;
   ExecCtx _local_exec_ctx;
   grpc_millis deadline = grpc_timespec_to_millis_round_up(
       grpc_timeout_seconds_to_deadline(seconds));
@@ -88,12 +88,12 @@ void test_tcp_server_poll(test_tcp_server *server, int seconds) {
   grpc_exec_ctx_finish();
 }
 
-static void do_nothing(void *arg, grpc_error *error) {}
-static void finish_pollset(void *arg, grpc_error *error) {
-  grpc_pollset_destroy((grpc_pollset *)arg);
+static void do_nothing(void* arg, grpc_error* error) {}
+static void finish_pollset(void* arg, grpc_error* error) {
+  grpc_pollset_destroy(static_cast<grpc_pollset*>(arg));
 }
 
-void test_tcp_server_destroy(test_tcp_server *server) {
+void test_tcp_server_destroy(test_tcp_server* server) {
   ExecCtx _local_exec_ctx;
   gpr_timespec shutdown_deadline;
   grpc_closure do_nothing_cb;
diff --git a/test/core/util/test_tcp_server.h b/test/core/util/test_tcp_server.h
index bd62992a09..58140388da 100644
--- a/test/core/util/test_tcp_server.h
+++ b/test/core/util/test_tcp_server.h
@@ -23,19 +23,19 @@
 #include "src/core/lib/iomgr/tcp_server.h"
 
 typedef struct test_tcp_server {
-  grpc_tcp_server *tcp_server;
+  grpc_tcp_server* tcp_server;
   grpc_closure shutdown_complete;
   int shutdown;
-  gpr_mu *mu;
-  grpc_pollset *pollset;
+  gpr_mu* mu;
+  grpc_pollset* pollset;
   grpc_tcp_server_cb on_connect;
-  void *cb_data;
+  void* cb_data;
 } test_tcp_server;
 
-void test_tcp_server_init(test_tcp_server *server,
-                          grpc_tcp_server_cb on_connect, void *user_data);
-void test_tcp_server_start(test_tcp_server *server, int port);
-void test_tcp_server_poll(test_tcp_server *server, int seconds);
-void test_tcp_server_destroy(test_tcp_server *server);
+void test_tcp_server_init(test_tcp_server* server,
+                          grpc_tcp_server_cb on_connect, void* user_data);
+void test_tcp_server_start(test_tcp_server* server, int port);
+void test_tcp_server_poll(test_tcp_server* server, int seconds);
+void test_tcp_server_destroy(test_tcp_server* server);
 
 #endif /* GRPC_TEST_CORE_UTIL_TEST_TCP_SERVER_H */
diff --git a/test/core/util/trickle_endpoint.cc b/test/core/util/trickle_endpoint.cc
index e36f64816e..763e684237 100644
--- a/test/core/util/trickle_endpoint.cc
+++ b/test/core/util/trickle_endpoint.cc
@@ -34,24 +34,24 @@
 typedef struct {
   grpc_endpoint base;
   double bytes_per_second;
-  grpc_endpoint *wrapped;
+  grpc_endpoint* wrapped;
   gpr_timespec last_write;
 
   gpr_mu mu;
   grpc_slice_buffer write_buffer;
   grpc_slice_buffer writing_buffer;
-  grpc_error *error;
+  grpc_error* error;
   bool writing;
-  grpc_closure *write_cb;
+  grpc_closure* write_cb;
 } trickle_endpoint;
 
-static void te_read(grpc_endpoint *ep, grpc_slice_buffer *slices,
-                    grpc_closure *cb) {
-  trickle_endpoint *te = (trickle_endpoint *)ep;
+static void te_read(grpc_endpoint* ep, grpc_slice_buffer* slices,
+                    grpc_closure* cb) {
+  trickle_endpoint* te = (trickle_endpoint*)ep;
   grpc_endpoint_read(te->wrapped, slices, cb);
 }
 
-static void maybe_call_write_cb_locked(trickle_endpoint *te) {
+static void maybe_call_write_cb_locked(trickle_endpoint* te) {
   if (te->write_cb != NULL && (te->error != GRPC_ERROR_NONE ||
                                te->write_buffer.length <= WRITE_BUFFER_SIZE)) {
     GRPC_CLOSURE_SCHED(te->write_cb, GRPC_ERROR_REF(te->error));
@@ -59,9 +59,9 @@ static void maybe_call_write_cb_locked(trickle_endpoint *te) {
   }
 }
 
-static void te_write(grpc_endpoint *ep, grpc_slice_buffer *slices,
-                     grpc_closure *cb) {
-  trickle_endpoint *te = (trickle_endpoint *)ep;
+static void te_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
+                     grpc_closure* cb) {
+  trickle_endpoint* te = (trickle_endpoint*)ep;
   gpr_mu_lock(&te->mu);
   GPR_ASSERT(te->write_cb == NULL);
   if (te->write_buffer.length == 0) {
@@ -76,19 +76,25 @@ static void te_write(grpc_endpoint *ep, grpc_slice_buffer *slices,
   gpr_mu_unlock(&te->mu);
 }
 
-static void te_add_to_pollset(grpc_endpoint *ep, grpc_pollset *pollset) {
-  trickle_endpoint *te = (trickle_endpoint *)ep;
+static void te_add_to_pollset(grpc_endpoint* ep, grpc_pollset* pollset) {
+  trickle_endpoint* te = (trickle_endpoint*)ep;
   grpc_endpoint_add_to_pollset(te->wrapped, pollset);
 }
 
-static void te_add_to_pollset_set(grpc_endpoint *ep,
-                                  grpc_pollset_set *pollset_set) {
-  trickle_endpoint *te = (trickle_endpoint *)ep;
+static void te_add_to_pollset_set(grpc_endpoint* ep,
+                                  grpc_pollset_set* pollset_set) {
+  trickle_endpoint* te = (trickle_endpoint*)ep;
   grpc_endpoint_add_to_pollset_set(te->wrapped, pollset_set);
 }
 
-static void te_shutdown(grpc_endpoint *ep, grpc_error *why) {
-  trickle_endpoint *te = (trickle_endpoint *)ep;
+static void te_delete_from_pollset_set(grpc_endpoint* ep,
+                                       grpc_pollset_set* pollset_set) {
+  trickle_endpoint* te = (trickle_endpoint*)ep;
+  grpc_endpoint_delete_from_pollset_set(te->wrapped, pollset_set);
+}
+
+static void te_shutdown(grpc_endpoint* ep, grpc_error* why) {
+  trickle_endpoint* te = (trickle_endpoint*)ep;
   gpr_mu_lock(&te->mu);
   if (te->error == GRPC_ERROR_NONE) {
     te->error = GRPC_ERROR_REF(why);
@@ -98,8 +104,8 @@ static void te_shutdown(grpc_endpoint *ep, grpc_error *why) {
   grpc_endpoint_shutdown(te->wrapped, why);
 }
 
-static void te_destroy(grpc_endpoint *ep) {
-  trickle_endpoint *te = (trickle_endpoint *)ep;
+static void te_destroy(grpc_endpoint* ep) {
+  trickle_endpoint* te = (trickle_endpoint*)ep;
   grpc_endpoint_destroy(te->wrapped);
   gpr_mu_destroy(&te->mu);
   grpc_slice_buffer_destroy_internal(&te->write_buffer);
@@ -108,37 +114,43 @@ static void te_destroy(grpc_endpoint *ep) {
   gpr_free(te);
 }
 
-static grpc_resource_user *te_get_resource_user(grpc_endpoint *ep) {
-  trickle_endpoint *te = (trickle_endpoint *)ep;
+static grpc_resource_user* te_get_resource_user(grpc_endpoint* ep) {
+  trickle_endpoint* te = (trickle_endpoint*)ep;
   return grpc_endpoint_get_resource_user(te->wrapped);
 }
 
-static char *te_get_peer(grpc_endpoint *ep) {
-  trickle_endpoint *te = (trickle_endpoint *)ep;
+static char* te_get_peer(grpc_endpoint* ep) {
+  trickle_endpoint* te = (trickle_endpoint*)ep;
   return grpc_endpoint_get_peer(te->wrapped);
 }
 
-static int te_get_fd(grpc_endpoint *ep) {
-  trickle_endpoint *te = (trickle_endpoint *)ep;
+static int te_get_fd(grpc_endpoint* ep) {
+  trickle_endpoint* te = (trickle_endpoint*)ep;
   return grpc_endpoint_get_fd(te->wrapped);
 }
 
-static void te_finish_write(void *arg, grpc_error *error) {
-  trickle_endpoint *te = (trickle_endpoint *)arg;
+static void te_finish_write(void* arg, grpc_error* error) {
+  trickle_endpoint* te = (trickle_endpoint*)arg;
   gpr_mu_lock(&te->mu);
   te->writing = false;
   grpc_slice_buffer_reset_and_unref(&te->writing_buffer);
   gpr_mu_unlock(&te->mu);
 }
 
-static const grpc_endpoint_vtable vtable = {
-    te_read,     te_write,   te_add_to_pollset,    te_add_to_pollset_set,
-    te_shutdown, te_destroy, te_get_resource_user, te_get_peer,
-    te_get_fd};
-
-grpc_endpoint *grpc_trickle_endpoint_create(grpc_endpoint *wrap,
+static const grpc_endpoint_vtable vtable = {te_read,
+                                            te_write,
+                                            te_add_to_pollset,
+                                            te_add_to_pollset_set,
+                                            te_delete_from_pollset_set,
+                                            te_shutdown,
+                                            te_destroy,
+                                            te_get_resource_user,
+                                            te_get_peer,
+                                            te_get_fd};
+
+grpc_endpoint* grpc_trickle_endpoint_create(grpc_endpoint* wrap,
                                             double bytes_per_second) {
-  trickle_endpoint *te = (trickle_endpoint *)gpr_malloc(sizeof(*te));
+  trickle_endpoint* te = (trickle_endpoint*)gpr_malloc(sizeof(*te));
   te->base.vtable = &vtable;
   te->wrapped = wrap;
   te->bytes_per_second = bytes_per_second;
@@ -155,8 +167,8 @@ static double ts2dbl(gpr_timespec s) {
   return (double)s.tv_sec + 1e-9 * (double)s.tv_nsec;
 }
 
-size_t grpc_trickle_endpoint_trickle(grpc_endpoint *ep) {
-  trickle_endpoint *te = (trickle_endpoint *)ep;
+size_t grpc_trickle_endpoint_trickle(grpc_endpoint* ep) {
+  trickle_endpoint* te = (trickle_endpoint*)ep;
   gpr_mu_lock(&te->mu);
   if (!te->writing && te->write_buffer.length > 0) {
     gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC);
@@ -180,8 +192,8 @@ size_t grpc_trickle_endpoint_trickle(grpc_endpoint *ep) {
   return backlog;
 }
 
-size_t grpc_trickle_get_backlog(grpc_endpoint *ep) {
-  trickle_endpoint *te = (trickle_endpoint *)ep;
+size_t grpc_trickle_get_backlog(grpc_endpoint* ep) {
+  trickle_endpoint* te = (trickle_endpoint*)ep;
   gpr_mu_lock(&te->mu);
   size_t backlog = te->write_buffer.length;
   gpr_mu_unlock(&te->mu);
diff --git a/test/core/util/trickle_endpoint.h b/test/core/util/trickle_endpoint.h
index be19dd2035..cd07de905a 100644
--- a/test/core/util/trickle_endpoint.h
+++ b/test/core/util/trickle_endpoint.h
@@ -21,20 +21,12 @@
 
 #include "src/core/lib/iomgr/endpoint.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif  // __cplusplus
-
-grpc_endpoint *grpc_trickle_endpoint_create(grpc_endpoint *wrap,
+grpc_endpoint* grpc_trickle_endpoint_create(grpc_endpoint* wrap,
                                             double bytes_per_second);
 
 /* Allow up to \a bytes through the endpoint. Returns the new backlog. */
-size_t grpc_trickle_endpoint_trickle(grpc_endpoint *endpoint);
-
-size_t grpc_trickle_get_backlog(grpc_endpoint *endpoint);
+size_t grpc_trickle_endpoint_trickle(grpc_endpoint* endpoint);
 
-#ifdef __cplusplus
-}
-#endif  // __cplusplus
+size_t grpc_trickle_get_backlog(grpc_endpoint* endpoint);
 
 #endif