454 files changed, 16366 insertions, 17234 deletions

diff --git a/test/core/backoff/BUILD b/test/core/backoff/BUILD
index 4ae762007c..4cd7acf066 100644
--- a/test/core/backoff/BUILD
+++ b/test/core/backoff/BUILD
@@ -25,8 +25,8 @@ package(
 
 grpc_cc_test(
     name = "backoff_test",
-    srcs = ["backoff_test.c"],
-    language = "C",
+    srcs = ["backoff_test.cc"],
+    language = "C++",
     deps = [
         "//:grpc",
         "//test/core/util:grpc_test_util",
diff --git a/test/core/backoff/backoff_test.c b/test/core/backoff/backoff_test.c
deleted file mode 100644
index a29cce6cc7..0000000000
--- a/test/core/backoff/backoff_test.c
+++ /dev/null
@@ -1,150 +0,0 @@
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include "src/core/lib/backoff/backoff.h"
-
-#include <grpc/support/log.h>
-
-#include "test/core/util/test_config.h"
-
-static void test_constant_backoff(void) {
-  grpc_backoff backoff;
-  grpc_backoff_init(&backoff, 200 /* initial timeout */, 1.0 /* multiplier */,
-                    0.0 /* jitter */, 100 /* min timeout */,
-                    1000 /* max timeout */);
-
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_millis next = grpc_backoff_begin(&exec_ctx, &backoff);
-  GPR_ASSERT(next - grpc_exec_ctx_now(&exec_ctx) == 200);
-  for (int i = 0; i < 10000; i++) {
-    next = grpc_backoff_step(&exec_ctx, &backoff);
-    GPR_ASSERT(next - grpc_exec_ctx_now(&exec_ctx) == 200);
-    exec_ctx.now = next;
-  }
-  grpc_exec_ctx_finish(&exec_ctx);
-}
-
-static void test_min_connect(void) {
-  grpc_backoff backoff;
-  grpc_backoff_init(&backoff, 100 /* initial timeout */, 1.0 /* multiplier */,
-                    0.0 /* jitter */, 200 /* min timeout */,
-                    1000 /* max timeout */);
-
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_millis next = grpc_backoff_begin(&exec_ctx, &backoff);
-  GPR_ASSERT(next - grpc_exec_ctx_now(&exec_ctx) == 200);
-  grpc_exec_ctx_finish(&exec_ctx);
-}
-
-static void test_no_jitter_backoff(void) {
-  grpc_backoff backoff;
-  grpc_backoff_init(&backoff, 2 /* initial timeout */, 2.0 /* multiplier */,
-                    0.0 /* jitter */, 1 /* min timeout */,
-                    513 /* max timeout */);
-  // x_1 = 2
-  // x_n = 2**i + x_{i-1} ( = 2**(n+1) - 2 )
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  exec_ctx.now = 0;
-  exec_ctx.now_is_valid = true;
-  grpc_millis next = grpc_backoff_begin(&exec_ctx, &backoff);
-  GPR_ASSERT(next == 2);
-  exec_ctx.now = next;
-  next = grpc_backoff_step(&exec_ctx, &backoff);
-  GPR_ASSERT(next == 6);
-  exec_ctx.now = next;
-  next = grpc_backoff_step(&exec_ctx, &backoff);
-  GPR_ASSERT(next == 14);
-  exec_ctx.now = next;
-  next = grpc_backoff_step(&exec_ctx, &backoff);
-  GPR_ASSERT(next == 30);
-  exec_ctx.now = next;
-  next = grpc_backoff_step(&exec_ctx, &backoff);
-  GPR_ASSERT(next == 62);
-  exec_ctx.now = next;
-  next = grpc_backoff_step(&exec_ctx, &backoff);
-  GPR_ASSERT(next == 126);
-  exec_ctx.now = next;
-  next = grpc_backoff_step(&exec_ctx, &backoff);
-  GPR_ASSERT(next == 254);
-  exec_ctx.now = next;
-  next = grpc_backoff_step(&exec_ctx, &backoff);
-  GPR_ASSERT(next == 510);
-  exec_ctx.now = next;
-  next = grpc_backoff_step(&exec_ctx, &backoff);
-  GPR_ASSERT(next == 1022);
-  exec_ctx.now = next;
-  next = grpc_backoff_step(&exec_ctx, &backoff);
-  // Hit the maximum timeout. From this point onwards, retries will increase
-  // only by max timeout.
-  GPR_ASSERT(next == 1535);
-  exec_ctx.now = next;
-  next = grpc_backoff_step(&exec_ctx, &backoff);
-  GPR_ASSERT(next == 2048);
-  exec_ctx.now = next;
-  next = grpc_backoff_step(&exec_ctx, &backoff);
-  GPR_ASSERT(next == 2561);
-  grpc_exec_ctx_finish(&exec_ctx);
-}
-
-static void test_jitter_backoff(void) {
-  const int64_t initial_timeout = 500;
-  const double jitter = 0.1;
-  grpc_backoff backoff;
-  grpc_backoff_init(&backoff, (grpc_millis)initial_timeout,
-                    1.0 /* multiplier */, jitter, 100 /* min timeout */,
-                    1000 /* max timeout */);
-
-  backoff.rng_state = 0;  // force consistent PRNG
-
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_millis next = grpc_backoff_begin(&exec_ctx, &backoff);
-  GPR_ASSERT(next - grpc_exec_ctx_now(&exec_ctx) == 500);
-
-  int64_t expected_next_lower_bound =
-      (int64_t)((double)initial_timeout * (1 - jitter));
-  int64_t expected_next_upper_bound =
-      (int64_t)((double)initial_timeout * (1 + jitter));
-
-  for (int i = 0; i < 10000; i++) {
-    next = grpc_backoff_step(&exec_ctx, &backoff);
-
-    // next-now must be within (jitter*100)% of the previous timeout.
-    const int64_t timeout_millis = next - grpc_exec_ctx_now(&exec_ctx);
-    GPR_ASSERT(timeout_millis >= expected_next_lower_bound);
-    GPR_ASSERT(timeout_millis <= expected_next_upper_bound);
-
-    expected_next_lower_bound =
-        (int64_t)((double)timeout_millis * (1 - jitter));
-    expected_next_upper_bound =
-        (int64_t)((double)timeout_millis * (1 + jitter));
-    exec_ctx.now = next;
-  }
-  grpc_exec_ctx_finish(&exec_ctx);
-}
-
-int main(int argc, char **argv) {
-  grpc_test_init(argc, argv);
-  gpr_time_init();
-
-  test_constant_backoff();
-  test_min_connect();
-  test_no_jitter_backoff();
-  test_jitter_backoff();
-
-  return 0;
-}
diff --git a/test/core/backoff/backoff_test.cc b/test/core/backoff/backoff_test.cc
new file mode 100644
index 0000000000..ef2de8d638
--- /dev/null
+++ b/test/core/backoff/backoff_test.cc
@@ -0,0 +1,187 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "src/core/lib/backoff/backoff.h"
+
+#include <grpc/support/log.h>
+#include <grpc/support/useful.h>
+
+#include "test/core/util/test_config.h"
+
+static void test_constant_backoff(void) {
+  grpc_backoff backoff;
+  const grpc_millis initial_backoff = 200;
+  const double multiplier = 1.0;
+  const double jitter = 0.0;
+  const grpc_millis min_connect_timeout = 100;
+  const grpc_millis max_backoff = 1000;
+  grpc_backoff_init(&backoff, initial_backoff, multiplier, jitter,
+                    min_connect_timeout, max_backoff);
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_backoff_result next_deadlines = grpc_backoff_begin(&exec_ctx, &backoff);
+  GPR_ASSERT(next_deadlines.current_deadline - grpc_exec_ctx_now(&exec_ctx) ==
+             initial_backoff);
+  GPR_ASSERT(next_deadlines.next_attempt_start_time -
+                 grpc_exec_ctx_now(&exec_ctx) ==
+             initial_backoff);
+  for (int i = 0; i < 10000; i++) {
+    next_deadlines = grpc_backoff_step(&exec_ctx, &backoff);
+    GPR_ASSERT(next_deadlines.current_deadline - grpc_exec_ctx_now(&exec_ctx) ==
+               initial_backoff);
+    GPR_ASSERT(next_deadlines.next_attempt_start_time -
+                   grpc_exec_ctx_now(&exec_ctx) ==
+               initial_backoff);
+    exec_ctx.now = next_deadlines.current_deadline;
+  }
+  grpc_exec_ctx_finish(&exec_ctx);
+}
+
+static void test_min_connect(void) {
+  grpc_backoff backoff;
+  const grpc_millis initial_backoff = 100;
+  const double multiplier = 1.0;
+  const double jitter = 0.0;
+  const grpc_millis min_connect_timeout = 200;
+  const grpc_millis max_backoff = 1000;
+  grpc_backoff_init(&backoff, initial_backoff, multiplier, jitter,
+                    min_connect_timeout, max_backoff);
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_backoff_result next = grpc_backoff_begin(&exec_ctx, &backoff);
+  // Because the min_connect_timeout > initial_backoff, current_deadline is used
+  // as the deadline for the current attempt.
+  GPR_ASSERT(next.current_deadline - grpc_exec_ctx_now(&exec_ctx) ==
+             min_connect_timeout);
+  // ... while, if the current attempt fails, the next one will happen after
+  // initial_backoff.
+  GPR_ASSERT(next.next_attempt_start_time - grpc_exec_ctx_now(&exec_ctx) ==
+             initial_backoff);
+  grpc_exec_ctx_finish(&exec_ctx);
+}
+
+static void test_no_jitter_backoff(void) {
+  grpc_backoff backoff;
+  const grpc_millis initial_backoff = 2;
+  const double multiplier = 2.0;
+  const double jitter = 0.0;
+  const grpc_millis min_connect_timeout = 1;
+  const grpc_millis max_backoff = 513;
+  grpc_backoff_init(&backoff, initial_backoff, multiplier, jitter,
+                    min_connect_timeout, max_backoff);
+  // x_1 = 2
+  // x_n = 2**i + x_{i-1} ( = 2**(n+1) - 2 )
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  exec_ctx.now = 0;
+  exec_ctx.now_is_valid = true;
+  grpc_backoff_result next_deadlines = grpc_backoff_begin(&exec_ctx, &backoff);
+  GPR_ASSERT(next_deadlines.current_deadline ==
+             next_deadlines.next_attempt_start_time);
+  GPR_ASSERT(next_deadlines.current_deadline == 2);
+  exec_ctx.now = next_deadlines.current_deadline;
+  next_deadlines = grpc_backoff_step(&exec_ctx, &backoff);
+  GPR_ASSERT(next_deadlines.current_deadline == 6);
+  exec_ctx.now = next_deadlines.current_deadline;
+  next_deadlines = grpc_backoff_step(&exec_ctx, &backoff);
+  GPR_ASSERT(next_deadlines.current_deadline == 14);
+  exec_ctx.now = next_deadlines.current_deadline;
+  next_deadlines = grpc_backoff_step(&exec_ctx, &backoff);
+  GPR_ASSERT(next_deadlines.current_deadline == 30);
+  exec_ctx.now = next_deadlines.current_deadline;
+  next_deadlines = grpc_backoff_step(&exec_ctx, &backoff);
+  GPR_ASSERT(next_deadlines.current_deadline == 62);
+  exec_ctx.now = next_deadlines.current_deadline;
+  next_deadlines = grpc_backoff_step(&exec_ctx, &backoff);
+  GPR_ASSERT(next_deadlines.current_deadline == 126);
+  exec_ctx.now = next_deadlines.current_deadline;
+  next_deadlines = grpc_backoff_step(&exec_ctx, &backoff);
+  GPR_ASSERT(next_deadlines.current_deadline == 254);
+  exec_ctx.now = next_deadlines.current_deadline;
+  next_deadlines = grpc_backoff_step(&exec_ctx, &backoff);
+  GPR_ASSERT(next_deadlines.current_deadline == 510);
+  exec_ctx.now = next_deadlines.current_deadline;
+  next_deadlines = grpc_backoff_step(&exec_ctx, &backoff);
+  GPR_ASSERT(next_deadlines.current_deadline == 1022);
+  exec_ctx.now = next_deadlines.current_deadline;
+  next_deadlines = grpc_backoff_step(&exec_ctx, &backoff);
+  // Hit the maximum timeout. From this point onwards, retries will increase
+  // only by max timeout.
+  GPR_ASSERT(next_deadlines.current_deadline == 1535);
+  exec_ctx.now = next_deadlines.current_deadline;
+  next_deadlines = grpc_backoff_step(&exec_ctx, &backoff);
+  GPR_ASSERT(next_deadlines.current_deadline == 2048);
+  exec_ctx.now = next_deadlines.current_deadline;
+  next_deadlines = grpc_backoff_step(&exec_ctx, &backoff);
+  GPR_ASSERT(next_deadlines.current_deadline == 2561);
+  grpc_exec_ctx_finish(&exec_ctx);
+}
+
+static void test_jitter_backoff(void) {
+  const grpc_millis initial_backoff = 500;
+  grpc_millis current_backoff = initial_backoff;
+  const grpc_millis max_backoff = 1000;
+  const grpc_millis min_connect_timeout = 100;
+  const double multiplier = 1.0;
+  const double jitter = 0.1;
+  grpc_backoff backoff;
+  grpc_backoff_init(&backoff, initial_backoff, multiplier, jitter,
+                    min_connect_timeout, max_backoff);
+
+  backoff.rng_state = 0;  // force consistent PRNG
+
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_backoff_result next_deadlines = grpc_backoff_begin(&exec_ctx, &backoff);
+  GPR_ASSERT(next_deadlines.current_deadline - grpc_exec_ctx_now(&exec_ctx) ==
+             initial_backoff);
+  GPR_ASSERT(next_deadlines.next_attempt_start_time -
+                 grpc_exec_ctx_now(&exec_ctx) ==
+             initial_backoff);
+
+  grpc_millis expected_next_lower_bound =
+      (grpc_millis)((double)current_backoff * (1 - jitter));
+  grpc_millis expected_next_upper_bound =
+      (grpc_millis)((double)current_backoff * (1 + jitter));
+
+  for (int i = 0; i < 10000; i++) {
+    next_deadlines = grpc_backoff_step(&exec_ctx, &backoff);
+    // next-now must be within (jitter*100)% of the current backoff (which
+    // increases by * multiplier up to max_backoff).
+    const grpc_millis timeout_millis =
+        next_deadlines.current_deadline - grpc_exec_ctx_now(&exec_ctx);
+    GPR_ASSERT(timeout_millis >= expected_next_lower_bound);
+    GPR_ASSERT(timeout_millis <= expected_next_upper_bound);
+    current_backoff = GPR_MIN(
+        (grpc_millis)((double)current_backoff * multiplier), max_backoff);
+    expected_next_lower_bound =
+        (grpc_millis)((double)current_backoff * (1 - jitter));
+    expected_next_upper_bound =
+        (grpc_millis)((double)current_backoff * (1 + jitter));
+    exec_ctx.now = next_deadlines.current_deadline;
+  }
+  grpc_exec_ctx_finish(&exec_ctx);
+}
+
+int main(int argc, char** argv) {
+  grpc_test_init(argc, argv);
+  gpr_time_init();
+
+  test_constant_backoff();
+  test_min_connect();
+  test_no_jitter_backoff();
+  test_jitter_backoff();
+
+  return 0;
+}
diff --git a/test/core/bad_client/bad_client.c b/test/core/bad_client/bad_client.cc
index b7b28a9ac4..c19b7bdf40 100644
--- a/test/core/bad_client/bad_client.c
+++ b/test/core/bad_client/bad_client.cc
@@ -36,53 +36,53 @@
 #include "src/core/lib/surface/server.h"
 
 typedef struct {
-  grpc_server *server;
-  grpc_completion_queue *cq;
+  grpc_server* server;
+  grpc_completion_queue* cq;
   grpc_bad_client_server_side_validator validator;
-  void *registered_method;
+  void* registered_method;
   gpr_event done_thd;
   gpr_event done_write;
 } thd_args;
 
-static void thd_func(void *arg) {
-  thd_args *a = (thd_args *)arg;
+static void thd_func(void* arg) {
+  thd_args* a = (thd_args*)arg;
   a->validator(a->server, a->cq, a->registered_method);
-  gpr_event_set(&a->done_thd, (void *)1);
+  gpr_event_set(&a->done_thd, (void*)1);
 }
 
-static void done_write(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  thd_args *a = (thd_args *)arg;
-  gpr_event_set(&a->done_write, (void *)1);
+static void done_write(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+  thd_args* a = (thd_args*)arg;
+  gpr_event_set(&a->done_write, (void*)1);
 }
 
-static void server_setup_transport(void *ts, grpc_transport *transport) {
-  thd_args *a = (thd_args *)ts;
+static void server_setup_transport(void* ts, grpc_transport* transport) {
+  thd_args* a = (thd_args*)ts;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_server_setup_transport(&exec_ctx, a->server, transport, NULL,
+  grpc_server_setup_transport(&exec_ctx, a->server, transport, nullptr,
                               grpc_server_get_channel_args(a->server));
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void read_done(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  gpr_event *read_done = (gpr_event *)arg;
-  gpr_event_set(read_done, (void *)1);
+static void read_done(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+  gpr_event* read_done = (gpr_event*)arg;
+  gpr_event_set(read_done, (void*)1);
 }
 
 void grpc_run_bad_client_test(
     grpc_bad_client_server_side_validator server_validator,
     grpc_bad_client_client_stream_validator client_validator,
-    const char *client_payload, size_t client_payload_length, uint32_t flags) {
+    const char* client_payload, size_t client_payload_length, uint32_t flags) {
   grpc_endpoint_pair sfd;
   thd_args a;
   gpr_thd_id id;
-  char *hex;
-  grpc_transport *transport;
+  char* hex;
+  grpc_transport* transport;
   grpc_slice slice =
       grpc_slice_from_copied_buffer(client_payload, client_payload_length);
   grpc_slice_buffer outgoing;
   grpc_closure done_write_closure;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_completion_queue *shutdown_cq;
+  grpc_completion_queue* shutdown_cq;
 
   if (client_payload_length < 4 * 1024) {
     hex = gpr_dump(client_payload, client_payload_length,
@@ -101,23 +101,23 @@ void grpc_run_bad_client_test(
   grpc_init();
 
   /* Create endpoints */
-  sfd = grpc_iomgr_create_endpoint_pair("fixture", NULL);
+  sfd = grpc_iomgr_create_endpoint_pair("fixture", nullptr);
 
   /* Create server, completion events */
-  a.server = grpc_server_create(NULL, NULL);
-  a.cq = grpc_completion_queue_create_for_next(NULL);
+  a.server = grpc_server_create(nullptr, nullptr);
+  a.cq = grpc_completion_queue_create_for_next(nullptr);
   gpr_event_init(&a.done_thd);
   gpr_event_init(&a.done_write);
   a.validator = server_validator;
-  grpc_server_register_completion_queue(a.server, a.cq, NULL);
+  grpc_server_register_completion_queue(a.server, a.cq, nullptr);
   a.registered_method =
       grpc_server_register_method(a.server, GRPC_BAD_CLIENT_REGISTERED_METHOD,
                                   GRPC_BAD_CLIENT_REGISTERED_HOST,
                                   GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER, 0);
   grpc_server_start(a.server);
-  transport = grpc_create_chttp2_transport(&exec_ctx, NULL, sfd.server, 0);
+  transport = grpc_create_chttp2_transport(&exec_ctx, nullptr, sfd.server, 0);
   server_setup_transport(&a, transport);
-  grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL);
+  grpc_chttp2_transport_start_reading(&exec_ctx, transport, nullptr);
   grpc_exec_ctx_finish(&exec_ctx);
 
   /* Bind everything into the same pollset */
@@ -128,7 +128,7 @@ void grpc_run_bad_client_test(
   GPR_ASSERT(grpc_server_has_open_connections(a.server));
 
   /* Start validator */
-  gpr_thd_new(&id, thd_func, &a, NULL);
+  gpr_thd_new(&id, thd_func, &a, nullptr);
 
   grpc_slice_buffer_init(&outgoing);
   grpc_slice_buffer_add(&outgoing, slice);
@@ -152,14 +152,14 @@ void grpc_run_bad_client_test(
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Forced Disconnect"));
     grpc_endpoint_destroy(&exec_ctx, sfd.client);
     grpc_exec_ctx_finish(&exec_ctx);
-    sfd.client = NULL;
+    sfd.client = nullptr;
   }
 
   GPR_ASSERT(gpr_event_wait(&a.done_thd, grpc_timeout_seconds_to_deadline(5)));
 
-  if (sfd.client != NULL) {
+  if (sfd.client != nullptr) {
     // Validate client stream, if requested.
-    if (client_validator != NULL) {
+    if (client_validator != nullptr) {
       gpr_timespec deadline = grpc_timeout_seconds_to_deadline(5);
       grpc_slice_buffer incoming;
       grpc_slice_buffer_init(&incoming);
@@ -175,9 +175,10 @@ void grpc_run_bad_client_test(
         grpc_exec_ctx_finish(&exec_ctx);
         do {
           GPR_ASSERT(gpr_time_cmp(deadline, gpr_now(deadline.clock_type)) > 0);
-          GPR_ASSERT(grpc_completion_queue_next(
-                         a.cq, grpc_timeout_milliseconds_to_deadline(100), NULL)
-                         .type == GRPC_QUEUE_TIMEOUT);
+          GPR_ASSERT(
+              grpc_completion_queue_next(
+                  a.cq, grpc_timeout_milliseconds_to_deadline(100), nullptr)
+                  .type == GRPC_QUEUE_TIMEOUT);
         } while (!gpr_event_get(&read_done_event));
         if (client_validator(&incoming)) break;
         gpr_log(GPR_INFO,
@@ -196,10 +197,11 @@ void grpc_run_bad_client_test(
 
   GPR_ASSERT(
       gpr_event_wait(&a.done_write, grpc_timeout_seconds_to_deadline(1)));
-  shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
-  grpc_server_shutdown_and_notify(a.server, shutdown_cq, NULL);
-  GPR_ASSERT(grpc_completion_queue_pluck(
-                 shutdown_cq, NULL, grpc_timeout_seconds_to_deadline(1), NULL)
+  shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
+  grpc_server_shutdown_and_notify(a.server, shutdown_cq, nullptr);
+  GPR_ASSERT(grpc_completion_queue_pluck(shutdown_cq, nullptr,
+                                         grpc_timeout_seconds_to_deadline(1),
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_completion_queue_destroy(shutdown_cq);
   grpc_server_destroy(a.server);
diff --git a/test/core/bad_client/bad_client.h b/test/core/bad_client/bad_client.h
index a5b01f7f2c..d3abfac2aa 100644
--- a/test/core/bad_client/bad_client.h
+++ b/test/core/bad_client/bad_client.h
@@ -28,13 +28,13 @@
 #define GRPC_BAD_CLIENT_REGISTERED_METHOD "/registered/bar"
 #define GRPC_BAD_CLIENT_REGISTERED_HOST "localhost"
 
-typedef void (*grpc_bad_client_server_side_validator)(grpc_server *server,
-                                                      grpc_completion_queue *cq,
-                                                      void *registered_method);
+typedef void (*grpc_bad_client_server_side_validator)(grpc_server* server,
+                                                      grpc_completion_queue* cq,
+                                                      void* registered_method);
 
 // Returns false if we need to read more data.
 typedef bool (*grpc_bad_client_client_stream_validator)(
-    grpc_slice_buffer *incoming);
+    grpc_slice_buffer* incoming);
 
 #define GRPC_BAD_CLIENT_DISCONNECT 1
 #define GRPC_BAD_CLIENT_LARGE_REQUEST 2
@@ -47,7 +47,7 @@ typedef bool (*grpc_bad_client_client_stream_validator)(
 void grpc_run_bad_client_test(
     grpc_bad_client_server_side_validator server_validator,
     grpc_bad_client_client_stream_validator client_validator,
-    const char *client_payload, size_t client_payload_length, uint32_t flags);
+    const char* client_payload, size_t client_payload_length, uint32_t flags);
 
 #define GRPC_RUN_BAD_CLIENT_TEST(server_validator, client_validator, payload, \
                                  flags)                                       \
diff --git a/test/core/bad_client/gen_build_yaml.py b/test/core/bad_client/gen_build_yaml.py
index 61cf1f7cd7..14c8a27334 100755
--- a/test/core/bad_client/gen_build_yaml.py
+++ b/test/core/bad_client/gen_build_yaml.py
@@ -46,7 +46,7 @@ def main():
             'build': 'private',
             'language': 'c',
             'src': [
-              'test/core/bad_client/bad_client.c'
+              'test/core/bad_client/bad_client.cc'
             ],
             'headers': [
               'test/core/bad_client/bad_client.h'
@@ -66,7 +66,7 @@ def main():
               'build': 'test',
               'language': 'c',
               'secure': 'no',
-              'src': ['test/core/bad_client/tests/%s.c' % t],
+              'src': ['test/core/bad_client/tests/%s.cc' % t],
               'vs_proj_dir': 'test',
               'exclude_iomgrs': ['uv'],
               'deps': [
diff --git a/test/core/bad_client/generate_tests.bzl b/test/core/bad_client/generate_tests.bzl
index 58b48d688f..022edf3ff3 100755
--- a/test/core/bad_client/generate_tests.bzl
+++ b/test/core/bad_client/generate_tests.bzl
@@ -38,16 +38,14 @@ BAD_CLIENT_TESTS = {
 def grpc_bad_client_tests():
   native.cc_library(
       name = 'bad_client_test',
-      srcs = ['bad_client.c'],
+      srcs = ['bad_client.cc'],
       hdrs = ['bad_client.h'],
-      copts = ['-std=c99'],
       deps = ['//test/core/util:grpc_test_util', '//:grpc', '//:gpr', '//test/core/end2end:cq_verifier']
   )
   for t, topt in BAD_CLIENT_TESTS.items():
     native.cc_test(
         name = '%s_bad_client_test' % t,
-        srcs = ['tests/%s.c' % t],
+        srcs = ['tests/%s.cc' % t],
         deps = [':bad_client_test'],
-        copts = ['-std=c99'],
     )
 
diff --git a/test/core/bad_client/tests/badreq.c b/test/core/bad_client/tests/badreq.cc
index 7d9a103e43..c30244e0cd 100644
--- a/test/core/bad_client/tests/badreq.c
+++ b/test/core/bad_client/tests/badreq.cc
@@ -27,21 +27,22 @@
   "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n" \
   "\x00\x00\x00\x04\x00\x00\x00\x00\x00" /* settings frame */
 
-static void verifier(grpc_server *server, grpc_completion_queue *cq,
-                     void *registered_method) {
+static void verifier(grpc_server* server, grpc_completion_queue* cq,
+                     void* registered_method) {
   while (grpc_server_has_open_connections(server)) {
     GPR_ASSERT(grpc_completion_queue_next(
-                   cq, grpc_timeout_milliseconds_to_deadline(20), NULL)
+                   cq, grpc_timeout_milliseconds_to_deadline(20), nullptr)
                    .type == GRPC_QUEUE_TIMEOUT);
   }
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
 
   /* invalid content type */
   GRPC_RUN_BAD_CLIENT_TEST(
-      verifier, NULL, PFX_STR
+      verifier, nullptr,
+      PFX_STR
       "\x00\x00\xc2\x01\x04\x00\x00\x00\x01"
       "\x10\x05:path\x08/foo/bar"
       "\x10\x07:scheme\x04http"
@@ -56,7 +57,8 @@ int main(int argc, char **argv) {
 
   /* invalid te */
   GRPC_RUN_BAD_CLIENT_TEST(
-      verifier, NULL, PFX_STR
+      verifier, nullptr,
+      PFX_STR
       "\x00\x00\xcb\x01\x04\x00\x00\x00\x01"
       "\x10\x05:path\x08/foo/bar"
       "\x10\x07:scheme\x04http"
@@ -73,7 +75,8 @@ int main(int argc, char **argv) {
 
   /* two path headers */
   GRPC_RUN_BAD_CLIENT_TEST(
-      verifier, NULL, PFX_STR
+      verifier, nullptr,
+      PFX_STR
       "\x00\x00\xd9\x01\x04\x00\x00\x00\x01"
       "\x10\x05:path\x08/foo/bar"
       "\x10\x05:path\x08/foo/bah"
@@ -90,7 +93,8 @@ int main(int argc, char **argv) {
 
   /* bad accept-encoding algorithm */
   GRPC_RUN_BAD_CLIENT_TEST(
-      verifier, NULL, PFX_STR
+      verifier, nullptr,
+      PFX_STR
       "\x00\x00\xd2\x01\x04\x00\x00\x00\x01"
       "\x10\x05:path\x08/foo/bar"
       "\x10\x07:scheme\x04http"
@@ -106,7 +110,8 @@ int main(int argc, char **argv) {
 
   /* bad grpc-encoding algorithm */
   GRPC_RUN_BAD_CLIENT_TEST(
-      verifier, NULL, PFX_STR
+      verifier, nullptr,
+      PFX_STR
       "\x00\x00\xf5\x01\x04\x00\x00\x00\x01"
       "\x10\x05:path\x08/foo/bar"
       "\x10\x07:scheme\x04http"
diff --git a/test/core/bad_client/tests/connection_prefix.c b/test/core/bad_client/tests/connection_prefix.c
deleted file mode 100644
index 6cc4b72314..0000000000
--- a/test/core/bad_client/tests/connection_prefix.c
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include "src/core/lib/surface/server.h"
-#include "test/core/bad_client/bad_client.h"
-
-static void verifier(grpc_server *server, grpc_completion_queue *cq,
-                     void *registered_method) {
-  while (grpc_server_has_open_connections(server)) {
-    GPR_ASSERT(grpc_completion_queue_next(
-                   cq, grpc_timeout_milliseconds_to_deadline(20), NULL)
-                   .type == GRPC_QUEUE_TIMEOUT);
-  }
-}
-
-int main(int argc, char **argv) {
-  grpc_test_init(argc, argv);
-
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, "X", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, "PX", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, "PRX", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, "PRIX", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, "PRI X", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, "PRI *X", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, "PRI * X", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, "PRI * HX", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, "PRI * HTX", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, "PRI * HTTX", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, "PRI * HTTPX", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, "PRI * HTTP/X", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, "PRI * HTTP/2X", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, "PRI * HTTP/2.X", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, "PRI * HTTP/2.0X", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, "PRI * HTTP/2.0\rX", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, "PRI * HTTP/2.0\r\nX", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, "PRI * HTTP/2.0\r\n\rX", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, "PRI * HTTP/2.0\r\n\r\nX", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, "PRI * HTTP/2.0\r\n\r\nSX", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, "PRI * HTTP/2.0\r\n\r\nSMX", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, "PRI * HTTP/2.0\r\n\r\nSM\rX", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, "PRI * HTTP/2.0\r\n\r\nSM\r\nX", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, "PRI * HTTP/2.0\r\n\r\nSM\r\n\rX",
-                           0);
-  return 0;
-}
diff --git a/test/core/bad_client/tests/connection_prefix.cc b/test/core/bad_client/tests/connection_prefix.cc
new file mode 100644
index 0000000000..47252f9f10
--- /dev/null
+++ b/test/core/bad_client/tests/connection_prefix.cc
@@ -0,0 +1,61 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "src/core/lib/surface/server.h"
+#include "test/core/bad_client/bad_client.h"
+
+static void verifier(grpc_server* server, grpc_completion_queue* cq,
+                     void* registered_method) {
+  while (grpc_server_has_open_connections(server)) {
+    GPR_ASSERT(grpc_completion_queue_next(
+                   cq, grpc_timeout_milliseconds_to_deadline(20), nullptr)
+                   .type == GRPC_QUEUE_TIMEOUT);
+  }
+}
+
+int main(int argc, char** argv) {
+  grpc_test_init(argc, argv);
+
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "X", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRIX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI X", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI *X", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI * X", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI * HX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI * HTX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI * HTTX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI * HTTPX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI * HTTP/X", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI * HTTP/2X", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI * HTTP/2.X", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI * HTTP/2.0X", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI * HTTP/2.0\rX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI * HTTP/2.0\r\nX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI * HTTP/2.0\r\n\rX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI * HTTP/2.0\r\n\r\nX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI * HTTP/2.0\r\n\r\nSX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI * HTTP/2.0\r\n\r\nSMX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI * HTTP/2.0\r\n\r\nSM\rX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI * HTTP/2.0\r\n\r\nSM\r\nX",
+                           0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI * HTTP/2.0\r\n\r\nSM\r\n\rX",
+                           0);
+  return 0;
+}
diff --git a/test/core/bad_client/tests/head_of_line_blocking.c b/test/core/bad_client/tests/head_of_line_blocking.cc
index 04485d501f..bbc5611991 100644
--- a/test/core/bad_client/tests/head_of_line_blocking.c
+++ b/test/core/bad_client/tests/head_of_line_blocking.cc
@@ -65,16 +65,16 @@ static const char prefix[] =
     "\x01\x00\x00\x27\x10"
     "";
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
-static void verifier(grpc_server *server, grpc_completion_queue *cq,
-                     void *registered_method) {
+static void verifier(grpc_server* server, grpc_completion_queue* cq,
+                     void* registered_method) {
   grpc_call_error error;
-  grpc_call *s;
-  cq_verifier *cqv = cq_verifier_create(cq);
+  grpc_call* s;
+  cq_verifier* cqv = cq_verifier_create(cq);
   grpc_metadata_array request_metadata_recv;
   gpr_timespec deadline;
-  grpc_byte_buffer *payload = NULL;
+  grpc_byte_buffer* payload = nullptr;
 
   grpc_metadata_array_init(&request_metadata_recv);
 
@@ -85,7 +85,7 @@ static void verifier(grpc_server *server, grpc_completion_queue *cq,
   CQ_EXPECT_COMPLETION(cqv, tag(101), 1);
   cq_verify(cqv);
 
-  GPR_ASSERT(payload != NULL);
+  GPR_ASSERT(payload != nullptr);
 
   grpc_metadata_array_destroy(&request_metadata_recv);
   grpc_call_unref(s);
@@ -93,20 +93,20 @@ static void verifier(grpc_server *server, grpc_completion_queue *cq,
   cq_verifier_destroy(cqv);
 }
 
-char *g_buffer;
+char* g_buffer;
 size_t g_cap = 0;
 size_t g_count = 0;
 
-static void addbuf(const void *data, size_t len) {
+static void addbuf(const void* data, size_t len) {
   if (g_count + len > g_cap) {
     g_cap = GPR_MAX(g_count + len, g_cap * 2);
-    g_buffer = gpr_realloc(g_buffer, g_cap);
+    g_buffer = static_cast<char*>(gpr_realloc(g_buffer, g_cap));
   }
   memcpy(g_buffer + g_count, data, len);
   g_count += len;
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   int i;
   grpc_test_init(argc, argv);
 
@@ -129,7 +129,7 @@ int main(int argc, char **argv) {
     addbuf(hdr, sizeof(hdr));
     addbuf(msg, FRAME_SIZE);
   }
-  grpc_run_bad_client_test(verifier, NULL, g_buffer, g_count, 0);
+  grpc_run_bad_client_test(verifier, nullptr, g_buffer, g_count, 0);
   gpr_free(g_buffer);
 
   return 0;
diff --git a/test/core/bad_client/tests/headers.c b/test/core/bad_client/tests/headers.cc
index c704dbbcb6..50bb72c493 100644
--- a/test/core/bad_client/tests/headers.c
+++ b/test/core/bad_client/tests/headers.cc
@@ -23,264 +23,310 @@
   "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n" \
   "\x00\x00\x00\x04\x00\x00\x00\x00\x00"
 
-static void verifier(grpc_server *server, grpc_completion_queue *cq,
-                     void *registered_method) {
+static void verifier(grpc_server* server, grpc_completion_queue* cq,
+                     void* registered_method) {
   while (grpc_server_has_open_connections(server)) {
     GPR_ASSERT(grpc_completion_queue_next(
-                   cq, grpc_timeout_milliseconds_to_deadline(20), NULL)
+                   cq, grpc_timeout_milliseconds_to_deadline(20), nullptr)
                    .type == GRPC_QUEUE_TIMEOUT);
   }
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
 
   /* partial http2 header prefixes */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR "\x00",
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, PFX_STR "\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR "\x00\x00",
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, PFX_STR "\x00\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR "\x00\x00\x00",
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, PFX_STR "\x00\x00\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR "\x00\x00\x00\x01",
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, PFX_STR "\x00\x00\x00\x01",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR "\x00\x00\x00\x01\x00",
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, PFX_STR "\x00\x00\x00\x01\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR "\x00\x00\x00\x01\x04",
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, PFX_STR "\x00\x00\x00\x01\x04",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR "\x00\x00\x00\x01\x05",
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, PFX_STR "\x00\x00\x00\x01\x05",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR "\x00\x00\x00\x01\x04\x00",
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR "\x00\x00\x00\x01\x04\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
                            PFX_STR "\x00\x00\x00\x01\x04\x00\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
                            PFX_STR "\x00\x00\x00\x01\x04\x00\x00\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
                            PFX_STR "\x00\x00\x00\x01\x04\x00\x00\x00\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
                            PFX_STR "\x00\x00\x00\x01\x04\x00\x00\x00\x01",
                            GRPC_BAD_CLIENT_DISCONNECT);
 
   /* test adding prioritization data */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x01\x01\x24\x00\x00\x00\x01"
                            "\x00",
                            0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x02\x01\x24\x00\x00\x00\x01"
                            "\x00\x00",
                            0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x03\x01\x24\x00\x00\x00\x01"
                            "\x00\x00\x00",
                            0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x04\x01\x24\x00\x00\x00\x01"
                            "\x00\x00\x00\x00",
                            0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x05\x01\x24\x00\x00\x00\x01"
                            "",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x05\x01\x24\x00\x00\x00\x01"
                            "\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x05\x01\x24\x00\x00\x00\x01"
                            "\x00\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x05\x01\x24\x00\x00\x00\x01"
                            "\x00\x00\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x05\x01\x24\x00\x00\x00\x01"
                            "\x00\x00\x00\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x05\x01\x24\x00\x00\x00\x01"
                            "\x00\x00\x00\x00\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
 
   /* test looking up an invalid index */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x01\x01\x04\x00\x00\x00\x01"
                            "\xfe",
                            0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x04\x01\x04\x00\x00\x00\x01"
                            "\x7f\x7f\x01"
                            "a",
                            0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x04\x01\x04\x00\x00\x00\x01"
                            "\x0f\x7f\x01"
                            "a",
                            0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x04\x01\x04\x00\x00\x00\x01"
                            "\x1f\x7f\x01"
                            "a",
                            0);
   /* test nvr, not indexed in static table */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x03\x01\x04\x00\x00\x00\x01"
                            "\x01\x01"
                            "a",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x03\x01\x04\x00\x00\x00\x01"
                            "\x11\x01"
                            "a",
                            GRPC_BAD_CLIENT_DISCONNECT);
   /* illegal op code */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x01\x01\x04\x00\x00\x00\x01"
                            "\x80",
                            0);
   /* parse some long indices */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x02\x01\x04\x00\x00\x00\x01"
                            "\xff\x00",
                            0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x03\x01\x04\x00\x00\x00\x01"
                            "\xff\x80\x00",
                            0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x04\x01\x04\x00\x00\x00\x01"
                            "\xff\x80\x80\x00",
                            0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x05\x01\x04\x00\x00\x00\x01"
                            "\xff\x80\x80\x80\x00",
                            0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x06\x01\x04\x00\x00\x00\x01"
                            "\xff\x80\x80\x80\x80\x00",
                            0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x07\x01\x04\x00\x00\x00\x01"
                            "\xff\x80\x80\x80\x80\x80\x00",
                            0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x08\x01\x04\x00\x00\x00\x01"
                            "\xff",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x08\x01\x04\x00\x00\x00\x01"
                            "\xff\x80",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x08\x01\x04\x00\x00\x00\x01"
                            "\xff\x80\x80",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x08\x01\x04\x00\x00\x00\x01"
                            "\xff\x80\x80\x80",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x08\x01\x04\x00\x00\x00\x01"
                            "\xff\x80\x80\x80\x80",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x08\x01\x04\x00\x00\x00\x01"
                            "\xff\x80\x80\x80\x80\x80",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x08\x01\x04\x00\x00\x00\x01"
                            "\xff\x80\x80\x80\x80\x80\x80",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x08\x01\x04\x00\x00\x00\x01"
                            "\xff\x80\x80\x80\x80\x80\x80\x00",
                            0);
   /* overflow on byte 4 */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x06\x01\x04\x00\x00\x00\x01"
                            "\xff\x80\x80\x80\x80\x7f",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x06\x01\x04\x00\x00\x00\x01"
                            "\xff\xff\xff\xff\xff\x0f",
                            GRPC_BAD_CLIENT_DISCONNECT);
   /* overflow after byte 4 */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x08\x01\x04\x00\x00\x00\x01"
                            "\xff\x80\x80\x80\x80\x80\x80\x02",
                            0);
   /* end of headers mid-opcode */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x01\x01\x04\x00\x00\x00\x01"
                            "\x01",
                            GRPC_BAD_CLIENT_DISCONNECT);
 
   /* dynamic table size update: set to default */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x03\x01\x04\x00\x00\x00\x01"
                            "\x3f\xe1\x1f",
                            GRPC_BAD_CLIENT_DISCONNECT);
   /* dynamic table size update: set too large */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x03\x01\x04\x00\x00\x00\x01"
                            "\x3f\xf1\x1f",
                            0);
   /* dynamic table size update: set twice */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x04\x01\x04\x00\x00\x00\x01"
                            "\x20\x3f\xe1\x1f",
                            GRPC_BAD_CLIENT_DISCONNECT);
   /* dynamic table size update: set thrice */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x03\x01\x04\x00\x00\x00\x01"
                            "\x20\x20\x20",
                            0);
 
   /* non-ending header followed by continuation frame */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x00\x01\x00\x00\x00\x00\x01"
                            "\x00\x00\x00\x09\x04\x00\x00\x00\x01",
                            GRPC_BAD_CLIENT_DISCONNECT);
   /* non-ending header followed by non-continuation frame */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x00\x01\x00\x00\x00\x00\x01"
                            "\x00\x00\x00\x00\x04\x00\x00\x00\x01",
                            0);
   /* non-ending header followed by a continuation frame for a different stream
    */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x00\x01\x04\x00\x00\x00\x01"
                            "\x00\x00\x00\x01\x00\x00\x00\x00\x03"
                            "\x00\x00\x00\x09\x04\x00\x00\x00\x01",
                            0);
   /* opening with a continuation frame */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
                            PFX_STR "\x00\x00\x00\x09\x04\x00\x00\x00\x01", 0);
   /* three header frames */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x00\x01\x04\x00\x00\x00\x01"
                            "\x00\x00\x00\x01\x04\x00\x00\x00\x01"
                            "\x00\x00\x00\x01\x04\x00\x00\x00\x01",
                            GRPC_BAD_CLIENT_DISCONNECT);
 
   /* an invalid header found with fuzzing */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
                            PFX_STR "\x00\x00\x00\x01\x39\x67\xed\x1d\x64",
                            GRPC_BAD_CLIENT_DISCONNECT);
 
   /* a badly encoded timeout value */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x19\x01\x04\x00\x00\x00\x01"
                            "\x10\x0cgrpc-timeout\x0a"
                            "15 seconds",
                            GRPC_BAD_CLIENT_DISCONNECT);
   /* a badly encoded timeout value: twice (catches caching) */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x19\x01\x04\x00\x00\x00\x01"
                            "\x10\x0cgrpc-timeout\x0a"
                            "15 seconds"
diff --git a/test/core/bad_client/tests/initial_settings_frame.c b/test/core/bad_client/tests/initial_settings_frame.cc
index 0696ef9383..edc52f503e 100644
--- a/test/core/bad_client/tests/initial_settings_frame.c
+++ b/test/core/bad_client/tests/initial_settings_frame.cc
@@ -22,85 +22,87 @@
 #define PFX_STR "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
 #define ONE_SETTING_HDR "\x00\x00\x06\x04\x00\x00\x00\x00\x00"
 
-static void verifier(grpc_server *server, grpc_completion_queue *cq,
-                     void *registered_method) {
+static void verifier(grpc_server* server, grpc_completion_queue* cq,
+                     void* registered_method) {
   while (grpc_server_has_open_connections(server)) {
     GPR_ASSERT(grpc_completion_queue_next(
-                   cq, grpc_timeout_milliseconds_to_deadline(20), NULL)
+                   cq, grpc_timeout_milliseconds_to_deadline(20), nullptr)
                    .type == GRPC_QUEUE_TIMEOUT);
   }
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
 
   /* various partial prefixes */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR "\x00",
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, PFX_STR "\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR "\x00\x00",
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, PFX_STR "\x00\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR "\x00\x00\x00",
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, PFX_STR "\x00\x00\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR "\x06",
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, PFX_STR "\x06",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR "\x00\x06",
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, PFX_STR "\x00\x06",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR "\x00\x00\x06",
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, PFX_STR "\x00\x00\x06",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR "\x00\x00\x00\x04",
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, PFX_STR "\x00\x00\x00\x04",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR "\x00\x00\x00\x04\x00",
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, PFX_STR "\x00\x00\x00\x04\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR "\x00\x00\x00\x04\x01",
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, PFX_STR "\x00\x00\x00\x04\x01",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR "\x00\x00\x00\x04\xff",
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, PFX_STR "\x00\x00\x00\x04\xff",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR "\x00\x00\x00\x04\x00\x00",
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR "\x00\x00\x00\x04\x00\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
                            PFX_STR "\x00\x00\x00\x04\x00\x00\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
                            PFX_STR "\x00\x00\x00\x04\x00\x00\x00\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
   /* must not send frames with stream id != 0 */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
                            PFX_STR "\x00\x00\x00\x04\x00\x00\x00\x00\x01", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
                            PFX_STR "\x00\x00\x00\x04\x00\x40\x00\x00\x00", 0);
   /* settings frame must be a multiple of six bytes long */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
                            PFX_STR "\x00\x00\x01\x04\x00\x00\x00\x00\x00", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
                            PFX_STR "\x00\x00\x02\x04\x00\x00\x00\x00\x00", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
                            PFX_STR "\x00\x00\x03\x04\x00\x00\x00\x00\x00", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
                            PFX_STR "\x00\x00\x04\x04\x00\x00\x00\x00\x00", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
                            PFX_STR "\x00\x00\x05\x04\x00\x00\x00\x00\x00", 0);
   /* some settings values are illegal */
   /* max frame size = 0 */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
                            PFX_STR ONE_SETTING_HDR "\x00\x05\x00\x00\x00\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
                            PFX_STR ONE_SETTING_HDR "\x00\x06\xff\xff\xff\xff",
                            GRPC_BAD_CLIENT_DISCONNECT);
   /* update intiial window size */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
                            PFX_STR ONE_SETTING_HDR "\x00\x04\x00\x01\x00\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
   /* ack with data */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x00\x04\x00\x00\x00\x00\x00"
                            "\x00\x00\x01\x04\x01\x00\x00\x00\x00",
                            0);
   /* settings frame with invalid flags */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
                            PFX_STR "\x00\x00\x00\x04\x10\x00\x00\x00\x00", 0);
   /* unknown settings should be ignored */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
                            PFX_STR ONE_SETTING_HDR "\x00\x99\x00\x00\x00\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
 
diff --git a/test/core/bad_client/tests/large_metadata.c b/test/core/bad_client/tests/large_metadata.cc
index ca3d234be9..1ce0f28967 100644
--- a/test/core/bad_client/tests/large_metadata.c
+++ b/test/core/bad_client/tests/large_metadata.cc
@@ -93,14 +93,14 @@
   "\x10\x02te\x08trailers"                                                                 \
   "\x10\x0auser-agent\"bad-client grpc-c/0.12.0.0 (linux)"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
-static void server_verifier(grpc_server *server, grpc_completion_queue *cq,
-                            void *registered_method) {
+static void server_verifier(grpc_server* server, grpc_completion_queue* cq,
+                            void* registered_method) {
   grpc_call_error error;
-  grpc_call *s;
+  grpc_call* s;
   grpc_call_details call_details;
-  cq_verifier *cqv = cq_verifier_create(cq);
+  cq_verifier* cqv = cq_verifier_create(cq);
   grpc_metadata_array request_metadata_recv;
 
   grpc_call_details_init(&call_details);
@@ -121,13 +121,13 @@ static void server_verifier(grpc_server *server, grpc_completion_queue *cq,
   cq_verifier_destroy(cqv);
 }
 
-static void server_verifier_sends_too_much_metadata(grpc_server *server,
-                                                    grpc_completion_queue *cq,
-                                                    void *registered_method) {
+static void server_verifier_sends_too_much_metadata(grpc_server* server,
+                                                    grpc_completion_queue* cq,
+                                                    void* registered_method) {
   grpc_call_error error;
-  grpc_call *s;
+  grpc_call* s;
   grpc_call_details call_details;
-  cq_verifier *cqv = cq_verifier_create(cq);
+  cq_verifier* cqv = cq_verifier_create(cq);
   grpc_metadata_array request_metadata_recv;
 
   grpc_call_details_init(&call_details);
@@ -154,8 +154,8 @@ static void server_verifier_sends_too_much_metadata(grpc_server *server,
   op.data.send_initial_metadata.count = 1;
   op.data.send_initial_metadata.metadata = &meta;
   op.flags = 0;
-  op.reserved = NULL;
-  error = grpc_call_start_batch(s, &op, 1, tag(102), NULL);
+  op.reserved = nullptr;
+  error = grpc_call_start_batch(s, &op, 1, tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
   CQ_EXPECT_COMPLETION(cqv, tag(102), 0);  // Operation fails.
   cq_verify(cqv);
@@ -167,10 +167,10 @@ static void server_verifier_sends_too_much_metadata(grpc_server *server,
   cq_verifier_destroy(cqv);
 }
 
-static bool client_validator(grpc_slice_buffer *incoming) {
+static bool client_validator(grpc_slice_buffer* incoming) {
   for (size_t i = 0; i < incoming->count; ++i) {
-    const char *s = (const char *)GRPC_SLICE_START_PTR(incoming->slices[i]);
-    char *hex = gpr_dump(s, GRPC_SLICE_LENGTH(incoming->slices[i]),
+    const char* s = (const char*)GRPC_SLICE_START_PTR(incoming->slices[i]);
+    char* hex = gpr_dump(s, GRPC_SLICE_LENGTH(incoming->slices[i]),
                          GPR_DUMP_HEX | GPR_DUMP_ASCII);
     gpr_log(GPR_INFO, "RESPONSE SLICE %" PRIdPTR ": %s", i, hex);
     gpr_free(hex);
@@ -183,7 +183,7 @@ static bool client_validator(grpc_slice_buffer *incoming) {
   GPR_ASSERT(last_frame_buffer.count == 1);
   grpc_slice last_frame = last_frame_buffer.slices[0];
 
-  const uint8_t *p = GRPC_SLICE_START_PTR(last_frame);
+  const uint8_t* p = GRPC_SLICE_START_PTR(last_frame);
   bool success =
       // Length == 4
       *p++ != 0 || *p++ != 0 || *p++ != 4 ||
@@ -204,7 +204,7 @@ static bool client_validator(grpc_slice_buffer *incoming) {
   return success;
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   int i;
 
   grpc_test_init(argc, argv);
@@ -213,14 +213,14 @@ int main(int argc, char **argv) {
   gpr_strvec headers;
   gpr_strvec_init(&headers);
   for (i = 0; i < NUM_HEADERS; ++i) {
-    char *str;
+    char* str;
     gpr_asprintf(&str, "%s%02d%s",
                  PFX_TOO_MUCH_METADATA_FROM_CLIENT_HEADER_START_STR, i,
                  PFX_TOO_MUCH_METADATA_FROM_CLIENT_HEADER_END_STR);
     gpr_strvec_add(&headers, str);
   }
   size_t headers_len;
-  const char *client_headers = gpr_strvec_flatten(&headers, &headers_len);
+  const char* client_headers = gpr_strvec_flatten(&headers, &headers_len);
   gpr_strvec_destroy(&headers);
   char client_payload[PFX_TOO_MUCH_METADATA_FROM_CLIENT_PAYLOAD_SIZE] =
       PFX_TOO_MUCH_METADATA_FROM_CLIENT_PREFIX_STR;
@@ -229,7 +229,7 @@ int main(int argc, char **argv) {
       client_headers, headers_len);
   GRPC_RUN_BAD_CLIENT_TEST(server_verifier, client_validator, client_payload,
                            0);
-  gpr_free((void *)client_headers);
+  gpr_free((void*)client_headers);
 
   // Test sending more metadata than the client will accept.
   GRPC_RUN_BAD_CLIENT_TEST(server_verifier_sends_too_much_metadata,
diff --git a/test/core/bad_client/tests/server_registered_method.c b/test/core/bad_client/tests/server_registered_method.cc
index f52350302b..6613c94b41 100644
--- a/test/core/bad_client/tests/server_registered_method.c
+++ b/test/core/bad_client/tests/server_registered_method.cc
@@ -38,16 +38,16 @@
   "\x10\x02te\x08trailers"                                    \
   "\x10\x0auser-agent\"bad-client grpc-c/0.12.0.0 (linux)"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
-static void verifier_succeeds(grpc_server *server, grpc_completion_queue *cq,
-                              void *registered_method) {
+static void verifier_succeeds(grpc_server* server, grpc_completion_queue* cq,
+                              void* registered_method) {
   grpc_call_error error;
-  grpc_call *s;
-  cq_verifier *cqv = cq_verifier_create(cq);
+  grpc_call* s;
+  cq_verifier* cqv = cq_verifier_create(cq);
   grpc_metadata_array request_metadata_recv;
   gpr_timespec deadline;
-  grpc_byte_buffer *payload = NULL;
+  grpc_byte_buffer* payload = nullptr;
 
   grpc_metadata_array_init(&request_metadata_recv);
 
@@ -58,7 +58,7 @@ static void verifier_succeeds(grpc_server *server, grpc_completion_queue *cq,
   CQ_EXPECT_COMPLETION(cqv, tag(101), 1);
   cq_verify(cqv);
 
-  GPR_ASSERT(payload != NULL);
+  GPR_ASSERT(payload != nullptr);
 
   grpc_metadata_array_destroy(&request_metadata_recv);
   grpc_call_unref(s);
@@ -66,57 +66,60 @@ static void verifier_succeeds(grpc_server *server, grpc_completion_queue *cq,
   cq_verifier_destroy(cqv);
 }
 
-static void verifier_fails(grpc_server *server, grpc_completion_queue *cq,
-                           void *registered_method) {
+static void verifier_fails(grpc_server* server, grpc_completion_queue* cq,
+                           void* registered_method) {
   while (grpc_server_has_open_connections(server)) {
     GPR_ASSERT(grpc_completion_queue_next(
-                   cq, grpc_timeout_milliseconds_to_deadline(20), NULL)
+                   cq, grpc_timeout_milliseconds_to_deadline(20), nullptr)
                    .type == GRPC_QUEUE_TIMEOUT);
   }
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
 
   /* body generated with
    * tools/codegen/core/gen_server_registered_method_bad_client_test_body.py */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier_fails, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(verifier_fails, nullptr,
                            PFX_STR "\x00\x00\x00\x00\x00\x00\x00\x00\x01",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier_fails, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(verifier_fails, nullptr,
                            PFX_STR "\x00\x00\x01\x00\x00\x00\x00\x00\x01\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier_fails, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier_fails, nullptr,
+                           PFX_STR
                            "\x00\x00\x02\x00\x00\x00\x00\x00\x01\x00\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier_fails, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier_fails, nullptr,
+                           PFX_STR
                            "\x00\x00\x03\x00\x00\x00\x00\x00\x01\x00\x00\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
   GRPC_RUN_BAD_CLIENT_TEST(
-      verifier_fails, NULL,
+      verifier_fails, nullptr,
       PFX_STR "\x00\x00\x04\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00",
       GRPC_BAD_CLIENT_DISCONNECT);
   GRPC_RUN_BAD_CLIENT_TEST(
-      verifier_succeeds, NULL,
+      verifier_succeeds, nullptr,
       PFX_STR "\x00\x00\x05\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00", 0);
   GRPC_RUN_BAD_CLIENT_TEST(
-      verifier_fails, NULL,
+      verifier_fails, nullptr,
       PFX_STR "\x00\x00\x05\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x01",
       GRPC_BAD_CLIENT_DISCONNECT);
   GRPC_RUN_BAD_CLIENT_TEST(
-      verifier_succeeds, NULL,
+      verifier_succeeds, nullptr,
       PFX_STR "\x00\x00\x06\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x01\x00",
       0);
   GRPC_RUN_BAD_CLIENT_TEST(
-      verifier_fails, NULL,
+      verifier_fails, nullptr,
       PFX_STR "\x00\x00\x05\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x02",
       GRPC_BAD_CLIENT_DISCONNECT);
   GRPC_RUN_BAD_CLIENT_TEST(
-      verifier_fails, NULL,
+      verifier_fails, nullptr,
       PFX_STR "\x00\x00\x06\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x02\x00",
       GRPC_BAD_CLIENT_DISCONNECT);
   GRPC_RUN_BAD_CLIENT_TEST(
-      verifier_succeeds, NULL, PFX_STR
+      verifier_succeeds, nullptr,
+      PFX_STR
       "\x00\x00\x07\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x02\x00\x00",
       0);
 
diff --git a/test/core/bad_client/tests/simple_request.c b/test/core/bad_client/tests/simple_request.cc
index a516632819..9f4a03e69b 100644
--- a/test/core/bad_client/tests/simple_request.c
+++ b/test/core/bad_client/tests/simple_request.cc
@@ -83,14 +83,14 @@
   "\x10\x0cgrpc-timeout\x02"                                                \
   "5S"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
-static void verifier(grpc_server *server, grpc_completion_queue *cq,
-                     void *registered_method) {
+static void verifier(grpc_server* server, grpc_completion_queue* cq,
+                     void* registered_method) {
   grpc_call_error error;
-  grpc_call *s;
+  grpc_call* s;
   grpc_call_details call_details;
-  cq_verifier *cqv = cq_verifier_create(cq);
+  cq_verifier* cqv = cq_verifier_create(cq);
   grpc_metadata_array request_metadata_recv;
 
   grpc_call_details_init(&call_details);
@@ -111,55 +111,57 @@ static void verifier(grpc_server *server, grpc_completion_queue *cq,
   cq_verifier_destroy(cqv);
 }
 
-static void failure_verifier(grpc_server *server, grpc_completion_queue *cq,
-                             void *registered_method) {
+static void failure_verifier(grpc_server* server, grpc_completion_queue* cq,
+                             void* registered_method) {
   while (grpc_server_has_open_connections(server)) {
     GPR_ASSERT(grpc_completion_queue_next(
-                   cq, grpc_timeout_milliseconds_to_deadline(20), NULL)
+                   cq, grpc_timeout_milliseconds_to_deadline(20), nullptr)
                    .type == GRPC_QUEUE_TIMEOUT);
   }
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
 
   /* basic request: check that things are working */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR, 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR_UNUSUAL, 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR_UNUSUAL2, 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, PFX_STR, 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, PFX_STR_UNUSUAL, 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, PFX_STR_UNUSUAL2, 0);
 
   /* push an illegal data frame */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x05\x00\x00\x00\x00\x00\x01"
                            "\x34\x00\x00\x00\x00",
                            0);
 
   /* push a data frame with bad flags */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
                            PFX_STR "\x00\x00\x00\x00\x02\x00\x00\x00\x01", 0);
   /* push a window update with a bad length */
-  GRPC_RUN_BAD_CLIENT_TEST(failure_verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(failure_verifier, nullptr,
                            PFX_STR "\x00\x00\x01\x08\x00\x00\x00\x00\x01", 0);
   /* push a window update with bad flags */
-  GRPC_RUN_BAD_CLIENT_TEST(failure_verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(failure_verifier, nullptr,
                            PFX_STR "\x00\x00\x00\x08\x10\x00\x00\x00\x01", 0);
   /* push a window update with bad data */
-  GRPC_RUN_BAD_CLIENT_TEST(failure_verifier, NULL, PFX_STR
+  GRPC_RUN_BAD_CLIENT_TEST(failure_verifier, nullptr,
+                           PFX_STR
                            "\x00\x00\x04\x08\x00\x00\x00\x00\x01"
                            "\xff\xff\xff\xff",
                            0);
   /* push a short goaway */
-  GRPC_RUN_BAD_CLIENT_TEST(failure_verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(failure_verifier, nullptr,
                            PFX_STR "\x00\x00\x04\x07\x00\x00\x00\x00\x00", 0);
   /* disconnect before sending goaway */
-  GRPC_RUN_BAD_CLIENT_TEST(failure_verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(failure_verifier, nullptr,
                            PFX_STR "\x00\x01\x12\x07\x00\x00\x00\x00\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
   /* push a rst_stream with a bad length */
-  GRPC_RUN_BAD_CLIENT_TEST(failure_verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(failure_verifier, nullptr,
                            PFX_STR "\x00\x00\x01\x03\x00\x00\x00\x00\x01", 0);
   /* push a rst_stream with bad flags */
-  GRPC_RUN_BAD_CLIENT_TEST(failure_verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(failure_verifier, nullptr,
                            PFX_STR "\x00\x00\x00\x03\x10\x00\x00\x00\x01", 0);
 
   return 0;
diff --git a/test/core/bad_client/tests/unknown_frame.c b/test/core/bad_client/tests/unknown_frame.cc
index 448803d12b..d962a4244d 100644
--- a/test/core/bad_client/tests/unknown_frame.c
+++ b/test/core/bad_client/tests/unknown_frame.cc
@@ -23,20 +23,20 @@
   "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n" \
   "\x00\x00\x00\x04\x00\x00\x00\x00\x00"
 
-static void verifier(grpc_server *server, grpc_completion_queue *cq,
-                     void *registered_method) {
+static void verifier(grpc_server* server, grpc_completion_queue* cq,
+                     void* registered_method) {
   while (grpc_server_has_open_connections(server)) {
     GPR_ASSERT(grpc_completion_queue_next(
-                   cq, grpc_timeout_milliseconds_to_deadline(20), NULL)
+                   cq, grpc_timeout_milliseconds_to_deadline(20), nullptr)
                    .type == GRPC_QUEUE_TIMEOUT);
   }
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
 
   /* test adding prioritization data */
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, NULL,
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
                            PFX_STR "\x00\x00\x00\x88\x00\x00\x00\x00\x01",
                            GRPC_BAD_CLIENT_DISCONNECT);
 
diff --git a/test/core/bad_client/tests/window_overflow.c b/test/core/bad_client/tests/window_overflow.cc
index e4b5f9711b..f4bd81828b 100644
--- a/test/core/bad_client/tests/window_overflow.c
+++ b/test/core/bad_client/tests/window_overflow.cc
@@ -42,29 +42,29 @@
   "\x10\x02te\x08trailers"                                                 \
   "\x10\x0auser-agent\"bad-client grpc-c/0.12.0.0 (linux)"
 
-static void verifier(grpc_server *server, grpc_completion_queue *cq,
-                     void *registered_method) {
+static void verifier(grpc_server* server, grpc_completion_queue* cq,
+                     void* registered_method) {
   while (grpc_server_has_open_connections(server)) {
     GPR_ASSERT(grpc_completion_queue_next(
-                   cq, grpc_timeout_milliseconds_to_deadline(20), NULL)
+                   cq, grpc_timeout_milliseconds_to_deadline(20), nullptr)
                    .type == GRPC_QUEUE_TIMEOUT);
   }
 }
 
-char *g_buffer;
+char* g_buffer;
 size_t g_cap = 0;
 size_t g_count = 0;
 
-static void addbuf(const void *data, size_t len) {
+static void addbuf(const void* data, size_t len) {
   if (g_count + len > g_cap) {
     g_cap = GPR_MAX(g_count + len, g_cap * 2);
-    g_buffer = gpr_realloc(g_buffer, g_cap);
+    g_buffer = static_cast<char*>(gpr_realloc(g_buffer, g_cap));
   }
   memcpy(g_buffer + g_count, data, len);
   g_count += len;
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   int i, j;
 #define MAX_FRAME_SIZE 16384
 #define MESSAGES_PER_FRAME (MAX_FRAME_SIZE / 5)
@@ -90,7 +90,7 @@ int main(int argc, char **argv) {
       addbuf(message, sizeof(message));
     }
   }
-  grpc_run_bad_client_test(verifier, NULL, g_buffer, g_count,
+  grpc_run_bad_client_test(verifier, nullptr, g_buffer, g_count,
                            GRPC_BAD_CLIENT_LARGE_REQUEST);
   gpr_free(g_buffer);
 
diff --git a/test/core/bad_ssl/bad_ssl_test.c b/test/core/bad_ssl/bad_ssl_test.cc
index 793627bcdc..0e74a62f19 100644
--- a/test/core/bad_ssl/bad_ssl_test.c
+++ b/test/core/bad_ssl/bad_ssl_test.cc
@@ -32,13 +32,13 @@
 #include "test/core/util/port.h"
 #include "test/core/util/test_config.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
-static void run_test(const char *target, size_t nops) {
-  grpc_channel_credentials *ssl_creds =
-      grpc_ssl_credentials_create(NULL, NULL, NULL);
-  grpc_channel *channel;
-  grpc_call *c;
+static void run_test(const char* target, size_t nops) {
+  grpc_channel_credentials* ssl_creds =
+      grpc_ssl_credentials_create(nullptr, nullptr, nullptr);
+  grpc_channel* channel;
+  grpc_call* c;
 
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
@@ -46,15 +46,16 @@ static void run_test(const char *target, size_t nops) {
   grpc_status_code status;
   grpc_call_error error;
   gpr_timespec deadline = grpc_timeout_seconds_to_deadline(5);
-  grpc_completion_queue *cq = grpc_completion_queue_create_for_next(NULL);
-  cq_verifier *cqv = cq_verifier_create(cq);
+  grpc_completion_queue* cq = grpc_completion_queue_create_for_next(nullptr);
+  cq_verifier* cqv = cq_verifier_create(cq);
 
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
 
-  grpc_arg ssl_name_override = {GRPC_ARG_STRING,
-                                GRPC_SSL_TARGET_NAME_OVERRIDE_ARG,
-                                {"foo.test.google.fr"}};
+  grpc_arg ssl_name_override = {
+      GRPC_ARG_STRING,
+      const_cast<char*>(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG),
+      {const_cast<char*>("foo.test.google.fr")}};
   grpc_channel_args args;
 
   args.num_args = 1;
@@ -63,36 +64,36 @@ static void run_test(const char *target, size_t nops) {
   grpc_metadata_array_init(&initial_metadata_recv);
   grpc_metadata_array_init(&trailing_metadata_recv);
 
-  channel = grpc_secure_channel_create(ssl_creds, target, &args, NULL);
+  channel = grpc_secure_channel_create(ssl_creds, target, &args, nullptr);
   grpc_slice host = grpc_slice_from_static_string("foo.test.google.fr:1234");
-  c = grpc_channel_create_call(channel, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
+  c = grpc_channel_create_call(channel, nullptr, GRPC_PROPAGATE_DEFAULTS, cq,
                                grpc_slice_from_static_string("/foo"), &host,
-                               deadline, NULL);
+                               deadline, nullptr);
 
   memset(ops, 0, sizeof(ops));
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = GRPC_INITIAL_METADATA_WAIT_FOR_READY;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, nops, tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, nops, tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
@@ -111,18 +112,18 @@ static void run_test(const char *target, size_t nops) {
   grpc_channel_credentials_release(ssl_creds);
 }
 
-int main(int argc, char **argv) {
-  char *me = argv[0];
-  char *lslash = strrchr(me, '/');
-  char *lunder = strrchr(me, '_');
-  char *tmp;
+int main(int argc, char** argv) {
+  char* me = argv[0];
+  char* lslash = strrchr(me, '/');
+  char* lunder = strrchr(me, '_');
+  char* tmp;
   char root[1024];
   char test[64];
   int port = grpc_pick_unused_port_or_die();
-  char *args[10];
+  char* args[10];
   int status;
   size_t i;
-  gpr_subprocess *svr;
+  gpr_subprocess* svr;
   /* figure out where we are */
   if (lslash) {
     memcpy(root, me, (size_t)(lslash - me));
@@ -141,9 +142,9 @@ int main(int argc, char **argv) {
   /* start the server */
   gpr_asprintf(&args[0], "%s/bad_ssl_%s_server%s", root, test,
                gpr_subprocess_binary_extension());
-  args[1] = "--bind";
+  args[1] = const_cast<char*>("--bind");
   gpr_join_host_port(&args[2], "::", port);
-  svr = gpr_subprocess_create(4, (const char **)args);
+  svr = gpr_subprocess_create(4, (const char**)args);
   gpr_free(args[0]);
 
   for (i = 3; i <= 4; i++) {
diff --git a/test/core/bad_ssl/gen_build_yaml.py b/test/core/bad_ssl/gen_build_yaml.py
index 30fdb5ea02..6b78e9c7aa 100755
--- a/test/core/bad_ssl/gen_build_yaml.py
+++ b/test/core/bad_ssl/gen_build_yaml.py
@@ -38,7 +38,7 @@ def main():
               'name': 'bad_ssl_test_server',
               'build': 'private',
               'language': 'c',
-              'src': ['test/core/bad_ssl/server_common.c'],
+              'src': ['test/core/bad_ssl/server_common.cc'],
               'headers': ['test/core/bad_ssl/server_common.h'],
               'vs_proj_dir': 'test',
               'platforms': ['linux', 'posix', 'mac'],
@@ -56,7 +56,7 @@ def main():
               'build': 'test',
               'language': 'c',
               'run': False,
-              'src': ['test/core/bad_ssl/servers/%s.c' % t],
+              'src': ['test/core/bad_ssl/servers/%s.cc' % t],
               'vs_proj_dir': 'test/bad_ssl',
               'platforms': ['linux', 'posix', 'mac'],
               'deps': [
@@ -73,7 +73,7 @@ def main():
               'cpu_cost': BAD_CLIENT_TESTS[t].cpu_cost,
               'build': 'test',
               'language': 'c',
-              'src': ['test/core/bad_ssl/bad_ssl_test.c'],
+              'src': ['test/core/bad_ssl/bad_ssl_test.cc'],
               'vs_proj_dir': 'test',
               'platforms': ['linux', 'posix', 'mac'],
               'deps': [
diff --git a/test/core/bad_ssl/generate_tests.bzl b/test/core/bad_ssl/generate_tests.bzl
index b61fabc051..b7cb8f86e6 100755
--- a/test/core/bad_ssl/generate_tests.bzl
+++ b/test/core/bad_ssl/generate_tests.bzl
@@ -24,14 +24,14 @@ BAD_SSL_TESTS = ['cert', 'alpn']
 def grpc_bad_ssl_tests():
   native.cc_library(
       name = 'bad_ssl_test_server',
-      srcs = ['server_common.c'],
+      srcs = ['server_common.cc'],
       hdrs = ['server_common.h'],
       deps = ['//test/core/util:grpc_test_util', '//:grpc', '//test/core/end2end:ssl_test_data']
   )
   for t in BAD_SSL_TESTS:
     native.cc_test(
         name = 'bad_ssl_%s_server' % t,
-        srcs = ['servers/%s.c' % t],
+        srcs = ['servers/%s.cc' % t],
         deps = [':bad_ssl_test_server'],
     )
 
diff --git a/test/core/bad_ssl/server_common.c b/test/core/bad_ssl/server_common.cc
index 0588d43c38..08842b8350 100644
--- a/test/core/bad_ssl/server_common.c
+++ b/test/core/bad_ssl/server_common.cc
@@ -32,9 +32,9 @@ static int got_sigint = 0;
 
 static void sigint_handler(int x) { got_sigint = 1; }
 
-const char *bad_ssl_addr(int argc, char **argv) {
-  gpr_cmdline *cl;
-  char *addr = NULL;
+const char* bad_ssl_addr(int argc, char** argv) {
+  gpr_cmdline* cl;
+  const char* addr = nullptr;
   cl = gpr_cmdline_create("test server");
   gpr_cmdline_add_string(cl, "bind", "Bind host:port", &addr);
   gpr_cmdline_parse(cl, argc, argv);
@@ -43,49 +43,50 @@ const char *bad_ssl_addr(int argc, char **argv) {
   return addr;
 }
 
-void bad_ssl_run(grpc_server *server) {
+void bad_ssl_run(grpc_server* server) {
   int shutdown_started = 0;
   int shutdown_finished = 0;
   grpc_event ev;
   grpc_call_error error;
-  grpc_call *s = NULL;
+  grpc_call* s = nullptr;
   grpc_call_details call_details;
   grpc_metadata_array request_metadata_recv;
 
-  grpc_completion_queue *cq = grpc_completion_queue_create_for_next(NULL);
-  grpc_completion_queue *shutdown_cq;
+  grpc_completion_queue* cq = grpc_completion_queue_create_for_next(nullptr);
+  grpc_completion_queue* shutdown_cq;
 
   grpc_call_details_init(&call_details);
   grpc_metadata_array_init(&request_metadata_recv);
 
-  grpc_server_register_completion_queue(server, cq, NULL);
+  grpc_server_register_completion_queue(server, cq, nullptr);
   grpc_server_start(server);
 
   error = grpc_server_request_call(server, &s, &call_details,
-                                   &request_metadata_recv, cq, cq, (void *)1);
+                                   &request_metadata_recv, cq, cq, (void*)1);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   signal(SIGINT, sigint_handler);
   while (!shutdown_finished) {
     if (got_sigint && !shutdown_started) {
       gpr_log(GPR_INFO, "Shutting down due to SIGINT");
-      shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
-      grpc_server_shutdown_and_notify(server, shutdown_cq, NULL);
-      GPR_ASSERT(
-          grpc_completion_queue_pluck(shutdown_cq, NULL,
-                                      grpc_timeout_seconds_to_deadline(5), NULL)
-              .type == GRPC_OP_COMPLETE);
+      shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
+      grpc_server_shutdown_and_notify(server, shutdown_cq, nullptr);
+      GPR_ASSERT(grpc_completion_queue_pluck(
+                     shutdown_cq, nullptr, grpc_timeout_seconds_to_deadline(5),
+                     nullptr)
+                     .type == GRPC_OP_COMPLETE);
       grpc_completion_queue_destroy(shutdown_cq);
       grpc_completion_queue_shutdown(cq);
       shutdown_started = 1;
     }
     ev = grpc_completion_queue_next(
-        cq, gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
-                         gpr_time_from_micros(1000000, GPR_TIMESPAN)),
-        NULL);
+        cq,
+        gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
+                     gpr_time_from_micros(1000000, GPR_TIMESPAN)),
+        nullptr);
     switch (ev.type) {
       case GRPC_OP_COMPLETE:
-        GPR_ASSERT(ev.tag == (void *)1);
+        GPR_ASSERT(ev.tag == (void*)1);
         GPR_ASSERT(ev.success == 0);
         break;
       case GRPC_QUEUE_SHUTDOWN:
@@ -97,7 +98,7 @@ void bad_ssl_run(grpc_server *server) {
     }
   }
 
-  GPR_ASSERT(s == NULL);
+  GPR_ASSERT(s == nullptr);
   grpc_call_details_destroy(&call_details);
   grpc_metadata_array_destroy(&request_metadata_recv);
 }
diff --git a/test/core/bad_ssl/server_common.h b/test/core/bad_ssl/server_common.h
index 35d51b1cb4..e1933b973e 100644
--- a/test/core/bad_ssl/server_common.h
+++ b/test/core/bad_ssl/server_common.h
@@ -21,7 +21,7 @@
 
 #include <grpc/grpc.h>
 
-const char *bad_ssl_addr(int argc, char **argv);
-void bad_ssl_run(grpc_server *server);
+const char* bad_ssl_addr(int argc, char** argv);
+void bad_ssl_run(grpc_server* server);
 
 #endif /* GRPC_TEST_CORE_BAD_SSL_SERVER_H */
diff --git a/test/core/bad_ssl/servers/alpn.c b/test/core/bad_ssl/servers/alpn.cc
index 3179054aff..23954d82fd 100644
--- a/test/core/bad_ssl/servers/alpn.c
+++ b/test/core/bad_ssl/servers/alpn.cc
@@ -31,9 +31,9 @@
  * a protocol that the connecting client does not support. It does this by
  * overriding the functions declared in alpn.c from the core library. */
 
-static const char *const fake_versions[] = {"not-h2"};
+static const char* const fake_versions[] = {"not-h2"};
 
-int grpc_chttp2_is_alpn_version_supported(const char *version, size_t size) {
+int grpc_chttp2_is_alpn_version_supported(const char* version, size_t size) {
   size_t i;
   for (i = 0; i < GPR_ARRAY_SIZE(fake_versions); i++) {
     if (!strncmp(version, fake_versions[i], size)) return 1;
@@ -45,22 +45,22 @@ size_t grpc_chttp2_num_alpn_versions(void) {
   return GPR_ARRAY_SIZE(fake_versions);
 }
 
-const char *grpc_chttp2_get_alpn_version_index(size_t i) {
+const char* grpc_chttp2_get_alpn_version_index(size_t i) {
   GPR_ASSERT(i < GPR_ARRAY_SIZE(fake_versions));
   return fake_versions[i];
 }
 
-int main(int argc, char **argv) {
-  const char *addr = bad_ssl_addr(argc, argv);
+int main(int argc, char** argv) {
+  const char* addr = bad_ssl_addr(argc, argv);
   grpc_ssl_pem_key_cert_pair pem_key_cert_pair = {test_server1_key,
                                                   test_server1_cert};
-  grpc_server_credentials *ssl_creds;
-  grpc_server *server;
+  grpc_server_credentials* ssl_creds;
+  grpc_server* server;
 
   grpc_init();
-  ssl_creds =
-      grpc_ssl_server_credentials_create(NULL, &pem_key_cert_pair, 1, 0, NULL);
-  server = grpc_server_create(NULL, NULL);
+  ssl_creds = grpc_ssl_server_credentials_create(nullptr, &pem_key_cert_pair, 1,
+                                                 0, nullptr);
+  server = grpc_server_create(nullptr, nullptr);
   GPR_ASSERT(grpc_server_add_secure_http2_port(server, addr, ssl_creds));
   grpc_server_credentials_release(ssl_creds);
 
diff --git a/test/core/bad_ssl/servers/cert.c b/test/core/bad_ssl/servers/cert.cc
index a1f3048164..a51dd34e4b 100644
--- a/test/core/bad_ssl/servers/cert.c
+++ b/test/core/bad_ssl/servers/cert.cc
@@ -31,11 +31,11 @@
 /* This server will present an untrusted cert to the connecting client,
  * causing the SSL handshake to fail */
 
-int main(int argc, char **argv) {
-  const char *addr = bad_ssl_addr(argc, argv);
+int main(int argc, char** argv) {
+  const char* addr = bad_ssl_addr(argc, argv);
   grpc_ssl_pem_key_cert_pair pem_key_cert_pair;
-  grpc_server_credentials *ssl_creds;
-  grpc_server *server;
+  grpc_server_credentials* ssl_creds;
+  grpc_server* server;
   grpc_slice cert_slice, key_slice;
 
   grpc_init();
@@ -46,12 +46,12 @@ int main(int argc, char **argv) {
   GPR_ASSERT(GRPC_LOG_IF_ERROR(
       "load_file",
       grpc_load_file("src/core/tsi/test_creds/badserver.key", 1, &key_slice)));
-  pem_key_cert_pair.private_key = (const char *)GRPC_SLICE_START_PTR(key_slice);
-  pem_key_cert_pair.cert_chain = (const char *)GRPC_SLICE_START_PTR(cert_slice);
+  pem_key_cert_pair.private_key = (const char*)GRPC_SLICE_START_PTR(key_slice);
+  pem_key_cert_pair.cert_chain = (const char*)GRPC_SLICE_START_PTR(cert_slice);
 
-  ssl_creds =
-      grpc_ssl_server_credentials_create(NULL, &pem_key_cert_pair, 1, 0, NULL);
-  server = grpc_server_create(NULL, NULL);
+  ssl_creds = grpc_ssl_server_credentials_create(nullptr, &pem_key_cert_pair, 1,
+                                                 0, nullptr);
+  server = grpc_server_create(nullptr, nullptr);
   GPR_ASSERT(grpc_server_add_secure_http2_port(server, addr, ssl_creds));
   grpc_server_credentials_release(ssl_creds);
 
diff --git a/test/core/census/BUILD b/test/core/census/BUILD
deleted file mode 100644
index 24fd2807d0..0000000000
--- a/test/core/census/BUILD
+++ /dev/null
@@ -1,82 +0,0 @@
-# Copyright 2016 gRPC authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-load("//bazel:grpc_build_system.bzl", "grpc_cc_library", "grpc_cc_test", "grpc_cc_binary", "grpc_package")
-
-grpc_package(name = "test/core/census")
-
-licenses(["notice"])  # Apache v2
-
-grpc_cc_test(
-    name = "context_test",
-    srcs = ["context_test.c"],
-    language = "C",
-    deps = [
-        "//:gpr",
-        "//:grpc",
-        "//test/core/util:gpr_test_util",
-        "//test/core/util:grpc_test_util",
-    ],
-)
-
-grpc_cc_test(
-    name = "mlog_test",
-    srcs = ["mlog_test.c"],
-    language = "C",
-    deps = [
-        "//:gpr",
-        "//:grpc",
-        "//test/core/util:gpr_test_util",
-        "//test/core/util:grpc_test_util",
-    ],
-)
-
-grpc_cc_test(
-    name = "resource_test",
-    srcs = ["resource_test.c"],
-    language = "C",
-    data = [
-        ":data/resource_empty_name.pb",
-        ":data/resource_full.pb",
-        ":data/resource_minimal_good.pb",
-        ":data/resource_no_name.pb",
-        ":data/resource_no_numerator.pb",
-        ":data/resource_no_unit.pb",
-    ],
-    deps = [
-        "//:gpr",
-        "//:grpc",
-        "//test/core/util:gpr_test_util",
-        "//test/core/util:grpc_test_util",
-    ],
-)
-
-grpc_cc_test(
-    name = "trace_context_test",
-    srcs = ["trace_context_test.c"],
-    language = "C",
-    data = [
-        ":data/context_empty.pb",
-        ":data/context_full.pb",
-        ":data/context_no_span_options.pb",
-        ":data/context_span_only.pb",
-        ":data/context_trace_only.pb",
-    ],
-    deps = [
-        "//:gpr",
-        "//:grpc",
-        "//test/core/util:gpr_test_util",
-        "//test/core/util:grpc_test_util",
-    ],
-)
diff --git a/test/core/census/README b/test/core/census/README
deleted file mode 100644
index d5363b7233..0000000000
--- a/test/core/census/README
+++ /dev/null
@@ -1,7 +0,0 @@
-Test source and data files for Census.
-
-binary proto files (*.pb) in data directory are generated from the *.txt file,
-via:
-
-BASE="filename"
-cat $BASE.txt | protoc --encode=google.census.Resource census.proto > $BASE.pb
diff --git a/test/core/census/context_test.c b/test/core/census/context_test.c
deleted file mode 100644
index ca5a6ec5cd..0000000000
--- a/test/core/census/context_test.c
+++ /dev/null
@@ -1,363 +0,0 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-// Test census_context functions, including encoding/decoding
-
-#include <grpc/census.h>
-#include <grpc/support/log.h>
-#include <grpc/support/time.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "test/core/util/test_config.h"
-
-// A set of tags Used to create a basic context for testing. Note that
-// replace_add_delete_test() relies on specific offsets into this array - if
-// you add or delete entries, you will also need to change the test.
-#define BASIC_TAG_COUNT 8
-static census_tag basic_tags[BASIC_TAG_COUNT] = {
-    /* 0 */ {"key0", "tag value", 0},
-    /* 1 */ {"k1", "a", CENSUS_TAG_PROPAGATE},
-    /* 2 */ {"k2", "a longer tag value supercalifragilisticexpialiadocious",
-             CENSUS_TAG_STATS},
-    /* 3 */ {"key_three", "", 0},
-    /* 4 */ {"a_really_really_really_really_long_key_4", "random",
-             CENSUS_TAG_PROPAGATE | CENSUS_TAG_STATS},
-    /* 5 */ {"k5", "v5", CENSUS_TAG_PROPAGATE},
-    /* 6 */ {"k6", "v6", CENSUS_TAG_STATS},
-    /* 7 */ {"k7", "v7", CENSUS_TAG_PROPAGATE | CENSUS_TAG_STATS}};
-
-// Set of tags used to modify the basic context. Note that
-// replace_add_delete_test() relies on specific offsets into this array - if
-// you add or delete entries, you will also need to change the test. Other
-// tests that rely on specific instances have XXX_XXX_OFFSET definitions (also
-// change the defines below if you add/delete entires).
-#define MODIFY_TAG_COUNT 10
-static census_tag modify_tags[MODIFY_TAG_COUNT] = {
-#define REPLACE_VALUE_OFFSET 0
-    /* 0 */ {"key0", "replace key0", 0},  // replaces tag value only
-#define ADD_TAG_OFFSET 1
-    /* 1 */ {"new_key", "xyzzy", CENSUS_TAG_STATS},  // new tag
-#define DELETE_TAG_OFFSET 2
-    /* 2 */ {"k5", NULL, 0},            // should delete tag
-    /* 3 */ {"k5", NULL, 0},            // try deleting already-deleted tag
-    /* 4 */ {"non-existent", NULL, 0},  // delete non-existent tag
-#define REPLACE_FLAG_OFFSET 5
-    /* 5 */ {"k1", "a", 0},                    // change flags only
-    /* 6 */ {"k7", "bar", CENSUS_TAG_STATS},   // change flags and value
-    /* 7 */ {"k2", "", CENSUS_TAG_PROPAGATE},  // more value and flags change
-    /* 8 */ {"k5", "bar", 0},  // add back tag, with different value
-    /* 9 */ {"foo", "bar", CENSUS_TAG_PROPAGATE},  // another new tag
-};
-
-// Utility function to compare tags. Returns true if all fields match.
-static bool compare_tag(const census_tag *t1, const census_tag *t2) {
-  return (strcmp(t1->key, t2->key) == 0 && strcmp(t1->value, t2->value) == 0 &&
-          t1->flags == t2->flags);
-}
-
-// Utility function to validate a tag exists in context.
-static bool validate_tag(const census_context *context, const census_tag *tag) {
-  census_tag tag2;
-  if (census_context_get_tag(context, tag->key, &tag2) != 1) return false;
-  return compare_tag(tag, &tag2);
-}
-
-// Create an empty context.
-static void empty_test(void) {
-  struct census_context *context = census_context_create(NULL, NULL, 0, NULL);
-  GPR_ASSERT(context != NULL);
-  const census_context_status *status = census_context_get_status(context);
-  census_context_status expected = {0, 0, 0, 0, 0, 0, 0};
-  GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0);
-  census_context_destroy(context);
-}
-
-// Test create and iteration over basic context.
-static void basic_test(void) {
-  const census_context_status *status;
-  struct census_context *context =
-      census_context_create(NULL, basic_tags, BASIC_TAG_COUNT, &status);
-  census_context_status expected = {4, 4, 0, 8, 0, 0, 0};
-  GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0);
-  census_context_iterator it;
-  census_context_initialize_iterator(context, &it);
-  census_tag tag;
-  while (census_context_next_tag(&it, &tag)) {
-    // can't rely on tag return order: make sure it matches exactly one.
-    int matches = 0;
-    for (int i = 0; i < BASIC_TAG_COUNT; i++) {
-      if (compare_tag(&tag, &basic_tags[i])) matches++;
-    }
-    GPR_ASSERT(matches == 1);
-  }
-  census_context_destroy(context);
-}
-
-// Test census_context_get_tag().
-static void lookup_by_key_test(void) {
-  struct census_context *context =
-      census_context_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL);
-  census_tag tag;
-  for (int i = 0; i < BASIC_TAG_COUNT; i++) {
-    GPR_ASSERT(census_context_get_tag(context, basic_tags[i].key, &tag) == 1);
-    GPR_ASSERT(compare_tag(&tag, &basic_tags[i]));
-  }
-  // non-existent keys
-  GPR_ASSERT(census_context_get_tag(context, "key", &tag) == 0);
-  GPR_ASSERT(census_context_get_tag(context, "key01", &tag) == 0);
-  GPR_ASSERT(census_context_get_tag(context, "k9", &tag) == 0);
-  GPR_ASSERT(census_context_get_tag(context, "random", &tag) == 0);
-  GPR_ASSERT(census_context_get_tag(context, "", &tag) == 0);
-  census_context_destroy(context);
-}
-
-// Try creating context with invalid entries.
-static void invalid_test(void) {
-  char key[300];
-  memset(key, 'k', 299);
-  key[299] = 0;
-  char value[300];
-  memset(value, 'v', 299);
-  value[299] = 0;
-  census_tag tag = {key, value, 0};
-  // long keys, short value. Key lengths (including terminator) should be
-  // <= 255 (CENSUS_MAX_TAG_KV_LEN)
-  value[3] = 0;
-  GPR_ASSERT(strlen(value) == 3);
-  GPR_ASSERT(strlen(key) == 299);
-  const census_context_status *status;
-  struct census_context *context =
-      census_context_create(NULL, &tag, 1, &status);
-  census_context_status expected = {0, 0, 0, 0, 0, 1, 0};
-  GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0);
-  census_context_destroy(context);
-  key[CENSUS_MAX_TAG_KV_LEN] = 0;
-  GPR_ASSERT(strlen(key) == CENSUS_MAX_TAG_KV_LEN);
-  context = census_context_create(NULL, &tag, 1, &status);
-  GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0);
-  census_context_destroy(context);
-  key[CENSUS_MAX_TAG_KV_LEN - 1] = 0;
-  GPR_ASSERT(strlen(key) == CENSUS_MAX_TAG_KV_LEN - 1);
-  context = census_context_create(NULL, &tag, 1, &status);
-  census_context_status expected2 = {0, 1, 0, 1, 0, 0, 0};
-  GPR_ASSERT(memcmp(status, &expected2, sizeof(expected2)) == 0);
-  census_context_destroy(context);
-  // now try with long values
-  value[3] = 'v';
-  GPR_ASSERT(strlen(value) == 299);
-  context = census_context_create(NULL, &tag, 1, &status);
-  GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0);
-  census_context_destroy(context);
-  value[CENSUS_MAX_TAG_KV_LEN] = 0;
-  GPR_ASSERT(strlen(value) == CENSUS_MAX_TAG_KV_LEN);
-  context = census_context_create(NULL, &tag, 1, &status);
-  GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0);
-  census_context_destroy(context);
-  value[CENSUS_MAX_TAG_KV_LEN - 1] = 0;
-  GPR_ASSERT(strlen(value) == CENSUS_MAX_TAG_KV_LEN - 1);
-  context = census_context_create(NULL, &tag, 1, &status);
-  GPR_ASSERT(memcmp(status, &expected2, sizeof(expected2)) == 0);
-  census_context_destroy(context);
-  // 0 length key.
-  key[0] = 0;
-  GPR_ASSERT(strlen(key) == 0);
-  context = census_context_create(NULL, &tag, 1, &status);
-  GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0);
-  census_context_destroy(context);
-  // invalid key character
-  key[0] = 31;  // 32 (' ') is the first valid character value
-  key[1] = 0;
-  GPR_ASSERT(strlen(key) == 1);
-  context = census_context_create(NULL, &tag, 1, &status);
-  GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0);
-  census_context_destroy(context);
-  // invalid value character
-  key[0] = ' ';
-  value[5] = 127;  // 127 (DEL) is ('~' + 1)
-  value[8] = 0;
-  GPR_ASSERT(strlen(key) == 1);
-  GPR_ASSERT(strlen(value) == 8);
-  context = census_context_create(NULL, &tag, 1, &status);
-  GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0);
-  census_context_destroy(context);
-}
-
-// Make a copy of a context
-static void copy_test(void) {
-  struct census_context *context =
-      census_context_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL);
-  const census_context_status *status;
-  struct census_context *context2 =
-      census_context_create(context, NULL, 0, &status);
-  census_context_status expected = {4, 4, 0, 0, 0, 0, 0};
-  GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0);
-  for (int i = 0; i < BASIC_TAG_COUNT; i++) {
-    census_tag tag;
-    GPR_ASSERT(census_context_get_tag(context2, basic_tags[i].key, &tag) == 1);
-    GPR_ASSERT(compare_tag(&tag, &basic_tags[i]));
-  }
-  census_context_destroy(context);
-  census_context_destroy(context2);
-}
-
-// replace a single tag value
-static void replace_value_test(void) {
-  struct census_context *context =
-      census_context_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL);
-  const census_context_status *status;
-  struct census_context *context2 = census_context_create(
-      context, modify_tags + REPLACE_VALUE_OFFSET, 1, &status);
-  census_context_status expected = {4, 4, 0, 0, 1, 0, 0};
-  GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0);
-  census_tag tag;
-  GPR_ASSERT(census_context_get_tag(
-                 context2, modify_tags[REPLACE_VALUE_OFFSET].key, &tag) == 1);
-  GPR_ASSERT(compare_tag(&tag, &modify_tags[REPLACE_VALUE_OFFSET]));
-  census_context_destroy(context);
-  census_context_destroy(context2);
-}
-
-// replace a single tags flags
-static void replace_flags_test(void) {
-  struct census_context *context =
-      census_context_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL);
-  const census_context_status *status;
-  struct census_context *context2 = census_context_create(
-      context, modify_tags + REPLACE_FLAG_OFFSET, 1, &status);
-  census_context_status expected = {3, 5, 0, 0, 1, 0, 0};
-  GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0);
-  census_tag tag;
-  GPR_ASSERT(census_context_get_tag(
-                 context2, modify_tags[REPLACE_FLAG_OFFSET].key, &tag) == 1);
-  GPR_ASSERT(compare_tag(&tag, &modify_tags[REPLACE_FLAG_OFFSET]));
-  census_context_destroy(context);
-  census_context_destroy(context2);
-}
-
-// delete a single tag.
-static void delete_tag_test(void) {
-  struct census_context *context =
-      census_context_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL);
-  const census_context_status *status;
-  struct census_context *context2 = census_context_create(
-      context, modify_tags + DELETE_TAG_OFFSET, 1, &status);
-  census_context_status expected = {3, 4, 1, 0, 0, 0, 0};
-  GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0);
-  census_tag tag;
-  GPR_ASSERT(census_context_get_tag(
-                 context2, modify_tags[DELETE_TAG_OFFSET].key, &tag) == 0);
-  census_context_destroy(context);
-  census_context_destroy(context2);
-}
-
-// add a single new tag.
-static void add_tag_test(void) {
-  struct census_context *context =
-      census_context_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL);
-  const census_context_status *status;
-  struct census_context *context2 =
-      census_context_create(context, modify_tags + ADD_TAG_OFFSET, 1, &status);
-  census_context_status expected = {4, 5, 0, 1, 0, 0, 0};
-  GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0);
-  census_tag tag;
-  GPR_ASSERT(census_context_get_tag(context2, modify_tags[ADD_TAG_OFFSET].key,
-                                    &tag) == 1);
-  GPR_ASSERT(compare_tag(&tag, &modify_tags[ADD_TAG_OFFSET]));
-  census_context_destroy(context);
-  census_context_destroy(context2);
-}
-
-// test many changes at once.
-static void replace_add_delete_test(void) {
-  struct census_context *context =
-      census_context_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL);
-  const census_context_status *status;
-  struct census_context *context2 =
-      census_context_create(context, modify_tags, MODIFY_TAG_COUNT, &status);
-  census_context_status expected = {3, 7, 1, 3, 4, 0, 0};
-  GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0);
-  // validate context contents. Use specific indices into the two arrays
-  // holding tag values.
-  GPR_ASSERT(validate_tag(context2, &basic_tags[3]));
-  GPR_ASSERT(validate_tag(context2, &basic_tags[4]));
-  GPR_ASSERT(validate_tag(context2, &basic_tags[6]));
-  GPR_ASSERT(validate_tag(context2, &modify_tags[0]));
-  GPR_ASSERT(validate_tag(context2, &modify_tags[1]));
-  GPR_ASSERT(validate_tag(context2, &modify_tags[5]));
-  GPR_ASSERT(validate_tag(context2, &modify_tags[6]));
-  GPR_ASSERT(validate_tag(context2, &modify_tags[7]));
-  GPR_ASSERT(validate_tag(context2, &modify_tags[8]));
-  GPR_ASSERT(validate_tag(context2, &modify_tags[9]));
-  GPR_ASSERT(!validate_tag(context2, &basic_tags[0]));
-  GPR_ASSERT(!validate_tag(context2, &basic_tags[1]));
-  GPR_ASSERT(!validate_tag(context2, &basic_tags[2]));
-  GPR_ASSERT(!validate_tag(context2, &basic_tags[5]));
-  GPR_ASSERT(!validate_tag(context2, &basic_tags[7]));
-  census_context_destroy(context);
-  census_context_destroy(context2);
-}
-
-#define BUF_SIZE 200
-
-// test encode/decode.
-static void encode_decode_test(void) {
-  char buffer[BUF_SIZE];
-  struct census_context *context =
-      census_context_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL);
-  // Test with too small a buffer
-  GPR_ASSERT(census_context_encode(context, buffer, 2) == 0);
-  // Test with sufficient buffer
-  size_t buf_used = census_context_encode(context, buffer, BUF_SIZE);
-  GPR_ASSERT(buf_used != 0);
-  census_context *context2 = census_context_decode(buffer, buf_used);
-  GPR_ASSERT(context2 != NULL);
-  const census_context_status *status = census_context_get_status(context2);
-  census_context_status expected = {4, 0, 0, 0, 0, 0, 0};
-  GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0);
-  for (int i = 0; i < BASIC_TAG_COUNT; i++) {
-    census_tag tag;
-    if (CENSUS_TAG_IS_PROPAGATED(basic_tags[i].flags)) {
-      GPR_ASSERT(census_context_get_tag(context2, basic_tags[i].key, &tag) ==
-                 1);
-      GPR_ASSERT(compare_tag(&tag, &basic_tags[i]));
-    } else {
-      GPR_ASSERT(census_context_get_tag(context2, basic_tags[i].key, &tag) ==
-                 0);
-    }
-  }
-  census_context_destroy(context2);
-  census_context_destroy(context);
-}
-
-int main(int argc, char *argv[]) {
-  grpc_test_init(argc, argv);
-  empty_test();
-  basic_test();
-  lookup_by_key_test();
-  invalid_test();
-  copy_test();
-  replace_value_test();
-  replace_flags_test();
-  delete_tag_test();
-  add_tag_test();
-  replace_add_delete_test();
-  encode_decode_test();
-  return 0;
-}
diff --git a/test/core/census/data/context_empty.pb b/test/core/census/data/context_empty.pb
deleted file mode 100644
index e69de29bb2..0000000000
--- a/test/core/census/data/context_empty.pb
+++ /dev/null
diff --git a/test/core/census/data/context_empty.txt b/test/core/census/data/context_empty.txt
deleted file mode 100644
index e69de29bb2..0000000000
--- a/test/core/census/data/context_empty.txt
+++ /dev/null
diff --git a/test/core/census/data/context_full.pb b/test/core/census/data/context_full.pb
deleted file mode 100644
index 7b5895cbf1..0000000000
--- a/test/core/census/data/context_full.pb
+++ /dev/null
diff --git a/test/core/census/data/context_full.txt b/test/core/census/data/context_full.txt
deleted file mode 100644
index 7d8df37ea1..0000000000
--- a/test/core/census/data/context_full.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-trace_id_hi : 5
-trace_id_lo : 1
-span_id : 7
-span_options : 1
diff --git a/test/core/census/data/context_no_span_options.pb b/test/core/census/data/context_no_span_options.pb
deleted file mode 100644
index 4b3425ac01..0000000000
--- a/test/core/census/data/context_no_span_options.pb
+++ /dev/null
diff --git a/test/core/census/data/context_no_span_options.txt b/test/core/census/data/context_no_span_options.txt
deleted file mode 100644
index 4c8398ffd0..0000000000
--- a/test/core/census/data/context_no_span_options.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-trace_id_hi : 5
-trace_id_lo : 1
-span_id : 7
diff --git a/test/core/census/data/context_span_only.pb b/test/core/census/data/context_span_only.pb
deleted file mode 100644
index a9315be91a..0000000000
--- a/test/core/census/data/context_span_only.pb
+++ /dev/null
diff --git a/test/core/census/data/context_span_only.txt b/test/core/census/data/context_span_only.txt
deleted file mode 100644
index 4e473fce53..0000000000
--- a/test/core/census/data/context_span_only.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-span_id : 7
-span_options : 1
diff --git a/test/core/census/data/context_trace_only.pb b/test/core/census/data/context_trace_only.pb
deleted file mode 100644
index aabb325f92..0000000000
--- a/test/core/census/data/context_trace_only.pb
+++ /dev/null
diff --git a/test/core/census/data/context_trace_only.txt b/test/core/census/data/context_trace_only.txt
deleted file mode 100644
index e48a6d7457..0000000000
--- a/test/core/census/data/context_trace_only.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-trace_id_hi : 5
-trace_id_lo : 1
-span_options : 1
diff --git a/test/core/census/data/resource_empty_name.pb b/test/core/census/data/resource_empty_name.pb
deleted file mode 100644
index 4d547445fa..0000000000
--- a/test/core/census/data/resource_empty_name.pb
+++ /dev/null
@@ -1 +0,0 @@
-

\ No newline at end of file
diff --git a/test/core/census/data/resource_empty_name.txt b/test/core/census/data/resource_empty_name.txt
deleted file mode 100644
index 271fd3274c..0000000000
--- a/test/core/census/data/resource_empty_name.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-# Name is present, but empty.
-name : ''
-unit {
-  numerator : SECS
-}
diff --git a/test/core/census/data/resource_full.pb b/test/core/census/data/resource_full.pb
deleted file mode 100644
index e4c6a2aef5..0000000000
--- a/test/core/census/data/resource_full.pb
+++ /dev/null
@@ -1,2 +0,0 @@
-
-
full_resource"A resource with everything defined



\ No newline at end of file
diff --git a/test/core/census/data/resource_full.txt b/test/core/census/data/resource_full.txt
deleted file mode 100644
index 1aa2fafe3a..0000000000
--- a/test/core/census/data/resource_full.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-# A full resource definition - all fields filled out.
-name : 'full_resource'
-description : 'A resource with everything defined'
-unit {
-  # Megabits per second.
-  prefix : 6
-  numerator : BITS
-  denominator : SECS
-}
diff --git a/test/core/census/data/resource_minimal_good.pb b/test/core/census/data/resource_minimal_good.pb
deleted file mode 100644
index 7100c462bf..0000000000
--- a/test/core/census/data/resource_minimal_good.pb
+++ /dev/null
@@ -1,2 +0,0 @@
-
-minimal_good

\ No newline at end of file
diff --git a/test/core/census/data/resource_minimal_good.txt b/test/core/census/data/resource_minimal_good.txt
deleted file mode 100644
index a7a7e71dd6..0000000000
--- a/test/core/census/data/resource_minimal_good.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-# A minimal "good" Resource definition: has a name and numerator/unit.
-name : 'minimal_good'
-unit {
-  numerator : SECS
-}
diff --git a/test/core/census/data/resource_no_name.pb b/test/core/census/data/resource_no_name.pb
deleted file mode 100644
index 4d547445fa..0000000000
--- a/test/core/census/data/resource_no_name.pb
+++ /dev/null
@@ -1 +0,0 @@
-

\ No newline at end of file
diff --git a/test/core/census/data/resource_no_name.txt b/test/core/census/data/resource_no_name.txt
deleted file mode 100644
index 8f12a91d35..0000000000
--- a/test/core/census/data/resource_no_name.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-# The minimal good Resource without a name.
-unit {
-  numerator : SECS
-}
diff --git a/test/core/census/data/resource_no_numerator.pb b/test/core/census/data/resource_no_numerator.pb
deleted file mode 100644
index 2a5cceee70..0000000000
--- a/test/core/census/data/resource_no_numerator.pb
+++ /dev/null
@@ -1,2 +0,0 @@
-
-resource_no_numeratorýÿÿÿÿÿÿÿÿ


\ No newline at end of file
diff --git a/test/core/census/data/resource_no_numerator.txt b/test/core/census/data/resource_no_numerator.txt
deleted file mode 100644
index fc1fec74a2..0000000000
--- a/test/core/census/data/resource_no_numerator.txt
+++ /dev/null
@@ -1,6 +0,0 @@
-# Resource without a numerator
-name : 'resource_no_numerator'
-unit {
-  prefix : -3
-  denominator : SECS
-}
diff --git a/test/core/census/data/resource_no_unit.pb b/test/core/census/data/resource_no_unit.pb
deleted file mode 100644
index 9dca2620e0..0000000000
--- a/test/core/census/data/resource_no_unit.pb
+++ /dev/null
@@ -1,2 +0,0 @@
-
-resource_no_unit
\ No newline at end of file
diff --git a/test/core/census/data/resource_no_unit.txt b/test/core/census/data/resource_no_unit.txt
deleted file mode 100644
index c5d5115ceb..0000000000
--- a/test/core/census/data/resource_no_unit.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-# The minimal good resource without a unit
-name : 'resource_no_unit'
diff --git a/test/core/census/intrusive_hash_map_test.c b/test/core/census/intrusive_hash_map_test.c
deleted file mode 100644
index 0826b55c63..0000000000
--- a/test/core/census/intrusive_hash_map_test.c
+++ /dev/null
@@ -1,284 +0,0 @@
-/*
- *
- * Copyright 2017 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include "src/core/ext/census/intrusive_hash_map.h"
-
-#include <grpc/support/log.h>
-#include <grpc/support/useful.h>
-#include "test/core/util/test_config.h"
-
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-/* The initial size of an intrusive hash map will be 2 to this power. */
-static const uint32_t kInitialLog2Size = 4;
-
-/* Simple object used for testing intrusive_hash_map. */
-typedef struct object { uint64_t val; } object;
-
-/* Helper function to allocate and initialize object. */
-static __inline object *make_new_object(uint64_t val) {
-  object *obj = (object *)gpr_malloc(sizeof(object));
-  obj->val = val;
-  return obj;
-}
-
-/* Wrapper struct for object. */
-typedef struct ptr_item {
-  INTRUSIVE_HASH_MAP_HEADER;
-  object *obj;
-} ptr_item;
-
-/* Helper function that creates a new hash map item.  It is up to the user to
- * free the item that was allocated. */
-static __inline ptr_item *make_ptr_item(uint64_t key, uint64_t value) {
-  ptr_item *new_item = (ptr_item *)gpr_malloc(sizeof(ptr_item));
-  new_item->IHM_key = key;
-  new_item->IHM_hash_link = NULL;
-  new_item->obj = make_new_object(value);
-  return new_item;
-}
-
-/* Helper function to deallocate ptr_item. */
-static void free_ptr_item(void *ptr) { gpr_free(((ptr_item *)ptr)->obj); }
-
-/* Simple string object used for testing intrusive_hash_map. */
-typedef struct string_item {
-  INTRUSIVE_HASH_MAP_HEADER;
-  // User data.
-  char buf[32];
-  uint16_t len;
-} string_item;
-
-/* Helper function to allocate and initialize string object. */
-static string_item *make_string_item(uint64_t key, const char *buf,
-                                     uint16_t len) {
-  string_item *item = (string_item *)gpr_malloc(sizeof(string_item));
-  item->IHM_key = key;
-  item->IHM_hash_link = NULL;
-  item->len = len;
-  memcpy(item->buf, buf, sizeof(char) * len);
-  return item;
-}
-
-/* Helper function for comparing two string objects. */
-static bool compare_string_item(const string_item *A, const string_item *B) {
-  if (A->IHM_key != B->IHM_key || A->len != B->len)
-    return false;
-  else {
-    for (int i = 0; i < A->len; ++i) {
-      if (A->buf[i] != B->buf[i]) return false;
-    }
-  }
-
-  return true;
-}
-
-void test_empty() {
-  intrusive_hash_map hash_map;
-  intrusive_hash_map_init(&hash_map, kInitialLog2Size);
-  GPR_ASSERT(0 == intrusive_hash_map_size(&hash_map));
-  GPR_ASSERT(intrusive_hash_map_empty(&hash_map));
-  intrusive_hash_map_free(&hash_map, NULL);
-}
-
-void test_single_item() {
-  intrusive_hash_map hash_map;
-  intrusive_hash_map_init(&hash_map, kInitialLog2Size);
-
-  ptr_item *new_item = make_ptr_item(10, 20);
-  bool ok = intrusive_hash_map_insert(&hash_map, (hm_item *)new_item);
-  GPR_ASSERT(ok);
-
-  ptr_item *item1 =
-      (ptr_item *)intrusive_hash_map_find(&hash_map, (uint64_t)10);
-  GPR_ASSERT(item1->obj->val == 20);
-  GPR_ASSERT(item1 == new_item);
-
-  ptr_item *item2 =
-      (ptr_item *)intrusive_hash_map_erase(&hash_map, (uint64_t)10);
-  GPR_ASSERT(item2 == new_item);
-
-  gpr_free(new_item->obj);
-  gpr_free(new_item);
-  GPR_ASSERT(0 == intrusive_hash_map_size(&hash_map));
-  intrusive_hash_map_free(&hash_map, &free_ptr_item);
-}
-
-void test_two_items() {
-  intrusive_hash_map hash_map;
-  intrusive_hash_map_init(&hash_map, kInitialLog2Size);
-
-  string_item *new_item1 = make_string_item(10, "test1", 5);
-  bool ok = intrusive_hash_map_insert(&hash_map, (hm_item *)new_item1);
-  GPR_ASSERT(ok);
-  string_item *new_item2 = make_string_item(20, "test2", 5);
-  ok = intrusive_hash_map_insert(&hash_map, (hm_item *)new_item2);
-  GPR_ASSERT(ok);
-
-  string_item *item1 =
-      (string_item *)intrusive_hash_map_find(&hash_map, (uint64_t)10);
-  GPR_ASSERT(compare_string_item(new_item1, item1));
-  GPR_ASSERT(item1 == new_item1);
-  string_item *item2 =
-      (string_item *)intrusive_hash_map_find(&hash_map, (uint64_t)20);
-  GPR_ASSERT(compare_string_item(new_item2, item2));
-  GPR_ASSERT(item2 == new_item2);
-
-  item1 = (string_item *)intrusive_hash_map_erase(&hash_map, (uint64_t)10);
-  GPR_ASSERT(item1 == new_item1);
-  item2 = (string_item *)intrusive_hash_map_erase(&hash_map, (uint64_t)20);
-  GPR_ASSERT(item2 == new_item2);
-
-  gpr_free(new_item1);
-  gpr_free(new_item2);
-  GPR_ASSERT(0 == intrusive_hash_map_size(&hash_map));
-  intrusive_hash_map_free(&hash_map, NULL);
-}
-
-// Test resetting and clearing the hash map.
-void test_reset_clear() {
-  intrusive_hash_map hash_map;
-  intrusive_hash_map_init(&hash_map, kInitialLog2Size);
-
-  // Add some data to the hash_map.
-  for (uint64_t i = 0; i < 3; ++i) {
-    intrusive_hash_map_insert(&hash_map, (hm_item *)make_ptr_item(i, i));
-  }
-  GPR_ASSERT(3 == intrusive_hash_map_size(&hash_map));
-
-  // Test find.
-  for (uint64_t i = 0; i < 3; ++i) {
-    ptr_item *item = (ptr_item *)intrusive_hash_map_find(&hash_map, i);
-    GPR_ASSERT(item != NULL);
-    GPR_ASSERT(item->IHM_key == i && item->obj->val == i);
-  }
-
-  intrusive_hash_map_clear(&hash_map, &free_ptr_item);
-  GPR_ASSERT(intrusive_hash_map_empty(&hash_map));
-  intrusive_hash_map_free(&hash_map, &free_ptr_item);
-}
-
-// Check that the hash_map contains every key between [min_value, max_value]
-// (inclusive).
-void check_hash_map_values(intrusive_hash_map *hash_map, uint64_t min_value,
-                           uint64_t max_value) {
-  GPR_ASSERT(intrusive_hash_map_size(hash_map) == max_value - min_value + 1);
-
-  for (uint64_t i = min_value; i <= max_value; ++i) {
-    ptr_item *item = (ptr_item *)intrusive_hash_map_find(hash_map, i);
-    GPR_ASSERT(item != NULL);
-    GPR_ASSERT(item->obj->val == i);
-  }
-}
-
-// Add many items and cause the hash_map to extend.
-void test_extend() {
-  intrusive_hash_map hash_map;
-  intrusive_hash_map_init(&hash_map, kInitialLog2Size);
-
-  const uint64_t kNumValues = (1 << 16);
-
-  for (uint64_t i = 0; i < kNumValues; ++i) {
-    ptr_item *item = make_ptr_item(i, i);
-    bool ok = intrusive_hash_map_insert(&hash_map, (hm_item *)item);
-    GPR_ASSERT(ok);
-    if (i % 1000 == 0) {
-      check_hash_map_values(&hash_map, 0, i);
-    }
-  }
-
-  for (uint64_t i = 0; i < kNumValues; ++i) {
-    ptr_item *item = (ptr_item *)intrusive_hash_map_find(&hash_map, i);
-    GPR_ASSERT(item != NULL);
-    GPR_ASSERT(item->IHM_key == i && item->obj->val == i);
-    ptr_item *item2 = (ptr_item *)intrusive_hash_map_erase(&hash_map, i);
-    GPR_ASSERT(item == item2);
-    gpr_free(item->obj);
-    gpr_free(item);
-  }
-
-  GPR_ASSERT(intrusive_hash_map_empty(&hash_map));
-  intrusive_hash_map_free(&hash_map, &free_ptr_item);
-}
-
-void test_stress() {
-  intrusive_hash_map hash_map;
-  intrusive_hash_map_init(&hash_map, kInitialLog2Size);
-  size_t n = 0;
-
-  // Randomly add and insert entries 1000000 times.
-  for (uint64_t i = 0; i < 1000000; ++i) {
-    int op = rand() & 0x1;
-
-    switch (op) {
-      // Case 0 is insertion of entry.
-      case 0: {
-        uint64_t key = (uint64_t)(rand() % 10000);
-        ptr_item *item = make_ptr_item(key, key);
-        bool ok = intrusive_hash_map_insert(&hash_map, (hm_item *)item);
-        if (ok) {
-          n++;
-        } else {
-          gpr_free(item->obj);
-          gpr_free(item);
-        }
-        break;
-      }
-      // Case 1 is removal of entry.
-      case 1: {
-        uint64_t key = (uint64_t)(rand() % 10000);
-        ptr_item *item = (ptr_item *)intrusive_hash_map_find(&hash_map, key);
-        if (item != NULL) {
-          n--;
-          GPR_ASSERT(key == item->obj->val);
-          ptr_item *item2 =
-              (ptr_item *)intrusive_hash_map_erase(&hash_map, key);
-          GPR_ASSERT(item == item2);
-          gpr_free(item->obj);
-          gpr_free(item);
-        }
-        break;
-      }
-    }
-  }
-  // Check size
-  GPR_ASSERT(n == intrusive_hash_map_size(&hash_map));
-
-  // Clean the hash_map up.
-  intrusive_hash_map_clear(&hash_map, &free_ptr_item);
-  GPR_ASSERT(intrusive_hash_map_empty(&hash_map));
-  intrusive_hash_map_free(&hash_map, &free_ptr_item);
-}
-
-int main(int argc, char **argv) {
-  grpc_test_init(argc, argv);
-  gpr_time_init();
-  srand((unsigned)gpr_now(GPR_CLOCK_REALTIME).tv_nsec);
-
-  test_empty();
-  test_single_item();
-  test_two_items();
-  test_reset_clear();
-  test_extend();
-  test_stress();
-
-  return 0;
-}
diff --git a/test/core/census/mlog_test.c b/test/core/census/mlog_test.c
deleted file mode 100644
index 968fd91da4..0000000000
--- a/test/core/census/mlog_test.c
+++ /dev/null
@@ -1,574 +0,0 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include "src/core/ext/census/mlog.h"
-#include <grpc/support/cpu.h>
-#include <grpc/support/log.h>
-#include <grpc/support/port_platform.h>
-#include <grpc/support/sync.h>
-#include <grpc/support/thd.h>
-#include <grpc/support/time.h>
-#include <grpc/support/useful.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "test/core/util/test_config.h"
-
-// Change this to non-zero if you want more output.
-#define VERBOSE 0
-
-// Log size to use for all tests.
-#define LOG_SIZE_IN_MB 1
-#define LOG_SIZE_IN_BYTES (LOG_SIZE_IN_MB << 20)
-
-// Fills in 'record' of size 'size'. Each byte in record is filled in with the
-// same value. The value is extracted from 'record' pointer.
-static void write_record(char* record, size_t size) {
-  char data = (char)((uintptr_t)record % 255);
-  memset(record, data, size);
-}
-
-// Reads fixed size records. Returns the number of records read in
-// 'num_records'.
-static void read_records(size_t record_size, const char* buffer,
-                         size_t buffer_size, int* num_records) {
-  GPR_ASSERT(buffer_size >= record_size);
-  GPR_ASSERT(buffer_size % record_size == 0);
-  *num_records = (int)(buffer_size / record_size);
-  for (int i = 0; i < *num_records; ++i) {
-    const char* record = buffer + (record_size * (size_t)i);
-    char data = (char)((uintptr_t)record % 255);
-    for (size_t j = 0; j < record_size; ++j) {
-      GPR_ASSERT(data == record[j]);
-    }
-  }
-}
-
-// Tries to write the specified number of records. Stops when the log gets
-// full. Returns the number of records written. Spins for random
-// number of times, up to 'max_spin_count', between writes.
-static int write_records_to_log(int writer_id, size_t record_size,
-                                int num_records, int max_spin_count) {
-  int counter = 0;
-  for (int i = 0; i < num_records; ++i) {
-    int spin_count = max_spin_count ? rand() % max_spin_count : 0;
-    if (VERBOSE && (counter++ == num_records / 10)) {
-      printf("   Writer %d: %d out of %d written\n", writer_id, i, num_records);
-      counter = 0;
-    }
-    char* record = (char*)(census_log_start_write(record_size));
-    if (record == NULL) {
-      return i;
-    }
-    write_record(record, record_size);
-    census_log_end_write(record, record_size);
-    for (int j = 0; j < spin_count; ++j) {
-      GPR_ASSERT(j >= 0);
-    }
-  }
-  return num_records;
-}
-
-// Performs a single read iteration. Returns the number of records read.
-static int perform_read_iteration(size_t record_size) {
-  const void* read_buffer = NULL;
-  size_t bytes_available;
-  int records_read = 0;
-  census_log_init_reader();
-  while ((read_buffer = census_log_read_next(&bytes_available))) {
-    int num_records = 0;
-    read_records(record_size, (const char*)read_buffer, bytes_available,
-                 &num_records);
-    records_read += num_records;
-  }
-  return records_read;
-}
-
-// Asserts that the log is empty.
-static void assert_log_empty(void) {
-  census_log_init_reader();
-  size_t bytes_available;
-  GPR_ASSERT(census_log_read_next(&bytes_available) == NULL);
-}
-
-// Fills the log and verifies data. If 'no fragmentation' is true, records
-// are sized such that CENSUS_LOG_2_MAX_RECORD_SIZE is a multiple of record
-// size. If not a circular log, verifies that the number of records written
-// match the number of records read.
-static void fill_log(size_t log_size, int no_fragmentation, int circular_log) {
-  size_t size;
-  if (no_fragmentation) {
-    int log2size = rand() % (CENSUS_LOG_2_MAX_RECORD_SIZE + 1);
-    size = ((size_t)1 << log2size);
-  } else {
-    while (1) {
-      size = 1 + ((size_t)rand() % CENSUS_LOG_MAX_RECORD_SIZE);
-      if (CENSUS_LOG_MAX_RECORD_SIZE % size) {
-        break;
-      }
-    }
-  }
-  int records_written =
-      write_records_to_log(0 /* writer id */, size,
-                           (int)((log_size / size) * 2), 0 /* spin count */);
-  int records_read = perform_read_iteration(size);
-  if (!circular_log) {
-    GPR_ASSERT(records_written == records_read);
-  }
-  assert_log_empty();
-}
-
-// Structure to pass args to writer_thread
-typedef struct writer_thread_args {
-  // Index of this thread in the writers vector.
-  int index;
-  // Record size.
-  size_t record_size;
-  // Number of records to write.
-  int num_records;
-  // Used to signal when writer is complete
-  gpr_cv* done;
-  gpr_mu* mu;
-  int* count;
-} writer_thread_args;
-
-// Writes the given number of records of random size (up to kMaxRecordSize) and
-// random data to the specified log.
-static void writer_thread(void* arg) {
-  writer_thread_args* args = (writer_thread_args*)arg;
-  // Maximum number of times to spin between writes.
-  static const int MAX_SPIN_COUNT = 50;
-  int records_written = 0;
-  if (VERBOSE) {
-    printf("   Writer %d starting\n", args->index);
-  }
-  while (records_written < args->num_records) {
-    records_written += write_records_to_log(args->index, args->record_size,
-                                            args->num_records - records_written,
-                                            MAX_SPIN_COUNT);
-    if (records_written < args->num_records) {
-      // Ran out of log space. Sleep for a bit and let the reader catch up.
-      // This should never happen for circular logs.
-      if (VERBOSE) {
-        printf(
-            "   Writer %d stalled due to out-of-space: %d out of %d "
-            "written\n",
-            args->index, records_written, args->num_records);
-      }
-      gpr_sleep_until(grpc_timeout_milliseconds_to_deadline(10));
-    }
-  }
-  // Done. Decrement count and signal.
-  gpr_mu_lock(args->mu);
-  (*args->count)--;
-  gpr_cv_signal(args->done);
-  if (VERBOSE) {
-    printf("   Writer %d done\n", args->index);
-  }
-  gpr_mu_unlock(args->mu);
-}
-
-// struct to pass args to reader_thread
-typedef struct reader_thread_args {
-  // Record size.
-  size_t record_size;
-  // Interval between read iterations.
-  int read_iteration_interval_in_msec;
-  // Total number of records.
-  int total_records;
-  // Signalled when reader should stop.
-  gpr_cv stop;
-  int stop_flag;
-  // Used to signal when reader has finished
-  gpr_cv* done;
-  gpr_mu* mu;
-  int running;
-} reader_thread_args;
-
-// Reads and verifies the specified number of records. Reader can also be
-// stopped via gpr_cv_signal(&args->stop). Sleeps for 'read_interval_in_msec'
-// between read iterations.
-static void reader_thread(void* arg) {
-  reader_thread_args* args = (reader_thread_args*)arg;
-  if (VERBOSE) {
-    printf("   Reader starting\n");
-  }
-  gpr_timespec interval = gpr_time_from_micros(
-      args->read_iteration_interval_in_msec * 1000, GPR_TIMESPAN);
-  gpr_mu_lock(args->mu);
-  int records_read = 0;
-  int num_iterations = 0;
-  int counter = 0;
-  while (!args->stop_flag && records_read < args->total_records) {
-    gpr_cv_wait(&args->stop, args->mu, interval);
-    if (!args->stop_flag) {
-      records_read += perform_read_iteration(args->record_size);
-      GPR_ASSERT(records_read <= args->total_records);
-      if (VERBOSE && (counter++ == 100000)) {
-        printf("   Reader: %d out of %d read\n", records_read,
-               args->total_records);
-        counter = 0;
-      }
-      ++num_iterations;
-    }
-  }
-  // Done
-  args->running = 0;
-  gpr_cv_signal(args->done);
-  if (VERBOSE) {
-    printf("   Reader: records: %d, iterations: %d\n", records_read,
-           num_iterations);
-  }
-  gpr_mu_unlock(args->mu);
-}
-
-// Creates NUM_WRITERS writers where each writer writes NUM_RECORDS_PER_WRITER
-// records. Also, starts a reader that iterates over and reads blocks every
-// READ_ITERATION_INTERVAL_IN_MSEC.
-// Number of writers.
-#define NUM_WRITERS 5
-static void multiple_writers_single_reader(int circular_log) {
-  // Sleep interval between read iterations.
-  static const int READ_ITERATION_INTERVAL_IN_MSEC = 10;
-  // Maximum record size.
-  static const size_t MAX_RECORD_SIZE = 20;
-  // Number of records written by each writer. This is sized such that we
-  // will write through the entire log ~10 times.
-  const int NUM_RECORDS_PER_WRITER =
-      (int)((10 * census_log_remaining_space()) / (MAX_RECORD_SIZE / 2)) /
-      NUM_WRITERS;
-  size_t record_size = ((size_t)rand() % MAX_RECORD_SIZE) + 1;
-  // Create and start writers.
-  writer_thread_args writers[NUM_WRITERS];
-  int writers_count = NUM_WRITERS;
-  gpr_cv writers_done;
-  gpr_mu writers_mu;  // protects writers_done and writers_count
-  gpr_cv_init(&writers_done);
-  gpr_mu_init(&writers_mu);
-  gpr_thd_id id;
-  for (int i = 0; i < NUM_WRITERS; ++i) {
-    writers[i].index = i;
-    writers[i].record_size = record_size;
-    writers[i].num_records = NUM_RECORDS_PER_WRITER;
-    writers[i].done = &writers_done;
-    writers[i].count = &writers_count;
-    writers[i].mu = &writers_mu;
-    gpr_thd_new(&id, &writer_thread, &writers[i], NULL);
-  }
-  // Start reader.
-  gpr_cv reader_done;
-  gpr_mu reader_mu;  // protects reader_done and reader.running
-  reader_thread_args reader;
-  reader.record_size = record_size;
-  reader.read_iteration_interval_in_msec = READ_ITERATION_INTERVAL_IN_MSEC;
-  reader.total_records = NUM_WRITERS * NUM_RECORDS_PER_WRITER;
-  reader.stop_flag = 0;
-  gpr_cv_init(&reader.stop);
-  gpr_cv_init(&reader_done);
-  reader.done = &reader_done;
-  gpr_mu_init(&reader_mu);
-  reader.mu = &reader_mu;
-  reader.running = 1;
-  gpr_thd_new(&id, &reader_thread, &reader, NULL);
-  // Wait for writers to finish.
-  gpr_mu_lock(&writers_mu);
-  while (writers_count != 0) {
-    gpr_cv_wait(&writers_done, &writers_mu, gpr_inf_future(GPR_CLOCK_REALTIME));
-  }
-  gpr_mu_unlock(&writers_mu);
-  gpr_mu_destroy(&writers_mu);
-  gpr_cv_destroy(&writers_done);
-  gpr_mu_lock(&reader_mu);
-  if (circular_log) {
-    // Stop reader.
-    reader.stop_flag = 1;
-    gpr_cv_signal(&reader.stop);
-  }
-  // wait for reader to finish
-  while (reader.running) {
-    gpr_cv_wait(&reader_done, &reader_mu, gpr_inf_future(GPR_CLOCK_REALTIME));
-  }
-  if (circular_log) {
-    // Assert that there were no out-of-space errors.
-    GPR_ASSERT(0 == census_log_out_of_space_count());
-  }
-  gpr_mu_unlock(&reader_mu);
-  gpr_mu_destroy(&reader_mu);
-  gpr_cv_destroy(&reader_done);
-  if (VERBOSE) {
-    printf("   Reader: finished\n");
-  }
-}
-
-static void setup_test(int circular_log) {
-  census_log_initialize(LOG_SIZE_IN_MB, circular_log);
-  //  GPR_ASSERT(census_log_remaining_space() == LOG_SIZE_IN_BYTES);
-}
-
-// Attempts to create a record of invalid size (size >
-// CENSUS_LOG_MAX_RECORD_SIZE).
-void test_invalid_record_size(void) {
-  static const size_t INVALID_SIZE = CENSUS_LOG_MAX_RECORD_SIZE + 1;
-  static const size_t VALID_SIZE = 1;
-  printf("Starting test: invalid record size\n");
-  setup_test(0);
-  void* record = census_log_start_write(INVALID_SIZE);
-  GPR_ASSERT(record == NULL);
-  // Now try writing a valid record.
-  record = census_log_start_write(VALID_SIZE);
-  GPR_ASSERT(record != NULL);
-  census_log_end_write(record, VALID_SIZE);
-  // Verifies that available space went down by one block. In theory, this
-  // check can fail if the thread is context switched to a new CPU during the
-  // start_write execution (multiple blocks get allocated), but this has not
-  // been observed in practice.
-  //  GPR_ASSERT(LOG_SIZE_IN_BYTES - CENSUS_LOG_MAX_RECORD_SIZE ==
-  //             census_log_remaining_space());
-  census_log_shutdown();
-}
-
-// Tests end_write() with a different size than what was specified in
-// start_write().
-void test_end_write_with_different_size(void) {
-  static const size_t START_WRITE_SIZE = 10;
-  static const size_t END_WRITE_SIZE = 7;
-  printf("Starting test: end write with different size\n");
-  setup_test(0);
-  void* record_written = census_log_start_write(START_WRITE_SIZE);
-  GPR_ASSERT(record_written != NULL);
-  census_log_end_write(record_written, END_WRITE_SIZE);
-  census_log_init_reader();
-  size_t bytes_available;
-  const void* record_read = census_log_read_next(&bytes_available);
-  GPR_ASSERT(record_written == record_read);
-  GPR_ASSERT(END_WRITE_SIZE == bytes_available);
-  assert_log_empty();
-  census_log_shutdown();
-}
-
-// Verifies that pending records are not available via read_next().
-void test_read_pending_record(void) {
-  static const size_t PR_RECORD_SIZE = 1024;
-  printf("Starting test: read pending record\n");
-  setup_test(0);
-  // Start a write.
-  void* record_written = census_log_start_write(PR_RECORD_SIZE);
-  GPR_ASSERT(record_written != NULL);
-  // As write is pending, read should fail.
-  census_log_init_reader();
-  size_t bytes_available;
-  const void* record_read = census_log_read_next(&bytes_available);
-  GPR_ASSERT(record_read == NULL);
-  // A read followed by end_write() should succeed.
-  census_log_end_write(record_written, PR_RECORD_SIZE);
-  census_log_init_reader();
-  record_read = census_log_read_next(&bytes_available);
-  GPR_ASSERT(record_written == record_read);
-  GPR_ASSERT(PR_RECORD_SIZE == bytes_available);
-  assert_log_empty();
-  census_log_shutdown();
-}
-
-// Tries reading beyond pending write.
-void test_read_beyond_pending_record(void) {
-  printf("Starting test: read beyond pending record\n");
-  setup_test(0);
-  // Start a write.
-  const size_t incomplete_record_size = 10;
-  void* incomplete_record = census_log_start_write(incomplete_record_size);
-  GPR_ASSERT(incomplete_record != NULL);
-  const size_t complete_record_size = 20;
-  void* complete_record = census_log_start_write(complete_record_size);
-  GPR_ASSERT(complete_record != NULL);
-  GPR_ASSERT(complete_record != incomplete_record);
-  census_log_end_write(complete_record, complete_record_size);
-  // Now iterate over blocks to read completed records.
-  census_log_init_reader();
-  size_t bytes_available;
-  const void* record_read = census_log_read_next(&bytes_available);
-  GPR_ASSERT(complete_record == record_read);
-  GPR_ASSERT(complete_record_size == bytes_available);
-  // Complete first record.
-  census_log_end_write(incomplete_record, incomplete_record_size);
-  // Have read past the incomplete record, so read_next() should return NULL.
-  // NB: this test also assumes our thread did not get switched to a different
-  // CPU between the two start_write calls
-  record_read = census_log_read_next(&bytes_available);
-  GPR_ASSERT(record_read == NULL);
-  // Reset reader to get the newly completed record.
-  census_log_init_reader();
-  record_read = census_log_read_next(&bytes_available);
-  GPR_ASSERT(incomplete_record == record_read);
-  GPR_ASSERT(incomplete_record_size == bytes_available);
-  assert_log_empty();
-  census_log_shutdown();
-}
-
-// Tests scenario where block being read is detached from a core and put on the
-// dirty list.
-void test_detached_while_reading(void) {
-  printf("Starting test: detached while reading\n");
-  setup_test(0);
-  // Start a write.
-  static const size_t DWR_RECORD_SIZE = 10;
-  void* record_written = census_log_start_write(DWR_RECORD_SIZE);
-  GPR_ASSERT(record_written != NULL);
-  census_log_end_write(record_written, DWR_RECORD_SIZE);
-  // Read this record.
-  census_log_init_reader();
-  size_t bytes_available;
-  const void* record_read = census_log_read_next(&bytes_available);
-  GPR_ASSERT(record_read != NULL);
-  GPR_ASSERT(DWR_RECORD_SIZE == bytes_available);
-  // Now fill the log. This will move the block being read from core-local
-  // array to the dirty list.
-  while ((record_written = census_log_start_write(DWR_RECORD_SIZE))) {
-    census_log_end_write(record_written, DWR_RECORD_SIZE);
-  }
-
-  // In this iteration, read_next() should only traverse blocks in the
-  // core-local array. Therefore, we expect at most gpr_cpu_num_cores() more
-  // blocks. As log is full, if read_next() is traversing the dirty list, we
-  // will get more than gpr_cpu_num_cores() blocks.
-  int block_read = 0;
-  while ((record_read = census_log_read_next(&bytes_available))) {
-    ++block_read;
-    GPR_ASSERT(block_read <= (int)gpr_cpu_num_cores());
-  }
-  census_log_shutdown();
-}
-
-// Fills non-circular log with records sized such that size is a multiple of
-// CENSUS_LOG_MAX_RECORD_SIZE (no per-block fragmentation).
-void test_fill_log_no_fragmentation(void) {
-  printf("Starting test: fill log no fragmentation\n");
-  const int circular = 0;
-  setup_test(circular);
-  fill_log(LOG_SIZE_IN_BYTES, 1 /* no fragmentation */, circular);
-  census_log_shutdown();
-}
-
-// Fills circular log with records sized such that size is a multiple of
-// CENSUS_LOG_MAX_RECORD_SIZE (no per-block fragmentation).
-void test_fill_circular_log_no_fragmentation(void) {
-  printf("Starting test: fill circular log no fragmentation\n");
-  const int circular = 1;
-  setup_test(circular);
-  fill_log(LOG_SIZE_IN_BYTES, 1 /* no fragmentation */, circular);
-  census_log_shutdown();
-}
-
-// Fills non-circular log with records that may straddle end of a block.
-void test_fill_log_with_straddling_records(void) {
-  printf("Starting test: fill log with straddling records\n");
-  const int circular = 0;
-  setup_test(circular);
-  fill_log(LOG_SIZE_IN_BYTES, 0 /* block straddling records */, circular);
-  census_log_shutdown();
-}
-
-// Fills circular log with records that may straddle end of a block.
-void test_fill_circular_log_with_straddling_records(void) {
-  printf("Starting test: fill circular log with straddling records\n");
-  const int circular = 1;
-  setup_test(circular);
-  fill_log(LOG_SIZE_IN_BYTES, 0 /* block straddling records */, circular);
-  census_log_shutdown();
-}
-
-// Tests scenario where multiple writers and a single reader are using a log
-// that is configured to discard old records.
-void test_multiple_writers_circular_log(void) {
-  printf("Starting test: multiple writers circular log\n");
-  const int circular = 1;
-  setup_test(circular);
-  multiple_writers_single_reader(circular);
-  census_log_shutdown();
-}
-
-// Tests scenario where multiple writers and a single reader are using a log
-// that is configured to discard old records.
-void test_multiple_writers(void) {
-  printf("Starting test: multiple writers\n");
-  const int circular = 0;
-  setup_test(circular);
-  multiple_writers_single_reader(circular);
-  census_log_shutdown();
-}
-
-// Repeat the straddling records and multiple writers tests with a small log.
-void test_small_log(void) {
-  printf("Starting test: small log\n");
-  const int circular = 0;
-  census_log_initialize(0, circular);
-  size_t log_size = census_log_remaining_space();
-  GPR_ASSERT(log_size > 0);
-  fill_log(log_size, 0, circular);
-  census_log_shutdown();
-  census_log_initialize(0, circular);
-  multiple_writers_single_reader(circular);
-  census_log_shutdown();
-}
-
-void test_performance(void) {
-  for (size_t write_size = 1; write_size < CENSUS_LOG_MAX_RECORD_SIZE;
-       write_size *= 2) {
-    setup_test(0);
-    gpr_timespec start_time = gpr_now(GPR_CLOCK_REALTIME);
-    int nrecords = 0;
-    while (1) {
-      void* record = census_log_start_write(write_size);
-      if (record == NULL) {
-        break;
-      }
-      census_log_end_write(record, write_size);
-      nrecords++;
-    }
-    gpr_timespec write_time =
-        gpr_time_sub(gpr_now(GPR_CLOCK_REALTIME), start_time);
-    double write_time_micro =
-        (double)write_time.tv_sec * 1000000 + (double)write_time.tv_nsec / 1000;
-    census_log_shutdown();
-    printf(
-        "Wrote %d %d byte records in %.3g microseconds: %g records/us "
-        "(%g ns/record), %g gigabytes/s\n",
-        nrecords, (int)write_size, write_time_micro,
-        nrecords / write_time_micro, 1000 * write_time_micro / nrecords,
-        (double)((int)write_size * nrecords) / write_time_micro / 1000);
-  }
-}
-
-int main(int argc, char** argv) {
-  grpc_test_init(argc, argv);
-  gpr_time_init();
-  srand((unsigned)gpr_now(GPR_CLOCK_REALTIME).tv_nsec);
-  test_invalid_record_size();
-  test_end_write_with_different_size();
-  test_read_pending_record();
-  test_read_beyond_pending_record();
-  test_detached_while_reading();
-  test_fill_log_no_fragmentation();
-  test_fill_circular_log_no_fragmentation();
-  test_fill_log_with_straddling_records();
-  test_fill_circular_log_with_straddling_records();
-  test_small_log();
-  test_multiple_writers();
-  test_multiple_writers_circular_log();
-  test_performance();
-  return 0;
-}
diff --git a/test/core/census/resource_test.c b/test/core/census/resource_test.c
deleted file mode 100644
index 48fc43e45b..0000000000
--- a/test/core/census/resource_test.c
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include "src/core/ext/census/resource.h"
-#include <grpc/census.h>
-#include <grpc/support/log.h>
-#include <grpc/support/port_platform.h>
-#include <grpc/support/useful.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include "src/core/ext/census/base_resources.h"
-#include "test/core/util/test_config.h"
-
-// Test all the functionality for dealing with Resources.
-
-// Just startup and shutdown resources subsystem.
-static void test_enable_disable() {
-  initialize_resources();
-  shutdown_resources();
-}
-
-// A blank/empty initialization should not work.
-static void test_empty_definition() {
-  initialize_resources();
-  int32_t rid = census_define_resource(NULL, 0);
-  GPR_ASSERT(rid == -1);
-  uint8_t buffer[50] = {0};
-  rid = census_define_resource(buffer, 50);
-  GPR_ASSERT(rid == -1);
-  shutdown_resources();
-}
-
-// Given a file name, read raw proto and define the resource included within.
-// Returns resource id from census_define_resource().
-static int32_t define_resource_from_file(const char *file) {
-#define BUF_SIZE 512
-  uint8_t buffer[BUF_SIZE];
-  FILE *input = fopen(file, "rb");
-  GPR_ASSERT(input != NULL);
-  size_t nbytes = fread(buffer, 1, BUF_SIZE, input);
-  GPR_ASSERT(nbytes != 0 && nbytes < BUF_SIZE && feof(input) && !ferror(input));
-  int32_t rid = census_define_resource(buffer, nbytes);
-  GPR_ASSERT(fclose(input) == 0);
-  return rid;
-}
-
-// Test definition of a single resource, using a proto read from a file. The
-// `succeed` parameter indicates whether we expect the definition to succeed or
-// fail. `name` is used to check that the returned resource can be looked up by
-// name.
-static void test_define_single_resource(const char *file, const char *name,
-                                        bool succeed) {
-  gpr_log(GPR_INFO, "Test defining resource \"%s\"\n", name);
-  initialize_resources();
-  int32_t rid = define_resource_from_file(file);
-  if (succeed) {
-    GPR_ASSERT(rid >= 0);
-    int32_t rid2 = census_resource_id(name);
-    GPR_ASSERT(rid == rid2);
-  } else {
-    GPR_ASSERT(rid < 0);
-  }
-  shutdown_resources();
-}
-
-// Try deleting various resources (both those that exist and those that don't).
-static void test_delete_resource(const char *minimal_good, const char *full) {
-  initialize_resources();
-  // Try deleting resource before any are defined.
-  census_delete_resource(0);
-  // Create and check a couple of resources.
-  int32_t rid1 = define_resource_from_file(minimal_good);
-  int32_t rid2 = define_resource_from_file(full);
-  GPR_ASSERT(rid1 >= 0 && rid2 >= 0 && rid1 != rid2);
-  int32_t rid3 = census_resource_id("minimal_good");
-  int32_t rid4 = census_resource_id("full_resource");
-  GPR_ASSERT(rid1 == rid3 && rid2 == rid4);
-  // Try deleting non-existant resources.
-  census_delete_resource(-1);
-  census_delete_resource(rid1 + rid2 + 1);
-  census_delete_resource(10000000);
-  // Delete one of the previously defined resources and check for deletion.
-  census_delete_resource(rid1);
-  rid3 = census_resource_id("minimal_good");
-  GPR_ASSERT(rid3 < 0);
-  // Check that re-adding works.
-  rid1 = define_resource_from_file(minimal_good);
-  GPR_ASSERT(rid1 >= 0);
-  rid3 = census_resource_id("minimal_good");
-  GPR_ASSERT(rid1 == rid3);
-  shutdown_resources();
-}
-
-// Test define base resources.
-static void test_base_resources() {
-  initialize_resources();
-  define_base_resources();
-  int32_t rid1 = census_resource_id("client_rpc_latency");
-  int32_t rid2 = census_resource_id("server_rpc_latency");
-  GPR_ASSERT(rid1 >= 0 && rid2 >= 0 && rid1 != rid2);
-  shutdown_resources();
-}
-
-int main(int argc, char **argv) {
-  const char *resource_empty_name_pb, *resource_full_pb,
-      *resource_minimal_good_pb, *resource_no_name_pb,
-      *resource_no_numerator_pb, *resource_no_unit_pb;
-  if (argc == 7) {
-    resource_empty_name_pb = argv[1];
-    resource_full_pb = argv[2];
-    resource_minimal_good_pb = argv[3];
-    resource_no_name_pb = argv[4];
-    resource_no_numerator_pb = argv[5];
-    resource_no_unit_pb = argv[6];
-  } else {
-    GPR_ASSERT(argc == 1);
-    resource_empty_name_pb = "test/core/census/data/resource_empty_name.pb";
-    resource_full_pb = "test/core/census/data/resource_full.pb";
-    resource_minimal_good_pb = "test/core/census/data/resource_minimal_good.pb";
-    resource_no_name_pb = "test/core/census/data/resource_no_name.pb";
-    resource_no_numerator_pb = "test/core/census/data/resource_no_numerator.pb";
-    resource_no_unit_pb = "test/core/census/data/resource_no_unit.pb";
-  }
-  grpc_test_init(argc, argv);
-  test_enable_disable();
-  test_empty_definition();
-  test_define_single_resource(resource_minimal_good_pb, "minimal_good", true);
-  test_define_single_resource(resource_full_pb, "full_resource", true);
-  test_define_single_resource(resource_no_name_pb, "resource_no_name", false);
-  test_define_single_resource(resource_no_numerator_pb, "resource_no_numerator",
-                              false);
-  test_define_single_resource(resource_no_unit_pb, "resource_no_unit", false);
-  test_define_single_resource(resource_empty_name_pb, "resource_empty_name",
-                              false);
-  test_delete_resource(resource_minimal_good_pb, resource_full_pb);
-  test_base_resources();
-  return 0;
-}
diff --git a/test/core/census/trace_context_test.c b/test/core/census/trace_context_test.c
deleted file mode 100644
index 6eb831a85e..0000000000
--- a/test/core/census/trace_context_test.c
+++ /dev/null
@@ -1,215 +0,0 @@
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <grpc/census.h>
-#include <grpc/support/log.h>
-#include <grpc/support/port_platform.h>
-#include <grpc/support/useful.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include "src/core/ext/census/base_resources.h"
-#include "src/core/ext/census/resource.h"
-#include "test/core/util/test_config.h"
-
-#include "src/core/ext/census/gen/trace_context.pb.h"
-#include "src/core/ext/census/trace_context.h"
-#include "third_party/nanopb/pb_decode.h"
-#include "third_party/nanopb/pb_encode.h"
-
-#define BUF_SIZE 256
-
-/* Encodes a TraceContext structure (ctxt1) to a buffer, and then decodes it
-to a second TraceContext (ctxt2).  Validates that the resulting TraceContext
-has a span_id, trace_id, and that the values are equal to those in initial
-TraceContext. On success, returns true.  If encode_trace_context returns 0,
-decode_trace_context fails, or the resulting TraceContext is missing a trace_id
-or span_id, it will return false. */
-bool validate_encode_decode_context(google_trace_TraceContext *ctxt1,
-                                    uint8_t *buffer, size_t buf_size) {
-  google_trace_TraceContext ctxt2 = google_trace_TraceContext_init_zero;
-  size_t msg_length;
-
-  msg_length = encode_trace_context(ctxt1, buffer, buf_size);
-  if (msg_length == 0) {
-    return false;
-  }
-
-  if (!decode_trace_context(&ctxt2, buffer, msg_length)) {
-    return false;
-  }
-
-  if (!ctxt2.has_trace_id_hi || !ctxt2.has_trace_id_lo || !ctxt2.has_span_id) {
-    return false;
-  }
-
-  GPR_ASSERT(ctxt1->trace_id_hi == ctxt2.trace_id_hi &&
-             ctxt1->trace_id_lo == ctxt2.trace_id_lo &&
-             ctxt1->span_id == ctxt2.span_id &&
-             ctxt1->has_span_options == ctxt2.has_span_options &&
-             (ctxt1->has_span_options
-                  ? ctxt1->span_options == ctxt2.span_options
-                  : true));
-
-  return true;
-}
-
-/* Decodes a proto-encoded TraceContext from a buffer.  If decode_trace_context
-fails or the resulting TraceContext is missing a trace_id or span_id it will
-return false, otherwise returns true. */
-bool validate_decode_context(google_trace_TraceContext *ctxt, uint8_t *buffer,
-                             size_t msg_length) {
-  // Validate the decoding of a context written to buffer.
-  if (!decode_trace_context(ctxt, buffer, msg_length)) {
-    return false;
-  }
-
-  if (!ctxt->has_trace_id_hi || !ctxt->has_trace_id_lo || !ctxt->has_span_id) {
-    return false;
-  }
-
-  return true;
-}
-
-/* Read an encoded trace context from a file.  Validates that the decoding
-gives the expected result (succeed). */
-static void read_and_validate_context_from_file(google_trace_TraceContext *ctxt,
-                                                const char *file,
-                                                const bool succeed) {
-  uint8_t buffer[BUF_SIZE];
-  FILE *input = fopen(file, "rb");
-  GPR_ASSERT(input != NULL);
-  size_t nbytes = fread(buffer, 1, BUF_SIZE, input);
-  GPR_ASSERT(nbytes <= BUF_SIZE && feof(input) && !ferror(input));
-  bool res = validate_decode_context(ctxt, buffer, nbytes);
-  GPR_ASSERT(res == succeed);
-  GPR_ASSERT(fclose(input) == 0);
-}
-
-// Test full proto-buffer.
-static void test_full() {
-  google_trace_TraceContext ctxt = google_trace_TraceContext_init_zero;
-  read_and_validate_context_from_file(
-      &ctxt, "test/core/census/data/context_full.pb", true);
-}
-
-// Test empty proto-buffer.
-static void test_empty() {
-  google_trace_TraceContext ctxt = google_trace_TraceContext_init_zero;
-  read_and_validate_context_from_file(
-      &ctxt, "test/core/census/data/context_empty.pb", false);
-}
-
-// Test proto-buffer with only trace_id.
-static void test_trace_only() {
-  google_trace_TraceContext ctxt = google_trace_TraceContext_init_zero;
-  read_and_validate_context_from_file(
-      &ctxt, "test/core/census/data/context_trace_only.pb", false);
-}
-
-// Test proto-buffer with only span_id.
-static void test_span_only() {
-  google_trace_TraceContext ctxt = google_trace_TraceContext_init_zero;
-  read_and_validate_context_from_file(
-      &ctxt, "test/core/census/data/context_span_only.pb", false);
-}
-
-// Test proto-buffer without span_options value.
-static void test_no_span_options() {
-  google_trace_TraceContext ctxt = google_trace_TraceContext_init_zero;
-  read_and_validate_context_from_file(
-      &ctxt, "test/core/census/data/context_no_span_options.pb", true);
-  GPR_ASSERT(ctxt.has_span_options == false && ctxt.span_options == 0);
-}
-
-static void test_encode_decode() {
-  uint8_t buffer[BUF_SIZE] = {0};
-
-  google_trace_TraceContext ctxt1 = google_trace_TraceContext_init_zero;
-  ctxt1.has_trace_id_hi = true;
-  ctxt1.has_trace_id_lo = true;
-  ctxt1.trace_id_lo = 1;
-  ctxt1.trace_id_hi = 2;
-  ctxt1.has_span_id = true;
-  ctxt1.span_id = 3;
-  validate_encode_decode_context(&ctxt1, buffer, sizeof(buffer));
-
-  // Missing trace_id. This should fail.
-  google_trace_TraceContext ctxt2 = google_trace_TraceContext_init_zero;
-  ctxt2.has_trace_id_hi = false;
-  ctxt2.has_trace_id_lo = false;
-  ctxt2.has_span_id = true;
-  validate_encode_decode_context(&ctxt2, buffer, sizeof(buffer));
-}
-
-// Test a corrupted proto-buffer. This should fail.
-static void test_corrupt() {
-  uint8_t buffer[BUF_SIZE] = {0};
-  google_trace_TraceContext ctxt1 = google_trace_TraceContext_init_zero;
-  size_t msg_length;
-
-  ctxt1.has_trace_id_hi = true;
-  ctxt1.has_trace_id_lo = true;
-  ctxt1.trace_id_lo = 1;
-  ctxt1.trace_id_hi = 2;
-  ctxt1.has_span_id = true;
-  ctxt1.span_id = 3;
-  ctxt1.has_span_options = true;
-  ctxt1.span_options = SPAN_OPTIONS_IS_SAMPLED;
-  msg_length = encode_trace_context(&ctxt1, buffer, sizeof(buffer));
-
-  /* Corrupt some bytes.  255 (0xFF) should be illegal for the first byte of the
-  proto encoded object. */
-  buffer[0] = 255;
-
-  bool res = validate_decode_context(&ctxt1, buffer, msg_length);
-  GPR_ASSERT(res == false);
-}
-
-static void test_buffer_size() {
-  // This buffer is too small. This should fail.
-  uint8_t buffer[16] = {0};
-  google_trace_TraceContext ctxt1 = google_trace_TraceContext_init_zero;
-  size_t msg_length;
-
-  ctxt1.has_trace_id_hi = true;
-  ctxt1.has_trace_id_lo = true;
-  ctxt1.trace_id_lo = 1;
-  ctxt1.trace_id_hi = 2;
-  ctxt1.has_span_id = true;
-  ctxt1.span_id = 3;
-  ctxt1.has_span_options = true;
-  ctxt1.span_options = SPAN_OPTIONS_IS_SAMPLED;
-  msg_length = encode_trace_context(&ctxt1, buffer, sizeof(buffer));
-
-  GPR_ASSERT(msg_length == 0);
-}
-
-int main(int argc, char **argv) {
-  grpc_test_init(argc, argv);
-  test_full();
-  test_empty();
-  test_trace_only();
-  test_span_only();
-  test_encode_decode();
-  test_corrupt();
-  test_no_span_options();
-  test_buffer_size();
-
-  return 0;
-}
diff --git a/test/core/channel/BUILD b/test/core/channel/BUILD
index 5ac77c449b..92f5907aac 100644
--- a/test/core/channel/BUILD
+++ b/test/core/channel/BUILD
@@ -20,8 +20,8 @@ licenses(["notice"])  # Apache v2
 
 grpc_cc_test(
     name = "channel_args_test",
-    srcs = ["channel_args_test.c"],
-    language = "C",
+    srcs = ["channel_args_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -32,8 +32,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "channel_stack_test",
-    srcs = ["channel_stack_test.c"],
-    language = "C",
+    srcs = ["channel_stack_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -44,8 +44,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "channel_stack_builder_test",
-    srcs = ["channel_stack_builder_test.c"],
-    language = "C",
+    srcs = ["channel_stack_builder_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
diff --git a/test/core/channel/channel_args_test.c b/test/core/channel/channel_args_test.cc
index deaf2933ec..e8b3334185 100644
--- a/test/core/channel/channel_args_test.c
+++ b/test/core/channel/channel_args_test.cc
@@ -31,19 +31,19 @@ static void test_create(void) {
   grpc_arg arg_int;
   grpc_arg arg_string;
   grpc_arg to_add[2];
-  grpc_channel_args *ch_args;
+  grpc_channel_args* ch_args;
 
-  arg_int.key = "int_arg";
+  arg_int.key = const_cast<char*>("int_arg");
   arg_int.type = GRPC_ARG_INTEGER;
   arg_int.value.integer = 123;
 
-  arg_string.key = "str key";
+  arg_string.key = const_cast<char*>("str key");
   arg_string.type = GRPC_ARG_STRING;
-  arg_string.value.string = "str value";
+  arg_string.value.string = const_cast<char*>("str value");
 
   to_add[0] = arg_int;
   to_add[1] = arg_string;
-  ch_args = grpc_channel_args_copy_and_add(NULL, to_add, 2);
+  ch_args = grpc_channel_args_copy_and_add(nullptr, to_add, 2);
 
   GPR_ASSERT(ch_args->num_args == 2);
   GPR_ASSERT(strcmp(ch_args->args[0].key, arg_int.key) == 0);
@@ -61,10 +61,10 @@ static void test_create(void) {
 
 static void test_set_compression_algorithm(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_channel_args *ch_args;
+  grpc_channel_args* ch_args;
 
   ch_args =
-      grpc_channel_args_set_compression_algorithm(NULL, GRPC_COMPRESS_GZIP);
+      grpc_channel_args_set_compression_algorithm(nullptr, GRPC_COMPRESS_GZIP);
   GPR_ASSERT(ch_args->num_args == 1);
   GPR_ASSERT(strcmp(ch_args->args[0].key,
                     GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM) == 0);
@@ -80,7 +80,7 @@ static void test_compression_algorithm_states(void) {
   unsigned states_bitset;
   size_t i;
 
-  ch_args = grpc_channel_args_copy_and_add(NULL, NULL, 0);
+  ch_args = grpc_channel_args_copy_and_add(nullptr, nullptr, 0);
   /* by default, all enabled */
   states_bitset =
       (unsigned)grpc_channel_args_compression_algorithm_get_states(ch_args);
@@ -127,11 +127,11 @@ static void test_compression_algorithm_states(void) {
 }
 
 static void test_set_socket_mutator(void) {
-  grpc_channel_args *ch_args;
+  grpc_channel_args* ch_args;
   grpc_socket_mutator mutator;
-  grpc_socket_mutator_init(&mutator, NULL);
+  grpc_socket_mutator_init(&mutator, nullptr);
 
-  ch_args = grpc_channel_args_set_socket_mutator(NULL, &mutator);
+  ch_args = grpc_channel_args_set_socket_mutator(nullptr, &mutator);
   GPR_ASSERT(ch_args->num_args == 1);
   GPR_ASSERT(strcmp(ch_args->args[0].key, GRPC_ARG_SOCKET_MUTATOR) == 0);
   GPR_ASSERT(ch_args->args[0].type == GRPC_ARG_POINTER);
@@ -143,7 +143,7 @@ static void test_set_socket_mutator(void) {
   }
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   test_create();
diff --git a/test/core/channel/channel_stack_builder_test.c b/test/core/channel/channel_stack_builder_test.cc
index 682efd1438..a67f0efafe 100644
--- a/test/core/channel/channel_stack_builder_test.c
+++ b/test/core/channel/channel_stack_builder_test.cc
@@ -29,30 +29,30 @@
 #include "src/core/lib/surface/channel_init.h"
 #include "test/core/util/test_config.h"
 
-static grpc_error *channel_init_func(grpc_exec_ctx *exec_ctx,
-                                     grpc_channel_element *elem,
-                                     grpc_channel_element_args *args) {
+static grpc_error* channel_init_func(grpc_exec_ctx* exec_ctx,
+                                     grpc_channel_element* elem,
+                                     grpc_channel_element_args* args) {
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error *call_init_func(grpc_exec_ctx *exec_ctx,
-                                  grpc_call_element *elem,
-                                  const grpc_call_element_args *args) {
+static grpc_error* call_init_func(grpc_exec_ctx* exec_ctx,
+                                  grpc_call_element* elem,
+                                  const grpc_call_element_args* args) {
   return GRPC_ERROR_NONE;
 }
 
-static void channel_destroy_func(grpc_exec_ctx *exec_ctx,
-                                 grpc_channel_element *elem) {}
+static void channel_destroy_func(grpc_exec_ctx* exec_ctx,
+                                 grpc_channel_element* elem) {}
 
-static void call_destroy_func(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
-                              const grpc_call_final_info *final_info,
-                              grpc_closure *ignored) {}
+static void call_destroy_func(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+                              const grpc_call_final_info* final_info,
+                              grpc_closure* ignored) {}
 
-static void call_func(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
-                      grpc_transport_stream_op_batch *op) {}
+static void call_func(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+                      grpc_transport_stream_op_batch* op) {}
 
-static void channel_func(grpc_exec_ctx *exec_ctx, grpc_channel_element *elem,
-                         grpc_transport_op *op) {
+static void channel_func(grpc_exec_ctx* exec_ctx, grpc_channel_element* elem,
+                         grpc_transport_op* op) {
   if (op->disconnect_with_error != GRPC_ERROR_NONE) {
     GRPC_ERROR_UNREF(op->disconnect_with_error);
   }
@@ -61,18 +61,18 @@ static void channel_func(grpc_exec_ctx *exec_ctx, grpc_channel_element *elem,
 
 bool g_replacement_fn_called = false;
 bool g_original_fn_called = false;
-void set_arg_once_fn(grpc_channel_stack *channel_stack,
-                     grpc_channel_element *elem, void *arg) {
-  bool *called = arg;
+void set_arg_once_fn(grpc_channel_stack* channel_stack,
+                     grpc_channel_element* elem, void* arg) {
+  bool* called = static_cast<bool*>(arg);
   // Make sure this function is only called once per arg.
   GPR_ASSERT(*called == false);
   *called = true;
 }
 
 static void test_channel_stack_builder_filter_replace(void) {
-  grpc_channel *channel =
-      grpc_insecure_channel_create("target name isn't used", NULL, NULL);
-  GPR_ASSERT(channel != NULL);
+  grpc_channel* channel =
+      grpc_insecure_channel_create("target name isn't used", nullptr, nullptr);
+  GPR_ASSERT(channel != nullptr);
   // Make sure the high priority filter has been created.
   GPR_ASSERT(g_replacement_fn_called);
   // ... and that the low priority one hasn't.
@@ -106,10 +106,11 @@ const grpc_channel_filter original_filter = {
     grpc_channel_next_get_info,
     "filter_name"};
 
-static bool add_replacement_filter(grpc_exec_ctx *exec_ctx,
-                                   grpc_channel_stack_builder *builder,
-                                   void *arg) {
-  const grpc_channel_filter *filter = arg;
+static bool add_replacement_filter(grpc_exec_ctx* exec_ctx,
+                                   grpc_channel_stack_builder* builder,
+                                   void* arg) {
+  const grpc_channel_filter* filter =
+      static_cast<const grpc_channel_filter*>(arg);
   // Get rid of any other version of the filter, as determined by having the
   // same name.
   GPR_ASSERT(grpc_channel_stack_builder_remove_filter(builder, filter->name));
@@ -117,26 +118,26 @@ static bool add_replacement_filter(grpc_exec_ctx *exec_ctx,
       builder, filter, set_arg_once_fn, &g_replacement_fn_called);
 }
 
-static bool add_original_filter(grpc_exec_ctx *exec_ctx,
-                                grpc_channel_stack_builder *builder,
-                                void *arg) {
+static bool add_original_filter(grpc_exec_ctx* exec_ctx,
+                                grpc_channel_stack_builder* builder,
+                                void* arg) {
   return grpc_channel_stack_builder_prepend_filter(
-      builder, (const grpc_channel_filter *)arg, set_arg_once_fn,
+      builder, (const grpc_channel_filter*)arg, set_arg_once_fn,
       &g_original_fn_called);
 }
 
 static void init_plugin(void) {
   grpc_channel_init_register_stage(GRPC_CLIENT_CHANNEL, INT_MAX,
                                    add_original_filter,
-                                   (void *)&original_filter);
+                                   (void*)&original_filter);
   grpc_channel_init_register_stage(GRPC_CLIENT_CHANNEL, INT_MAX,
                                    add_replacement_filter,
-                                   (void *)&replacement_filter);
+                                   (void*)&replacement_filter);
 }
 
 static void destroy_plugin(void) {}
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_register_plugin(init_plugin, destroy_plugin);
   grpc_init();
diff --git a/test/core/channel/channel_stack_test.c b/test/core/channel/channel_stack_test.cc
index a07ef89ba8..988ea9bac9 100644
--- a/test/core/channel/channel_stack_test.c
+++ b/test/core/channel/channel_stack_test.cc
@@ -27,54 +27,55 @@
 #include "src/core/lib/slice/slice_internal.h"
 #include "test/core/util/test_config.h"
 
-static grpc_error *channel_init_func(grpc_exec_ctx *exec_ctx,
-                                     grpc_channel_element *elem,
-                                     grpc_channel_element_args *args) {
+static grpc_error* channel_init_func(grpc_exec_ctx* exec_ctx,
+                                     grpc_channel_element* elem,
+                                     grpc_channel_element_args* args) {
   GPR_ASSERT(args->channel_args->num_args == 1);
   GPR_ASSERT(args->channel_args->args[0].type == GRPC_ARG_INTEGER);
   GPR_ASSERT(0 == strcmp(args->channel_args->args[0].key, "test_key"));
   GPR_ASSERT(args->channel_args->args[0].value.integer == 42);
   GPR_ASSERT(args->is_first);
   GPR_ASSERT(args->is_last);
-  *(int *)(elem->channel_data) = 0;
+  *(int*)(elem->channel_data) = 0;
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error *call_init_func(grpc_exec_ctx *exec_ctx,
-                                  grpc_call_element *elem,
-                                  const grpc_call_element_args *args) {
-  ++*(int *)(elem->channel_data);
-  *(int *)(elem->call_data) = 0;
+static grpc_error* call_init_func(grpc_exec_ctx* exec_ctx,
+                                  grpc_call_element* elem,
+                                  const grpc_call_element_args* args) {
+  ++*(int*)(elem->channel_data);
+  *(int*)(elem->call_data) = 0;
   return GRPC_ERROR_NONE;
 }
 
-static void channel_destroy_func(grpc_exec_ctx *exec_ctx,
-                                 grpc_channel_element *elem) {}
+static void channel_destroy_func(grpc_exec_ctx* exec_ctx,
+                                 grpc_channel_element* elem) {}
 
-static void call_destroy_func(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
-                              const grpc_call_final_info *final_info,
-                              grpc_closure *ignored) {
-  ++*(int *)(elem->channel_data);
+static void call_destroy_func(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+                              const grpc_call_final_info* final_info,
+                              grpc_closure* ignored) {
+  ++*(int*)(elem->channel_data);
 }
 
-static void call_func(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
-                      grpc_transport_stream_op_batch *op) {
-  ++*(int *)(elem->call_data);
+static void call_func(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+                      grpc_transport_stream_op_batch* op) {
+  ++*(int*)(elem->call_data);
 }
 
-static void channel_func(grpc_exec_ctx *exec_ctx, grpc_channel_element *elem,
-                         grpc_transport_op *op) {
-  ++*(int *)(elem->channel_data);
+static void channel_func(grpc_exec_ctx* exec_ctx, grpc_channel_element* elem,
+                         grpc_transport_op* op) {
+  ++*(int*)(elem->channel_data);
 }
 
-static void free_channel(grpc_exec_ctx *exec_ctx, void *arg,
-                         grpc_error *error) {
-  grpc_channel_stack_destroy(exec_ctx, arg);
+static void free_channel(grpc_exec_ctx* exec_ctx, void* arg,
+                         grpc_error* error) {
+  grpc_channel_stack_destroy(exec_ctx, static_cast<grpc_channel_stack*>(arg));
   gpr_free(arg);
 }
 
-static void free_call(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  grpc_call_stack_destroy(exec_ctx, arg, NULL, NULL);
+static void free_call(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+  grpc_call_stack_destroy(exec_ctx, static_cast<grpc_call_stack*>(arg), nullptr,
+                          nullptr);
   gpr_free(arg);
 }
 
@@ -91,50 +92,54 @@ static void test_create_channel_stack(void) {
       channel_destroy_func,
       grpc_channel_next_get_info,
       "some_test_filter"};
-  const grpc_channel_filter *filters = &filter;
-  grpc_channel_stack *channel_stack;
-  grpc_call_stack *call_stack;
-  grpc_channel_element *channel_elem;
-  grpc_call_element *call_elem;
+  const grpc_channel_filter* filters = &filter;
+  grpc_channel_stack* channel_stack;
+  grpc_call_stack* call_stack;
+  grpc_channel_element* channel_elem;
+  grpc_call_element* call_elem;
   grpc_arg arg;
   grpc_channel_args chan_args;
-  int *channel_data;
-  int *call_data;
+  int* channel_data;
+  int* call_data;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_slice path = grpc_slice_from_static_string("/service/method");
 
   arg.type = GRPC_ARG_INTEGER;
-  arg.key = "test_key";
+  arg.key = const_cast<char*>("test_key");
   arg.value.integer = 42;
 
   chan_args.num_args = 1;
   chan_args.args = &arg;
 
-  channel_stack = gpr_malloc(grpc_channel_stack_size(&filters, 1));
+  channel_stack = static_cast<grpc_channel_stack*>(
+      gpr_malloc(grpc_channel_stack_size(&filters, 1)));
   grpc_channel_stack_init(&exec_ctx, 1, free_channel, channel_stack, &filters,
-                          1, &chan_args, NULL, "test", channel_stack);
+                          1, &chan_args, nullptr, "test", channel_stack);
   GPR_ASSERT(channel_stack->count == 1);
   channel_elem = grpc_channel_stack_element(channel_stack, 0);
-  channel_data = (int *)channel_elem->channel_data;
+  channel_data = (int*)channel_elem->channel_data;
   GPR_ASSERT(*channel_data == 0);
 
-  call_stack = gpr_malloc(channel_stack->call_stack_size);
+  call_stack =
+      static_cast<grpc_call_stack*>(gpr_malloc(channel_stack->call_stack_size));
   const grpc_call_element_args args = {
-      .call_stack = call_stack,
-      .server_transport_data = NULL,
-      .context = NULL,
-      .path = path,
-      .start_time = gpr_now(GPR_CLOCK_MONOTONIC),
-      .deadline = GRPC_MILLIS_INF_FUTURE,
-      .arena = NULL};
-  grpc_error *error = grpc_call_stack_init(&exec_ctx, channel_stack, 1,
+      call_stack,                   /* call_stack */
+      nullptr,                      /* server_transport_data */
+      nullptr,                      /* context */
+      path,                         /* path */
+      gpr_now(GPR_CLOCK_MONOTONIC), /* start_time */
+      GRPC_MILLIS_INF_FUTURE,       /* deadline */
+      nullptr,                      /* arena */
+      nullptr                       /* call_combiner */
+  };
+  grpc_error* error = grpc_call_stack_init(&exec_ctx, channel_stack, 1,
                                            free_call, call_stack, &args);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   GPR_ASSERT(call_stack->count == 1);
   call_elem = grpc_call_stack_element(call_stack, 0);
   GPR_ASSERT(call_elem->filter == channel_elem->filter);
   GPR_ASSERT(call_elem->channel_data == channel_elem->channel_data);
-  call_data = (int *)call_elem->call_data;
+  call_data = (int*)call_elem->call_data;
   GPR_ASSERT(*call_data == 0);
   GPR_ASSERT(*channel_data == 1);
 
@@ -148,7 +153,7 @@ static void test_create_channel_stack(void) {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   test_create_channel_stack();
diff --git a/test/core/channel/minimal_stack_is_minimal_test.c b/test/core/channel/minimal_stack_is_minimal_test.cc
index b4528346f7..e0cffa39a8 100644
--- a/test/core/channel/minimal_stack_is_minimal_test.c
+++ b/test/core/channel/minimal_stack_is_minimal_test.cc
@@ -42,8 +42,8 @@
 #include "test/core/util/test_config.h"
 
 // use CHECK_STACK instead
-static int check_stack(const char *file, int line, const char *transport_name,
-                       grpc_channel_args *init_args,
+static int check_stack(const char* file, int line, const char* transport_name,
+                       grpc_channel_args* init_args,
                        unsigned channel_stack_type, ...);
 
 // arguments: const char *transport_name   - the name of the transport type to
@@ -55,17 +55,17 @@ static int check_stack(const char *file, int line, const char *transport_name,
 //                                 filters to instantiate, terminated with NULL
 #define CHECK_STACK(...) check_stack(__FILE__, __LINE__, __VA_ARGS__)
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   int errors = 0;
 
   // tests with a minimal stack
-  grpc_arg minimal_stack_arg = {.type = GRPC_ARG_INTEGER,
-                                .key = GRPC_ARG_MINIMAL_STACK,
-                                .value.integer = 1};
-  grpc_channel_args minimal_stack_args = {.num_args = 1,
-                                          .args = &minimal_stack_arg};
+  grpc_arg minimal_stack_arg;
+  minimal_stack_arg.type = GRPC_ARG_INTEGER;
+  minimal_stack_arg.key = const_cast<char*>(GRPC_ARG_MINIMAL_STACK);
+  minimal_stack_arg.value.integer = 1;
+  grpc_channel_args minimal_stack_args = {1, &minimal_stack_arg};
   errors += CHECK_STACK("unknown", &minimal_stack_args,
                         GRPC_CLIENT_DIRECT_CHANNEL, "connected", NULL);
   errors += CHECK_STACK("unknown", &minimal_stack_args, GRPC_CLIENT_SUBCHANNEL,
@@ -79,26 +79,27 @@ int main(int argc, char **argv) {
                         "http-client", "connected", NULL);
   errors += CHECK_STACK("chttp2", &minimal_stack_args, GRPC_SERVER_CHANNEL,
                         "server", "http-server", "connected", NULL);
-  errors += CHECK_STACK(NULL, &minimal_stack_args, GRPC_CLIENT_CHANNEL,
+  errors += CHECK_STACK(nullptr, &minimal_stack_args, GRPC_CLIENT_CHANNEL,
                         "client-channel", NULL);
 
   // tests with a default stack
-  errors += CHECK_STACK("unknown", NULL, GRPC_CLIENT_DIRECT_CHANNEL,
+  errors += CHECK_STACK("unknown", nullptr, GRPC_CLIENT_DIRECT_CHANNEL,
                         "message_size", "deadline", "connected", NULL);
-  errors += CHECK_STACK("unknown", NULL, GRPC_CLIENT_SUBCHANNEL, "message_size",
-                        "connected", NULL);
-  errors += CHECK_STACK("unknown", NULL, GRPC_SERVER_CHANNEL, "server",
+  errors += CHECK_STACK("unknown", nullptr, GRPC_CLIENT_SUBCHANNEL,
+                        "message_size", "connected", NULL);
+  errors += CHECK_STACK("unknown", nullptr, GRPC_SERVER_CHANNEL, "server",
                         "message_size", "deadline", "connected", NULL);
-  errors += CHECK_STACK("chttp2", NULL, GRPC_CLIENT_DIRECT_CHANNEL,
+  errors += CHECK_STACK("chttp2", nullptr, GRPC_CLIENT_DIRECT_CHANNEL,
                         "message_size", "deadline", "http-client",
                         "message_compress", "connected", NULL);
-  errors += CHECK_STACK("chttp2", NULL, GRPC_CLIENT_SUBCHANNEL, "message_size",
-                        "http-client", "message_compress", "connected", NULL);
-  errors += CHECK_STACK("chttp2", NULL, GRPC_SERVER_CHANNEL, "server",
+  errors +=
+      CHECK_STACK("chttp2", nullptr, GRPC_CLIENT_SUBCHANNEL, "message_size",
+                  "http-client", "message_compress", "connected", NULL);
+  errors += CHECK_STACK("chttp2", nullptr, GRPC_SERVER_CHANNEL, "server",
                         "message_size", "deadline", "http-server",
                         "message_compress", "connected", NULL);
-  errors +=
-      CHECK_STACK(NULL, NULL, GRPC_CLIENT_CHANNEL, "client-channel", NULL);
+  errors += CHECK_STACK(nullptr, nullptr, GRPC_CLIENT_CHANNEL, "client-channel",
+                        NULL);
 
   GPR_ASSERT(errors == 0);
   grpc_shutdown();
@@ -109,16 +110,18 @@ int main(int argc, char **argv) {
  * End of tests definitions, start of test infrastructure
  */
 
-static int check_stack(const char *file, int line, const char *transport_name,
-                       grpc_channel_args *init_args,
+static int check_stack(const char* file, int line, const char* transport_name,
+                       grpc_channel_args* init_args,
                        unsigned channel_stack_type, ...) {
   // create dummy channel stack
-  grpc_channel_stack_builder *builder = grpc_channel_stack_builder_create();
-  grpc_transport_vtable fake_transport_vtable = {.name = transport_name};
-  grpc_transport fake_transport = {.vtable = &fake_transport_vtable};
+  grpc_channel_stack_builder* builder = grpc_channel_stack_builder_create();
+  grpc_transport_vtable fake_transport_vtable;
+  memset(&fake_transport_vtable, 0, sizeof(grpc_transport_vtable));
+  fake_transport_vtable.name = transport_name;
+  grpc_transport fake_transport = {&fake_transport_vtable};
   grpc_channel_stack_builder_set_target(builder, "foo.test.google.fr");
-  grpc_channel_args *channel_args = grpc_channel_args_copy(init_args);
-  if (transport_name != NULL) {
+  grpc_channel_args* channel_args = grpc_channel_args_copy(init_args);
+  if (transport_name != nullptr) {
     grpc_channel_stack_builder_set_transport(builder, &fake_transport);
   }
   {
@@ -136,26 +139,26 @@ static int check_stack(const char *file, int line, const char *transport_name,
   va_list args;
   va_start(args, channel_stack_type);
   for (;;) {
-    char *a = va_arg(args, char *);
-    if (a == NULL) break;
+    char* a = va_arg(args, char*);
+    if (a == nullptr) break;
     if (v.count != 0) gpr_strvec_add(&v, gpr_strdup(", "));
     gpr_strvec_add(&v, gpr_strdup(a));
   }
   va_end(args);
-  char *expect = gpr_strvec_flatten(&v, NULL);
+  char* expect = gpr_strvec_flatten(&v, nullptr);
   gpr_strvec_destroy(&v);
 
   // build up our "got" list
   gpr_strvec_init(&v);
-  grpc_channel_stack_builder_iterator *it =
+  grpc_channel_stack_builder_iterator* it =
       grpc_channel_stack_builder_create_iterator_at_first(builder);
   while (grpc_channel_stack_builder_move_next(it)) {
-    const char *name = grpc_channel_stack_builder_iterator_filter_name(it);
-    if (name == NULL) continue;
+    const char* name = grpc_channel_stack_builder_iterator_filter_name(it);
+    if (name == nullptr) continue;
     if (v.count != 0) gpr_strvec_add(&v, gpr_strdup(", "));
     gpr_strvec_add(&v, gpr_strdup(name));
   }
-  char *got = gpr_strvec_flatten(&v, NULL);
+  char* got = gpr_strvec_flatten(&v, nullptr);
   gpr_strvec_destroy(&v);
   grpc_channel_stack_builder_iterator_destroy(it);
 
@@ -170,7 +173,7 @@ static int check_stack(const char *file, int line, const char *transport_name,
       gpr_strvec_add(&v, gpr_strdup("="));
       switch (channel_args->args[i].type) {
         case GRPC_ARG_INTEGER: {
-          char *tmp;
+          char* tmp;
           gpr_asprintf(&tmp, "%d", channel_args->args[i].value.integer);
           gpr_strvec_add(&v, tmp);
           break;
@@ -179,7 +182,7 @@ static int check_stack(const char *file, int line, const char *transport_name,
           gpr_strvec_add(&v, gpr_strdup(channel_args->args[i].value.string));
           break;
         case GRPC_ARG_POINTER: {
-          char *tmp;
+          char* tmp;
           gpr_asprintf(&tmp, "%p", channel_args->args[i].value.pointer.p);
           gpr_strvec_add(&v, tmp);
           break;
@@ -187,15 +190,17 @@ static int check_stack(const char *file, int line, const char *transport_name,
       }
     }
     gpr_strvec_add(&v, gpr_strdup("}"));
-    char *args_str = gpr_strvec_flatten(&v, NULL);
+    char* args_str = gpr_strvec_flatten(&v, nullptr);
     gpr_strvec_destroy(&v);
 
     gpr_log(file, line, GPR_LOG_SEVERITY_ERROR,
             "**************************************************");
-    gpr_log(file, line, GPR_LOG_SEVERITY_ERROR,
-            "FAILED transport=%s; stack_type=%s; channel_args=%s:",
-            transport_name, grpc_channel_stack_type_string(channel_stack_type),
-            args_str);
+    gpr_log(
+        file, line, GPR_LOG_SEVERITY_ERROR,
+        "FAILED transport=%s; stack_type=%s; channel_args=%s:", transport_name,
+        grpc_channel_stack_type_string(
+            static_cast<grpc_channel_stack_type>(channel_stack_type)),
+        args_str);
     gpr_log(file, line, GPR_LOG_SEVERITY_ERROR, "EXPECTED: %s", expect);
     gpr_log(file, line, GPR_LOG_SEVERITY_ERROR, "GOT:      %s", got);
     result = 1;
diff --git a/test/core/client_channel/BUILD b/test/core/client_channel/BUILD
index c4a93238f2..ec72e0ea72 100644
--- a/test/core/client_channel/BUILD
+++ b/test/core/client_channel/BUILD
@@ -22,8 +22,8 @@ load("//test/core/util:grpc_fuzzer.bzl", "grpc_fuzzer")
 
 grpc_fuzzer(
     name = "uri_fuzzer_test",
-    srcs = ["uri_fuzzer_test.c"],
-    language = "C",
+    srcs = ["uri_fuzzer_test.cc"],
+    language = "C++",
     corpus = "uri_corpus",
     deps = [
         "//:gpr",
@@ -34,8 +34,8 @@ grpc_fuzzer(
 
 grpc_cc_test(
     name = "lb_policies_test",
-    srcs = ["lb_policies_test.c"],
-    language = "C",
+    srcs = ["lb_policies_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
diff --git a/test/core/client_channel/lb_policies_test.c b/test/core/client_channel/lb_policies_test.cc
index ba37cd673f..5f8d3b84cc 100644
--- a/test/core/client_channel/lb_policies_test.c
+++ b/test/core/client_channel/lb_policies_test.cc
@@ -41,39 +41,39 @@
 
 typedef struct servers_fixture {
   size_t num_servers;
-  grpc_server **servers;
-  grpc_call **server_calls;
-  grpc_completion_queue *cq;
-  grpc_completion_queue *shutdown_cq;
-  char **servers_hostports;
-  grpc_metadata_array *request_metadata_recv;
+  grpc_server** servers;
+  grpc_call** server_calls;
+  grpc_completion_queue* cq;
+  grpc_completion_queue* shutdown_cq;
+  char** servers_hostports;
+  grpc_metadata_array* request_metadata_recv;
 } servers_fixture;
 
 typedef struct request_sequences {
   size_t n;         /* number of iterations */
-  int *connections; /* indexed by the interation number, value is the index of
+  int* connections; /* indexed by the interation number, value is the index of
                        the server it connected to or -1 if none */
-  int *connectivity_states; /* indexed by the interation number, value is the
-                               client connectivity state */
+  /* indexed by the interation number, value is the client connectivity state */
+  grpc_connectivity_state* connectivity_states;
 } request_sequences;
 
-typedef void (*verifier_fn)(const servers_fixture *, grpc_channel *,
-                            const request_sequences *, const size_t);
+typedef void (*verifier_fn)(const servers_fixture*, grpc_channel*,
+                            const request_sequences*, const size_t);
 
 typedef struct test_spec {
   size_t num_iters;
   size_t num_servers;
 
-  int **kill_at;
-  int **revive_at;
+  int** kill_at;
+  int** revive_at;
 
-  const char *description;
+  const char* description;
 
   verifier_fn verifier;
 
 } test_spec;
 
-static void test_spec_reset(test_spec *spec) {
+static void test_spec_reset(test_spec* spec) {
   size_t i, j;
 
   for (i = 0; i < spec->num_iters; i++) {
@@ -84,25 +84,26 @@ static void test_spec_reset(test_spec *spec) {
   }
 }
 
-static test_spec *test_spec_create(size_t num_iters, size_t num_servers) {
-  test_spec *spec;
+static test_spec* test_spec_create(size_t num_iters, size_t num_servers) {
+  test_spec* spec;
   size_t i;
 
-  spec = gpr_malloc(sizeof(test_spec));
+  spec = static_cast<test_spec*>(gpr_malloc(sizeof(test_spec)));
   spec->num_iters = num_iters;
   spec->num_servers = num_servers;
-  spec->kill_at = gpr_malloc(sizeof(int *) * num_iters);
-  spec->revive_at = gpr_malloc(sizeof(int *) * num_iters);
+  spec->kill_at = static_cast<int**>(gpr_malloc(sizeof(int*) * num_iters));
+  spec->revive_at = static_cast<int**>(gpr_malloc(sizeof(int*) * num_iters));
   for (i = 0; i < num_iters; i++) {
-    spec->kill_at[i] = gpr_malloc(sizeof(int) * num_servers);
-    spec->revive_at[i] = gpr_malloc(sizeof(int) * num_servers);
+    spec->kill_at[i] = static_cast<int*>(gpr_malloc(sizeof(int) * num_servers));
+    spec->revive_at[i] =
+        static_cast<int*>(gpr_malloc(sizeof(int) * num_servers));
   }
 
   test_spec_reset(spec);
   return spec;
 }
 
-static void test_spec_destroy(test_spec *spec) {
+static void test_spec_destroy(test_spec* spec) {
   size_t i;
   for (i = 0; i < spec->num_iters; i++) {
     gpr_free(spec->kill_at[i]);
@@ -115,29 +116,29 @@ static void test_spec_destroy(test_spec *spec) {
   gpr_free(spec);
 }
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static gpr_timespec n_millis_time(int n) {
   return gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
                       gpr_time_from_millis(n, GPR_TIMESPAN));
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, n_millis_time(5000), NULL);
+    ev = grpc_completion_queue_next(cq, n_millis_time(5000), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void kill_server(const servers_fixture *f, size_t i) {
+static void kill_server(const servers_fixture* f, size_t i) {
   gpr_log(GPR_INFO, "KILLING SERVER %" PRIuPTR, i);
-  GPR_ASSERT(f->servers[i] != NULL);
+  GPR_ASSERT(f->servers[i] != nullptr);
   grpc_server_shutdown_and_notify(f->servers[i], f->shutdown_cq, tag(10000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(10000),
-                                         n_millis_time(5000), NULL)
+                                         n_millis_time(5000), nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->servers[i]);
-  f->servers[i] = NULL;
+  f->servers[i] = nullptr;
 }
 
 typedef struct request_data {
@@ -145,19 +146,19 @@ typedef struct request_data {
   grpc_metadata_array trailing_metadata_recv;
   grpc_slice details;
   grpc_status_code status;
-  grpc_call_details *call_details;
+  grpc_call_details* call_details;
 } request_data;
 
-static void revive_server(const servers_fixture *f, request_data *rdata,
+static void revive_server(const servers_fixture* f, request_data* rdata,
                           size_t i) {
   int got_port;
   gpr_log(GPR_INFO, "RAISE AGAIN SERVER %" PRIuPTR, i);
-  GPR_ASSERT(f->servers[i] == NULL);
+  GPR_ASSERT(f->servers[i] == nullptr);
 
   gpr_log(GPR_DEBUG, "revive: %s", f->servers_hostports[i]);
 
-  f->servers[i] = grpc_server_create(NULL, NULL);
-  grpc_server_register_completion_queue(f->servers[i], f->cq, NULL);
+  f->servers[i] = grpc_server_create(nullptr, nullptr);
+  grpc_server_register_completion_queue(f->servers[i], f->cq, nullptr);
   GPR_ASSERT((got_port = grpc_server_add_insecure_http2_port(
                   f->servers[i], f->servers_hostports[i])) > 0);
   grpc_server_start(f->servers[i]);
@@ -169,39 +170,43 @@ static void revive_server(const servers_fixture *f, request_data *rdata,
                                       f->cq, tag(1000 + (int)i)));
 }
 
-static servers_fixture *setup_servers(const char *server_host,
-                                      request_data *rdata,
+static servers_fixture* setup_servers(const char* server_host,
+                                      request_data* rdata,
                                       const size_t num_servers) {
-  servers_fixture *f = gpr_malloc(sizeof(servers_fixture));
+  servers_fixture* f =
+      static_cast<servers_fixture*>(gpr_malloc(sizeof(servers_fixture)));
   size_t i;
 
   f->num_servers = num_servers;
-  f->server_calls = gpr_malloc(sizeof(grpc_call *) * num_servers);
-  f->request_metadata_recv =
-      gpr_malloc(sizeof(grpc_metadata_array) * num_servers);
+  f->server_calls =
+      static_cast<grpc_call**>(gpr_malloc(sizeof(grpc_call*) * num_servers));
+  f->request_metadata_recv = static_cast<grpc_metadata_array*>(
+      gpr_malloc(sizeof(grpc_metadata_array) * num_servers));
   /* Create servers. */
-  f->servers = gpr_malloc(sizeof(grpc_server *) * num_servers);
-  f->servers_hostports = gpr_malloc(sizeof(char *) * num_servers);
-  f->cq = grpc_completion_queue_create_for_next(NULL);
-  f->shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
+  f->servers = static_cast<grpc_server**>(
+      gpr_malloc(sizeof(grpc_server*) * num_servers));
+  f->servers_hostports =
+      static_cast<char**>(gpr_malloc(sizeof(char*) * num_servers));
+  f->cq = grpc_completion_queue_create_for_next(nullptr);
+  f->shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
   for (i = 0; i < num_servers; i++) {
     grpc_metadata_array_init(&f->request_metadata_recv[i]);
     gpr_join_host_port(&f->servers_hostports[i], server_host,
                        grpc_pick_unused_port_or_die());
-    f->servers[i] = 0;
+    f->servers[i] = nullptr;
     revive_server(f, rdata, i);
   }
   return f;
 }
 
-static void teardown_servers(servers_fixture *f) {
+static void teardown_servers(servers_fixture* f) {
   size_t i;
   /* Destroy server. */
   for (i = 0; i < f->num_servers; i++) {
-    if (f->servers[i] == NULL) continue;
+    if (f->servers[i] == nullptr) continue;
     grpc_server_shutdown_and_notify(f->servers[i], f->shutdown_cq, tag(10000));
     GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(10000),
-                                           n_millis_time(5000), NULL)
+                                           n_millis_time(5000), nullptr)
                    .type == GRPC_OP_COMPLETE);
     grpc_server_destroy(f->servers[i]);
   }
@@ -226,28 +231,29 @@ static void teardown_servers(servers_fixture *f) {
 static request_sequences request_sequences_create(size_t n) {
   request_sequences res;
   res.n = n;
-  res.connections = gpr_malloc(sizeof(*res.connections) * n);
-  res.connectivity_states = gpr_malloc(sizeof(*res.connectivity_states) * n);
+  res.connections = static_cast<int*>(gpr_malloc(sizeof(*res.connections) * n));
+  res.connectivity_states = static_cast<grpc_connectivity_state*>(
+      gpr_malloc(sizeof(*res.connectivity_states) * n));
   memset(res.connections, 0, sizeof(*res.connections) * n);
   memset(res.connectivity_states, 0, sizeof(*res.connectivity_states) * n);
   return res;
 }
 
-static void request_sequences_destroy(const request_sequences *rseqs) {
+static void request_sequences_destroy(const request_sequences* rseqs) {
   gpr_free(rseqs->connections);
   gpr_free(rseqs->connectivity_states);
 }
 
 /** Returns connection sequence (server indices), which must be freed */
-static request_sequences perform_request(servers_fixture *f,
-                                         grpc_channel *client,
-                                         request_data *rdata,
-                                         const test_spec *spec) {
-  grpc_call *c;
+static request_sequences perform_request(servers_fixture* f,
+                                         grpc_channel* client,
+                                         request_data* rdata,
+                                         const test_spec* spec) {
+  grpc_call* c;
   int s_idx;
-  int *s_valid;
+  int* s_valid;
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   int was_cancelled;
   size_t i, iter_num;
   grpc_event ev;
@@ -255,10 +261,10 @@ static request_sequences perform_request(servers_fixture *f,
   int completed_client;
   const request_sequences sequences = request_sequences_create(spec->num_iters);
 
-  s_valid = gpr_malloc(sizeof(int) * f->num_servers);
+  s_valid = static_cast<int*>(gpr_malloc(sizeof(int) * f->num_servers));
 
   for (iter_num = 0; iter_num < spec->num_iters; iter_num++) {
-    cq_verifier *cqv = cq_verifier_create(f->cq);
+    cq_verifier* cqv = cq_verifier_create(f->cq);
     was_cancelled = 2;
 
     for (i = 0; i < f->num_servers; i++) {
@@ -280,9 +286,10 @@ static request_sequences perform_request(servers_fixture *f,
     memset(s_valid, 0, f->num_servers * sizeof(int));
 
     grpc_slice host = grpc_slice_from_static_string("foo.test.google.fr");
-    c = grpc_channel_create_call(client, NULL, GRPC_PROPAGATE_DEFAULTS, f->cq,
-                                 grpc_slice_from_static_string("/foo"), &host,
-                                 gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+    c = grpc_channel_create_call(client, nullptr, GRPC_PROPAGATE_DEFAULTS,
+                                 f->cq, grpc_slice_from_static_string("/foo"),
+                                 &host, gpr_inf_future(GPR_CLOCK_REALTIME),
+                                 nullptr);
     GPR_ASSERT(c);
     completed_client = 0;
 
@@ -291,17 +298,17 @@ static request_sequences perform_request(servers_fixture *f,
     op->op = GRPC_OP_SEND_INITIAL_METADATA;
     op->data.send_initial_metadata.count = 0;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
     op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
     op->op = GRPC_OP_RECV_INITIAL_METADATA;
     op->data.recv_initial_metadata.recv_initial_metadata =
         &rdata->initial_metadata_recv;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
     op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
     op->data.recv_status_on_client.trailing_metadata =
@@ -309,16 +316,16 @@ static request_sequences perform_request(servers_fixture *f,
     op->data.recv_status_on_client.status = &rdata->status;
     op->data.recv_status_on_client.status_details = &rdata->details;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
-    GPR_ASSERT(GRPC_CALL_OK ==
-               grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL));
+    GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(c, ops, (size_t)(op - ops),
+                                                     tag(1), nullptr));
 
     s_idx = -1;
-    while (
-        (ev = grpc_completion_queue_next(
-             f->cq, grpc_timeout_milliseconds_to_deadline(RETRY_TIMEOUT), NULL))
-            .type != GRPC_QUEUE_TIMEOUT) {
+    while ((ev = grpc_completion_queue_next(
+                f->cq, grpc_timeout_milliseconds_to_deadline(RETRY_TIMEOUT),
+                nullptr))
+               .type != GRPC_QUEUE_TIMEOUT) {
       GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
       read_tag = ((int)(intptr_t)ev.tag);
       const grpc_connectivity_state conn_state =
@@ -346,7 +353,7 @@ static request_sequences perform_request(servers_fixture *f,
       op->op = GRPC_OP_SEND_INITIAL_METADATA;
       op->data.send_initial_metadata.count = 0;
       op->flags = 0;
-      op->reserved = NULL;
+      op->reserved = nullptr;
       op++;
       op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
       op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -354,16 +361,16 @@ static request_sequences perform_request(servers_fixture *f,
       grpc_slice status_details = grpc_slice_from_static_string("xyz");
       op->data.send_status_from_server.status_details = &status_details;
       op->flags = 0;
-      op->reserved = NULL;
+      op->reserved = nullptr;
       op++;
       op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
       op->data.recv_close_on_server.cancelled = &was_cancelled;
       op->flags = 0;
-      op->reserved = NULL;
+      op->reserved = nullptr;
       op++;
       GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(f->server_calls[s_idx],
                                                        ops, (size_t)(op - ops),
-                                                       tag(102), NULL));
+                                                       tag(102), nullptr));
 
       CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
       if (!completed_client) {
@@ -388,17 +395,17 @@ static request_sequences perform_request(servers_fixture *f,
                                      &f->request_metadata_recv[s_idx], f->cq,
                                      f->cq, tag(1000 + (int)s_idx)));
     } else { /* no response from server */
-      grpc_call_cancel(c, NULL);
+      grpc_call_cancel(c, nullptr);
       if (!completed_client) {
         CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
         cq_verify(cqv);
       }
     }
 
-    GPR_ASSERT(
-        grpc_completion_queue_next(
-            f->cq, grpc_timeout_milliseconds_to_deadline(RETRY_TIMEOUT), NULL)
-            .type == GRPC_QUEUE_TIMEOUT);
+    GPR_ASSERT(grpc_completion_queue_next(
+                   f->cq, grpc_timeout_milliseconds_to_deadline(RETRY_TIMEOUT),
+                   nullptr)
+                   .type == GRPC_QUEUE_TIMEOUT);
 
     grpc_metadata_array_destroy(&rdata->initial_metadata_recv);
     grpc_metadata_array_destroy(&rdata->trailing_metadata_recv);
@@ -418,15 +425,16 @@ static request_sequences perform_request(servers_fixture *f,
   return sequences;
 }
 
-static grpc_call **perform_multirequest(servers_fixture *f,
-                                        grpc_channel *client,
+static grpc_call** perform_multirequest(servers_fixture* f,
+                                        grpc_channel* client,
                                         size_t concurrent_calls) {
-  grpc_call **calls;
+  grpc_call** calls;
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   size_t i;
 
-  calls = gpr_malloc(sizeof(grpc_call *) * concurrent_calls);
+  calls = static_cast<grpc_call**>(
+      gpr_malloc(sizeof(grpc_call*) * concurrent_calls));
   for (i = 0; i < f->num_servers; i++) {
     kill_server(f, i);
   }
@@ -436,54 +444,55 @@ static grpc_call **perform_multirequest(servers_fixture *f,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
 
   grpc_slice host = grpc_slice_from_static_string("foo.test.google.fr");
   for (i = 0; i < concurrent_calls; i++) {
-    calls[i] =
-        grpc_channel_create_call(client, NULL, GRPC_PROPAGATE_DEFAULTS, f->cq,
-                                 grpc_slice_from_static_string("/foo"), &host,
-                                 gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+    calls[i] = grpc_channel_create_call(
+        client, nullptr, GRPC_PROPAGATE_DEFAULTS, f->cq,
+        grpc_slice_from_static_string("/foo"), &host,
+        gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
     GPR_ASSERT(calls[i]);
     GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(calls[i], ops,
                                                      (size_t)(op - ops), tag(1),
-                                                     NULL));
+                                                     nullptr));
   }
 
   return calls;
 }
 
-void run_spec(const test_spec *spec) {
-  grpc_channel *client;
-  char *client_hostport;
-  char *servers_hostports_str;
+void run_spec(const test_spec* spec) {
+  grpc_channel* client;
+  char* client_hostport;
+  char* servers_hostports_str;
   request_data rdata;
-  servers_fixture *f;
+  servers_fixture* f;
   grpc_channel_args args;
   grpc_arg arg_array[2];
-  rdata.call_details =
-      gpr_malloc(sizeof(grpc_call_details) * spec->num_servers);
+  rdata.call_details = static_cast<grpc_call_details*>(
+      gpr_malloc(sizeof(grpc_call_details) * spec->num_servers));
   f = setup_servers("127.0.0.1", &rdata, spec->num_servers);
 
   /* Create client. */
-  servers_hostports_str = gpr_strjoin_sep((const char **)f->servers_hostports,
-                                          f->num_servers, ",", NULL);
+  servers_hostports_str = gpr_strjoin_sep((const char**)f->servers_hostports,
+                                          f->num_servers, ",", nullptr);
   gpr_asprintf(&client_hostport, "ipv4:%s", servers_hostports_str);
 
   arg_array[0].type = GRPC_ARG_INTEGER;
-  arg_array[0].key = "grpc.testing.fixed_reconnect_backoff_ms";
+  arg_array[0].key =
+      const_cast<char*>("grpc.testing.fixed_reconnect_backoff_ms");
   arg_array[0].value.integer = RETRY_TIMEOUT;
   arg_array[1].type = GRPC_ARG_STRING;
-  arg_array[1].key = GRPC_ARG_LB_POLICY_NAME;
-  arg_array[1].value.string = "round_robin";
+  arg_array[1].key = const_cast<char*>(GRPC_ARG_LB_POLICY_NAME);
+  arg_array[1].value.string = const_cast<char*>("round_robin");
   args.num_args = 2;
   args.args = arg_array;
 
-  client = grpc_insecure_channel_create(client_hostport, &args, NULL);
+  client = grpc_insecure_channel_create(client_hostport, &args, nullptr);
 
   gpr_log(GPR_INFO, "Testing '%s' with servers=%s client=%s", spec->description,
           servers_hostports_str, client_hostport);
@@ -501,30 +510,32 @@ void run_spec(const test_spec *spec) {
   teardown_servers(f);
 }
 
-static grpc_channel *create_client(const servers_fixture *f) {
-  grpc_channel *client;
-  char *client_hostport;
-  char *servers_hostports_str;
+static grpc_channel* create_client(const servers_fixture* f) {
+  grpc_channel* client;
+  char* client_hostport;
+  char* servers_hostports_str;
   grpc_arg arg_array[3];
   grpc_channel_args args;
 
-  servers_hostports_str = gpr_strjoin_sep((const char **)f->servers_hostports,
-                                          f->num_servers, ",", NULL);
+  servers_hostports_str = gpr_strjoin_sep((const char**)f->servers_hostports,
+                                          f->num_servers, ",", nullptr);
   gpr_asprintf(&client_hostport, "ipv4:%s", servers_hostports_str);
 
   arg_array[0].type = GRPC_ARG_INTEGER;
-  arg_array[0].key = "grpc.testing.fixed_reconnect_backoff_ms";
+  arg_array[0].key =
+      const_cast<char*>("grpc.testing.fixed_reconnect_backoff_ms");
   arg_array[0].value.integer = RETRY_TIMEOUT;
   arg_array[1].type = GRPC_ARG_STRING;
-  arg_array[1].key = GRPC_ARG_LB_POLICY_NAME;
-  arg_array[1].value.string = "ROUND_ROBIN";
+  arg_array[1].key = const_cast<char*>(GRPC_ARG_LB_POLICY_NAME);
+  arg_array[1].value.string = const_cast<char*>("ROUND_ROBIN");
   arg_array[2].type = GRPC_ARG_INTEGER;
-  arg_array[2].key = GRPC_ARG_HTTP2_MIN_SENT_PING_INTERVAL_WITHOUT_DATA_MS;
+  arg_array[2].key =
+      const_cast<char*>(GRPC_ARG_HTTP2_MIN_SENT_PING_INTERVAL_WITHOUT_DATA_MS);
   arg_array[2].value.integer = 0;
   args.num_args = GPR_ARRAY_SIZE(arg_array);
   args.args = arg_array;
 
-  client = grpc_insecure_channel_create(client_hostport, &args, NULL);
+  client = grpc_insecure_channel_create(client_hostport, &args, nullptr);
   gpr_free(client_hostport);
   gpr_free(servers_hostports_str);
 
@@ -532,21 +543,22 @@ static grpc_channel *create_client(const servers_fixture *f) {
 }
 
 static void test_ping() {
-  grpc_channel *client;
+  grpc_channel* client;
   request_data rdata;
-  servers_fixture *f;
-  cq_verifier *cqv;
+  servers_fixture* f;
+  cq_verifier* cqv;
   grpc_connectivity_state state = GRPC_CHANNEL_IDLE;
   const size_t num_servers = 1;
   int i;
 
-  rdata.call_details = gpr_malloc(sizeof(grpc_call_details) * num_servers);
+  rdata.call_details = static_cast<grpc_call_details*>(
+      gpr_malloc(sizeof(grpc_call_details) * num_servers));
   f = setup_servers("127.0.0.1", &rdata, num_servers);
   cqv = cq_verifier_create(f->cq);
 
   client = create_client(f);
 
-  grpc_channel_ping(client, f->cq, tag(0), NULL);
+  grpc_channel_ping(client, f->cq, tag(0), nullptr);
   CQ_EXPECT_COMPLETION(cqv, tag(0), 0);
 
   /* check that we're still in idle, and start connecting */
@@ -566,7 +578,7 @@ static void test_ping() {
   }
 
   for (i = 1; i <= 5; i++) {
-    grpc_channel_ping(client, f->cq, tag(i), NULL);
+    grpc_channel_ping(client, f->cq, tag(i), nullptr);
     CQ_EXPECT_COMPLETION(cqv, tag(i), 1);
     cq_verify(cqv);
   }
@@ -580,20 +592,19 @@ static void test_ping() {
 
 static void test_pending_calls(size_t concurrent_calls) {
   size_t i;
-  grpc_call **calls;
-  grpc_channel *client;
+  grpc_call** calls;
+  grpc_channel* client;
   request_data rdata;
-  servers_fixture *f;
-  test_spec *spec = test_spec_create(0, 4);
-  rdata.call_details =
-      gpr_malloc(sizeof(grpc_call_details) * spec->num_servers);
+  servers_fixture* f;
+  test_spec* spec = test_spec_create(0, 4);
+  rdata.call_details = static_cast<grpc_call_details*>(
+      gpr_malloc(sizeof(grpc_call_details) * spec->num_servers));
   f = setup_servers("127.0.0.1", &rdata, spec->num_servers);
 
   client = create_client(f);
   calls = perform_multirequest(f, client, concurrent_calls);
-  grpc_call_cancel(
-      calls[0],
-      NULL); /* exercise the cancel pick path whilst there are pending picks */
+  grpc_call_cancel(calls[0], nullptr); /* exercise the cancel pick path whilst
+                                          there are pending picks */
 
   gpr_free(rdata.call_details);
 
@@ -609,8 +620,8 @@ static void test_pending_calls(size_t concurrent_calls) {
 }
 
 static void test_get_channel_info() {
-  grpc_channel *channel =
-      grpc_insecure_channel_create("ipv4:127.0.0.1:1234", NULL, NULL);
+  grpc_channel* channel =
+      grpc_insecure_channel_create("ipv4:127.0.0.1:1234", nullptr, nullptr);
   // Ensures that resolver returns.
   grpc_channel_check_connectivity_state(channel, true /* try_to_connect */);
   // First, request no fields.  This is a no-op.
@@ -618,26 +629,27 @@ static void test_get_channel_info() {
   memset(&channel_info, 0, sizeof(channel_info));
   grpc_channel_get_info(channel, &channel_info);
   // Request LB policy name.
-  char *lb_policy_name = NULL;
+  char* lb_policy_name = nullptr;
   channel_info.lb_policy_name = &lb_policy_name;
   grpc_channel_get_info(channel, &channel_info);
-  GPR_ASSERT(lb_policy_name != NULL);
+  GPR_ASSERT(lb_policy_name != nullptr);
   GPR_ASSERT(strcmp(lb_policy_name, "pick_first") == 0);
   gpr_free(lb_policy_name);
   // Request service config, which does not exist, so we'll get nothing back.
   memset(&channel_info, 0, sizeof(channel_info));
-  char *service_config_json = "dummy_string";
+  char* service_config_json = const_cast<char*>("dummy_string");
   channel_info.service_config_json = &service_config_json;
   grpc_channel_get_info(channel, &channel_info);
-  GPR_ASSERT(service_config_json == NULL);
+  GPR_ASSERT(service_config_json == nullptr);
   // Recreate the channel such that it has a service config.
   grpc_channel_destroy(channel);
   grpc_arg arg;
   arg.type = GRPC_ARG_STRING;
-  arg.key = GRPC_ARG_SERVICE_CONFIG;
-  arg.value.string = "{\"loadBalancingPolicy\": \"ROUND_ROBIN\"}";
-  grpc_channel_args *args = grpc_channel_args_copy_and_add(NULL, &arg, 1);
-  channel = grpc_insecure_channel_create("ipv4:127.0.0.1:1234", args, NULL);
+  arg.key = const_cast<char*>(GRPC_ARG_SERVICE_CONFIG);
+  arg.value.string =
+      const_cast<char*>("{\"loadBalancingPolicy\": \"ROUND_ROBIN\"}");
+  grpc_channel_args* args = grpc_channel_args_copy_and_add(nullptr, &arg, 1);
+  channel = grpc_insecure_channel_create("ipv4:127.0.0.1:1234", args, nullptr);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_channel_args_destroy(&exec_ctx, args);
@@ -647,15 +659,15 @@ static void test_get_channel_info() {
   grpc_channel_check_connectivity_state(channel, true /* try_to_connect */);
   // Now request the service config again.
   grpc_channel_get_info(channel, &channel_info);
-  GPR_ASSERT(service_config_json != NULL);
+  GPR_ASSERT(service_config_json != nullptr);
   GPR_ASSERT(strcmp(service_config_json, arg.value.string) == 0);
   gpr_free(service_config_json);
   // Clean up.
   grpc_channel_destroy(channel);
 }
 
-static void print_failed_expectations(const int *expected_connection_sequence,
-                                      const int *actual_connection_sequence,
+static void print_failed_expectations(const int* expected_connection_sequence,
+                                      const int* actual_connection_sequence,
                                       const size_t expected_seq_length,
                                       const size_t num_iters) {
   size_t i;
@@ -667,16 +679,16 @@ static void print_failed_expectations(const int *expected_connection_sequence,
   }
 }
 
-static void verify_vanilla_round_robin(const servers_fixture *f,
-                                       grpc_channel *client,
-                                       const request_sequences *sequences,
+static void verify_vanilla_round_robin(const servers_fixture* f,
+                                       grpc_channel* client,
+                                       const request_sequences* sequences,
                                        const size_t num_iters) {
   const size_t expected_seq_length = f->num_servers;
 
   /* verify conn. seq. expectation */
   /* get the first sequence of "num_servers" elements */
-  int *expected_connection_sequence =
-      gpr_malloc(sizeof(int) * expected_seq_length);
+  int* expected_connection_sequence =
+      static_cast<int*>(gpr_malloc(sizeof(int) * expected_seq_length));
   memcpy(expected_connection_sequence, sequences->connections,
          sizeof(int) * expected_seq_length);
 
@@ -695,7 +707,8 @@ static void verify_vanilla_round_robin(const servers_fixture *f,
   /* All servers are available, therefore all client subchannels are READY, even
    * when we only need one for the client channel state to be READY */
   for (size_t i = 0; i < sequences->n; i++) {
-    const grpc_connectivity_state actual = sequences->connectivity_states[i];
+    const grpc_connectivity_state actual =
+        static_cast<grpc_connectivity_state>(sequences->connectivity_states[i]);
     const grpc_connectivity_state expected = GRPC_CHANNEL_READY;
     if (actual != expected) {
       gpr_log(GPR_ERROR,
@@ -713,15 +726,16 @@ static void verify_vanilla_round_robin(const servers_fixture *f,
 /* At the start of the second iteration, all but the first and last servers (as
  * given in "f") are killed */
 static void verify_vanishing_floor_round_robin(
-    const servers_fixture *f, grpc_channel *client,
-    const request_sequences *sequences, const size_t num_iters) {
-  int *expected_connection_sequence;
+    const servers_fixture* f, grpc_channel* client,
+    const request_sequences* sequences, const size_t num_iters) {
+  int* expected_connection_sequence;
   const size_t expected_seq_length = 2;
   size_t i;
 
   /* verify conn. seq. expectation */
   /* copy the first full sequence (without -1s) */
-  expected_connection_sequence = gpr_malloc(sizeof(int) * expected_seq_length);
+  expected_connection_sequence =
+      static_cast<int*>(gpr_malloc(sizeof(int) * expected_seq_length));
   memcpy(expected_connection_sequence, sequences->connections + 2,
          expected_seq_length * sizeof(int));
 
@@ -750,7 +764,8 @@ static void verify_vanishing_floor_round_robin(
   /* There's always at least one subchannel READY (connected), therefore the
    * overall state of the client channel is READY at all times. */
   for (i = 0; i < sequences->n; i++) {
-    const grpc_connectivity_state actual = sequences->connectivity_states[i];
+    const grpc_connectivity_state actual =
+        static_cast<grpc_connectivity_state>(sequences->connectivity_states[i]);
     const grpc_connectivity_state expected = GRPC_CHANNEL_READY;
     if (actual != expected) {
       gpr_log(GPR_ERROR,
@@ -765,9 +780,9 @@ static void verify_vanishing_floor_round_robin(
   gpr_free(expected_connection_sequence);
 }
 
-static void verify_total_carnage_round_robin(const servers_fixture *f,
-                                             grpc_channel *client,
-                                             const request_sequences *sequences,
+static void verify_total_carnage_round_robin(const servers_fixture* f,
+                                             grpc_channel* client,
+                                             const request_sequences* sequences,
                                              const size_t num_iters) {
   for (size_t i = 0; i < num_iters; i++) {
     const int actual = sequences->connections[i];
@@ -785,7 +800,8 @@ static void verify_total_carnage_round_robin(const servers_fixture *f,
    * Note that all other states (IDLE, CONNECTING, TRANSIENT_FAILURE) are still
    * possible, as the policy transitions while attempting to reconnect. */
   for (size_t i = 0; i < sequences->n; i++) {
-    const grpc_connectivity_state actual = sequences->connectivity_states[i];
+    const grpc_connectivity_state actual =
+        static_cast<grpc_connectivity_state>(sequences->connectivity_states[i]);
     if (actual == GRPC_CHANNEL_READY || actual == GRPC_CHANNEL_SHUTDOWN) {
       gpr_log(GPR_ERROR,
               "CONNECTIVITY STATUS SEQUENCE FAILURE: got unexpected state "
@@ -797,15 +813,16 @@ static void verify_total_carnage_round_robin(const servers_fixture *f,
 }
 
 static void verify_partial_carnage_round_robin(
-    const servers_fixture *f, grpc_channel *client,
-    const request_sequences *sequences, const size_t num_iters) {
-  int *expected_connection_sequence;
+    const servers_fixture* f, grpc_channel* client,
+    const request_sequences* sequences, const size_t num_iters) {
+  int* expected_connection_sequence;
   size_t i;
   const size_t expected_seq_length = f->num_servers;
 
   /* verify conn. seq. expectation */
   /* get the first sequence of "num_servers" elements */
-  expected_connection_sequence = gpr_malloc(sizeof(int) * expected_seq_length);
+  expected_connection_sequence =
+      static_cast<int*>(gpr_malloc(sizeof(int) * expected_seq_length));
   memcpy(expected_connection_sequence, sequences->connections,
          sizeof(int) * expected_seq_length);
 
@@ -827,7 +844,8 @@ static void verify_partial_carnage_round_robin(
 
   /* We can assert that the first client channel state should be READY, when all
    * servers were available */
-  grpc_connectivity_state actual = sequences->connectivity_states[0];
+  grpc_connectivity_state actual =
+      static_cast<grpc_connectivity_state>(sequences->connectivity_states[0]);
   grpc_connectivity_state expected = GRPC_CHANNEL_READY;
   if (actual != expected) {
     gpr_log(GPR_ERROR,
@@ -841,7 +859,8 @@ static void verify_partial_carnage_round_robin(
   /* ... and that the last one shouldn't be READY (or SHUTDOWN): all servers are
    * gone. It may be all other states (IDLE, CONNECTING, TRANSIENT_FAILURE), as
    * the policy transitions while attempting to reconnect. */
-  actual = sequences->connectivity_states[num_iters - 1];
+  actual = static_cast<grpc_connectivity_state>(
+      sequences->connectivity_states[num_iters - 1]);
   for (i = 0; i < sequences->n; i++) {
     if (actual == GRPC_CHANNEL_READY || actual == GRPC_CHANNEL_SHUTDOWN) {
       gpr_log(GPR_ERROR,
@@ -854,9 +873,9 @@ static void verify_partial_carnage_round_robin(
   gpr_free(expected_connection_sequence);
 }
 
-static void dump_array(const char *desc, const int *data, const size_t count) {
+static void dump_array(const char* desc, const int* data, const size_t count) {
   gpr_strvec s;
-  char *tmp;
+  char* tmp;
   size_t i;
   gpr_strvec_init(&s);
   gpr_strvec_add(&s, gpr_strdup(desc));
@@ -865,15 +884,15 @@ static void dump_array(const char *desc, const int *data, const size_t count) {
     gpr_asprintf(&tmp, " %d", data[i]);
     gpr_strvec_add(&s, tmp);
   }
-  tmp = gpr_strvec_flatten(&s, NULL);
+  tmp = gpr_strvec_flatten(&s, nullptr);
   gpr_strvec_destroy(&s);
   gpr_log(GPR_DEBUG, "%s", tmp);
   gpr_free(tmp);
 }
 
-static void verify_rebirth_round_robin(const servers_fixture *f,
-                                       grpc_channel *client,
-                                       const request_sequences *sequences,
+static void verify_rebirth_round_robin(const servers_fixture* f,
+                                       grpc_channel* client,
+                                       const request_sequences* sequences,
                                        const size_t num_iters) {
   dump_array("actual_connection_sequence", sequences->connections, num_iters);
 
@@ -894,7 +913,8 @@ static void verify_rebirth_round_robin(const servers_fixture *f,
   /* We can assert that the first client channel state should be READY, when all
    * servers were available; same thing for the last one. In the middle
    * somewhere there must exist at least one TRANSIENT_FAILURE */
-  grpc_connectivity_state actual = sequences->connectivity_states[0];
+  grpc_connectivity_state actual =
+      static_cast<grpc_connectivity_state>(sequences->connectivity_states[0]);
   grpc_connectivity_state expected = GRPC_CHANNEL_READY;
   if (actual != expected) {
     gpr_log(GPR_ERROR,
@@ -905,7 +925,8 @@ static void verify_rebirth_round_robin(const servers_fixture *f,
     abort();
   }
 
-  actual = sequences->connectivity_states[num_iters - 1];
+  actual = static_cast<grpc_connectivity_state>(
+      sequences->connectivity_states[num_iters - 1]);
   expected = GRPC_CHANNEL_READY;
   if (actual != expected) {
     gpr_log(GPR_ERROR,
@@ -931,14 +952,15 @@ static void verify_rebirth_round_robin(const servers_fixture *f,
         "instead:");
     for (size_t i = 0; i < num_iters; i++) {
       gpr_log(GPR_ERROR, "[%d]: %s", (int)i,
-              grpc_connectivity_state_name(sequences->connectivity_states[i]));
+              grpc_connectivity_state_name(static_cast<grpc_connectivity_state>(
+                  sequences->connectivity_states[i])));
     }
   }
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  test_spec *spec;
+  test_spec* spec;
   size_t i;
   const size_t NUM_ITERS = 10;
   const size_t NUM_SERVERS = 4;
@@ -948,8 +970,8 @@ int main(int argc, char **argv) {
   grpc_tracer_set_enabled("round_robin", 1);
 
   GPR_ASSERT(grpc_lb_policy_create(&exec_ctx, "this-lb-policy-does-not-exist",
-                                   NULL) == NULL);
-  GPR_ASSERT(grpc_lb_policy_create(&exec_ctx, NULL, NULL) == NULL);
+                                   nullptr) == nullptr);
+  GPR_ASSERT(grpc_lb_policy_create(&exec_ctx, nullptr, nullptr) == nullptr);
 
   spec = test_spec_create(NUM_ITERS, NUM_SERVERS);
   /* everything is fine, all servers stay up the whole time and life's peachy
diff --git a/test/core/client_channel/parse_address_test.c b/test/core/client_channel/parse_address_test.cc
index d011176869..94f76da920 100644
--- a/test/core/client_channel/parse_address_test.c
+++ b/test/core/client_channel/parse_address_test.cc
@@ -32,13 +32,13 @@
 
 #ifdef GRPC_HAVE_UNIX_SOCKET
 
-static void test_grpc_parse_unix(const char *uri_text, const char *pathname) {
+static void test_grpc_parse_unix(const char* uri_text, const char* pathname) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_uri *uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
+  grpc_uri* uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
   grpc_resolved_address addr;
 
   GPR_ASSERT(1 == grpc_parse_unix(uri, &addr));
-  struct sockaddr_un *addr_un = (struct sockaddr_un *)addr.addr;
+  struct sockaddr_un* addr_un = (struct sockaddr_un*)addr.addr;
   GPR_ASSERT(AF_UNIX == addr_un->sun_family);
   GPR_ASSERT(0 == strcmp(addr_un->sun_path, pathname));
 
@@ -48,22 +48,22 @@ static void test_grpc_parse_unix(const char *uri_text, const char *pathname) {
 
 #else /* GRPC_HAVE_UNIX_SOCKET */
 
-static void test_grpc_parse_unix(const char *uri_text, const char *pathname) {}
+static void test_grpc_parse_unix(const char* uri_text, const char* pathname) {}
 
 #endif /* GRPC_HAVE_UNIX_SOCKET */
 
-static void test_grpc_parse_ipv4(const char *uri_text, const char *host,
+static void test_grpc_parse_ipv4(const char* uri_text, const char* host,
                                  unsigned short port) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_uri *uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
+  grpc_uri* uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
   grpc_resolved_address addr;
   char ntop_buf[INET_ADDRSTRLEN];
 
   GPR_ASSERT(1 == grpc_parse_ipv4(uri, &addr));
-  struct sockaddr_in *addr_in = (struct sockaddr_in *)addr.addr;
+  struct sockaddr_in* addr_in = (struct sockaddr_in*)addr.addr;
   GPR_ASSERT(AF_INET == addr_in->sin_family);
-  GPR_ASSERT(NULL != grpc_inet_ntop(AF_INET, &addr_in->sin_addr, ntop_buf,
-                                    sizeof(ntop_buf)));
+  GPR_ASSERT(nullptr != grpc_inet_ntop(AF_INET, &addr_in->sin_addr, ntop_buf,
+                                       sizeof(ntop_buf)));
   GPR_ASSERT(0 == strcmp(ntop_buf, host));
   GPR_ASSERT(ntohs(addr_in->sin_port) == port);
 
@@ -71,18 +71,18 @@ static void test_grpc_parse_ipv4(const char *uri_text, const char *host,
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void test_grpc_parse_ipv6(const char *uri_text, const char *host,
+static void test_grpc_parse_ipv6(const char* uri_text, const char* host,
                                  unsigned short port, uint32_t scope_id) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_uri *uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
+  grpc_uri* uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
   grpc_resolved_address addr;
   char ntop_buf[INET6_ADDRSTRLEN];
 
   GPR_ASSERT(1 == grpc_parse_ipv6(uri, &addr));
-  struct sockaddr_in6 *addr_in6 = (struct sockaddr_in6 *)addr.addr;
+  struct sockaddr_in6* addr_in6 = (struct sockaddr_in6*)addr.addr;
   GPR_ASSERT(AF_INET6 == addr_in6->sin6_family);
-  GPR_ASSERT(NULL != grpc_inet_ntop(AF_INET6, &addr_in6->sin6_addr, ntop_buf,
-                                    sizeof(ntop_buf)));
+  GPR_ASSERT(nullptr != grpc_inet_ntop(AF_INET6, &addr_in6->sin6_addr, ntop_buf,
+                                       sizeof(ntop_buf)));
   GPR_ASSERT(0 == strcmp(ntop_buf, host));
   GPR_ASSERT(ntohs(addr_in6->sin6_port) == port);
   GPR_ASSERT(addr_in6->sin6_scope_id == scope_id);
@@ -91,7 +91,7 @@ static void test_grpc_parse_ipv6(const char *uri_text, const char *host,
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
 
   test_grpc_parse_unix("unix:/path/name", "/path/name");
diff --git a/test/core/client_channel/resolvers/BUILD b/test/core/client_channel/resolvers/BUILD
index 0907e06623..b5269c7ef0 100644
--- a/test/core/client_channel/resolvers/BUILD
+++ b/test/core/client_channel/resolvers/BUILD
@@ -20,8 +20,8 @@ licenses(["notice"])  # Apache v2
 
 grpc_cc_test(
     name = "dns_resolver_connectivity_test",
-    srcs = ["dns_resolver_connectivity_test.c"],
-    language = "C",
+    srcs = ["dns_resolver_connectivity_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -32,8 +32,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "dns_resolver_test",
-    srcs = ["dns_resolver_test.c"],
-    language = "C",
+    srcs = ["dns_resolver_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -44,8 +44,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "sockaddr_resolver_test",
-    srcs = ["sockaddr_resolver_test.c"],
-    language = "C",
+    srcs = ["sockaddr_resolver_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -56,8 +56,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "fake_resolver_test",
-    srcs = ["fake_resolver_test.c"],
-    language = "C",
+    srcs = ["fake_resolver_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
diff --git a/test/core/client_channel/resolvers/dns_resolver_connectivity_test.c b/test/core/client_channel/resolvers/dns_resolver_connectivity_test.cc
index 4597285063..dcf315eba5 100644
--- a/test/core/client_channel/resolvers/dns_resolver_connectivity_test.c
+++ b/test/core/client_channel/resolvers/dns_resolver_connectivity_test.cc
@@ -33,114 +33,117 @@
 
 static gpr_mu g_mu;
 static bool g_fail_resolution = true;
-static grpc_combiner *g_combiner;
+static grpc_combiner* g_combiner;
 
-static void my_resolve_address(grpc_exec_ctx *exec_ctx, const char *addr,
-                               const char *default_port,
-                               grpc_pollset_set *interested_parties,
-                               grpc_closure *on_done,
-                               grpc_resolved_addresses **addrs) {
+static void my_resolve_address(grpc_exec_ctx* exec_ctx, const char* addr,
+                               const char* default_port,
+                               grpc_pollset_set* interested_parties,
+                               grpc_closure* on_done,
+                               grpc_resolved_addresses** addrs) {
   gpr_mu_lock(&g_mu);
   GPR_ASSERT(0 == strcmp("test", addr));
-  grpc_error *error = GRPC_ERROR_NONE;
+  grpc_error* error = GRPC_ERROR_NONE;
   if (g_fail_resolution) {
     g_fail_resolution = false;
     gpr_mu_unlock(&g_mu);
     error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Forced Failure");
   } else {
     gpr_mu_unlock(&g_mu);
-    *addrs = gpr_malloc(sizeof(**addrs));
+    *addrs = static_cast<grpc_resolved_addresses*>(gpr_malloc(sizeof(**addrs)));
     (*addrs)->naddrs = 1;
-    (*addrs)->addrs = gpr_malloc(sizeof(*(*addrs)->addrs));
+    (*addrs)->addrs = static_cast<grpc_resolved_address*>(
+        gpr_malloc(sizeof(*(*addrs)->addrs)));
     (*addrs)->addrs[0].len = 123;
   }
   GRPC_CLOSURE_SCHED(exec_ctx, on_done, error);
 }
 
-static grpc_ares_request *my_dns_lookup_ares(
-    grpc_exec_ctx *exec_ctx, const char *dns_server, const char *addr,
-    const char *default_port, grpc_pollset_set *interested_parties,
-    grpc_closure *on_done, grpc_lb_addresses **lb_addrs, bool check_grpclb,
-    char **service_config_json) {
+static grpc_ares_request* my_dns_lookup_ares(
+    grpc_exec_ctx* exec_ctx, const char* dns_server, const char* addr,
+    const char* default_port, grpc_pollset_set* interested_parties,
+    grpc_closure* on_done, grpc_lb_addresses** lb_addrs, bool check_grpclb,
+    char** service_config_json) {
   gpr_mu_lock(&g_mu);
   GPR_ASSERT(0 == strcmp("test", addr));
-  grpc_error *error = GRPC_ERROR_NONE;
+  grpc_error* error = GRPC_ERROR_NONE;
   if (g_fail_resolution) {
     g_fail_resolution = false;
     gpr_mu_unlock(&g_mu);
     error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Forced Failure");
   } else {
     gpr_mu_unlock(&g_mu);
-    *lb_addrs = grpc_lb_addresses_create(1, NULL);
-    grpc_lb_addresses_set_address(*lb_addrs, 0, NULL, 0, false, NULL, NULL);
+    *lb_addrs = grpc_lb_addresses_create(1, nullptr);
+    grpc_lb_addresses_set_address(*lb_addrs, 0, nullptr, 0, false, nullptr,
+                                  nullptr);
   }
   GRPC_CLOSURE_SCHED(exec_ctx, on_done, error);
-  return NULL;
+  return nullptr;
 }
 
-static grpc_resolver *create_resolver(grpc_exec_ctx *exec_ctx,
-                                      const char *name) {
-  grpc_resolver_factory *factory = grpc_resolver_factory_lookup("dns");
-  grpc_uri *uri = grpc_uri_parse(exec_ctx, name, 0);
+static grpc_resolver* create_resolver(grpc_exec_ctx* exec_ctx,
+                                      const char* name) {
+  grpc_resolver_factory* factory = grpc_resolver_factory_lookup("dns");
+  grpc_uri* uri = grpc_uri_parse(exec_ctx, name, 0);
   GPR_ASSERT(uri);
   grpc_resolver_args args;
   memset(&args, 0, sizeof(args));
   args.uri = uri;
   args.combiner = g_combiner;
-  grpc_resolver *resolver =
+  grpc_resolver* resolver =
       grpc_resolver_factory_create_resolver(exec_ctx, factory, &args);
   grpc_resolver_factory_unref(factory);
   grpc_uri_destroy(uri);
   return resolver;
 }
 
-static void on_done(grpc_exec_ctx *exec_ctx, void *ev, grpc_error *error) {
-  gpr_event_set(ev, (void *)1);
+static void on_done(grpc_exec_ctx* exec_ctx, void* ev, grpc_error* error) {
+  gpr_event_set((gpr_event*)ev, (void*)1);
 }
 
 // interleave waiting for an event with a timer check
-static bool wait_loop(int deadline_seconds, gpr_event *ev) {
+static bool wait_loop(int deadline_seconds, gpr_event* ev) {
   while (deadline_seconds) {
     gpr_log(GPR_DEBUG, "Test: waiting for %d more seconds", deadline_seconds);
     if (gpr_event_wait(ev, grpc_timeout_seconds_to_deadline(1))) return true;
     deadline_seconds--;
 
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_timer_check(&exec_ctx, NULL);
+    grpc_timer_check(&exec_ctx, nullptr);
     grpc_exec_ctx_finish(&exec_ctx);
   }
   return false;
 }
 
 typedef struct next_args {
-  grpc_resolver *resolver;
-  grpc_channel_args **result;
-  grpc_closure *on_complete;
+  grpc_resolver* resolver;
+  grpc_channel_args** result;
+  grpc_closure* on_complete;
 } next_args;
 
-static void call_resolver_next_now_lock_taken(grpc_exec_ctx *exec_ctx,
-                                              void *arg,
-                                              grpc_error *error_unused) {
-  next_args *a = arg;
+static void call_resolver_next_now_lock_taken(grpc_exec_ctx* exec_ctx,
+                                              void* arg,
+                                              grpc_error* error_unused) {
+  next_args* a = static_cast<next_args*>(arg);
   grpc_resolver_next_locked(exec_ctx, a->resolver, a->result, a->on_complete);
   gpr_free(a);
 }
 
-static void call_resolver_next_after_locking(grpc_exec_ctx *exec_ctx,
-                                             grpc_resolver *resolver,
-                                             grpc_channel_args **result,
-                                             grpc_closure *on_complete) {
-  next_args *a = gpr_malloc(sizeof(*a));
+static void call_resolver_next_after_locking(grpc_exec_ctx* exec_ctx,
+                                             grpc_resolver* resolver,
+                                             grpc_channel_args** result,
+                                             grpc_closure* on_complete) {
+  next_args* a = static_cast<next_args*>(gpr_malloc(sizeof(*a)));
   a->resolver = resolver;
   a->result = result;
   a->on_complete = on_complete;
-  GRPC_CLOSURE_SCHED(exec_ctx, GRPC_CLOSURE_CREATE(
-                                   call_resolver_next_now_lock_taken, a,
-                                   grpc_combiner_scheduler(resolver->combiner)),
-                     GRPC_ERROR_NONE);
+  GRPC_CLOSURE_SCHED(
+      exec_ctx,
+      GRPC_CLOSURE_CREATE(call_resolver_next_now_lock_taken, a,
+                          grpc_combiner_scheduler(resolver->combiner)),
+      GRPC_ERROR_NONE);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
 
   grpc_init();
@@ -148,10 +151,10 @@ int main(int argc, char **argv) {
   g_combiner = grpc_combiner_create();
   grpc_resolve_address = my_resolve_address;
   grpc_dns_lookup_ares = my_dns_lookup_ares;
-  grpc_channel_args *result = (grpc_channel_args *)1;
+  grpc_channel_args* result = (grpc_channel_args*)1;
 
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_resolver *resolver = create_resolver(&exec_ctx, "dns:test");
+  grpc_resolver* resolver = create_resolver(&exec_ctx, "dns:test");
   gpr_event ev1;
   gpr_event_init(&ev1);
   call_resolver_next_after_locking(
@@ -159,7 +162,7 @@ int main(int argc, char **argv) {
       GRPC_CLOSURE_CREATE(on_done, &ev1, grpc_schedule_on_exec_ctx));
   grpc_exec_ctx_flush(&exec_ctx);
   GPR_ASSERT(wait_loop(5, &ev1));
-  GPR_ASSERT(result == NULL);
+  GPR_ASSERT(result == nullptr);
 
   gpr_event ev2;
   gpr_event_init(&ev2);
@@ -168,7 +171,7 @@ int main(int argc, char **argv) {
       GRPC_CLOSURE_CREATE(on_done, &ev2, grpc_schedule_on_exec_ctx));
   grpc_exec_ctx_flush(&exec_ctx);
   GPR_ASSERT(wait_loop(30, &ev2));
-  GPR_ASSERT(result != NULL);
+  GPR_ASSERT(result != nullptr);
 
   grpc_channel_args_destroy(&exec_ctx, result);
   GRPC_RESOLVER_UNREF(&exec_ctx, resolver, "test");
diff --git a/test/core/client_channel/resolvers/dns_resolver_test.c b/test/core/client_channel/resolvers/dns_resolver_test.cc
index a14926f173..4c040caeb9 100644
--- a/test/core/client_channel/resolvers/dns_resolver_test.c
+++ b/test/core/client_channel/resolvers/dns_resolver_test.cc
@@ -25,13 +25,13 @@
 #include "src/core/lib/iomgr/combiner.h"
 #include "test/core/util/test_config.h"
 
-static grpc_combiner *g_combiner;
+static grpc_combiner* g_combiner;
 
-static void test_succeeds(grpc_resolver_factory *factory, const char *string) {
+static void test_succeeds(grpc_resolver_factory* factory, const char* string) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_uri *uri = grpc_uri_parse(&exec_ctx, string, 0);
+  grpc_uri* uri = grpc_uri_parse(&exec_ctx, string, 0);
   grpc_resolver_args args;
-  grpc_resolver *resolver;
+  grpc_resolver* resolver;
   gpr_log(GPR_DEBUG, "test: '%s' should be valid for '%s'", string,
           factory->vtable->scheme);
   GPR_ASSERT(uri);
@@ -39,17 +39,17 @@ static void test_succeeds(grpc_resolver_factory *factory, const char *string) {
   args.uri = uri;
   args.combiner = g_combiner;
   resolver = grpc_resolver_factory_create_resolver(&exec_ctx, factory, &args);
-  GPR_ASSERT(resolver != NULL);
+  GPR_ASSERT(resolver != nullptr);
   GRPC_RESOLVER_UNREF(&exec_ctx, resolver, "test_succeeds");
   grpc_uri_destroy(uri);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void test_fails(grpc_resolver_factory *factory, const char *string) {
+static void test_fails(grpc_resolver_factory* factory, const char* string) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_uri *uri = grpc_uri_parse(&exec_ctx, string, 0);
+  grpc_uri* uri = grpc_uri_parse(&exec_ctx, string, 0);
   grpc_resolver_args args;
-  grpc_resolver *resolver;
+  grpc_resolver* resolver;
   gpr_log(GPR_DEBUG, "test: '%s' should be invalid for '%s'", string,
           factory->vtable->scheme);
   GPR_ASSERT(uri);
@@ -57,13 +57,13 @@ static void test_fails(grpc_resolver_factory *factory, const char *string) {
   args.uri = uri;
   args.combiner = g_combiner;
   resolver = grpc_resolver_factory_create_resolver(&exec_ctx, factory, &args);
-  GPR_ASSERT(resolver == NULL);
+  GPR_ASSERT(resolver == nullptr);
   grpc_uri_destroy(uri);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-int main(int argc, char **argv) {
-  grpc_resolver_factory *dns;
+int main(int argc, char** argv) {
+  grpc_resolver_factory* dns;
   grpc_test_init(argc, argv);
   grpc_init();
 
diff --git a/test/core/client_channel/resolvers/fake_resolver_test.c b/test/core/client_channel/resolvers/fake_resolver_test.cc
index 9b0854d6d8..d5538e9621 100644
--- a/test/core/client_channel/resolvers/fake_resolver_test.c
+++ b/test/core/client_channel/resolvers/fake_resolver_test.cc
@@ -32,10 +32,10 @@
 
 #include "test/core/util/test_config.h"
 
-static grpc_resolver *build_fake_resolver(
-    grpc_exec_ctx *exec_ctx, grpc_combiner *combiner,
-    grpc_fake_resolver_response_generator *response_generator) {
-  grpc_resolver_factory *factory = grpc_resolver_factory_lookup("fake");
+static grpc_resolver* build_fake_resolver(
+    grpc_exec_ctx* exec_ctx, grpc_combiner* combiner,
+    grpc_fake_resolver_response_generator* response_generator) {
+  grpc_resolver_factory* factory = grpc_resolver_factory_lookup("fake");
   grpc_arg generator_arg =
       grpc_fake_resolver_response_generator_arg(response_generator);
   grpc_resolver_args args;
@@ -43,65 +43,65 @@ static grpc_resolver *build_fake_resolver(
   grpc_channel_args channel_args = {1, &generator_arg};
   args.args = &channel_args;
   args.combiner = combiner;
-  grpc_resolver *resolver =
+  grpc_resolver* resolver =
       grpc_resolver_factory_create_resolver(exec_ctx, factory, &args);
   grpc_resolver_factory_unref(factory);
   return resolver;
 }
 
 typedef struct on_resolution_arg {
-  grpc_channel_args *resolver_result;
-  grpc_channel_args *expected_resolver_result;
+  grpc_channel_args* resolver_result;
+  grpc_channel_args* expected_resolver_result;
   gpr_event ev;
 } on_resolution_arg;
 
-void on_resolution_cb(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  on_resolution_arg *res = arg;
+void on_resolution_cb(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+  on_resolution_arg* res = static_cast<on_resolution_arg*>(arg);
   // We only check the addresses channel arg because that's the only one
   // explicitly set by the test via
   // grpc_fake_resolver_response_generator_set_response.
-  const grpc_lb_addresses *actual_lb_addresses =
+  const grpc_lb_addresses* actual_lb_addresses =
       grpc_lb_addresses_find_channel_arg(res->resolver_result);
-  const grpc_lb_addresses *expected_lb_addresses =
+  const grpc_lb_addresses* expected_lb_addresses =
       grpc_lb_addresses_find_channel_arg(res->expected_resolver_result);
   GPR_ASSERT(
       grpc_lb_addresses_cmp(actual_lb_addresses, expected_lb_addresses) == 0);
   grpc_channel_args_destroy(exec_ctx, res->resolver_result);
   grpc_channel_args_destroy(exec_ctx, res->expected_resolver_result);
-  gpr_event_set(&res->ev, (void *)1);
+  gpr_event_set(&res->ev, (void*)1);
 }
 
 static void test_fake_resolver() {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_combiner *combiner = grpc_combiner_create();
+  grpc_combiner* combiner = grpc_combiner_create();
   // Create resolver.
-  grpc_fake_resolver_response_generator *response_generator =
+  grpc_fake_resolver_response_generator* response_generator =
       grpc_fake_resolver_response_generator_create();
-  grpc_resolver *resolver =
+  grpc_resolver* resolver =
       build_fake_resolver(&exec_ctx, combiner, response_generator);
-  GPR_ASSERT(resolver != NULL);
+  GPR_ASSERT(resolver != nullptr);
 
   // Setup expectations.
-  grpc_uri *uris[] = {grpc_uri_parse(&exec_ctx, "ipv4:10.2.1.1:1234", true),
+  grpc_uri* uris[] = {grpc_uri_parse(&exec_ctx, "ipv4:10.2.1.1:1234", true),
                       grpc_uri_parse(&exec_ctx, "ipv4:127.0.0.1:4321", true)};
-  char *balancer_names[] = {"name1", "name2"};
+  const char* balancer_names[] = {"name1", "name2"};
   const bool is_balancer[] = {true, false};
-  grpc_lb_addresses *addresses = grpc_lb_addresses_create(3, NULL);
+  grpc_lb_addresses* addresses = grpc_lb_addresses_create(3, nullptr);
   for (size_t i = 0; i < GPR_ARRAY_SIZE(uris); ++i) {
     grpc_lb_addresses_set_address_from_uri(
-        addresses, i, uris[i], is_balancer[i], balancer_names[i], NULL);
+        addresses, i, uris[i], is_balancer[i], balancer_names[i], nullptr);
     grpc_uri_destroy(uris[i]);
   }
   const grpc_arg addresses_arg =
       grpc_lb_addresses_create_channel_arg(addresses);
-  grpc_channel_args *results =
-      grpc_channel_args_copy_and_add(NULL, &addresses_arg, 1);
+  grpc_channel_args* results =
+      grpc_channel_args_copy_and_add(nullptr, &addresses_arg, 1);
   grpc_lb_addresses_destroy(&exec_ctx, addresses);
   on_resolution_arg on_res_arg;
   memset(&on_res_arg, 0, sizeof(on_res_arg));
   on_res_arg.expected_resolver_result = results;
   gpr_event_init(&on_res_arg.ev);
-  grpc_closure *on_resolution = GRPC_CLOSURE_CREATE(
+  grpc_closure* on_resolution = GRPC_CLOSURE_CREATE(
       on_resolution_cb, &on_res_arg, grpc_combiner_scheduler(combiner));
 
   // Set resolver results and trigger first resolution. on_resolution_cb
@@ -112,25 +112,25 @@ static void test_fake_resolver() {
                             on_resolution);
   grpc_exec_ctx_flush(&exec_ctx);
   GPR_ASSERT(gpr_event_wait(&on_res_arg.ev,
-                            grpc_timeout_seconds_to_deadline(5)) != NULL);
+                            grpc_timeout_seconds_to_deadline(5)) != nullptr);
 
   // Setup update.
-  grpc_uri *uris_update[] = {
+  grpc_uri* uris_update[] = {
       grpc_uri_parse(&exec_ctx, "ipv4:192.168.1.0:31416", true)};
-  char *balancer_names_update[] = {"name3"};
+  const char* balancer_names_update[] = {"name3"};
   const bool is_balancer_update[] = {false};
-  grpc_lb_addresses *addresses_update = grpc_lb_addresses_create(1, NULL);
+  grpc_lb_addresses* addresses_update = grpc_lb_addresses_create(1, nullptr);
   for (size_t i = 0; i < GPR_ARRAY_SIZE(uris_update); ++i) {
     grpc_lb_addresses_set_address_from_uri(addresses_update, i, uris_update[i],
                                            is_balancer_update[i],
-                                           balancer_names_update[i], NULL);
+                                           balancer_names_update[i], nullptr);
     grpc_uri_destroy(uris_update[i]);
   }
 
   grpc_arg addresses_update_arg =
       grpc_lb_addresses_create_channel_arg(addresses_update);
-  grpc_channel_args *results_update =
-      grpc_channel_args_copy_and_add(NULL, &addresses_update_arg, 1);
+  grpc_channel_args* results_update =
+      grpc_channel_args_copy_and_add(nullptr, &addresses_update_arg, 1);
   grpc_lb_addresses_destroy(&exec_ctx, addresses_update);
 
   // Setup expectations for the update.
@@ -148,7 +148,7 @@ static void test_fake_resolver() {
                             &on_res_arg_update.resolver_result, on_resolution);
   grpc_exec_ctx_flush(&exec_ctx);
   GPR_ASSERT(gpr_event_wait(&on_res_arg_update.ev,
-                            grpc_timeout_seconds_to_deadline(5)) != NULL);
+                            grpc_timeout_seconds_to_deadline(5)) != nullptr);
 
   // Requesting a new resolution without re-senting the response shouldn't
   // trigger the resolution callback.
@@ -158,7 +158,7 @@ static void test_fake_resolver() {
   grpc_exec_ctx_flush(&exec_ctx);
   GPR_ASSERT(gpr_event_wait(&on_res_arg.ev,
                             grpc_timeout_milliseconds_to_deadline(100)) ==
-             NULL);
+             nullptr);
 
   GRPC_COMBINER_UNREF(&exec_ctx, combiner, "test_fake_resolver");
   GRPC_RESOLVER_UNREF(&exec_ctx, resolver, "test_fake_resolver");
@@ -166,7 +166,7 @@ static void test_fake_resolver() {
   grpc_fake_resolver_response_generator_unref(response_generator);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
 
diff --git a/test/core/client_channel/resolvers/sockaddr_resolver_test.c b/test/core/client_channel/resolvers/sockaddr_resolver_test.cc
index 8b88619164..dfa2d12b5e 100644
--- a/test/core/client_channel/resolvers/sockaddr_resolver_test.c
+++ b/test/core/client_channel/resolvers/sockaddr_resolver_test.cc
@@ -28,23 +28,23 @@
 
 #include "test/core/util/test_config.h"
 
-static grpc_combiner *g_combiner;
+static grpc_combiner* g_combiner;
 
 typedef struct on_resolution_arg {
-  char *expected_server_name;
-  grpc_channel_args *resolver_result;
+  char* expected_server_name;
+  grpc_channel_args* resolver_result;
 } on_resolution_arg;
 
-void on_resolution_cb(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  on_resolution_arg *res = arg;
+void on_resolution_cb(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+  on_resolution_arg* res = static_cast<on_resolution_arg*>(arg);
   grpc_channel_args_destroy(exec_ctx, res->resolver_result);
 }
 
-static void test_succeeds(grpc_resolver_factory *factory, const char *string) {
+static void test_succeeds(grpc_resolver_factory* factory, const char* string) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_uri *uri = grpc_uri_parse(&exec_ctx, string, 0);
+  grpc_uri* uri = grpc_uri_parse(&exec_ctx, string, 0);
   grpc_resolver_args args;
-  grpc_resolver *resolver;
+  grpc_resolver* resolver;
   gpr_log(GPR_DEBUG, "test: '%s' should be valid for '%s'", string,
           factory->vtable->scheme);
   GPR_ASSERT(uri);
@@ -52,12 +52,12 @@ static void test_succeeds(grpc_resolver_factory *factory, const char *string) {
   args.uri = uri;
   args.combiner = g_combiner;
   resolver = grpc_resolver_factory_create_resolver(&exec_ctx, factory, &args);
-  GPR_ASSERT(resolver != NULL);
+  GPR_ASSERT(resolver != nullptr);
 
   on_resolution_arg on_res_arg;
   memset(&on_res_arg, 0, sizeof(on_res_arg));
   on_res_arg.expected_server_name = uri->path;
-  grpc_closure *on_resolution = GRPC_CLOSURE_CREATE(
+  grpc_closure* on_resolution = GRPC_CLOSURE_CREATE(
       on_resolution_cb, &on_res_arg, grpc_schedule_on_exec_ctx);
 
   grpc_resolver_next_locked(&exec_ctx, resolver, &on_res_arg.resolver_result,
@@ -67,11 +67,11 @@ static void test_succeeds(grpc_resolver_factory *factory, const char *string) {
   grpc_uri_destroy(uri);
 }
 
-static void test_fails(grpc_resolver_factory *factory, const char *string) {
+static void test_fails(grpc_resolver_factory* factory, const char* string) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_uri *uri = grpc_uri_parse(&exec_ctx, string, 0);
+  grpc_uri* uri = grpc_uri_parse(&exec_ctx, string, 0);
   grpc_resolver_args args;
-  grpc_resolver *resolver;
+  grpc_resolver* resolver;
   gpr_log(GPR_DEBUG, "test: '%s' should be invalid for '%s'", string,
           factory->vtable->scheme);
   GPR_ASSERT(uri);
@@ -79,12 +79,12 @@ static void test_fails(grpc_resolver_factory *factory, const char *string) {
   args.uri = uri;
   args.combiner = g_combiner;
   resolver = grpc_resolver_factory_create_resolver(&exec_ctx, factory, &args);
-  GPR_ASSERT(resolver == NULL);
+  GPR_ASSERT(resolver == nullptr);
   grpc_uri_destroy(uri);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_resolver_factory *ipv4, *ipv6;
   grpc_test_init(argc, argv);
   grpc_init();
diff --git a/test/core/client_channel/uri_fuzzer_test.c b/test/core/client_channel/uri_fuzzer_test.cc
index e51d0031ec..ba31793ff3 100644
--- a/test/core/client_channel/uri_fuzzer_test.c
+++ b/test/core/client_channel/uri_fuzzer_test.cc
@@ -28,13 +28,13 @@
 bool squelch = true;
 bool leak_check = true;
 
-int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
-  char *s = gpr_malloc(size + 1);
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  char* s = static_cast<char*>(gpr_malloc(size + 1));
   memcpy(s, data, size);
   s[size] = 0;
 
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_uri *x;
+  grpc_uri* x;
   if ((x = grpc_uri_parse(&exec_ctx, s, 1))) {
     grpc_uri_destroy(x);
   }
diff --git a/test/core/client_channel/uri_parser_test.c b/test/core/client_channel/uri_parser_test.cc
index f53cae196b..30183f9f57 100644
--- a/test/core/client_channel/uri_parser_test.c
+++ b/test/core/client_channel/uri_parser_test.cc
@@ -25,11 +25,11 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "test/core/util/test_config.h"
 
-static void test_succeeds(const char *uri_text, const char *scheme,
-                          const char *authority, const char *path,
-                          const char *query, const char *fragment) {
+static void test_succeeds(const char* uri_text, const char* scheme,
+                          const char* authority, const char* path,
+                          const char* query, const char* fragment) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_uri *uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
+  grpc_uri* uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
   GPR_ASSERT(uri);
   GPR_ASSERT(0 == strcmp(scheme, uri->scheme));
   GPR_ASSERT(0 == strcmp(authority, uri->authority));
@@ -40,17 +40,17 @@ static void test_succeeds(const char *uri_text, const char *scheme,
   grpc_uri_destroy(uri);
 }
 
-static void test_fails(const char *uri_text) {
+static void test_fails(const char* uri_text) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  GPR_ASSERT(NULL == grpc_uri_parse(&exec_ctx, uri_text, 0));
+  GPR_ASSERT(nullptr == grpc_uri_parse(&exec_ctx, uri_text, 0));
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
 static void test_query_parts() {
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    const char *uri_text = "http://foo/path?a&b=B&c=&#frag";
-    grpc_uri *uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
+    const char* uri_text = "http://foo/path?a&b=B&c=&#frag";
+    grpc_uri* uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
     GPR_ASSERT(uri);
 
     GPR_ASSERT(0 == strcmp("http", uri->scheme));
@@ -60,7 +60,7 @@ static void test_query_parts() {
     GPR_ASSERT(4 == uri->num_query_parts);
 
     GPR_ASSERT(0 == strcmp("a", uri->query_parts[0]));
-    GPR_ASSERT(NULL == uri->query_parts_values[0]);
+    GPR_ASSERT(nullptr == uri->query_parts_values[0]);
 
     GPR_ASSERT(0 == strcmp("b", uri->query_parts[1]));
     GPR_ASSERT(0 == strcmp("B", uri->query_parts_values[1]));
@@ -69,12 +69,12 @@ static void test_query_parts() {
     GPR_ASSERT(0 == strcmp("", uri->query_parts_values[2]));
 
     GPR_ASSERT(0 == strcmp("", uri->query_parts[3]));
-    GPR_ASSERT(NULL == uri->query_parts_values[3]);
+    GPR_ASSERT(nullptr == uri->query_parts_values[3]);
 
-    GPR_ASSERT(NULL == grpc_uri_get_query_arg(uri, "a"));
+    GPR_ASSERT(nullptr == grpc_uri_get_query_arg(uri, "a"));
     GPR_ASSERT(0 == strcmp("B", grpc_uri_get_query_arg(uri, "b")));
     GPR_ASSERT(0 == strcmp("", grpc_uri_get_query_arg(uri, "c")));
-    GPR_ASSERT(NULL == grpc_uri_get_query_arg(uri, ""));
+    GPR_ASSERT(nullptr == grpc_uri_get_query_arg(uri, ""));
 
     GPR_ASSERT(0 == strcmp("frag", uri->fragment));
     grpc_exec_ctx_finish(&exec_ctx);
@@ -83,8 +83,8 @@ static void test_query_parts() {
   {
     /* test the current behavior of multiple query part values */
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    const char *uri_text = "http://auth/path?foo=bar=baz&foobar==";
-    grpc_uri *uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
+    const char* uri_text = "http://auth/path?foo=bar=baz&foobar==";
+    grpc_uri* uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
     GPR_ASSERT(uri);
 
     GPR_ASSERT(0 == strcmp("http", uri->scheme));
@@ -102,8 +102,8 @@ static void test_query_parts() {
   {
     /* empty query */
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    const char *uri_text = "http://foo/path";
-    grpc_uri *uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
+    const char* uri_text = "http://foo/path";
+    grpc_uri* uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
     GPR_ASSERT(uri);
 
     GPR_ASSERT(0 == strcmp("http", uri->scheme));
@@ -111,15 +111,15 @@ static void test_query_parts() {
     GPR_ASSERT(0 == strcmp("/path", uri->path));
     GPR_ASSERT(0 == strcmp("", uri->query));
     GPR_ASSERT(0 == uri->num_query_parts);
-    GPR_ASSERT(NULL == uri->query_parts);
-    GPR_ASSERT(NULL == uri->query_parts_values);
+    GPR_ASSERT(nullptr == uri->query_parts);
+    GPR_ASSERT(nullptr == uri->query_parts_values);
     GPR_ASSERT(0 == strcmp("", uri->fragment));
     grpc_exec_ctx_finish(&exec_ctx);
     grpc_uri_destroy(uri);
   }
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_succeeds("http://www.google.com", "http", "www.google.com", "", "", "");
   test_succeeds("dns:///foo", "dns", "", "/foo", "", "");
diff --git a/test/core/compression/BUILD b/test/core/compression/BUILD
index 1ab6e35f0d..ee71eecfeb 100644
--- a/test/core/compression/BUILD
+++ b/test/core/compression/BUILD
@@ -20,8 +20,8 @@ licenses(["notice"])  # Apache v2
 
 grpc_cc_test(
     name = "algorithm_test",
-    srcs = ["algorithm_test.c"],
-    language = "C",
+    srcs = ["algorithm_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -32,8 +32,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "compression_test",
-    srcs = ["compression_test.c"],
-    language = "C",
+    srcs = ["compression_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -44,8 +44,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "message_compress_test",
-    srcs = ["message_compress_test.c"],
-    language = "C",
+    srcs = ["message_compress_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
diff --git a/test/core/compression/algorithm_test.c b/test/core/compression/algorithm_test.cc
index a11e6e90ac..2f1d8bc8eb 100644
--- a/test/core/compression/algorithm_test.c
+++ b/test/core/compression/algorithm_test.cc
@@ -35,7 +35,7 @@ static void test_algorithm_mesh(void) {
   gpr_log(GPR_DEBUG, "test_algorithm_mesh");
 
   for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) {
-    const char *name;
+    const char* name;
     grpc_compression_algorithm parsed;
     grpc_slice mdstr;
     grpc_mdelem mdelem;
@@ -68,9 +68,11 @@ static void test_algorithm_failure(void) {
   gpr_log(GPR_DEBUG, "test_algorithm_failure");
 
   GPR_ASSERT(grpc_compression_algorithm_name(GRPC_COMPRESS_ALGORITHMS_COUNT,
-                                             NULL) == 0);
-  GPR_ASSERT(grpc_compression_algorithm_name(GRPC_COMPRESS_ALGORITHMS_COUNT + 1,
-                                             NULL) == 0);
+                                             nullptr) == 0);
+  GPR_ASSERT(
+      grpc_compression_algorithm_name(static_cast<grpc_compression_algorithm>(
+                                          GRPC_COMPRESS_ALGORITHMS_COUNT + 1),
+                                      nullptr) == 0);
   mdstr = grpc_slice_from_static_string("this-is-an-invalid-algorithm");
   GPR_ASSERT(grpc_compression_algorithm_from_slice(mdstr) ==
              GRPC_COMPRESS_ALGORITHMS_COUNT);
@@ -78,13 +80,14 @@ static void test_algorithm_failure(void) {
       grpc_compression_algorithm_slice(GRPC_COMPRESS_ALGORITHMS_COUNT),
       grpc_empty_slice()));
   GPR_ASSERT(grpc_slice_eq(
-      grpc_compression_algorithm_slice(GRPC_COMPRESS_ALGORITHMS_COUNT + 1),
+      grpc_compression_algorithm_slice(static_cast<grpc_compression_algorithm>(
+          static_cast<int>(GRPC_COMPRESS_ALGORITHMS_COUNT) + 1)),
       grpc_empty_slice()));
   grpc_slice_unref_internal(&exec_ctx, mdstr);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
 
diff --git a/test/core/compression/compression_test.c b/test/core/compression/compression_test.cc
index 326a800300..a1a9441c8d 100644
--- a/test/core/compression/compression_test.c
+++ b/test/core/compression/compression_test.cc
@@ -28,15 +28,15 @@
 
 static void test_compression_algorithm_parse(void) {
   size_t i;
-  const char *valid_names[] = {"identity", "gzip", "deflate"};
+  const char* valid_names[] = {"identity", "gzip", "deflate"};
   const grpc_compression_algorithm valid_algorithms[] = {
       GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_DEFLATE};
-  const char *invalid_names[] = {"gzip2", "foo", "", "2gzip"};
+  const char* invalid_names[] = {"gzip2", "foo", "", "2gzip"};
 
   gpr_log(GPR_DEBUG, "test_compression_algorithm_parse");
 
   for (i = 0; i < GPR_ARRAY_SIZE(valid_names); i++) {
-    const char *valid_name = valid_names[i];
+    const char* valid_name = valid_names[i];
     grpc_compression_algorithm algorithm;
     const int success = grpc_compression_algorithm_parse(
         grpc_slice_from_static_string(valid_name), &algorithm);
@@ -45,7 +45,7 @@ static void test_compression_algorithm_parse(void) {
   }
 
   for (i = 0; i < GPR_ARRAY_SIZE(invalid_names); i++) {
-    const char *invalid_name = invalid_names[i];
+    const char* invalid_name = invalid_names[i];
     grpc_compression_algorithm algorithm;
     int success;
     success = grpc_compression_algorithm_parse(
@@ -57,9 +57,9 @@ static void test_compression_algorithm_parse(void) {
 
 static void test_compression_algorithm_name(void) {
   int success;
-  const char *name;
+  const char* name;
   size_t i;
-  const char *valid_names[] = {"identity", "gzip", "deflate"};
+  const char* valid_names[] = {"identity", "gzip", "deflate"};
   const grpc_compression_algorithm valid_algorithms[] = {
       GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_DEFLATE};
 
@@ -181,28 +181,34 @@ static void test_compression_enable_disable_algorithm(void) {
 
   grpc_compression_options_init(&options);
   for (algorithm = GRPC_COMPRESS_NONE;
-       algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT; algorithm++) {
+       algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT;
+       algorithm = static_cast<grpc_compression_algorithm>(
+           static_cast<int>(algorithm) + 1)) {
     /* all algorithms are enabled by default */
     GPR_ASSERT(grpc_compression_options_is_algorithm_enabled(&options,
                                                              algorithm) != 0);
   }
   /* disable one by one */
   for (algorithm = GRPC_COMPRESS_NONE;
-       algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT; algorithm++) {
+       algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT;
+       algorithm = static_cast<grpc_compression_algorithm>(
+           static_cast<int>(algorithm) + 1)) {
     grpc_compression_options_disable_algorithm(&options, algorithm);
     GPR_ASSERT(grpc_compression_options_is_algorithm_enabled(&options,
                                                              algorithm) == 0);
   }
   /* re-enable one by one */
   for (algorithm = GRPC_COMPRESS_NONE;
-       algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT; algorithm++) {
+       algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT;
+       algorithm = static_cast<grpc_compression_algorithm>(
+           static_cast<int>(algorithm) + 1)) {
     grpc_compression_options_enable_algorithm(&options, algorithm);
     GPR_ASSERT(grpc_compression_options_is_algorithm_enabled(&options,
                                                              algorithm) != 0);
   }
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_init();
   test_compression_algorithm_parse();
   test_compression_algorithm_name();
diff --git a/test/core/compression/message_compress_test.c b/test/core/compression/message_compress_test.cc
index f7f4893dee..676415ba9d 100644
--- a/test/core/compression/message_compress_test.c
+++ b/test/core/compression/message_compress_test.cc
@@ -49,17 +49,18 @@ static void assert_passthrough(grpc_slice value,
   grpc_slice_buffer output;
   grpc_slice final;
   int was_compressed;
-  const char *algorithm_name;
+  const char* algorithm_name;
 
   GPR_ASSERT(grpc_compression_algorithm_name(algorithm, &algorithm_name) != 0);
-  gpr_log(
-      GPR_INFO, "assert_passthrough: value_length=%" PRIuPTR
-                " value_hash=0x%08x "
-                "algorithm='%s' uncompressed_split='%s' compressed_split='%s'",
-      GRPC_SLICE_LENGTH(value), gpr_murmur_hash3(GRPC_SLICE_START_PTR(value),
-                                                 GRPC_SLICE_LENGTH(value), 0),
-      algorithm_name, grpc_slice_split_mode_name(uncompressed_split_mode),
-      grpc_slice_split_mode_name(compressed_split_mode));
+  gpr_log(GPR_INFO,
+          "assert_passthrough: value_length=%" PRIuPTR
+          " value_hash=0x%08x "
+          "algorithm='%s' uncompressed_split='%s' compressed_split='%s'",
+          GRPC_SLICE_LENGTH(value),
+          gpr_murmur_hash3(GRPC_SLICE_START_PTR(value),
+                           GRPC_SLICE_LENGTH(value), 0),
+          algorithm_name, grpc_slice_split_mode_name(uncompressed_split_mode),
+          grpc_slice_split_mode_name(compressed_split_mode));
 
   grpc_slice_buffer_init(&input);
   grpc_slice_buffer_init(&compressed_raw);
@@ -148,16 +149,17 @@ static grpc_slice create_test_value(test_value id) {
 static void test_tiny_data_compress(void) {
   grpc_slice_buffer input;
   grpc_slice_buffer output;
-  grpc_compression_algorithm i;
 
   grpc_slice_buffer_init(&input);
   grpc_slice_buffer_init(&output);
   grpc_slice_buffer_add(&input, create_test_value(ONE_A));
 
-  for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) {
+  for (int i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) {
     if (i == GRPC_COMPRESS_NONE) continue;
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    GPR_ASSERT(0 == grpc_msg_compress(&exec_ctx, i, &input, &output));
+    GPR_ASSERT(0 == grpc_msg_compress(
+                        &exec_ctx, static_cast<grpc_compression_algorithm>(i),
+                        &input, &output));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(1 == output.count);
   }
@@ -252,8 +254,10 @@ static void test_bad_compression_algorithm(void) {
                                      &input, &output);
   GPR_ASSERT(0 == was_compressed);
 
-  was_compressed = grpc_msg_compress(
-      &exec_ctx, GRPC_COMPRESS_ALGORITHMS_COUNT + 123, &input, &output);
+  was_compressed = grpc_msg_compress(&exec_ctx,
+                                     static_cast<grpc_compression_algorithm>(
+                                         GRPC_COMPRESS_ALGORITHMS_COUNT + 123),
+                                     &input, &output);
   GPR_ASSERT(0 == was_compressed);
   grpc_exec_ctx_finish(&exec_ctx);
 
@@ -276,8 +280,11 @@ static void test_bad_decompression_algorithm(void) {
       &exec_ctx, GRPC_COMPRESS_ALGORITHMS_COUNT, &input, &output);
   GPR_ASSERT(0 == was_decompressed);
 
-  was_decompressed = grpc_msg_decompress(
-      &exec_ctx, GRPC_COMPRESS_ALGORITHMS_COUNT + 123, &input, &output);
+  was_decompressed =
+      grpc_msg_decompress(&exec_ctx,
+                          static_cast<grpc_compression_algorithm>(
+                              GRPC_COMPRESS_ALGORITHMS_COUNT + 123),
+                          &input, &output);
   GPR_ASSERT(0 == was_decompressed);
   grpc_exec_ctx_finish(&exec_ctx);
 
@@ -285,7 +292,7 @@ static void test_bad_decompression_algorithm(void) {
   grpc_slice_buffer_destroy(&output);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   unsigned i, j, k, m;
   grpc_slice_split_mode uncompressed_split_modes[] = {
       GRPC_SLICE_SPLIT_IDENTITY, GRPC_SLICE_SPLIT_ONE_BYTE};
@@ -300,8 +307,13 @@ int main(int argc, char **argv) {
     for (j = 0; j < GPR_ARRAY_SIZE(uncompressed_split_modes); j++) {
       for (k = 0; k < GPR_ARRAY_SIZE(compressed_split_modes); k++) {
         for (m = 0; m < TEST_VALUE_COUNT; m++) {
-          grpc_slice slice = create_test_value(m);
-          assert_passthrough(slice, i, j, k, get_compressability(m, i));
+          grpc_slice slice = create_test_value(static_cast<test_value>(m));
+          assert_passthrough(
+              slice, static_cast<grpc_compression_algorithm>(i),
+              static_cast<grpc_slice_split_mode>(j),
+              static_cast<grpc_slice_split_mode>(k),
+              get_compressability(static_cast<test_value>(m),
+                                  static_cast<grpc_compression_algorithm>(i)));
           grpc_slice_unref(slice);
         }
       }
diff --git a/test/core/compression/stream_compression_test.c b/test/core/compression/stream_compression_test.cc
index afed6cd6b5..2f30b7fc19 100644
--- a/test/core/compression/stream_compression_test.c
+++ b/test/core/compression/stream_compression_test.cc
@@ -25,7 +25,7 @@
 
 #include "src/core/lib/compression/stream_compression.h"
 
-static void generate_random_payload(char *payload, size_t size) {
+static void generate_random_payload(char* payload, size_t size) {
   size_t i;
   static const char chars[] = "abcdefghijklmnopqrstuvwxyz1234567890";
   for (i = 0; i < size - 1; ++i) {
@@ -34,8 +34,8 @@ static void generate_random_payload(char *payload, size_t size) {
   payload[size - 1] = '\0';
 }
 
-static bool slice_buffer_equals_string(grpc_slice_buffer *buf,
-                                       const char *str) {
+static bool slice_buffer_equals_string(grpc_slice_buffer* buf,
+                                       const char* str) {
   size_t i;
   if (buf->length != strlen(str)) {
     return false;
@@ -43,8 +43,8 @@ static bool slice_buffer_equals_string(grpc_slice_buffer *buf,
   size_t pointer = 0;
   for (i = 0; i < buf->count; i++) {
     size_t slice_len = GRPC_SLICE_LENGTH(buf->slices[i]);
-    if (0 != strncmp(str + pointer,
-                     (char *)GRPC_SLICE_START_PTR(buf->slices[i]), slice_len)) {
+    if (0 != strncmp(str + pointer, (char*)GRPC_SLICE_START_PTR(buf->slices[i]),
+                     slice_len)) {
       return false;
     }
     pointer += slice_len;
@@ -58,15 +58,15 @@ static void test_stream_compression_simple_compress_decompress() {
   grpc_slice_buffer_init(&source);
   grpc_slice_buffer_init(&relay);
   grpc_slice_buffer_init(&sink);
-  grpc_stream_compression_context *compress_ctx =
+  grpc_stream_compression_context* compress_ctx =
       grpc_stream_compression_context_create(
           GRPC_STREAM_COMPRESSION_GZIP_COMPRESS);
-  grpc_stream_compression_context *decompress_ctx =
+  grpc_stream_compression_context* decompress_ctx =
       grpc_stream_compression_context_create(
           GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS);
   grpc_slice slice = grpc_slice_from_static_string(test_str);
   grpc_slice_buffer_add(&source, slice);
-  GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, NULL,
+  GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, nullptr,
                                   ~(size_t)0,
                                   GRPC_STREAM_COMPRESSION_FLUSH_FINISH));
   bool end_of_context;
@@ -91,15 +91,15 @@ test_stream_compression_simple_compress_decompress_with_output_size_constraint()
   grpc_slice_buffer_init(&source);
   grpc_slice_buffer_init(&relay);
   grpc_slice_buffer_init(&sink);
-  grpc_stream_compression_context *compress_ctx =
+  grpc_stream_compression_context* compress_ctx =
       grpc_stream_compression_context_create(
           GRPC_STREAM_COMPRESSION_GZIP_COMPRESS);
-  grpc_stream_compression_context *decompress_ctx =
+  grpc_stream_compression_context* decompress_ctx =
       grpc_stream_compression_context_create(
           GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS);
   grpc_slice slice = grpc_slice_from_static_string(test_str);
   grpc_slice_buffer_add(&source, slice);
-  GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, NULL,
+  GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, nullptr,
                                   ~(size_t)0,
                                   GRPC_STREAM_COMPRESSION_FLUSH_FINISH));
   grpc_stream_compression_context_destroy(compress_ctx);
@@ -112,7 +112,7 @@ test_stream_compression_simple_compress_decompress_with_output_size_constraint()
   GPR_ASSERT(output_size == max_output_size);
   GPR_ASSERT(end_of_context == false);
   grpc_slice slice_recv = grpc_slice_buffer_take_first(&sink);
-  char *str_recv = (char *)GRPC_SLICE_START_PTR(slice_recv);
+  char* str_recv = (char*)GRPC_SLICE_START_PTR(slice_recv);
   GPR_ASSERT(GRPC_SLICE_LENGTH(slice_recv) == max_output_size);
   GPR_ASSERT(0 == strncmp(test_str, str_recv, max_output_size));
   grpc_slice_unref(slice_recv);
@@ -134,21 +134,22 @@ test_stream_compression_simple_compress_decompress_with_output_size_constraint()
 #define LARGE_DATA_SIZE (1024 * 1024)
 static void
 test_stream_compression_simple_compress_decompress_with_large_data() {
-  char *test_str = gpr_malloc(LARGE_DATA_SIZE * sizeof(char));
+  char* test_str =
+      static_cast<char*>(gpr_malloc(LARGE_DATA_SIZE * sizeof(char)));
   generate_random_payload(test_str, LARGE_DATA_SIZE);
   grpc_slice_buffer source, relay, sink;
   grpc_slice_buffer_init(&source);
   grpc_slice_buffer_init(&relay);
   grpc_slice_buffer_init(&sink);
-  grpc_stream_compression_context *compress_ctx =
+  grpc_stream_compression_context* compress_ctx =
       grpc_stream_compression_context_create(
           GRPC_STREAM_COMPRESSION_GZIP_COMPRESS);
-  grpc_stream_compression_context *decompress_ctx =
+  grpc_stream_compression_context* decompress_ctx =
       grpc_stream_compression_context_create(
           GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS);
   grpc_slice slice = grpc_slice_from_static_string(test_str);
   grpc_slice_buffer_add(&source, slice);
-  GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, NULL,
+  GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, nullptr,
                                   ~(size_t)0,
                                   GRPC_STREAM_COMPRESSION_FLUSH_FINISH));
   bool end_of_context;
@@ -174,12 +175,12 @@ static void test_stream_compression_drop_context() {
   grpc_slice_buffer_init(&source);
   grpc_slice_buffer_init(&relay);
   grpc_slice_buffer_init(&sink);
-  grpc_stream_compression_context *compress_ctx =
+  grpc_stream_compression_context* compress_ctx =
       grpc_stream_compression_context_create(
           GRPC_STREAM_COMPRESSION_GZIP_COMPRESS);
   grpc_slice slice = grpc_slice_from_static_string(test_str);
   grpc_slice_buffer_add(&source, slice);
-  GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, NULL,
+  GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, nullptr,
                                   ~(size_t)0,
                                   GRPC_STREAM_COMPRESSION_FLUSH_FINISH));
   grpc_stream_compression_context_destroy(compress_ctx);
@@ -188,7 +189,7 @@ static void test_stream_compression_drop_context() {
       GRPC_STREAM_COMPRESSION_GZIP_COMPRESS);
   slice = grpc_slice_from_static_string(test_str2);
   grpc_slice_buffer_add(&source, slice);
-  GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, NULL,
+  GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, nullptr,
                                   ~(size_t)0,
                                   GRPC_STREAM_COMPRESSION_FLUSH_FINISH));
   grpc_stream_compression_context_destroy(compress_ctx);
@@ -207,7 +208,7 @@ static void test_stream_compression_drop_context() {
   grpc_slice_unref(slice2);
   grpc_slice_buffer_add(&relay, slice3);
 
-  grpc_stream_compression_context *decompress_ctx =
+  grpc_stream_compression_context* decompress_ctx =
       grpc_stream_compression_context_create(
           GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS);
   bool end_of_context;
@@ -243,16 +244,16 @@ static void test_stream_compression_sync_flush() {
   grpc_slice_buffer_init(&source);
   grpc_slice_buffer_init(&relay);
   grpc_slice_buffer_init(&sink);
-  grpc_stream_compression_context *compress_ctx =
+  grpc_stream_compression_context* compress_ctx =
       grpc_stream_compression_context_create(
           GRPC_STREAM_COMPRESSION_GZIP_COMPRESS);
   grpc_slice slice = grpc_slice_from_static_string(test_str);
   grpc_slice_buffer_add(&source, slice);
-  GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, NULL,
+  GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, nullptr,
                                   ~(size_t)0,
                                   GRPC_STREAM_COMPRESSION_FLUSH_SYNC));
 
-  grpc_stream_compression_context *decompress_ctx =
+  grpc_stream_compression_context* decompress_ctx =
       grpc_stream_compression_context_create(
           GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS);
   bool end_of_context;
@@ -267,7 +268,7 @@ static void test_stream_compression_sync_flush() {
   grpc_slice_buffer_init(&sink);
   slice = grpc_slice_from_static_string(test_str2);
   grpc_slice_buffer_add(&source, slice);
-  GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, NULL,
+  GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, nullptr,
                                   ~(size_t)0,
                                   GRPC_STREAM_COMPRESSION_FLUSH_FINISH));
   grpc_stream_compression_context_destroy(compress_ctx);
@@ -284,7 +285,7 @@ static void test_stream_compression_sync_flush() {
   grpc_slice_buffer_destroy(&sink);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_init();
   test_stream_compression_simple_compress_decompress();
   test_stream_compression_simple_compress_decompress_with_output_size_constraint();
diff --git a/test/core/debug/stats_test.cc b/test/core/debug/stats_test.cc
index 501581952d..5fae61f8f6 100644
--- a/test/core/debug/stats_test.cc
+++ b/test/core/debug/stats_test.cc
@@ -16,9 +16,7 @@
  *
  */
 
-extern "C" {
 #include "src/core/lib/debug/stats.h"
-}
 
 #include <mutex>
 #include <thread>
@@ -111,13 +109,12 @@ TEST_P(HistogramTest, IncHistogram) {
     }
   };
   std::vector<int> test_values;
-  for (int j = -1000;
-       j <
-       grpc_stats_histo_bucket_boundaries[kHistogram]
-                                         [grpc_stats_histo_buckets[kHistogram] -
-                                          1] +
-           1000;
-       j++) {
+  // largest bucket boundary for current histogram type.
+  int max_bucket_boundary =
+      grpc_stats_histo_bucket_boundaries[kHistogram]
+                                        [grpc_stats_histo_buckets[kHistogram] -
+                                         1];
+  for (int j = -1000; j < max_bucket_boundary + 1000;) {
     int expected_bucket = FindExpectedBucket(kHistogram, j);
     if (cur_bucket != expected_bucket) {
       threads.emplace_back(
@@ -126,6 +123,14 @@ TEST_P(HistogramTest, IncHistogram) {
       test_values.clear();
     }
     test_values.push_back(j);
+    if (j < max_bucket_boundary &&
+        FindExpectedBucket(kHistogram, j + 1000) == expected_bucket &&
+        FindExpectedBucket(kHistogram, j - 1000) == expected_bucket) {
+      // if we are far from bucket boundary, skip values to speed-up the tests
+      j += 500;
+    } else {
+      j++;
+    }
   }
   run(test_values, cur_bucket);
   for (auto& t : threads) {
diff --git a/test/core/end2end/BUILD b/test/core/end2end/BUILD
index 49bfc43646..f8281bfe6f 100644
--- a/test/core/end2end/BUILD
+++ b/test/core/end2end/BUILD
@@ -22,9 +22,9 @@ load(":generate_tests.bzl", "grpc_end2end_tests")
 
 grpc_cc_library(
     name = "cq_verifier",
-    srcs = ["cq_verifier.c"],
+    srcs = ["cq_verifier.cc"],
     hdrs = ["cq_verifier.h"],
-    language = "C",
+    language = "C++",
     visibility = ["//test:__subpackages__"],
     deps = [
         "//:gpr",
@@ -36,22 +36,22 @@ grpc_cc_library(
 grpc_cc_library(
     name = "ssl_test_data",
     srcs = [
-        "data/client_certs.c",
-        "data/server1_cert.c",
-        "data/server1_key.c",
-        "data/test_root_cert.c",
+        "data/client_certs.cc",
+        "data/server1_cert.cc",
+        "data/server1_key.cc",
+        "data/test_root_cert.cc",
     ],
     hdrs = ["data/ssl_test_data.h"],
-    language = "C",
+    language = "C++",
     visibility = ["//test:__subpackages__"],
 )
 
 
 grpc_cc_library(
     name = "http_proxy",
-    srcs = ["fixtures/http_proxy_fixture.c"],
+    srcs = ["fixtures/http_proxy_fixture.cc"],
     hdrs = ["fixtures/http_proxy_fixture.h"],
-    language = "C",
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -61,9 +61,9 @@ grpc_cc_library(
 
 grpc_cc_library(
     name = "proxy",
-    srcs = ["fixtures/proxy.c"],
+    srcs = ["fixtures/proxy.cc"],
     hdrs = ["fixtures/proxy.h"],
-    language = "C",
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
diff --git a/test/core/end2end/bad_server_response_test.c b/test/core/end2end/bad_server_response_test.cc
index 2070fa5b02..b0c6ae926e 100644
--- a/test/core/end2end/bad_server_response_test.c
+++ b/test/core/end2end/bad_server_response_test.cc
@@ -70,17 +70,17 @@
 #define SERVER_INCOMING_DATA_LENGTH_LOWER_THRESHOLD (size_t)200
 
 struct rpc_state {
-  char *target;
-  grpc_completion_queue *cq;
-  grpc_channel *channel;
-  grpc_call *call;
+  char* target;
+  grpc_completion_queue* cq;
+  grpc_channel* channel;
+  grpc_call* call;
   size_t incoming_data_length;
   grpc_slice_buffer temp_incoming_buffer;
   grpc_slice_buffer outgoing_buffer;
-  grpc_endpoint *tcp;
+  grpc_endpoint* tcp;
   gpr_atm done_atm;
   bool write_done;
-  const char *response_payload;
+  const char* response_payload;
   size_t response_payload_length;
 };
 
@@ -89,15 +89,15 @@ static struct rpc_state state;
 static grpc_closure on_read;
 static grpc_closure on_write;
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
-static void done_write(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
+static void done_write(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
   GPR_ASSERT(error == GRPC_ERROR_NONE);
 
   gpr_atm_rel_store(&state.done_atm, 1);
 }
 
-static void handle_write(grpc_exec_ctx *exec_ctx) {
+static void handle_write(grpc_exec_ctx* exec_ctx) {
   grpc_slice slice = grpc_slice_from_copied_buffer(
       state.response_payload, state.response_payload_length);
 
@@ -106,13 +106,13 @@ static void handle_write(grpc_exec_ctx *exec_ctx) {
   grpc_endpoint_write(exec_ctx, state.tcp, &state.outgoing_buffer, &on_write);
 }
 
-static void handle_read(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
+static void handle_read(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   state.incoming_data_length += state.temp_incoming_buffer.length;
 
   size_t i;
   for (i = 0; i < state.temp_incoming_buffer.count; i++) {
-    char *dump = grpc_dump_slice(state.temp_incoming_buffer.slices[i],
+    char* dump = grpc_dump_slice(state.temp_incoming_buffer.slices[i],
                                  GPR_DUMP_HEX | GPR_DUMP_ASCII);
     gpr_log(GPR_DEBUG, "Server received: %s", dump);
     gpr_free(dump);
@@ -130,13 +130,13 @@ static void handle_read(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
   }
 }
 
-static void on_connect(grpc_exec_ctx *exec_ctx, void *arg, grpc_endpoint *tcp,
-                       grpc_pollset *accepting_pollset,
-                       grpc_tcp_server_acceptor *acceptor) {
+static void on_connect(grpc_exec_ctx* exec_ctx, void* arg, grpc_endpoint* tcp,
+                       grpc_pollset* accepting_pollset,
+                       grpc_tcp_server_acceptor* acceptor) {
   gpr_free(acceptor);
-  test_tcp_server *server = (test_tcp_server *)arg;
-  GRPC_CLOSURE_INIT(&on_read, handle_read, NULL, grpc_schedule_on_exec_ctx);
-  GRPC_CLOSURE_INIT(&on_write, done_write, NULL, grpc_schedule_on_exec_ctx);
+  test_tcp_server* server = (test_tcp_server*)arg;
+  GRPC_CLOSURE_INIT(&on_read, handle_read, nullptr, grpc_schedule_on_exec_ctx);
+  GRPC_CLOSURE_INIT(&on_write, done_write, nullptr, grpc_schedule_on_exec_ctx);
   grpc_slice_buffer_init(&state.temp_incoming_buffer);
   grpc_slice_buffer_init(&state.outgoing_buffer);
   state.tcp = tcp;
@@ -151,25 +151,25 @@ static gpr_timespec n_sec_deadline(int seconds) {
 }
 
 static void start_rpc(int target_port, grpc_status_code expected_status,
-                      const char *expected_detail) {
+                      const char* expected_detail) {
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_status_code status;
   grpc_call_error error;
-  cq_verifier *cqv;
+  cq_verifier* cqv;
   grpc_slice details;
 
-  state.cq = grpc_completion_queue_create_for_next(NULL);
+  state.cq = grpc_completion_queue_create_for_next(nullptr);
   cqv = cq_verifier_create(state.cq);
   gpr_join_host_port(&state.target, "127.0.0.1", target_port);
-  state.channel = grpc_insecure_channel_create(state.target, NULL, NULL);
+  state.channel = grpc_insecure_channel_create(state.target, nullptr, nullptr);
   grpc_slice host = grpc_slice_from_static_string("localhost");
   state.call = grpc_channel_create_call(
-      state.channel, NULL, GRPC_PROPAGATE_DEFAULTS, state.cq,
+      state.channel, nullptr, GRPC_PROPAGATE_DEFAULTS, state.cq,
       grpc_slice_from_static_string("/Service/Method"), &host,
-      gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+      gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
 
   grpc_metadata_array_init(&initial_metadata_recv);
   grpc_metadata_array_init(&trailing_metadata_recv);
@@ -179,26 +179,26 @@ static void start_rpc(int target_port, grpc_status_code expected_status,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error =
-      grpc_call_start_batch(state.call, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(state.call, ops, (size_t)(op - ops), tag(1),
+                                nullptr);
 
   GPR_ASSERT(GRPC_CALL_OK == error);
 
@@ -206,7 +206,7 @@ static void start_rpc(int target_port, grpc_status_code expected_status,
   cq_verify(cqv);
 
   GPR_ASSERT(status == expected_status);
-  if (expected_detail != NULL) {
+  if (expected_detail != nullptr) {
     GPR_ASSERT(-1 != grpc_slice_slice(details, grpc_slice_from_static_string(
                                                    expected_detail)));
   }
@@ -217,14 +217,14 @@ static void start_rpc(int target_port, grpc_status_code expected_status,
   cq_verifier_destroy(cqv);
 }
 
-static void cleanup_rpc(grpc_exec_ctx *exec_ctx) {
+static void cleanup_rpc(grpc_exec_ctx* exec_ctx) {
   grpc_event ev;
   grpc_slice_buffer_destroy_internal(exec_ctx, &state.temp_incoming_buffer);
   grpc_slice_buffer_destroy_internal(exec_ctx, &state.outgoing_buffer);
   grpc_call_unref(state.call);
   grpc_completion_queue_shutdown(state.cq);
   do {
-    ev = grpc_completion_queue_next(state.cq, n_sec_deadline(1), NULL);
+    ev = grpc_completion_queue_next(state.cq, n_sec_deadline(1), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
   grpc_completion_queue_destroy(state.cq);
   grpc_channel_destroy(state.channel);
@@ -232,12 +232,12 @@ static void cleanup_rpc(grpc_exec_ctx *exec_ctx) {
 }
 
 typedef struct {
-  test_tcp_server *server;
-  gpr_event *signal_when_done;
+  test_tcp_server* server;
+  gpr_event* signal_when_done;
 } poll_args;
 
-static void actually_poll_server(void *arg) {
-  poll_args *pa = (poll_args *)arg;
+static void actually_poll_server(void* arg) {
+  poll_args* pa = (poll_args*)arg;
   gpr_timespec deadline = n_sec_deadline(10);
   while (true) {
     bool done = gpr_atm_acq_load(&state.done_atm) != 0;
@@ -250,25 +250,25 @@ static void actually_poll_server(void *arg) {
     }
     test_tcp_server_poll(pa->server, 1);
   }
-  gpr_event_set(pa->signal_when_done, (void *)1);
+  gpr_event_set(pa->signal_when_done, (void*)1);
   gpr_free(pa);
 }
 
-static void poll_server_until_read_done(test_tcp_server *server,
-                                        gpr_event *signal_when_done) {
+static void poll_server_until_read_done(test_tcp_server* server,
+                                        gpr_event* signal_when_done) {
   gpr_atm_rel_store(&state.done_atm, 0);
   state.write_done = 0;
   gpr_thd_id id;
-  poll_args *pa = (poll_args *)gpr_malloc(sizeof(*pa));
+  poll_args* pa = (poll_args*)gpr_malloc(sizeof(*pa));
   pa->server = server;
   pa->signal_when_done = signal_when_done;
-  gpr_thd_new(&id, actually_poll_server, pa, NULL);
+  gpr_thd_new(&id, actually_poll_server, pa, nullptr);
 }
 
-static void run_test(const char *response_payload,
+static void run_test(const char* response_payload,
                      size_t response_payload_length,
                      grpc_status_code expected_status,
-                     const char *expected_detail) {
+                     const char* expected_detail) {
   test_tcp_server test_server;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   gpr_event ev;
@@ -297,7 +297,7 @@ static void run_test(const char *response_payload,
   grpc_shutdown();
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
 
   /* status defined in hpack static table */
@@ -331,7 +331,7 @@ int main(int argc, char **argv) {
 
   /* unparseable response */
   run_test(UNPARSEABLE_RESP, sizeof(UNPARSEABLE_RESP) - 1, GRPC_STATUS_UNKNOWN,
-           NULL);
+           nullptr);
 
   /* http1 response */
   run_test(HTTP1_RESP, sizeof(HTTP1_RESP) - 1, GRPC_STATUS_UNAVAILABLE,
diff --git a/test/core/end2end/connection_refused_test.c b/test/core/end2end/connection_refused_test.cc
index 40227dece4..f3f2dda91d 100644
--- a/test/core/end2end/connection_refused_test.c
+++ b/test/core/end2end/connection_refused_test.cc
@@ -33,15 +33,15 @@
 #include "test/core/util/port.h"
 #include "test/core/util/test_config.h"
 
-static void *tag(intptr_t i) { return (void *)i; }
+static void* tag(intptr_t i) { return (void*)i; }
 
 static void run_test(bool wait_for_ready, bool use_service_config) {
-  grpc_channel *chan;
-  grpc_call *call;
-  grpc_completion_queue *cq;
-  cq_verifier *cqv;
+  grpc_channel* chan;
+  grpc_call* call;
+  grpc_completion_queue* cq;
+  cq_verifier* cqv;
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array trailing_metadata_recv;
   grpc_status_code status;
   grpc_slice details;
@@ -53,17 +53,17 @@ static void run_test(bool wait_for_ready, bool use_service_config) {
 
   grpc_metadata_array_init(&trailing_metadata_recv);
 
-  cq = grpc_completion_queue_create_for_next(NULL);
+  cq = grpc_completion_queue_create_for_next(nullptr);
   cqv = cq_verifier_create(cq);
 
   /* if using service config, create channel args */
-  grpc_channel_args *args = NULL;
+  grpc_channel_args* args = nullptr;
   if (use_service_config) {
     GPR_ASSERT(wait_for_ready);
     grpc_arg arg;
     arg.type = GRPC_ARG_STRING;
-    arg.key = GRPC_ARG_SERVICE_CONFIG;
-    arg.value.string =
+    arg.key = const_cast<char*>(GRPC_ARG_SERVICE_CONFIG);
+    arg.value.string = const_cast<char*>(
         "{\n"
         "  \"methodConfig\": [ {\n"
         "    \"name\": [\n"
@@ -71,21 +71,22 @@ static void run_test(bool wait_for_ready, bool use_service_config) {
         "    ],\n"
         "    \"waitForReady\": true\n"
         "  } ]\n"
-        "}";
+        "}");
     args = grpc_channel_args_copy_and_add(args, &arg, 1);
   }
 
   /* create a call, channel to a port which will refuse connection */
   int port = grpc_pick_unused_port_or_die();
-  char *addr;
+  char* addr;
   gpr_join_host_port(&addr, "127.0.0.1", port);
   gpr_log(GPR_INFO, "server: %s", addr);
-  chan = grpc_insecure_channel_create(addr, args, NULL);
+  chan = grpc_insecure_channel_create(addr, args, nullptr);
   grpc_slice host = grpc_slice_from_static_string("nonexistant");
   gpr_timespec deadline = grpc_timeout_seconds_to_deadline(2);
-  call = grpc_channel_create_call(
-      chan, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
-      grpc_slice_from_static_string("/service/method"), &host, deadline, NULL);
+  call =
+      grpc_channel_create_call(chan, nullptr, GRPC_PROPAGATE_DEFAULTS, cq,
+                               grpc_slice_from_static_string("/service/method"),
+                               &host, deadline, nullptr);
 
   gpr_free(addr);
 
@@ -96,17 +97,18 @@ static void run_test(bool wait_for_ready, bool use_service_config) {
   op->flags = (wait_for_ready && !use_service_config)
                   ? GRPC_INITIAL_METADATA_WAIT_FOR_READY
                   : 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(
-                                 call, ops, (size_t)(op - ops), tag(1), NULL));
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(call, ops,
+                                                   (size_t)(op - ops), tag(1),
+                                                   nullptr));
   /* verify that all tags get completed */
   CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
   cq_verify(cqv);
@@ -118,9 +120,9 @@ static void run_test(bool wait_for_ready, bool use_service_config) {
   }
 
   grpc_completion_queue_shutdown(cq);
-  while (
-      grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL)
-          .type != GRPC_QUEUE_SHUTDOWN)
+  while (grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME),
+                                    nullptr)
+             .type != GRPC_QUEUE_SHUTDOWN)
     ;
   grpc_completion_queue_destroy(cq);
   grpc_call_unref(call);
@@ -132,14 +134,14 @@ static void run_test(bool wait_for_ready, bool use_service_config) {
 
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    if (args != NULL) grpc_channel_args_destroy(&exec_ctx, args);
+    if (args != nullptr) grpc_channel_args_destroy(&exec_ctx, args);
     grpc_exec_ctx_finish(&exec_ctx);
   }
 
   grpc_shutdown();
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   run_test(false /* wait_for_ready */, false /* use_service_config */);
   run_test(true /* wait_for_ready */, false /* use_service_config */);
diff --git a/test/core/end2end/cq_verifier.c b/test/core/end2end/cq_verifier.cc
index bb978923b2..8686f4e7b7 100644
--- a/test/core/end2end/cq_verifier.c
+++ b/test/core/end2end/cq_verifier.cc
@@ -38,43 +38,43 @@
 typedef struct metadata {
   size_t count;
   size_t cap;
-  char **keys;
-  char **values;
+  char** keys;
+  char** values;
 } metadata;
 
 /* details what we expect to find on a single event - and forms a linked
    list to detail other expectations */
 typedef struct expectation {
-  struct expectation *next;
-  const char *file;
+  struct expectation* next;
+  const char* file;
   int line;
   grpc_completion_type type;
-  void *tag;
+  void* tag;
   int success;
 } expectation;
 
 /* the verifier itself */
 struct cq_verifier {
   /* bound completion queue */
-  grpc_completion_queue *cq;
+  grpc_completion_queue* cq;
   /* start of expectation list */
-  expectation *first_expectation;
+  expectation* first_expectation;
 };
 
-cq_verifier *cq_verifier_create(grpc_completion_queue *cq) {
-  cq_verifier *v = (cq_verifier *)gpr_malloc(sizeof(cq_verifier));
+cq_verifier* cq_verifier_create(grpc_completion_queue* cq) {
+  cq_verifier* v = (cq_verifier*)gpr_malloc(sizeof(cq_verifier));
   v->cq = cq;
-  v->first_expectation = NULL;
+  v->first_expectation = nullptr;
   return v;
 }
 
-void cq_verifier_destroy(cq_verifier *v) {
+void cq_verifier_destroy(cq_verifier* v) {
   cq_verify(v);
   gpr_free(v);
 }
 
-static int has_metadata(const grpc_metadata *md, size_t count, const char *key,
-                        const char *value) {
+static int has_metadata(const grpc_metadata* md, size_t count, const char* key,
+                        const char* value) {
   size_t i;
   for (i = 0; i < count; i++) {
     if (0 == grpc_slice_str_cmp(md[i].key, key) &&
@@ -85,12 +85,12 @@ static int has_metadata(const grpc_metadata *md, size_t count, const char *key,
   return 0;
 }
 
-int contains_metadata(grpc_metadata_array *array, const char *key,
-                      const char *value) {
+int contains_metadata(grpc_metadata_array* array, const char* key,
+                      const char* value) {
   return has_metadata(array->metadata, array->count, key, value);
 }
 
-static int has_metadata_slices(const grpc_metadata *md, size_t count,
+static int has_metadata_slices(const grpc_metadata* md, size_t count,
                                grpc_slice key, grpc_slice value) {
   size_t i;
   for (i = 0; i < count; i++) {
@@ -101,15 +101,15 @@ static int has_metadata_slices(const grpc_metadata *md, size_t count,
   return 0;
 }
 
-int contains_metadata_slices(grpc_metadata_array *array, grpc_slice key,
+int contains_metadata_slices(grpc_metadata_array* array, grpc_slice key,
                              grpc_slice value) {
   return has_metadata_slices(array->metadata, array->count, key, value);
 }
 
-static grpc_slice merge_slices(grpc_slice *slices, size_t nslices) {
+static grpc_slice merge_slices(grpc_slice* slices, size_t nslices) {
   size_t i;
   size_t len = 0;
-  uint8_t *cursor;
+  uint8_t* cursor;
   grpc_slice out;
 
   for (i = 0; i < nslices; i++) {
@@ -128,7 +128,7 @@ static grpc_slice merge_slices(grpc_slice *slices, size_t nslices) {
   return out;
 }
 
-int raw_byte_buffer_eq_slice(grpc_byte_buffer *rbb, grpc_slice b) {
+int raw_byte_buffer_eq_slice(grpc_byte_buffer* rbb, grpc_slice b) {
   grpc_slice a;
   int ok;
 
@@ -144,9 +144,9 @@ int raw_byte_buffer_eq_slice(grpc_byte_buffer *rbb, grpc_slice b) {
   return ok;
 }
 
-int byte_buffer_eq_slice(grpc_byte_buffer *bb, grpc_slice b) {
+int byte_buffer_eq_slice(grpc_byte_buffer* bb, grpc_slice b) {
   grpc_byte_buffer_reader reader;
-  grpc_byte_buffer *rbb;
+  grpc_byte_buffer* rbb;
   int res;
 
   GPR_ASSERT(grpc_byte_buffer_reader_init(&reader, bb) &&
@@ -159,9 +159,9 @@ int byte_buffer_eq_slice(grpc_byte_buffer *bb, grpc_slice b) {
   return res;
 }
 
-int byte_buffer_eq_string(grpc_byte_buffer *bb, const char *str) {
+int byte_buffer_eq_string(grpc_byte_buffer* bb, const char* str) {
   grpc_byte_buffer_reader reader;
-  grpc_byte_buffer *rbb;
+  grpc_byte_buffer* rbb;
   int res;
 
   GPR_ASSERT(grpc_byte_buffer_reader_init(&reader, bb) &&
@@ -174,10 +174,10 @@ int byte_buffer_eq_string(grpc_byte_buffer *bb, const char *str) {
   return res;
 }
 
-static bool is_probably_integer(void *p) { return ((uintptr_t)p) < 1000000; }
+static bool is_probably_integer(void* p) { return ((uintptr_t)p) < 1000000; }
 
-static void expectation_to_strvec(gpr_strvec *buf, expectation *e) {
-  char *tmp;
+static void expectation_to_strvec(gpr_strvec* buf, expectation* e) {
+  char* tmp;
 
   if (is_probably_integer(e->tag)) {
     gpr_asprintf(&tmp, "tag(%" PRIdPTR ") ", (intptr_t)e->tag);
@@ -200,29 +200,29 @@ static void expectation_to_strvec(gpr_strvec *buf, expectation *e) {
   }
 }
 
-static void expectations_to_strvec(gpr_strvec *buf, cq_verifier *v) {
-  expectation *e;
+static void expectations_to_strvec(gpr_strvec* buf, cq_verifier* v) {
+  expectation* e;
 
-  for (e = v->first_expectation; e != NULL; e = e->next) {
+  for (e = v->first_expectation; e != nullptr; e = e->next) {
     expectation_to_strvec(buf, e);
     gpr_strvec_add(buf, gpr_strdup("\n"));
   }
 }
 
-static void fail_no_event_received(cq_verifier *v) {
+static void fail_no_event_received(cq_verifier* v) {
   gpr_strvec buf;
-  char *msg;
+  char* msg;
   gpr_strvec_init(&buf);
   gpr_strvec_add(&buf, gpr_strdup("no event received, but expected:\n"));
   expectations_to_strvec(&buf, v);
-  msg = gpr_strvec_flatten(&buf, NULL);
+  msg = gpr_strvec_flatten(&buf, nullptr);
   gpr_log(GPR_ERROR, "%s", msg);
   gpr_strvec_destroy(&buf);
   gpr_free(msg);
   abort();
 }
 
-static void verify_matches(expectation *e, grpc_event *ev) {
+static void verify_matches(expectation* e, grpc_event* ev) {
   GPR_ASSERT(e->type == ev->type);
   switch (e->type) {
     case GRPC_OP_COMPLETE:
@@ -230,7 +230,7 @@ static void verify_matches(expectation *e, grpc_event *ev) {
         gpr_strvec expected;
         gpr_strvec_init(&expected);
         expectation_to_strvec(&expected, e);
-        char *s = gpr_strvec_flatten(&expected, NULL);
+        char* s = gpr_strvec_flatten(&expected, nullptr);
         gpr_strvec_destroy(&expected);
         gpr_log(GPR_ERROR, "actual success does not match expected: %s", s);
         gpr_free(s);
@@ -248,34 +248,34 @@ static void verify_matches(expectation *e, grpc_event *ev) {
   }
 }
 
-void cq_verify(cq_verifier *v) {
+void cq_verify(cq_verifier* v) {
   const gpr_timespec deadline = grpc_timeout_seconds_to_deadline(10);
-  while (v->first_expectation != NULL) {
-    grpc_event ev = grpc_completion_queue_next(v->cq, deadline, NULL);
+  while (v->first_expectation != nullptr) {
+    grpc_event ev = grpc_completion_queue_next(v->cq, deadline, nullptr);
     if (ev.type == GRPC_QUEUE_TIMEOUT) {
       fail_no_event_received(v);
       break;
     }
-    expectation *e;
-    expectation *prev = NULL;
-    for (e = v->first_expectation; e != NULL; e = e->next) {
+    expectation* e;
+    expectation* prev = nullptr;
+    for (e = v->first_expectation; e != nullptr; e = e->next) {
       if (e->tag == ev.tag) {
         verify_matches(e, &ev);
         if (e == v->first_expectation) v->first_expectation = e->next;
-        if (prev != NULL) prev->next = e->next;
+        if (prev != nullptr) prev->next = e->next;
         gpr_free(e);
         break;
       }
       prev = e;
     }
-    if (e == NULL) {
-      char *s = grpc_event_string(&ev);
+    if (e == nullptr) {
+      char* s = grpc_event_string(&ev);
       gpr_log(GPR_ERROR, "cq returned unexpected event: %s", s);
       gpr_free(s);
       gpr_strvec expectations;
       gpr_strvec_init(&expectations);
       expectations_to_strvec(&expectations, v);
-      s = gpr_strvec_flatten(&expectations, NULL);
+      s = gpr_strvec_flatten(&expectations, nullptr);
       gpr_strvec_destroy(&expectations);
       gpr_log(GPR_ERROR, "expected tags:\n%s", s);
       gpr_free(s);
@@ -284,28 +284,29 @@ void cq_verify(cq_verifier *v) {
   }
 }
 
-void cq_verify_empty_timeout(cq_verifier *v, int timeout_sec) {
+void cq_verify_empty_timeout(cq_verifier* v, int timeout_sec) {
   gpr_timespec deadline =
       gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
                    gpr_time_from_seconds(timeout_sec, GPR_TIMESPAN));
   grpc_event ev;
 
-  GPR_ASSERT(v->first_expectation == NULL && "expectation queue must be empty");
+  GPR_ASSERT(v->first_expectation == nullptr &&
+             "expectation queue must be empty");
 
-  ev = grpc_completion_queue_next(v->cq, deadline, NULL);
+  ev = grpc_completion_queue_next(v->cq, deadline, nullptr);
   if (ev.type != GRPC_QUEUE_TIMEOUT) {
-    char *s = grpc_event_string(&ev);
+    char* s = grpc_event_string(&ev);
     gpr_log(GPR_ERROR, "unexpected event (expected nothing): %s", s);
     gpr_free(s);
     abort();
   }
 }
 
-void cq_verify_empty(cq_verifier *v) { cq_verify_empty_timeout(v, 1); }
+void cq_verify_empty(cq_verifier* v) { cq_verify_empty_timeout(v, 1); }
 
-static void add(cq_verifier *v, const char *file, int line,
-                grpc_completion_type type, void *tag, bool success) {
-  expectation *e = (expectation *)gpr_malloc(sizeof(expectation));
+static void add(cq_verifier* v, const char* file, int line,
+                grpc_completion_type type, void* tag, bool success) {
+  expectation* e = (expectation*)gpr_malloc(sizeof(expectation));
   e->type = type;
   e->file = file;
   e->line = line;
@@ -315,7 +316,7 @@ static void add(cq_verifier *v, const char *file, int line,
   v->first_expectation = e;
 }
 
-void cq_expect_completion(cq_verifier *v, const char *file, int line, void *tag,
+void cq_expect_completion(cq_verifier* v, const char* file, int line, void* tag,
                           bool success) {
   add(v, file, line, GRPC_OP_COMPLETE, tag, success);
 }
diff --git a/test/core/end2end/cq_verifier.h b/test/core/end2end/cq_verifier.h
index cc80b58c90..0b3b3fb349 100644
--- a/test/core/end2end/cq_verifier.h
+++ b/test/core/end2end/cq_verifier.h
@@ -24,39 +24,47 @@
 #include <grpc/grpc.h>
 #include "test/core/util/test_config.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* A cq_verifier can verify that expected events arrive in a timely fashion
    on a single completion queue */
 
 typedef struct cq_verifier cq_verifier;
 
 /* construct/destroy a cq_verifier */
-cq_verifier *cq_verifier_create(grpc_completion_queue *cq);
-void cq_verifier_destroy(cq_verifier *v);
+cq_verifier* cq_verifier_create(grpc_completion_queue* cq);
+void cq_verifier_destroy(cq_verifier* v);
 
 /* ensure all expected events (and only those events) are present on the
    bound completion queue */
-void cq_verify(cq_verifier *v);
+void cq_verify(cq_verifier* v);
 
 /* ensure that the completion queue is empty */
-void cq_verify_empty(cq_verifier *v);
+void cq_verify_empty(cq_verifier* v);
 
 /* ensure that the completion queue is empty, waiting up to \a timeout secs. */
-void cq_verify_empty_timeout(cq_verifier *v, int timeout_sec);
+void cq_verify_empty_timeout(cq_verifier* v, int timeout_sec);
 
 /* Various expectation matchers
    Any functions taking ... expect a NULL terminated list of key/value pairs
    (each pair using two parameter slots) of metadata that MUST be present in
    the event. */
-void cq_expect_completion(cq_verifier *v, const char *file, int line, void *tag,
+void cq_expect_completion(cq_verifier* v, const char* file, int line, void* tag,
                           bool success);
 #define CQ_EXPECT_COMPLETION(v, tag, success) \
   cq_expect_completion(v, __FILE__, __LINE__, tag, success)
 
-int byte_buffer_eq_slice(grpc_byte_buffer *bb, grpc_slice b);
-int byte_buffer_eq_string(grpc_byte_buffer *byte_buffer, const char *string);
-int contains_metadata(grpc_metadata_array *array, const char *key,
-                      const char *value);
-int contains_metadata_slices(grpc_metadata_array *array, grpc_slice key,
+int byte_buffer_eq_slice(grpc_byte_buffer* bb, grpc_slice b);
+int byte_buffer_eq_string(grpc_byte_buffer* byte_buffer, const char* string);
+int contains_metadata(grpc_metadata_array* array, const char* key,
+                      const char* value);
+int contains_metadata_slices(grpc_metadata_array* array, grpc_slice key,
                              grpc_slice value);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_TEST_CORE_END2END_CQ_VERIFIER_H */
diff --git a/test/core/end2end/cq_verifier_internal.h b/test/core/end2end/cq_verifier_internal.h
index 0aa8dc6b1c..0629e0e5a7 100644
--- a/test/core/end2end/cq_verifier_internal.h
+++ b/test/core/end2end/cq_verifier_internal.h
@@ -23,10 +23,10 @@
 
 typedef struct expectation expectation;
 
-expectation *cq_verifier_get_first_expectation(cq_verifier *v);
+expectation* cq_verifier_get_first_expectation(cq_verifier* v);
 
-void cq_verifier_set_first_expectation(cq_verifier *v, expectation *e);
+void cq_verifier_set_first_expectation(cq_verifier* v, expectation* e);
 
-grpc_event cq_verifier_next_event(cq_verifier *v, int timeout_seconds);
+grpc_event cq_verifier_next_event(cq_verifier* v, int timeout_seconds);
 
 #endif /* GRPC_TEST_CORE_END2END_CQ_VERIFIER_INTERNAL_H */
diff --git a/test/core/end2end/cq_verifier_native.c b/test/core/end2end/cq_verifier_native.cc
index f19b15c465..e93956b188 100644
--- a/test/core/end2end/cq_verifier_native.c
+++ b/test/core/end2end/cq_verifier_native.cc
@@ -19,41 +19,42 @@
 /* This check is for testing only. */
 #ifndef GRPC_UV
 
+#include <grpc/support/alloc.h>
+
 #include "test/core/end2end/cq_verifier_internal.h"
 
 /* the verifier itself */
 struct cq_verifier {
   /* bound completion queue */
-  grpc_completion_queue *cq;
+  grpc_completion_queue* cq;
   /* start of expectation list */
-  expectation *first_expectation;
-  uv_timer_t timer;
+  expectation* first_expectation;
 };
 
-cq_verifier *cq_verifier_create(grpc_completion_queue *cq) {
-  cq_verifier *v = gpr_malloc(sizeof(cq_verifier));
+cq_verifier* cq_verifier_create(grpc_completion_queue* cq) {
+  cq_verifier* v = static_cast<cq_verifier*>(gpr_malloc(sizeof(cq_verifier)));
   v->cq = cq;
-  cq_verifier_set_first_expectation(v, NULL);
+  cq_verifier_set_first_expectation(v, nullptr);
   return v;
 }
 
-void cq_verifier_destroy(cq_verifier *v) {
+void cq_verifier_destroy(cq_verifier* v) {
   cq_verify(v);
   gpr_free(v);
 }
 
-expectation *cq_verifier_get_first_expectation(cq_verifier *v) {
+expectation* cq_verifier_get_first_expectation(cq_verifier* v) {
   return v->first_expectation;
 }
 
-void cq_verifier_set_first_expectation(cq_verifier *v, expectation *e) {
+void cq_verifier_set_first_expectation(cq_verifier* v, expectation* e) {
   v->first_expectation = e;
 }
 
-grpc_event cq_verifier_next_event(cq_verifier *v, int timeout_seconds) {
+grpc_event cq_verifier_next_event(cq_verifier* v, int timeout_seconds) {
   const gpr_timespec deadline =
       grpc_timeout_seconds_to_deadline(timeout_seconds);
-  return grpc_completion_queue_next(v->cq, deadline, NULL);
+  return grpc_completion_queue_next(v->cq, deadline, nullptr);
 }
 
 #endif /* GRPC_UV */
diff --git a/test/core/end2end/cq_verifier_uv.c b/test/core/end2end/cq_verifier_uv.cc
index fc873b784f..e23b3ae2a0 100644
--- a/test/core/end2end/cq_verifier_uv.c
+++ b/test/core/end2end/cq_verifier_uv.cc
@@ -36,56 +36,56 @@ typedef enum timer_state {
 /* the verifier itself */
 struct cq_verifier {
   /* bound completion queue */
-  grpc_completion_queue *cq;
+  grpc_completion_queue* cq;
   /* start of expectation list */
-  expectation *first_expectation;
+  expectation* first_expectation;
   uv_timer_t timer;
 };
 
-cq_verifier *cq_verifier_create(grpc_completion_queue *cq) {
-  cq_verifier *v = gpr_malloc(sizeof(cq_verifier));
+cq_verifier* cq_verifier_create(grpc_completion_queue* cq) {
+  cq_verifier* v = static_cast<cq_verifier*>(gpr_malloc(sizeof(cq_verifier)));
   v->cq = cq;
   v->first_expectation = NULL;
   uv_timer_init(uv_default_loop(), &v->timer);
-  v->timer.data = (void *)TIMER_STARTED;
+  v->timer.data = (void*)TIMER_STARTED;
   return v;
 }
 
-static void timer_close_cb(uv_handle_t *handle) {
-  handle->data = (void *)TIMER_CLOSED;
+static void timer_close_cb(uv_handle_t* handle) {
+  handle->data = (void*)TIMER_CLOSED;
 }
 
-void cq_verifier_destroy(cq_verifier *v) {
+void cq_verifier_destroy(cq_verifier* v) {
   cq_verify(v);
-  uv_close((uv_handle_t *)&v->timer, timer_close_cb);
-  while ((timer_state)v->timer.data != TIMER_CLOSED) {
+  uv_close((uv_handle_t*)&v->timer, timer_close_cb);
+  while (reinterpret_cast<timer_state>(v->timer.data) != TIMER_CLOSED) {
     uv_run(uv_default_loop(), UV_RUN_NOWAIT);
   }
   gpr_free(v);
 }
 
-expectation *cq_verifier_get_first_expectation(cq_verifier *v) {
+expectation* cq_verifier_get_first_expectation(cq_verifier* v) {
   return v->first_expectation;
 }
 
-void cq_verifier_set_first_expectation(cq_verifier *v, expectation *e) {
+void cq_verifier_set_first_expectation(cq_verifier* v, expectation* e) {
   v->first_expectation = e;
 }
 
-static void timer_run_cb(uv_timer_t *timer) {
-  timer->data = (void *)TIMER_TRIGGERED;
+static void timer_run_cb(uv_timer_t* timer) {
+  timer->data = (void*)TIMER_TRIGGERED;
 }
 
-grpc_event cq_verifier_next_event(cq_verifier *v, int timeout_seconds) {
+grpc_event cq_verifier_next_event(cq_verifier* v, int timeout_seconds) {
   uint64_t timeout_ms =
       timeout_seconds < 0 ? 0 : (uint64_t)timeout_seconds * 1000;
   grpc_event ev;
-  v->timer.data = (void *)TIMER_STARTED;
+  v->timer.data = (void*)TIMER_STARTED;
   uv_timer_start(&v->timer, timer_run_cb, timeout_ms, 0);
   ev = grpc_completion_queue_next(v->cq, gpr_inf_past(GPR_CLOCK_MONOTONIC),
                                   NULL);
   // Stop the loop if the timer goes off or we get a non-timeout event
-  while (((timer_state)v->timer.data != TIMER_TRIGGERED) &&
+  while ((reinterpret_cast<timer_state>(v->timer.data) != TIMER_TRIGGERED) &&
          ev.type == GRPC_QUEUE_TIMEOUT) {
     uv_run(uv_default_loop(), UV_RUN_ONCE);
     ev = grpc_completion_queue_next(v->cq, gpr_inf_past(GPR_CLOCK_MONOTONIC),
diff --git a/test/core/end2end/data/client_certs.c b/test/core/end2end/data/client_certs.cc
index 78770674c4..7e0b10da5c 100644
--- a/test/core/end2end/data/client_certs.c
+++ b/test/core/end2end/data/client_certs.cc
@@ -16,7 +16,7 @@
  *
  */
 
-const char test_self_signed_client_cert[] = {
+extern "C" const char test_self_signed_client_cert[] = {
     0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20, 0x43,
     0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d,
     0x2d, 0x2d, 0x2d, 0x0a, 0x4d, 0x49, 0x49, 0x43, 0x6f, 0x44, 0x43, 0x43,
@@ -100,7 +100,7 @@ const char test_self_signed_client_cert[] = {
     0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
     0x0a, 0x00};
 
-const char test_self_signed_client_key[] = {
+extern "C" const char test_self_signed_client_key[] = {
     0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20, 0x50,
     0x52, 0x49, 0x56, 0x41, 0x54, 0x45, 0x20, 0x4b, 0x45, 0x59, 0x2d, 0x2d,
     0x2d, 0x2d, 0x2d, 0x0a, 0x4d, 0x49, 0x49, 0x43, 0x64, 0x77, 0x49, 0x42,
@@ -179,7 +179,7 @@ const char test_self_signed_client_key[] = {
     0x52, 0x49, 0x56, 0x41, 0x54, 0x45, 0x20, 0x4b, 0x45, 0x59, 0x2d, 0x2d,
     0x2d, 0x2d, 0x2d, 0x0a, 0x00};
 
-const char test_signed_client_cert[] = {
+extern "C" const char test_signed_client_cert[] = {
     0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20, 0x43,
     0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d,
     0x2d, 0x2d, 0x2d, 0x0a, 0x4d, 0x49, 0x49, 0x43, 0x48, 0x7a, 0x43, 0x43,
@@ -248,7 +248,7 @@ const char test_signed_client_cert[] = {
     0x20, 0x43, 0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45,
     0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x00};
 
-const char test_signed_client_key[] = {
+extern "C" const char test_signed_client_key[] = {
     0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20, 0x50,
     0x52, 0x49, 0x56, 0x41, 0x54, 0x45, 0x20, 0x4b, 0x45, 0x59, 0x2d, 0x2d,
     0x2d, 0x2d, 0x2d, 0x0a, 0x4d, 0x49, 0x49, 0x43, 0x65, 0x51, 0x49, 0x42,
diff --git a/test/core/end2end/data/server1_cert.c b/test/core/end2end/data/server1_cert.cc
index 8d149607b6..dd09810732 100644
--- a/test/core/end2end/data/server1_cert.c
+++ b/test/core/end2end/data/server1_cert.cc
@@ -16,7 +16,7 @@
  *
  */
 
-const char test_server1_cert[] = {
+extern "C" const char test_server1_cert[] = {
     0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20, 0x43,
     0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d,
     0x2d, 0x2d, 0x2d, 0x0a, 0x4d, 0x49, 0x49, 0x43, 0x6e, 0x44, 0x43, 0x43,
diff --git a/test/core/end2end/data/server1_key.c b/test/core/end2end/data/server1_key.cc
index eee5cc6d82..59dcaf6334 100644
--- a/test/core/end2end/data/server1_key.c
+++ b/test/core/end2end/data/server1_key.cc
@@ -16,7 +16,7 @@
  *
  */
 
-const char test_server1_key[] = {
+extern "C" const char test_server1_key[] = {
     0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20, 0x52,
     0x53, 0x41, 0x20, 0x50, 0x52, 0x49, 0x56, 0x41, 0x54, 0x45, 0x20, 0x4b,
     0x45, 0x59, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x4d, 0x49, 0x49, 0x43,
diff --git a/test/core/end2end/data/test_root_cert.c b/test/core/end2end/data/test_root_cert.cc
index ef39ca56ab..36fca2e45f 100644
--- a/test/core/end2end/data/test_root_cert.c
+++ b/test/core/end2end/data/test_root_cert.cc
@@ -16,7 +16,7 @@
  *
  */
 
-const char test_root_cert[] = {
+extern "C" const char test_root_cert[] = {
     0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20, 0x43,
     0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d,
     0x2d, 0x2d, 0x2d, 0x0a, 0x4d, 0x49, 0x49, 0x43, 0x49, 0x7a, 0x43, 0x43,
diff --git a/test/core/end2end/dualstack_socket_test.c b/test/core/end2end/dualstack_socket_test.cc
index f9150f145a..ad2b24fdb0 100644
--- a/test/core/end2end/dualstack_socket_test.c
+++ b/test/core/end2end/dualstack_socket_test.cc
@@ -39,36 +39,36 @@
 
 /* This test exercises IPv4, IPv6, and dualstack sockets in various ways. */
 
-static void *tag(intptr_t i) { return (void *)i; }
+static void* tag(intptr_t i) { return (void*)i; }
 
 static gpr_timespec ms_from_now(int ms) {
   return grpc_timeout_milliseconds_to_deadline(ms);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, ms_from_now(5000), NULL);
+    ev = grpc_completion_queue_next(cq, ms_from_now(5000), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void do_nothing(void *ignored) {}
+static void do_nothing(void* ignored) {}
 
-void test_connect(const char *server_host, const char *client_host, int port,
+void test_connect(const char* server_host, const char* client_host, int port,
                   int expect_ok) {
-  char *client_hostport;
-  char *server_hostport;
-  grpc_channel *client;
-  grpc_server *server;
-  grpc_completion_queue *cq;
-  grpc_completion_queue *shutdown_cq;
-  grpc_call *c;
-  grpc_call *s;
-  cq_verifier *cqv;
+  char* client_hostport;
+  char* server_hostport;
+  grpc_channel* client;
+  grpc_server* server;
+  grpc_completion_queue* cq;
+  grpc_completion_queue* shutdown_cq;
+  grpc_call* c;
+  grpc_call* s;
+  cq_verifier* cqv;
   gpr_timespec deadline;
   int got_port;
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -77,7 +77,7 @@ void test_connect(const char *server_host, const char *client_host, int port,
   grpc_slice details;
   int was_cancelled = 2;
   grpc_call_details call_details;
-  char *peer;
+  char* peer;
   int picked_port = 0;
 
   if (port == 0) {
@@ -93,9 +93,9 @@ void test_connect(const char *server_host, const char *client_host, int port,
   grpc_call_details_init(&call_details);
 
   /* Create server. */
-  cq = grpc_completion_queue_create_for_next(NULL);
-  server = grpc_server_create(NULL, NULL);
-  grpc_server_register_completion_queue(server, cq, NULL);
+  cq = grpc_completion_queue_create_for_next(nullptr);
+  server = grpc_server_create(nullptr, nullptr);
+  grpc_server_register_completion_queue(server, cq, nullptr);
   GPR_ASSERT((got_port = grpc_server_add_insecure_http2_port(
                   server, server_hostport)) > 0);
   if (port == 0) {
@@ -112,20 +112,21 @@ void test_connect(const char *server_host, const char *client_host, int port,
     size_t i;
     grpc_slice uri_slice;
     grpc_slice_buffer uri_parts;
-    char **hosts_with_port;
+    char** hosts_with_port;
 
     uri_slice =
-        grpc_slice_new((char *)client_host, strlen(client_host), do_nothing);
+        grpc_slice_new((char*)client_host, strlen(client_host), do_nothing);
     grpc_slice_buffer_init(&uri_parts);
     grpc_slice_split(uri_slice, ",", &uri_parts);
-    hosts_with_port = gpr_malloc(sizeof(char *) * uri_parts.count);
+    hosts_with_port =
+        static_cast<char**>(gpr_malloc(sizeof(char*) * uri_parts.count));
     for (i = 0; i < uri_parts.count; i++) {
-      char *uri_part_str = grpc_slice_to_c_string(uri_parts.slices[i]);
+      char* uri_part_str = grpc_slice_to_c_string(uri_parts.slices[i]);
       gpr_asprintf(&hosts_with_port[i], "%s:%d", uri_part_str, port);
       gpr_free(uri_part_str);
     }
-    client_hostport = gpr_strjoin_sep((const char **)hosts_with_port,
-                                      uri_parts.count, ",", NULL);
+    client_hostport = gpr_strjoin_sep((const char**)hosts_with_port,
+                                      uri_parts.count, ",", nullptr);
     for (i = 0; i < uri_parts.count; i++) {
       gpr_free(hosts_with_port[i]);
     }
@@ -135,7 +136,7 @@ void test_connect(const char *server_host, const char *client_host, int port,
   } else {
     gpr_join_host_port(&client_hostport, client_host, port);
   }
-  client = grpc_insecure_channel_create(client_hostport, NULL, NULL);
+  client = grpc_insecure_channel_create(client_hostport, nullptr, nullptr);
 
   gpr_log(GPR_INFO, "Testing with server=%s client=%s (expecting %s)",
           server_hostport, client_hostport, expect_ok ? "success" : "failure");
@@ -154,9 +155,9 @@ void test_connect(const char *server_host, const char *client_host, int port,
 
   /* Send a trivial request. */
   grpc_slice host = grpc_slice_from_static_string("foo.test.google.fr");
-  c = grpc_channel_create_call(client, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
+  c = grpc_channel_create_call(client, nullptr, GRPC_PROPAGATE_DEFAULTS, cq,
                                grpc_slice_from_static_string("/foo"), &host,
-                               deadline, NULL);
+                               deadline, nullptr);
   GPR_ASSERT(c);
 
   memset(ops, 0, sizeof(ops));
@@ -164,25 +165,25 @@ void test_connect(const char *server_host, const char *client_host, int port,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = expect_ok ? GRPC_INITIAL_METADATA_WAIT_FOR_READY : 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   if (expect_ok) {
@@ -210,7 +211,8 @@ void test_connect(const char *server_host, const char *client_host, int port,
     op->data.recv_close_on_server.cancelled = &was_cancelled;
     op->flags = 0;
     op++;
-    error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+    error =
+        grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
 
     CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -245,11 +247,11 @@ void test_connect(const char *server_host, const char *client_host, int port,
   grpc_channel_destroy(client);
 
   /* Destroy server. */
-  shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
+  shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
   grpc_server_shutdown_and_notify(server, shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(server);
   grpc_completion_queue_destroy(shutdown_cq);
@@ -268,18 +270,18 @@ void test_connect(const char *server_host, const char *client_host, int port,
   }
 }
 
-int external_dns_works(const char *host) {
-  grpc_resolved_addresses *res = NULL;
-  grpc_error *error = grpc_blocking_resolve_address(host, "80", &res);
+int external_dns_works(const char* host) {
+  grpc_resolved_addresses* res = nullptr;
+  grpc_error* error = grpc_blocking_resolve_address(host, "80", &res);
   GRPC_ERROR_UNREF(error);
-  if (res != NULL) {
+  if (res != nullptr) {
     grpc_resolved_addresses_destroy(res);
     return 1;
   }
   return 0;
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   int do_ipv6 = 1;
 
   grpc_test_init(argc, argv);
@@ -352,6 +354,6 @@ int main(int argc, char **argv) {
 
 #else /* GRPC_POSIX_SOCKET */
 
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
 
 #endif /* GRPC_POSIX_SOCKET */
diff --git a/test/core/end2end/end2end_nosec_tests.c b/test/core/end2end/end2end_nosec_tests.cc
index 3236feea56..3236feea56 100644
--- a/test/core/end2end/end2end_nosec_tests.c
+++ b/test/core/end2end/end2end_nosec_tests.cc
diff --git a/test/core/end2end/end2end_test_utils.c b/test/core/end2end/end2end_test_utils.cc
index c1f119548a..51d2730f0e 100644
--- a/test/core/end2end/end2end_test_utils.c
+++ b/test/core/end2end/end2end_test_utils.cc
@@ -22,27 +22,27 @@
 
 #include <grpc/support/log.h>
 
-const char *get_host_override_string(const char *str,
+const char* get_host_override_string(const char* str,
                                      grpc_end2end_test_config config) {
   if (config.feature_mask & FEATURE_MASK_SUPPORTS_AUTHORITY_HEADER) {
     return str;
   } else {
-    return NULL;
+    return nullptr;
   }
 }
 
-const grpc_slice *get_host_override_slice(const char *str,
+const grpc_slice* get_host_override_slice(const char* str,
                                           grpc_end2end_test_config config) {
-  const char *r = get_host_override_string(str, config);
-  if (r != NULL) {
+  const char* r = get_host_override_string(str, config);
+  if (r != nullptr) {
     static grpc_slice ret;
     ret = grpc_slice_from_static_string(r);
     return &ret;
   }
-  return NULL;
+  return nullptr;
 }
 
-void validate_host_override_string(const char *pattern, grpc_slice str,
+void validate_host_override_string(const char* pattern, grpc_slice str,
                                    grpc_end2end_test_config config) {
   if (config.feature_mask & FEATURE_MASK_SUPPORTS_AUTHORITY_HEADER) {
     GPR_ASSERT(0 == grpc_slice_str_cmp(str, pattern));
diff --git a/test/core/end2end/end2end_tests.c b/test/core/end2end/end2end_tests.cc
index ca9443b642..ca9443b642 100644
--- a/test/core/end2end/end2end_tests.c
+++ b/test/core/end2end/end2end_tests.cc
diff --git a/test/core/end2end/end2end_tests.h b/test/core/end2end/end2end_tests.h
index 87269ec468..33943a7271 100644
--- a/test/core/end2end/end2end_tests.h
+++ b/test/core/end2end/end2end_tests.h
@@ -21,6 +21,10 @@
 
 #include <grpc/grpc.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct grpc_end2end_test_fixture grpc_end2end_test_fixture;
 typedef struct grpc_end2end_test_config grpc_end2end_test_config;
 
@@ -38,40 +42,44 @@ typedef struct grpc_end2end_test_config grpc_end2end_test_config;
 #define FAIL_AUTH_CHECK_SERVER_ARG_NAME "fail_auth_check"
 
 struct grpc_end2end_test_fixture {
-  grpc_completion_queue *cq;
-  grpc_completion_queue *shutdown_cq;
-  grpc_server *server;
-  grpc_channel *client;
-  void *fixture_data;
+  grpc_completion_queue* cq;
+  grpc_completion_queue* shutdown_cq;
+  grpc_server* server;
+  grpc_channel* client;
+  void* fixture_data;
 };
 
 struct grpc_end2end_test_config {
   /* A descriptive name for this test fixture. */
-  const char *name;
+  const char* name;
 
   /* Which features are supported by this fixture. See feature flags above. */
   uint32_t feature_mask;
 
-  grpc_end2end_test_fixture (*create_fixture)(grpc_channel_args *client_args,
-                                              grpc_channel_args *server_args);
-  void (*init_client)(grpc_end2end_test_fixture *f,
-                      grpc_channel_args *client_args);
-  void (*init_server)(grpc_end2end_test_fixture *f,
-                      grpc_channel_args *server_args);
-  void (*tear_down_data)(grpc_end2end_test_fixture *f);
+  grpc_end2end_test_fixture (*create_fixture)(grpc_channel_args* client_args,
+                                              grpc_channel_args* server_args);
+  void (*init_client)(grpc_end2end_test_fixture* f,
+                      grpc_channel_args* client_args);
+  void (*init_server)(grpc_end2end_test_fixture* f,
+                      grpc_channel_args* server_args);
+  void (*tear_down_data)(grpc_end2end_test_fixture* f);
 };
 
 void grpc_end2end_tests_pre_init(void);
-void grpc_end2end_tests(int argc, char **argv, grpc_end2end_test_config config);
+void grpc_end2end_tests(int argc, char** argv, grpc_end2end_test_config config);
 
-const char *get_host_override_string(const char *str,
+const char* get_host_override_string(const char* str,
                                      grpc_end2end_test_config config);
 /* Returns a pointer to a statically allocated slice: future invocations
    overwrite past invocations, not threadsafe, etc... */
-const grpc_slice *get_host_override_slice(const char *str,
+const grpc_slice* get_host_override_slice(const char* str,
                                           grpc_end2end_test_config config);
 
-void validate_host_override_string(const char *pattern, grpc_slice str,
+void validate_host_override_string(const char* pattern, grpc_slice str,
                                    grpc_end2end_test_config config);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_TEST_CORE_END2END_END2END_TESTS_H */
diff --git a/test/core/end2end/fixtures/h2_census.c b/test/core/end2end/fixtures/h2_census.cc
index 9870ccb34a..fed8ead5c8 100644
--- a/test/core/end2end/fixtures/h2_census.c
+++ b/test/core/end2end/fixtures/h2_census.cc
@@ -37,21 +37,22 @@
 #include "test/core/util/test_config.h"
 
 typedef struct fullstack_fixture_data {
-  char *localaddr;
+  char* localaddr;
 } fullstack_fixture_data;
 
 static grpc_end2end_test_fixture chttp2_create_fixture_fullstack(
-    grpc_channel_args *client_args, grpc_channel_args *server_args) {
+    grpc_channel_args* client_args, grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   int port = grpc_pick_unused_port_or_die();
-  fullstack_fixture_data *ffd = gpr_malloc(sizeof(fullstack_fixture_data));
+  fullstack_fixture_data* ffd = static_cast<fullstack_fixture_data*>(
+      gpr_malloc(sizeof(fullstack_fixture_data)));
   memset(&f, 0, sizeof(f));
 
   gpr_join_host_port(&ffd->localaddr, "localhost", port);
 
   f.fixture_data = ffd;
-  f.cq = grpc_completion_queue_create_for_next(NULL);
-  f.shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
+  f.cq = grpc_completion_queue_create_for_next(nullptr);
+  f.shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
 
   return f;
 }
@@ -59,17 +60,19 @@ static grpc_end2end_test_fixture chttp2_create_fixture_fullstack(
 static grpc_arg make_census_enable_arg(void) {
   grpc_arg arg;
   arg.type = GRPC_ARG_INTEGER;
-  arg.key = GRPC_ARG_ENABLE_CENSUS;
+  arg.key = const_cast<char*>(GRPC_ARG_ENABLE_CENSUS);
   arg.value.integer = 1;
   return arg;
 }
 
-void chttp2_init_client_fullstack(grpc_end2end_test_fixture *f,
-                                  grpc_channel_args *client_args) {
-  fullstack_fixture_data *ffd = f->fixture_data;
+void chttp2_init_client_fullstack(grpc_end2end_test_fixture* f,
+                                  grpc_channel_args* client_args) {
+  fullstack_fixture_data* ffd =
+      static_cast<fullstack_fixture_data*>(f->fixture_data);
   grpc_arg arg = make_census_enable_arg();
   client_args = grpc_channel_args_copy_and_add(client_args, &arg, 1);
-  f->client = grpc_insecure_channel_create(ffd->localaddr, client_args, NULL);
+  f->client =
+      grpc_insecure_channel_create(ffd->localaddr, client_args, nullptr);
   GPR_ASSERT(f->client);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -78,41 +81,44 @@ void chttp2_init_client_fullstack(grpc_end2end_test_fixture *f,
   }
 }
 
-void chttp2_init_server_fullstack(grpc_end2end_test_fixture *f,
-                                  grpc_channel_args *server_args) {
-  fullstack_fixture_data *ffd = f->fixture_data;
+void chttp2_init_server_fullstack(grpc_end2end_test_fixture* f,
+                                  grpc_channel_args* server_args) {
+  fullstack_fixture_data* ffd =
+      static_cast<fullstack_fixture_data*>(f->fixture_data);
   grpc_arg arg = make_census_enable_arg();
   if (f->server) {
     grpc_server_destroy(f->server);
   }
   server_args = grpc_channel_args_copy_and_add(server_args, &arg, 1);
-  f->server = grpc_server_create(server_args, NULL);
+  f->server = grpc_server_create(server_args, nullptr);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_channel_args_destroy(&exec_ctx, server_args);
     grpc_exec_ctx_finish(&exec_ctx);
   }
-  grpc_server_register_completion_queue(f->server, f->cq, NULL);
+  grpc_server_register_completion_queue(f->server, f->cq, nullptr);
   GPR_ASSERT(grpc_server_add_insecure_http2_port(f->server, ffd->localaddr));
   grpc_server_start(f->server);
 }
 
-void chttp2_tear_down_fullstack(grpc_end2end_test_fixture *f) {
-  fullstack_fixture_data *ffd = f->fixture_data;
+void chttp2_tear_down_fullstack(grpc_end2end_test_fixture* f) {
+  fullstack_fixture_data* ffd =
+      static_cast<fullstack_fixture_data*>(f->fixture_data);
   gpr_free(ffd->localaddr);
   gpr_free(ffd);
 }
 
 /* All test configurations */
 static grpc_end2end_test_config configs[] = {
-    {"chttp2/fullstack+census", FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION |
-                                    FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL |
-                                    FEATURE_MASK_SUPPORTS_AUTHORITY_HEADER,
+    {"chttp2/fullstack+census",
+     FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION |
+         FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL |
+         FEATURE_MASK_SUPPORTS_AUTHORITY_HEADER,
      chttp2_create_fixture_fullstack, chttp2_init_client_fullstack,
      chttp2_init_server_fullstack, chttp2_tear_down_fullstack},
 };
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   size_t i;
 
   grpc_test_init(argc, argv);
diff --git a/test/core/end2end/fixtures/h2_compress.c b/test/core/end2end/fixtures/h2_compress.cc
index 9866dea7eb..ea8990fd0a 100644
--- a/test/core/end2end/fixtures/h2_compress.c
+++ b/test/core/end2end/fixtures/h2_compress.cc
@@ -37,47 +37,50 @@
 #include "test/core/util/test_config.h"
 
 typedef struct fullstack_compression_fixture_data {
-  char *localaddr;
-  grpc_channel_args *client_args_compression;
-  grpc_channel_args *server_args_compression;
+  char* localaddr;
+  grpc_channel_args* client_args_compression;
+  grpc_channel_args* server_args_compression;
 } fullstack_compression_fixture_data;
 
 static grpc_end2end_test_fixture chttp2_create_fixture_fullstack_compression(
-    grpc_channel_args *client_args, grpc_channel_args *server_args) {
+    grpc_channel_args* client_args, grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   int port = grpc_pick_unused_port_or_die();
-  fullstack_compression_fixture_data *ffd =
-      gpr_malloc(sizeof(fullstack_compression_fixture_data));
+  fullstack_compression_fixture_data* ffd =
+      static_cast<fullstack_compression_fixture_data*>(
+          gpr_malloc(sizeof(fullstack_compression_fixture_data)));
   memset(ffd, 0, sizeof(fullstack_compression_fixture_data));
 
   gpr_join_host_port(&ffd->localaddr, "localhost", port);
 
   memset(&f, 0, sizeof(f));
   f.fixture_data = ffd;
-  f.cq = grpc_completion_queue_create_for_next(NULL);
-  f.shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
+  f.cq = grpc_completion_queue_create_for_next(nullptr);
+  f.shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
 
   return f;
 }
 
-void chttp2_init_client_fullstack_compression(grpc_end2end_test_fixture *f,
-                                              grpc_channel_args *client_args) {
-  fullstack_compression_fixture_data *ffd = f->fixture_data;
-  if (ffd->client_args_compression != NULL) {
+void chttp2_init_client_fullstack_compression(grpc_end2end_test_fixture* f,
+                                              grpc_channel_args* client_args) {
+  fullstack_compression_fixture_data* ffd =
+      static_cast<fullstack_compression_fixture_data*>(f->fixture_data);
+  if (ffd->client_args_compression != nullptr) {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_channel_args_destroy(&exec_ctx, ffd->client_args_compression);
     grpc_exec_ctx_finish(&exec_ctx);
   }
   ffd->client_args_compression = grpc_channel_args_set_compression_algorithm(
       client_args, GRPC_COMPRESS_GZIP);
-  f->client = grpc_insecure_channel_create(ffd->localaddr,
-                                           ffd->client_args_compression, NULL);
+  f->client = grpc_insecure_channel_create(
+      ffd->localaddr, ffd->client_args_compression, nullptr);
 }
 
-void chttp2_init_server_fullstack_compression(grpc_end2end_test_fixture *f,
-                                              grpc_channel_args *server_args) {
-  fullstack_compression_fixture_data *ffd = f->fixture_data;
-  if (ffd->server_args_compression != NULL) {
+void chttp2_init_server_fullstack_compression(grpc_end2end_test_fixture* f,
+                                              grpc_channel_args* server_args) {
+  fullstack_compression_fixture_data* ffd =
+      static_cast<fullstack_compression_fixture_data*>(f->fixture_data);
+  if (ffd->server_args_compression != nullptr) {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_channel_args_destroy(&exec_ctx, ffd->server_args_compression);
     grpc_exec_ctx_finish(&exec_ctx);
@@ -87,15 +90,16 @@ void chttp2_init_server_fullstack_compression(grpc_end2end_test_fixture *f,
   if (f->server) {
     grpc_server_destroy(f->server);
   }
-  f->server = grpc_server_create(ffd->server_args_compression, NULL);
-  grpc_server_register_completion_queue(f->server, f->cq, NULL);
+  f->server = grpc_server_create(ffd->server_args_compression, nullptr);
+  grpc_server_register_completion_queue(f->server, f->cq, nullptr);
   GPR_ASSERT(grpc_server_add_insecure_http2_port(f->server, ffd->localaddr));
   grpc_server_start(f->server);
 }
 
-void chttp2_tear_down_fullstack_compression(grpc_end2end_test_fixture *f) {
+void chttp2_tear_down_fullstack_compression(grpc_end2end_test_fixture* f) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  fullstack_compression_fixture_data *ffd = f->fixture_data;
+  fullstack_compression_fixture_data* ffd =
+      static_cast<fullstack_compression_fixture_data*>(f->fixture_data);
   grpc_channel_args_destroy(&exec_ctx, ffd->client_args_compression);
   grpc_channel_args_destroy(&exec_ctx, ffd->server_args_compression);
   gpr_free(ffd->localaddr);
@@ -105,16 +109,17 @@ void chttp2_tear_down_fullstack_compression(grpc_end2end_test_fixture *f) {
 
 /* All test configurations */
 static grpc_end2end_test_config configs[] = {
-    {"chttp2/fullstack_compression", FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION |
-                                         FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL |
-                                         FEATURE_MASK_SUPPORTS_AUTHORITY_HEADER,
+    {"chttp2/fullstack_compression",
+     FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION |
+         FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL |
+         FEATURE_MASK_SUPPORTS_AUTHORITY_HEADER,
      chttp2_create_fixture_fullstack_compression,
      chttp2_init_client_fullstack_compression,
      chttp2_init_server_fullstack_compression,
      chttp2_tear_down_fullstack_compression},
 };
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   size_t i;
 
   grpc_test_init(argc, argv);
diff --git a/test/core/end2end/fixtures/h2_fakesec.c b/test/core/end2end/fixtures/h2_fakesec.cc
index e622d952be..87d4668d50 100644
--- a/test/core/end2end/fixtures/h2_fakesec.c
+++ b/test/core/end2end/fixtures/h2_fakesec.cc
@@ -31,75 +31,79 @@
 #include "test/core/util/test_config.h"
 
 typedef struct fullstack_secure_fixture_data {
-  char *localaddr;
+  char* localaddr;
 } fullstack_secure_fixture_data;
 
 static grpc_end2end_test_fixture chttp2_create_fixture_secure_fullstack(
-    grpc_channel_args *client_args, grpc_channel_args *server_args) {
+    grpc_channel_args* client_args, grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   int port = grpc_pick_unused_port_or_die();
-  fullstack_secure_fixture_data *ffd =
-      gpr_malloc(sizeof(fullstack_secure_fixture_data));
+  fullstack_secure_fixture_data* ffd =
+      static_cast<fullstack_secure_fixture_data*>(
+          gpr_malloc(sizeof(fullstack_secure_fixture_data)));
 
   memset(&f, 0, sizeof(f));
   gpr_join_host_port(&ffd->localaddr, "localhost", port);
 
   f.fixture_data = ffd;
-  f.cq = grpc_completion_queue_create_for_next(NULL);
-  f.shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
+  f.cq = grpc_completion_queue_create_for_next(nullptr);
+  f.shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
 
   return f;
 }
 
-static void process_auth_failure(void *state, grpc_auth_context *ctx,
-                                 const grpc_metadata *md, size_t md_count,
+static void process_auth_failure(void* state, grpc_auth_context* ctx,
+                                 const grpc_metadata* md, size_t md_count,
                                  grpc_process_auth_metadata_done_cb cb,
-                                 void *user_data) {
-  GPR_ASSERT(state == NULL);
-  cb(user_data, NULL, 0, NULL, 0, GRPC_STATUS_UNAUTHENTICATED, NULL);
+                                 void* user_data) {
+  GPR_ASSERT(state == nullptr);
+  cb(user_data, nullptr, 0, nullptr, 0, GRPC_STATUS_UNAUTHENTICATED, nullptr);
 }
 
 static void chttp2_init_client_secure_fullstack(
-    grpc_end2end_test_fixture *f, grpc_channel_args *client_args,
-    grpc_channel_credentials *creds) {
-  fullstack_secure_fixture_data *ffd = f->fixture_data;
+    grpc_end2end_test_fixture* f, grpc_channel_args* client_args,
+    grpc_channel_credentials* creds) {
+  fullstack_secure_fixture_data* ffd =
+      static_cast<fullstack_secure_fixture_data*>(f->fixture_data);
   f->client =
-      grpc_secure_channel_create(creds, ffd->localaddr, client_args, NULL);
-  GPR_ASSERT(f->client != NULL);
+      grpc_secure_channel_create(creds, ffd->localaddr, client_args, nullptr);
+  GPR_ASSERT(f->client != nullptr);
   grpc_channel_credentials_release(creds);
 }
 
 static void chttp2_init_server_secure_fullstack(
-    grpc_end2end_test_fixture *f, grpc_channel_args *server_args,
-    grpc_server_credentials *server_creds) {
-  fullstack_secure_fixture_data *ffd = f->fixture_data;
+    grpc_end2end_test_fixture* f, grpc_channel_args* server_args,
+    grpc_server_credentials* server_creds) {
+  fullstack_secure_fixture_data* ffd =
+      static_cast<fullstack_secure_fixture_data*>(f->fixture_data);
   if (f->server) {
     grpc_server_destroy(f->server);
   }
-  f->server = grpc_server_create(server_args, NULL);
-  grpc_server_register_completion_queue(f->server, f->cq, NULL);
+  f->server = grpc_server_create(server_args, nullptr);
+  grpc_server_register_completion_queue(f->server, f->cq, nullptr);
   GPR_ASSERT(grpc_server_add_secure_http2_port(f->server, ffd->localaddr,
                                                server_creds));
   grpc_server_credentials_release(server_creds);
   grpc_server_start(f->server);
 }
 
-void chttp2_tear_down_secure_fullstack(grpc_end2end_test_fixture *f) {
-  fullstack_secure_fixture_data *ffd = f->fixture_data;
+void chttp2_tear_down_secure_fullstack(grpc_end2end_test_fixture* f) {
+  fullstack_secure_fixture_data* ffd =
+      static_cast<fullstack_secure_fixture_data*>(f->fixture_data);
   gpr_free(ffd->localaddr);
   gpr_free(ffd);
 }
 
 static void chttp2_init_client_fake_secure_fullstack(
-    grpc_end2end_test_fixture *f, grpc_channel_args *client_args) {
-  grpc_channel_credentials *fake_ts_creds =
+    grpc_end2end_test_fixture* f, grpc_channel_args* client_args) {
+  grpc_channel_credentials* fake_ts_creds =
       grpc_fake_transport_security_credentials_create();
   chttp2_init_client_secure_fullstack(f, client_args, fake_ts_creds);
 }
 
-static int fail_server_auth_check(grpc_channel_args *server_args) {
+static int fail_server_auth_check(grpc_channel_args* server_args) {
   size_t i;
-  if (server_args == NULL) return 0;
+  if (server_args == nullptr) return 0;
   for (i = 0; i < server_args->num_args; i++) {
     if (strcmp(server_args->args[i].key, FAIL_AUTH_CHECK_SERVER_ARG_NAME) ==
         0) {
@@ -110,11 +114,12 @@ static int fail_server_auth_check(grpc_channel_args *server_args) {
 }
 
 static void chttp2_init_server_fake_secure_fullstack(
-    grpc_end2end_test_fixture *f, grpc_channel_args *server_args) {
-  grpc_server_credentials *fake_ts_creds =
+    grpc_end2end_test_fixture* f, grpc_channel_args* server_args) {
+  grpc_server_credentials* fake_ts_creds =
       grpc_fake_transport_security_server_credentials_create();
   if (fail_server_auth_check(server_args)) {
-    grpc_auth_metadata_processor processor = {process_auth_failure, NULL, NULL};
+    grpc_auth_metadata_processor processor = {process_auth_failure, nullptr,
+                                              nullptr};
     grpc_server_credentials_set_auth_metadata_processor(fake_ts_creds,
                                                         processor);
   }
@@ -135,7 +140,7 @@ static grpc_end2end_test_config configs[] = {
      chttp2_tear_down_secure_fullstack},
 };
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   size_t i;
   grpc_test_init(argc, argv);
   grpc_end2end_tests_pre_init();
diff --git a/test/core/end2end/fixtures/h2_fd.c b/test/core/end2end/fixtures/h2_fd.cc
index e82c120221..97f4b71bf0 100644
--- a/test/core/end2end/fixtures/h2_fd.c
+++ b/test/core/end2end/fixtures/h2_fd.cc
@@ -35,7 +35,9 @@
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 #include "test/core/util/test_config.h"
 
-typedef struct { int fd_pair[2]; } sp_fixture_data;
+typedef struct {
+  int fd_pair[2];
+} sp_fixture_data;
 
 static void create_sockets(int sv[2]) {
   int flags;
@@ -49,24 +51,25 @@ static void create_sockets(int sv[2]) {
 }
 
 static grpc_end2end_test_fixture chttp2_create_fixture_socketpair(
-    grpc_channel_args *client_args, grpc_channel_args *server_args) {
-  sp_fixture_data *fixture_data = gpr_malloc(sizeof(*fixture_data));
+    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+  sp_fixture_data* fixture_data =
+      static_cast<sp_fixture_data*>(gpr_malloc(sizeof(*fixture_data)));
 
   grpc_end2end_test_fixture f;
   memset(&f, 0, sizeof(f));
   f.fixture_data = fixture_data;
-  f.cq = grpc_completion_queue_create_for_next(NULL);
-  f.shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
+  f.cq = grpc_completion_queue_create_for_next(nullptr);
+  f.shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
 
   create_sockets(fixture_data->fd_pair);
 
   return f;
 }
 
-static void chttp2_init_client_socketpair(grpc_end2end_test_fixture *f,
-                                          grpc_channel_args *client_args) {
+static void chttp2_init_client_socketpair(grpc_end2end_test_fixture* f,
+                                          grpc_channel_args* client_args) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  sp_fixture_data *sfd = f->fixture_data;
+  sp_fixture_data* sfd = static_cast<sp_fixture_data*>(f->fixture_data);
 
   GPR_ASSERT(!f->client);
   f->client = grpc_insecure_channel_create_from_fd(
@@ -76,22 +79,22 @@ static void chttp2_init_client_socketpair(grpc_end2end_test_fixture *f,
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void chttp2_init_server_socketpair(grpc_end2end_test_fixture *f,
-                                          grpc_channel_args *server_args) {
+static void chttp2_init_server_socketpair(grpc_end2end_test_fixture* f,
+                                          grpc_channel_args* server_args) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  sp_fixture_data *sfd = f->fixture_data;
+  sp_fixture_data* sfd = static_cast<sp_fixture_data*>(f->fixture_data);
   GPR_ASSERT(!f->server);
-  f->server = grpc_server_create(server_args, NULL);
+  f->server = grpc_server_create(server_args, nullptr);
   GPR_ASSERT(f->server);
-  grpc_server_register_completion_queue(f->server, f->cq, NULL);
+  grpc_server_register_completion_queue(f->server, f->cq, nullptr);
   grpc_server_start(f->server);
 
-  grpc_server_add_insecure_channel_from_fd(f->server, NULL, sfd->fd_pair[1]);
+  grpc_server_add_insecure_channel_from_fd(f->server, nullptr, sfd->fd_pair[1]);
 
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void chttp2_tear_down_socketpair(grpc_end2end_test_fixture *f) {
+static void chttp2_tear_down_socketpair(grpc_end2end_test_fixture* f) {
   gpr_free(f->fixture_data);
 }
 
@@ -102,7 +105,7 @@ static grpc_end2end_test_config configs[] = {
      chttp2_init_server_socketpair, chttp2_tear_down_socketpair},
 };
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   size_t i;
 
   grpc_test_init(argc, argv);
@@ -120,6 +123,6 @@ int main(int argc, char **argv) {
 
 #else /* GRPC_POSIX_SOCKET */
 
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
 
 #endif /* GRPC_POSIX_SOCKET */
diff --git a/test/core/end2end/fixtures/h2_full+pipe.c b/test/core/end2end/fixtures/h2_full+pipe.cc
index c764bd704a..b080591e85 100644
--- a/test/core/end2end/fixtures/h2_full+pipe.c
+++ b/test/core/end2end/fixtures/h2_full+pipe.cc
@@ -42,60 +42,66 @@
 #include "test/core/util/test_config.h"
 
 typedef struct fullstack_fixture_data {
-  char *localaddr;
+  char* localaddr;
 } fullstack_fixture_data;
 
 static grpc_end2end_test_fixture chttp2_create_fixture_fullstack(
-    grpc_channel_args *client_args, grpc_channel_args *server_args) {
+    grpc_channel_args* client_args, grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   int port = grpc_pick_unused_port_or_die();
-  fullstack_fixture_data *ffd = gpr_malloc(sizeof(fullstack_fixture_data));
+  fullstack_fixture_data* ffd = static_cast<fullstack_fixture_data*>(
+      gpr_malloc(sizeof(fullstack_fixture_data)));
   memset(&f, 0, sizeof(f));
 
   gpr_join_host_port(&ffd->localaddr, "localhost", port);
 
   f.fixture_data = ffd;
-  f.cq = grpc_completion_queue_create_for_next(NULL);
-  f.shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
+  f.cq = grpc_completion_queue_create_for_next(nullptr);
+  f.shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
 
   return f;
 }
 
-void chttp2_init_client_fullstack(grpc_end2end_test_fixture *f,
-                                  grpc_channel_args *client_args) {
-  fullstack_fixture_data *ffd = f->fixture_data;
-  f->client = grpc_insecure_channel_create(ffd->localaddr, client_args, NULL);
+void chttp2_init_client_fullstack(grpc_end2end_test_fixture* f,
+                                  grpc_channel_args* client_args) {
+  fullstack_fixture_data* ffd =
+      static_cast<fullstack_fixture_data*>(f->fixture_data);
+  f->client =
+      grpc_insecure_channel_create(ffd->localaddr, client_args, nullptr);
   GPR_ASSERT(f->client);
 }
 
-void chttp2_init_server_fullstack(grpc_end2end_test_fixture *f,
-                                  grpc_channel_args *server_args) {
-  fullstack_fixture_data *ffd = f->fixture_data;
+void chttp2_init_server_fullstack(grpc_end2end_test_fixture* f,
+                                  grpc_channel_args* server_args) {
+  fullstack_fixture_data* ffd =
+      static_cast<fullstack_fixture_data*>(f->fixture_data);
   if (f->server) {
     grpc_server_destroy(f->server);
   }
-  f->server = grpc_server_create(server_args, NULL);
-  grpc_server_register_completion_queue(f->server, f->cq, NULL);
+  f->server = grpc_server_create(server_args, nullptr);
+  grpc_server_register_completion_queue(f->server, f->cq, nullptr);
   GPR_ASSERT(grpc_server_add_insecure_http2_port(f->server, ffd->localaddr));
   grpc_server_start(f->server);
 }
 
-void chttp2_tear_down_fullstack(grpc_end2end_test_fixture *f) {
-  fullstack_fixture_data *ffd = f->fixture_data;
+void chttp2_tear_down_fullstack(grpc_end2end_test_fixture* f) {
+  fullstack_fixture_data* ffd =
+      static_cast<fullstack_fixture_data*>(f->fixture_data);
   gpr_free(ffd->localaddr);
   gpr_free(ffd);
 }
 
 /* All test configurations */
 static grpc_end2end_test_config configs[] = {
-    {"chttp2/fullstack", FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION |
-                             FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL |
-                             FEATURE_MASK_SUPPORTS_AUTHORITY_HEADER,
+    {"chttp2/fullstack",
+     FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION |
+         FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL |
+         FEATURE_MASK_SUPPORTS_AUTHORITY_HEADER,
      chttp2_create_fixture_fullstack, chttp2_init_client_fullstack,
      chttp2_init_server_fullstack, chttp2_tear_down_fullstack},
 };
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   size_t i;
 
   grpc_allow_specialized_wakeup_fd = 0;
@@ -115,6 +121,6 @@ int main(int argc, char **argv) {
 
 #else /* GRPC_POSIX_WAKEUP_FD */
 
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
 
 #endif /* GRPC_POSIX_WAKEUP_FD */
diff --git a/test/core/end2end/fixtures/h2_full+trace.c b/test/core/end2end/fixtures/h2_full+trace.cc
index 7eb29e0d32..a49de96009 100644
--- a/test/core/end2end/fixtures/h2_full+trace.c
+++ b/test/core/end2end/fixtures/h2_full+trace.cc
@@ -42,60 +42,66 @@
 #include "test/core/util/test_config.h"
 
 typedef struct fullstack_fixture_data {
-  char *localaddr;
+  char* localaddr;
 } fullstack_fixture_data;
 
 static grpc_end2end_test_fixture chttp2_create_fixture_fullstack(
-    grpc_channel_args *client_args, grpc_channel_args *server_args) {
+    grpc_channel_args* client_args, grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   int port = grpc_pick_unused_port_or_die();
-  fullstack_fixture_data *ffd = gpr_malloc(sizeof(fullstack_fixture_data));
+  fullstack_fixture_data* ffd = static_cast<fullstack_fixture_data*>(
+      gpr_malloc(sizeof(fullstack_fixture_data)));
   memset(&f, 0, sizeof(f));
 
   gpr_join_host_port(&ffd->localaddr, "localhost", port);
 
   f.fixture_data = ffd;
-  f.cq = grpc_completion_queue_create_for_next(NULL);
-  f.shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
+  f.cq = grpc_completion_queue_create_for_next(nullptr);
+  f.shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
 
   return f;
 }
 
-void chttp2_init_client_fullstack(grpc_end2end_test_fixture *f,
-                                  grpc_channel_args *client_args) {
-  fullstack_fixture_data *ffd = f->fixture_data;
-  f->client = grpc_insecure_channel_create(ffd->localaddr, client_args, NULL);
+void chttp2_init_client_fullstack(grpc_end2end_test_fixture* f,
+                                  grpc_channel_args* client_args) {
+  fullstack_fixture_data* ffd =
+      static_cast<fullstack_fixture_data*>(f->fixture_data);
+  f->client =
+      grpc_insecure_channel_create(ffd->localaddr, client_args, nullptr);
   GPR_ASSERT(f->client);
 }
 
-void chttp2_init_server_fullstack(grpc_end2end_test_fixture *f,
-                                  grpc_channel_args *server_args) {
-  fullstack_fixture_data *ffd = f->fixture_data;
+void chttp2_init_server_fullstack(grpc_end2end_test_fixture* f,
+                                  grpc_channel_args* server_args) {
+  fullstack_fixture_data* ffd =
+      static_cast<fullstack_fixture_data*>(f->fixture_data);
   if (f->server) {
     grpc_server_destroy(f->server);
   }
-  f->server = grpc_server_create(server_args, NULL);
-  grpc_server_register_completion_queue(f->server, f->cq, NULL);
+  f->server = grpc_server_create(server_args, nullptr);
+  grpc_server_register_completion_queue(f->server, f->cq, nullptr);
   GPR_ASSERT(grpc_server_add_insecure_http2_port(f->server, ffd->localaddr));
   grpc_server_start(f->server);
 }
 
-void chttp2_tear_down_fullstack(grpc_end2end_test_fixture *f) {
-  fullstack_fixture_data *ffd = f->fixture_data;
+void chttp2_tear_down_fullstack(grpc_end2end_test_fixture* f) {
+  fullstack_fixture_data* ffd =
+      static_cast<fullstack_fixture_data*>(f->fixture_data);
   gpr_free(ffd->localaddr);
   gpr_free(ffd);
 }
 
 /* All test configurations */
 static grpc_end2end_test_config configs[] = {
-    {"chttp2/fullstack", FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION |
-                             FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL |
-                             FEATURE_MASK_SUPPORTS_AUTHORITY_HEADER,
+    {"chttp2/fullstack",
+     FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION |
+         FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL |
+         FEATURE_MASK_SUPPORTS_AUTHORITY_HEADER,
      chttp2_create_fixture_fullstack, chttp2_init_client_fullstack,
      chttp2_init_server_fullstack, chttp2_tear_down_fullstack},
 };
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   size_t i;
 
   /* force tracing on, with a value to force many
diff --git a/test/core/end2end/fixtures/h2_full+workarounds.c b/test/core/end2end/fixtures/h2_full+workarounds.cc
index a98e5ad57f..71a497d796 100644
--- a/test/core/end2end/fixtures/h2_full+workarounds.c
+++ b/test/core/end2end/fixtures/h2_full+workarounds.cc
@@ -36,77 +36,83 @@
 #include "test/core/util/port.h"
 #include "test/core/util/test_config.h"
 
-static char *workarounds_arg[GRPC_MAX_WORKAROUND_ID] = {
-    GRPC_ARG_WORKAROUND_CRONET_COMPRESSION};
+static char* workarounds_arg[GRPC_MAX_WORKAROUND_ID] = {
+    const_cast<char*>(GRPC_ARG_WORKAROUND_CRONET_COMPRESSION)};
 
 typedef struct fullstack_fixture_data {
-  char *localaddr;
+  char* localaddr;
 } fullstack_fixture_data;
 
 static grpc_end2end_test_fixture chttp2_create_fixture_fullstack(
-    grpc_channel_args *client_args, grpc_channel_args *server_args) {
+    grpc_channel_args* client_args, grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   int port = grpc_pick_unused_port_or_die();
-  fullstack_fixture_data *ffd = gpr_malloc(sizeof(fullstack_fixture_data));
+  fullstack_fixture_data* ffd = static_cast<fullstack_fixture_data*>(
+      gpr_malloc(sizeof(fullstack_fixture_data)));
   memset(&f, 0, sizeof(f));
 
   gpr_join_host_port(&ffd->localaddr, "localhost", port);
 
   f.fixture_data = ffd;
-  f.cq = grpc_completion_queue_create_for_next(NULL);
-  f.shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
+  f.cq = grpc_completion_queue_create_for_next(nullptr);
+  f.shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
 
   return f;
 }
 
-void chttp2_init_client_fullstack(grpc_end2end_test_fixture *f,
-                                  grpc_channel_args *client_args) {
-  fullstack_fixture_data *ffd = f->fixture_data;
-  f->client = grpc_insecure_channel_create(ffd->localaddr, client_args, NULL);
+void chttp2_init_client_fullstack(grpc_end2end_test_fixture* f,
+                                  grpc_channel_args* client_args) {
+  fullstack_fixture_data* ffd =
+      static_cast<fullstack_fixture_data*>(f->fixture_data);
+  f->client =
+      grpc_insecure_channel_create(ffd->localaddr, client_args, nullptr);
   GPR_ASSERT(f->client);
 }
 
-void chttp2_init_server_fullstack(grpc_end2end_test_fixture *f,
-                                  grpc_channel_args *server_args) {
+void chttp2_init_server_fullstack(grpc_end2end_test_fixture* f,
+                                  grpc_channel_args* server_args) {
   int i;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  fullstack_fixture_data *ffd = f->fixture_data;
+  fullstack_fixture_data* ffd =
+      static_cast<fullstack_fixture_data*>(f->fixture_data);
   grpc_arg args[GRPC_MAX_WORKAROUND_ID];
   for (i = 0; i < GRPC_MAX_WORKAROUND_ID; i++) {
     args[i].key = workarounds_arg[i];
     args[i].type = GRPC_ARG_INTEGER;
     args[i].value.integer = 1;
   }
-  grpc_channel_args *server_args_new =
+  grpc_channel_args* server_args_new =
       grpc_channel_args_copy_and_add(server_args, args, GRPC_MAX_WORKAROUND_ID);
   if (f->server) {
     grpc_server_destroy(f->server);
   }
-  f->server = grpc_server_create(server_args_new, NULL);
-  grpc_server_register_completion_queue(f->server, f->cq, NULL);
+  f->server = grpc_server_create(server_args_new, nullptr);
+  grpc_server_register_completion_queue(f->server, f->cq, nullptr);
   GPR_ASSERT(grpc_server_add_insecure_http2_port(f->server, ffd->localaddr));
   grpc_server_start(f->server);
   grpc_channel_args_destroy(&exec_ctx, server_args_new);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-void chttp2_tear_down_fullstack(grpc_end2end_test_fixture *f) {
-  fullstack_fixture_data *ffd = f->fixture_data;
+void chttp2_tear_down_fullstack(grpc_end2end_test_fixture* f) {
+  fullstack_fixture_data* ffd =
+      static_cast<fullstack_fixture_data*>(f->fixture_data);
   gpr_free(ffd->localaddr);
   gpr_free(ffd);
 }
 
 /* All test configurations */
 static grpc_end2end_test_config configs[] = {
-    {"chttp2/fullstack", FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION |
-                             FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL |
-                             FEATURE_MASK_SUPPORTS_AUTHORITY_HEADER |
-                             FEATURE_MASK_SUPPORTS_WORKAROUNDS,
+    {"chttp2/fullstack",
+     FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION |
+         FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL |
+         FEATURE_MASK_SUPPORTS_AUTHORITY_HEADER |
+         FEATURE_MASK_SUPPORTS_WORKAROUNDS,
      chttp2_create_fixture_fullstack, chttp2_init_client_fullstack,
      chttp2_init_server_fullstack, chttp2_tear_down_fullstack},
 };
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   size_t i;
 
   grpc_test_init(argc, argv);
diff --git a/test/core/end2end/fixtures/h2_full.c b/test/core/end2end/fixtures/h2_full.cc
index ae68bd9698..6d15c28662 100644
--- a/test/core/end2end/fixtures/h2_full.c
+++ b/test/core/end2end/fixtures/h2_full.cc
@@ -36,60 +36,66 @@
 #include "test/core/util/test_config.h"
 
 typedef struct fullstack_fixture_data {
-  char *localaddr;
+  char* localaddr;
 } fullstack_fixture_data;
 
 static grpc_end2end_test_fixture chttp2_create_fixture_fullstack(
-    grpc_channel_args *client_args, grpc_channel_args *server_args) {
+    grpc_channel_args* client_args, grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   int port = grpc_pick_unused_port_or_die();
-  fullstack_fixture_data *ffd = gpr_malloc(sizeof(fullstack_fixture_data));
+  fullstack_fixture_data* ffd = static_cast<fullstack_fixture_data*>(
+      gpr_malloc(sizeof(fullstack_fixture_data)));
   memset(&f, 0, sizeof(f));
 
   gpr_join_host_port(&ffd->localaddr, "localhost", port);
 
   f.fixture_data = ffd;
-  f.cq = grpc_completion_queue_create_for_next(NULL);
-  f.shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
+  f.cq = grpc_completion_queue_create_for_next(nullptr);
+  f.shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
 
   return f;
 }
 
-void chttp2_init_client_fullstack(grpc_end2end_test_fixture *f,
-                                  grpc_channel_args *client_args) {
-  fullstack_fixture_data *ffd = f->fixture_data;
-  f->client = grpc_insecure_channel_create(ffd->localaddr, client_args, NULL);
+void chttp2_init_client_fullstack(grpc_end2end_test_fixture* f,
+                                  grpc_channel_args* client_args) {
+  fullstack_fixture_data* ffd =
+      static_cast<fullstack_fixture_data*>(f->fixture_data);
+  f->client =
+      grpc_insecure_channel_create(ffd->localaddr, client_args, nullptr);
   GPR_ASSERT(f->client);
 }
 
-void chttp2_init_server_fullstack(grpc_end2end_test_fixture *f,
-                                  grpc_channel_args *server_args) {
-  fullstack_fixture_data *ffd = f->fixture_data;
+void chttp2_init_server_fullstack(grpc_end2end_test_fixture* f,
+                                  grpc_channel_args* server_args) {
+  fullstack_fixture_data* ffd =
+      static_cast<fullstack_fixture_data*>(f->fixture_data);
   if (f->server) {
     grpc_server_destroy(f->server);
   }
-  f->server = grpc_server_create(server_args, NULL);
-  grpc_server_register_completion_queue(f->server, f->cq, NULL);
+  f->server = grpc_server_create(server_args, nullptr);
+  grpc_server_register_completion_queue(f->server, f->cq, nullptr);
   GPR_ASSERT(grpc_server_add_insecure_http2_port(f->server, ffd->localaddr));
   grpc_server_start(f->server);
 }
 
-void chttp2_tear_down_fullstack(grpc_end2end_test_fixture *f) {
-  fullstack_fixture_data *ffd = f->fixture_data;
+void chttp2_tear_down_fullstack(grpc_end2end_test_fixture* f) {
+  fullstack_fixture_data* ffd =
+      static_cast<fullstack_fixture_data*>(f->fixture_data);
   gpr_free(ffd->localaddr);
   gpr_free(ffd);
 }
 
 /* All test configurations */
 static grpc_end2end_test_config configs[] = {
-    {"chttp2/fullstack", FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION |
-                             FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL |
-                             FEATURE_MASK_SUPPORTS_AUTHORITY_HEADER,
+    {"chttp2/fullstack",
+     FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION |
+         FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL |
+         FEATURE_MASK_SUPPORTS_AUTHORITY_HEADER,
      chttp2_create_fixture_fullstack, chttp2_init_client_fullstack,
      chttp2_init_server_fullstack, chttp2_tear_down_fullstack},
 };
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   size_t i;
 
   grpc_test_init(argc, argv);
diff --git a/test/core/end2end/fixtures/h2_http_proxy.c b/test/core/end2end/fixtures/h2_http_proxy.cc
index 6145892365..099367d91b 100644
--- a/test/core/end2end/fixtures/h2_http_proxy.c
+++ b/test/core/end2end/fixtures/h2_http_proxy.cc
@@ -39,15 +39,16 @@
 #include "test/core/util/test_config.h"
 
 typedef struct fullstack_fixture_data {
-  char *server_addr;
-  grpc_end2end_http_proxy *proxy;
+  char* server_addr;
+  grpc_end2end_http_proxy* proxy;
 } fullstack_fixture_data;
 
 static grpc_end2end_test_fixture chttp2_create_fixture_fullstack(
-    grpc_channel_args *client_args, grpc_channel_args *server_args) {
+    grpc_channel_args* client_args, grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   memset(&f, 0, sizeof(f));
-  fullstack_fixture_data *ffd = gpr_malloc(sizeof(fullstack_fixture_data));
+  fullstack_fixture_data* ffd = static_cast<fullstack_fixture_data*>(
+      gpr_malloc(sizeof(fullstack_fixture_data)));
   const int server_port = grpc_pick_unused_port_or_die();
   gpr_join_host_port(&ffd->server_addr, "localhost", server_port);
 
@@ -56,21 +57,22 @@ static grpc_end2end_test_fixture chttp2_create_fixture_fullstack(
   ffd->proxy = grpc_end2end_http_proxy_create(client_args);
 
   f.fixture_data = ffd;
-  f.cq = grpc_completion_queue_create_for_next(NULL);
-  f.shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
+  f.cq = grpc_completion_queue_create_for_next(nullptr);
+  f.shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
 
   return f;
 }
 
-void chttp2_init_client_fullstack(grpc_end2end_test_fixture *f,
-                                  grpc_channel_args *client_args) {
-  fullstack_fixture_data *ffd = f->fixture_data;
-  char *proxy_uri;
+void chttp2_init_client_fullstack(grpc_end2end_test_fixture* f,
+                                  grpc_channel_args* client_args) {
+  fullstack_fixture_data* ffd =
+      static_cast<fullstack_fixture_data*>(f->fixture_data);
+  char* proxy_uri;
 
   /* If testing for proxy auth, add credentials to proxy uri */
-  const grpc_arg *proxy_auth_arg =
+  const grpc_arg* proxy_auth_arg =
       grpc_channel_args_find(client_args, GRPC_ARG_HTTP_PROXY_AUTH_CREDS);
-  if (proxy_auth_arg == NULL || proxy_auth_arg->type != GRPC_ARG_STRING) {
+  if (proxy_auth_arg == nullptr || proxy_auth_arg->type != GRPC_ARG_STRING) {
     gpr_asprintf(&proxy_uri, "http://%s",
                  grpc_end2end_http_proxy_get_proxy_name(ffd->proxy));
   } else {
@@ -79,24 +81,27 @@ void chttp2_init_client_fullstack(grpc_end2end_test_fixture *f,
   }
   gpr_setenv("http_proxy", proxy_uri);
   gpr_free(proxy_uri);
-  f->client = grpc_insecure_channel_create(ffd->server_addr, client_args, NULL);
+  f->client =
+      grpc_insecure_channel_create(ffd->server_addr, client_args, nullptr);
   GPR_ASSERT(f->client);
 }
 
-void chttp2_init_server_fullstack(grpc_end2end_test_fixture *f,
-                                  grpc_channel_args *server_args) {
-  fullstack_fixture_data *ffd = f->fixture_data;
+void chttp2_init_server_fullstack(grpc_end2end_test_fixture* f,
+                                  grpc_channel_args* server_args) {
+  fullstack_fixture_data* ffd =
+      static_cast<fullstack_fixture_data*>(f->fixture_data);
   if (f->server) {
     grpc_server_destroy(f->server);
   }
-  f->server = grpc_server_create(server_args, NULL);
-  grpc_server_register_completion_queue(f->server, f->cq, NULL);
+  f->server = grpc_server_create(server_args, nullptr);
+  grpc_server_register_completion_queue(f->server, f->cq, nullptr);
   GPR_ASSERT(grpc_server_add_insecure_http2_port(f->server, ffd->server_addr));
   grpc_server_start(f->server);
 }
 
-void chttp2_tear_down_fullstack(grpc_end2end_test_fixture *f) {
-  fullstack_fixture_data *ffd = f->fixture_data;
+void chttp2_tear_down_fullstack(grpc_end2end_test_fixture* f) {
+  fullstack_fixture_data* ffd =
+      static_cast<fullstack_fixture_data*>(f->fixture_data);
   gpr_free(ffd->server_addr);
   grpc_end2end_http_proxy_destroy(ffd->proxy);
   gpr_free(ffd);
@@ -104,14 +109,15 @@ void chttp2_tear_down_fullstack(grpc_end2end_test_fixture *f) {
 
 /* All test configurations */
 static grpc_end2end_test_config configs[] = {
-    {"chttp2/fullstack", FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION |
-                             FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL |
-                             FEATURE_MASK_SUPPORTS_AUTHORITY_HEADER,
+    {"chttp2/fullstack",
+     FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION |
+         FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL |
+         FEATURE_MASK_SUPPORTS_AUTHORITY_HEADER,
      chttp2_create_fixture_fullstack, chttp2_init_client_fullstack,
      chttp2_init_server_fullstack, chttp2_tear_down_fullstack},
 };
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   size_t i;
 
   grpc_test_init(argc, argv);
diff --git a/test/core/end2end/fixtures/h2_load_reporting.c b/test/core/end2end/fixtures/h2_load_reporting.cc
index 8a05bb722a..7486b6af78 100644
--- a/test/core/end2end/fixtures/h2_load_reporting.c
+++ b/test/core/end2end/fixtures/h2_load_reporting.cc
@@ -38,54 +38,58 @@
 #include "test/core/util/test_config.h"
 
 typedef struct load_reporting_fixture_data {
-  char *localaddr;
+  char* localaddr;
 } load_reporting_fixture_data;
 
 static grpc_end2end_test_fixture chttp2_create_fixture_load_reporting(
-    grpc_channel_args *client_args, grpc_channel_args *server_args) {
+    grpc_channel_args* client_args, grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   int port = grpc_pick_unused_port_or_die();
-  load_reporting_fixture_data *ffd =
-      gpr_malloc(sizeof(load_reporting_fixture_data));
+  load_reporting_fixture_data* ffd = static_cast<load_reporting_fixture_data*>(
+      gpr_malloc(sizeof(load_reporting_fixture_data)));
   memset(&f, 0, sizeof(f));
 
   gpr_join_host_port(&ffd->localaddr, "localhost", port);
 
   f.fixture_data = ffd;
-  f.cq = grpc_completion_queue_create_for_next(NULL);
-  f.shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
+  f.cq = grpc_completion_queue_create_for_next(nullptr);
+  f.shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
 
   return f;
 }
 
-void chttp2_init_client_load_reporting(grpc_end2end_test_fixture *f,
-                                       grpc_channel_args *client_args) {
-  load_reporting_fixture_data *ffd = f->fixture_data;
-  f->client = grpc_insecure_channel_create(ffd->localaddr, client_args, NULL);
+void chttp2_init_client_load_reporting(grpc_end2end_test_fixture* f,
+                                       grpc_channel_args* client_args) {
+  load_reporting_fixture_data* ffd =
+      static_cast<load_reporting_fixture_data*>(f->fixture_data);
+  f->client =
+      grpc_insecure_channel_create(ffd->localaddr, client_args, nullptr);
   GPR_ASSERT(f->client);
 }
 
-void chttp2_init_server_load_reporting(grpc_end2end_test_fixture *f,
-                                       grpc_channel_args *server_args) {
-  load_reporting_fixture_data *ffd = f->fixture_data;
+void chttp2_init_server_load_reporting(grpc_end2end_test_fixture* f,
+                                       grpc_channel_args* server_args) {
+  load_reporting_fixture_data* ffd =
+      static_cast<load_reporting_fixture_data*>(f->fixture_data);
   grpc_arg arg = grpc_load_reporting_enable_arg();
   if (f->server) {
     grpc_server_destroy(f->server);
   }
   server_args = grpc_channel_args_copy_and_add(server_args, &arg, 1);
-  f->server = grpc_server_create(server_args, NULL);
+  f->server = grpc_server_create(server_args, nullptr);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_channel_args_destroy(&exec_ctx, server_args);
     grpc_exec_ctx_finish(&exec_ctx);
   }
-  grpc_server_register_completion_queue(f->server, f->cq, NULL);
+  grpc_server_register_completion_queue(f->server, f->cq, nullptr);
   GPR_ASSERT(grpc_server_add_insecure_http2_port(f->server, ffd->localaddr));
   grpc_server_start(f->server);
 }
 
-void chttp2_tear_down_load_reporting(grpc_end2end_test_fixture *f) {
-  load_reporting_fixture_data *ffd = f->fixture_data;
+void chttp2_tear_down_load_reporting(grpc_end2end_test_fixture* f) {
+  load_reporting_fixture_data* ffd =
+      static_cast<load_reporting_fixture_data*>(f->fixture_data);
   gpr_free(ffd->localaddr);
   gpr_free(ffd);
 }
@@ -100,7 +104,7 @@ static grpc_end2end_test_config configs[] = {
      chttp2_init_server_load_reporting, chttp2_tear_down_load_reporting},
 };
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   size_t i;
 
   grpc_test_init(argc, argv);
diff --git a/test/core/end2end/fixtures/h2_oauth2.c b/test/core/end2end/fixtures/h2_oauth2.cc
index ee1d0b1416..1642cb0db9 100644
--- a/test/core/end2end/fixtures/h2_oauth2.c
+++ b/test/core/end2end/fixtures/h2_oauth2.cc
@@ -32,16 +32,16 @@
 #include "test/core/util/test_config.h"
 
 static const char oauth2_md[] = "Bearer aaslkfjs424535asdf";
-static const char *client_identity_property_name = "smurf_name";
-static const char *client_identity = "Brainy Smurf";
+static const char* client_identity_property_name = "smurf_name";
+static const char* client_identity = "Brainy Smurf";
 
 typedef struct fullstack_secure_fixture_data {
-  char *localaddr;
+  char* localaddr;
 } fullstack_secure_fixture_data;
 
-static const grpc_metadata *find_metadata(const grpc_metadata *md,
-                                          size_t md_count, const char *key,
-                                          const char *value) {
+static const grpc_metadata* find_metadata(const grpc_metadata* md,
+                                          size_t md_count, const char* key,
+                                          const char* value) {
   size_t i;
   for (i = 0; i < md_count; i++) {
     if (grpc_slice_str_cmp(md[i].key, key) == 0 &&
@@ -49,105 +49,113 @@ static const grpc_metadata *find_metadata(const grpc_metadata *md,
       return &md[i];
     }
   }
-  return NULL;
+  return nullptr;
 }
 
-typedef struct { size_t pseudo_refcount; } test_processor_state;
+typedef struct {
+  size_t pseudo_refcount;
+} test_processor_state;
 
-static void process_oauth2_success(void *state, grpc_auth_context *ctx,
-                                   const grpc_metadata *md, size_t md_count,
+static void process_oauth2_success(void* state, grpc_auth_context* ctx,
+                                   const grpc_metadata* md, size_t md_count,
                                    grpc_process_auth_metadata_done_cb cb,
-                                   void *user_data) {
-  const grpc_metadata *oauth2 =
+                                   void* user_data) {
+  const grpc_metadata* oauth2 =
       find_metadata(md, md_count, "authorization", oauth2_md);
-  test_processor_state *s;
+  test_processor_state* s;
 
-  GPR_ASSERT(state != NULL);
-  s = (test_processor_state *)state;
+  GPR_ASSERT(state != nullptr);
+  s = (test_processor_state*)state;
   GPR_ASSERT(s->pseudo_refcount == 1);
-  GPR_ASSERT(oauth2 != NULL);
+  GPR_ASSERT(oauth2 != nullptr);
   grpc_auth_context_add_cstring_property(ctx, client_identity_property_name,
                                          client_identity);
   GPR_ASSERT(grpc_auth_context_set_peer_identity_property_name(
                  ctx, client_identity_property_name) == 1);
-  cb(user_data, oauth2, 1, NULL, 0, GRPC_STATUS_OK, NULL);
+  cb(user_data, oauth2, 1, nullptr, 0, GRPC_STATUS_OK, nullptr);
 }
 
-static void process_oauth2_failure(void *state, grpc_auth_context *ctx,
-                                   const grpc_metadata *md, size_t md_count,
+static void process_oauth2_failure(void* state, grpc_auth_context* ctx,
+                                   const grpc_metadata* md, size_t md_count,
                                    grpc_process_auth_metadata_done_cb cb,
-                                   void *user_data) {
-  const grpc_metadata *oauth2 =
+                                   void* user_data) {
+  const grpc_metadata* oauth2 =
       find_metadata(md, md_count, "authorization", oauth2_md);
-  test_processor_state *s;
-  GPR_ASSERT(state != NULL);
-  s = (test_processor_state *)state;
+  test_processor_state* s;
+  GPR_ASSERT(state != nullptr);
+  s = (test_processor_state*)state;
   GPR_ASSERT(s->pseudo_refcount == 1);
-  GPR_ASSERT(oauth2 != NULL);
-  cb(user_data, oauth2, 1, NULL, 0, GRPC_STATUS_UNAUTHENTICATED, NULL);
+  GPR_ASSERT(oauth2 != nullptr);
+  cb(user_data, oauth2, 1, nullptr, 0, GRPC_STATUS_UNAUTHENTICATED, nullptr);
 }
 
 static grpc_end2end_test_fixture chttp2_create_fixture_secure_fullstack(
-    grpc_channel_args *client_args, grpc_channel_args *server_args) {
+    grpc_channel_args* client_args, grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   int port = grpc_pick_unused_port_or_die();
-  fullstack_secure_fixture_data *ffd =
-      gpr_malloc(sizeof(fullstack_secure_fixture_data));
+  fullstack_secure_fixture_data* ffd =
+      static_cast<fullstack_secure_fixture_data*>(
+          gpr_malloc(sizeof(fullstack_secure_fixture_data)));
   memset(&f, 0, sizeof(f));
 
   gpr_join_host_port(&ffd->localaddr, "localhost", port);
 
   f.fixture_data = ffd;
-  f.cq = grpc_completion_queue_create_for_next(NULL);
-  f.shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
+  f.cq = grpc_completion_queue_create_for_next(nullptr);
+  f.shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
 
   return f;
 }
 
 static void chttp2_init_client_secure_fullstack(
-    grpc_end2end_test_fixture *f, grpc_channel_args *client_args,
-    grpc_channel_credentials *creds) {
-  fullstack_secure_fixture_data *ffd = f->fixture_data;
+    grpc_end2end_test_fixture* f, grpc_channel_args* client_args,
+    grpc_channel_credentials* creds) {
+  fullstack_secure_fixture_data* ffd =
+      static_cast<fullstack_secure_fixture_data*>(f->fixture_data);
   f->client =
-      grpc_secure_channel_create(creds, ffd->localaddr, client_args, NULL);
-  GPR_ASSERT(f->client != NULL);
+      grpc_secure_channel_create(creds, ffd->localaddr, client_args, nullptr);
+  GPR_ASSERT(f->client != nullptr);
   grpc_channel_credentials_release(creds);
 }
 
 static void chttp2_init_server_secure_fullstack(
-    grpc_end2end_test_fixture *f, grpc_channel_args *server_args,
-    grpc_server_credentials *server_creds) {
-  fullstack_secure_fixture_data *ffd = f->fixture_data;
+    grpc_end2end_test_fixture* f, grpc_channel_args* server_args,
+    grpc_server_credentials* server_creds) {
+  fullstack_secure_fixture_data* ffd =
+      static_cast<fullstack_secure_fixture_data*>(f->fixture_data);
   if (f->server) {
     grpc_server_destroy(f->server);
   }
-  f->server = grpc_server_create(server_args, NULL);
-  grpc_server_register_completion_queue(f->server, f->cq, NULL);
+  f->server = grpc_server_create(server_args, nullptr);
+  grpc_server_register_completion_queue(f->server, f->cq, nullptr);
   GPR_ASSERT(grpc_server_add_secure_http2_port(f->server, ffd->localaddr,
                                                server_creds));
   grpc_server_credentials_release(server_creds);
   grpc_server_start(f->server);
 }
 
-void chttp2_tear_down_secure_fullstack(grpc_end2end_test_fixture *f) {
-  fullstack_secure_fixture_data *ffd = f->fixture_data;
+void chttp2_tear_down_secure_fullstack(grpc_end2end_test_fixture* f) {
+  fullstack_secure_fixture_data* ffd =
+      static_cast<fullstack_secure_fixture_data*>(f->fixture_data);
   gpr_free(ffd->localaddr);
   gpr_free(ffd);
 }
 
 static void chttp2_init_client_simple_ssl_with_oauth2_secure_fullstack(
-    grpc_end2end_test_fixture *f, grpc_channel_args *client_args) {
+    grpc_end2end_test_fixture* f, grpc_channel_args* client_args) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_channel_credentials *ssl_creds =
-      grpc_ssl_credentials_create(test_root_cert, NULL, NULL);
-  grpc_call_credentials *oauth2_creds = grpc_md_only_test_credentials_create(
+  grpc_channel_credentials* ssl_creds =
+      grpc_ssl_credentials_create(test_root_cert, nullptr, nullptr);
+  grpc_call_credentials* oauth2_creds = grpc_md_only_test_credentials_create(
       &exec_ctx, "authorization", oauth2_md, true /* is_async */);
-  grpc_channel_credentials *ssl_oauth2_creds =
-      grpc_composite_channel_credentials_create(ssl_creds, oauth2_creds, NULL);
-  grpc_arg ssl_name_override = {GRPC_ARG_STRING,
-                                GRPC_SSL_TARGET_NAME_OVERRIDE_ARG,
-                                {"foo.test.google.fr"}};
-  grpc_channel_args *new_client_args =
+  grpc_channel_credentials* ssl_oauth2_creds =
+      grpc_composite_channel_credentials_create(ssl_creds, oauth2_creds,
+                                                nullptr);
+  grpc_arg ssl_name_override = {
+      GRPC_ARG_STRING,
+      const_cast<char*>(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG),
+      {const_cast<char*>("foo.test.google.fr")}};
+  grpc_channel_args* new_client_args =
       grpc_channel_args_copy_and_add(client_args, &ssl_name_override, 1);
   chttp2_init_client_secure_fullstack(f, new_client_args, ssl_oauth2_creds);
   grpc_channel_args_destroy(&exec_ctx, new_client_args);
@@ -156,9 +164,9 @@ static void chttp2_init_client_simple_ssl_with_oauth2_secure_fullstack(
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static int fail_server_auth_check(grpc_channel_args *server_args) {
+static int fail_server_auth_check(grpc_channel_args* server_args) {
   size_t i;
-  if (server_args == NULL) return 0;
+  if (server_args == nullptr) return 0;
   for (i = 0; i < server_args->num_args; i++) {
     if (strcmp(server_args->args[i].key, FAIL_AUTH_CHECK_SERVER_ARG_NAME) ==
         0) {
@@ -168,14 +176,15 @@ static int fail_server_auth_check(grpc_channel_args *server_args) {
   return 0;
 }
 
-static void processor_destroy(void *state) {
-  test_processor_state *s = (test_processor_state *)state;
+static void processor_destroy(void* state) {
+  test_processor_state* s = (test_processor_state*)state;
   GPR_ASSERT((s->pseudo_refcount--) == 1);
   gpr_free(s);
 }
 
 static grpc_auth_metadata_processor test_processor_create(int failing) {
-  test_processor_state *s = gpr_malloc(sizeof(*s));
+  test_processor_state* s =
+      static_cast<test_processor_state*>(gpr_malloc(sizeof(*s)));
   grpc_auth_metadata_processor result;
   s->pseudo_refcount = 1;
   result.state = s;
@@ -189,11 +198,11 @@ static grpc_auth_metadata_processor test_processor_create(int failing) {
 }
 
 static void chttp2_init_server_simple_ssl_secure_fullstack(
-    grpc_end2end_test_fixture *f, grpc_channel_args *server_args) {
+    grpc_end2end_test_fixture* f, grpc_channel_args* server_args) {
   grpc_ssl_pem_key_cert_pair pem_key_cert_pair = {test_server1_key,
                                                   test_server1_cert};
-  grpc_server_credentials *ssl_creds =
-      grpc_ssl_server_credentials_create(NULL, &pem_key_cert_pair, 1, 0, NULL);
+  grpc_server_credentials* ssl_creds = grpc_ssl_server_credentials_create(
+      nullptr, &pem_key_cert_pair, 1, 0, nullptr);
   grpc_server_credentials_set_auth_metadata_processor(
       ssl_creds, test_processor_create(fail_server_auth_check(server_args)));
   chttp2_init_server_secure_fullstack(f, server_args, ssl_creds);
@@ -213,7 +222,7 @@ static grpc_end2end_test_config configs[] = {
      chttp2_tear_down_secure_fullstack},
 };
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   size_t i;
   grpc_test_init(argc, argv);
   grpc_end2end_tests_pre_init();
diff --git a/test/core/end2end/fixtures/h2_proxy.c b/test/core/end2end/fixtures/h2_proxy.cc
index 069130baf4..295654cb6a 100644
--- a/test/core/end2end/fixtures/h2_proxy.c
+++ b/test/core/end2end/fixtures/h2_proxy.cc
@@ -37,77 +37,82 @@
 #include "test/core/util/test_config.h"
 
 typedef struct fullstack_fixture_data {
-  grpc_end2end_proxy *proxy;
+  grpc_end2end_proxy* proxy;
 } fullstack_fixture_data;
 
-static grpc_server *create_proxy_server(const char *port,
-                                        grpc_channel_args *server_args) {
-  grpc_server *s = grpc_server_create(server_args, NULL);
+static grpc_server* create_proxy_server(const char* port,
+                                        grpc_channel_args* server_args) {
+  grpc_server* s = grpc_server_create(server_args, nullptr);
   GPR_ASSERT(grpc_server_add_insecure_http2_port(s, port));
   return s;
 }
 
-static grpc_channel *create_proxy_client(const char *target,
-                                         grpc_channel_args *client_args) {
-  return grpc_insecure_channel_create(target, client_args, NULL);
+static grpc_channel* create_proxy_client(const char* target,
+                                         grpc_channel_args* client_args) {
+  return grpc_insecure_channel_create(target, client_args, nullptr);
 }
 
 static const grpc_end2end_proxy_def proxy_def = {create_proxy_server,
                                                  create_proxy_client};
 
 static grpc_end2end_test_fixture chttp2_create_fixture_fullstack(
-    grpc_channel_args *client_args, grpc_channel_args *server_args) {
+    grpc_channel_args* client_args, grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
-  fullstack_fixture_data *ffd = gpr_malloc(sizeof(fullstack_fixture_data));
+  fullstack_fixture_data* ffd = static_cast<fullstack_fixture_data*>(
+      gpr_malloc(sizeof(fullstack_fixture_data)));
   memset(&f, 0, sizeof(f));
 
   ffd->proxy = grpc_end2end_proxy_create(&proxy_def, client_args, server_args);
 
   f.fixture_data = ffd;
-  f.cq = grpc_completion_queue_create_for_next(NULL);
-  f.shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
+  f.cq = grpc_completion_queue_create_for_next(nullptr);
+  f.shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
 
   return f;
 }
 
-void chttp2_init_client_fullstack(grpc_end2end_test_fixture *f,
-                                  grpc_channel_args *client_args) {
-  fullstack_fixture_data *ffd = f->fixture_data;
+void chttp2_init_client_fullstack(grpc_end2end_test_fixture* f,
+                                  grpc_channel_args* client_args) {
+  fullstack_fixture_data* ffd =
+      static_cast<fullstack_fixture_data*>(f->fixture_data);
   f->client = grpc_insecure_channel_create(
-      grpc_end2end_proxy_get_client_target(ffd->proxy), client_args, NULL);
+      grpc_end2end_proxy_get_client_target(ffd->proxy), client_args, nullptr);
   GPR_ASSERT(f->client);
 }
 
-void chttp2_init_server_fullstack(grpc_end2end_test_fixture *f,
-                                  grpc_channel_args *server_args) {
-  fullstack_fixture_data *ffd = f->fixture_data;
+void chttp2_init_server_fullstack(grpc_end2end_test_fixture* f,
+                                  grpc_channel_args* server_args) {
+  fullstack_fixture_data* ffd =
+      static_cast<fullstack_fixture_data*>(f->fixture_data);
   if (f->server) {
     grpc_server_destroy(f->server);
   }
-  f->server = grpc_server_create(server_args, NULL);
-  grpc_server_register_completion_queue(f->server, f->cq, NULL);
+  f->server = grpc_server_create(server_args, nullptr);
+  grpc_server_register_completion_queue(f->server, f->cq, nullptr);
   GPR_ASSERT(grpc_server_add_insecure_http2_port(
       f->server, grpc_end2end_proxy_get_server_port(ffd->proxy)));
   grpc_server_start(f->server);
 }
 
-void chttp2_tear_down_fullstack(grpc_end2end_test_fixture *f) {
-  fullstack_fixture_data *ffd = f->fixture_data;
+void chttp2_tear_down_fullstack(grpc_end2end_test_fixture* f) {
+  fullstack_fixture_data* ffd =
+      static_cast<fullstack_fixture_data*>(f->fixture_data);
   grpc_end2end_proxy_destroy(ffd->proxy);
   gpr_free(ffd);
 }
 
 /* All test configurations */
 static grpc_end2end_test_config configs[] = {
-    {"chttp2/fullstack+proxy", FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION |
-                                   FEATURE_MASK_SUPPORTS_REQUEST_PROXYING |
-                                   FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL |
-                                   FEATURE_MASK_SUPPORTS_AUTHORITY_HEADER,
+    {"chttp2/fullstack+proxy",
+     FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION |
+         FEATURE_MASK_SUPPORTS_REQUEST_PROXYING |
+         FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL |
+         FEATURE_MASK_SUPPORTS_AUTHORITY_HEADER,
      chttp2_create_fixture_fullstack, chttp2_init_client_fullstack,
      chttp2_init_server_fullstack, chttp2_tear_down_fullstack},
 };
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   size_t i;
 
   grpc_test_init(argc, argv);
diff --git a/test/core/end2end/fixtures/h2_sockpair+trace.c b/test/core/end2end/fixtures/h2_sockpair+trace.cc
index 39ccb84b52..fe4ab74843 100644
--- a/test/core/end2end/fixtures/h2_sockpair+trace.c
+++ b/test/core/end2end/fixtures/h2_sockpair+trace.cc
@@ -48,24 +48,24 @@
 /* chttp2 transport that is immediately available (used for testing
    connected_channel without a client_channel */
 
-static void server_setup_transport(void *ts, grpc_transport *transport) {
-  grpc_end2end_test_fixture *f = ts;
+static void server_setup_transport(void* ts, grpc_transport* transport) {
+  grpc_end2end_test_fixture* f = static_cast<grpc_end2end_test_fixture*>(ts);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_endpoint_pair *sfd = f->fixture_data;
+  grpc_endpoint_pair* sfd = static_cast<grpc_endpoint_pair*>(f->fixture_data);
   grpc_endpoint_add_to_pollset(&exec_ctx, sfd->server, grpc_cq_pollset(f->cq));
-  grpc_server_setup_transport(&exec_ctx, f->server, transport, NULL,
+  grpc_server_setup_transport(&exec_ctx, f->server, transport, nullptr,
                               grpc_server_get_channel_args(f->server));
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
 typedef struct {
-  grpc_end2end_test_fixture *f;
-  grpc_channel_args *client_args;
+  grpc_end2end_test_fixture* f;
+  grpc_channel_args* client_args;
 } sp_client_setup;
 
-static void client_setup_transport(grpc_exec_ctx *exec_ctx, void *ts,
-                                   grpc_transport *transport) {
-  sp_client_setup *cs = ts;
+static void client_setup_transport(grpc_exec_ctx* exec_ctx, void* ts,
+                                   grpc_transport* transport) {
+  sp_client_setup* cs = static_cast<sp_client_setup*>(ts);
 
   cs->f->client =
       grpc_channel_create(exec_ctx, "socketpair-target", cs->client_args,
@@ -73,25 +73,26 @@ static void client_setup_transport(grpc_exec_ctx *exec_ctx, void *ts,
 }
 
 static grpc_end2end_test_fixture chttp2_create_fixture_socketpair(
-    grpc_channel_args *client_args, grpc_channel_args *server_args) {
-  grpc_endpoint_pair *sfd = gpr_malloc(sizeof(grpc_endpoint_pair));
+    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+  grpc_endpoint_pair* sfd =
+      static_cast<grpc_endpoint_pair*>(gpr_malloc(sizeof(grpc_endpoint_pair)));
 
   grpc_end2end_test_fixture f;
   memset(&f, 0, sizeof(f));
   f.fixture_data = sfd;
-  f.cq = grpc_completion_queue_create_for_next(NULL);
-  f.shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
+  f.cq = grpc_completion_queue_create_for_next(nullptr);
+  f.shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
 
-  *sfd = grpc_iomgr_create_endpoint_pair("fixture", NULL);
+  *sfd = grpc_iomgr_create_endpoint_pair("fixture", nullptr);
 
   return f;
 }
 
-static void chttp2_init_client_socketpair(grpc_end2end_test_fixture *f,
-                                          grpc_channel_args *client_args) {
+static void chttp2_init_client_socketpair(grpc_end2end_test_fixture* f,
+                                          grpc_channel_args* client_args) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_endpoint_pair *sfd = f->fixture_data;
-  grpc_transport *transport;
+  grpc_endpoint_pair* sfd = static_cast<grpc_endpoint_pair*>(f->fixture_data);
+  grpc_transport* transport;
   sp_client_setup cs;
   cs.client_args = client_args;
   cs.f = f;
@@ -99,27 +100,27 @@ static void chttp2_init_client_socketpair(grpc_end2end_test_fixture *f,
       grpc_create_chttp2_transport(&exec_ctx, client_args, sfd->client, 1);
   client_setup_transport(&exec_ctx, &cs, transport);
   GPR_ASSERT(f->client);
-  grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL);
+  grpc_chttp2_transport_start_reading(&exec_ctx, transport, nullptr);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void chttp2_init_server_socketpair(grpc_end2end_test_fixture *f,
-                                          grpc_channel_args *server_args) {
+static void chttp2_init_server_socketpair(grpc_end2end_test_fixture* f,
+                                          grpc_channel_args* server_args) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_endpoint_pair *sfd = f->fixture_data;
-  grpc_transport *transport;
+  grpc_endpoint_pair* sfd = static_cast<grpc_endpoint_pair*>(f->fixture_data);
+  grpc_transport* transport;
   GPR_ASSERT(!f->server);
-  f->server = grpc_server_create(server_args, NULL);
-  grpc_server_register_completion_queue(f->server, f->cq, NULL);
+  f->server = grpc_server_create(server_args, nullptr);
+  grpc_server_register_completion_queue(f->server, f->cq, nullptr);
   grpc_server_start(f->server);
   transport =
       grpc_create_chttp2_transport(&exec_ctx, server_args, sfd->server, 0);
   server_setup_transport(f, transport);
-  grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL);
+  grpc_chttp2_transport_start_reading(&exec_ctx, transport, nullptr);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void chttp2_tear_down_socketpair(grpc_end2end_test_fixture *f) {
+static void chttp2_tear_down_socketpair(grpc_end2end_test_fixture* f) {
   gpr_free(f->fixture_data);
 }
 
@@ -130,7 +131,7 @@ static grpc_end2end_test_config configs[] = {
      chttp2_init_server_socketpair, chttp2_tear_down_socketpair},
 };
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   size_t i;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
diff --git a/test/core/end2end/fixtures/h2_sockpair.c b/test/core/end2end/fixtures/h2_sockpair.cc
index 03566ead9b..59a3a6db31 100644
--- a/test/core/end2end/fixtures/h2_sockpair.c
+++ b/test/core/end2end/fixtures/h2_sockpair.cc
@@ -42,24 +42,24 @@
 /* chttp2 transport that is immediately available (used for testing
    connected_channel without a client_channel */
 
-static void server_setup_transport(void *ts, grpc_transport *transport) {
-  grpc_end2end_test_fixture *f = ts;
+static void server_setup_transport(void* ts, grpc_transport* transport) {
+  grpc_end2end_test_fixture* f = static_cast<grpc_end2end_test_fixture*>(ts);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_endpoint_pair *sfd = f->fixture_data;
+  grpc_endpoint_pair* sfd = static_cast<grpc_endpoint_pair*>(f->fixture_data);
   grpc_endpoint_add_to_pollset(&exec_ctx, sfd->server, grpc_cq_pollset(f->cq));
-  grpc_server_setup_transport(&exec_ctx, f->server, transport, NULL,
+  grpc_server_setup_transport(&exec_ctx, f->server, transport, nullptr,
                               grpc_server_get_channel_args(f->server));
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
 typedef struct {
-  grpc_end2end_test_fixture *f;
-  grpc_channel_args *client_args;
+  grpc_end2end_test_fixture* f;
+  grpc_channel_args* client_args;
 } sp_client_setup;
 
-static void client_setup_transport(grpc_exec_ctx *exec_ctx, void *ts,
-                                   grpc_transport *transport) {
-  sp_client_setup *cs = ts;
+static void client_setup_transport(grpc_exec_ctx* exec_ctx, void* ts,
+                                   grpc_transport* transport) {
+  sp_client_setup* cs = static_cast<sp_client_setup*>(ts);
 
   cs->f->client =
       grpc_channel_create(exec_ctx, "socketpair-target", cs->client_args,
@@ -67,25 +67,26 @@ static void client_setup_transport(grpc_exec_ctx *exec_ctx, void *ts,
 }
 
 static grpc_end2end_test_fixture chttp2_create_fixture_socketpair(
-    grpc_channel_args *client_args, grpc_channel_args *server_args) {
-  grpc_endpoint_pair *sfd = gpr_malloc(sizeof(grpc_endpoint_pair));
+    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+  grpc_endpoint_pair* sfd =
+      static_cast<grpc_endpoint_pair*>(gpr_malloc(sizeof(grpc_endpoint_pair)));
 
   grpc_end2end_test_fixture f;
   memset(&f, 0, sizeof(f));
   f.fixture_data = sfd;
-  f.cq = grpc_completion_queue_create_for_next(NULL);
-  f.shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
+  f.cq = grpc_completion_queue_create_for_next(nullptr);
+  f.shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
 
-  *sfd = grpc_iomgr_create_endpoint_pair("fixture", NULL);
+  *sfd = grpc_iomgr_create_endpoint_pair("fixture", nullptr);
 
   return f;
 }
 
-static void chttp2_init_client_socketpair(grpc_end2end_test_fixture *f,
-                                          grpc_channel_args *client_args) {
+static void chttp2_init_client_socketpair(grpc_end2end_test_fixture* f,
+                                          grpc_channel_args* client_args) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_endpoint_pair *sfd = f->fixture_data;
-  grpc_transport *transport;
+  grpc_endpoint_pair* sfd = static_cast<grpc_endpoint_pair*>(f->fixture_data);
+  grpc_transport* transport;
   sp_client_setup cs;
   cs.client_args = client_args;
   cs.f = f;
@@ -93,27 +94,27 @@ static void chttp2_init_client_socketpair(grpc_end2end_test_fixture *f,
       grpc_create_chttp2_transport(&exec_ctx, client_args, sfd->client, 1);
   client_setup_transport(&exec_ctx, &cs, transport);
   GPR_ASSERT(f->client);
-  grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL);
+  grpc_chttp2_transport_start_reading(&exec_ctx, transport, nullptr);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void chttp2_init_server_socketpair(grpc_end2end_test_fixture *f,
-                                          grpc_channel_args *server_args) {
+static void chttp2_init_server_socketpair(grpc_end2end_test_fixture* f,
+                                          grpc_channel_args* server_args) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_endpoint_pair *sfd = f->fixture_data;
-  grpc_transport *transport;
+  grpc_endpoint_pair* sfd = static_cast<grpc_endpoint_pair*>(f->fixture_data);
+  grpc_transport* transport;
   GPR_ASSERT(!f->server);
-  f->server = grpc_server_create(server_args, NULL);
-  grpc_server_register_completion_queue(f->server, f->cq, NULL);
+  f->server = grpc_server_create(server_args, nullptr);
+  grpc_server_register_completion_queue(f->server, f->cq, nullptr);
   grpc_server_start(f->server);
   transport =
       grpc_create_chttp2_transport(&exec_ctx, server_args, sfd->server, 0);
   server_setup_transport(f, transport);
-  grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL);
+  grpc_chttp2_transport_start_reading(&exec_ctx, transport, nullptr);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void chttp2_tear_down_socketpair(grpc_end2end_test_fixture *f) {
+static void chttp2_tear_down_socketpair(grpc_end2end_test_fixture* f) {
   gpr_free(f->fixture_data);
 }
 
@@ -124,7 +125,7 @@ static grpc_end2end_test_config configs[] = {
      chttp2_init_server_socketpair, chttp2_tear_down_socketpair},
 };
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   size_t i;
 
   grpc_test_init(argc, argv);
diff --git a/test/core/end2end/fixtures/h2_sockpair_1byte.c b/test/core/end2end/fixtures/h2_sockpair_1byte.cc
index c75a3876d5..d935efbbac 100644
--- a/test/core/end2end/fixtures/h2_sockpair_1byte.c
+++ b/test/core/end2end/fixtures/h2_sockpair_1byte.cc
@@ -42,24 +42,24 @@
 /* chttp2 transport that is immediately available (used for testing
    connected_channel without a client_channel */
 
-static void server_setup_transport(void *ts, grpc_transport *transport) {
-  grpc_end2end_test_fixture *f = ts;
+static void server_setup_transport(void* ts, grpc_transport* transport) {
+  grpc_end2end_test_fixture* f = static_cast<grpc_end2end_test_fixture*>(ts);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_endpoint_pair *sfd = f->fixture_data;
+  grpc_endpoint_pair* sfd = static_cast<grpc_endpoint_pair*>(f->fixture_data);
   grpc_endpoint_add_to_pollset(&exec_ctx, sfd->server, grpc_cq_pollset(f->cq));
-  grpc_server_setup_transport(&exec_ctx, f->server, transport, NULL,
+  grpc_server_setup_transport(&exec_ctx, f->server, transport, nullptr,
                               grpc_server_get_channel_args(f->server));
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
 typedef struct {
-  grpc_end2end_test_fixture *f;
-  grpc_channel_args *client_args;
+  grpc_end2end_test_fixture* f;
+  grpc_channel_args* client_args;
 } sp_client_setup;
 
-static void client_setup_transport(grpc_exec_ctx *exec_ctx, void *ts,
-                                   grpc_transport *transport) {
-  sp_client_setup *cs = ts;
+static void client_setup_transport(grpc_exec_ctx* exec_ctx, void* ts,
+                                   grpc_transport* transport) {
+  sp_client_setup* cs = static_cast<sp_client_setup*>(ts);
 
   cs->f->client =
       grpc_channel_create(exec_ctx, "socketpair-target", cs->client_args,
@@ -67,35 +67,37 @@ static void client_setup_transport(grpc_exec_ctx *exec_ctx, void *ts,
 }
 
 static grpc_end2end_test_fixture chttp2_create_fixture_socketpair(
-    grpc_channel_args *client_args, grpc_channel_args *server_args) {
-  grpc_endpoint_pair *sfd = gpr_malloc(sizeof(grpc_endpoint_pair));
+    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+  grpc_endpoint_pair* sfd =
+      static_cast<grpc_endpoint_pair*>(gpr_malloc(sizeof(grpc_endpoint_pair)));
 
   grpc_end2end_test_fixture f;
   memset(&f, 0, sizeof(f));
   f.fixture_data = sfd;
-  f.cq = grpc_completion_queue_create_for_next(NULL);
-  f.shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
-
-  grpc_arg a[] = {{.key = GRPC_ARG_TCP_READ_CHUNK_SIZE,
-                   .type = GRPC_ARG_INTEGER,
-                   .value.integer = 1},
-                  {.key = GRPC_ARG_TCP_MIN_READ_CHUNK_SIZE,
-                   .type = GRPC_ARG_INTEGER,
-                   .value.integer = 1},
-                  {.key = GRPC_ARG_TCP_MAX_READ_CHUNK_SIZE,
-                   .type = GRPC_ARG_INTEGER,
-                   .value.integer = 1}};
-  grpc_channel_args args = {.num_args = GPR_ARRAY_SIZE(a), .args = a};
+  f.cq = grpc_completion_queue_create_for_next(nullptr);
+  f.shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
+
+  grpc_arg a[3];
+  a[0].key = const_cast<char*>(GRPC_ARG_TCP_READ_CHUNK_SIZE);
+  a[0].type = GRPC_ARG_INTEGER;
+  a[0].value.integer = 1;
+  a[1].key = const_cast<char*>(GRPC_ARG_TCP_MIN_READ_CHUNK_SIZE);
+  a[1].type = GRPC_ARG_INTEGER;
+  a[1].value.integer = 1;
+  a[2].key = const_cast<char*>(GRPC_ARG_TCP_MAX_READ_CHUNK_SIZE);
+  a[2].type = GRPC_ARG_INTEGER;
+  a[2].value.integer = 1;
+  grpc_channel_args args = {GPR_ARRAY_SIZE(a), a};
   *sfd = grpc_iomgr_create_endpoint_pair("fixture", &args);
 
   return f;
 }
 
-static void chttp2_init_client_socketpair(grpc_end2end_test_fixture *f,
-                                          grpc_channel_args *client_args) {
+static void chttp2_init_client_socketpair(grpc_end2end_test_fixture* f,
+                                          grpc_channel_args* client_args) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_endpoint_pair *sfd = f->fixture_data;
-  grpc_transport *transport;
+  grpc_endpoint_pair* sfd = static_cast<grpc_endpoint_pair*>(f->fixture_data);
+  grpc_transport* transport;
   sp_client_setup cs;
   cs.client_args = client_args;
   cs.f = f;
@@ -103,27 +105,27 @@ static void chttp2_init_client_socketpair(grpc_end2end_test_fixture *f,
       grpc_create_chttp2_transport(&exec_ctx, client_args, sfd->client, 1);
   client_setup_transport(&exec_ctx, &cs, transport);
   GPR_ASSERT(f->client);
-  grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL);
+  grpc_chttp2_transport_start_reading(&exec_ctx, transport, nullptr);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void chttp2_init_server_socketpair(grpc_end2end_test_fixture *f,
-                                          grpc_channel_args *server_args) {
+static void chttp2_init_server_socketpair(grpc_end2end_test_fixture* f,
+                                          grpc_channel_args* server_args) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_endpoint_pair *sfd = f->fixture_data;
-  grpc_transport *transport;
+  grpc_endpoint_pair* sfd = static_cast<grpc_endpoint_pair*>(f->fixture_data);
+  grpc_transport* transport;
   GPR_ASSERT(!f->server);
-  f->server = grpc_server_create(server_args, NULL);
-  grpc_server_register_completion_queue(f->server, f->cq, NULL);
+  f->server = grpc_server_create(server_args, nullptr);
+  grpc_server_register_completion_queue(f->server, f->cq, nullptr);
   grpc_server_start(f->server);
   transport =
       grpc_create_chttp2_transport(&exec_ctx, server_args, sfd->server, 0);
   server_setup_transport(f, transport);
-  grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL);
+  grpc_chttp2_transport_start_reading(&exec_ctx, transport, nullptr);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void chttp2_tear_down_socketpair(grpc_end2end_test_fixture *f) {
+static void chttp2_tear_down_socketpair(grpc_end2end_test_fixture* f) {
   gpr_free(f->fixture_data);
 }
 
@@ -135,7 +137,7 @@ static grpc_end2end_test_config configs[] = {
      chttp2_tear_down_socketpair},
 };
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   size_t i;
 
   g_fixture_slowdown_factor = 2;
diff --git a/test/core/end2end/fixtures/h2_ssl.c b/test/core/end2end/fixtures/h2_ssl.cc
index 0bac464e69..3d7e2e327e 100644
--- a/test/core/end2end/fixtures/h2_ssl.c
+++ b/test/core/end2end/fixtures/h2_ssl.cc
@@ -35,73 +35,78 @@
 #include "test/core/util/test_config.h"
 
 typedef struct fullstack_secure_fixture_data {
-  char *localaddr;
+  char* localaddr;
 } fullstack_secure_fixture_data;
 
 static grpc_end2end_test_fixture chttp2_create_fixture_secure_fullstack(
-    grpc_channel_args *client_args, grpc_channel_args *server_args) {
+    grpc_channel_args* client_args, grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   int port = grpc_pick_unused_port_or_die();
-  fullstack_secure_fixture_data *ffd =
-      gpr_malloc(sizeof(fullstack_secure_fixture_data));
+  fullstack_secure_fixture_data* ffd =
+      static_cast<fullstack_secure_fixture_data*>(
+          gpr_malloc(sizeof(fullstack_secure_fixture_data)));
   memset(&f, 0, sizeof(f));
 
   gpr_join_host_port(&ffd->localaddr, "localhost", port);
 
   f.fixture_data = ffd;
-  f.cq = grpc_completion_queue_create_for_next(NULL);
-  f.shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
+  f.cq = grpc_completion_queue_create_for_next(nullptr);
+  f.shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
 
   return f;
 }
 
-static void process_auth_failure(void *state, grpc_auth_context *ctx,
-                                 const grpc_metadata *md, size_t md_count,
+static void process_auth_failure(void* state, grpc_auth_context* ctx,
+                                 const grpc_metadata* md, size_t md_count,
                                  grpc_process_auth_metadata_done_cb cb,
-                                 void *user_data) {
-  GPR_ASSERT(state == NULL);
-  cb(user_data, NULL, 0, NULL, 0, GRPC_STATUS_UNAUTHENTICATED, NULL);
+                                 void* user_data) {
+  GPR_ASSERT(state == nullptr);
+  cb(user_data, nullptr, 0, nullptr, 0, GRPC_STATUS_UNAUTHENTICATED, nullptr);
 }
 
 static void chttp2_init_client_secure_fullstack(
-    grpc_end2end_test_fixture *f, grpc_channel_args *client_args,
-    grpc_channel_credentials *creds) {
-  fullstack_secure_fixture_data *ffd = f->fixture_data;
+    grpc_end2end_test_fixture* f, grpc_channel_args* client_args,
+    grpc_channel_credentials* creds) {
+  fullstack_secure_fixture_data* ffd =
+      static_cast<fullstack_secure_fixture_data*>(f->fixture_data);
   f->client =
-      grpc_secure_channel_create(creds, ffd->localaddr, client_args, NULL);
-  GPR_ASSERT(f->client != NULL);
+      grpc_secure_channel_create(creds, ffd->localaddr, client_args, nullptr);
+  GPR_ASSERT(f->client != nullptr);
   grpc_channel_credentials_release(creds);
 }
 
 static void chttp2_init_server_secure_fullstack(
-    grpc_end2end_test_fixture *f, grpc_channel_args *server_args,
-    grpc_server_credentials *server_creds) {
-  fullstack_secure_fixture_data *ffd = f->fixture_data;
+    grpc_end2end_test_fixture* f, grpc_channel_args* server_args,
+    grpc_server_credentials* server_creds) {
+  fullstack_secure_fixture_data* ffd =
+      static_cast<fullstack_secure_fixture_data*>(f->fixture_data);
   if (f->server) {
     grpc_server_destroy(f->server);
   }
-  f->server = grpc_server_create(server_args, NULL);
-  grpc_server_register_completion_queue(f->server, f->cq, NULL);
+  f->server = grpc_server_create(server_args, nullptr);
+  grpc_server_register_completion_queue(f->server, f->cq, nullptr);
   GPR_ASSERT(grpc_server_add_secure_http2_port(f->server, ffd->localaddr,
                                                server_creds));
   grpc_server_credentials_release(server_creds);
   grpc_server_start(f->server);
 }
 
-void chttp2_tear_down_secure_fullstack(grpc_end2end_test_fixture *f) {
-  fullstack_secure_fixture_data *ffd = f->fixture_data;
+void chttp2_tear_down_secure_fullstack(grpc_end2end_test_fixture* f) {
+  fullstack_secure_fixture_data* ffd =
+      static_cast<fullstack_secure_fixture_data*>(f->fixture_data);
   gpr_free(ffd->localaddr);
   gpr_free(ffd);
 }
 
 static void chttp2_init_client_simple_ssl_secure_fullstack(
-    grpc_end2end_test_fixture *f, grpc_channel_args *client_args) {
-  grpc_channel_credentials *ssl_creds =
-      grpc_ssl_credentials_create(NULL, NULL, NULL);
-  grpc_arg ssl_name_override = {GRPC_ARG_STRING,
-                                GRPC_SSL_TARGET_NAME_OVERRIDE_ARG,
-                                {"foo.test.google.fr"}};
-  grpc_channel_args *new_client_args =
+    grpc_end2end_test_fixture* f, grpc_channel_args* client_args) {
+  grpc_channel_credentials* ssl_creds =
+      grpc_ssl_credentials_create(nullptr, nullptr, nullptr);
+  grpc_arg ssl_name_override = {
+      GRPC_ARG_STRING,
+      const_cast<char*>(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG),
+      {const_cast<char*>("foo.test.google.fr")}};
+  grpc_channel_args* new_client_args =
       grpc_channel_args_copy_and_add(client_args, &ssl_name_override, 1);
   chttp2_init_client_secure_fullstack(f, new_client_args, ssl_creds);
   {
@@ -111,9 +116,9 @@ static void chttp2_init_client_simple_ssl_secure_fullstack(
   }
 }
 
-static int fail_server_auth_check(grpc_channel_args *server_args) {
+static int fail_server_auth_check(grpc_channel_args* server_args) {
   size_t i;
-  if (server_args == NULL) return 0;
+  if (server_args == nullptr) return 0;
   for (i = 0; i < server_args->num_args; i++) {
     if (strcmp(server_args->args[i].key, FAIL_AUTH_CHECK_SERVER_ARG_NAME) ==
         0) {
@@ -124,13 +129,14 @@ static int fail_server_auth_check(grpc_channel_args *server_args) {
 }
 
 static void chttp2_init_server_simple_ssl_secure_fullstack(
-    grpc_end2end_test_fixture *f, grpc_channel_args *server_args) {
+    grpc_end2end_test_fixture* f, grpc_channel_args* server_args) {
   grpc_ssl_pem_key_cert_pair pem_cert_key_pair = {test_server1_key,
                                                   test_server1_cert};
-  grpc_server_credentials *ssl_creds =
-      grpc_ssl_server_credentials_create(NULL, &pem_cert_key_pair, 1, 0, NULL);
+  grpc_server_credentials* ssl_creds = grpc_ssl_server_credentials_create(
+      nullptr, &pem_cert_key_pair, 1, 0, nullptr);
   if (fail_server_auth_check(server_args)) {
-    grpc_auth_metadata_processor processor = {process_auth_failure, NULL, NULL};
+    grpc_auth_metadata_processor processor = {process_auth_failure, nullptr,
+                                              nullptr};
     grpc_server_credentials_set_auth_metadata_processor(ssl_creds, processor);
   }
   chttp2_init_server_secure_fullstack(f, server_args, ssl_creds);
@@ -150,19 +156,19 @@ static grpc_end2end_test_config configs[] = {
      chttp2_tear_down_secure_fullstack},
 };
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   size_t i;
-  FILE *roots_file;
+  FILE* roots_file;
   size_t roots_size = strlen(test_root_cert);
-  char *roots_filename;
+  char* roots_filename;
 
   grpc_test_init(argc, argv);
   grpc_end2end_tests_pre_init();
 
   /* Set the SSL roots env var. */
   roots_file = gpr_tmpfile("chttp2_simple_ssl_fullstack_test", &roots_filename);
-  GPR_ASSERT(roots_filename != NULL);
-  GPR_ASSERT(roots_file != NULL);
+  GPR_ASSERT(roots_filename != nullptr);
+  GPR_ASSERT(roots_file != nullptr);
   GPR_ASSERT(fwrite(test_root_cert, 1, roots_size, roots_file) == roots_size);
   fclose(roots_file);
   gpr_setenv(GRPC_DEFAULT_SSL_ROOTS_FILE_PATH_ENV_VAR, roots_filename);
diff --git a/test/core/end2end/fixtures/h2_ssl_proxy.c b/test/core/end2end/fixtures/h2_ssl_proxy.cc
index 8bc7183510..f8d5a699e4 100644
--- a/test/core/end2end/fixtures/h2_ssl_proxy.c
+++ b/test/core/end2end/fixtures/h2_ssl_proxy.cc
@@ -36,33 +36,34 @@
 #include "test/core/util/test_config.h"
 
 typedef struct fullstack_secure_fixture_data {
-  grpc_end2end_proxy *proxy;
+  grpc_end2end_proxy* proxy;
 } fullstack_secure_fixture_data;
 
-static grpc_server *create_proxy_server(const char *port,
-                                        grpc_channel_args *server_args) {
-  grpc_server *s = grpc_server_create(server_args, NULL);
+static grpc_server* create_proxy_server(const char* port,
+                                        grpc_channel_args* server_args) {
+  grpc_server* s = grpc_server_create(server_args, nullptr);
   grpc_ssl_pem_key_cert_pair pem_cert_key_pair = {test_server1_key,
                                                   test_server1_cert};
-  grpc_server_credentials *ssl_creds =
-      grpc_ssl_server_credentials_create(NULL, &pem_cert_key_pair, 1, 0, NULL);
+  grpc_server_credentials* ssl_creds = grpc_ssl_server_credentials_create(
+      nullptr, &pem_cert_key_pair, 1, 0, nullptr);
   GPR_ASSERT(grpc_server_add_secure_http2_port(s, port, ssl_creds));
   grpc_server_credentials_release(ssl_creds);
   return s;
 }
 
-static grpc_channel *create_proxy_client(const char *target,
-                                         grpc_channel_args *client_args) {
-  grpc_channel *channel;
-  grpc_channel_credentials *ssl_creds =
-      grpc_ssl_credentials_create(NULL, NULL, NULL);
-  grpc_arg ssl_name_override = {GRPC_ARG_STRING,
-                                GRPC_SSL_TARGET_NAME_OVERRIDE_ARG,
-                                {"foo.test.google.fr"}};
-  grpc_channel_args *new_client_args =
+static grpc_channel* create_proxy_client(const char* target,
+                                         grpc_channel_args* client_args) {
+  grpc_channel* channel;
+  grpc_channel_credentials* ssl_creds =
+      grpc_ssl_credentials_create(nullptr, nullptr, nullptr);
+  grpc_arg ssl_name_override = {
+      GRPC_ARG_STRING,
+      const_cast<char*>(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG),
+      {const_cast<char*>("foo.test.google.fr")}};
+  grpc_channel_args* new_client_args =
       grpc_channel_args_copy_and_add(client_args, &ssl_name_override, 1);
   channel =
-      grpc_secure_channel_create(ssl_creds, target, new_client_args, NULL);
+      grpc_secure_channel_create(ssl_creds, target, new_client_args, nullptr);
   grpc_channel_credentials_release(ssl_creds);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -76,69 +77,74 @@ static const grpc_end2end_proxy_def proxy_def = {create_proxy_server,
                                                  create_proxy_client};
 
 static grpc_end2end_test_fixture chttp2_create_fixture_secure_fullstack(
-    grpc_channel_args *client_args, grpc_channel_args *server_args) {
+    grpc_channel_args* client_args, grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
-  fullstack_secure_fixture_data *ffd =
-      gpr_malloc(sizeof(fullstack_secure_fixture_data));
+  fullstack_secure_fixture_data* ffd =
+      static_cast<fullstack_secure_fixture_data*>(
+          gpr_malloc(sizeof(fullstack_secure_fixture_data)));
   memset(&f, 0, sizeof(f));
 
   ffd->proxy = grpc_end2end_proxy_create(&proxy_def, client_args, server_args);
 
   f.fixture_data = ffd;
-  f.cq = grpc_completion_queue_create_for_next(NULL);
-  f.shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
+  f.cq = grpc_completion_queue_create_for_next(nullptr);
+  f.shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
 
   return f;
 }
 
-static void process_auth_failure(void *state, grpc_auth_context *ctx,
-                                 const grpc_metadata *md, size_t md_count,
+static void process_auth_failure(void* state, grpc_auth_context* ctx,
+                                 const grpc_metadata* md, size_t md_count,
                                  grpc_process_auth_metadata_done_cb cb,
-                                 void *user_data) {
-  GPR_ASSERT(state == NULL);
-  cb(user_data, NULL, 0, NULL, 0, GRPC_STATUS_UNAUTHENTICATED, NULL);
+                                 void* user_data) {
+  GPR_ASSERT(state == nullptr);
+  cb(user_data, nullptr, 0, nullptr, 0, GRPC_STATUS_UNAUTHENTICATED, nullptr);
 }
 
 static void chttp2_init_client_secure_fullstack(
-    grpc_end2end_test_fixture *f, grpc_channel_args *client_args,
-    grpc_channel_credentials *creds) {
-  fullstack_secure_fixture_data *ffd = f->fixture_data;
+    grpc_end2end_test_fixture* f, grpc_channel_args* client_args,
+    grpc_channel_credentials* creds) {
+  fullstack_secure_fixture_data* ffd =
+      static_cast<fullstack_secure_fixture_data*>(f->fixture_data);
   f->client = grpc_secure_channel_create(
       creds, grpc_end2end_proxy_get_client_target(ffd->proxy), client_args,
-      NULL);
-  GPR_ASSERT(f->client != NULL);
+      nullptr);
+  GPR_ASSERT(f->client != nullptr);
   grpc_channel_credentials_release(creds);
 }
 
 static void chttp2_init_server_secure_fullstack(
-    grpc_end2end_test_fixture *f, grpc_channel_args *server_args,
-    grpc_server_credentials *server_creds) {
-  fullstack_secure_fixture_data *ffd = f->fixture_data;
+    grpc_end2end_test_fixture* f, grpc_channel_args* server_args,
+    grpc_server_credentials* server_creds) {
+  fullstack_secure_fixture_data* ffd =
+      static_cast<fullstack_secure_fixture_data*>(f->fixture_data);
   if (f->server) {
     grpc_server_destroy(f->server);
   }
-  f->server = grpc_server_create(server_args, NULL);
-  grpc_server_register_completion_queue(f->server, f->cq, NULL);
+  f->server = grpc_server_create(server_args, nullptr);
+  grpc_server_register_completion_queue(f->server, f->cq, nullptr);
   GPR_ASSERT(grpc_server_add_secure_http2_port(
       f->server, grpc_end2end_proxy_get_server_port(ffd->proxy), server_creds));
   grpc_server_credentials_release(server_creds);
   grpc_server_start(f->server);
 }
 
-void chttp2_tear_down_secure_fullstack(grpc_end2end_test_fixture *f) {
-  fullstack_secure_fixture_data *ffd = f->fixture_data;
+void chttp2_tear_down_secure_fullstack(grpc_end2end_test_fixture* f) {
+  fullstack_secure_fixture_data* ffd =
+      static_cast<fullstack_secure_fixture_data*>(f->fixture_data);
   grpc_end2end_proxy_destroy(ffd->proxy);
   gpr_free(ffd);
 }
 
 static void chttp2_init_client_simple_ssl_secure_fullstack(
-    grpc_end2end_test_fixture *f, grpc_channel_args *client_args) {
-  grpc_channel_credentials *ssl_creds =
-      grpc_ssl_credentials_create(NULL, NULL, NULL);
-  grpc_arg ssl_name_override = {GRPC_ARG_STRING,
-                                GRPC_SSL_TARGET_NAME_OVERRIDE_ARG,
-                                {"foo.test.google.fr"}};
-  grpc_channel_args *new_client_args =
+    grpc_end2end_test_fixture* f, grpc_channel_args* client_args) {
+  grpc_channel_credentials* ssl_creds =
+      grpc_ssl_credentials_create(nullptr, nullptr, nullptr);
+  grpc_arg ssl_name_override = {
+      GRPC_ARG_STRING,
+      const_cast<char*>(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG),
+      {const_cast<char*>("foo.test.google.fr")}};
+  grpc_channel_args* new_client_args =
       grpc_channel_args_copy_and_add(client_args, &ssl_name_override, 1);
   chttp2_init_client_secure_fullstack(f, new_client_args, ssl_creds);
   {
@@ -148,9 +154,9 @@ static void chttp2_init_client_simple_ssl_secure_fullstack(
   }
 }
 
-static int fail_server_auth_check(grpc_channel_args *server_args) {
+static int fail_server_auth_check(grpc_channel_args* server_args) {
   size_t i;
-  if (server_args == NULL) return 0;
+  if (server_args == nullptr) return 0;
   for (i = 0; i < server_args->num_args; i++) {
     if (strcmp(server_args->args[i].key, FAIL_AUTH_CHECK_SERVER_ARG_NAME) ==
         0) {
@@ -161,13 +167,14 @@ static int fail_server_auth_check(grpc_channel_args *server_args) {
 }
 
 static void chttp2_init_server_simple_ssl_secure_fullstack(
-    grpc_end2end_test_fixture *f, grpc_channel_args *server_args) {
+    grpc_end2end_test_fixture* f, grpc_channel_args* server_args) {
   grpc_ssl_pem_key_cert_pair pem_cert_key_pair = {test_server1_key,
                                                   test_server1_cert};
-  grpc_server_credentials *ssl_creds =
-      grpc_ssl_server_credentials_create(NULL, &pem_cert_key_pair, 1, 0, NULL);
+  grpc_server_credentials* ssl_creds = grpc_ssl_server_credentials_create(
+      nullptr, &pem_cert_key_pair, 1, 0, nullptr);
   if (fail_server_auth_check(server_args)) {
-    grpc_auth_metadata_processor processor = {process_auth_failure, NULL, NULL};
+    grpc_auth_metadata_processor processor = {process_auth_failure, nullptr,
+                                              nullptr};
     grpc_server_credentials_set_auth_metadata_processor(ssl_creds, processor);
   }
   chttp2_init_server_secure_fullstack(f, server_args, ssl_creds);
@@ -188,19 +195,19 @@ static grpc_end2end_test_config configs[] = {
      chttp2_tear_down_secure_fullstack},
 };
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   size_t i;
-  FILE *roots_file;
+  FILE* roots_file;
   size_t roots_size = strlen(test_root_cert);
-  char *roots_filename;
+  char* roots_filename;
 
   grpc_test_init(argc, argv);
   grpc_end2end_tests_pre_init();
 
   /* Set the SSL roots env var. */
   roots_file = gpr_tmpfile("chttp2_simple_ssl_fullstack_test", &roots_filename);
-  GPR_ASSERT(roots_filename != NULL);
-  GPR_ASSERT(roots_file != NULL);
+  GPR_ASSERT(roots_filename != nullptr);
+  GPR_ASSERT(roots_file != nullptr);
   GPR_ASSERT(fwrite(test_root_cert, 1, roots_size, roots_file) == roots_size);
   fclose(roots_file);
   gpr_setenv(GRPC_DEFAULT_SSL_ROOTS_FILE_PATH_ENV_VAR, roots_filename);
diff --git a/test/core/end2end/fixtures/h2_uds.c b/test/core/end2end/fixtures/h2_uds.cc
index 05a31985e7..28f0a50e15 100644
--- a/test/core/end2end/fixtures/h2_uds.c
+++ b/test/core/end2end/fixtures/h2_uds.cc
@@ -40,61 +40,67 @@
 #include "test/core/util/test_config.h"
 
 typedef struct fullstack_fixture_data {
-  char *localaddr;
+  char* localaddr;
 } fullstack_fixture_data;
 
 static int unique = 1;
 
 static grpc_end2end_test_fixture chttp2_create_fixture_fullstack(
-    grpc_channel_args *client_args, grpc_channel_args *server_args) {
+    grpc_channel_args* client_args, grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
-  fullstack_fixture_data *ffd = gpr_malloc(sizeof(fullstack_fixture_data));
+  fullstack_fixture_data* ffd = static_cast<fullstack_fixture_data*>(
+      gpr_malloc(sizeof(fullstack_fixture_data)));
   memset(&f, 0, sizeof(f));
 
   gpr_asprintf(&ffd->localaddr, "unix:/tmp/grpc_fullstack_test.%d.%d", getpid(),
                unique++);
 
   f.fixture_data = ffd;
-  f.cq = grpc_completion_queue_create_for_next(NULL);
-  f.shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
+  f.cq = grpc_completion_queue_create_for_next(nullptr);
+  f.shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
 
   return f;
 }
 
-void chttp2_init_client_fullstack(grpc_end2end_test_fixture *f,
-                                  grpc_channel_args *client_args) {
-  fullstack_fixture_data *ffd = f->fixture_data;
-  f->client = grpc_insecure_channel_create(ffd->localaddr, client_args, NULL);
+void chttp2_init_client_fullstack(grpc_end2end_test_fixture* f,
+                                  grpc_channel_args* client_args) {
+  fullstack_fixture_data* ffd =
+      static_cast<fullstack_fixture_data*>(f->fixture_data);
+  f->client =
+      grpc_insecure_channel_create(ffd->localaddr, client_args, nullptr);
 }
 
-void chttp2_init_server_fullstack(grpc_end2end_test_fixture *f,
-                                  grpc_channel_args *server_args) {
-  fullstack_fixture_data *ffd = f->fixture_data;
+void chttp2_init_server_fullstack(grpc_end2end_test_fixture* f,
+                                  grpc_channel_args* server_args) {
+  fullstack_fixture_data* ffd =
+      static_cast<fullstack_fixture_data*>(f->fixture_data);
   if (f->server) {
     grpc_server_destroy(f->server);
   }
-  f->server = grpc_server_create(server_args, NULL);
-  grpc_server_register_completion_queue(f->server, f->cq, NULL);
+  f->server = grpc_server_create(server_args, nullptr);
+  grpc_server_register_completion_queue(f->server, f->cq, nullptr);
   GPR_ASSERT(grpc_server_add_insecure_http2_port(f->server, ffd->localaddr));
   grpc_server_start(f->server);
 }
 
-void chttp2_tear_down_fullstack(grpc_end2end_test_fixture *f) {
-  fullstack_fixture_data *ffd = f->fixture_data;
+void chttp2_tear_down_fullstack(grpc_end2end_test_fixture* f) {
+  fullstack_fixture_data* ffd =
+      static_cast<fullstack_fixture_data*>(f->fixture_data);
   gpr_free(ffd->localaddr);
   gpr_free(ffd);
 }
 
 /* All test configurations */
 static grpc_end2end_test_config configs[] = {
-    {"chttp2/fullstack_uds", FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION |
-                                 FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL |
-                                 FEATURE_MASK_SUPPORTS_AUTHORITY_HEADER,
+    {"chttp2/fullstack_uds",
+     FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION |
+         FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL |
+         FEATURE_MASK_SUPPORTS_AUTHORITY_HEADER,
      chttp2_create_fixture_fullstack, chttp2_init_client_fullstack,
      chttp2_init_server_fullstack, chttp2_tear_down_fullstack},
 };
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   size_t i;
 
   grpc_test_init(argc, argv);
diff --git a/test/core/end2end/fixtures/http_proxy_fixture.c b/test/core/end2end/fixtures/http_proxy_fixture.cc
index d29401fdc3..ac0c953a79 100644
--- a/test/core/end2end/fixtures/http_proxy_fixture.c
+++ b/test/core/end2end/fixtures/http_proxy_fixture.cc
@@ -88,9 +88,11 @@ typedef struct proxy_connection {
 
   grpc_slice_buffer client_read_buffer;
   grpc_slice_buffer client_deferred_write_buffer;
+  bool client_is_writing;
   grpc_slice_buffer client_write_buffer;
   grpc_slice_buffer server_read_buffer;
   grpc_slice_buffer server_deferred_write_buffer;
+  bool server_is_writing;
   grpc_slice_buffer server_write_buffer;
 
   grpc_http_parser http_parser;
@@ -108,7 +110,7 @@ static void proxy_connection_unref(grpc_exec_ctx* exec_ctx,
     gpr_log(GPR_DEBUG, "endpoints: %p %p", conn->client_endpoint,
             conn->server_endpoint);
     grpc_endpoint_destroy(exec_ctx, conn->client_endpoint);
-    if (conn->server_endpoint != NULL) {
+    if (conn->server_endpoint != nullptr) {
       grpc_endpoint_destroy(exec_ctx, conn->server_endpoint);
     }
     grpc_pollset_set_destroy(exec_ctx, conn->pollset_set);
@@ -137,7 +139,7 @@ static void proxy_connection_failed(grpc_exec_ctx* exec_ctx,
 
   grpc_endpoint_shutdown(exec_ctx, conn->client_endpoint,
                          GRPC_ERROR_REF(error));
-  if (conn->server_endpoint != NULL) {
+  if (conn->server_endpoint != nullptr) {
     grpc_endpoint_shutdown(exec_ctx, conn->server_endpoint,
                            GRPC_ERROR_REF(error));
   }
@@ -148,6 +150,7 @@ static void proxy_connection_failed(grpc_exec_ctx* exec_ctx,
 static void on_client_write_done(grpc_exec_ctx* exec_ctx, void* arg,
                                  grpc_error* error) {
   proxy_connection* conn = (proxy_connection*)arg;
+  conn->client_is_writing = false;
   if (error != GRPC_ERROR_NONE) {
     proxy_connection_failed(exec_ctx, conn, true /* is_client */,
                             "HTTP proxy client write", error);
@@ -160,6 +163,7 @@ static void on_client_write_done(grpc_exec_ctx* exec_ctx, void* arg,
   if (conn->client_deferred_write_buffer.length > 0) {
     grpc_slice_buffer_move_into(&conn->client_deferred_write_buffer,
                                 &conn->client_write_buffer);
+    conn->client_is_writing = true;
     grpc_endpoint_write(exec_ctx, conn->client_endpoint,
                         &conn->client_write_buffer,
                         &conn->on_client_write_done);
@@ -173,6 +177,7 @@ static void on_client_write_done(grpc_exec_ctx* exec_ctx, void* arg,
 static void on_server_write_done(grpc_exec_ctx* exec_ctx, void* arg,
                                  grpc_error* error) {
   proxy_connection* conn = (proxy_connection*)arg;
+  conn->server_is_writing = false;
   if (error != GRPC_ERROR_NONE) {
     proxy_connection_failed(exec_ctx, conn, false /* is_client */,
                             "HTTP proxy server write", error);
@@ -185,6 +190,7 @@ static void on_server_write_done(grpc_exec_ctx* exec_ctx, void* arg,
   if (conn->server_deferred_write_buffer.length > 0) {
     grpc_slice_buffer_move_into(&conn->server_deferred_write_buffer,
                                 &conn->server_write_buffer);
+    conn->server_is_writing = true;
     grpc_endpoint_write(exec_ctx, conn->server_endpoint,
                         &conn->server_write_buffer,
                         &conn->on_server_write_done);
@@ -210,13 +216,14 @@ static void on_client_read_done(grpc_exec_ctx* exec_ctx, void* arg,
   // the current write is finished.
   //
   // Otherwise, move the read data into the write buffer and write it.
-  if (conn->server_write_buffer.length > 0) {
+  if (conn->server_is_writing) {
     grpc_slice_buffer_move_into(&conn->client_read_buffer,
                                 &conn->server_deferred_write_buffer);
   } else {
     grpc_slice_buffer_move_into(&conn->client_read_buffer,
                                 &conn->server_write_buffer);
     proxy_connection_ref(conn, "client_read");
+    conn->server_is_writing = true;
     grpc_endpoint_write(exec_ctx, conn->server_endpoint,
                         &conn->server_write_buffer,
                         &conn->on_server_write_done);
@@ -242,13 +249,14 @@ static void on_server_read_done(grpc_exec_ctx* exec_ctx, void* arg,
   // the current write is finished.
   //
   // Otherwise, move the read data into the write buffer and write it.
-  if (conn->client_write_buffer.length > 0) {
+  if (conn->client_is_writing) {
     grpc_slice_buffer_move_into(&conn->server_read_buffer,
                                 &conn->client_deferred_write_buffer);
   } else {
     grpc_slice_buffer_move_into(&conn->server_read_buffer,
                                 &conn->client_write_buffer);
     proxy_connection_ref(conn, "server_read");
+    conn->client_is_writing = true;
     grpc_endpoint_write(exec_ctx, conn->client_endpoint,
                         &conn->client_write_buffer,
                         &conn->on_client_write_done);
@@ -262,6 +270,7 @@ static void on_server_read_done(grpc_exec_ctx* exec_ctx, void* arg,
 static void on_write_response_done(grpc_exec_ctx* exec_ctx, void* arg,
                                    grpc_error* error) {
   proxy_connection* conn = (proxy_connection*)arg;
+  conn->client_is_writing = false;
   if (error != GRPC_ERROR_NONE) {
     proxy_connection_failed(exec_ctx, conn, true /* is_client */,
                             "HTTP proxy write response", error);
@@ -302,6 +311,7 @@ static void on_server_connect_done(grpc_exec_ctx* exec_ctx, void* arg,
   grpc_slice slice =
       grpc_slice_from_copied_string("HTTP/1.0 200 connected\r\n\r\n");
   grpc_slice_buffer_add(&conn->client_write_buffer, slice);
+  conn->client_is_writing = true;
   grpc_endpoint_write(exec_ctx, conn->client_endpoint,
                       &conn->client_write_buffer,
                       &conn->on_write_response_done);
@@ -315,8 +325,8 @@ static void on_server_connect_done(grpc_exec_ctx* exec_ctx, void* arg,
 static bool proxy_auth_header_matches(grpc_exec_ctx* exec_ctx,
                                       char* proxy_auth_header_val,
                                       char* expected_cred) {
-  GPR_ASSERT(proxy_auth_header_val != NULL);
-  GPR_ASSERT(expected_cred != NULL);
+  GPR_ASSERT(proxy_auth_header_val != nullptr);
+  GPR_ASSERT(expected_cred != nullptr);
   if (strncmp(proxy_auth_header_val, "Basic ", 6) != 0) {
     return false;
   }
@@ -348,8 +358,8 @@ static void on_read_request_done(grpc_exec_ctx* exec_ctx, void* arg,
   // Read request and feed it to the parser.
   for (size_t i = 0; i < conn->client_read_buffer.count; ++i) {
     if (GRPC_SLICE_LENGTH(conn->client_read_buffer.slices[i]) > 0) {
-      error = grpc_http_parser_parse(&conn->http_parser,
-                                     conn->client_read_buffer.slices[i], NULL);
+      error = grpc_http_parser_parse(
+          &conn->http_parser, conn->client_read_buffer.slices[i], nullptr);
       if (error != GRPC_ERROR_NONE) {
         proxy_connection_failed(exec_ctx, conn, true /* is_client */,
                                 "HTTP proxy request parse", error);
@@ -380,7 +390,7 @@ static void on_read_request_done(grpc_exec_ctx* exec_ctx, void* arg,
   // If proxy auth is being used, check if the header is present and as expected
   const grpc_arg* proxy_auth_arg = grpc_channel_args_find(
       conn->proxy->channel_args, GRPC_ARG_HTTP_PROXY_AUTH_CREDS);
-  if (proxy_auth_arg != NULL && proxy_auth_arg->type == GRPC_ARG_STRING) {
+  if (proxy_auth_arg != nullptr && proxy_auth_arg->type == GRPC_ARG_STRING) {
     bool client_authenticated = false;
     for (size_t i = 0; i < conn->http_request.hdr_count; i++) {
       if (strcmp(conn->http_request.hdrs[i].key, "Proxy-Authorization") == 0) {
@@ -400,7 +410,7 @@ static void on_read_request_done(grpc_exec_ctx* exec_ctx, void* arg,
     }
   }
   // Resolve address.
-  grpc_resolved_addresses* resolved_addresses = NULL;
+  grpc_resolved_addresses* resolved_addresses = nullptr;
   error = grpc_blocking_resolve_address(conn->http_request.path, "80",
                                         &resolved_addresses);
   if (error != GRPC_ERROR_NONE) {
@@ -415,7 +425,7 @@ static void on_read_request_done(grpc_exec_ctx* exec_ctx, void* arg,
   const grpc_millis deadline =
       grpc_exec_ctx_now(exec_ctx) + 10 * GPR_MS_PER_SEC;
   grpc_tcp_client_connect(exec_ctx, &conn->on_server_connect_done,
-                          &conn->server_endpoint, conn->pollset_set, NULL,
+                          &conn->server_endpoint, conn->pollset_set, nullptr,
                           &resolved_addresses->addrs[0], deadline);
   grpc_resolved_addresses_destroy(resolved_addresses);
 }
@@ -450,9 +460,11 @@ static void on_accept(grpc_exec_ctx* exec_ctx, void* arg,
                     grpc_combiner_scheduler(conn->proxy->combiner));
   grpc_slice_buffer_init(&conn->client_read_buffer);
   grpc_slice_buffer_init(&conn->client_deferred_write_buffer);
+  conn->client_is_writing = false;
   grpc_slice_buffer_init(&conn->client_write_buffer);
   grpc_slice_buffer_init(&conn->server_read_buffer);
   grpc_slice_buffer_init(&conn->server_deferred_write_buffer);
+  conn->server_is_writing = false;
   grpc_slice_buffer_init(&conn->server_write_buffer);
   grpc_http_parser_init(&conn->http_parser, GRPC_HTTP_REQUEST,
                         &conn->http_request);
@@ -469,7 +481,7 @@ static void thread_main(void* arg) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   do {
     gpr_ref(&proxy->users);
-    grpc_pollset_worker* worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     gpr_mu_lock(proxy->mu);
     GRPC_LOG_IF_ERROR(
         "grpc_pollset_work",
@@ -496,7 +508,7 @@ grpc_end2end_http_proxy* grpc_end2end_http_proxy_create(
   // Create TCP server.
   proxy->channel_args = grpc_channel_args_copy(args);
   grpc_error* error = grpc_tcp_server_create(
-      &exec_ctx, NULL, proxy->channel_args, &proxy->server);
+      &exec_ctx, nullptr, proxy->channel_args, &proxy->server);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   // Bind to port.
   grpc_resolved_address resolved_addr;
diff --git a/test/core/end2end/fixtures/inproc.c b/test/core/end2end/fixtures/inproc.cc
index 6f742f0293..b748fbf09a 100644
--- a/test/core/end2end/fixtures/inproc.c
+++ b/test/core/end2end/fixtures/inproc.cc
@@ -40,36 +40,37 @@ typedef struct inproc_fixture_data {
 } inproc_fixture_data;
 
 static grpc_end2end_test_fixture inproc_create_fixture(
-    grpc_channel_args *client_args, grpc_channel_args *server_args) {
+    grpc_channel_args* client_args, grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
-  inproc_fixture_data *ffd = gpr_malloc(sizeof(inproc_fixture_data));
+  inproc_fixture_data* ffd = static_cast<inproc_fixture_data*>(
+      gpr_malloc(sizeof(inproc_fixture_data)));
   memset(&f, 0, sizeof(f));
 
   f.fixture_data = ffd;
-  f.cq = grpc_completion_queue_create_for_next(NULL);
-  f.shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
+  f.cq = grpc_completion_queue_create_for_next(nullptr);
+  f.shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
 
   return f;
 }
 
-void inproc_init_client(grpc_end2end_test_fixture *f,
-                        grpc_channel_args *client_args) {
-  f->client = grpc_inproc_channel_create(f->server, client_args, NULL);
+void inproc_init_client(grpc_end2end_test_fixture* f,
+                        grpc_channel_args* client_args) {
+  f->client = grpc_inproc_channel_create(f->server, client_args, nullptr);
   GPR_ASSERT(f->client);
 }
 
-void inproc_init_server(grpc_end2end_test_fixture *f,
-                        grpc_channel_args *server_args) {
+void inproc_init_server(grpc_end2end_test_fixture* f,
+                        grpc_channel_args* server_args) {
   if (f->server) {
     grpc_server_destroy(f->server);
   }
-  f->server = grpc_server_create(server_args, NULL);
-  grpc_server_register_completion_queue(f->server, f->cq, NULL);
+  f->server = grpc_server_create(server_args, nullptr);
+  grpc_server_register_completion_queue(f->server, f->cq, nullptr);
   grpc_server_start(f->server);
 }
 
-void inproc_tear_down(grpc_end2end_test_fixture *f) {
-  inproc_fixture_data *ffd = f->fixture_data;
+void inproc_tear_down(grpc_end2end_test_fixture* f) {
+  inproc_fixture_data* ffd = static_cast<inproc_fixture_data*>(f->fixture_data);
   gpr_free(ffd);
 }
 
@@ -79,7 +80,7 @@ static grpc_end2end_test_config configs[] = {
      inproc_init_client, inproc_init_server, inproc_tear_down},
 };
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   size_t i;
 
   grpc_test_init(argc, argv);
diff --git a/test/core/end2end/fixtures/proxy.c b/test/core/end2end/fixtures/proxy.cc
index 6a2d75da09..2fab62b721 100644
--- a/test/core/end2end/fixtures/proxy.c
+++ b/test/core/end2end/fixtures/proxy.cc
@@ -31,37 +31,37 @@
 
 struct grpc_end2end_proxy {
   gpr_thd_id thd;
-  char *proxy_port;
-  char *server_port;
-  grpc_completion_queue *cq;
-  grpc_server *server;
-  grpc_channel *client;
+  char* proxy_port;
+  char* server_port;
+  grpc_completion_queue* cq;
+  grpc_server* server;
+  grpc_channel* client;
 
   int shutdown;
 
   /* requested call */
-  grpc_call *new_call;
+  grpc_call* new_call;
   grpc_call_details new_call_details;
   grpc_metadata_array new_call_metadata;
 };
 
 typedef struct {
-  void (*func)(void *arg, int success);
-  void *arg;
+  void (*func)(void* arg, int success);
+  void* arg;
 } closure;
 
 typedef struct {
   gpr_refcount refs;
-  grpc_end2end_proxy *proxy;
+  grpc_end2end_proxy* proxy;
 
-  grpc_call *c2p;
-  grpc_call *p2s;
+  grpc_call* c2p;
+  grpc_call* p2s;
 
   grpc_metadata_array c2p_initial_metadata;
   grpc_metadata_array p2s_initial_metadata;
 
-  grpc_byte_buffer *c2p_msg;
-  grpc_byte_buffer *p2s_msg;
+  grpc_byte_buffer* c2p_msg;
+  grpc_byte_buffer* p2s_msg;
 
   grpc_metadata_array p2s_trailing_metadata;
   grpc_status_code p2s_status;
@@ -70,17 +70,17 @@ typedef struct {
   int c2p_server_cancelled;
 } proxy_call;
 
-static void thread_main(void *arg);
-static void request_call(grpc_end2end_proxy *proxy);
+static void thread_main(void* arg);
+static void request_call(grpc_end2end_proxy* proxy);
 
-grpc_end2end_proxy *grpc_end2end_proxy_create(const grpc_end2end_proxy_def *def,
-                                              grpc_channel_args *client_args,
-                                              grpc_channel_args *server_args) {
+grpc_end2end_proxy* grpc_end2end_proxy_create(const grpc_end2end_proxy_def* def,
+                                              grpc_channel_args* client_args,
+                                              grpc_channel_args* server_args) {
   gpr_thd_options opt = gpr_thd_options_default();
   int proxy_port = grpc_pick_unused_port_or_die();
   int server_port = grpc_pick_unused_port_or_die();
 
-  grpc_end2end_proxy *proxy = (grpc_end2end_proxy *)gpr_malloc(sizeof(*proxy));
+  grpc_end2end_proxy* proxy = (grpc_end2end_proxy*)gpr_malloc(sizeof(*proxy));
   memset(proxy, 0, sizeof(*proxy));
 
   gpr_join_host_port(&proxy->proxy_port, "localhost", proxy_port);
@@ -89,11 +89,11 @@ grpc_end2end_proxy *grpc_end2end_proxy_create(const grpc_end2end_proxy_def *def,
   gpr_log(GPR_DEBUG, "PROXY ADDR:%s BACKEND:%s", proxy->proxy_port,
           proxy->server_port);
 
-  proxy->cq = grpc_completion_queue_create_for_next(NULL);
+  proxy->cq = grpc_completion_queue_create_for_next(nullptr);
   proxy->server = def->create_server(proxy->proxy_port, server_args);
   proxy->client = def->create_client(proxy->server_port, client_args);
 
-  grpc_server_register_completion_queue(proxy->server, proxy->cq, NULL);
+  grpc_server_register_completion_queue(proxy->server, proxy->cq, nullptr);
   grpc_server_start(proxy->server);
 
   grpc_call_details_init(&proxy->new_call_details);
@@ -105,20 +105,20 @@ grpc_end2end_proxy *grpc_end2end_proxy_create(const grpc_end2end_proxy_def *def,
   return proxy;
 }
 
-static closure *new_closure(void (*func)(void *arg, int success), void *arg) {
-  closure *cl = (closure *)gpr_malloc(sizeof(*cl));
+static closure* new_closure(void (*func)(void* arg, int success), void* arg) {
+  closure* cl = (closure*)gpr_malloc(sizeof(*cl));
   cl->func = func;
   cl->arg = arg;
   return cl;
 }
 
-static void shutdown_complete(void *arg, int success) {
-  grpc_end2end_proxy *proxy = (grpc_end2end_proxy *)arg;
+static void shutdown_complete(void* arg, int success) {
+  grpc_end2end_proxy* proxy = (grpc_end2end_proxy*)arg;
   proxy->shutdown = 1;
   grpc_completion_queue_shutdown(proxy->cq);
 }
 
-void grpc_end2end_proxy_destroy(grpc_end2end_proxy *proxy) {
+void grpc_end2end_proxy_destroy(grpc_end2end_proxy* proxy) {
   grpc_server_shutdown_and_notify(proxy->server, proxy->cq,
                                   new_closure(shutdown_complete, proxy));
   gpr_thd_join(proxy->thd);
@@ -131,7 +131,7 @@ void grpc_end2end_proxy_destroy(grpc_end2end_proxy *proxy) {
   gpr_free(proxy);
 }
 
-static void unrefpc(proxy_call *pc, const char *reason) {
+static void unrefpc(proxy_call* pc, const char* reason) {
   if (gpr_unref(&pc->refs)) {
     grpc_call_unref(pc->c2p);
     grpc_call_unref(pc->p2s);
@@ -143,15 +143,15 @@ static void unrefpc(proxy_call *pc, const char *reason) {
   }
 }
 
-static void refpc(proxy_call *pc, const char *reason) { gpr_ref(&pc->refs); }
+static void refpc(proxy_call* pc, const char* reason) { gpr_ref(&pc->refs); }
 
-static void on_c2p_sent_initial_metadata(void *arg, int success) {
-  proxy_call *pc = (proxy_call *)arg;
+static void on_c2p_sent_initial_metadata(void* arg, int success) {
+  proxy_call* pc = (proxy_call*)arg;
   unrefpc(pc, "on_c2p_sent_initial_metadata");
 }
 
-static void on_p2s_recv_initial_metadata(void *arg, int success) {
-  proxy_call *pc = (proxy_call *)arg;
+static void on_p2s_recv_initial_metadata(void* arg, int success) {
+  proxy_call* pc = (proxy_call*)arg;
   grpc_op op;
   grpc_call_error err;
 
@@ -159,27 +159,28 @@ static void on_p2s_recv_initial_metadata(void *arg, int success) {
   if (!pc->proxy->shutdown) {
     op.op = GRPC_OP_SEND_INITIAL_METADATA;
     op.flags = 0;
-    op.reserved = NULL;
+    op.reserved = nullptr;
     op.data.send_initial_metadata.count = pc->p2s_initial_metadata.count;
     op.data.send_initial_metadata.metadata = pc->p2s_initial_metadata.metadata;
     refpc(pc, "on_c2p_sent_initial_metadata");
-    err = grpc_call_start_batch(
-        pc->c2p, &op, 1, new_closure(on_c2p_sent_initial_metadata, pc), NULL);
+    err = grpc_call_start_batch(pc->c2p, &op, 1,
+                                new_closure(on_c2p_sent_initial_metadata, pc),
+                                nullptr);
     GPR_ASSERT(err == GRPC_CALL_OK);
   }
 
   unrefpc(pc, "on_p2s_recv_initial_metadata");
 }
 
-static void on_p2s_sent_initial_metadata(void *arg, int success) {
-  proxy_call *pc = (proxy_call *)arg;
+static void on_p2s_sent_initial_metadata(void* arg, int success) {
+  proxy_call* pc = (proxy_call*)arg;
   unrefpc(pc, "on_p2s_sent_initial_metadata");
 }
 
-static void on_c2p_recv_msg(void *arg, int success);
+static void on_c2p_recv_msg(void* arg, int success);
 
-static void on_p2s_sent_message(void *arg, int success) {
-  proxy_call *pc = (proxy_call *)arg;
+static void on_p2s_sent_message(void* arg, int success) {
+  proxy_call* pc = (proxy_call*)arg;
   grpc_op op;
   grpc_call_error err;
 
@@ -187,48 +188,48 @@ static void on_p2s_sent_message(void *arg, int success) {
   if (!pc->proxy->shutdown && success) {
     op.op = GRPC_OP_RECV_MESSAGE;
     op.flags = 0;
-    op.reserved = NULL;
+    op.reserved = nullptr;
     op.data.recv_message.recv_message = &pc->c2p_msg;
     refpc(pc, "on_c2p_recv_msg");
     err = grpc_call_start_batch(pc->c2p, &op, 1,
-                                new_closure(on_c2p_recv_msg, pc), NULL);
+                                new_closure(on_c2p_recv_msg, pc), nullptr);
     GPR_ASSERT(err == GRPC_CALL_OK);
   }
 
   unrefpc(pc, "on_p2s_sent_message");
 }
 
-static void on_p2s_sent_close(void *arg, int success) {
-  proxy_call *pc = (proxy_call *)arg;
+static void on_p2s_sent_close(void* arg, int success) {
+  proxy_call* pc = (proxy_call*)arg;
   unrefpc(pc, "on_p2s_sent_close");
 }
 
-static void on_c2p_recv_msg(void *arg, int success) {
-  proxy_call *pc = (proxy_call *)arg;
+static void on_c2p_recv_msg(void* arg, int success) {
+  proxy_call* pc = (proxy_call*)arg;
   grpc_op op;
   grpc_call_error err;
 
   if (!pc->proxy->shutdown && success) {
-    if (pc->c2p_msg != NULL) {
+    if (pc->c2p_msg != nullptr) {
       op.op = GRPC_OP_SEND_MESSAGE;
       op.flags = 0;
-      op.reserved = NULL;
+      op.reserved = nullptr;
       op.data.send_message.send_message = pc->c2p_msg;
       refpc(pc, "on_p2s_sent_message");
-      err = grpc_call_start_batch(pc->p2s, &op, 1,
-                                  new_closure(on_p2s_sent_message, pc), NULL);
+      err = grpc_call_start_batch(
+          pc->p2s, &op, 1, new_closure(on_p2s_sent_message, pc), nullptr);
       GPR_ASSERT(err == GRPC_CALL_OK);
     } else {
       op.op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
       op.flags = 0;
-      op.reserved = NULL;
+      op.reserved = nullptr;
       refpc(pc, "on_p2s_sent_close");
       err = grpc_call_start_batch(pc->p2s, &op, 1,
-                                  new_closure(on_p2s_sent_close, pc), NULL);
+                                  new_closure(on_p2s_sent_close, pc), nullptr);
       GPR_ASSERT(err == GRPC_CALL_OK);
     }
   } else {
-    if (pc->c2p_msg != NULL) {
+    if (pc->c2p_msg != nullptr) {
       grpc_byte_buffer_destroy(pc->c2p_msg);
     }
   }
@@ -236,10 +237,10 @@ static void on_c2p_recv_msg(void *arg, int success) {
   unrefpc(pc, "on_c2p_recv_msg");
 }
 
-static void on_p2s_recv_msg(void *arg, int success);
+static void on_p2s_recv_msg(void* arg, int success);
 
-static void on_c2p_sent_message(void *arg, int success) {
-  proxy_call *pc = (proxy_call *)arg;
+static void on_c2p_sent_message(void* arg, int success) {
+  proxy_call* pc = (proxy_call*)arg;
   grpc_op op;
   grpc_call_error err;
 
@@ -247,30 +248,30 @@ static void on_c2p_sent_message(void *arg, int success) {
   if (!pc->proxy->shutdown && success) {
     op.op = GRPC_OP_RECV_MESSAGE;
     op.flags = 0;
-    op.reserved = NULL;
+    op.reserved = nullptr;
     op.data.recv_message.recv_message = &pc->p2s_msg;
     refpc(pc, "on_p2s_recv_msg");
     err = grpc_call_start_batch(pc->p2s, &op, 1,
-                                new_closure(on_p2s_recv_msg, pc), NULL);
+                                new_closure(on_p2s_recv_msg, pc), nullptr);
     GPR_ASSERT(err == GRPC_CALL_OK);
   }
 
   unrefpc(pc, "on_c2p_sent_message");
 }
 
-static void on_p2s_recv_msg(void *arg, int success) {
-  proxy_call *pc = (proxy_call *)arg;
+static void on_p2s_recv_msg(void* arg, int success) {
+  proxy_call* pc = (proxy_call*)arg;
   grpc_op op;
   grpc_call_error err;
 
   if (!pc->proxy->shutdown && success && pc->p2s_msg) {
     op.op = GRPC_OP_SEND_MESSAGE;
     op.flags = 0;
-    op.reserved = NULL;
+    op.reserved = nullptr;
     op.data.send_message.send_message = pc->p2s_msg;
     refpc(pc, "on_c2p_sent_message");
     err = grpc_call_start_batch(pc->c2p, &op, 1,
-                                new_closure(on_c2p_sent_message, pc), NULL);
+                                new_closure(on_c2p_sent_message, pc), nullptr);
     GPR_ASSERT(err == GRPC_CALL_OK);
   } else {
     grpc_byte_buffer_destroy(pc->p2s_msg);
@@ -278,13 +279,13 @@ static void on_p2s_recv_msg(void *arg, int success) {
   unrefpc(pc, "on_p2s_recv_msg");
 }
 
-static void on_c2p_sent_status(void *arg, int success) {
-  proxy_call *pc = (proxy_call *)arg;
+static void on_c2p_sent_status(void* arg, int success) {
+  proxy_call* pc = (proxy_call*)arg;
   unrefpc(pc, "on_c2p_sent_status");
 }
 
-static void on_p2s_status(void *arg, int success) {
-  proxy_call *pc = (proxy_call *)arg;
+static void on_p2s_status(void* arg, int success) {
+  proxy_call* pc = (proxy_call*)arg;
   grpc_op op;
   grpc_call_error err;
 
@@ -292,7 +293,7 @@ static void on_p2s_status(void *arg, int success) {
     GPR_ASSERT(success);
     op.op = GRPC_OP_SEND_STATUS_FROM_SERVER;
     op.flags = 0;
-    op.reserved = NULL;
+    op.reserved = nullptr;
     op.data.send_status_from_server.trailing_metadata_count =
         pc->p2s_trailing_metadata.count;
     op.data.send_status_from_server.trailing_metadata =
@@ -301,26 +302,26 @@ static void on_p2s_status(void *arg, int success) {
     op.data.send_status_from_server.status_details = &pc->p2s_status_details;
     refpc(pc, "on_c2p_sent_status");
     err = grpc_call_start_batch(pc->c2p, &op, 1,
-                                new_closure(on_c2p_sent_status, pc), NULL);
+                                new_closure(on_c2p_sent_status, pc), nullptr);
     GPR_ASSERT(err == GRPC_CALL_OK);
   }
 
   unrefpc(pc, "on_p2s_status");
 }
 
-static void on_c2p_closed(void *arg, int success) {
-  proxy_call *pc = (proxy_call *)arg;
+static void on_c2p_closed(void* arg, int success) {
+  proxy_call* pc = (proxy_call*)arg;
   unrefpc(pc, "on_c2p_closed");
 }
 
-static void on_new_call(void *arg, int success) {
-  grpc_end2end_proxy *proxy = (grpc_end2end_proxy *)arg;
+static void on_new_call(void* arg, int success) {
+  grpc_end2end_proxy* proxy = (grpc_end2end_proxy*)arg;
   grpc_call_error err;
 
   if (success) {
     grpc_op op;
     memset(&op, 0, sizeof(op));
-    proxy_call *pc = (proxy_call *)gpr_malloc(sizeof(*pc));
+    proxy_call* pc = (proxy_call*)gpr_malloc(sizeof(*pc));
     memset(pc, 0, sizeof(*pc));
     pc->proxy = proxy;
     GPR_SWAP(grpc_metadata_array, pc->c2p_initial_metadata,
@@ -329,18 +330,19 @@ static void on_new_call(void *arg, int success) {
     pc->p2s = grpc_channel_create_call(
         proxy->client, pc->c2p, GRPC_PROPAGATE_DEFAULTS, proxy->cq,
         proxy->new_call_details.method, &proxy->new_call_details.host,
-        proxy->new_call_details.deadline, NULL);
+        proxy->new_call_details.deadline, nullptr);
     gpr_ref_init(&pc->refs, 1);
 
-    op.reserved = NULL;
+    op.reserved = nullptr;
 
     op.op = GRPC_OP_RECV_INITIAL_METADATA;
     op.flags = 0;
     op.data.recv_initial_metadata.recv_initial_metadata =
         &pc->p2s_initial_metadata;
     refpc(pc, "on_p2s_recv_initial_metadata");
-    err = grpc_call_start_batch(
-        pc->p2s, &op, 1, new_closure(on_p2s_recv_initial_metadata, pc), NULL);
+    err = grpc_call_start_batch(pc->p2s, &op, 1,
+                                new_closure(on_p2s_recv_initial_metadata, pc),
+                                nullptr);
     GPR_ASSERT(err == GRPC_CALL_OK);
 
     op.op = GRPC_OP_SEND_INITIAL_METADATA;
@@ -348,8 +350,9 @@ static void on_new_call(void *arg, int success) {
     op.data.send_initial_metadata.count = pc->c2p_initial_metadata.count;
     op.data.send_initial_metadata.metadata = pc->c2p_initial_metadata.metadata;
     refpc(pc, "on_p2s_sent_initial_metadata");
-    err = grpc_call_start_batch(
-        pc->p2s, &op, 1, new_closure(on_p2s_sent_initial_metadata, pc), NULL);
+    err = grpc_call_start_batch(pc->p2s, &op, 1,
+                                new_closure(on_p2s_sent_initial_metadata, pc),
+                                nullptr);
     GPR_ASSERT(err == GRPC_CALL_OK);
 
     op.op = GRPC_OP_RECV_MESSAGE;
@@ -357,7 +360,7 @@ static void on_new_call(void *arg, int success) {
     op.data.recv_message.recv_message = &pc->c2p_msg;
     refpc(pc, "on_c2p_recv_msg");
     err = grpc_call_start_batch(pc->c2p, &op, 1,
-                                new_closure(on_c2p_recv_msg, pc), NULL);
+                                new_closure(on_c2p_recv_msg, pc), nullptr);
     GPR_ASSERT(err == GRPC_CALL_OK);
 
     op.op = GRPC_OP_RECV_MESSAGE;
@@ -365,7 +368,7 @@ static void on_new_call(void *arg, int success) {
     op.data.recv_message.recv_message = &pc->p2s_msg;
     refpc(pc, "on_p2s_recv_msg");
     err = grpc_call_start_batch(pc->p2s, &op, 1,
-                                new_closure(on_p2s_recv_msg, pc), NULL);
+                                new_closure(on_p2s_recv_msg, pc), nullptr);
     GPR_ASSERT(err == GRPC_CALL_OK);
 
     op.op = GRPC_OP_RECV_STATUS_ON_CLIENT;
@@ -376,7 +379,7 @@ static void on_new_call(void *arg, int success) {
     op.data.recv_status_on_client.status_details = &pc->p2s_status_details;
     refpc(pc, "on_p2s_status");
     err = grpc_call_start_batch(pc->p2s, &op, 1, new_closure(on_p2s_status, pc),
-                                NULL);
+                                nullptr);
     GPR_ASSERT(err == GRPC_CALL_OK);
 
     op.op = GRPC_OP_RECV_CLOSE_ON_SERVER;
@@ -384,7 +387,7 @@ static void on_new_call(void *arg, int success) {
     op.data.recv_close_on_server.cancelled = &pc->c2p_server_cancelled;
     refpc(pc, "on_c2p_closed");
     err = grpc_call_start_batch(pc->c2p, &op, 1, new_closure(on_c2p_closed, pc),
-                                NULL);
+                                nullptr);
     GPR_ASSERT(err == GRPC_CALL_OK);
 
     request_call(proxy);
@@ -394,12 +397,12 @@ static void on_new_call(void *arg, int success) {
 
     unrefpc(pc, "init");
   } else {
-    GPR_ASSERT(proxy->new_call == NULL);
+    GPR_ASSERT(proxy->new_call == nullptr);
   }
 }
 
-static void request_call(grpc_end2end_proxy *proxy) {
-  proxy->new_call = NULL;
+static void request_call(grpc_end2end_proxy* proxy) {
+  proxy->new_call = nullptr;
   GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(
                                  proxy->server, &proxy->new_call,
                                  &proxy->new_call_details,
@@ -407,12 +410,12 @@ static void request_call(grpc_end2end_proxy *proxy) {
                                  proxy->cq, new_closure(on_new_call, proxy)));
 }
 
-static void thread_main(void *arg) {
-  grpc_end2end_proxy *proxy = (grpc_end2end_proxy *)arg;
-  closure *cl;
+static void thread_main(void* arg) {
+  grpc_end2end_proxy* proxy = (grpc_end2end_proxy*)arg;
+  closure* cl;
   for (;;) {
     grpc_event ev = grpc_completion_queue_next(
-        proxy->cq, gpr_inf_future(GPR_CLOCK_MONOTONIC), NULL);
+        proxy->cq, gpr_inf_future(GPR_CLOCK_MONOTONIC), nullptr);
     switch (ev.type) {
       case GRPC_QUEUE_TIMEOUT:
         gpr_log(GPR_ERROR, "Should never reach here");
@@ -420,7 +423,7 @@ static void thread_main(void *arg) {
       case GRPC_QUEUE_SHUTDOWN:
         return;
       case GRPC_OP_COMPLETE:
-        cl = (closure *)ev.tag;
+        cl = (closure*)ev.tag;
         cl->func(cl->arg, ev.success);
         gpr_free(cl);
         break;
@@ -428,10 +431,10 @@ static void thread_main(void *arg) {
   }
 }
 
-const char *grpc_end2end_proxy_get_client_target(grpc_end2end_proxy *proxy) {
+const char* grpc_end2end_proxy_get_client_target(grpc_end2end_proxy* proxy) {
   return proxy->proxy_port;
 }
 
-const char *grpc_end2end_proxy_get_server_port(grpc_end2end_proxy *proxy) {
+const char* grpc_end2end_proxy_get_server_port(grpc_end2end_proxy* proxy) {
   return proxy->server_port;
 }
diff --git a/test/core/end2end/fixtures/proxy.h b/test/core/end2end/fixtures/proxy.h
index 89b965c903..18ad763ea7 100644
--- a/test/core/end2end/fixtures/proxy.h
+++ b/test/core/end2end/fixtures/proxy.h
@@ -26,18 +26,18 @@
 typedef struct grpc_end2end_proxy grpc_end2end_proxy;
 
 typedef struct grpc_end2end_proxy_def {
-  grpc_server *(*create_server)(const char *port,
-                                grpc_channel_args *server_args);
-  grpc_channel *(*create_client)(const char *target,
-                                 grpc_channel_args *client_args);
+  grpc_server* (*create_server)(const char* port,
+                                grpc_channel_args* server_args);
+  grpc_channel* (*create_client)(const char* target,
+                                 grpc_channel_args* client_args);
 } grpc_end2end_proxy_def;
 
-grpc_end2end_proxy *grpc_end2end_proxy_create(const grpc_end2end_proxy_def *def,
-                                              grpc_channel_args *client_args,
-                                              grpc_channel_args *server_args);
-void grpc_end2end_proxy_destroy(grpc_end2end_proxy *proxy);
+grpc_end2end_proxy* grpc_end2end_proxy_create(const grpc_end2end_proxy_def* def,
+                                              grpc_channel_args* client_args,
+                                              grpc_channel_args* server_args);
+void grpc_end2end_proxy_destroy(grpc_end2end_proxy* proxy);
 
-const char *grpc_end2end_proxy_get_client_target(grpc_end2end_proxy *proxy);
-const char *grpc_end2end_proxy_get_server_port(grpc_end2end_proxy *proxy);
+const char* grpc_end2end_proxy_get_client_target(grpc_end2end_proxy* proxy);
+const char* grpc_end2end_proxy_get_server_port(grpc_end2end_proxy* proxy);
 
 #endif /* GRPC_TEST_CORE_END2END_FIXTURES_PROXY_H */
diff --git a/test/core/end2end/fuzzers/BUILD b/test/core/end2end/fuzzers/BUILD
index 4ed9a70578..d33e2b0ff4 100644
--- a/test/core/end2end/fuzzers/BUILD
+++ b/test/core/end2end/fuzzers/BUILD
@@ -22,8 +22,8 @@ load("//test/core/util:grpc_fuzzer.bzl", "grpc_fuzzer")
 
 grpc_fuzzer(
     name = "api_fuzzer",
-    srcs = ["api_fuzzer.c"],
-    language = "C",
+    srcs = ["api_fuzzer.cc"],
+    language = "C++",
     corpus = "api_fuzzer_corpus",
     deps = [
         "//:gpr",
@@ -35,8 +35,8 @@ grpc_fuzzer(
 
 grpc_fuzzer(
     name = "client_fuzzer",
-    srcs = ["client_fuzzer.c"],
-    language = "C",
+    srcs = ["client_fuzzer.cc"],
+    language = "C++",
     corpus = "client_fuzzer_corpus",
     deps = [
         "//:gpr",
@@ -47,8 +47,8 @@ grpc_fuzzer(
 
 grpc_fuzzer(
     name = "server_fuzzer",
-    srcs = ["server_fuzzer.c"],
-    language = "C",
+    srcs = ["server_fuzzer.cc"],
+    language = "C++",
     corpus = "server_fuzzer_corpus",
     deps = [
         "//:gpr",
diff --git a/test/core/end2end/fuzzers/api_fuzzer.c b/test/core/end2end/fuzzers/api_fuzzer.cc
index 0a787bbf30..b8ec12586e 100644
--- a/test/core/end2end/fuzzers/api_fuzzer.c
+++ b/test/core/end2end/fuzzers/api_fuzzer.cc
@@ -46,17 +46,17 @@
 bool squelch = true;
 bool leak_check = true;
 
-static void dont_log(gpr_log_func_args *args) {}
+static void dont_log(gpr_log_func_args* args) {}
 
 ////////////////////////////////////////////////////////////////////////////////
 // global state
 
 static gpr_timespec g_now;
-static grpc_server *g_server;
-static grpc_channel *g_channel;
-static grpc_resource_quota *g_resource_quota;
+static grpc_server* g_server;
+static grpc_channel* g_channel;
+static grpc_resource_quota* g_resource_quota;
 
-extern gpr_timespec (*gpr_now_impl)(gpr_clock_type clock_type);
+extern "C" gpr_timespec (*gpr_now_impl)(gpr_clock_type clock_type);
 
 static gpr_timespec now_impl(gpr_clock_type clock_type) {
   GPR_ASSERT(clock_type != GPR_TIMESPAN);
@@ -70,33 +70,33 @@ static gpr_timespec now_impl(gpr_clock_type clock_type) {
 //               past the end (avoiding needing to check everywhere)
 
 typedef struct {
-  const uint8_t *cur;
-  const uint8_t *end;
+  const uint8_t* cur;
+  const uint8_t* end;
 } input_stream;
 
-static uint8_t next_byte(input_stream *inp) {
+static uint8_t next_byte(input_stream* inp) {
   if (inp->cur == inp->end) {
     return 0;
   }
   return *inp->cur++;
 }
 
-static void end(input_stream *inp) { inp->cur = inp->end; }
+static void end(input_stream* inp) { inp->cur = inp->end; }
 
-static char *read_string(input_stream *inp, bool *special) {
-  char *str = NULL;
+static char* read_string(input_stream* inp, bool* special) {
+  char* str = nullptr;
   size_t cap = 0;
   size_t sz = 0;
   char c;
   do {
     if (cap == sz) {
       cap = GPR_MAX(3 * cap / 2, cap + 8);
-      str = gpr_realloc(str, cap);
+      str = static_cast<char*>(gpr_realloc(str, cap));
     }
     c = (char)next_byte(inp);
     str[sz++] = c;
   } while (c != 0 && c != 1);
-  if (special != NULL) {
+  if (special != nullptr) {
     *special = (c == 1);
   }
   if (c == 1) {
@@ -105,16 +105,16 @@ static char *read_string(input_stream *inp, bool *special) {
   return str;
 }
 
-static void read_buffer(input_stream *inp, char **buffer, size_t *length,
-                        bool *special) {
+static void read_buffer(input_stream* inp, char** buffer, size_t* length,
+                        bool* special) {
   *length = next_byte(inp);
   if (*length == 255) {
-    if (special != NULL) *special = true;
+    if (special != nullptr) *special = true;
     *length = next_byte(inp);
   } else {
-    if (special != NULL) *special = false;
+    if (special != nullptr) *special = false;
   }
-  *buffer = gpr_malloc(*length);
+  *buffer = static_cast<char*>(gpr_malloc(*length));
   for (size_t i = 0; i < *length; i++) {
     (*buffer)[i] = (char)next_byte(inp);
   }
@@ -126,16 +126,16 @@ static grpc_slice maybe_intern(grpc_slice s, bool intern) {
   return r;
 }
 
-static grpc_slice read_string_like_slice(input_stream *inp) {
+static grpc_slice read_string_like_slice(input_stream* inp) {
   bool special;
-  char *s = read_string(inp, &special);
+  char* s = read_string(inp, &special);
   grpc_slice r = maybe_intern(grpc_slice_from_copied_string(s), special);
   gpr_free(s);
   return r;
 }
 
-static grpc_slice read_buffer_like_slice(input_stream *inp) {
-  char *buffer;
+static grpc_slice read_buffer_like_slice(input_stream* inp) {
+  char* buffer;
   size_t length;
   bool special;
   read_buffer(inp, &buffer, &length, &special);
@@ -145,7 +145,7 @@ static grpc_slice read_buffer_like_slice(input_stream *inp) {
   return r;
 }
 
-static uint32_t read_uint22(input_stream *inp) {
+static uint32_t read_uint22(input_stream* inp) {
   uint8_t b = next_byte(inp);
   uint32_t x = b & 0x7f;
   if (b & 0x80) {
@@ -160,7 +160,7 @@ static uint32_t read_uint22(input_stream *inp) {
   return x;
 }
 
-static uint32_t read_uint32(input_stream *inp) {
+static uint32_t read_uint32(input_stream* inp) {
   uint8_t b = next_byte(inp);
   uint32_t x = b & 0x7f;
   if (b & 0x80) {
@@ -184,29 +184,29 @@ static uint32_t read_uint32(input_stream *inp) {
   return x;
 }
 
-static grpc_byte_buffer *read_message(input_stream *inp) {
+static grpc_byte_buffer* read_message(input_stream* inp) {
   grpc_slice slice = grpc_slice_malloc(read_uint22(inp));
   memset(GRPC_SLICE_START_PTR(slice), 0, GRPC_SLICE_LENGTH(slice));
-  grpc_byte_buffer *out = grpc_raw_byte_buffer_create(&slice, 1);
+  grpc_byte_buffer* out = grpc_raw_byte_buffer_create(&slice, 1);
   grpc_slice_unref(slice);
   return out;
 }
 
-static int read_int(input_stream *inp) { return (int)read_uint32(inp); }
+static int read_int(input_stream* inp) { return (int)read_uint32(inp); }
 
-static grpc_channel_args *read_args(input_stream *inp) {
+static grpc_channel_args* read_args(input_stream* inp) {
   size_t n = next_byte(inp);
-  grpc_arg *args = gpr_malloc(sizeof(*args) * n);
+  grpc_arg* args = static_cast<grpc_arg*>(gpr_malloc(sizeof(*args) * n));
   for (size_t i = 0; i < n; i++) {
     switch (next_byte(inp)) {
       case 1:
         args[i].type = GRPC_ARG_STRING;
-        args[i].key = read_string(inp, NULL);
-        args[i].value.string = read_string(inp, NULL);
+        args[i].key = read_string(inp, nullptr);
+        args[i].value.string = read_string(inp, nullptr);
         break;
       case 2:
         args[i].type = GRPC_ARG_INTEGER;
-        args[i].key = read_string(inp, NULL);
+        args[i].key = read_string(inp, nullptr);
         args[i].value.integer = read_int(inp);
         break;
       case 3:
@@ -222,7 +222,8 @@ static grpc_channel_args *read_args(input_stream *inp) {
         break;
     }
   }
-  grpc_channel_args *a = gpr_malloc(sizeof(*a));
+  grpc_channel_args* a =
+      static_cast<grpc_channel_args*>(gpr_malloc(sizeof(*a)));
   a->args = args;
   a->num_args = n;
   return a;
@@ -230,95 +231,99 @@ static grpc_channel_args *read_args(input_stream *inp) {
 
 typedef struct cred_artifact_ctx {
   int num_release;
-  char *release[3];
+  char* release[3];
 } cred_artifact_ctx;
 #define CRED_ARTIFACT_CTX_INIT \
   {                            \
     0, { 0 }                   \
   }
 
-static void cred_artifact_ctx_finish(cred_artifact_ctx *ctx) {
+static void cred_artifact_ctx_finish(cred_artifact_ctx* ctx) {
   for (int i = 0; i < ctx->num_release; i++) {
     gpr_free(ctx->release[i]);
   }
 }
 
-static const char *read_cred_artifact(cred_artifact_ctx *ctx, input_stream *inp,
-                                      const char **builtins,
+static const char* read_cred_artifact(cred_artifact_ctx* ctx, input_stream* inp,
+                                      const char** builtins,
                                       size_t num_builtins) {
   uint8_t b = next_byte(inp);
-  if (b == 0) return NULL;
-  if (b == 1) return ctx->release[ctx->num_release++] = read_string(inp, NULL);
+  if (b == 0) return nullptr;
+  if (b == 1)
+    return ctx->release[ctx->num_release++] = read_string(inp, nullptr);
   if (b >= num_builtins + 1) {
     end(inp);
-    return NULL;
+    return nullptr;
   }
   return builtins[b - 1];
 }
 
-static grpc_channel_credentials *read_ssl_channel_creds(input_stream *inp) {
+static grpc_channel_credentials* read_ssl_channel_creds(input_stream* inp) {
   cred_artifact_ctx ctx = CRED_ARTIFACT_CTX_INIT;
-  static const char *builtin_root_certs[] = {test_root_cert};
-  static const char *builtin_private_keys[] = {
+  static const char* builtin_root_certs[] = {test_root_cert};
+  static const char* builtin_private_keys[] = {
       test_server1_key, test_self_signed_client_key, test_signed_client_key};
-  static const char *builtin_cert_chains[] = {
+  static const char* builtin_cert_chains[] = {
       test_server1_cert, test_self_signed_client_cert, test_signed_client_cert};
-  const char *root_certs = read_cred_artifact(
+  const char* root_certs = read_cred_artifact(
       &ctx, inp, builtin_root_certs, GPR_ARRAY_SIZE(builtin_root_certs));
-  const char *private_key = read_cred_artifact(
+  const char* private_key = read_cred_artifact(
       &ctx, inp, builtin_private_keys, GPR_ARRAY_SIZE(builtin_private_keys));
-  const char *certs = read_cred_artifact(&ctx, inp, builtin_cert_chains,
+  const char* certs = read_cred_artifact(&ctx, inp, builtin_cert_chains,
                                          GPR_ARRAY_SIZE(builtin_cert_chains));
   grpc_ssl_pem_key_cert_pair key_cert_pair = {private_key, certs};
-  grpc_channel_credentials *creds = grpc_ssl_credentials_create(
-      root_certs, private_key != NULL && certs != NULL ? &key_cert_pair : NULL,
-      NULL);
+  grpc_channel_credentials* creds = grpc_ssl_credentials_create(
+      root_certs,
+      private_key != nullptr && certs != nullptr ? &key_cert_pair : nullptr,
+      nullptr);
   cred_artifact_ctx_finish(&ctx);
   return creds;
 }
 
-static grpc_call_credentials *read_call_creds(input_stream *inp) {
+static grpc_call_credentials* read_call_creds(input_stream* inp) {
   switch (next_byte(inp)) {
     default:
       end(inp);
-      return NULL;
+      return nullptr;
     case 0:
-      return NULL;
+      return nullptr;
     case 1: {
-      grpc_call_credentials *c1 = read_call_creds(inp);
-      grpc_call_credentials *c2 = read_call_creds(inp);
-      if (c1 != NULL && c2 != NULL) {
-        grpc_call_credentials *out =
-            grpc_composite_call_credentials_create(c1, c2, NULL);
+      grpc_call_credentials* c1 = read_call_creds(inp);
+      grpc_call_credentials* c2 = read_call_creds(inp);
+      if (c1 != nullptr && c2 != nullptr) {
+        grpc_call_credentials* out =
+            grpc_composite_call_credentials_create(c1, c2, nullptr);
         grpc_call_credentials_release(c1);
         grpc_call_credentials_release(c2);
         return out;
-      } else if (c1 != NULL) {
+      } else if (c1 != nullptr) {
         return c1;
-      } else if (c2 != NULL) {
+      } else if (c2 != nullptr) {
         return c2;
       } else {
-        return NULL;
+        return nullptr;
       }
-      GPR_UNREACHABLE_CODE(return NULL);
+      GPR_UNREACHABLE_CODE(return nullptr);
     }
     case 2: {
       cred_artifact_ctx ctx = CRED_ARTIFACT_CTX_INIT;
-      const char *access_token = read_cred_artifact(&ctx, inp, NULL, 0);
-      grpc_call_credentials *out =
-          access_token == NULL ? NULL : grpc_access_token_credentials_create(
-                                            access_token, NULL);
+      const char* access_token = read_cred_artifact(&ctx, inp, nullptr, 0);
+      grpc_call_credentials* out =
+          access_token == nullptr
+              ? nullptr
+              : grpc_access_token_credentials_create(access_token, nullptr);
       cred_artifact_ctx_finish(&ctx);
       return out;
     }
     case 3: {
       cred_artifact_ctx ctx = CRED_ARTIFACT_CTX_INIT;
-      const char *auth_token = read_cred_artifact(&ctx, inp, NULL, 0);
-      const char *auth_selector = read_cred_artifact(&ctx, inp, NULL, 0);
-      grpc_call_credentials *out = auth_token == NULL || auth_selector == NULL
-                                       ? NULL
-                                       : grpc_google_iam_credentials_create(
-                                             auth_token, auth_selector, NULL);
+      const char* auth_token = read_cred_artifact(&ctx, inp, nullptr, 0);
+      const char* auth_selector = read_cred_artifact(&ctx, inp, nullptr, 0);
+      grpc_call_credentials* out =
+          auth_token == nullptr || auth_selector == nullptr
+              ? nullptr
+              : grpc_google_iam_credentials_create(auth_token, auth_selector,
+                                                   nullptr);
       cred_artifact_ctx_finish(&ctx);
       return out;
     }
@@ -326,17 +331,17 @@ static grpc_call_credentials *read_call_creds(input_stream *inp) {
   }
 }
 
-static grpc_channel_credentials *read_channel_creds(input_stream *inp) {
+static grpc_channel_credentials* read_channel_creds(input_stream* inp) {
   switch (next_byte(inp)) {
     case 0:
       return read_ssl_channel_creds(inp);
       break;
     case 1: {
-      grpc_channel_credentials *c1 = read_channel_creds(inp);
-      grpc_call_credentials *c2 = read_call_creds(inp);
-      if (c1 != NULL && c2 != NULL) {
-        grpc_channel_credentials *out =
-            grpc_composite_channel_credentials_create(c1, c2, NULL);
+      grpc_channel_credentials* c1 = read_channel_creds(inp);
+      grpc_call_credentials* c2 = read_call_creds(inp);
+      if (c1 != nullptr && c2 != nullptr) {
+        grpc_channel_credentials* out =
+            grpc_composite_channel_credentials_create(c1, c2, nullptr);
         grpc_channel_credentials_release(c1);
         grpc_call_credentials_release(c2);
         return out;
@@ -344,47 +349,50 @@ static grpc_channel_credentials *read_channel_creds(input_stream *inp) {
         return c1;
       } else if (c2) {
         grpc_call_credentials_release(c2);
-        return NULL;
+        return nullptr;
       } else {
-        return NULL;
+        return nullptr;
       }
-      GPR_UNREACHABLE_CODE(return NULL);
+      GPR_UNREACHABLE_CODE(return nullptr);
     }
     case 2:
-      return NULL;
+      return nullptr;
     default:
       end(inp);
-      return NULL;
+      return nullptr;
   }
 }
 
-static bool is_eof(input_stream *inp) { return inp->cur == inp->end; }
+static bool is_eof(input_stream* inp) { return inp->cur == inp->end; }
 
 ////////////////////////////////////////////////////////////////////////////////
 // dns resolution
 
 typedef struct addr_req {
   grpc_timer timer;
-  char *addr;
-  grpc_closure *on_done;
-  grpc_resolved_addresses **addrs;
-  grpc_lb_addresses **lb_addrs;
+  char* addr;
+  grpc_closure* on_done;
+  grpc_resolved_addresses** addrs;
+  grpc_lb_addresses** lb_addrs;
 } addr_req;
 
-static void finish_resolve(grpc_exec_ctx *exec_ctx, void *arg,
-                           grpc_error *error) {
-  addr_req *r = arg;
+static void finish_resolve(grpc_exec_ctx* exec_ctx, void* arg,
+                           grpc_error* error) {
+  addr_req* r = static_cast<addr_req*>(arg);
 
   if (error == GRPC_ERROR_NONE && 0 == strcmp(r->addr, "server")) {
-    if (r->addrs != NULL) {
-      grpc_resolved_addresses *addrs = gpr_malloc(sizeof(*addrs));
+    if (r->addrs != nullptr) {
+      grpc_resolved_addresses* addrs =
+          static_cast<grpc_resolved_addresses*>(gpr_malloc(sizeof(*addrs)));
       addrs->naddrs = 1;
-      addrs->addrs = gpr_malloc(sizeof(*addrs->addrs));
+      addrs->addrs = static_cast<grpc_resolved_address*>(
+          gpr_malloc(sizeof(*addrs->addrs)));
       addrs->addrs[0].len = 0;
       *r->addrs = addrs;
-    } else if (r->lb_addrs != NULL) {
-      grpc_lb_addresses *lb_addrs = grpc_lb_addresses_create(1, NULL);
-      grpc_lb_addresses_set_address(lb_addrs, 0, NULL, 0, NULL, NULL, NULL);
+    } else if (r->lb_addrs != nullptr) {
+      grpc_lb_addresses* lb_addrs = grpc_lb_addresses_create(1, nullptr);
+      grpc_lb_addresses_set_address(lb_addrs, 0, nullptr, 0, false, nullptr,
+                                    nullptr);
       *r->lb_addrs = lb_addrs;
     }
     GRPC_CLOSURE_SCHED(exec_ctx, r->on_done, GRPC_ERROR_NONE);
@@ -398,71 +406,72 @@ static void finish_resolve(grpc_exec_ctx *exec_ctx, void *arg,
   gpr_free(r);
 }
 
-void my_resolve_address(grpc_exec_ctx *exec_ctx, const char *addr,
-                        const char *default_port,
-                        grpc_pollset_set *interested_parties,
-                        grpc_closure *on_done,
-                        grpc_resolved_addresses **addresses) {
-  addr_req *r = gpr_malloc(sizeof(*r));
+void my_resolve_address(grpc_exec_ctx* exec_ctx, const char* addr,
+                        const char* default_port,
+                        grpc_pollset_set* interested_parties,
+                        grpc_closure* on_done,
+                        grpc_resolved_addresses** addresses) {
+  addr_req* r = static_cast<addr_req*>(gpr_malloc(sizeof(*r)));
   r->addr = gpr_strdup(addr);
   r->on_done = on_done;
   r->addrs = addresses;
-  r->lb_addrs = NULL;
+  r->lb_addrs = nullptr;
   grpc_timer_init(
       exec_ctx, &r->timer, GPR_MS_PER_SEC + grpc_exec_ctx_now(exec_ctx),
       GRPC_CLOSURE_CREATE(finish_resolve, r, grpc_schedule_on_exec_ctx));
 }
 
-grpc_ares_request *my_dns_lookup_ares(
-    grpc_exec_ctx *exec_ctx, const char *dns_server, const char *addr,
-    const char *default_port, grpc_pollset_set *interested_parties,
-    grpc_closure *on_done, grpc_lb_addresses **lb_addrs, bool check_grpclb,
-    char **service_config_json) {
-  addr_req *r = gpr_malloc(sizeof(*r));
+grpc_ares_request* my_dns_lookup_ares(
+    grpc_exec_ctx* exec_ctx, const char* dns_server, const char* addr,
+    const char* default_port, grpc_pollset_set* interested_parties,
+    grpc_closure* on_done, grpc_lb_addresses** lb_addrs, bool check_grpclb,
+    char** service_config_json) {
+  addr_req* r = static_cast<addr_req*>(gpr_malloc(sizeof(*r)));
   r->addr = gpr_strdup(addr);
   r->on_done = on_done;
-  r->addrs = NULL;
+  r->addrs = nullptr;
   r->lb_addrs = lb_addrs;
   grpc_timer_init(
       exec_ctx, &r->timer, GPR_MS_PER_SEC + grpc_exec_ctx_now(exec_ctx),
       GRPC_CLOSURE_CREATE(finish_resolve, r, grpc_schedule_on_exec_ctx));
-  return NULL;
+  return nullptr;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // client connection
 
 // defined in tcp_client_posix.c
-extern void (*grpc_tcp_client_connect_impl)(
-    grpc_exec_ctx *exec_ctx, grpc_closure *closure, grpc_endpoint **ep,
-    grpc_pollset_set *interested_parties, const grpc_channel_args *channel_args,
-    const grpc_resolved_address *addr, gpr_timespec deadline);
+extern "C" void (*grpc_tcp_client_connect_impl)(
+    grpc_exec_ctx* exec_ctx, grpc_closure* closure, grpc_endpoint** ep,
+    grpc_pollset_set* interested_parties, const grpc_channel_args* channel_args,
+    const grpc_resolved_address* addr, grpc_millis deadline);
 
-static void sched_connect(grpc_exec_ctx *exec_ctx, grpc_closure *closure,
-                          grpc_endpoint **ep, gpr_timespec deadline);
+static void sched_connect(grpc_exec_ctx* exec_ctx, grpc_closure* closure,
+                          grpc_endpoint** ep, gpr_timespec deadline);
 
 typedef struct {
   grpc_timer timer;
-  grpc_closure *closure;
-  grpc_endpoint **ep;
+  grpc_closure* closure;
+  grpc_endpoint** ep;
   gpr_timespec deadline;
 } future_connect;
 
-static void do_connect(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  future_connect *fc = arg;
+static void do_connect(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+  future_connect* fc = static_cast<future_connect*>(arg);
   if (error != GRPC_ERROR_NONE) {
-    *fc->ep = NULL;
+    *fc->ep = nullptr;
     GRPC_CLOSURE_SCHED(exec_ctx, fc->closure, GRPC_ERROR_REF(error));
-  } else if (g_server != NULL) {
-    grpc_endpoint *client;
-    grpc_endpoint *server;
-    grpc_passthru_endpoint_create(&client, &server, g_resource_quota, NULL);
+  } else if (g_server != nullptr) {
+    grpc_endpoint* client;
+    grpc_endpoint* server;
+    grpc_passthru_endpoint_create(&client, &server, g_resource_quota, nullptr);
     *fc->ep = client;
 
-    grpc_transport *transport =
-        grpc_create_chttp2_transport(exec_ctx, NULL, server, 0);
-    grpc_server_setup_transport(exec_ctx, g_server, transport, NULL, NULL);
-    grpc_chttp2_transport_start_reading(exec_ctx, transport, NULL);
+    grpc_transport* transport =
+        grpc_create_chttp2_transport(exec_ctx, nullptr, server, 0);
+    grpc_server_setup_transport(exec_ctx, g_server, transport, nullptr,
+                                nullptr);
+    grpc_chttp2_transport_start_reading(exec_ctx, transport, nullptr);
 
     GRPC_CLOSURE_SCHED(exec_ctx, fc->closure, GRPC_ERROR_NONE);
   } else {
@@ -471,16 +480,17 @@ static void do_connect(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
   gpr_free(fc);
 }
 
-static void sched_connect(grpc_exec_ctx *exec_ctx, grpc_closure *closure,
-                          grpc_endpoint **ep, gpr_timespec deadline) {
+static void sched_connect(grpc_exec_ctx* exec_ctx, grpc_closure* closure,
+                          grpc_endpoint** ep, gpr_timespec deadline) {
   if (gpr_time_cmp(deadline, gpr_now(deadline.clock_type)) < 0) {
-    *ep = NULL;
-    GRPC_CLOSURE_SCHED(exec_ctx, closure, GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                                              "Connect deadline exceeded"));
+    *ep = nullptr;
+    GRPC_CLOSURE_SCHED(
+        exec_ctx, closure,
+        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Connect deadline exceeded"));
     return;
   }
 
-  future_connect *fc = gpr_malloc(sizeof(*fc));
+  future_connect* fc = static_cast<future_connect*>(gpr_malloc(sizeof(*fc)));
   fc->closure = closure;
   fc->ep = ep;
   fc->deadline = deadline;
@@ -489,53 +499,55 @@ static void sched_connect(grpc_exec_ctx *exec_ctx, grpc_closure *closure,
       GRPC_CLOSURE_CREATE(do_connect, fc, grpc_schedule_on_exec_ctx));
 }
 
-static void my_tcp_client_connect(grpc_exec_ctx *exec_ctx,
-                                  grpc_closure *closure, grpc_endpoint **ep,
-                                  grpc_pollset_set *interested_parties,
-                                  const grpc_channel_args *channel_args,
-                                  const grpc_resolved_address *addr,
-                                  gpr_timespec deadline) {
-  sched_connect(exec_ctx, closure, ep, deadline);
+static void my_tcp_client_connect(grpc_exec_ctx* exec_ctx,
+                                  grpc_closure* closure, grpc_endpoint** ep,
+                                  grpc_pollset_set* interested_parties,
+                                  const grpc_channel_args* channel_args,
+                                  const grpc_resolved_address* addr,
+                                  grpc_millis deadline) {
+  sched_connect(exec_ctx, closure, ep,
+                grpc_millis_to_timespec(deadline, GPR_CLOCK_MONOTONIC));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // test driver
 
 typedef struct validator {
-  void (*validate)(void *arg, bool success);
-  void *arg;
+  void (*validate)(void* arg, bool success);
+  void* arg;
 } validator;
 
-static validator *create_validator(void (*validate)(void *arg, bool success),
-                                   void *arg) {
-  validator *v = gpr_malloc(sizeof(*v));
+static validator* create_validator(void (*validate)(void* arg, bool success),
+                                   void* arg) {
+  validator* v = static_cast<validator*>(gpr_malloc(sizeof(*v)));
   v->validate = validate;
   v->arg = arg;
   return v;
 }
 
-static void assert_success_and_decrement(void *counter, bool success) {
+static void assert_success_and_decrement(void* counter, bool success) {
   GPR_ASSERT(success);
-  --*(int *)counter;
+  --*(int*)counter;
 }
 
-static void decrement(void *counter, bool success) { --*(int *)counter; }
+static void decrement(void* counter, bool success) { --*(int*)counter; }
 
 typedef struct connectivity_watch {
-  int *counter;
+  int* counter;
   gpr_timespec deadline;
 } connectivity_watch;
 
-static connectivity_watch *make_connectivity_watch(gpr_timespec s,
-                                                   int *counter) {
-  connectivity_watch *o = gpr_malloc(sizeof(*o));
+static connectivity_watch* make_connectivity_watch(gpr_timespec s,
+                                                   int* counter) {
+  connectivity_watch* o =
+      static_cast<connectivity_watch*>(gpr_malloc(sizeof(*o)));
   o->deadline = s;
   o->counter = counter;
   return o;
 }
 
-static void validate_connectivity_watch(void *p, bool success) {
-  connectivity_watch *w = p;
+static void validate_connectivity_watch(void* p, bool success) {
+  connectivity_watch* w = static_cast<connectivity_watch*>(p);
   if (!success) {
     GPR_ASSERT(gpr_time_cmp(gpr_now(w->deadline.clock_type), w->deadline) >= 0);
   }
@@ -543,8 +555,8 @@ static void validate_connectivity_watch(void *p, bool success) {
   gpr_free(w);
 }
 
-static void free_non_null(void *p) {
-  GPR_ASSERT(p != NULL);
+static void free_non_null(void* p) {
+  GPR_ASSERT(p != nullptr);
   gpr_free(p);
 }
 
@@ -554,8 +566,8 @@ typedef enum { ROOT, CLIENT, SERVER, PENDING_SERVER } call_state_type;
 
 typedef struct call_state {
   call_state_type type;
-  grpc_call *call;
-  grpc_byte_buffer *recv_message;
+  grpc_call* call;
+  grpc_byte_buffer* recv_message;
   grpc_status_code status;
   grpc_metadata_array recv_initial_metadata;
   grpc_metadata_array recv_trailing_metadata;
@@ -563,7 +575,7 @@ typedef struct call_state {
   int cancelled;
   int pending_ops;
   grpc_call_details call_details;
-  grpc_byte_buffer *send_message;
+  grpc_byte_buffer* send_message;
   // starts at 0, individual flags from DONE_FLAG_xxx are set
   // as different operations are completed
   uint64_t done_flags;
@@ -571,23 +583,23 @@ typedef struct call_state {
   // array of pointers to free later
   size_t num_to_free;
   size_t cap_to_free;
-  void **to_free;
+  void** to_free;
 
   // array of slices to unref
   size_t num_slices_to_unref;
   size_t cap_slices_to_unref;
-  grpc_slice **slices_to_unref;
+  grpc_slice** slices_to_unref;
 
-  struct call_state *next;
-  struct call_state *prev;
+  struct call_state* next;
+  struct call_state* prev;
 } call_state;
 
-static call_state *g_active_call;
+static call_state* g_active_call;
 
-static call_state *new_call(call_state *sibling, call_state_type type) {
-  call_state *c = gpr_malloc(sizeof(*c));
+static call_state* new_call(call_state* sibling, call_state_type type) {
+  call_state* c = static_cast<call_state*>(gpr_malloc(sizeof(*c)));
   memset(c, 0, sizeof(*c));
-  if (sibling != NULL) {
+  if (sibling != nullptr) {
     c->next = sibling;
     c->prev = sibling->prev;
     c->next->prev = c->prev->next = c;
@@ -598,10 +610,10 @@ static call_state *new_call(call_state *sibling, call_state_type type) {
   return c;
 }
 
-static call_state *maybe_delete_call_state(call_state *call) {
-  call_state *next = call->next;
+static call_state* maybe_delete_call_state(call_state* call) {
+  call_state* next = call->next;
 
-  if (call->call != NULL) return next;
+  if (call->call != nullptr) return next;
   if (call->pending_ops != 0) return next;
 
   if (call == g_active_call) {
@@ -631,33 +643,34 @@ static call_state *maybe_delete_call_state(call_state *call) {
   return next;
 }
 
-static void add_to_free(call_state *call, void *p) {
+static void add_to_free(call_state* call, void* p) {
   if (call->num_to_free == call->cap_to_free) {
     call->cap_to_free = GPR_MAX(8, 2 * call->cap_to_free);
-    call->to_free =
-        gpr_realloc(call->to_free, sizeof(*call->to_free) * call->cap_to_free);
+    call->to_free = static_cast<void**>(
+        gpr_realloc(call->to_free, sizeof(*call->to_free) * call->cap_to_free));
   }
   call->to_free[call->num_to_free++] = p;
 }
 
-static grpc_slice *add_slice_to_unref(call_state *call, grpc_slice s) {
+static grpc_slice* add_slice_to_unref(call_state* call, grpc_slice s) {
   if (call->num_slices_to_unref == call->cap_slices_to_unref) {
     call->cap_slices_to_unref = GPR_MAX(8, 2 * call->cap_slices_to_unref);
-    call->slices_to_unref =
-        gpr_realloc(call->slices_to_unref,
-                    sizeof(*call->slices_to_unref) * call->cap_slices_to_unref);
+    call->slices_to_unref = static_cast<grpc_slice**>(gpr_realloc(
+        call->slices_to_unref,
+        sizeof(*call->slices_to_unref) * call->cap_slices_to_unref));
   }
   call->slices_to_unref[call->num_slices_to_unref] =
-      gpr_malloc(sizeof(grpc_slice));
+      static_cast<grpc_slice*>(gpr_malloc(sizeof(grpc_slice)));
   *call->slices_to_unref[call->num_slices_to_unref++] = s;
   return call->slices_to_unref[call->num_slices_to_unref - 1];
 }
 
-static void read_metadata(input_stream *inp, size_t *count,
-                          grpc_metadata **metadata, call_state *cs) {
+static void read_metadata(input_stream* inp, size_t* count,
+                          grpc_metadata** metadata, call_state* cs) {
   *count = next_byte(inp);
   if (*count) {
-    *metadata = gpr_malloc(*count * sizeof(**metadata));
+    *metadata =
+        static_cast<grpc_metadata*>(gpr_malloc(*count * sizeof(**metadata)));
     memset(*metadata, 0, *count * sizeof(**metadata));
     for (size_t i = 0; i < *count; i++) {
       (*metadata)[i].key = read_string_like_slice(inp);
@@ -667,23 +680,23 @@ static void read_metadata(input_stream *inp, size_t *count,
       add_slice_to_unref(cs, (*metadata)[i].value);
     }
   } else {
-    *metadata = gpr_malloc(1);
+    *metadata = static_cast<grpc_metadata*>(gpr_malloc(1));
   }
   add_to_free(cs, *metadata);
 }
 
-static call_state *destroy_call(call_state *call) {
+static call_state* destroy_call(call_state* call) {
   grpc_call_unref(call->call);
-  call->call = NULL;
+  call->call = nullptr;
   return maybe_delete_call_state(call);
 }
 
-static void finished_request_call(void *csp, bool success) {
-  call_state *cs = csp;
+static void finished_request_call(void* csp, bool success) {
+  call_state* cs = static_cast<call_state*>(csp);
   GPR_ASSERT(cs->pending_ops > 0);
   --cs->pending_ops;
   if (success) {
-    GPR_ASSERT(cs->call != NULL);
+    GPR_ASSERT(cs->call != nullptr);
     cs->type = SERVER;
   } else {
     maybe_delete_call_state(cs);
@@ -691,25 +704,25 @@ static void finished_request_call(void *csp, bool success) {
 }
 
 typedef struct {
-  call_state *cs;
+  call_state* cs;
   uint8_t has_ops;
 } batch_info;
 
-static void finished_batch(void *p, bool success) {
-  batch_info *bi = p;
+static void finished_batch(void* p, bool success) {
+  batch_info* bi = static_cast<batch_info*>(p);
   --bi->cs->pending_ops;
   if ((bi->has_ops & (1u << GRPC_OP_RECV_MESSAGE)) &&
       (bi->cs->done_flags & DONE_FLAG_CALL_CLOSED)) {
-    GPR_ASSERT(bi->cs->recv_message == NULL);
+    GPR_ASSERT(bi->cs->recv_message == nullptr);
   }
   if ((bi->has_ops & (1u << GRPC_OP_RECV_MESSAGE) &&
-       bi->cs->recv_message != NULL)) {
+       bi->cs->recv_message != nullptr)) {
     grpc_byte_buffer_destroy(bi->cs->recv_message);
-    bi->cs->recv_message = NULL;
+    bi->cs->recv_message = nullptr;
   }
   if ((bi->has_ops & (1u << GRPC_OP_SEND_MESSAGE))) {
     grpc_byte_buffer_destroy(bi->cs->send_message);
-    bi->cs->send_message = NULL;
+    bi->cs->send_message = nullptr;
   }
   if ((bi->has_ops & (1u << GRPC_OP_RECV_STATUS_ON_CLIENT)) ||
       (bi->has_ops & (1u << GRPC_OP_RECV_CLOSE_ON_SERVER))) {
@@ -719,18 +732,18 @@ static void finished_batch(void *p, bool success) {
   gpr_free(bi);
 }
 
-static validator *make_finished_batch_validator(call_state *cs,
+static validator* make_finished_batch_validator(call_state* cs,
                                                 uint8_t has_ops) {
-  batch_info *bi = gpr_malloc(sizeof(*bi));
+  batch_info* bi = static_cast<batch_info*>(gpr_malloc(sizeof(*bi)));
   bi->cs = cs;
   bi->has_ops = has_ops;
   return create_validator(finished_batch, bi);
 }
 
-int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   grpc_test_only_set_slice_hash_seed(0);
-  char *grpc_trace_fuzzer = gpr_getenv("GRPC_TRACE_FUZZER");
-  if (squelch && grpc_trace_fuzzer == NULL) gpr_set_log_function(dont_log);
+  char* grpc_trace_fuzzer = gpr_getenv("GRPC_TRACE_FUZZER");
+  if (squelch && grpc_trace_fuzzer == nullptr) gpr_set_log_function(dont_log);
   gpr_free(grpc_trace_fuzzer);
   input_stream inp = {data, data + size};
   grpc_tcp_client_connect_impl = my_tcp_client_connect;
@@ -745,42 +758,43 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   grpc_resolve_address = my_resolve_address;
   grpc_dns_lookup_ares = my_dns_lookup_ares;
 
-  GPR_ASSERT(g_channel == NULL);
-  GPR_ASSERT(g_server == NULL);
+  GPR_ASSERT(g_channel == nullptr);
+  GPR_ASSERT(g_server == nullptr);
 
   bool server_shutdown = false;
   int pending_server_shutdowns = 0;
   int pending_channel_watches = 0;
   int pending_pings = 0;
 
-  g_active_call = new_call(NULL, ROOT);
+  g_active_call = new_call(nullptr, ROOT);
   g_resource_quota = grpc_resource_quota_create("api_fuzzer");
 
-  grpc_completion_queue *cq = grpc_completion_queue_create_for_next(NULL);
+  grpc_completion_queue* cq = grpc_completion_queue_create_for_next(nullptr);
 
-  while (!is_eof(&inp) || g_channel != NULL || g_server != NULL ||
+  while (!is_eof(&inp) || g_channel != nullptr || g_server != nullptr ||
          pending_channel_watches > 0 || pending_pings > 0 ||
          g_active_call->type != ROOT || g_active_call->next != g_active_call) {
     if (is_eof(&inp)) {
-      if (g_channel != NULL) {
+      if (g_channel != nullptr) {
         grpc_channel_destroy(g_channel);
-        g_channel = NULL;
+        g_channel = nullptr;
       }
-      if (g_server != NULL) {
+      if (g_server != nullptr) {
         if (!server_shutdown) {
           grpc_server_shutdown_and_notify(
-              g_server, cq, create_validator(assert_success_and_decrement,
-                                             &pending_server_shutdowns));
+              g_server, cq,
+              create_validator(assert_success_and_decrement,
+                               &pending_server_shutdowns));
           server_shutdown = true;
           pending_server_shutdowns++;
         } else if (pending_server_shutdowns == 0) {
           grpc_server_destroy(g_server);
-          g_server = NULL;
+          g_server = nullptr;
         }
       }
-      call_state *s = g_active_call;
+      call_state* s = g_active_call;
       do {
-        if (s->type != PENDING_SERVER && s->call != NULL) {
+        if (s->type != PENDING_SERVER && s->call != nullptr) {
           s = destroy_call(s);
         } else {
           s = s->next;
@@ -800,10 +814,10 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
       // tickle completion queue
       case 0: {
         grpc_event ev = grpc_completion_queue_next(
-            cq, gpr_inf_past(GPR_CLOCK_REALTIME), NULL);
+            cq, gpr_inf_past(GPR_CLOCK_REALTIME), nullptr);
         switch (ev.type) {
           case GRPC_OP_COMPLETE: {
-            validator *v = ev.tag;
+            validator* v = static_cast<validator*>(ev.tag);
             v->validate(v->arg, ev.success);
             gpr_free(v);
             break;
@@ -824,13 +838,13 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
       }
       // create an insecure channel
       case 2: {
-        if (g_channel == NULL) {
-          char *target = read_string(&inp, NULL);
-          char *target_uri;
+        if (g_channel == nullptr) {
+          char* target = read_string(&inp, nullptr);
+          char* target_uri;
           gpr_asprintf(&target_uri, "dns:%s", target);
-          grpc_channel_args *args = read_args(&inp);
-          g_channel = grpc_insecure_channel_create(target_uri, args, NULL);
-          GPR_ASSERT(g_channel != NULL);
+          grpc_channel_args* args = read_args(&inp);
+          g_channel = grpc_insecure_channel_create(target_uri, args, nullptr);
+          GPR_ASSERT(g_channel != nullptr);
           {
             grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
             grpc_channel_args_destroy(&exec_ctx, args);
@@ -845,9 +859,9 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
       }
       // destroy a channel
       case 3: {
-        if (g_channel != NULL) {
+        if (g_channel != nullptr) {
           grpc_channel_destroy(g_channel);
-          g_channel = NULL;
+          g_channel = nullptr;
         } else {
           end(&inp);
         }
@@ -855,16 +869,16 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
       }
       // bring up a server
       case 4: {
-        if (g_server == NULL) {
-          grpc_channel_args *args = read_args(&inp);
-          g_server = grpc_server_create(args, NULL);
-          GPR_ASSERT(g_server != NULL);
+        if (g_server == nullptr) {
+          grpc_channel_args* args = read_args(&inp);
+          g_server = grpc_server_create(args, nullptr);
+          GPR_ASSERT(g_server != nullptr);
           {
             grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
             grpc_channel_args_destroy(&exec_ctx, args);
             grpc_exec_ctx_finish(&exec_ctx);
           }
-          grpc_server_register_completion_queue(g_server, cq, NULL);
+          grpc_server_register_completion_queue(g_server, cq, nullptr);
           grpc_server_start(g_server);
           server_shutdown = false;
           GPR_ASSERT(pending_server_shutdowns == 0);
@@ -875,10 +889,11 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
       }
       // begin server shutdown
       case 5: {
-        if (g_server != NULL) {
+        if (g_server != nullptr) {
           grpc_server_shutdown_and_notify(
-              g_server, cq, create_validator(assert_success_and_decrement,
-                                             &pending_server_shutdowns));
+              g_server, cq,
+              create_validator(assert_success_and_decrement,
+                               &pending_server_shutdowns));
           pending_server_shutdowns++;
           server_shutdown = true;
         } else {
@@ -888,7 +903,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
       }
       // cancel all calls if shutdown
       case 6: {
-        if (g_server != NULL && server_shutdown) {
+        if (g_server != nullptr && server_shutdown) {
           grpc_server_cancel_all_calls(g_server);
         } else {
           end(&inp);
@@ -897,10 +912,10 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
       }
       // destroy server
       case 7: {
-        if (g_server != NULL && server_shutdown &&
+        if (g_server != nullptr && server_shutdown &&
             pending_server_shutdowns == 0) {
           grpc_server_destroy(g_server);
-          g_server = NULL;
+          g_server = nullptr;
         } else {
           end(&inp);
         }
@@ -908,7 +923,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
       }
       // check connectivity
       case 8: {
-        if (g_channel != NULL) {
+        if (g_channel != nullptr) {
           uint8_t try_to_connect = next_byte(&inp);
           if (try_to_connect == 0 || try_to_connect == 1) {
             grpc_channel_check_connectivity_state(g_channel, try_to_connect);
@@ -922,7 +937,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
       }
       // watch connectivity
       case 9: {
-        if (g_channel != NULL) {
+        if (g_channel != nullptr) {
           grpc_connectivity_state st =
               grpc_channel_check_connectivity_state(g_channel, 0);
           if (st != GRPC_CHANNEL_SHUTDOWN) {
@@ -944,10 +959,10 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
       // create a call
       case 10: {
         bool ok = true;
-        if (g_channel == NULL) ok = false;
-        grpc_call *parent_call = NULL;
+        if (g_channel == nullptr) ok = false;
+        grpc_call* parent_call = nullptr;
         if (g_active_call->type != ROOT) {
-          if (g_active_call->call == NULL || g_active_call->type == CLIENT) {
+          if (g_active_call->call == nullptr || g_active_call->type == CLIENT) {
             end(&inp);
             break;
           }
@@ -964,10 +979,10 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
                          gpr_time_from_micros(read_uint32(&inp), GPR_TIMESPAN));
 
         if (ok) {
-          call_state *cs = new_call(g_active_call, CLIENT);
+          call_state* cs = new_call(g_active_call, CLIENT);
           cs->call =
               grpc_channel_create_call(g_channel, parent_call, propagation_mask,
-                                       cq, method, &host, deadline, NULL);
+                                       cq, method, &host, deadline, nullptr);
         } else {
           end(&inp);
         }
@@ -983,7 +998,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
       // queue some ops on a call
       case 12: {
         if (g_active_call->type == PENDING_SERVER ||
-            g_active_call->type == ROOT || g_active_call->call == NULL) {
+            g_active_call->type == ROOT || g_active_call->call == nullptr) {
           end(&inp);
           break;
         }
@@ -992,11 +1007,12 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
           end(&inp);
           break;
         }
-        grpc_op *ops = gpr_malloc(sizeof(grpc_op) * num_ops);
+        grpc_op* ops =
+            static_cast<grpc_op*>(gpr_malloc(sizeof(grpc_op) * num_ops));
         if (num_ops > 0) memset(ops, 0, sizeof(grpc_op) * num_ops);
         bool ok = true;
         size_t i;
-        grpc_op *op;
+        grpc_op* op;
         uint8_t has_ops = 0;
         for (i = 0; i < num_ops; i++) {
           op = &ops[i];
@@ -1015,7 +1031,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
               break;
             case GRPC_OP_SEND_MESSAGE:
               op->op = GRPC_OP_SEND_MESSAGE;
-              if (g_active_call->send_message != NULL) {
+              if (g_active_call->send_message != nullptr) {
                 ok = false;
               } else {
                 has_ops |= 1 << GRPC_OP_SEND_MESSAGE;
@@ -1035,7 +1051,8 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
                   &op->data.send_status_from_server.trailing_metadata_count,
                   &op->data.send_status_from_server.trailing_metadata,
                   g_active_call);
-              op->data.send_status_from_server.status = next_byte(&inp);
+              op->data.send_status_from_server.status =
+                  static_cast<grpc_status_code>(next_byte(&inp));
               op->data.send_status_from_server.status_details =
                   add_slice_to_unref(g_active_call,
                                      read_buffer_like_slice(&inp));
@@ -1066,14 +1083,14 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
                   &g_active_call->cancelled;
               break;
           }
-          op->reserved = NULL;
+          op->reserved = nullptr;
           op->flags = read_uint32(&inp);
         }
         if (ok) {
-          validator *v = make_finished_batch_validator(g_active_call, has_ops);
+          validator* v = make_finished_batch_validator(g_active_call, has_ops);
           g_active_call->pending_ops++;
-          grpc_call_error error =
-              grpc_call_start_batch(g_active_call->call, ops, num_ops, v, NULL);
+          grpc_call_error error = grpc_call_start_batch(
+              g_active_call->call, ops, num_ops, v, nullptr);
           if (error != GRPC_CALL_OK) {
             v->validate(v->arg, false);
             gpr_free(v);
@@ -1083,7 +1100,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
         }
         if (!ok && (has_ops & (1 << GRPC_OP_SEND_MESSAGE))) {
           grpc_byte_buffer_destroy(g_active_call->send_message);
-          g_active_call->send_message = NULL;
+          g_active_call->send_message = nullptr;
         }
         gpr_free(ops);
 
@@ -1091,8 +1108,8 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
       }
       // cancel current call
       case 13: {
-        if (g_active_call->type != ROOT && g_active_call->call != NULL) {
-          grpc_call_cancel(g_active_call->call, NULL);
+        if (g_active_call->type != ROOT && g_active_call->call != nullptr) {
+          grpc_call_cancel(g_active_call->call, nullptr);
         } else {
           end(&inp);
         }
@@ -1100,7 +1117,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
       }
       // get a calls peer
       case 14: {
-        if (g_active_call->type != ROOT && g_active_call->call != NULL) {
+        if (g_active_call->type != ROOT && g_active_call->call != nullptr) {
           free_non_null(grpc_call_get_peer(g_active_call->call));
         } else {
           end(&inp);
@@ -1109,7 +1126,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
       }
       // get a channels target
       case 15: {
-        if (g_channel != NULL) {
+        if (g_channel != nullptr) {
           free_non_null(grpc_channel_get_target(g_channel));
         } else {
           end(&inp);
@@ -1118,10 +1135,11 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
       }
       // send a ping on a channel
       case 16: {
-        if (g_channel != NULL) {
+        if (g_channel != nullptr) {
           pending_pings++;
           grpc_channel_ping(g_channel, cq,
-                            create_validator(decrement, &pending_pings), NULL);
+                            create_validator(decrement, &pending_pings),
+                            nullptr);
         } else {
           end(&inp);
         }
@@ -1129,27 +1147,27 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
       }
       // enable a tracer
       case 17: {
-        char *tracer = read_string(&inp, NULL);
+        char* tracer = read_string(&inp, nullptr);
         grpc_tracer_set_enabled(tracer, 1);
         gpr_free(tracer);
         break;
       }
       // disable a tracer
       case 18: {
-        char *tracer = read_string(&inp, NULL);
+        char* tracer = read_string(&inp, nullptr);
         grpc_tracer_set_enabled(tracer, 0);
         gpr_free(tracer);
         break;
       }
       // request a server call
       case 19: {
-        if (g_server == NULL) {
+        if (g_server == nullptr) {
           end(&inp);
           break;
         }
-        call_state *cs = new_call(g_active_call, PENDING_SERVER);
+        call_state* cs = new_call(g_active_call, PENDING_SERVER);
         cs->pending_ops++;
-        validator *v = create_validator(finished_request_call, cs);
+        validator* v = create_validator(finished_request_call, cs);
         grpc_call_error error =
             grpc_server_request_call(g_server, &cs->call, &cs->call_details,
                                      &cs->recv_initial_metadata, cq, cq, v);
@@ -1163,7 +1181,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
       case 20: {
         if (g_active_call->type != ROOT &&
             g_active_call->type != PENDING_SERVER &&
-            g_active_call->call != NULL) {
+            g_active_call->call != nullptr) {
           destroy_call(g_active_call);
         } else {
           end(&inp);
@@ -1177,14 +1195,15 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
       }
       // create a secure channel
       case 22: {
-        if (g_channel == NULL) {
-          char *target = read_string(&inp, NULL);
-          char *target_uri;
+        if (g_channel == nullptr) {
+          char* target = read_string(&inp, nullptr);
+          char* target_uri;
           gpr_asprintf(&target_uri, "dns:%s", target);
-          grpc_channel_args *args = read_args(&inp);
-          grpc_channel_credentials *creds = read_channel_creds(&inp);
-          g_channel = grpc_secure_channel_create(creds, target_uri, args, NULL);
-          GPR_ASSERT(g_channel != NULL);
+          grpc_channel_args* args = read_args(&inp);
+          grpc_channel_credentials* creds = read_channel_creds(&inp);
+          g_channel =
+              grpc_secure_channel_create(creds, target_uri, args, nullptr);
+          GPR_ASSERT(g_channel != nullptr);
           {
             grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
             grpc_channel_args_destroy(&exec_ctx, args);
@@ -1201,15 +1220,15 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
     }
   }
 
-  GPR_ASSERT(g_channel == NULL);
-  GPR_ASSERT(g_server == NULL);
+  GPR_ASSERT(g_channel == nullptr);
+  GPR_ASSERT(g_server == nullptr);
   GPR_ASSERT(g_active_call->type == ROOT);
   GPR_ASSERT(g_active_call->next == g_active_call);
   gpr_free(g_active_call);
 
   grpc_completion_queue_shutdown(cq);
   GPR_ASSERT(
-      grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME), NULL)
+      grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME), nullptr)
           .type == GRPC_QUEUE_SHUTDOWN);
   grpc_completion_queue_destroy(cq);
 
diff --git a/test/core/end2end/fuzzers/client_fuzzer.c b/test/core/end2end/fuzzers/client_fuzzer.cc
index 88ba6bad83..ebc8c2780d 100644
--- a/test/core/end2end/fuzzers/client_fuzzer.c
+++ b/test/core/end2end/fuzzers/client_fuzzer.cc
@@ -33,11 +33,11 @@ bool leak_check = true;
 
 static void discard_write(grpc_slice slice) {}
 
-static void *tag(int n) { return (void *)(uintptr_t)n; }
+static void* tag(int n) { return (void*)(uintptr_t)n; }
 
-static void dont_log(gpr_log_func_args *args) {}
+static void dont_log(gpr_log_func_args* args) {}
 
-int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   grpc_test_only_set_slice_hash_seed(0);
   struct grpc_memory_counters counters;
   if (squelch) gpr_set_log_function(dont_log);
@@ -46,27 +46,27 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_executor_set_threading(&exec_ctx, false);
 
-  grpc_resource_quota *resource_quota =
+  grpc_resource_quota* resource_quota =
       grpc_resource_quota_create("client_fuzzer");
-  grpc_endpoint *mock_endpoint =
+  grpc_endpoint* mock_endpoint =
       grpc_mock_endpoint_create(discard_write, resource_quota);
   grpc_resource_quota_unref_internal(&exec_ctx, resource_quota);
 
-  grpc_completion_queue *cq = grpc_completion_queue_create_for_next(NULL);
-  grpc_transport *transport =
-      grpc_create_chttp2_transport(&exec_ctx, NULL, mock_endpoint, 1);
-  grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL);
+  grpc_completion_queue* cq = grpc_completion_queue_create_for_next(nullptr);
+  grpc_transport* transport =
+      grpc_create_chttp2_transport(&exec_ctx, nullptr, mock_endpoint, 1);
+  grpc_chttp2_transport_start_reading(&exec_ctx, transport, nullptr);
 
-  grpc_channel *channel = grpc_channel_create(
-      &exec_ctx, "test-target", NULL, GRPC_CLIENT_DIRECT_CHANNEL, transport);
+  grpc_channel* channel = grpc_channel_create(
+      &exec_ctx, "test-target", nullptr, GRPC_CLIENT_DIRECT_CHANNEL, transport);
   grpc_slice host = grpc_slice_from_static_string("localhost");
-  grpc_call *call = grpc_channel_create_call(
-      channel, NULL, 0, cq, grpc_slice_from_static_string("/foo"), &host,
-      gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+  grpc_call* call = grpc_channel_create_call(
+      channel, nullptr, 0, cq, grpc_slice_from_static_string("/foo"), &host,
+      gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
 
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array_init(&initial_metadata_recv);
-  grpc_byte_buffer *response_payload_recv = NULL;
+  grpc_byte_buffer* response_payload_recv = nullptr;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array_init(&trailing_metadata_recv);
   grpc_status_code status;
@@ -74,46 +74,47 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
 
   grpc_op ops[6];
   memset(ops, 0, sizeof(ops));
-  grpc_op *op = ops;
+  grpc_op* op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &response_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   grpc_call_error error =
-      grpc_call_start_batch(call, ops, (size_t)(op - ops), tag(1), NULL);
+      grpc_call_start_batch(call, ops, (size_t)(op - ops), tag(1), nullptr);
   int requested_calls = 1;
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   grpc_mock_endpoint_put_read(
       &exec_ctx, mock_endpoint,
-      grpc_slice_from_copied_buffer((const char *)data, size));
+      grpc_slice_from_copied_buffer((const char*)data, size));
 
   grpc_event ev;
   while (1) {
     grpc_exec_ctx_flush(&exec_ctx);
-    ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME), NULL);
+    ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME),
+                                    nullptr);
     switch (ev.type) {
       case GRPC_QUEUE_TIMEOUT:
         goto done;
@@ -127,15 +128,17 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
 
 done:
   if (requested_calls) {
-    grpc_call_cancel(call, NULL);
+    grpc_call_cancel(call, nullptr);
   }
   for (int i = 0; i < requested_calls; i++) {
-    ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME), NULL);
+    ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME),
+                                    nullptr);
     GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
   }
   grpc_completion_queue_shutdown(cq);
   for (int i = 0; i < requested_calls; i++) {
-    ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME), NULL);
+    ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME),
+                                    nullptr);
     GPR_ASSERT(ev.type == GRPC_QUEUE_SHUTDOWN);
   }
   grpc_call_unref(call);
@@ -144,7 +147,7 @@ done:
   grpc_metadata_array_destroy(&trailing_metadata_recv);
   grpc_slice_unref(details);
   grpc_channel_destroy(channel);
-  if (response_payload_recv != NULL) {
+  if (response_payload_recv != nullptr) {
     grpc_byte_buffer_destroy(response_payload_recv);
   }
   grpc_shutdown();
diff --git a/test/core/end2end/fuzzers/server_fuzzer.c b/test/core/end2end/fuzzers/server_fuzzer.cc
index ef4c0a4bfd..fb6477b579 100644
--- a/test/core/end2end/fuzzers/server_fuzzer.c
+++ b/test/core/end2end/fuzzers/server_fuzzer.cc
@@ -30,12 +30,12 @@ bool leak_check = true;
 
 static void discard_write(grpc_slice slice) {}
 
-static void *tag(int n) { return (void *)(uintptr_t)n; }
-static int detag(void *p) { return (int)(uintptr_t)p; }
+static void* tag(int n) { return (void*)(uintptr_t)n; }
+static int detag(void* p) { return (int)(uintptr_t)p; }
 
-static void dont_log(gpr_log_func_args *args) {}
+static void dont_log(gpr_log_func_args* args) {}
 
-int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   grpc_test_only_set_slice_hash_seed(0);
   struct grpc_memory_counters counters;
   if (squelch) gpr_set_log_function(dont_log);
@@ -44,28 +44,28 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_executor_set_threading(&exec_ctx, false);
 
-  grpc_resource_quota *resource_quota =
+  grpc_resource_quota* resource_quota =
       grpc_resource_quota_create("server_fuzzer");
-  grpc_endpoint *mock_endpoint =
+  grpc_endpoint* mock_endpoint =
       grpc_mock_endpoint_create(discard_write, resource_quota);
   grpc_resource_quota_unref_internal(&exec_ctx, resource_quota);
   grpc_mock_endpoint_put_read(
       &exec_ctx, mock_endpoint,
-      grpc_slice_from_copied_buffer((const char *)data, size));
+      grpc_slice_from_copied_buffer((const char*)data, size));
 
-  grpc_server *server = grpc_server_create(NULL, NULL);
-  grpc_completion_queue *cq = grpc_completion_queue_create_for_next(NULL);
-  grpc_server_register_completion_queue(server, cq, NULL);
+  grpc_server* server = grpc_server_create(nullptr, nullptr);
+  grpc_completion_queue* cq = grpc_completion_queue_create_for_next(nullptr);
+  grpc_server_register_completion_queue(server, cq, nullptr);
   // TODO(ctiller): add registered methods (one for POST, one for PUT)
   // void *registered_method =
   //    grpc_server_register_method(server, "/reg", NULL, 0);
   grpc_server_start(server);
-  grpc_transport *transport =
-      grpc_create_chttp2_transport(&exec_ctx, NULL, mock_endpoint, 0);
-  grpc_server_setup_transport(&exec_ctx, server, transport, NULL, NULL);
-  grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL);
+  grpc_transport* transport =
+      grpc_create_chttp2_transport(&exec_ctx, nullptr, mock_endpoint, 0);
+  grpc_server_setup_transport(&exec_ctx, server, transport, nullptr, nullptr);
+  grpc_chttp2_transport_start_reading(&exec_ctx, transport, nullptr);
 
-  grpc_call *call1 = NULL;
+  grpc_call* call1 = nullptr;
   grpc_call_details call_details1;
   grpc_metadata_array request_metadata1;
   grpc_call_details_init(&call_details1);
@@ -80,7 +80,8 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   grpc_event ev;
   while (1) {
     grpc_exec_ctx_flush(&exec_ctx);
-    ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME), NULL);
+    ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME),
+                                    nullptr);
     switch (ev.type) {
       case GRPC_QUEUE_TIMEOUT:
         goto done;
@@ -97,18 +98,20 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   }
 
 done:
-  if (call1 != NULL) grpc_call_unref(call1);
+  if (call1 != nullptr) grpc_call_unref(call1);
   grpc_call_details_destroy(&call_details1);
   grpc_metadata_array_destroy(&request_metadata1);
   grpc_server_shutdown_and_notify(server, cq, tag(0xdead));
   grpc_server_cancel_all_calls(server);
   for (int i = 0; i <= requested_calls; i++) {
-    ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME), NULL);
+    ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME),
+                                    nullptr);
     GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
   }
   grpc_completion_queue_shutdown(cq);
   for (int i = 0; i <= requested_calls; i++) {
-    ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME), NULL);
+    ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME),
+                                    nullptr);
     GPR_ASSERT(ev.type == GRPC_QUEUE_SHUTDOWN);
   }
   grpc_server_destroy(server);
diff --git a/test/core/end2end/gen_build_yaml.py b/test/core/end2end/gen_build_yaml.py
index f7f996d5c1..7c8e7f420a 100755
--- a/test/core/end2end/gen_build_yaml.py
+++ b/test/core/end2end/gen_build_yaml.py
@@ -220,9 +220,9 @@ def main():
               'build': 'private',
               'language': 'c',
               'secure': True,
-              'src': ['test/core/end2end/end2end_tests.c',
-                      'test/core/end2end/end2end_test_utils.c'] + [
-                  'test/core/end2end/tests/%s.c' % t
+              'src': ['test/core/end2end/end2end_tests.cc',
+                      'test/core/end2end/end2end_test_utils.cc'] + [
+                  'test/core/end2end/tests/%s.cc' % t
                   for t in sorted(END2END_TESTS.keys())],
               'headers': ['test/core/end2end/tests/cancel_test_helpers.h',
                           'test/core/end2end/end2end_tests.h'],
@@ -235,9 +235,9 @@ def main():
               'build': 'private',
               'language': 'c',
               'secure': False,
-              'src': ['test/core/end2end/end2end_nosec_tests.c',
-                      'test/core/end2end/end2end_test_utils.c'] + [
-                  'test/core/end2end/tests/%s.c' % t
+              'src': ['test/core/end2end/end2end_nosec_tests.cc',
+                      'test/core/end2end/end2end_test_utils.cc'] + [
+                  'test/core/end2end/tests/%s.cc' % t
                   for t in sorted(END2END_TESTS.keys())
                   if not END2END_TESTS[t].secure],
               'headers': ['test/core/end2end/tests/cancel_test_helpers.h',
@@ -252,7 +252,7 @@ def main():
               'build': 'test',
               'language': 'c',
               'run': False,
-              'src': ['test/core/end2end/fixtures/%s.c' % f],
+              'src': ['test/core/end2end/fixtures/%s.cc' % f],
               'platforms': END2END_FIXTURES[f].platforms,
               'ci_platforms': (END2END_FIXTURES[f].platforms
                                if END2END_FIXTURES[f].ci_mac else without(
@@ -269,7 +269,7 @@ def main():
               'build': 'test',
               'language': 'c',
               'secure': False,
-              'src': ['test/core/end2end/fixtures/%s.c' % f],
+              'src': ['test/core/end2end/fixtures/%s.cc' % f],
               'run': False,
               'platforms': END2END_FIXTURES[f].platforms,
               'ci_platforms': (END2END_FIXTURES[f].platforms
diff --git a/test/core/end2end/generate_tests.bzl b/test/core/end2end/generate_tests.bzl
index 89a95edfd7..b9a42bdb88 100755
--- a/test/core/end2end/generate_tests.bzl
+++ b/test/core/end2end/generate_tests.bzl
@@ -186,14 +186,14 @@ def compatible(fopt, topt):
 def grpc_end2end_tests():
   grpc_cc_library(
     name = 'end2end_tests',
-    srcs = ['end2end_tests.c', 'end2end_test_utils.c'] + [
-             'tests/%s.c' % t
+    srcs = ['end2end_tests.cc', 'end2end_test_utils.cc'] + [
+             'tests/%s.cc' % t
              for t in sorted(END2END_TESTS.keys())],
     hdrs = [
       'tests/cancel_test_helpers.h',
       'end2end_tests.h'
     ],
-    language = "C",
+    language = "C++",
     deps = [
       ':cq_verifier',
       ':ssl_test_data',
@@ -205,8 +205,8 @@ def grpc_end2end_tests():
   for f, fopt in END2END_FIXTURES.items():
     grpc_cc_binary(
       name = '%s_test' % f,
-      srcs = ['fixtures/%s.c' % f],
-      language = "C",
+      srcs = ['fixtures/%s.cc' % f],
+      language = "C++",
       deps = [
         ':end2end_tests',
         '//test/core/util:grpc_test_util',
diff --git a/test/core/end2end/goaway_server_test.c b/test/core/end2end/goaway_server_test.cc
index c3aca13249..2d0db967c3 100644
--- a/test/core/end2end/goaway_server_test.c
+++ b/test/core/end2end/goaway_server_test.cc
@@ -35,21 +35,21 @@
 #include "test/core/util/port.h"
 #include "test/core/util/test_config.h"
 
-static void *tag(intptr_t i) { return (void *)i; }
+static void* tag(intptr_t i) { return (void*)i; }
 
 static gpr_mu g_mu;
 static int g_resolve_port = -1;
-static void (*iomgr_resolve_address)(grpc_exec_ctx *exec_ctx, const char *addr,
-                                     const char *default_port,
-                                     grpc_pollset_set *interested_parties,
-                                     grpc_closure *on_done,
-                                     grpc_resolved_addresses **addresses);
-
-static grpc_ares_request *(*iomgr_dns_lookup_ares)(
-    grpc_exec_ctx *exec_ctx, const char *dns_server, const char *addr,
-    const char *default_port, grpc_pollset_set *interested_parties,
-    grpc_closure *on_done, grpc_lb_addresses **addresses, bool check_grpclb,
-    char **service_config_json);
+static void (*iomgr_resolve_address)(grpc_exec_ctx* exec_ctx, const char* addr,
+                                     const char* default_port,
+                                     grpc_pollset_set* interested_parties,
+                                     grpc_closure* on_done,
+                                     grpc_resolved_addresses** addresses);
+
+static grpc_ares_request* (*iomgr_dns_lookup_ares)(
+    grpc_exec_ctx* exec_ctx, const char* dns_server, const char* addr,
+    const char* default_port, grpc_pollset_set* interested_parties,
+    grpc_closure* on_done, grpc_lb_addresses** addresses, bool check_grpclb,
+    char** service_config_json);
 
 static void set_resolve_port(int port) {
   gpr_mu_lock(&g_mu);
@@ -57,28 +57,29 @@ static void set_resolve_port(int port) {
   gpr_mu_unlock(&g_mu);
 }
 
-static void my_resolve_address(grpc_exec_ctx *exec_ctx, const char *addr,
-                               const char *default_port,
-                               grpc_pollset_set *interested_parties,
-                               grpc_closure *on_done,
-                               grpc_resolved_addresses **addrs) {
+static void my_resolve_address(grpc_exec_ctx* exec_ctx, const char* addr,
+                               const char* default_port,
+                               grpc_pollset_set* interested_parties,
+                               grpc_closure* on_done,
+                               grpc_resolved_addresses** addrs) {
   if (0 != strcmp(addr, "test")) {
     iomgr_resolve_address(exec_ctx, addr, default_port, interested_parties,
                           on_done, addrs);
     return;
   }
 
-  grpc_error *error = GRPC_ERROR_NONE;
+  grpc_error* error = GRPC_ERROR_NONE;
   gpr_mu_lock(&g_mu);
   if (g_resolve_port < 0) {
     gpr_mu_unlock(&g_mu);
     error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Forced Failure");
   } else {
-    *addrs = gpr_malloc(sizeof(**addrs));
+    *addrs = static_cast<grpc_resolved_addresses*>(gpr_malloc(sizeof(**addrs)));
     (*addrs)->naddrs = 1;
-    (*addrs)->addrs = gpr_malloc(sizeof(*(*addrs)->addrs));
+    (*addrs)->addrs = static_cast<grpc_resolved_address*>(
+        gpr_malloc(sizeof(*(*addrs)->addrs)));
     memset((*addrs)->addrs, 0, sizeof(*(*addrs)->addrs));
-    struct sockaddr_in *sa = (struct sockaddr_in *)(*addrs)->addrs[0].addr;
+    struct sockaddr_in* sa = (struct sockaddr_in*)(*addrs)->addrs[0].addr;
     sa->sin_family = AF_INET;
     sa->sin_addr.s_addr = htonl(0x7f000001);
     sa->sin_port = htons((uint16_t)g_resolve_port);
@@ -88,42 +89,43 @@ static void my_resolve_address(grpc_exec_ctx *exec_ctx, const char *addr,
   GRPC_CLOSURE_SCHED(exec_ctx, on_done, error);
 }
 
-static grpc_ares_request *my_dns_lookup_ares(
-    grpc_exec_ctx *exec_ctx, const char *dns_server, const char *addr,
-    const char *default_port, grpc_pollset_set *interested_parties,
-    grpc_closure *on_done, grpc_lb_addresses **lb_addrs, bool check_grpclb,
-    char **service_config_json) {
+static grpc_ares_request* my_dns_lookup_ares(
+    grpc_exec_ctx* exec_ctx, const char* dns_server, const char* addr,
+    const char* default_port, grpc_pollset_set* interested_parties,
+    grpc_closure* on_done, grpc_lb_addresses** lb_addrs, bool check_grpclb,
+    char** service_config_json) {
   if (0 != strcmp(addr, "test")) {
     return iomgr_dns_lookup_ares(exec_ctx, dns_server, addr, default_port,
                                  interested_parties, on_done, lb_addrs,
                                  check_grpclb, service_config_json);
   }
 
-  grpc_error *error = GRPC_ERROR_NONE;
+  grpc_error* error = GRPC_ERROR_NONE;
   gpr_mu_lock(&g_mu);
   if (g_resolve_port < 0) {
     gpr_mu_unlock(&g_mu);
     error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Forced Failure");
   } else {
-    *lb_addrs = grpc_lb_addresses_create(1, NULL);
-    struct sockaddr_in *sa = gpr_zalloc(sizeof(struct sockaddr_in));
+    *lb_addrs = grpc_lb_addresses_create(1, nullptr);
+    struct sockaddr_in* sa = static_cast<struct sockaddr_in*>(
+        gpr_zalloc(sizeof(struct sockaddr_in)));
     sa->sin_family = AF_INET;
     sa->sin_addr.s_addr = htonl(0x7f000001);
     sa->sin_port = htons((uint16_t)g_resolve_port);
-    grpc_lb_addresses_set_address(*lb_addrs, 0, sa, sizeof(*sa), false, NULL,
-                                  NULL);
+    grpc_lb_addresses_set_address(*lb_addrs, 0, sa, sizeof(*sa), false, nullptr,
+                                  nullptr);
     gpr_free(sa);
     gpr_mu_unlock(&g_mu);
   }
   GRPC_CLOSURE_SCHED(exec_ctx, on_done, error);
-  return NULL;
+  return nullptr;
 }
 
-int main(int argc, char **argv) {
-  grpc_completion_queue *cq;
-  cq_verifier *cqv;
+int main(int argc, char** argv) {
+  grpc_completion_queue* cq;
+  cq_verifier* cqv;
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
 
   grpc_test_init(argc, argv);
 
@@ -155,42 +157,44 @@ int main(int argc, char **argv) {
   grpc_metadata_array_init(&request_metadata2);
   grpc_call_details_init(&request_details2);
 
-  cq = grpc_completion_queue_create_for_next(NULL);
+  cq = grpc_completion_queue_create_for_next(nullptr);
   cqv = cq_verifier_create(cq);
 
   /* reserve two ports */
   int port1 = grpc_pick_unused_port_or_die();
   int port2 = grpc_pick_unused_port_or_die();
 
-  char *addr;
+  char* addr;
 
   grpc_channel_args client_args;
   grpc_arg arg_array[1];
   arg_array[0].type = GRPC_ARG_INTEGER;
-  arg_array[0].key = "grpc.testing.fixed_reconnect_backoff_ms";
+  arg_array[0].key =
+      const_cast<char*>("grpc.testing.fixed_reconnect_backoff_ms");
   arg_array[0].value.integer = 1000;
   client_args.args = arg_array;
   client_args.num_args = 1;
 
   /* create a channel that picks first amongst the servers */
-  grpc_channel *chan = grpc_insecure_channel_create("test", &client_args, NULL);
+  grpc_channel* chan =
+      grpc_insecure_channel_create("test", &client_args, nullptr);
   /* and an initial call to them */
   grpc_slice host = grpc_slice_from_static_string("127.0.0.1");
-  grpc_call *call1 =
-      grpc_channel_create_call(chan, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
+  grpc_call* call1 =
+      grpc_channel_create_call(chan, nullptr, GRPC_PROPAGATE_DEFAULTS, cq,
                                grpc_slice_from_static_string("/foo"), &host,
-                               grpc_timeout_seconds_to_deadline(20), NULL);
+                               grpc_timeout_seconds_to_deadline(20), nullptr);
   /* send initial metadata to probe connectivity */
   memset(ops, 0, sizeof(ops));
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(call1, ops,
                                                    (size_t)(op - ops),
-                                                   tag(0x101), NULL));
+                                                   tag(0x101), nullptr));
   /* and receive status to probe termination */
   memset(ops, 0, sizeof(ops));
   op = ops;
@@ -199,22 +203,22 @@ int main(int argc, char **argv) {
   op->data.recv_status_on_client.status = &status1;
   op->data.recv_status_on_client.status_details = &details1;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(call1, ops,
                                                    (size_t)(op - ops),
-                                                   tag(0x102), NULL));
+                                                   tag(0x102), nullptr));
 
   /* bring a server up on the first port */
-  grpc_server *server1 = grpc_server_create(NULL, NULL);
+  grpc_server* server1 = grpc_server_create(nullptr, nullptr);
   gpr_asprintf(&addr, "127.0.0.1:%d", port1);
   grpc_server_add_insecure_http2_port(server1, addr);
-  grpc_server_register_completion_queue(server1, cq, NULL);
+  grpc_server_register_completion_queue(server1, cq, nullptr);
   gpr_free(addr);
   grpc_server_start(server1);
 
   /* request a call to the server */
-  grpc_call *server_call1;
+  grpc_call* server_call1;
   GPR_ASSERT(GRPC_CALL_OK ==
              grpc_server_request_call(server1, &server_call1, &request_details1,
                                       &request_metadata1, cq, cq, tag(0x301)));
@@ -241,7 +245,7 @@ int main(int argc, char **argv) {
   op++;
   GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(server_call1, ops,
                                                    (size_t)(op - ops),
-                                                   tag(0x302), NULL));
+                                                   tag(0x302), nullptr));
 
   /* shutdown first server:
    * we should see a connectivity change and then nothing */
@@ -252,21 +256,21 @@ int main(int argc, char **argv) {
   cq_verify_empty(cqv);
 
   /* and a new call: should go through to server2 when we start it */
-  grpc_call *call2 =
-      grpc_channel_create_call(chan, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
+  grpc_call* call2 =
+      grpc_channel_create_call(chan, nullptr, GRPC_PROPAGATE_DEFAULTS, cq,
                                grpc_slice_from_static_string("/foo"), &host,
-                               grpc_timeout_seconds_to_deadline(20), NULL);
+                               grpc_timeout_seconds_to_deadline(20), nullptr);
   /* send initial metadata to probe connectivity */
   memset(ops, 0, sizeof(ops));
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(call2, ops,
                                                    (size_t)(op - ops),
-                                                   tag(0x201), NULL));
+                                                   tag(0x201), nullptr));
   /* and receive status to probe termination */
   memset(ops, 0, sizeof(ops));
   op = ops;
@@ -275,23 +279,23 @@ int main(int argc, char **argv) {
   op->data.recv_status_on_client.status = &status2;
   op->data.recv_status_on_client.status_details = &details2;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(call2, ops,
                                                    (size_t)(op - ops),
-                                                   tag(0x202), NULL));
+                                                   tag(0x202), nullptr));
 
   /* and bring up second server */
   set_resolve_port(port2);
-  grpc_server *server2 = grpc_server_create(NULL, NULL);
+  grpc_server* server2 = grpc_server_create(nullptr, nullptr);
   gpr_asprintf(&addr, "127.0.0.1:%d", port2);
   grpc_server_add_insecure_http2_port(server2, addr);
-  grpc_server_register_completion_queue(server2, cq, NULL);
+  grpc_server_register_completion_queue(server2, cq, nullptr);
   gpr_free(addr);
   grpc_server_start(server2);
 
   /* request a call to the server */
-  grpc_call *server_call2;
+  grpc_call* server_call2;
   GPR_ASSERT(GRPC_CALL_OK ==
              grpc_server_request_call(server2, &server_call2, &request_details2,
                                       &request_metadata2, cq, cq, tag(0x401)));
@@ -310,14 +314,14 @@ int main(int argc, char **argv) {
   op++;
   GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(server_call2, ops,
                                                    (size_t)(op - ops),
-                                                   tag(0x402), NULL));
+                                                   tag(0x402), nullptr));
 
   /* shutdown second server: we should see nothing */
   grpc_server_shutdown_and_notify(server2, cq, tag(0xdead2));
   cq_verify_empty(cqv);
 
-  grpc_call_cancel(call1, NULL);
-  grpc_call_cancel(call2, NULL);
+  grpc_call_cancel(call1, nullptr);
+  grpc_call_cancel(call2, nullptr);
 
   /* now everything else should finish */
   CQ_EXPECT_COMPLETION(cqv, tag(0x102), 1);
diff --git a/test/core/end2end/h2_ssl_cert_test.cc b/test/core/end2end/h2_ssl_cert_test.cc
index 6da5e8396e..9a98c07158 100644
--- a/test/core/end2end/h2_ssl_cert_test.cc
+++ b/test/core/end2end/h2_ssl_cert_test.cc
@@ -16,9 +16,7 @@
  *
  */
 
-extern "C" {
 #include "test/core/end2end/end2end_tests.h"
-}
 
 #include <stdio.h>
 #include <string.h>
@@ -27,7 +25,6 @@ extern "C" {
 #include <grpc/support/host_port.h>
 #include <grpc/support/log.h>
 
-extern "C" {
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/support/env.h"
@@ -37,7 +34,6 @@ extern "C" {
 #include "test/core/end2end/data/ssl_test_data.h"
 #include "test/core/util/port.h"
 #include "test/core/util/test_config.h"
-}
 
 #include <gtest/gtest.h>
 
@@ -45,72 +41,72 @@ namespace grpc {
 namespace testing {
 
 typedef struct fullstack_secure_fixture_data {
-  char *localaddr;
+  char* localaddr;
 } fullstack_secure_fixture_data;
 
 static grpc_end2end_test_fixture chttp2_create_fixture_secure_fullstack(
-    grpc_channel_args *client_args, grpc_channel_args *server_args) {
+    grpc_channel_args* client_args, grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   int port = grpc_pick_unused_port_or_die();
-  fullstack_secure_fixture_data *ffd =
-      static_cast<fullstack_secure_fixture_data *>(
+  fullstack_secure_fixture_data* ffd =
+      static_cast<fullstack_secure_fixture_data*>(
           gpr_malloc(sizeof(fullstack_secure_fixture_data)));
   memset(&f, 0, sizeof(f));
 
   gpr_join_host_port(&ffd->localaddr, "localhost", port);
 
   f.fixture_data = ffd;
-  f.cq = grpc_completion_queue_create_for_next(NULL);
-  f.shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
+  f.cq = grpc_completion_queue_create_for_next(nullptr);
+  f.shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
 
   return f;
 }
 
-static void process_auth_failure(void *state, grpc_auth_context *ctx,
-                                 const grpc_metadata *md, size_t md_count,
+static void process_auth_failure(void* state, grpc_auth_context* ctx,
+                                 const grpc_metadata* md, size_t md_count,
                                  grpc_process_auth_metadata_done_cb cb,
-                                 void *user_data) {
-  GPR_ASSERT(state == NULL);
-  cb(user_data, NULL, 0, NULL, 0, GRPC_STATUS_UNAUTHENTICATED, NULL);
+                                 void* user_data) {
+  GPR_ASSERT(state == nullptr);
+  cb(user_data, nullptr, 0, nullptr, 0, GRPC_STATUS_UNAUTHENTICATED, nullptr);
 }
 
 static void chttp2_init_client_secure_fullstack(
-    grpc_end2end_test_fixture *f, grpc_channel_args *client_args,
-    grpc_channel_credentials *creds) {
-  fullstack_secure_fixture_data *ffd =
-      static_cast<fullstack_secure_fixture_data *>(f->fixture_data);
+    grpc_end2end_test_fixture* f, grpc_channel_args* client_args,
+    grpc_channel_credentials* creds) {
+  fullstack_secure_fixture_data* ffd =
+      static_cast<fullstack_secure_fixture_data*>(f->fixture_data);
   f->client =
-      grpc_secure_channel_create(creds, ffd->localaddr, client_args, NULL);
-  GPR_ASSERT(f->client != NULL);
+      grpc_secure_channel_create(creds, ffd->localaddr, client_args, nullptr);
+  GPR_ASSERT(f->client != nullptr);
   grpc_channel_credentials_release(creds);
 }
 
 static void chttp2_init_server_secure_fullstack(
-    grpc_end2end_test_fixture *f, grpc_channel_args *server_args,
-    grpc_server_credentials *server_creds) {
-  fullstack_secure_fixture_data *ffd =
-      static_cast<fullstack_secure_fixture_data *>(f->fixture_data);
+    grpc_end2end_test_fixture* f, grpc_channel_args* server_args,
+    grpc_server_credentials* server_creds) {
+  fullstack_secure_fixture_data* ffd =
+      static_cast<fullstack_secure_fixture_data*>(f->fixture_data);
   if (f->server) {
     grpc_server_destroy(f->server);
   }
-  f->server = grpc_server_create(server_args, NULL);
-  grpc_server_register_completion_queue(f->server, f->cq, NULL);
+  f->server = grpc_server_create(server_args, nullptr);
+  grpc_server_register_completion_queue(f->server, f->cq, nullptr);
   GPR_ASSERT(grpc_server_add_secure_http2_port(f->server, ffd->localaddr,
                                                server_creds));
   grpc_server_credentials_release(server_creds);
   grpc_server_start(f->server);
 }
 
-void chttp2_tear_down_secure_fullstack(grpc_end2end_test_fixture *f) {
-  fullstack_secure_fixture_data *ffd =
-      static_cast<fullstack_secure_fixture_data *>(f->fixture_data);
+void chttp2_tear_down_secure_fullstack(grpc_end2end_test_fixture* f) {
+  fullstack_secure_fixture_data* ffd =
+      static_cast<fullstack_secure_fixture_data*>(f->fixture_data);
   gpr_free(ffd->localaddr);
   gpr_free(ffd);
 }
 
-static int fail_server_auth_check(grpc_channel_args *server_args) {
+static int fail_server_auth_check(grpc_channel_args* server_args) {
   size_t i;
-  if (server_args == NULL) return 0;
+  if (server_args == nullptr) return 0;
   for (i = 0; i < server_args->num_args; i++) {
     if (strcmp(server_args->args[i].key, FAIL_AUTH_CHECK_SERVER_ARG_NAME) ==
         0) {
@@ -128,7 +124,7 @@ static int fail_server_auth_check(grpc_channel_args *server_args) {
       grpc_end2end_test_fixture * f, grpc_channel_args * server_args) {     \
     grpc_ssl_pem_key_cert_pair pem_cert_key_pair = {test_server1_key,       \
                                                     test_server1_cert};     \
-    grpc_server_credentials *ssl_creds =                                    \
+    grpc_server_credentials* ssl_creds =                                    \
         grpc_ssl_server_credentials_create_ex(                              \
             test_root_cert, &pem_cert_key_pair, 1, REQUEST_TYPE, NULL);     \
     if (fail_server_auth_check(server_args)) {                              \
@@ -154,14 +150,14 @@ typedef enum { NONE, SELF_SIGNED, SIGNED, BAD_CERT_PAIR } certtype;
 #define CLIENT_INIT(cert_type)                                               \
   static void CLIENT_INIT_NAME(cert_type)(grpc_end2end_test_fixture * f,     \
                                           grpc_channel_args * client_args) { \
-    grpc_channel_credentials *ssl_creds = NULL;                              \
+    grpc_channel_credentials* ssl_creds = NULL;                              \
     grpc_ssl_pem_key_cert_pair self_signed_client_key_cert_pair = {          \
         test_self_signed_client_key, test_self_signed_client_cert};          \
     grpc_ssl_pem_key_cert_pair signed_client_key_cert_pair = {               \
         test_signed_client_key, test_signed_client_cert};                    \
     grpc_ssl_pem_key_cert_pair bad_client_key_cert_pair = {                  \
         test_self_signed_client_key, test_signed_client_cert};               \
-    grpc_ssl_pem_key_cert_pair *key_cert_pair = NULL;                        \
+    grpc_ssl_pem_key_cert_pair* key_cert_pair = NULL;                        \
     switch (cert_type) {                                                     \
       case SELF_SIGNED:                                                      \
         key_cert_pair = &self_signed_client_key_cert_pair;                   \
@@ -179,9 +175,9 @@ typedef enum { NONE, SELF_SIGNED, SIGNED, BAD_CERT_PAIR } certtype;
         grpc_ssl_credentials_create(test_root_cert, key_cert_pair, NULL);    \
     grpc_arg ssl_name_override = {                                           \
         GRPC_ARG_STRING,                                                     \
-        const_cast<char *>(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG),               \
-        {const_cast<char *>("foo.test.google.fr")}};                         \
-    grpc_channel_args *new_client_args =                                     \
+        const_cast<char*>(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG),                \
+        {const_cast<char*>("foo.test.google.fr")}};                          \
+    grpc_channel_args* new_client_args =                                     \
         grpc_channel_args_copy_and_add(client_args, &ssl_name_override, 1);  \
     chttp2_init_client_secure_fullstack(f, new_client_args, ssl_creds);      \
     {                                                                        \
@@ -201,15 +197,17 @@ CLIENT_INIT(BAD_CERT_PAIR)
 
 typedef enum { SUCCESS, FAIL } test_result;
 
-#define SSL_TEST(request_type, cert_type, result)                         \
-  {                                                                       \
-    {TEST_NAME(request_type, cert_type, result),                          \
-     FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION |                           \
-         FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS |                     \
-         FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL,                            \
-     chttp2_create_fixture_secure_fullstack, CLIENT_INIT_NAME(cert_type), \
-     SERVER_INIT_NAME(request_type), chttp2_tear_down_secure_fullstack},  \
-        result                                                            \
+#define SSL_TEST(request_type, cert_type, result)     \
+  {                                                   \
+    {TEST_NAME(request_type, cert_type, result),      \
+     FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION |       \
+         FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | \
+         FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL,        \
+     chttp2_create_fixture_secure_fullstack,          \
+     CLIENT_INIT_NAME(cert_type),                     \
+     SERVER_INIT_NAME(request_type),                  \
+     chttp2_tear_down_secure_fullstack},              \
+        result                                        \
   }
 
 /* All test configurations */
@@ -258,7 +256,7 @@ static grpc_end2end_test_config_wrapper configs[] = {
              BAD_CERT_PAIR, FAIL),
 };
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static gpr_timespec n_seconds_time(int n) {
   return grpc_timeout_seconds_to_deadline(n);
@@ -266,31 +264,31 @@ static gpr_timespec n_seconds_time(int n) {
 
 static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_time(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_time(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -302,17 +300,17 @@ static void end_test(grpc_end2end_test_fixture *f) {
 
 static void simple_request_body(grpc_end2end_test_fixture f,
                                 test_result expected_result) {
-  grpc_call *c;
+  grpc_call* c;
   gpr_timespec deadline = five_seconds_time();
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_call_error error;
 
   grpc_slice host = grpc_slice_from_static_string("foo.test.google.fr:1234");
-  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+  c = grpc_channel_create_call(f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
                                grpc_slice_from_static_string("/foo"), &host,
-                               deadline, NULL);
+                               deadline, nullptr);
   GPR_ASSERT(c);
 
   memset(ops, 0, sizeof(ops));
@@ -320,9 +318,9 @@ static void simple_request_body(grpc_end2end_test_fixture f,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = GRPC_INITIAL_METADATA_WAIT_FOR_READY;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(1), expected_result == SUCCESS);
@@ -360,17 +358,17 @@ INSTANTIATE_TEST_CASE_P(H2SslCert, H2SslCertTest, ::testing::ValuesIn(configs));
 }  // namespace testing
 }  // namespace grpc
 
-int main(int argc, char **argv) {
-  FILE *roots_file;
+int main(int argc, char** argv) {
+  FILE* roots_file;
   size_t roots_size = strlen(test_root_cert);
-  char *roots_filename;
+  char* roots_filename;
 
   grpc_test_init(argc, argv);
   /* Set the SSL roots env var. */
   roots_file =
       gpr_tmpfile("chttp2_simple_ssl_cert_fullstack_test", &roots_filename);
-  GPR_ASSERT(roots_filename != NULL);
-  GPR_ASSERT(roots_file != NULL);
+  GPR_ASSERT(roots_filename != nullptr);
+  GPR_ASSERT(roots_file != nullptr);
   GPR_ASSERT(fwrite(test_root_cert, 1, roots_size, roots_file) == roots_size);
   fclose(roots_file);
   gpr_setenv(GRPC_DEFAULT_SSL_ROOTS_FILE_PATH_ENV_VAR, roots_filename);
diff --git a/test/core/end2end/invalid_call_argument_test.c b/test/core/end2end/invalid_call_argument_test.cc
index e3fd5a8fbe..cb6b4c08ef 100644
--- a/test/core/end2end/invalid_call_argument_test.c
+++ b/test/core/end2end/invalid_call_argument_test.cc
@@ -30,22 +30,22 @@
 #include "test/core/util/port.h"
 #include "test/core/util/test_config.h"
 
-static void *tag(intptr_t i) { return (void *)i; }
+static void* tag(intptr_t i) { return (void*)i; }
 
 struct test_state {
   int is_client;
-  grpc_channel *chan;
-  grpc_call *call;
+  grpc_channel* chan;
+  grpc_call* call;
   gpr_timespec deadline;
-  grpc_completion_queue *cq;
-  cq_verifier *cqv;
+  grpc_completion_queue* cq;
+  cq_verifier* cqv;
   grpc_op ops[6];
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_status_code status;
   grpc_slice details;
-  grpc_call *server_call;
-  grpc_server *server;
+  grpc_call* server_call;
+  grpc_server* server;
   grpc_metadata_array server_initial_metadata_recv;
   grpc_call_details call_details;
 };
@@ -54,13 +54,13 @@ static struct test_state g_state;
 
 static void prepare_test(int is_client) {
   int port = grpc_pick_unused_port_or_die();
-  char *server_hostport;
-  grpc_op *op;
+  char* server_hostport;
+  grpc_op* op;
   g_state.is_client = is_client;
   grpc_metadata_array_init(&g_state.initial_metadata_recv);
   grpc_metadata_array_init(&g_state.trailing_metadata_recv);
   g_state.deadline = grpc_timeout_seconds_to_deadline(5);
-  g_state.cq = grpc_completion_queue_create_for_next(NULL);
+  g_state.cq = grpc_completion_queue_create_for_next(nullptr);
   g_state.cqv = cq_verifier_create(g_state.cq);
   g_state.details = grpc_empty_slice();
   memset(g_state.ops, 0, sizeof(g_state.ops));
@@ -68,36 +68,39 @@ static void prepare_test(int is_client) {
   if (is_client) {
     /* create a call, channel to a non existant server */
     g_state.chan =
-        grpc_insecure_channel_create("nonexistant:54321", NULL, NULL);
+        grpc_insecure_channel_create("nonexistant:54321", nullptr, nullptr);
     grpc_slice host = grpc_slice_from_static_string("nonexistant");
     g_state.call = grpc_channel_create_call(
-        g_state.chan, NULL, GRPC_PROPAGATE_DEFAULTS, g_state.cq,
-        grpc_slice_from_static_string("/Foo"), &host, g_state.deadline, NULL);
+        g_state.chan, nullptr, GRPC_PROPAGATE_DEFAULTS, g_state.cq,
+        grpc_slice_from_static_string("/Foo"), &host, g_state.deadline,
+        nullptr);
   } else {
-    g_state.server = grpc_server_create(NULL, NULL);
-    grpc_server_register_completion_queue(g_state.server, g_state.cq, NULL);
+    g_state.server = grpc_server_create(nullptr, nullptr);
+    grpc_server_register_completion_queue(g_state.server, g_state.cq, nullptr);
     gpr_join_host_port(&server_hostport, "0.0.0.0", port);
     grpc_server_add_insecure_http2_port(g_state.server, server_hostport);
     grpc_server_start(g_state.server);
     gpr_free(server_hostport);
     gpr_join_host_port(&server_hostport, "localhost", port);
-    g_state.chan = grpc_insecure_channel_create(server_hostport, NULL, NULL);
+    g_state.chan =
+        grpc_insecure_channel_create(server_hostport, nullptr, nullptr);
     gpr_free(server_hostport);
     grpc_slice host = grpc_slice_from_static_string("bar");
     g_state.call = grpc_channel_create_call(
-        g_state.chan, NULL, GRPC_PROPAGATE_DEFAULTS, g_state.cq,
-        grpc_slice_from_static_string("/Foo"), &host, g_state.deadline, NULL);
+        g_state.chan, nullptr, GRPC_PROPAGATE_DEFAULTS, g_state.cq,
+        grpc_slice_from_static_string("/Foo"), &host, g_state.deadline,
+        nullptr);
     grpc_metadata_array_init(&g_state.server_initial_metadata_recv);
     grpc_call_details_init(&g_state.call_details);
     op = g_state.ops;
     op->op = GRPC_OP_SEND_INITIAL_METADATA;
     op->data.send_initial_metadata.count = 0;
     op->flags = GRPC_INITIAL_METADATA_WAIT_FOR_READY;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
     GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(g_state.call, g_state.ops,
                                                      (size_t)(op - g_state.ops),
-                                                     tag(1), NULL));
+                                                     tag(1), nullptr));
     GPR_ASSERT(GRPC_CALL_OK ==
                grpc_server_request_call(g_state.server, &g_state.server_call,
                                         &g_state.call_details,
@@ -110,7 +113,7 @@ static void prepare_test(int is_client) {
 }
 
 static void cleanup_test() {
-  grpc_completion_queue *shutdown_cq;
+  grpc_completion_queue* shutdown_cq;
   grpc_call_unref(g_state.call);
   cq_verifier_destroy(g_state.cqv);
   grpc_channel_destroy(g_state.chan);
@@ -119,12 +122,12 @@ static void cleanup_test() {
   grpc_metadata_array_destroy(&g_state.trailing_metadata_recv);
 
   if (!g_state.is_client) {
-    shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
+    shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
     grpc_call_unref(g_state.server_call);
     grpc_server_shutdown_and_notify(g_state.server, shutdown_cq, tag(1000));
     GPR_ASSERT(grpc_completion_queue_pluck(shutdown_cq, tag(1000),
                                            grpc_timeout_seconds_to_deadline(5),
-                                           NULL)
+                                           nullptr)
                    .type == GRPC_OP_COMPLETE);
     grpc_completion_queue_destroy(shutdown_cq);
     grpc_server_destroy(g_state.server);
@@ -133,7 +136,7 @@ static void cleanup_test() {
   }
   grpc_completion_queue_shutdown(g_state.cq);
   while (grpc_completion_queue_next(g_state.cq,
-                                    gpr_inf_future(GPR_CLOCK_REALTIME), NULL)
+                                    gpr_inf_future(GPR_CLOCK_REALTIME), nullptr)
              .type != GRPC_QUEUE_SHUTDOWN)
     ;
   grpc_completion_queue_destroy(g_state.cq);
@@ -144,14 +147,14 @@ static void test_non_null_reserved_on_start_batch() {
 
   prepare_test(1);
   GPR_ASSERT(GRPC_CALL_ERROR ==
-             grpc_call_start_batch(g_state.call, NULL, 0, NULL, tag(1)));
+             grpc_call_start_batch(g_state.call, nullptr, 0, nullptr, tag(1)));
   cleanup_test();
 }
 
 static void test_non_null_reserved_on_op() {
   gpr_log(GPR_INFO, "test_non_null_reserved_on_op");
 
-  grpc_op *op;
+  grpc_op* op;
   prepare_test(1);
 
   op = g_state.ops;
@@ -162,25 +165,26 @@ static void test_non_null_reserved_on_op() {
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR ==
              grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(1), NULL));
+                                   (size_t)(op - g_state.ops), tag(1),
+                                   nullptr));
   cleanup_test();
 }
 
 static void test_send_initial_metadata_more_than_once() {
   gpr_log(GPR_INFO, "test_send_initial_metadata_more_than_once");
 
-  grpc_op *op;
+  grpc_op* op;
   prepare_test(1);
 
   op = g_state.ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(g_state.call, g_state.ops,
                                                    (size_t)(op - g_state.ops),
-                                                   tag(1), NULL));
+                                                   tag(1), nullptr));
   CQ_EXPECT_COMPLETION(g_state.cqv, tag(1), 0);
   cq_verify(g_state.cqv);
 
@@ -188,83 +192,87 @@ static void test_send_initial_metadata_more_than_once() {
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
              grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(1), NULL));
+                                   (size_t)(op - g_state.ops), tag(1),
+                                   nullptr));
   cleanup_test();
 }
 
 static void test_too_many_metadata() {
   gpr_log(GPR_INFO, "test_too_many_metadata");
 
-  grpc_op *op;
+  grpc_op* op;
   prepare_test(1);
 
   op = g_state.ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = (size_t)INT_MAX + 1;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_INVALID_METADATA ==
              grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(1), NULL));
+                                   (size_t)(op - g_state.ops), tag(1),
+                                   nullptr));
   cleanup_test();
 }
 
 static void test_send_null_message() {
   gpr_log(GPR_INFO, "test_send_null_message");
 
-  grpc_op *op;
+  grpc_op* op;
   prepare_test(1);
 
   op = g_state.ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
-  op->data.send_message.send_message = NULL;
+  op->data.send_message.send_message = nullptr;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_INVALID_MESSAGE ==
              grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(1), NULL));
+                                   (size_t)(op - g_state.ops), tag(1),
+                                   nullptr));
   cleanup_test();
 }
 
 static void test_send_messages_at_the_same_time() {
   gpr_log(GPR_INFO, "test_send_messages_at_the_same_time");
 
-  grpc_op *op;
+  grpc_op* op;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
-  grpc_byte_buffer *request_payload =
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
   prepare_test(1);
   op = g_state.ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
-  op->data.send_message.send_message = tag(2);
+  op->data.send_message.send_message = static_cast<grpc_byte_buffer*>(tag(2));
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
              grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(1), NULL));
+                                   (size_t)(op - g_state.ops), tag(1),
+                                   nullptr));
   grpc_byte_buffer_destroy(request_payload);
   cleanup_test();
 }
@@ -272,7 +280,7 @@ static void test_send_messages_at_the_same_time() {
 static void test_send_server_status_from_client() {
   gpr_log(GPR_INFO, "test_send_server_status_from_client");
 
-  grpc_op *op;
+  grpc_op* op;
   prepare_test(1);
 
   op = g_state.ops;
@@ -282,29 +290,30 @@ static void test_send_server_status_from_client() {
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_NOT_ON_CLIENT ==
              grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(1), NULL));
+                                   (size_t)(op - g_state.ops), tag(1),
+                                   nullptr));
   cleanup_test();
 }
 
 static void test_receive_initial_metadata_twice_at_client() {
   gpr_log(GPR_INFO, "test_receive_initial_metadata_twice_at_client");
 
-  grpc_op *op;
+  grpc_op* op;
   prepare_test(1);
   op = g_state.ops;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata =
       &g_state.initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(g_state.call, g_state.ops,
                                                    (size_t)(op - g_state.ops),
-                                                   tag(1), NULL));
+                                                   tag(1), nullptr));
   CQ_EXPECT_COMPLETION(g_state.cqv, tag(1), 0);
   cq_verify(g_state.cqv);
   op = g_state.ops;
@@ -312,77 +321,81 @@ static void test_receive_initial_metadata_twice_at_client() {
   op->data.recv_initial_metadata.recv_initial_metadata =
       &g_state.initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
              grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(1), NULL));
+                                   (size_t)(op - g_state.ops), tag(1),
+                                   nullptr));
   cleanup_test();
 }
 
 static void test_receive_message_with_invalid_flags() {
   gpr_log(GPR_INFO, "test_receive_message_with_invalid_flags");
 
-  grpc_op *op;
-  grpc_byte_buffer *payload = NULL;
+  grpc_op* op;
+  grpc_byte_buffer* payload = nullptr;
   prepare_test(1);
   op = g_state.ops;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &payload;
   op->flags = 1;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_INVALID_FLAGS ==
              grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(1), NULL));
+                                   (size_t)(op - g_state.ops), tag(1),
+                                   nullptr));
   cleanup_test();
 }
 
 static void test_receive_two_messages_at_the_same_time() {
   gpr_log(GPR_INFO, "test_receive_two_messages_at_the_same_time");
 
-  grpc_op *op;
-  grpc_byte_buffer *payload = NULL;
+  grpc_op* op;
+  grpc_byte_buffer* payload = nullptr;
   prepare_test(1);
   op = g_state.ops;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
              grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(1), NULL));
+                                   (size_t)(op - g_state.ops), tag(1),
+                                   nullptr));
   cleanup_test();
 }
 
 static void test_recv_close_on_server_from_client() {
   gpr_log(GPR_INFO, "test_recv_close_on_server_from_client");
 
-  grpc_op *op;
+  grpc_op* op;
   prepare_test(1);
 
   op = g_state.ops;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
-  op->data.recv_close_on_server.cancelled = NULL;
+  op->data.recv_close_on_server.cancelled = nullptr;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_NOT_ON_CLIENT ==
              grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(1), NULL));
+                                   (size_t)(op - g_state.ops), tag(1),
+                                   nullptr));
   cleanup_test();
 }
 
 static void test_recv_status_on_client_twice() {
   gpr_log(GPR_INFO, "test_recv_status_on_client_twice");
 
-  grpc_op *op;
+  grpc_op* op;
   prepare_test(1);
 
   op = g_state.ops;
@@ -392,49 +405,51 @@ static void test_recv_status_on_client_twice() {
   op->data.recv_status_on_client.status = &g_state.status;
   op->data.recv_status_on_client.status_details = &g_state.details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(g_state.call, g_state.ops,
                                                    (size_t)(op - g_state.ops),
-                                                   tag(1), NULL));
+                                                   tag(1), nullptr));
   CQ_EXPECT_COMPLETION(g_state.cqv, tag(1), 1);
   cq_verify(g_state.cqv);
 
   op = g_state.ops;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
-  op->data.recv_status_on_client.trailing_metadata = NULL;
-  op->data.recv_status_on_client.status = NULL;
-  op->data.recv_status_on_client.status_details = NULL;
+  op->data.recv_status_on_client.trailing_metadata = nullptr;
+  op->data.recv_status_on_client.status = nullptr;
+  op->data.recv_status_on_client.status_details = nullptr;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
              grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(1), NULL));
+                                   (size_t)(op - g_state.ops), tag(1),
+                                   nullptr));
   cleanup_test();
 }
 
 static void test_send_close_from_client_on_server() {
   gpr_log(GPR_INFO, "test_send_close_from_client_on_server");
 
-  grpc_op *op;
+  grpc_op* op;
   prepare_test(0);
 
   op = g_state.ops;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_NOT_ON_SERVER ==
              grpc_call_start_batch(g_state.server_call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(2), NULL));
+                                   (size_t)(op - g_state.ops), tag(2),
+                                   nullptr));
   cleanup_test();
 }
 
 static void test_recv_status_on_client_from_server() {
   gpr_log(GPR_INFO, "test_recv_status_on_client_from_server");
 
-  grpc_op *op;
+  grpc_op* op;
   prepare_test(0);
 
   op = g_state.ops;
@@ -444,18 +459,19 @@ static void test_recv_status_on_client_from_server() {
   op->data.recv_status_on_client.status = &g_state.status;
   op->data.recv_status_on_client.status_details = &g_state.details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_NOT_ON_SERVER ==
              grpc_call_start_batch(g_state.server_call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(2), NULL));
+                                   (size_t)(op - g_state.ops), tag(2),
+                                   nullptr));
   cleanup_test();
 }
 
 static void test_send_status_from_server_with_invalid_flags() {
   gpr_log(GPR_INFO, "test_send_status_from_server_with_invalid_flags");
 
-  grpc_op *op;
+  grpc_op* op;
   prepare_test(0);
 
   op = g_state.ops;
@@ -465,18 +481,19 @@ static void test_send_status_from_server_with_invalid_flags() {
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 1;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_INVALID_FLAGS ==
              grpc_call_start_batch(g_state.server_call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(2), NULL));
+                                   (size_t)(op - g_state.ops), tag(2),
+                                   nullptr));
   cleanup_test();
 }
 
 static void test_too_many_trailing_metadata() {
   gpr_log(GPR_INFO, "test_too_many_trailing_metadata");
 
-  grpc_op *op;
+  grpc_op* op;
   prepare_test(0);
 
   op = g_state.ops;
@@ -487,18 +504,19 @@ static void test_too_many_trailing_metadata() {
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_INVALID_METADATA ==
              grpc_call_start_batch(g_state.server_call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(2), NULL));
+                                   (size_t)(op - g_state.ops), tag(2),
+                                   nullptr));
   cleanup_test();
 }
 
 static void test_send_server_status_twice() {
   gpr_log(GPR_INFO, "test_send_server_status_twice");
 
-  grpc_op *op;
+  grpc_op* op;
   prepare_test(0);
 
   op = g_state.ops;
@@ -508,59 +526,62 @@ static void test_send_server_status_twice() {
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
   op->data.send_status_from_server.status = GRPC_STATUS_UNIMPLEMENTED;
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
              grpc_call_start_batch(g_state.server_call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(2), NULL));
+                                   (size_t)(op - g_state.ops), tag(2),
+                                   nullptr));
   cleanup_test();
 }
 
 static void test_recv_close_on_server_with_invalid_flags() {
   gpr_log(GPR_INFO, "test_recv_close_on_server_with_invalid_flags");
 
-  grpc_op *op;
+  grpc_op* op;
   prepare_test(0);
 
   op = g_state.ops;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
-  op->data.recv_close_on_server.cancelled = NULL;
+  op->data.recv_close_on_server.cancelled = nullptr;
   op->flags = 1;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_INVALID_FLAGS ==
              grpc_call_start_batch(g_state.server_call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(2), NULL));
+                                   (size_t)(op - g_state.ops), tag(2),
+                                   nullptr));
   cleanup_test();
 }
 
 static void test_recv_close_on_server_twice() {
   gpr_log(GPR_INFO, "test_recv_close_on_server_twice");
 
-  grpc_op *op;
+  grpc_op* op;
   prepare_test(0);
 
   op = g_state.ops;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
-  op->data.recv_close_on_server.cancelled = NULL;
+  op->data.recv_close_on_server.cancelled = nullptr;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
-  op->data.recv_close_on_server.cancelled = NULL;
+  op->data.recv_close_on_server.cancelled = nullptr;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
              grpc_call_start_batch(g_state.server_call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(2), NULL));
+                                   (size_t)(op - g_state.ops), tag(2),
+                                   nullptr));
   cleanup_test();
 }
 
@@ -571,22 +592,23 @@ static void test_invalid_initial_metadata_reserved_key() {
   metadata.key = grpc_slice_from_static_string(":start_with_colon");
   metadata.value = grpc_slice_from_static_string("value");
 
-  grpc_op *op;
+  grpc_op* op;
   prepare_test(1);
   op = g_state.ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 1;
   op->data.send_initial_metadata.metadata = &metadata;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_INVALID_METADATA ==
              grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(1), NULL));
+                                   (size_t)(op - g_state.ops), tag(1),
+                                   nullptr));
   cleanup_test();
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   test_invalid_initial_metadata_reserved_key();
diff --git a/test/core/end2end/multiple_server_queues_test.c b/test/core/end2end/multiple_server_queues_test.cc
index f231c62dd0..dfa3b48b52 100644
--- a/test/core/end2end/multiple_server_queues_test.c
+++ b/test/core/end2end/multiple_server_queues_test.cc
@@ -19,13 +19,13 @@
 #include <grpc/grpc.h>
 #include "test/core/util/test_config.h"
 
-int main(int argc, char **argv) {
-  grpc_completion_queue *cq1;
-  grpc_completion_queue *cq2;
-  grpc_completion_queue *cq3;
+int main(int argc, char** argv) {
+  grpc_completion_queue* cq1;
+  grpc_completion_queue* cq2;
+  grpc_completion_queue* cq3;
   grpc_completion_queue_attributes attr;
 
-  grpc_server *server;
+  grpc_server* server;
 
   grpc_test_init(argc, argv);
   grpc_init();
@@ -34,33 +34,33 @@ int main(int argc, char **argv) {
   attr.cq_completion_type = GRPC_CQ_NEXT;
   attr.cq_polling_type = GRPC_CQ_DEFAULT_POLLING;
   cq1 = grpc_completion_queue_create(
-      grpc_completion_queue_factory_lookup(&attr), &attr, NULL);
+      grpc_completion_queue_factory_lookup(&attr), &attr, nullptr);
 
   attr.cq_polling_type = GRPC_CQ_NON_LISTENING;
   cq2 = grpc_completion_queue_create(
-      grpc_completion_queue_factory_lookup(&attr), &attr, NULL);
+      grpc_completion_queue_factory_lookup(&attr), &attr, nullptr);
 
   attr.cq_polling_type = GRPC_CQ_NON_POLLING;
   cq3 = grpc_completion_queue_create(
-      grpc_completion_queue_factory_lookup(&attr), &attr, NULL);
+      grpc_completion_queue_factory_lookup(&attr), &attr, nullptr);
 
-  server = grpc_server_create(NULL, NULL);
-  grpc_server_register_completion_queue(server, cq1, NULL);
+  server = grpc_server_create(nullptr, nullptr);
+  grpc_server_register_completion_queue(server, cq1, nullptr);
   grpc_server_add_insecure_http2_port(server, "[::]:0");
-  grpc_server_register_completion_queue(server, cq2, NULL);
-  grpc_server_register_completion_queue(server, cq3, NULL);
+  grpc_server_register_completion_queue(server, cq2, nullptr);
+  grpc_server_register_completion_queue(server, cq3, nullptr);
 
   grpc_server_start(server);
-  grpc_server_shutdown_and_notify(server, cq2, NULL);
+  grpc_server_shutdown_and_notify(server, cq2, nullptr);
   grpc_completion_queue_next(cq2, gpr_inf_future(GPR_CLOCK_REALTIME),
-                             NULL); /* cue queue hang */
+                             nullptr); /* cue queue hang */
   grpc_completion_queue_shutdown(cq1);
   grpc_completion_queue_shutdown(cq2);
   grpc_completion_queue_shutdown(cq3);
 
-  grpc_completion_queue_next(cq1, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
-  grpc_completion_queue_next(cq2, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
-  grpc_completion_queue_next(cq3, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+  grpc_completion_queue_next(cq1, gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
+  grpc_completion_queue_next(cq2, gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
+  grpc_completion_queue_next(cq3, gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
 
   grpc_server_destroy(server);
   grpc_completion_queue_destroy(cq1);
diff --git a/test/core/end2end/no_server_test.c b/test/core/end2end/no_server_test.cc
index 962499bb4f..6113885171 100644
--- a/test/core/end2end/no_server_test.c
+++ b/test/core/end2end/no_server_test.cc
@@ -25,16 +25,16 @@
 #include "test/core/end2end/cq_verifier.h"
 #include "test/core/util/test_config.h"
 
-static void *tag(intptr_t i) { return (void *)i; }
+static void* tag(intptr_t i) { return (void*)i; }
 
-int main(int argc, char **argv) {
-  grpc_channel *chan;
-  grpc_call *call;
+int main(int argc, char** argv) {
+  grpc_channel* chan;
+  grpc_call* call;
   gpr_timespec deadline = grpc_timeout_seconds_to_deadline(2);
-  grpc_completion_queue *cq;
-  cq_verifier *cqv;
+  grpc_completion_queue* cq;
+  cq_verifier* cqv;
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array trailing_metadata_recv;
   grpc_status_code status;
   grpc_slice details;
@@ -44,32 +44,33 @@ int main(int argc, char **argv) {
 
   grpc_metadata_array_init(&trailing_metadata_recv);
 
-  cq = grpc_completion_queue_create_for_next(NULL);
+  cq = grpc_completion_queue_create_for_next(nullptr);
   cqv = cq_verifier_create(cq);
 
   /* create a call, channel to a non existant server */
-  chan = grpc_insecure_channel_create("nonexistant:54321", NULL, NULL);
+  chan = grpc_insecure_channel_create("nonexistant:54321", nullptr, nullptr);
   grpc_slice host = grpc_slice_from_static_string("nonexistant");
-  call = grpc_channel_create_call(chan, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
+  call = grpc_channel_create_call(chan, nullptr, GRPC_PROPAGATE_DEFAULTS, cq,
                                   grpc_slice_from_static_string("/Foo"), &host,
-                                  deadline, NULL);
+                                  deadline, nullptr);
 
   memset(ops, 0, sizeof(ops));
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(
-                                 call, ops, (size_t)(op - ops), tag(1), NULL));
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(call, ops,
+                                                   (size_t)(op - ops), tag(1),
+                                                   nullptr));
   /* verify that all tags get completed */
   CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
   cq_verify(cqv);
@@ -77,9 +78,9 @@ int main(int argc, char **argv) {
   GPR_ASSERT(status == GRPC_STATUS_DEADLINE_EXCEEDED);
 
   grpc_completion_queue_shutdown(cq);
-  while (
-      grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL)
-          .type != GRPC_QUEUE_SHUTDOWN)
+  while (grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME),
+                                    nullptr)
+             .type != GRPC_QUEUE_SHUTDOWN)
     ;
   grpc_completion_queue_destroy(cq);
   grpc_call_unref(call);
diff --git a/test/core/end2end/tests/authority_not_supported.c b/test/core/end2end/tests/authority_not_supported.cc
index b54d6d0d6f..9c8545058c 100644
--- a/test/core/end2end/tests/authority_not_supported.c
+++ b/test/core/end2end/tests/authority_not_supported.cc
@@ -28,12 +28,12 @@
 #include <grpc/support/useful.h>
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -50,31 +50,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -86,36 +86,36 @@ static void end_test(grpc_end2end_test_fixture *f) {
 
 /* Request/response with metadata and payload.*/
 static void test_with_authority_header(grpc_end2end_test_config config) {
-  grpc_call *c;
+  grpc_call* c;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
-  grpc_byte_buffer *request_payload =
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
   grpc_metadata meta_c[2] = {{grpc_slice_from_static_string("key1"),
                               grpc_slice_from_static_string("val1"),
                               0,
-                              {{NULL, NULL, NULL, NULL}}},
+                              {{nullptr, nullptr, nullptr, nullptr}}},
                              {grpc_slice_from_static_string("key2"),
                               grpc_slice_from_static_string("val2"),
                               0,
-                              {{NULL, NULL, NULL, NULL}}}};
+                              {{nullptr, nullptr, nullptr, nullptr}}}};
   grpc_end2end_test_fixture f =
-      begin_test(config, "test_with_authority_header", NULL, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+      begin_test(config, "test_with_authority_header", nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
-  grpc_byte_buffer *response_payload_recv = NULL;
+  grpc_byte_buffer* response_payload_recv = nullptr;
   grpc_status_code status;
   grpc_call_error error;
   grpc_slice details;
 
   grpc_slice host = grpc_slice_from_static_string("foo.test.google.fr");
   gpr_timespec deadline = five_seconds_from_now();
-  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+  c = grpc_channel_create_call(f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
                                grpc_slice_from_static_string("/foo"), &host,
-                               deadline, NULL);
+                               deadline, nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -127,35 +127,35 @@ static void test_with_authority_header(grpc_end2end_test_config config) {
   op->data.send_initial_metadata.count = 2;
   op->data.send_initial_metadata.metadata = meta_c;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &response_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
diff --git a/test/core/end2end/tests/bad_hostname.c b/test/core/end2end/tests/bad_hostname.cc
index 32093f2ecf..97ef62b5e3 100644
--- a/test/core/end2end/tests/bad_hostname.c
+++ b/test/core/end2end/tests/bad_hostname.cc
@@ -30,12 +30,12 @@
 #include "src/core/lib/support/string.h"
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -52,31 +52,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -87,10 +87,10 @@ static void end_test(grpc_end2end_test_fixture *f) {
 }
 
 static void simple_request_body(grpc_end2end_test_fixture f) {
-  grpc_call *c;
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  grpc_call* c;
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -101,9 +101,9 @@ static void simple_request_body(grpc_end2end_test_fixture f) {
 
   grpc_slice host = grpc_slice_from_static_string("slartibartfast.local");
   gpr_timespec deadline = five_seconds_from_now();
-  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+  c = grpc_channel_create_call(f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
                                grpc_slice_from_static_string("/foo"), &host,
-                               deadline, NULL);
+                               deadline, nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -116,25 +116,25 @@ static void simple_request_body(grpc_end2end_test_fixture f) {
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
@@ -156,7 +156,7 @@ static void simple_request_body(grpc_end2end_test_fixture f) {
 static void test_invoke_simple_request(grpc_end2end_test_config config) {
   grpc_end2end_test_fixture f;
 
-  f = begin_test(config, "test_invoke_simple_request", NULL, NULL);
+  f = begin_test(config, "test_invoke_simple_request", nullptr, nullptr);
   simple_request_body(f);
   end_test(&f);
   config.tear_down_data(&f);
diff --git a/test/core/end2end/tests/bad_ping.c b/test/core/end2end/tests/bad_ping.cc
index 34cc8e78cd..30a1b8de77 100644
--- a/test/core/end2end/tests/bad_ping.c
+++ b/test/core/end2end/tests/bad_ping.cc
@@ -31,29 +31,29 @@
 
 #define MAX_PING_STRIKES 1
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
     ev = grpc_completion_queue_next(cq, grpc_timeout_seconds_to_deadline(5),
-                                    NULL);
+                                    nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -64,41 +64,41 @@ static void end_test(grpc_end2end_test_fixture *f) {
 }
 
 static void test_bad_ping(grpc_end2end_test_config config) {
-  grpc_end2end_test_fixture f = config.create_fixture(NULL, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
-  grpc_arg client_a[] = {
-      {.type = GRPC_ARG_INTEGER,
-       .key = GRPC_ARG_HTTP2_MIN_SENT_PING_INTERVAL_WITHOUT_DATA_MS,
-       .value.integer = 10},
-      {.type = GRPC_ARG_INTEGER,
-       .key = GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA,
-       .value.integer = 0},
-      {.type = GRPC_ARG_INTEGER,
-       .key = GRPC_ARG_HTTP2_BDP_PROBE,
-       .value.integer = 0}};
-  grpc_arg server_a[] = {
-      {.type = GRPC_ARG_INTEGER,
-       .key = GRPC_ARG_HTTP2_MIN_RECV_PING_INTERVAL_WITHOUT_DATA_MS,
-       .value.integer = 300000 /* 5 minutes */},
-      {.type = GRPC_ARG_INTEGER,
-       .key = GRPC_ARG_HTTP2_MAX_PING_STRIKES,
-       .value.integer = MAX_PING_STRIKES},
-      {.type = GRPC_ARG_INTEGER,
-       .key = GRPC_ARG_HTTP2_BDP_PROBE,
-       .value.integer = 0}};
-  grpc_channel_args client_args = {.num_args = GPR_ARRAY_SIZE(client_a),
-                                   .args = client_a};
-  grpc_channel_args server_args = {.num_args = GPR_ARRAY_SIZE(server_a),
-                                   .args = server_a};
+  grpc_end2end_test_fixture f = config.create_fixture(nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
+  grpc_arg client_a[3];
+  client_a[0].type = GRPC_ARG_INTEGER;
+  client_a[0].key =
+      const_cast<char*>(GRPC_ARG_HTTP2_MIN_SENT_PING_INTERVAL_WITHOUT_DATA_MS);
+  client_a[0].value.integer = 10;
+  client_a[1].type = GRPC_ARG_INTEGER;
+  client_a[1].key = const_cast<char*>(GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA);
+  client_a[1].value.integer = 0;
+  client_a[2].type = GRPC_ARG_INTEGER;
+  client_a[2].key = const_cast<char*>(GRPC_ARG_HTTP2_BDP_PROBE);
+  client_a[2].value.integer = 0;
+  grpc_arg server_a[3];
+  server_a[0].type = GRPC_ARG_INTEGER;
+  server_a[0].key =
+      const_cast<char*>(GRPC_ARG_HTTP2_MIN_RECV_PING_INTERVAL_WITHOUT_DATA_MS);
+  server_a[0].value.integer = 300000 /* 5 minutes */;
+  server_a[1].type = GRPC_ARG_INTEGER;
+  server_a[1].key = const_cast<char*>(GRPC_ARG_HTTP2_MAX_PING_STRIKES);
+  server_a[1].value.integer = MAX_PING_STRIKES;
+  server_a[2].type = GRPC_ARG_INTEGER;
+  server_a[2].key = const_cast<char*>(GRPC_ARG_HTTP2_BDP_PROBE);
+  server_a[2].value.integer = 0;
+  grpc_channel_args client_args = {GPR_ARRAY_SIZE(client_a), client_a};
+  grpc_channel_args server_args = {GPR_ARRAY_SIZE(server_a), server_a};
 
   config.init_client(&f, &client_args);
   config.init_server(&f, &server_args);
 
-  grpc_call *c;
-  grpc_call *s;
+  grpc_call* c;
+  grpc_call* s;
   gpr_timespec deadline = grpc_timeout_seconds_to_deadline(10);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -109,10 +109,10 @@ static void test_bad_ping(grpc_end2end_test_config config) {
   int was_cancelled = 2;
 
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -124,27 +124,27 @@ static void test_bad_ping(grpc_end2end_test_config config) {
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
-  op->data.send_initial_metadata.metadata = NULL;
+  op->data.send_initial_metadata.metadata = nullptr;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -160,7 +160,7 @@ static void test_bad_ping(grpc_end2end_test_config config) {
   // needed here.
   int i;
   for (i = 1; i <= MAX_PING_STRIKES + 1; i++) {
-    grpc_channel_ping(f.client, f.cq, tag(200 + i), NULL);
+    grpc_channel_ping(f.client, f.cq, tag(200 + i), nullptr);
     CQ_EXPECT_COMPLETION(cqv, tag(200 + i), 1);
     if (i == MAX_PING_STRIKES + 1) {
       CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
@@ -173,7 +173,7 @@ static void test_bad_ping(grpc_end2end_test_config config) {
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -181,14 +181,14 @@ static void test_bad_ping(grpc_end2end_test_config config) {
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
diff --git a/test/core/end2end/tests/binary_metadata.c b/test/core/end2end/tests/binary_metadata.cc
index e949daee1d..381671e331 100644
--- a/test/core/end2end/tests/binary_metadata.c
+++ b/test/core/end2end/tests/binary_metadata.cc
@@ -28,12 +28,12 @@
 #include <grpc/support/useful.h>
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -50,31 +50,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -87,48 +87,49 @@ static void end_test(grpc_end2end_test_fixture *f) {
 /* Request/response with metadata and payload.*/
 static void test_request_response_with_metadata_and_payload(
     grpc_end2end_test_config config) {
-  grpc_call *c;
-  grpc_call *s;
+  grpc_call* c;
+  grpc_call* s;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
   grpc_slice response_payload_slice =
       grpc_slice_from_copied_string("hello you");
-  grpc_byte_buffer *request_payload =
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
-  grpc_byte_buffer *response_payload =
+  grpc_byte_buffer* response_payload =
       grpc_raw_byte_buffer_create(&response_payload_slice, 1);
   grpc_metadata meta_c[2] = {
       {grpc_slice_from_static_string("key1-bin"),
        grpc_slice_from_static_string(
            "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc"),
        0,
-       {{NULL, NULL, NULL, NULL}}},
+       {{nullptr, nullptr, nullptr, nullptr}}},
       {grpc_slice_from_static_string("key2-bin"),
        grpc_slice_from_static_string(
            "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d"),
        0,
-       {{NULL, NULL, NULL, NULL}}}};
+       {{nullptr, nullptr, nullptr, nullptr}}}};
   grpc_metadata meta_s[2] = {
       {grpc_slice_from_static_string("key3-bin"),
        grpc_slice_from_static_string(
            "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee"),
        0,
-       {{NULL, NULL, NULL, NULL}}},
+       {{nullptr, nullptr, nullptr, nullptr}}},
       {grpc_slice_from_static_string("key4-bin"),
        grpc_slice_from_static_string(
            "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff"),
        0,
-       {{NULL, NULL, NULL, NULL}}}};
-  grpc_end2end_test_fixture f = begin_test(
-      config, "test_request_response_with_metadata_and_payload", NULL, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+       {{nullptr, nullptr, nullptr, nullptr}}}};
+  grpc_end2end_test_fixture f =
+      begin_test(config, "test_request_response_with_metadata_and_payload",
+                 nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *request_payload_recv = NULL;
-  grpc_byte_buffer *response_payload_recv = NULL;
+  grpc_byte_buffer* request_payload_recv = nullptr;
+  grpc_byte_buffer* response_payload_recv = nullptr;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
@@ -137,10 +138,10 @@ static void test_request_response_with_metadata_and_payload(
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -154,35 +155,35 @@ static void test_request_response_with_metadata_and_payload(
   op->data.send_initial_metadata.count = 2;
   op->data.send_initial_metadata.metadata = meta_c;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &response_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -198,14 +199,14 @@ static void test_request_response_with_metadata_and_payload(
   op->data.send_initial_metadata.count = 2;
   op->data.send_initial_metadata.metadata = meta_s;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &request_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -216,12 +217,12 @@ static void test_request_response_with_metadata_and_payload(
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = response_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -244,9 +245,9 @@ static void test_request_response_with_metadata_and_payload(
       "\xfd\xfe\xff");
   op->data.send_status_from_server.status_details = &status_string;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(103), 1);
diff --git a/test/core/end2end/tests/call_creds.c b/test/core/end2end/tests/call_creds.cc
index 600005c9a9..e1c868232c 100644
--- a/test/core/end2end/tests/call_creds.c
+++ b/test/core/end2end/tests/call_creds.cc
@@ -38,24 +38,26 @@ static const char overridden_iam_selector[] = "overridden_selector";
 
 typedef enum { NONE, OVERRIDE, DESTROY } override_mode;
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
+                                            const char* test_name,
                                             int fail_server_auth_check) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
-  f = config.create_fixture(NULL, NULL);
-  config.init_client(&f, NULL);
+  f = config.create_fixture(nullptr, nullptr);
+  config.init_client(&f, nullptr);
   if (fail_server_auth_check) {
     grpc_arg fail_auth_arg = {
-        GRPC_ARG_STRING, FAIL_AUTH_CHECK_SERVER_ARG_NAME, {NULL}};
+        GRPC_ARG_STRING,
+        const_cast<char*>(FAIL_AUTH_CHECK_SERVER_ARG_NAME),
+        {nullptr}};
     grpc_channel_args args;
     args.num_args = 1;
     args.args = &fail_auth_arg;
     config.init_server(&f, &args);
   } else {
-    config.init_server(&f, NULL);
+    config.init_server(&f, nullptr);
   }
   return f;
 }
@@ -68,31 +70,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -102,79 +104,79 @@ static void end_test(grpc_end2end_test_fixture *f) {
   grpc_completion_queue_destroy(f->shutdown_cq);
 }
 
-static void print_auth_context(int is_client, const grpc_auth_context *ctx) {
-  const grpc_auth_property *p;
+static void print_auth_context(int is_client, const grpc_auth_context* ctx) {
+  const grpc_auth_property* p;
   grpc_auth_property_iterator it;
   gpr_log(GPR_INFO, "%s peer:", is_client ? "client" : "server");
   gpr_log(GPR_INFO, "\tauthenticated: %s",
           grpc_auth_context_peer_is_authenticated(ctx) ? "YES" : "NO");
   it = grpc_auth_context_peer_identity(ctx);
-  while ((p = grpc_auth_property_iterator_next(&it)) != NULL) {
+  while ((p = grpc_auth_property_iterator_next(&it)) != nullptr) {
     gpr_log(GPR_INFO, "\t\t%s: %s", p->name, p->value);
   }
   gpr_log(GPR_INFO, "\tall properties:");
   it = grpc_auth_context_property_iterator(ctx);
-  while ((p = grpc_auth_property_iterator_next(&it)) != NULL) {
+  while ((p = grpc_auth_property_iterator_next(&it)) != nullptr) {
     gpr_log(GPR_INFO, "\t\t%s: %s", p->name, p->value);
   }
 }
 
 static void request_response_with_payload_and_call_creds(
-    const char *test_name, grpc_end2end_test_config config,
+    const char* test_name, grpc_end2end_test_config config,
     override_mode mode) {
-  grpc_call *c;
-  grpc_call *s;
+  grpc_call* c;
+  grpc_call* s;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
   grpc_slice response_payload_slice =
       grpc_slice_from_copied_string("hello you");
-  grpc_byte_buffer *request_payload =
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
-  grpc_byte_buffer *response_payload =
+  grpc_byte_buffer* response_payload =
       grpc_raw_byte_buffer_create(&response_payload_slice, 1);
   grpc_end2end_test_fixture f;
-  cq_verifier *cqv;
+  cq_verifier* cqv;
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *request_payload_recv = NULL;
-  grpc_byte_buffer *response_payload_recv = NULL;
+  grpc_byte_buffer* request_payload_recv = nullptr;
+  grpc_byte_buffer* response_payload_recv = nullptr;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
   grpc_slice details;
   int was_cancelled = 2;
-  grpc_call_credentials *creds = NULL;
-  grpc_auth_context *s_auth_context = NULL;
-  grpc_auth_context *c_auth_context = NULL;
+  grpc_call_credentials* creds = nullptr;
+  grpc_auth_context* s_auth_context = nullptr;
+  grpc_auth_context* c_auth_context = nullptr;
 
   f = begin_test(config, test_name, 0);
   cqv = cq_verifier_create(f.cq);
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
-  creds = grpc_google_iam_credentials_create(iam_token, iam_selector, NULL);
-  GPR_ASSERT(creds != NULL);
+  creds = grpc_google_iam_credentials_create(iam_token, iam_selector, nullptr);
+  GPR_ASSERT(creds != nullptr);
   GPR_ASSERT(grpc_call_set_credentials(c, creds) == GRPC_CALL_OK);
   switch (mode) {
     case NONE:
       break;
     case OVERRIDE:
       grpc_call_credentials_release(creds);
-      creds = grpc_google_iam_credentials_create(overridden_iam_token,
-                                                 overridden_iam_selector, NULL);
-      GPR_ASSERT(creds != NULL);
+      creds = grpc_google_iam_credentials_create(
+          overridden_iam_token, overridden_iam_selector, nullptr);
+      GPR_ASSERT(creds != nullptr);
       GPR_ASSERT(grpc_call_set_credentials(c, creds) == GRPC_CALL_OK);
       break;
     case DESTROY:
-      GPR_ASSERT(grpc_call_set_credentials(c, NULL) == GRPC_CALL_OK);
+      GPR_ASSERT(grpc_call_set_credentials(c, nullptr) == GRPC_CALL_OK);
       break;
   }
   grpc_call_credentials_release(creds);
@@ -189,35 +191,35 @@ static void request_response_with_payload_and_call_creds(
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &response_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -227,31 +229,31 @@ static void request_response_with_payload_and_call_creds(
   CQ_EXPECT_COMPLETION(cqv, tag(101), 1);
   cq_verify(cqv);
   s_auth_context = grpc_call_auth_context(s);
-  GPR_ASSERT(s_auth_context != NULL);
+  GPR_ASSERT(s_auth_context != nullptr);
   print_auth_context(0, s_auth_context);
   grpc_auth_context_release(s_auth_context);
 
   c_auth_context = grpc_call_auth_context(c);
-  GPR_ASSERT(c_auth_context != NULL);
+  GPR_ASSERT(c_auth_context != nullptr);
   print_auth_context(1, c_auth_context);
   grpc_auth_context_release(c_auth_context);
 
   /* Cannot set creds on the server call object. */
-  GPR_ASSERT(grpc_call_set_credentials(s, NULL) != GRPC_CALL_OK);
+  GPR_ASSERT(grpc_call_set_credentials(s, nullptr) != GRPC_CALL_OK);
 
   memset(ops, 0, sizeof(ops));
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &request_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -262,12 +264,12 @@ static void request_response_with_payload_and_call_creds(
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = response_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -275,9 +277,9 @@ static void request_response_with_payload_and_call_creds(
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(103), 1);
@@ -369,11 +371,11 @@ static void test_request_response_with_payload_and_deleted_call_creds(
 static void test_request_with_server_rejecting_client_creds(
     grpc_end2end_test_config config) {
   grpc_op ops[6];
-  grpc_op *op;
-  grpc_call *c;
+  grpc_op* op;
+  grpc_call* c;
   grpc_end2end_test_fixture f;
   gpr_timespec deadline = five_seconds_from_now();
-  cq_verifier *cqv;
+  cq_verifier* cqv;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -381,25 +383,25 @@ static void test_request_with_server_rejecting_client_creds(
   grpc_status_code status;
   grpc_call_error error;
   grpc_slice details;
-  grpc_byte_buffer *response_payload_recv = NULL;
+  grpc_byte_buffer* response_payload_recv = nullptr;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
-  grpc_byte_buffer *request_payload =
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
-  grpc_call_credentials *creds;
+  grpc_call_credentials* creds;
 
   f = begin_test(config, "test_request_with_server_rejecting_client_creds", 1);
   cqv = cq_verifier_create(f.cq);
 
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
-  creds = grpc_google_iam_credentials_create(iam_token, iam_selector, NULL);
-  GPR_ASSERT(creds != NULL);
+  creds = grpc_google_iam_credentials_create(iam_token, iam_selector, nullptr);
+  GPR_ASSERT(creds != nullptr);
   GPR_ASSERT(grpc_call_set_credentials(c, creds) == GRPC_CALL_OK);
   grpc_call_credentials_release(creds);
 
@@ -415,33 +417,33 @@ static void test_request_with_server_rejecting_client_creds(
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &response_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(error == GRPC_CALL_OK);
 
   CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
diff --git a/test/core/end2end/tests/cancel_after_accept.c b/test/core/end2end/tests/cancel_after_accept.cc
index c3ac0c3201..83439d71d2 100644
--- a/test/core/end2end/tests/cancel_after_accept.c
+++ b/test/core/end2end/tests/cancel_after_accept.cc
@@ -35,14 +35,14 @@
 #include "test/core/end2end/cq_verifier.h"
 #include "test/core/end2end/tests/cancel_test_helpers.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
+                                            const char* test_name,
                                             cancellation_mode mode,
                                             bool use_service_config,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s/%s/%s", test_name, config.name,
           mode.name, use_service_config ? "service_config" : "client_api");
@@ -60,31 +60,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -99,9 +99,9 @@ static void test_cancel_after_accept(grpc_end2end_test_config config,
                                      cancellation_mode mode,
                                      bool use_service_config) {
   grpc_op ops[6];
-  grpc_op *op;
-  grpc_call *c;
-  grpc_call *s;
+  grpc_op* op;
+  grpc_call* c;
+  grpc_call* s;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -109,47 +109,48 @@ static void test_cancel_after_accept(grpc_end2end_test_config config,
   grpc_status_code status;
   grpc_call_error error;
   grpc_slice details;
-  grpc_byte_buffer *request_payload_recv = NULL;
-  grpc_byte_buffer *response_payload_recv = NULL;
+  grpc_byte_buffer* request_payload_recv = nullptr;
+  grpc_byte_buffer* response_payload_recv = nullptr;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
   grpc_slice response_payload_slice =
       grpc_slice_from_copied_string("hello you");
-  grpc_byte_buffer *request_payload =
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
-  grpc_byte_buffer *response_payload =
+  grpc_byte_buffer* response_payload =
       grpc_raw_byte_buffer_create(&response_payload_slice, 1);
   int was_cancelled = 2;
 
-  grpc_channel_args *args = NULL;
+  grpc_channel_args* args = nullptr;
   if (use_service_config) {
     grpc_arg arg;
     arg.type = GRPC_ARG_STRING;
-    arg.key = GRPC_ARG_SERVICE_CONFIG;
-    arg.value.string =
+    arg.key = const_cast<char*>(GRPC_ARG_SERVICE_CONFIG);
+    arg.value.string = const_cast<char*>(
         "{\n"
         "  \"methodConfig\": [ {\n"
         "    \"name\": [\n"
-        "      { \"service\": \"service\", \"method\": \"method\" }\n"
+        "      { \"service\": \"service\", \"method\": \"method\" },\n"
+        "      { \"service\": \"unused\" }\n"
         "    ],\n"
         "    \"timeout\": \"5s\"\n"
         "  } ]\n"
-        "}";
+        "}");
     args = grpc_channel_args_copy_and_add(args, &arg, 1);
   }
 
   grpc_end2end_test_fixture f = begin_test(config, "cancel_after_accept", mode,
-                                           use_service_config, args, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+                                           use_service_config, args, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
 
   gpr_timespec deadline = use_service_config
                               ? gpr_inf_future(GPR_CLOCK_MONOTONIC)
                               : five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/service/method"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -164,29 +165,29 @@ static void test_cancel_after_accept(grpc_end2end_test_config config,
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &response_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error = grpc_server_request_call(f.server, &s, &call_details,
@@ -200,27 +201,27 @@ static void test_cancel_after_accept(grpc_end2end_test_config config,
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &request_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = response_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(3), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(3), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
-  GPR_ASSERT(GRPC_CALL_OK == mode.initiate_cancel(c, NULL));
+  GPR_ASSERT(GRPC_CALL_OK == mode.initiate_cancel(c, nullptr));
 
   CQ_EXPECT_COMPLETION(cqv, tag(3), 1);
   CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
@@ -243,7 +244,7 @@ static void test_cancel_after_accept(grpc_end2end_test_config config,
   grpc_call_unref(c);
   grpc_call_unref(s);
 
-  if (args != NULL) {
+  if (args != nullptr) {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_channel_args_destroy(&exec_ctx, args);
     grpc_exec_ctx_finish(&exec_ctx);
diff --git a/test/core/end2end/tests/cancel_after_client_done.c b/test/core/end2end/tests/cancel_after_client_done.cc
index 0e2a751d83..9b832d435d 100644
--- a/test/core/end2end/tests/cancel_after_client_done.c
+++ b/test/core/end2end/tests/cancel_after_client_done.cc
@@ -29,13 +29,13 @@
 #include "test/core/end2end/cq_verifier.h"
 #include "test/core/end2end/tests/cancel_test_helpers.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
+                                            const char* test_name,
                                             cancellation_mode mode,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s/%s", test_name, config.name,
           mode.name);
@@ -53,31 +53,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -91,12 +91,13 @@ static void end_test(grpc_end2end_test_fixture *f) {
 static void test_cancel_after_accept_and_writes_closed(
     grpc_end2end_test_config config, cancellation_mode mode) {
   grpc_op ops[6];
-  grpc_op *op;
-  grpc_call *c;
-  grpc_call *s;
-  grpc_end2end_test_fixture f = begin_test(
-      config, "test_cancel_after_accept_and_writes_closed", mode, NULL, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  grpc_op* op;
+  grpc_call* c;
+  grpc_call* s;
+  grpc_end2end_test_fixture f =
+      begin_test(config, "test_cancel_after_accept_and_writes_closed", mode,
+                 nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -104,24 +105,24 @@ static void test_cancel_after_accept_and_writes_closed(
   grpc_status_code status;
   grpc_call_error error;
   grpc_slice details;
-  grpc_byte_buffer *request_payload_recv = NULL;
-  grpc_byte_buffer *response_payload_recv = NULL;
+  grpc_byte_buffer* request_payload_recv = nullptr;
+  grpc_byte_buffer* response_payload_recv = nullptr;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
   grpc_slice response_payload_slice =
       grpc_slice_from_copied_string("hello you");
-  grpc_byte_buffer *request_payload =
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
-  grpc_byte_buffer *response_payload =
+  grpc_byte_buffer* response_payload =
       grpc_raw_byte_buffer_create(&response_payload_slice, 1);
   int was_cancelled = 2;
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -136,33 +137,33 @@ static void test_cancel_after_accept_and_writes_closed(
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &response_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error = grpc_server_request_call(f.server, &s, &call_details,
@@ -176,27 +177,27 @@ static void test_cancel_after_accept_and_writes_closed(
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &request_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = response_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(3), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(3), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
-  GPR_ASSERT(GRPC_CALL_OK == mode.initiate_cancel(c, NULL));
+  GPR_ASSERT(GRPC_CALL_OK == mode.initiate_cancel(c, nullptr));
 
   CQ_EXPECT_COMPLETION(cqv, tag(3), 1);
   CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
diff --git a/test/core/end2end/tests/cancel_after_invoke.c b/test/core/end2end/tests/cancel_after_invoke.cc
index aad9fdbf94..d3891b160e 100644
--- a/test/core/end2end/tests/cancel_after_invoke.c
+++ b/test/core/end2end/tests/cancel_after_invoke.cc
@@ -29,14 +29,14 @@
 #include "test/core/end2end/cq_verifier.h"
 #include "test/core/end2end/tests/cancel_test_helpers.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
+                                            const char* test_name,
                                             cancellation_mode mode,
                                             size_t test_ops,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s/%s [%" PRIdPTR " ops]", test_name,
           config.name, mode.name, test_ops);
@@ -54,31 +54,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->cq, tag(1000));
   grpc_event ev = grpc_completion_queue_next(
-      f->cq, grpc_timeout_seconds_to_deadline(5), NULL);
+      f->cq, grpc_timeout_seconds_to_deadline(5), nullptr);
   GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
   GPR_ASSERT(ev.tag == tag(1000));
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -92,11 +92,11 @@ static void end_test(grpc_end2end_test_fixture *f) {
 static void test_cancel_after_invoke(grpc_end2end_test_config config,
                                      cancellation_mode mode, size_t test_ops) {
   grpc_op ops[6];
-  grpc_op *op;
-  grpc_call *c;
+  grpc_op* op;
+  grpc_call* c;
   grpc_end2end_test_fixture f = begin_test(config, "test_cancel_after_invoke",
-                                           mode, test_ops, NULL, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+                                           mode, test_ops, nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -104,18 +104,18 @@ static void test_cancel_after_invoke(grpc_end2end_test_config config,
   grpc_status_code status;
   grpc_call_error error;
   grpc_slice details;
-  grpc_byte_buffer *response_payload_recv = NULL;
+  grpc_byte_buffer* response_payload_recv = nullptr;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
-  grpc_byte_buffer *request_payload =
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -130,36 +130,36 @@ static void test_cancel_after_invoke(grpc_end2end_test_config config,
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &response_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, test_ops, tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, test_ops, tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
-  GPR_ASSERT(GRPC_CALL_OK == mode.initiate_cancel(c, NULL));
+  GPR_ASSERT(GRPC_CALL_OK == mode.initiate_cancel(c, nullptr));
 
   CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
   cq_verify(cqv);
diff --git a/test/core/end2end/tests/cancel_after_round_trip.c b/test/core/end2end/tests/cancel_after_round_trip.cc
index bc41bd3a6d..ddcec67de5 100644
--- a/test/core/end2end/tests/cancel_after_round_trip.c
+++ b/test/core/end2end/tests/cancel_after_round_trip.cc
@@ -35,14 +35,14 @@
 #include "test/core/end2end/cq_verifier.h"
 #include "test/core/end2end/tests/cancel_test_helpers.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
+                                            const char* test_name,
                                             cancellation_mode mode,
                                             bool use_service_config,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s/%s/%s", test_name, config.name,
           mode.name, use_service_config ? "service_config" : "client_api");
@@ -60,31 +60,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -99,9 +99,9 @@ static void test_cancel_after_round_trip(grpc_end2end_test_config config,
                                          cancellation_mode mode,
                                          bool use_service_config) {
   grpc_op ops[6];
-  grpc_op *op;
-  grpc_call *c;
-  grpc_call *s;
+  grpc_op* op;
+  grpc_call* c;
+  grpc_call* s;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -109,26 +109,26 @@ static void test_cancel_after_round_trip(grpc_end2end_test_config config,
   grpc_status_code status;
   grpc_call_error error;
   grpc_slice details;
-  grpc_byte_buffer *request_payload_recv = NULL;
-  grpc_byte_buffer *response_payload_recv = NULL;
+  grpc_byte_buffer* request_payload_recv = nullptr;
+  grpc_byte_buffer* response_payload_recv = nullptr;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
   grpc_slice response_payload_slice =
       grpc_slice_from_copied_string("hello you");
-  grpc_byte_buffer *request_payload =
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
-  grpc_byte_buffer *response_payload1 =
+  grpc_byte_buffer* response_payload1 =
       grpc_raw_byte_buffer_create(&response_payload_slice, 1);
-  grpc_byte_buffer *response_payload2 =
+  grpc_byte_buffer* response_payload2 =
       grpc_raw_byte_buffer_create(&response_payload_slice, 1);
   int was_cancelled = 2;
 
-  grpc_channel_args *args = NULL;
+  grpc_channel_args* args = nullptr;
   if (use_service_config) {
     grpc_arg arg;
     arg.type = GRPC_ARG_STRING;
-    arg.key = GRPC_ARG_SERVICE_CONFIG;
-    arg.value.string =
+    arg.key = const_cast<char*>(GRPC_ARG_SERVICE_CONFIG);
+    arg.value.string = const_cast<char*>(
         "{\n"
         "  \"methodConfig\": [ {\n"
         "    \"name\": [\n"
@@ -136,22 +136,23 @@ static void test_cancel_after_round_trip(grpc_end2end_test_config config,
         "    ],\n"
         "    \"timeout\": \"5s\"\n"
         "  } ]\n"
-        "}";
+        "}");
     args = grpc_channel_args_copy_and_add(args, &arg, 1);
   }
 
-  grpc_end2end_test_fixture f = begin_test(
-      config, "cancel_after_round_trip", mode, use_service_config, args, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  grpc_end2end_test_fixture f =
+      begin_test(config, "cancel_after_round_trip", mode, use_service_config,
+                 args, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
 
   gpr_timespec deadline = use_service_config
                               ? gpr_inf_future(GPR_CLOCK_MONOTONIC)
                               : five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/service/method"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -164,24 +165,24 @@ static void test_cancel_after_round_trip(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &response_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -196,19 +197,19 @@ static void test_cancel_after_round_trip(grpc_end2end_test_config config,
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &request_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = response_payload1;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -217,8 +218,8 @@ static void test_cancel_after_round_trip(grpc_end2end_test_config config,
 
   grpc_byte_buffer_destroy(request_payload_recv);
   grpc_byte_buffer_destroy(response_payload_recv);
-  request_payload_recv = NULL;
-  response_payload_recv = NULL;
+  request_payload_recv = nullptr;
+  response_payload_recv = nullptr;
 
   memset(ops, 0, sizeof(ops));
   op = ops;
@@ -227,31 +228,31 @@ static void test_cancel_after_round_trip(grpc_end2end_test_config config,
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &response_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
-  GPR_ASSERT(GRPC_CALL_OK == mode.initiate_cancel(c, NULL));
+  GPR_ASSERT(GRPC_CALL_OK == mode.initiate_cancel(c, nullptr));
 
   memset(ops, 0, sizeof(ops));
   op = ops;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = response_payload2;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(2), 1);
@@ -276,7 +277,7 @@ static void test_cancel_after_round_trip(grpc_end2end_test_config config,
   grpc_call_unref(c);
   grpc_call_unref(s);
 
-  if (args != NULL) {
+  if (args != nullptr) {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_channel_args_destroy(&exec_ctx, args);
     grpc_exec_ctx_finish(&exec_ctx);
diff --git a/test/core/end2end/tests/cancel_before_invoke.c b/test/core/end2end/tests/cancel_before_invoke.cc
index 397e8b8ba6..1112375176 100644
--- a/test/core/end2end/tests/cancel_before_invoke.c
+++ b/test/core/end2end/tests/cancel_before_invoke.cc
@@ -28,13 +28,13 @@
 #include <grpc/support/useful.h>
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
+                                            const char* test_name,
                                             size_t num_ops,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s [%" PRIdPTR " ops]", test_name,
           config.name, num_ops);
@@ -52,31 +52,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -90,11 +90,11 @@ static void end_test(grpc_end2end_test_fixture *f) {
 static void test_cancel_before_invoke(grpc_end2end_test_config config,
                                       size_t test_ops) {
   grpc_op ops[6];
-  grpc_op *op;
-  grpc_call *c;
+  grpc_op* op;
+  grpc_call* c;
   grpc_end2end_test_fixture f =
-      begin_test(config, "cancel_before_invoke", test_ops, NULL, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+      begin_test(config, "cancel_before_invoke", test_ops, nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -102,21 +102,21 @@ static void test_cancel_before_invoke(grpc_end2end_test_config config,
   grpc_status_code status;
   grpc_call_error error;
   grpc_slice details;
-  grpc_byte_buffer *response_payload_recv = NULL;
+  grpc_byte_buffer* response_payload_recv = nullptr;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
-  grpc_byte_buffer *request_payload =
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
-  GPR_ASSERT(GRPC_CALL_OK == grpc_call_cancel(c, NULL));
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_cancel(c, nullptr));
 
   grpc_metadata_array_init(&initial_metadata_recv);
   grpc_metadata_array_init(&trailing_metadata_recv);
@@ -130,33 +130,33 @@ static void test_cancel_before_invoke(grpc_end2end_test_config config,
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &response_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, test_ops, tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, test_ops, tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
diff --git a/test/core/end2end/tests/cancel_in_a_vacuum.c b/test/core/end2end/tests/cancel_in_a_vacuum.cc
index cd9551bef9..a6c534eb08 100644
--- a/test/core/end2end/tests/cancel_in_a_vacuum.c
+++ b/test/core/end2end/tests/cancel_in_a_vacuum.cc
@@ -29,13 +29,13 @@
 #include "test/core/end2end/cq_verifier.h"
 #include "test/core/end2end/tests/cancel_test_helpers.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
+                                            const char* test_name,
                                             cancellation_mode mode,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s/%s", test_name, config.name,
           mode.name);
@@ -53,31 +53,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -90,20 +90,20 @@ static void end_test(grpc_end2end_test_fixture *f) {
 /* Cancel and do nothing */
 static void test_cancel_in_a_vacuum(grpc_end2end_test_config config,
                                     cancellation_mode mode) {
-  grpc_call *c;
+  grpc_call* c;
   grpc_end2end_test_fixture f =
-      begin_test(config, "test_cancel_in_a_vacuum", mode, NULL, NULL);
-  cq_verifier *v_client = cq_verifier_create(f.cq);
+      begin_test(config, "test_cancel_in_a_vacuum", mode, nullptr, nullptr);
+  cq_verifier* v_client = cq_verifier_create(f.cq);
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
-  GPR_ASSERT(GRPC_CALL_OK == mode.initiate_cancel(c, NULL));
+  GPR_ASSERT(GRPC_CALL_OK == mode.initiate_cancel(c, nullptr));
 
   grpc_call_unref(c);
 
diff --git a/test/core/end2end/tests/cancel_test_helpers.h b/test/core/end2end/tests/cancel_test_helpers.h
index d85616b153..477d19929d 100644
--- a/test/core/end2end/tests/cancel_test_helpers.h
+++ b/test/core/end2end/tests/cancel_test_helpers.h
@@ -20,13 +20,13 @@
 #define GRPC_TEST_CORE_END2END_TESTS_CANCEL_TEST_HELPERS_H
 
 typedef struct {
-  const char *name;
-  grpc_call_error (*initiate_cancel)(grpc_call *call, void *reserved);
+  const char* name;
+  grpc_call_error (*initiate_cancel)(grpc_call* call, void* reserved);
   grpc_status_code expect_status;
-  const char *expect_details;
+  const char* expect_details;
 } cancellation_mode;
 
-static grpc_call_error wait_for_deadline(grpc_call *call, void *reserved) {
+static grpc_call_error wait_for_deadline(grpc_call* call, void* reserved) {
   (void)reserved;
   return GRPC_CALL_OK;
 }
diff --git a/test/core/end2end/tests/cancel_with_status.c b/test/core/end2end/tests/cancel_with_status.cc
index ab8c4f4187..c867751d53 100644
--- a/test/core/end2end/tests/cancel_with_status.c
+++ b/test/core/end2end/tests/cancel_with_status.cc
@@ -31,13 +31,13 @@
 #include "src/core/lib/support/string.h"
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
+                                            const char* test_name,
                                             size_t num_ops,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s [%" PRIdPTR " ops]", test_name,
           config.name, num_ops);
@@ -55,31 +55,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->cq, tag(1000));
   grpc_event ev = grpc_completion_queue_next(
-      f->cq, grpc_timeout_seconds_to_deadline(5), NULL);
+      f->cq, grpc_timeout_seconds_to_deadline(5), nullptr);
   GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
   GPR_ASSERT(ev.tag == tag(1000));
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -91,10 +91,10 @@ static void end_test(grpc_end2end_test_fixture *f) {
 
 static void simple_request_body(grpc_end2end_test_config config,
                                 grpc_end2end_test_fixture f, size_t num_ops) {
-  grpc_call *c;
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  grpc_call* c;
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_status_code status;
@@ -105,10 +105,10 @@ static void simple_request_body(grpc_end2end_test_config config,
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -121,29 +121,29 @@ static void simple_request_body(grpc_end2end_test_config config,
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(num_ops <= (size_t)(op - ops));
-  error = grpc_call_start_batch(c, ops, num_ops, tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, num_ops, tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
-  char *dynamic_string = gpr_strdup("xyz");
+  char* dynamic_string = gpr_strdup("xyz");
   grpc_call_cancel_with_status(c, GRPC_STATUS_UNIMPLEMENTED,
-                               (const char *)dynamic_string, NULL);
+                               (const char*)dynamic_string, nullptr);
   // The API of \a description allows for it to be a dynamic/non-const
   // string, test this guarantee.
   gpr_free(dynamic_string);
@@ -167,7 +167,8 @@ static void test_invoke_simple_request(grpc_end2end_test_config config,
                                        size_t num_ops) {
   grpc_end2end_test_fixture f;
 
-  f = begin_test(config, "test_invoke_simple_request", num_ops, NULL, NULL);
+  f = begin_test(config, "test_invoke_simple_request", num_ops, nullptr,
+                 nullptr);
   simple_request_body(config, f, num_ops);
   end_test(&f);
   config.tear_down_data(&f);
diff --git a/test/core/end2end/tests/compressed_payload.c b/test/core/end2end/tests/compressed_payload.cc
index ba03773036..a8ea0ff2e0 100644
--- a/test/core/end2end/tests/compressed_payload.c
+++ b/test/core/end2end/tests/compressed_payload.cc
@@ -36,12 +36,12 @@
 #include "src/core/lib/transport/static_metadata.h"
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -58,31 +58,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -93,30 +93,30 @@ static void end_test(grpc_end2end_test_fixture *f) {
 }
 
 static void request_for_disabled_algorithm(
-    grpc_end2end_test_config config, const char *test_name,
+    grpc_end2end_test_config config, const char* test_name,
     uint32_t send_flags_bitmask,
     grpc_compression_algorithm algorithm_to_disable,
     grpc_compression_algorithm requested_client_compression_algorithm,
-    grpc_status_code expected_error, grpc_metadata *client_metadata) {
-  grpc_call *c;
-  grpc_call *s;
+    grpc_status_code expected_error, grpc_metadata* client_metadata) {
+  grpc_call* c;
+  grpc_call* s;
   grpc_slice request_payload_slice;
-  grpc_byte_buffer *request_payload;
-  grpc_channel_args *client_args;
-  grpc_channel_args *server_args;
+  grpc_byte_buffer* request_payload;
+  grpc_channel_args* client_args;
+  grpc_channel_args* server_args;
   grpc_end2end_test_fixture f;
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *request_payload_recv = NULL;
+  grpc_byte_buffer* request_payload_recv = nullptr;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
   grpc_slice details;
   int was_cancelled = 2;
-  cq_verifier *cqv;
+  cq_verifier* cqv;
   char str[1024];
 
   memset(str, 'x', 1023);
@@ -125,9 +125,9 @@ static void request_for_disabled_algorithm(
   request_payload = grpc_raw_byte_buffer_create(&request_payload_slice, 1);
 
   client_args = grpc_channel_args_set_compression_algorithm(
-      NULL, requested_client_compression_algorithm);
+      nullptr, requested_client_compression_algorithm);
   server_args =
-      grpc_channel_args_set_compression_algorithm(NULL, GRPC_COMPRESS_NONE);
+      grpc_channel_args_set_compression_algorithm(nullptr, GRPC_COMPRESS_NONE);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     server_args = grpc_channel_args_compression_algorithm_set_state(
@@ -140,10 +140,10 @@ static void request_for_disabled_algorithm(
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -159,37 +159,37 @@ static void request_for_disabled_algorithm(
   memset(ops, 0, sizeof(ops));
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
-  if (client_metadata != NULL) {
+  if (client_metadata != nullptr) {
     op->data.send_initial_metadata.count = 1;
     op->data.send_initial_metadata.metadata = client_metadata;
   } else {
     op->data.send_initial_metadata.count = 0;
   }
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = send_flags_bitmask;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(101), true);
@@ -200,14 +200,14 @@ static void request_for_disabled_algorithm(
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &request_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), false);
@@ -216,9 +216,9 @@ static void request_for_disabled_algorithm(
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(103), true);
@@ -229,9 +229,9 @@ static void request_for_disabled_algorithm(
   /* with a certain error */
   GPR_ASSERT(status == expected_error);
 
-  const char *algo_name = NULL;
+  const char* algo_name = nullptr;
   GPR_ASSERT(grpc_compression_algorithm_name(algorithm_to_disable, &algo_name));
-  char *expected_details = NULL;
+  char* expected_details = nullptr;
   gpr_asprintf(&expected_details, "Compression algorithm '%s' is disabled.",
                algo_name);
   /* and we expect a specific reason for it */
@@ -268,36 +268,36 @@ static void request_for_disabled_algorithm(
 }
 
 static void request_with_payload_template(
-    grpc_end2end_test_config config, const char *test_name,
+    grpc_end2end_test_config config, const char* test_name,
     uint32_t client_send_flags_bitmask,
     grpc_compression_algorithm default_client_channel_compression_algorithm,
     grpc_compression_algorithm default_server_channel_compression_algorithm,
     grpc_compression_algorithm expected_algorithm_from_client,
     grpc_compression_algorithm expected_algorithm_from_server,
-    grpc_metadata *client_init_metadata, bool set_server_level,
+    grpc_metadata* client_init_metadata, bool set_server_level,
     grpc_compression_level server_compression_level,
     bool send_message_before_initial_metadata) {
-  grpc_call *c;
-  grpc_call *s;
+  grpc_call* c;
+  grpc_call* s;
   grpc_slice request_payload_slice;
-  grpc_byte_buffer *request_payload = NULL;
-  grpc_channel_args *client_args;
-  grpc_channel_args *server_args;
+  grpc_byte_buffer* request_payload = nullptr;
+  grpc_channel_args* client_args;
+  grpc_channel_args* server_args;
   grpc_end2end_test_fixture f;
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *request_payload_recv = NULL;
-  grpc_byte_buffer *response_payload;
-  grpc_byte_buffer *response_payload_recv;
+  grpc_byte_buffer* request_payload_recv = nullptr;
+  grpc_byte_buffer* response_payload;
+  grpc_byte_buffer* response_payload_recv;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
   grpc_slice details;
   int was_cancelled = 2;
-  cq_verifier *cqv;
+  cq_verifier* cqv;
   char request_str[1024];
   char response_str[1024];
 
@@ -312,19 +312,19 @@ static void request_with_payload_template(
       grpc_slice_from_copied_string(response_str);
 
   client_args = grpc_channel_args_set_compression_algorithm(
-      NULL, default_client_channel_compression_algorithm);
+      nullptr, default_client_channel_compression_algorithm);
   server_args = grpc_channel_args_set_compression_algorithm(
-      NULL, default_server_channel_compression_algorithm);
+      nullptr, default_server_channel_compression_algorithm);
 
   f = begin_test(config, test_name, client_args, server_args);
   cqv = cq_verifier_create(f.cq);
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -339,9 +339,9 @@ static void request_with_payload_template(
     op->op = GRPC_OP_SEND_MESSAGE;
     op->data.send_message.send_message = request_payload;
     op->flags = client_send_flags_bitmask;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), NULL);
+    error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
     CQ_EXPECT_COMPLETION(cqv, tag(2), true);
   }
@@ -349,28 +349,28 @@ static void request_with_payload_template(
   memset(ops, 0, sizeof(ops));
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
-  if (client_init_metadata != NULL) {
+  if (client_init_metadata != nullptr) {
     op->data.send_initial_metadata.count = 1;
     op->data.send_initial_metadata.metadata = client_init_metadata;
   } else {
     op->data.send_initial_metadata.count = 0;
   }
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -399,14 +399,14 @@ static void request_with_payload_template(
         server_compression_level;
   }
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(101), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(101), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   for (int i = 0; i < 2; i++) {
@@ -419,9 +419,10 @@ static void request_with_payload_template(
       op->op = GRPC_OP_SEND_MESSAGE;
       op->data.send_message.send_message = request_payload;
       op->flags = client_send_flags_bitmask;
-      op->reserved = NULL;
+      op->reserved = nullptr;
       op++;
-      error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), NULL);
+      error =
+          grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), nullptr);
       GPR_ASSERT(GRPC_CALL_OK == error);
       CQ_EXPECT_COMPLETION(cqv, tag(2), 1);
     }
@@ -431,9 +432,10 @@ static void request_with_payload_template(
     op->op = GRPC_OP_RECV_MESSAGE;
     op->data.recv_message.recv_message = &request_payload_recv;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+    error =
+        grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
 
     CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -449,9 +451,10 @@ static void request_with_payload_template(
     op->op = GRPC_OP_SEND_MESSAGE;
     op->data.send_message.send_message = response_payload;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), NULL);
+    error =
+        grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
 
     memset(ops, 0, sizeof(ops));
@@ -459,9 +462,9 @@ static void request_with_payload_template(
     op->op = GRPC_OP_RECV_MESSAGE;
     op->data.recv_message.recv_message = &response_payload_recv;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(3), NULL);
+    error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(3), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
 
     CQ_EXPECT_COMPLETION(cqv, tag(103), 1);
@@ -493,9 +496,9 @@ static void request_with_payload_template(
   op = ops;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(4), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(4), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   memset(ops, 0, sizeof(ops));
@@ -506,9 +509,9 @@ static void request_with_payload_template(
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(104), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(104), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
@@ -551,7 +554,7 @@ static void test_invoke_request_with_exceptionally_uncompressed_payload(
   request_with_payload_template(
       config, "test_invoke_request_with_exceptionally_uncompressed_payload",
       GRPC_WRITE_NO_COMPRESS, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP,
-      GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP, NULL, false,
+      GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP, nullptr, false,
       /* ignored */ GRPC_COMPRESS_LEVEL_NONE, false);
 }
 
@@ -560,8 +563,8 @@ static void test_invoke_request_with_uncompressed_payload(
   request_with_payload_template(
       config, "test_invoke_request_with_uncompressed_payload", 0,
       GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE,
-      GRPC_COMPRESS_NONE, NULL, false, /* ignored */ GRPC_COMPRESS_LEVEL_NONE,
-      false);
+      GRPC_COMPRESS_NONE, nullptr, false,
+      /* ignored */ GRPC_COMPRESS_LEVEL_NONE, false);
 }
 
 static void test_invoke_request_with_compressed_payload(
@@ -569,8 +572,8 @@ static void test_invoke_request_with_compressed_payload(
   request_with_payload_template(
       config, "test_invoke_request_with_compressed_payload", 0,
       GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP,
-      GRPC_COMPRESS_GZIP, NULL, false, /* ignored */ GRPC_COMPRESS_LEVEL_NONE,
-      false);
+      GRPC_COMPRESS_GZIP, nullptr, false,
+      /* ignored */ GRPC_COMPRESS_LEVEL_NONE, false);
 }
 
 static void test_invoke_request_with_send_message_before_initial_metadata(
@@ -578,8 +581,8 @@ static void test_invoke_request_with_send_message_before_initial_metadata(
   request_with_payload_template(
       config, "test_invoke_request_with_compressed_payload", 0,
       GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP,
-      GRPC_COMPRESS_GZIP, NULL, false, /* ignored */ GRPC_COMPRESS_LEVEL_NONE,
-      true);
+      GRPC_COMPRESS_GZIP, nullptr, false,
+      /* ignored */ GRPC_COMPRESS_LEVEL_NONE, true);
 }
 
 static void test_invoke_request_with_server_level(
@@ -587,7 +590,7 @@ static void test_invoke_request_with_server_level(
   request_with_payload_template(
       config, "test_invoke_request_with_server_level", 0, GRPC_COMPRESS_NONE,
       GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE /* ignored */,
-      NULL, true, GRPC_COMPRESS_LEVEL_HIGH, false);
+      nullptr, true, GRPC_COMPRESS_LEVEL_HIGH, false);
 }
 
 static void test_invoke_request_with_compressed_payload_md_override(
@@ -630,9 +633,10 @@ static void test_invoke_request_with_compressed_payload_md_override(
 
 static void test_invoke_request_with_disabled_algorithm(
     grpc_end2end_test_config config) {
-  request_for_disabled_algorithm(
-      config, "test_invoke_request_with_disabled_algorithm", 0,
-      GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP, GRPC_STATUS_UNIMPLEMENTED, NULL);
+  request_for_disabled_algorithm(config,
+                                 "test_invoke_request_with_disabled_algorithm",
+                                 0, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP,
+                                 GRPC_STATUS_UNIMPLEMENTED, nullptr);
 }
 
 void compressed_payload(grpc_end2end_test_config config) {
diff --git a/test/core/end2end/tests/connectivity.c b/test/core/end2end/tests/connectivity.cc
index 610243ee3a..2ea4ca81f5 100644
--- a/test/core/end2end/tests/connectivity.c
+++ b/test/core/end2end/tests/connectivity.cc
@@ -25,30 +25,30 @@
 
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 typedef struct {
   gpr_event started;
-  grpc_channel *channel;
-  grpc_completion_queue *cq;
+  grpc_channel* channel;
+  grpc_completion_queue* cq;
 } child_events;
 
-static void child_thread(void *arg) {
-  child_events *ce = (child_events *)arg;
+static void child_thread(void* arg) {
+  child_events* ce = (child_events*)arg;
   grpc_event ev;
-  gpr_event_set(&ce->started, (void *)1);
+  gpr_event_set(&ce->started, (void*)1);
   gpr_log(GPR_DEBUG, "verifying");
   ev = grpc_completion_queue_next(ce->cq, gpr_inf_future(GPR_CLOCK_MONOTONIC),
-                                  NULL);
+                                  nullptr);
   GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
   GPR_ASSERT(ev.tag == tag(1));
   GPR_ASSERT(ev.success == 0);
 }
 
 static void test_connectivity(grpc_end2end_test_config config) {
-  grpc_end2end_test_fixture f = config.create_fixture(NULL, NULL);
+  grpc_end2end_test_fixture f = config.create_fixture(nullptr, nullptr);
   grpc_connectivity_state state;
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   child_events ce;
   gpr_thd_options thdopt = gpr_thd_options_default();
   gpr_thd_id thdid;
@@ -56,7 +56,8 @@ static void test_connectivity(grpc_end2end_test_config config) {
   grpc_channel_args client_args;
   grpc_arg arg_array[1];
   arg_array[0].type = GRPC_ARG_INTEGER;
-  arg_array[0].key = "grpc.testing.fixed_reconnect_backoff_ms";
+  arg_array[0].key =
+      const_cast<char*>("grpc.testing.fixed_reconnect_backoff_ms");
   arg_array[0].value.integer = 1000;
   client_args.args = arg_array;
   client_args.num_args = 1;
@@ -114,7 +115,7 @@ static void test_connectivity(grpc_end2end_test_config config) {
   gpr_log(GPR_DEBUG, "*** STARTING SERVER ***");
 
   /* now let's bring up a server to connect to */
-  config.init_server(&f, NULL);
+  config.init_server(&f, nullptr);
 
   gpr_log(GPR_DEBUG, "*** STARTED SERVER ***");
 
diff --git a/test/core/end2end/tests/default_host.c b/test/core/end2end/tests/default_host.cc
index d1db9b342a..85f92b0ab0 100644
--- a/test/core/end2end/tests/default_host.c
+++ b/test/core/end2end/tests/default_host.cc
@@ -30,12 +30,12 @@
 #include "src/core/lib/support/string.h"
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -52,31 +52,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -87,11 +87,11 @@ static void end_test(grpc_end2end_test_fixture *f) {
 }
 
 static void simple_request_body(grpc_end2end_test_fixture f) {
-  grpc_call *c;
-  grpc_call *s;
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  grpc_call* c;
+  grpc_call* s;
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -100,16 +100,16 @@ static void simple_request_body(grpc_end2end_test_fixture f) {
   grpc_call_error error;
   grpc_slice details;
   int was_cancelled = 2;
-  char *peer;
+  char* peer;
 
   gpr_timespec deadline = five_seconds_from_now();
-  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
-                               grpc_slice_from_static_string("/foo"), NULL,
-                               deadline, NULL);
+  c = grpc_channel_create_call(f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               grpc_slice_from_static_string("/foo"), nullptr,
+                               deadline, nullptr);
   GPR_ASSERT(c);
 
   peer = grpc_call_get_peer(c);
-  GPR_ASSERT(peer != NULL);
+  GPR_ASSERT(peer != nullptr);
   gpr_log(GPR_DEBUG, "client_peer_before_call=%s", peer);
   gpr_free(peer);
 
@@ -123,25 +123,25 @@ static void simple_request_body(grpc_end2end_test_fixture f) {
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(error == GRPC_CALL_OK);
 
   error =
@@ -152,11 +152,11 @@ static void simple_request_body(grpc_end2end_test_fixture f) {
   cq_verify(cqv);
 
   peer = grpc_call_get_peer(s);
-  GPR_ASSERT(peer != NULL);
+  GPR_ASSERT(peer != nullptr);
   gpr_log(GPR_DEBUG, "server_peer=%s", peer);
   gpr_free(peer);
   peer = grpc_call_get_peer(c);
-  GPR_ASSERT(peer != NULL);
+  GPR_ASSERT(peer != nullptr);
   gpr_log(GPR_DEBUG, "client_peer=%s", peer);
   gpr_free(peer);
 
@@ -165,7 +165,7 @@ static void simple_request_body(grpc_end2end_test_fixture f) {
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -173,14 +173,14 @@ static void simple_request_body(grpc_end2end_test_fixture f) {
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(error == GRPC_CALL_OK);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -208,7 +208,7 @@ static void simple_request_body(grpc_end2end_test_fixture f) {
 static void test_invoke_simple_request(grpc_end2end_test_config config) {
   grpc_end2end_test_fixture f;
 
-  f = begin_test(config, "test_invoke_simple_request", NULL, NULL);
+  f = begin_test(config, "test_invoke_simple_request", nullptr, nullptr);
   simple_request_body(f);
   end_test(&f);
   config.tear_down_data(&f);
diff --git a/test/core/end2end/tests/disappearing_server.c b/test/core/end2end/tests/disappearing_server.cc
index 19e4c05605..29fb19463f 100644
--- a/test/core/end2end/tests/disappearing_server.c
+++ b/test/core/end2end/tests/disappearing_server.cc
@@ -28,7 +28,7 @@
 #include <grpc/support/useful.h>
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static gpr_timespec n_seconds_from_now(int n) {
   return grpc_timeout_seconds_to_deadline(n);
@@ -38,26 +38,26 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -70,12 +70,12 @@ static void end_test(grpc_end2end_test_fixture *f) {
 }
 
 static void do_request_and_shutdown_server(grpc_end2end_test_config config,
-                                           grpc_end2end_test_fixture *f,
-                                           cq_verifier *cqv) {
-  grpc_call *c;
-  grpc_call *s;
+                                           grpc_end2end_test_fixture* f,
+                                           cq_verifier* cqv) {
+  grpc_call* c;
+  grpc_call* s;
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -87,10 +87,10 @@ static void do_request_and_shutdown_server(grpc_end2end_test_config config,
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f->client, NULL, GRPC_PROPAGATE_DEFAULTS, f->cq,
+      f->client, nullptr, GRPC_PROPAGATE_DEFAULTS, f->cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -103,25 +103,25 @@ static void do_request_and_shutdown_server(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -140,7 +140,7 @@ static void do_request_and_shutdown_server(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -148,14 +148,14 @@ static void do_request_and_shutdown_server(grpc_end2end_test_config config,
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -181,19 +181,19 @@ static void do_request_and_shutdown_server(grpc_end2end_test_config config,
 }
 
 static void disappearing_server_test(grpc_end2end_test_config config) {
-  grpc_end2end_test_fixture f = config.create_fixture(NULL, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  grpc_end2end_test_fixture f = config.create_fixture(nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
 
   gpr_log(GPR_INFO, "Running test: %s/%s", "disappearing_server_test",
           config.name);
 
-  config.init_client(&f, NULL);
-  config.init_server(&f, NULL);
+  config.init_client(&f, nullptr);
+  config.init_server(&f, nullptr);
 
   do_request_and_shutdown_server(config, &f, cqv);
 
   /* now destroy and recreate the server */
-  config.init_server(&f, NULL);
+  config.init_server(&f, nullptr);
 
   do_request_and_shutdown_server(config, &f, cqv);
 
diff --git a/test/core/end2end/tests/empty_batch.c b/test/core/end2end/tests/empty_batch.cc
index ee57c16780..b249c141de 100644
--- a/test/core/end2end/tests/empty_batch.c
+++ b/test/core/end2end/tests/empty_batch.cc
@@ -30,12 +30,12 @@
 #include "src/core/lib/support/string.h"
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -52,31 +52,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -88,20 +88,20 @@ static void end_test(grpc_end2end_test_fixture *f) {
 
 static void empty_batch_body(grpc_end2end_test_config config,
                              grpc_end2end_test_fixture f) {
-  grpc_call *c;
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  grpc_call* c;
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_call_error error;
-  grpc_op *op = NULL;
+  grpc_op* op = nullptr;
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
-  error = grpc_call_start_batch(c, op, 0, tag(1), NULL);
+  error = grpc_call_start_batch(c, op, 0, tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
   CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
   cq_verify(cqv);
@@ -114,7 +114,7 @@ static void empty_batch_body(grpc_end2end_test_config config,
 static void test_invoke_empty_body(grpc_end2end_test_config config) {
   grpc_end2end_test_fixture f;
 
-  f = begin_test(config, "test_invoke_empty_body", NULL, NULL);
+  f = begin_test(config, "test_invoke_empty_body", nullptr, nullptr);
   empty_batch_body(config, f);
   end_test(&f);
   config.tear_down_data(&f);
diff --git a/test/core/end2end/tests/filter_call_init_fails.c b/test/core/end2end/tests/filter_call_init_fails.cc
index 09e9dbcd7b..6eed68a2f9 100644
--- a/test/core/end2end/tests/filter_call_init_fails.c
+++ b/test/core/end2end/tests/filter_call_init_fails.cc
@@ -38,12 +38,12 @@ static bool g_enable_server_channel_filter = false;
 static bool g_enable_client_channel_filter = false;
 static bool g_enable_client_subchannel_filter = false;
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -60,31 +60,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -97,21 +97,21 @@ static void end_test(grpc_end2end_test_fixture *f) {
 // Simple request via a SERVER_CHANNEL filter that always fails to
 // initialize the call.
 static void test_server_channel_filter(grpc_end2end_test_config config) {
-  grpc_call *c;
-  grpc_call *s;
+  grpc_call* c;
+  grpc_call* s;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
-  grpc_byte_buffer *request_payload =
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
   grpc_end2end_test_fixture f =
-      begin_test(config, "filter_call_init_fails", NULL, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+      begin_test(config, "filter_call_init_fails", nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *request_payload_recv = NULL;
+  grpc_byte_buffer* request_payload_recv = nullptr;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
@@ -119,10 +119,10 @@ static void test_server_channel_filter(grpc_end2end_test_config config) {
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -134,32 +134,32 @@ static void test_server_channel_filter(grpc_end2end_test_config config) {
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
-  op->data.send_initial_metadata.metadata = NULL;
+  op->data.send_initial_metadata.metadata = nullptr;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -193,31 +193,31 @@ static void test_server_channel_filter(grpc_end2end_test_config config) {
 // Simple request via a CLIENT_CHANNEL or CLIENT_DIRECT_CHANNEL filter
 // that always fails to initialize the call.
 static void test_client_channel_filter(grpc_end2end_test_config config) {
-  grpc_call *c;
+  grpc_call* c;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
-  grpc_byte_buffer *request_payload =
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
   gpr_timespec deadline = five_seconds_from_now();
   grpc_end2end_test_fixture f =
-      begin_test(config, "filter_call_init_fails", NULL, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+      begin_test(config, "filter_call_init_fails", nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *request_payload_recv = NULL;
+  grpc_byte_buffer* request_payload_recv = nullptr;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
   grpc_slice details;
 
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -229,32 +229,32 @@ static void test_client_channel_filter(grpc_end2end_test_config config) {
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
-  op->data.send_initial_metadata.metadata = NULL;
+  op->data.send_initial_metadata.metadata = nullptr;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
@@ -283,31 +283,31 @@ static void test_client_channel_filter(grpc_end2end_test_config config) {
 // Simple request via a CLIENT_SUBCHANNEL filter that always fails to
 // initialize the call.
 static void test_client_subchannel_filter(grpc_end2end_test_config config) {
-  grpc_call *c;
+  grpc_call* c;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
-  grpc_byte_buffer *request_payload =
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
   gpr_timespec deadline = five_seconds_from_now();
   grpc_end2end_test_fixture f =
-      begin_test(config, "filter_call_init_fails", NULL, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+      begin_test(config, "filter_call_init_fails", nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *request_payload_recv = NULL;
+  grpc_byte_buffer* request_payload_recv = nullptr;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
   grpc_slice details;
 
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -319,33 +319,33 @@ static void test_client_subchannel_filter(grpc_end2end_test_config config) {
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
-  op->data.send_initial_metadata.metadata = NULL;
+  op->data.send_initial_metadata.metadata = nullptr;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
 
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
@@ -363,13 +363,13 @@ static void test_client_subchannel_filter(grpc_end2end_test_config config) {
   details = grpc_empty_slice();
 
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(2), 1);
@@ -399,26 +399,26 @@ static void test_client_subchannel_filter(grpc_end2end_test_config config) {
  * Test filter - always fails to initialize a call
  */
 
-static grpc_error *init_call_elem(grpc_exec_ctx *exec_ctx,
-                                  grpc_call_element *elem,
-                                  const grpc_call_element_args *args) {
+static grpc_error* init_call_elem(grpc_exec_ctx* exec_ctx,
+                                  grpc_call_element* elem,
+                                  const grpc_call_element_args* args) {
   return grpc_error_set_int(
       GRPC_ERROR_CREATE_FROM_STATIC_STRING("access denied"),
       GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_PERMISSION_DENIED);
 }
 
-static void destroy_call_elem(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
-                              const grpc_call_final_info *final_info,
-                              grpc_closure *ignored) {}
+static void destroy_call_elem(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+                              const grpc_call_final_info* final_info,
+                              grpc_closure* ignored) {}
 
-static grpc_error *init_channel_elem(grpc_exec_ctx *exec_ctx,
-                                     grpc_channel_element *elem,
-                                     grpc_channel_element_args *args) {
+static grpc_error* init_channel_elem(grpc_exec_ctx* exec_ctx,
+                                     grpc_channel_element* elem,
+                                     grpc_channel_element_args* args) {
   return GRPC_ERROR_NONE;
 }
 
-static void destroy_channel_elem(grpc_exec_ctx *exec_ctx,
-                                 grpc_channel_element *elem) {}
+static void destroy_channel_elem(grpc_exec_ctx* exec_ctx,
+                                 grpc_channel_element* elem) {}
 
 static const grpc_channel_filter test_filter = {
     grpc_call_next_op,
@@ -437,19 +437,19 @@ static const grpc_channel_filter test_filter = {
  * Registration
  */
 
-static bool maybe_add_server_channel_filter(grpc_exec_ctx *exec_ctx,
-                                            grpc_channel_stack_builder *builder,
-                                            void *arg) {
+static bool maybe_add_server_channel_filter(grpc_exec_ctx* exec_ctx,
+                                            grpc_channel_stack_builder* builder,
+                                            void* arg) {
   if (g_enable_server_channel_filter) {
     // Want to add the filter as close to the end as possible, to make
     // sure that all of the filters work well together.  However, we
     // can't add it at the very end, because the connected channel filter
     // must be the last one.  So we add it right before the last one.
-    grpc_channel_stack_builder_iterator *it =
+    grpc_channel_stack_builder_iterator* it =
         grpc_channel_stack_builder_create_iterator_at_last(builder);
     GPR_ASSERT(grpc_channel_stack_builder_move_prev(it));
     const bool retval = grpc_channel_stack_builder_add_filter_before(
-        it, &test_filter, NULL, NULL);
+        it, &test_filter, nullptr, nullptr);
     grpc_channel_stack_builder_iterator_destroy(it);
     return retval;
   } else {
@@ -457,19 +457,19 @@ static bool maybe_add_server_channel_filter(grpc_exec_ctx *exec_ctx,
   }
 }
 
-static bool maybe_add_client_channel_filter(grpc_exec_ctx *exec_ctx,
-                                            grpc_channel_stack_builder *builder,
-                                            void *arg) {
+static bool maybe_add_client_channel_filter(grpc_exec_ctx* exec_ctx,
+                                            grpc_channel_stack_builder* builder,
+                                            void* arg) {
   if (g_enable_client_channel_filter) {
     // Want to add the filter as close to the end as possible, to make
     // sure that all of the filters work well together.  However, we
     // can't add it at the very end, because the connected channel filter
     // must be the last one.  So we add it right before the last one.
-    grpc_channel_stack_builder_iterator *it =
+    grpc_channel_stack_builder_iterator* it =
         grpc_channel_stack_builder_create_iterator_at_last(builder);
     GPR_ASSERT(grpc_channel_stack_builder_move_prev(it));
     const bool retval = grpc_channel_stack_builder_add_filter_before(
-        it, &test_filter, NULL, NULL);
+        it, &test_filter, nullptr, nullptr);
     grpc_channel_stack_builder_iterator_destroy(it);
     return retval;
   } else {
@@ -478,17 +478,17 @@ static bool maybe_add_client_channel_filter(grpc_exec_ctx *exec_ctx,
 }
 
 static bool maybe_add_client_subchannel_filter(
-    grpc_exec_ctx *exec_ctx, grpc_channel_stack_builder *builder, void *arg) {
+    grpc_exec_ctx* exec_ctx, grpc_channel_stack_builder* builder, void* arg) {
   if (g_enable_client_subchannel_filter) {
     // Want to add the filter as close to the end as possible, to make
     // sure that all of the filters work well together.  However, we
     // can't add it at the very end, because the client channel filter
     // must be the last one.  So we add it right before the last one.
-    grpc_channel_stack_builder_iterator *it =
+    grpc_channel_stack_builder_iterator* it =
         grpc_channel_stack_builder_create_iterator_at_last(builder);
     GPR_ASSERT(grpc_channel_stack_builder_move_prev(it));
     const bool retval = grpc_channel_stack_builder_add_filter_before(
-        it, &test_filter, NULL, NULL);
+        it, &test_filter, nullptr, nullptr);
     grpc_channel_stack_builder_iterator_destroy(it);
     return retval;
   } else {
@@ -498,13 +498,13 @@ static bool maybe_add_client_subchannel_filter(
 
 static void init_plugin(void) {
   grpc_channel_init_register_stage(GRPC_SERVER_CHANNEL, INT_MAX,
-                                   maybe_add_server_channel_filter, NULL);
+                                   maybe_add_server_channel_filter, nullptr);
   grpc_channel_init_register_stage(GRPC_CLIENT_CHANNEL, INT_MAX,
-                                   maybe_add_client_channel_filter, NULL);
+                                   maybe_add_client_channel_filter, nullptr);
   grpc_channel_init_register_stage(GRPC_CLIENT_SUBCHANNEL, INT_MAX,
-                                   maybe_add_client_subchannel_filter, NULL);
+                                   maybe_add_client_subchannel_filter, nullptr);
   grpc_channel_init_register_stage(GRPC_CLIENT_DIRECT_CHANNEL, INT_MAX,
-                                   maybe_add_client_channel_filter, NULL);
+                                   maybe_add_client_channel_filter, nullptr);
 }
 
 static void destroy_plugin(void) {}
diff --git a/test/core/end2end/tests/filter_causes_close.c b/test/core/end2end/tests/filter_causes_close.cc
index ee7aeb3f33..793f590686 100644
--- a/test/core/end2end/tests/filter_causes_close.c
+++ b/test/core/end2end/tests/filter_causes_close.cc
@@ -33,12 +33,12 @@
 
 static bool g_enable_filter = false;
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -55,31 +55,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -91,21 +91,21 @@ static void end_test(grpc_end2end_test_fixture *f) {
 
 /* Simple request via a server filter that always closes the stream.*/
 static void test_request(grpc_end2end_test_config config) {
-  grpc_call *c;
-  grpc_call *s;
+  grpc_call* c;
+  grpc_call* s;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
-  grpc_byte_buffer *request_payload =
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
   grpc_end2end_test_fixture f =
-      begin_test(config, "filter_causes_close", NULL, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+      begin_test(config, "filter_causes_close", nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *request_payload_recv = NULL;
+  grpc_byte_buffer* request_payload_recv = nullptr;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
@@ -113,10 +113,10 @@ static void test_request(grpc_end2end_test_config config) {
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -128,32 +128,32 @@ static void test_request(grpc_end2end_test_config config) {
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
-  op->data.send_initial_metadata.metadata = NULL;
+  op->data.send_initial_metadata.metadata = nullptr;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -189,14 +189,18 @@ static void test_request(grpc_end2end_test_config config) {
  * Test filter - always closes incoming requests
  */
 
-typedef struct { grpc_closure *recv_im_ready; } call_data;
+typedef struct {
+  grpc_closure* recv_im_ready;
+} call_data;
 
-typedef struct { uint8_t unused; } channel_data;
+typedef struct {
+  uint8_t unused;
+} channel_data;
 
-static void recv_im_ready(grpc_exec_ctx *exec_ctx, void *arg,
-                          grpc_error *error) {
-  grpc_call_element *elem = (grpc_call_element *)arg;
-  call_data *calld = (call_data *)elem->call_data;
+static void recv_im_ready(grpc_exec_ctx* exec_ctx, void* arg,
+                          grpc_error* error) {
+  grpc_call_element* elem = (grpc_call_element*)arg;
+  call_data* calld = (call_data*)elem->call_data;
   GRPC_CLOSURE_RUN(
       exec_ctx, calld->recv_im_ready,
       grpc_error_set_int(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
@@ -206,9 +210,9 @@ static void recv_im_ready(grpc_exec_ctx *exec_ctx, void *arg,
 }
 
 static void start_transport_stream_op_batch(
-    grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
-    grpc_transport_stream_op_batch *op) {
-  call_data *calld = (call_data *)elem->call_data;
+    grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+    grpc_transport_stream_op_batch* op) {
+  call_data* calld = (call_data*)elem->call_data;
   if (op->recv_initial_metadata) {
     calld->recv_im_ready =
         op->payload->recv_initial_metadata.recv_initial_metadata_ready;
@@ -218,24 +222,24 @@ static void start_transport_stream_op_batch(
   grpc_call_next_op(exec_ctx, elem, op);
 }
 
-static grpc_error *init_call_elem(grpc_exec_ctx *exec_ctx,
-                                  grpc_call_element *elem,
-                                  const grpc_call_element_args *args) {
+static grpc_error* init_call_elem(grpc_exec_ctx* exec_ctx,
+                                  grpc_call_element* elem,
+                                  const grpc_call_element_args* args) {
   return GRPC_ERROR_NONE;
 }
 
-static void destroy_call_elem(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
-                              const grpc_call_final_info *final_info,
-                              grpc_closure *ignored) {}
+static void destroy_call_elem(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+                              const grpc_call_final_info* final_info,
+                              grpc_closure* ignored) {}
 
-static grpc_error *init_channel_elem(grpc_exec_ctx *exec_ctx,
-                                     grpc_channel_element *elem,
-                                     grpc_channel_element_args *args) {
+static grpc_error* init_channel_elem(grpc_exec_ctx* exec_ctx,
+                                     grpc_channel_element* elem,
+                                     grpc_channel_element_args* args) {
   return GRPC_ERROR_NONE;
 }
 
-static void destroy_channel_elem(grpc_exec_ctx *exec_ctx,
-                                 grpc_channel_element *elem) {}
+static void destroy_channel_elem(grpc_exec_ctx* exec_ctx,
+                                 grpc_channel_element* elem) {}
 
 static const grpc_channel_filter test_filter = {
     start_transport_stream_op_batch,
@@ -254,11 +258,11 @@ static const grpc_channel_filter test_filter = {
  * Registration
  */
 
-static bool maybe_add_filter(grpc_exec_ctx *exec_ctx,
-                             grpc_channel_stack_builder *builder, void *arg) {
+static bool maybe_add_filter(grpc_exec_ctx* exec_ctx,
+                             grpc_channel_stack_builder* builder, void* arg) {
   if (g_enable_filter) {
     return grpc_channel_stack_builder_prepend_filter(builder, &test_filter,
-                                                     NULL, NULL);
+                                                     nullptr, nullptr);
   } else {
     return true;
   }
@@ -266,7 +270,7 @@ static bool maybe_add_filter(grpc_exec_ctx *exec_ctx,
 
 static void init_plugin(void) {
   grpc_channel_init_register_stage(GRPC_SERVER_CHANNEL, 0, maybe_add_filter,
-                                   NULL);
+                                   nullptr);
 }
 
 static void destroy_plugin(void) {}
diff --git a/test/core/end2end/tests/filter_latency.c b/test/core/end2end/tests/filter_latency.cc
index c24934f05d..c4d96ebfe2 100644
--- a/test/core/end2end/tests/filter_latency.c
+++ b/test/core/end2end/tests/filter_latency.cc
@@ -40,12 +40,12 @@ static gpr_mu g_mu;
 static gpr_timespec g_client_latency;
 static gpr_timespec g_server_latency;
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -62,31 +62,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -98,21 +98,21 @@ static void end_test(grpc_end2end_test_fixture *f) {
 
 // Simple request via a server filter that saves the reported latency value.
 static void test_request(grpc_end2end_test_config config) {
-  grpc_call *c;
-  grpc_call *s;
+  grpc_call* c;
+  grpc_call* s;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
-  grpc_byte_buffer *request_payload =
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
   grpc_end2end_test_fixture f =
-      begin_test(config, "filter_latency", NULL, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+      begin_test(config, "filter_latency", nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *request_payload_recv = NULL;
+  grpc_byte_buffer* request_payload_recv = nullptr;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
@@ -127,9 +127,9 @@ static void test_request(grpc_end2end_test_config config) {
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
-      get_host_override_slice("foo.test.google.fr", config), deadline, NULL);
+      get_host_override_slice("foo.test.google.fr", config), deadline, nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -141,32 +141,32 @@ static void test_request(grpc_end2end_test_config config) {
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
-  op->data.send_initial_metadata.metadata = NULL;
+  op->data.send_initial_metadata.metadata = nullptr;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -182,7 +182,7 @@ static void test_request(grpc_end2end_test_config config) {
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -190,14 +190,14 @@ static void test_request(grpc_end2end_test_config config) {
   grpc_slice status_string = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_string;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -247,38 +247,38 @@ static void test_request(grpc_end2end_test_config config) {
  * Test latency filter
  */
 
-static grpc_error *init_call_elem(grpc_exec_ctx *exec_ctx,
-                                  grpc_call_element *elem,
-                                  const grpc_call_element_args *args) {
+static grpc_error* init_call_elem(grpc_exec_ctx* exec_ctx,
+                                  grpc_call_element* elem,
+                                  const grpc_call_element_args* args) {
   return GRPC_ERROR_NONE;
 }
 
-static void client_destroy_call_elem(grpc_exec_ctx *exec_ctx,
-                                     grpc_call_element *elem,
-                                     const grpc_call_final_info *final_info,
-                                     grpc_closure *ignored) {
+static void client_destroy_call_elem(grpc_exec_ctx* exec_ctx,
+                                     grpc_call_element* elem,
+                                     const grpc_call_final_info* final_info,
+                                     grpc_closure* ignored) {
   gpr_mu_lock(&g_mu);
   g_client_latency = final_info->stats.latency;
   gpr_mu_unlock(&g_mu);
 }
 
-static void server_destroy_call_elem(grpc_exec_ctx *exec_ctx,
-                                     grpc_call_element *elem,
-                                     const grpc_call_final_info *final_info,
-                                     grpc_closure *ignored) {
+static void server_destroy_call_elem(grpc_exec_ctx* exec_ctx,
+                                     grpc_call_element* elem,
+                                     const grpc_call_final_info* final_info,
+                                     grpc_closure* ignored) {
   gpr_mu_lock(&g_mu);
   g_server_latency = final_info->stats.latency;
   gpr_mu_unlock(&g_mu);
 }
 
-static grpc_error *init_channel_elem(grpc_exec_ctx *exec_ctx,
-                                     grpc_channel_element *elem,
-                                     grpc_channel_element_args *args) {
+static grpc_error* init_channel_elem(grpc_exec_ctx* exec_ctx,
+                                     grpc_channel_element* elem,
+                                     grpc_channel_element_args* args) {
   return GRPC_ERROR_NONE;
 }
 
-static void destroy_channel_elem(grpc_exec_ctx *exec_ctx,
-                                 grpc_channel_element *elem) {}
+static void destroy_channel_elem(grpc_exec_ctx* exec_ctx,
+                                 grpc_channel_element* elem) {}
 
 static const grpc_channel_filter test_client_filter = {
     grpc_call_next_op,
@@ -310,19 +310,19 @@ static const grpc_channel_filter test_server_filter = {
  * Registration
  */
 
-static bool maybe_add_filter(grpc_exec_ctx *exec_ctx,
-                             grpc_channel_stack_builder *builder, void *arg) {
-  grpc_channel_filter *filter = (grpc_channel_filter *)arg;
+static bool maybe_add_filter(grpc_exec_ctx* exec_ctx,
+                             grpc_channel_stack_builder* builder, void* arg) {
+  grpc_channel_filter* filter = (grpc_channel_filter*)arg;
   if (g_enable_filter) {
     // Want to add the filter as close to the end as possible, to make
     // sure that all of the filters work well together.  However, we
     // can't add it at the very end, because the connected channel filter
     // must be the last one.  So we add it right before the last one.
-    grpc_channel_stack_builder_iterator *it =
+    grpc_channel_stack_builder_iterator* it =
         grpc_channel_stack_builder_create_iterator_at_last(builder);
     GPR_ASSERT(grpc_channel_stack_builder_move_prev(it));
-    const bool retval =
-        grpc_channel_stack_builder_add_filter_before(it, filter, NULL, NULL);
+    const bool retval = grpc_channel_stack_builder_add_filter_before(
+        it, filter, nullptr, nullptr);
     grpc_channel_stack_builder_iterator_destroy(it);
     return retval;
   } else {
@@ -334,13 +334,13 @@ static void init_plugin(void) {
   gpr_mu_init(&g_mu);
   grpc_channel_init_register_stage(GRPC_CLIENT_CHANNEL, INT_MAX,
                                    maybe_add_filter,
-                                   (void *)&test_client_filter);
+                                   (void*)&test_client_filter);
   grpc_channel_init_register_stage(GRPC_CLIENT_DIRECT_CHANNEL, INT_MAX,
                                    maybe_add_filter,
-                                   (void *)&test_client_filter);
+                                   (void*)&test_client_filter);
   grpc_channel_init_register_stage(GRPC_SERVER_CHANNEL, INT_MAX,
                                    maybe_add_filter,
-                                   (void *)&test_server_filter);
+                                   (void*)&test_server_filter);
 }
 
 static void destroy_plugin(void) { gpr_mu_destroy(&g_mu); }
diff --git a/test/core/end2end/tests/graceful_server_shutdown.c b/test/core/end2end/tests/graceful_server_shutdown.cc
index 9b3ff98195..bf11b49fa4 100644
--- a/test/core/end2end/tests/graceful_server_shutdown.c
+++ b/test/core/end2end/tests/graceful_server_shutdown.cc
@@ -28,12 +28,12 @@
 #include <grpc/support/useful.h>
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -50,26 +50,26 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -82,13 +82,14 @@ static void end_test(grpc_end2end_test_fixture *f) {
 
 static void test_early_server_shutdown_finishes_inflight_calls(
     grpc_end2end_test_config config) {
-  grpc_call *c;
-  grpc_call *s;
-  grpc_end2end_test_fixture f = begin_test(
-      config, "test_early_server_shutdown_finishes_inflight_calls", NULL, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  grpc_call* c;
+  grpc_call* s;
+  grpc_end2end_test_fixture f =
+      begin_test(config, "test_early_server_shutdown_finishes_inflight_calls",
+                 nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -100,10 +101,10 @@ static void test_early_server_shutdown_finishes_inflight_calls(
 
   gpr_timespec deadline = n_seconds_from_now(10);
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -115,27 +116,27 @@ static void test_early_server_shutdown_finishes_inflight_calls(
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
-  op->data.send_initial_metadata.metadata = NULL;
+  op->data.send_initial_metadata.metadata = nullptr;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -154,7 +155,7 @@ static void test_early_server_shutdown_finishes_inflight_calls(
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -162,14 +163,14 @@ static void test_early_server_shutdown_finishes_inflight_calls(
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
diff --git a/test/core/end2end/tests/high_initial_seqno.c b/test/core/end2end/tests/high_initial_seqno.cc
index 04b94838bb..d390a954e5 100644
--- a/test/core/end2end/tests/high_initial_seqno.c
+++ b/test/core/end2end/tests/high_initial_seqno.cc
@@ -32,12 +32,12 @@
 #include "src/core/lib/support/string.h"
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -54,31 +54,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -90,11 +90,11 @@ static void end_test(grpc_end2end_test_fixture *f) {
 
 static void simple_request_body(grpc_end2end_test_config config,
                                 grpc_end2end_test_fixture f) {
-  grpc_call *c;
-  grpc_call *s;
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  grpc_call* c;
+  grpc_call* s;
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -106,10 +106,10 @@ static void simple_request_body(grpc_end2end_test_config config,
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -122,25 +122,25 @@ static void simple_request_body(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -155,7 +155,7 @@ static void simple_request_body(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -163,14 +163,14 @@ static void simple_request_body(grpc_end2end_test_config config,
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -208,10 +208,10 @@ static void test_invoke_10_simple_requests(grpc_end2end_test_config config,
   grpc_end2end_test_fixture f;
   grpc_arg client_arg;
   grpc_channel_args client_args;
-  char *name;
+  char* name;
 
   client_arg.type = GRPC_ARG_INTEGER;
-  client_arg.key = GRPC_ARG_HTTP2_INITIAL_SEQUENCE_NUMBER;
+  client_arg.key = const_cast<char*>(GRPC_ARG_HTTP2_INITIAL_SEQUENCE_NUMBER);
   client_arg.value.integer = initial_sequence_number;
 
   client_args.num_args = 1;
@@ -219,7 +219,7 @@ static void test_invoke_10_simple_requests(grpc_end2end_test_config config,
 
   gpr_asprintf(&name, "test_invoke_requests first_seqno=%d",
                initial_sequence_number);
-  f = begin_test(config, name, &client_args, NULL);
+  f = begin_test(config, name, &client_args, nullptr);
   for (i = 0; i < 10; i++) {
     simple_request_body(config, f);
     gpr_log(GPR_INFO, "Running test: Passed simple request %d", i);
diff --git a/test/core/end2end/tests/hpack_size.c b/test/core/end2end/tests/hpack_size.cc
index 9358c119b1..7ac5fefa22 100644
--- a/test/core/end2end/tests/hpack_size.c
+++ b/test/core/end2end/tests/hpack_size.cc
@@ -32,9 +32,9 @@
 #include "src/core/lib/support/string.h"
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
-const char *hobbits[][2] = {
+const char* hobbits[][2] = {
     {"Adaldrida", "Brandybuck"}, {"Adamanta", "Took"},
     {"Adalgrim", "Took"},        {"Adelard", "Took"},
     {"Amaranth", "Brandybuck"},  {"Andwise", "Roper"},
@@ -171,13 +171,13 @@ const char *hobbits[][2] = {
     {"Wiseman", "Gamwich"}*/
 };
 
-const char *dragons[] = {"Ancalagon", "Glaurung", "Scatha",
+const char* dragons[] = {"Ancalagon", "Glaurung", "Scatha",
                          "Smaug the Magnificent"};
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -194,31 +194,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -230,11 +230,11 @@ static void end_test(grpc_end2end_test_fixture *f) {
 
 static void simple_request_body(grpc_end2end_test_config config,
                                 grpc_end2end_test_fixture f, size_t index) {
-  grpc_call *c;
-  grpc_call *s;
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  grpc_call* c;
+  grpc_call* s;
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -258,10 +258,10 @@ static void simple_request_body(grpc_end2end_test_config config,
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -275,25 +275,25 @@ static void simple_request_body(grpc_end2end_test_config config,
   op->data.send_initial_metadata.count = GPR_ARRAY_SIZE(extra_metadata);
   op->data.send_initial_metadata.metadata = extra_metadata;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -308,7 +308,7 @@ static void simple_request_body(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -316,14 +316,14 @@ static void simple_request_body(grpc_end2end_test_config config,
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -357,23 +357,23 @@ static void test_size(grpc_end2end_test_config config, int encode_size,
   grpc_channel_args server_args;
   grpc_arg client_arg;
   grpc_channel_args client_args;
-  char *name;
+  char* name;
 
   server_arg.type = GRPC_ARG_INTEGER;
-  server_arg.key = GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_DECODER;
+  server_arg.key = const_cast<char*>(GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_DECODER);
   server_arg.value.integer = decode_size;
   server_args.num_args = 1;
   server_args.args = &server_arg;
 
   client_arg.type = GRPC_ARG_INTEGER;
-  client_arg.key = GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_ENCODER;
+  client_arg.key = const_cast<char*>(GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_ENCODER);
   client_arg.value.integer = encode_size;
   client_args.num_args = 1;
   client_args.args = &client_arg;
 
   gpr_asprintf(&name, "test_size:e=%d:d=%d", encode_size, decode_size);
-  f = begin_test(config, name, encode_size != 4096 ? &client_args : NULL,
-                 decode_size != 4096 ? &server_args : NULL);
+  f = begin_test(config, name, encode_size != 4096 ? &client_args : nullptr,
+                 decode_size != 4096 ? &server_args : nullptr);
   for (i = 0; i < 4 * GPR_ARRAY_SIZE(hobbits); i++) {
     simple_request_body(config, f, i);
   }
diff --git a/test/core/end2end/tests/idempotent_request.c b/test/core/end2end/tests/idempotent_request.cc
index 829ece6631..e39975382a 100644
--- a/test/core/end2end/tests/idempotent_request.c
+++ b/test/core/end2end/tests/idempotent_request.cc
@@ -30,12 +30,12 @@
 #include "src/core/lib/support/string.h"
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -52,31 +52,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -88,11 +88,11 @@ static void end_test(grpc_end2end_test_fixture *f) {
 
 static void simple_request_body(grpc_end2end_test_config config,
                                 grpc_end2end_test_fixture f) {
-  grpc_call *c;
-  grpc_call *s;
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  grpc_call* c;
+  grpc_call* s;
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -101,18 +101,18 @@ static void simple_request_body(grpc_end2end_test_config config,
   grpc_call_error error;
   grpc_slice details;
   int was_cancelled = 2;
-  char *peer;
+  char* peer;
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   peer = grpc_call_get_peer(c);
-  GPR_ASSERT(peer != NULL);
+  GPR_ASSERT(peer != nullptr);
   gpr_log(GPR_DEBUG, "client_peer_before_call=%s", peer);
   gpr_free(peer);
 
@@ -126,25 +126,25 @@ static void simple_request_body(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -155,11 +155,11 @@ static void simple_request_body(grpc_end2end_test_config config,
   cq_verify(cqv);
 
   peer = grpc_call_get_peer(s);
-  GPR_ASSERT(peer != NULL);
+  GPR_ASSERT(peer != nullptr);
   gpr_log(GPR_DEBUG, "server_peer=%s", peer);
   gpr_free(peer);
   peer = grpc_call_get_peer(c);
-  GPR_ASSERT(peer != NULL);
+  GPR_ASSERT(peer != nullptr);
   gpr_log(GPR_DEBUG, "client_peer=%s", peer);
   gpr_free(peer);
 
@@ -168,7 +168,7 @@ static void simple_request_body(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -176,14 +176,14 @@ static void simple_request_body(grpc_end2end_test_config config,
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -213,7 +213,7 @@ static void simple_request_body(grpc_end2end_test_config config,
 static void test_invoke_simple_request(grpc_end2end_test_config config) {
   grpc_end2end_test_fixture f;
 
-  f = begin_test(config, "test_invoke_simple_request", NULL, NULL);
+  f = begin_test(config, "test_invoke_simple_request", nullptr, nullptr);
   simple_request_body(config, f);
   end_test(&f);
   config.tear_down_data(&f);
@@ -222,7 +222,7 @@ static void test_invoke_simple_request(grpc_end2end_test_config config) {
 static void test_invoke_10_simple_requests(grpc_end2end_test_config config) {
   int i;
   grpc_end2end_test_fixture f =
-      begin_test(config, "test_invoke_10_simple_requests", NULL, NULL);
+      begin_test(config, "test_invoke_10_simple_requests", nullptr, nullptr);
   for (i = 0; i < 10; i++) {
     simple_request_body(config, f);
     gpr_log(GPR_INFO, "Passed simple request %d", i);
diff --git a/test/core/end2end/tests/invoke_large_request.c b/test/core/end2end/tests/invoke_large_request.cc
index ff269fa3ee..8a67e3c2b1 100644
--- a/test/core/end2end/tests/invoke_large_request.c
+++ b/test/core/end2end/tests/invoke_large_request.cc
@@ -29,12 +29,12 @@
 #include <grpc/support/useful.h>
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -47,31 +47,31 @@ static gpr_timespec n_seconds_from_now(int n) {
   return grpc_timeout_seconds_to_deadline(n);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, n_seconds_from_now(5), NULL);
+    ev = grpc_completion_queue_next(cq, n_seconds_from_now(5), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -89,17 +89,17 @@ static grpc_slice large_slice(void) {
 
 static void test_invoke_large_request(grpc_end2end_test_config config,
                                       int max_frame_size, int lookahead_bytes) {
-  char *name;
+  char* name;
   gpr_asprintf(&name,
                "test_invoke_large_request:max_frame_size=%d:lookahead_bytes=%d",
                max_frame_size, lookahead_bytes);
 
   grpc_arg args[2];
   args[0].type = GRPC_ARG_INTEGER;
-  args[0].key = GRPC_ARG_HTTP2_MAX_FRAME_SIZE;
+  args[0].key = const_cast<char*>(GRPC_ARG_HTTP2_MAX_FRAME_SIZE);
   args[0].value.integer = max_frame_size;
   args[1].type = GRPC_ARG_INTEGER;
-  args[1].key = GRPC_ARG_HTTP2_STREAM_LOOKAHEAD_BYTES;
+  args[1].key = const_cast<char*>(GRPC_ARG_HTTP2_STREAM_LOOKAHEAD_BYTES);
   args[1].value.integer = lookahead_bytes;
   grpc_channel_args channel_args = {GPR_ARRAY_SIZE(args), args};
 
@@ -109,20 +109,20 @@ static void test_invoke_large_request(grpc_end2end_test_config config,
 
   grpc_slice request_payload_slice = large_slice();
   grpc_slice response_payload_slice = large_slice();
-  grpc_call *c;
-  grpc_call *s;
-  grpc_byte_buffer *request_payload =
+  grpc_call* c;
+  grpc_call* s;
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
-  grpc_byte_buffer *response_payload =
+  grpc_byte_buffer* response_payload =
       grpc_raw_byte_buffer_create(&response_payload_slice, 1);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *request_payload_recv = NULL;
-  grpc_byte_buffer *response_payload_recv = NULL;
+  grpc_byte_buffer* request_payload_recv = nullptr;
+  grpc_byte_buffer* response_payload_recv = nullptr;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
@@ -131,10 +131,10 @@ static void test_invoke_large_request(grpc_end2end_test_config config,
 
   gpr_timespec deadline = n_seconds_from_now(30);
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -147,35 +147,35 @@ static void test_invoke_large_request(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &response_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -190,14 +190,14 @@ static void test_invoke_large_request(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &request_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -208,12 +208,12 @@ static void test_invoke_large_request(grpc_end2end_test_config config,
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = response_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -221,9 +221,9 @@ static void test_invoke_large_request(grpc_end2end_test_config config,
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(103), 1);
diff --git a/test/core/end2end/tests/keepalive_timeout.c b/test/core/end2end/tests/keepalive_timeout.cc
index 0053368ecc..822565510f 100644
--- a/test/core/end2end/tests/keepalive_timeout.c
+++ b/test/core/end2end/tests/keepalive_timeout.cc
@@ -32,12 +32,12 @@
 #include "src/core/lib/support/env.h"
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "%s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -54,31 +54,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
 
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
-                                         five_seconds_from_now(), NULL)
+                                         five_seconds_from_now(), nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -91,35 +91,35 @@ static void end_test(grpc_end2end_test_fixture *f) {
 /* Client sends a request, server replies with a payload, then waits for the
    keepalive watchdog timeouts before returning status. */
 static void test_keepalive_timeout(grpc_end2end_test_config config) {
-  grpc_call *c;
-  grpc_call *s;
+  grpc_call* c;
+  grpc_call* s;
   grpc_slice response_payload_slice =
       grpc_slice_from_copied_string("hello world");
-  grpc_byte_buffer *response_payload =
+  grpc_byte_buffer* response_payload =
       grpc_raw_byte_buffer_create(&response_payload_slice, 1);
 
-  grpc_arg keepalive_arg_elems[] = {{.type = GRPC_ARG_INTEGER,
-                                     .key = GRPC_ARG_KEEPALIVE_TIME_MS,
-                                     .value.integer = 1500},
-                                    {.type = GRPC_ARG_INTEGER,
-                                     .key = GRPC_ARG_KEEPALIVE_TIMEOUT_MS,
-                                     .value.integer = 0},
-                                    {.type = GRPC_ARG_INTEGER,
-                                     .key = GRPC_ARG_HTTP2_BDP_PROBE,
-                                     .value.integer = 0}};
-  grpc_channel_args keepalive_args = {
-      .num_args = GPR_ARRAY_SIZE(keepalive_arg_elems),
-      .args = keepalive_arg_elems};
+  grpc_arg keepalive_arg_elems[3];
+  keepalive_arg_elems[0].type = GRPC_ARG_INTEGER;
+  keepalive_arg_elems[0].key = const_cast<char*>(GRPC_ARG_KEEPALIVE_TIME_MS);
+  keepalive_arg_elems[0].value.integer = 1500;
+  keepalive_arg_elems[1].type = GRPC_ARG_INTEGER;
+  keepalive_arg_elems[1].key = const_cast<char*>(GRPC_ARG_KEEPALIVE_TIMEOUT_MS);
+  keepalive_arg_elems[1].value.integer = 0;
+  keepalive_arg_elems[2].type = GRPC_ARG_INTEGER;
+  keepalive_arg_elems[2].key = const_cast<char*>(GRPC_ARG_HTTP2_BDP_PROBE);
+  keepalive_arg_elems[2].value.integer = 0;
+  grpc_channel_args keepalive_args = {GPR_ARRAY_SIZE(keepalive_arg_elems),
+                                      keepalive_arg_elems};
 
   grpc_end2end_test_fixture f =
-      begin_test(config, "keepalive_timeout", &keepalive_args, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+      begin_test(config, "keepalive_timeout", &keepalive_args, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *response_payload_recv = NULL;
+  grpc_byte_buffer* response_payload_recv = nullptr;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
@@ -130,10 +130,10 @@ static void test_keepalive_timeout(grpc_end2end_test_config config) {
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -154,7 +154,7 @@ static void test_keepalive_timeout(grpc_end2end_test_config config) {
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &response_payload_recv;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(
@@ -171,7 +171,7 @@ static void test_keepalive_timeout(grpc_end2end_test_config config) {
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = response_payload;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -185,14 +185,14 @@ static void test_keepalive_timeout(grpc_end2end_test_config config) {
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(3), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(3), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(3), 1);
   cq_verify(cqv);
 
-  char *details_str = grpc_slice_to_c_string(details);
-  char *method_str = grpc_slice_to_c_string(call_details.method);
+  char* details_str = grpc_slice_to_c_string(details);
+  char* method_str = grpc_slice_to_c_string(call_details.method);
   GPR_ASSERT(status == GRPC_STATUS_INTERNAL);
   GPR_ASSERT(0 == grpc_slice_str_cmp(details, "keepalive watchdog timeout"));
   GPR_ASSERT(0 == grpc_slice_str_cmp(call_details.method, "/foo"));
diff --git a/test/core/end2end/tests/large_metadata.c b/test/core/end2end/tests/large_metadata.cc
index 81a45d827a..8ddf433ac0 100644
--- a/test/core/end2end/tests/large_metadata.c
+++ b/test/core/end2end/tests/large_metadata.cc
@@ -28,12 +28,12 @@
 #include <grpc/support/useful.h>
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -50,31 +50,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -86,27 +86,28 @@ static void end_test(grpc_end2end_test_fixture *f) {
 
 // Request with a large amount of metadata.
 static void test_request_with_large_metadata(grpc_end2end_test_config config) {
-  grpc_call *c;
-  grpc_call *s;
+  grpc_call* c;
+  grpc_call* s;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
-  grpc_byte_buffer *request_payload =
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
   grpc_metadata meta;
   const size_t large_size = 64 * 1024;
-  grpc_arg arg = {GRPC_ARG_INTEGER,
-                  GRPC_ARG_MAX_METADATA_SIZE,
-                  {.integer = (int)large_size + 1024}};
+  grpc_arg arg;
+  arg.type = GRPC_ARG_INTEGER;
+  arg.key = const_cast<char*>(GRPC_ARG_MAX_METADATA_SIZE);
+  arg.value.integer = (int)large_size + 1024;
   grpc_channel_args args = {1, &arg};
   grpc_end2end_test_fixture f =
       begin_test(config, "test_request_with_large_metadata", &args, &args);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *request_payload_recv = NULL;
+  grpc_byte_buffer* request_payload_recv = nullptr;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
@@ -115,10 +116,10 @@ static void test_request_with_large_metadata(grpc_end2end_test_config config) {
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   meta.key = grpc_slice_from_static_string("key");
@@ -137,30 +138,30 @@ static void test_request_with_large_metadata(grpc_end2end_test_config config) {
   op->data.send_initial_metadata.count = 1;
   op->data.send_initial_metadata.metadata = &meta;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -177,14 +178,14 @@ static void test_request_with_large_metadata(grpc_end2end_test_config config) {
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &request_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -197,7 +198,7 @@ static void test_request_with_large_metadata(grpc_end2end_test_config config) {
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -205,9 +206,9 @@ static void test_request_with_large_metadata(grpc_end2end_test_config config) {
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(103), 1);
diff --git a/test/core/end2end/tests/load_reporting_hook.c b/test/core/end2end/tests/load_reporting_hook.cc
index 7b503790db..faabec34cb 100644
--- a/test/core/end2end/tests/load_reporting_hook.c
+++ b/test/core/end2end/tests/load_reporting_hook.cc
@@ -36,16 +36,16 @@
 
 enum { TIMEOUT = 200000 };
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 typedef struct {
   gpr_mu mu;
   intptr_t channel_id;
   intptr_t call_id;
 
-  char *initial_md_str;
-  char *trailing_md_str;
-  char *method_name;
+  char* initial_md_str;
+  char* trailing_md_str;
+  char* method_name;
 
   uint64_t incoming_bytes;
   uint64_t outgoing_bytes;
@@ -56,9 +56,9 @@ typedef struct {
 } load_reporting_data;
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
 
@@ -77,31 +77,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -113,25 +113,25 @@ static void end_test(grpc_end2end_test_fixture *f) {
 
 static void request_response_with_payload(
     grpc_end2end_test_config config, grpc_end2end_test_fixture f,
-    const char *method_name, const char *request_msg, const char *response_msg,
-    grpc_metadata *initial_lr_metadata, grpc_metadata *trailing_lr_metadata) {
+    const char* method_name, const char* request_msg, const char* response_msg,
+    grpc_metadata* initial_lr_metadata, grpc_metadata* trailing_lr_metadata) {
   grpc_slice request_payload_slice = grpc_slice_from_static_string(request_msg);
   grpc_slice response_payload_slice =
       grpc_slice_from_static_string(response_msg);
-  grpc_call *c;
-  grpc_call *s;
-  grpc_byte_buffer *request_payload =
+  grpc_call* c;
+  grpc_call* s;
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
-  grpc_byte_buffer *response_payload =
+  grpc_byte_buffer* response_payload =
       grpc_raw_byte_buffer_create(&response_payload_slice, 1);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *request_payload_recv = NULL;
-  grpc_byte_buffer *response_payload_recv = NULL;
+  grpc_byte_buffer* request_payload_recv = nullptr;
+  grpc_byte_buffer* response_payload_recv = nullptr;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
@@ -140,10 +140,10 @@ static void request_response_with_payload(
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string(method_name),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -154,39 +154,39 @@ static void request_response_with_payload(
   memset(ops, 0, sizeof(ops));
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
-  GPR_ASSERT(initial_lr_metadata != NULL);
+  GPR_ASSERT(initial_lr_metadata != nullptr);
   op->data.send_initial_metadata.count = 1;
   op->data.send_initial_metadata.metadata = initial_lr_metadata;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &response_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -201,14 +201,14 @@ static void request_response_with_payload(
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &request_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -219,24 +219,24 @@ static void request_response_with_payload(
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = response_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
-  GPR_ASSERT(trailing_lr_metadata != NULL);
+  GPR_ASSERT(trailing_lr_metadata != nullptr);
   op->data.send_status_from_server.trailing_metadata_count = 1;
   op->data.send_status_from_server.trailing_metadata = trailing_lr_metadata;
   op->data.send_status_from_server.status = GRPC_STATUS_OK;
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(103), 1);
@@ -264,7 +264,7 @@ static void request_response_with_payload(
 
 /* override the default for testing purposes */
 extern void (*g_load_reporting_fn)(
-    const grpc_load_reporting_call_data *call_data);
+    const grpc_load_reporting_call_data* call_data);
 
 static void test_load_reporting_hook(grpc_end2end_test_config config) {
   /* TODO(dgq): this test is currently a noop until LR is fully defined.
@@ -272,15 +272,15 @@ static void test_load_reporting_hook(grpc_end2end_test_config config) {
 
   /* Introduce load reporting for the server through its arguments */
   grpc_arg arg = grpc_load_reporting_enable_arg();
-  grpc_channel_args *lr_server_args =
-      grpc_channel_args_copy_and_add(NULL, &arg, 1);
+  grpc_channel_args* lr_server_args =
+      grpc_channel_args_copy_and_add(nullptr, &arg, 1);
 
   grpc_end2end_test_fixture f =
-      begin_test(config, "test_load_reporting_hook", NULL, lr_server_args);
+      begin_test(config, "test_load_reporting_hook", nullptr, lr_server_args);
 
-  const char *method_name = "/gRPCFTW";
-  const char *request_msg = "the msg from the client";
-  const char *response_msg = "... and the response from the server";
+  const char* method_name = "/gRPCFTW";
+  const char* request_msg = "the msg from the client";
+  const char* response_msg = "... and the response from the server";
 
   grpc_metadata initial_lr_metadata;
   grpc_metadata trailing_lr_metadata;
diff --git a/test/core/end2end/tests/max_concurrent_streams.c b/test/core/end2end/tests/max_concurrent_streams.cc
index d18c13997c..c0539739e1 100644
--- a/test/core/end2end/tests/max_concurrent_streams.c
+++ b/test/core/end2end/tests/max_concurrent_streams.cc
@@ -28,12 +28,12 @@
 #include <grpc/support/useful.h>
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -50,31 +50,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -86,11 +86,11 @@ static void end_test(grpc_end2end_test_fixture *f) {
 
 static void simple_request_body(grpc_end2end_test_config config,
                                 grpc_end2end_test_fixture f) {
-  grpc_call *c;
-  grpc_call *s;
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  grpc_call* c;
+  grpc_call* s;
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -102,10 +102,10 @@ static void simple_request_body(grpc_end2end_test_config config,
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -118,25 +118,25 @@ static void simple_request_body(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -151,7 +151,7 @@ static void simple_request_body(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -159,14 +159,14 @@ static void simple_request_body(grpc_end2end_test_config config,
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -196,13 +196,13 @@ static void test_max_concurrent_streams(grpc_end2end_test_config config) {
   grpc_end2end_test_fixture f;
   grpc_arg server_arg;
   grpc_channel_args server_args;
-  grpc_call *c1;
-  grpc_call *c2;
-  grpc_call *s1;
-  grpc_call *s2;
+  grpc_call* c1;
+  grpc_call* c2;
+  grpc_call* s1;
+  grpc_call* s2;
   int live_call;
   gpr_timespec deadline;
-  cq_verifier *cqv;
+  cq_verifier* cqv;
   grpc_event ev;
   grpc_call_details call_details;
   grpc_metadata_array request_metadata_recv;
@@ -216,19 +216,19 @@ static void test_max_concurrent_streams(grpc_end2end_test_config config) {
   grpc_status_code status2;
   grpc_slice details2;
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   int was_cancelled;
   int got_client_start;
   int got_server_start;
 
-  server_arg.key = GRPC_ARG_MAX_CONCURRENT_STREAMS;
+  server_arg.key = const_cast<char*>(GRPC_ARG_MAX_CONCURRENT_STREAMS);
   server_arg.type = GRPC_ARG_INTEGER;
   server_arg.value.integer = 1;
 
   server_args.num_args = 1;
   server_args.args = &server_arg;
 
-  f = begin_test(config, "test_max_concurrent_streams", NULL, &server_args);
+  f = begin_test(config, "test_max_concurrent_streams", nullptr, &server_args);
   cqv = cq_verifier_create(f.cq);
 
   grpc_metadata_array_init(&request_metadata_recv);
@@ -248,16 +248,16 @@ static void test_max_concurrent_streams(grpc_end2end_test_config config) {
      the first completes */
   deadline = n_seconds_from_now(1000);
   c1 = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/alpha"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c1);
   c2 = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/beta"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c2);
 
   GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(
@@ -269,13 +269,13 @@ static void test_max_concurrent_streams(grpc_end2end_test_config config) {
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c1, ops, (size_t)(op - ops), tag(301), NULL);
+  error = grpc_call_start_batch(c1, ops, (size_t)(op - ops), tag(301), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   memset(ops, 0, sizeof(ops));
@@ -285,15 +285,15 @@ static void test_max_concurrent_streams(grpc_end2end_test_config config) {
   op->data.recv_status_on_client.status = &status1;
   op->data.recv_status_on_client.status_details = &details1;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata =
       &initial_metadata_recv1;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c1, ops, (size_t)(op - ops), tag(302), NULL);
+  error = grpc_call_start_batch(c1, ops, (size_t)(op - ops), tag(302), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   memset(ops, 0, sizeof(ops));
@@ -301,13 +301,13 @@ static void test_max_concurrent_streams(grpc_end2end_test_config config) {
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c2, ops, (size_t)(op - ops), tag(401), NULL);
+  error = grpc_call_start_batch(c2, ops, (size_t)(op - ops), tag(401), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   memset(ops, 0, sizeof(ops));
@@ -317,15 +317,15 @@ static void test_max_concurrent_streams(grpc_end2end_test_config config) {
   op->data.recv_status_on_client.status = &status2;
   op->data.recv_status_on_client.status_details = &details2;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata =
       &initial_metadata_recv1;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c2, ops, (size_t)(op - ops), tag(402), NULL);
+  error = grpc_call_start_batch(c2, ops, (size_t)(op - ops), tag(402), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   got_client_start = 0;
@@ -333,7 +333,7 @@ static void test_max_concurrent_streams(grpc_end2end_test_config config) {
   live_call = -1;
   while (!got_client_start || !got_server_start) {
     ev = grpc_completion_queue_next(f.cq, grpc_timeout_seconds_to_deadline(3),
-                                    NULL);
+                                    nullptr);
     GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
     GPR_ASSERT(ev.success);
     if (ev.tag == tag(101)) {
@@ -357,12 +357,12 @@ static void test_max_concurrent_streams(grpc_end2end_test_config config) {
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -370,9 +370,9 @@ static void test_max_concurrent_streams(grpc_end2end_test_config config) {
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s1, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s1, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -395,21 +395,21 @@ static void test_max_concurrent_streams(grpc_end2end_test_config config) {
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
   op->data.send_status_from_server.status = GRPC_STATUS_UNIMPLEMENTED;
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s2, ops, (size_t)(op - ops), tag(202), NULL);
+  error = grpc_call_start_batch(s2, ops, (size_t)(op - ops), tag(202), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(live_call + 2), 1);
@@ -441,11 +441,11 @@ static void test_max_concurrent_streams_with_timeout_on_first(
   grpc_end2end_test_fixture f;
   grpc_arg server_arg;
   grpc_channel_args server_args;
-  grpc_call *c1;
-  grpc_call *c2;
-  grpc_call *s1;
-  grpc_call *s2;
-  cq_verifier *cqv;
+  grpc_call* c1;
+  grpc_call* c2;
+  grpc_call* s1;
+  grpc_call* s2;
+  cq_verifier* cqv;
   grpc_call_details call_details;
   grpc_metadata_array request_metadata_recv;
   grpc_metadata_array initial_metadata_recv1;
@@ -458,10 +458,10 @@ static void test_max_concurrent_streams_with_timeout_on_first(
   grpc_status_code status2;
   grpc_slice details2 = grpc_empty_slice();
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   int was_cancelled;
 
-  server_arg.key = GRPC_ARG_MAX_CONCURRENT_STREAMS;
+  server_arg.key = const_cast<char*>(GRPC_ARG_MAX_CONCURRENT_STREAMS);
   server_arg.type = GRPC_ARG_INTEGER;
   server_arg.value.integer = 1;
 
@@ -469,7 +469,7 @@ static void test_max_concurrent_streams_with_timeout_on_first(
   server_args.args = &server_arg;
 
   f = begin_test(config, "test_max_concurrent_streams_with_timeout_on_first",
-                 NULL, &server_args);
+                 nullptr, &server_args);
   cqv = cq_verifier_create(f.cq);
 
   grpc_metadata_array_init(&request_metadata_recv);
@@ -488,16 +488,16 @@ static void test_max_concurrent_streams_with_timeout_on_first(
   /* start two requests - ensuring that the second is not accepted until
      the first completes */
   c1 = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/alpha"),
       get_host_override_slice("foo.test.google.fr:1234", config),
-      n_seconds_from_now(3), NULL);
+      n_seconds_from_now(3), nullptr);
   GPR_ASSERT(c1);
   c2 = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/beta"),
       get_host_override_slice("foo.test.google.fr:1234", config),
-      n_seconds_from_now(1000), NULL);
+      n_seconds_from_now(1000), nullptr);
   GPR_ASSERT(c2);
 
   GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(
@@ -509,13 +509,13 @@ static void test_max_concurrent_streams_with_timeout_on_first(
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c1, ops, (size_t)(op - ops), tag(301), NULL);
+  error = grpc_call_start_batch(c1, ops, (size_t)(op - ops), tag(301), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   memset(ops, 0, sizeof(ops));
@@ -525,15 +525,15 @@ static void test_max_concurrent_streams_with_timeout_on_first(
   op->data.recv_status_on_client.status = &status1;
   op->data.recv_status_on_client.status_details = &details1;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata =
       &initial_metadata_recv1;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c1, ops, (size_t)(op - ops), tag(302), NULL);
+  error = grpc_call_start_batch(c1, ops, (size_t)(op - ops), tag(302), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(101), 1);
@@ -545,13 +545,13 @@ static void test_max_concurrent_streams_with_timeout_on_first(
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c2, ops, (size_t)(op - ops), tag(401), NULL);
+  error = grpc_call_start_batch(c2, ops, (size_t)(op - ops), tag(401), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   memset(ops, 0, sizeof(ops));
@@ -561,15 +561,15 @@ static void test_max_concurrent_streams_with_timeout_on_first(
   op->data.recv_status_on_client.status = &status2;
   op->data.recv_status_on_client.status_details = &details2;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata =
       &initial_metadata_recv2;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c2, ops, (size_t)(op - ops), tag(402), NULL);
+  error = grpc_call_start_batch(c2, ops, (size_t)(op - ops), tag(402), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   grpc_call_details_destroy(&call_details);
@@ -589,12 +589,12 @@ static void test_max_concurrent_streams_with_timeout_on_first(
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -602,9 +602,9 @@ static void test_max_concurrent_streams_with_timeout_on_first(
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s2, ops, (size_t)(op - ops), tag(202), NULL);
+  error = grpc_call_start_batch(s2, ops, (size_t)(op - ops), tag(202), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(402), 1);
@@ -636,10 +636,10 @@ static void test_max_concurrent_streams_with_timeout_on_second(
   grpc_end2end_test_fixture f;
   grpc_arg server_arg;
   grpc_channel_args server_args;
-  grpc_call *c1;
-  grpc_call *c2;
-  grpc_call *s1;
-  cq_verifier *cqv;
+  grpc_call* c1;
+  grpc_call* c2;
+  grpc_call* s1;
+  cq_verifier* cqv;
   grpc_call_details call_details;
   grpc_metadata_array request_metadata_recv;
   grpc_metadata_array initial_metadata_recv1;
@@ -652,10 +652,10 @@ static void test_max_concurrent_streams_with_timeout_on_second(
   grpc_status_code status2;
   grpc_slice details2 = grpc_empty_slice();
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   int was_cancelled;
 
-  server_arg.key = GRPC_ARG_MAX_CONCURRENT_STREAMS;
+  server_arg.key = const_cast<char*>(GRPC_ARG_MAX_CONCURRENT_STREAMS);
   server_arg.type = GRPC_ARG_INTEGER;
   server_arg.value.integer = 1;
 
@@ -663,7 +663,7 @@ static void test_max_concurrent_streams_with_timeout_on_second(
   server_args.args = &server_arg;
 
   f = begin_test(config, "test_max_concurrent_streams_with_timeout_on_second",
-                 NULL, &server_args);
+                 nullptr, &server_args);
   cqv = cq_verifier_create(f.cq);
 
   grpc_metadata_array_init(&request_metadata_recv);
@@ -683,16 +683,16 @@ static void test_max_concurrent_streams_with_timeout_on_second(
      the first completes , and the second request will timeout in the
      concurrent_list */
   c1 = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/alpha"),
       get_host_override_slice("foo.test.google.fr:1234", config),
-      n_seconds_from_now(1000), NULL);
+      n_seconds_from_now(1000), nullptr);
   GPR_ASSERT(c1);
   c2 = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/beta"),
       get_host_override_slice("foo.test.google.fr:1234", config),
-      n_seconds_from_now(3), NULL);
+      n_seconds_from_now(3), nullptr);
   GPR_ASSERT(c2);
 
   GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(
@@ -704,13 +704,13 @@ static void test_max_concurrent_streams_with_timeout_on_second(
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c1, ops, (size_t)(op - ops), tag(301), NULL);
+  error = grpc_call_start_batch(c1, ops, (size_t)(op - ops), tag(301), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   memset(ops, 0, sizeof(ops));
@@ -720,15 +720,15 @@ static void test_max_concurrent_streams_with_timeout_on_second(
   op->data.recv_status_on_client.status = &status1;
   op->data.recv_status_on_client.status_details = &details1;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata =
       &initial_metadata_recv1;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c1, ops, (size_t)(op - ops), tag(302), NULL);
+  error = grpc_call_start_batch(c1, ops, (size_t)(op - ops), tag(302), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(101), 1);
@@ -740,13 +740,13 @@ static void test_max_concurrent_streams_with_timeout_on_second(
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c2, ops, (size_t)(op - ops), tag(401), NULL);
+  error = grpc_call_start_batch(c2, ops, (size_t)(op - ops), tag(401), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   memset(ops, 0, sizeof(ops));
@@ -756,15 +756,15 @@ static void test_max_concurrent_streams_with_timeout_on_second(
   op->data.recv_status_on_client.status = &status2;
   op->data.recv_status_on_client.status_details = &details2;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata =
       &initial_metadata_recv2;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c2, ops, (size_t)(op - ops), tag(402), NULL);
+  error = grpc_call_start_batch(c2, ops, (size_t)(op - ops), tag(402), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   /* the second request is time out*/
@@ -782,12 +782,12 @@ static void test_max_concurrent_streams_with_timeout_on_second(
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -795,9 +795,9 @@ static void test_max_concurrent_streams_with_timeout_on_second(
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s1, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s1, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(302), 1);
diff --git a/test/core/end2end/tests/max_connection_age.c b/test/core/end2end/tests/max_connection_age.cc
index b6daa59d7b..ddccfc3b51 100644
--- a/test/core/end2end/tests/max_connection_age.c
+++ b/test/core/end2end/tests/max_connection_age.cc
@@ -45,29 +45,29 @@
 /* The grace period for the test to observe the channel shutdown process */
 #define IMMEDIATE_SHUTDOWN_GRACE_TIME_MS 3000
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
     ev = grpc_completion_queue_next(cq, grpc_timeout_seconds_to_deadline(5),
-                                    NULL);
+                                    nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -78,28 +78,28 @@ static void end_test(grpc_end2end_test_fixture *f) {
 }
 
 static void test_max_age_forcibly_close(grpc_end2end_test_config config) {
-  grpc_end2end_test_fixture f = config.create_fixture(NULL, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
-  grpc_arg server_a[] = {{.type = GRPC_ARG_INTEGER,
-                          .key = GRPC_ARG_MAX_CONNECTION_AGE_MS,
-                          .value.integer = MAX_CONNECTION_AGE_MS},
-                         {.type = GRPC_ARG_INTEGER,
-                          .key = GRPC_ARG_MAX_CONNECTION_AGE_GRACE_MS,
-                          .value.integer = MAX_CONNECTION_AGE_GRACE_MS},
-                         {.type = GRPC_ARG_INTEGER,
-                          .key = GRPC_ARG_MAX_CONNECTION_IDLE_MS,
-                          .value.integer = MAX_CONNECTION_IDLE_MS}};
-  grpc_channel_args server_args = {.num_args = GPR_ARRAY_SIZE(server_a),
-                                   .args = server_a};
-
-  config.init_client(&f, NULL);
+  grpc_end2end_test_fixture f = config.create_fixture(nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
+  grpc_arg server_a[3];
+  server_a[0].type = GRPC_ARG_INTEGER;
+  server_a[0].key = const_cast<char*>(GRPC_ARG_MAX_CONNECTION_AGE_MS);
+  server_a[0].value.integer = MAX_CONNECTION_AGE_MS;
+  server_a[1].type = GRPC_ARG_INTEGER;
+  server_a[1].key = const_cast<char*>(GRPC_ARG_MAX_CONNECTION_AGE_GRACE_MS);
+  server_a[1].value.integer = MAX_CONNECTION_AGE_GRACE_MS;
+  server_a[2].type = GRPC_ARG_INTEGER;
+  server_a[2].key = const_cast<char*>(GRPC_ARG_MAX_CONNECTION_IDLE_MS);
+  server_a[2].value.integer = MAX_CONNECTION_IDLE_MS;
+  grpc_channel_args server_args = {GPR_ARRAY_SIZE(server_a), server_a};
+
+  config.init_client(&f, nullptr);
   config.init_server(&f, &server_args);
 
-  grpc_call *c;
-  grpc_call *s;
+  grpc_call* c;
+  grpc_call* s;
   gpr_timespec deadline = grpc_timeout_seconds_to_deadline(CALL_DEADLINE_S);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -110,10 +110,10 @@ static void test_max_age_forcibly_close(grpc_end2end_test_config config) {
   int was_cancelled = 2;
 
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -125,27 +125,27 @@ static void test_max_age_forcibly_close(grpc_end2end_test_config config) {
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
-  op->data.send_initial_metadata.metadata = NULL;
+  op->data.send_initial_metadata.metadata = nullptr;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -175,7 +175,7 @@ static void test_max_age_forcibly_close(grpc_end2end_test_config config) {
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -183,14 +183,14 @@ static void test_max_age_forcibly_close(grpc_end2end_test_config config) {
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
   CQ_EXPECT_COMPLETION(cqv, tag(102), true);
   cq_verify(cqv);
@@ -221,28 +221,28 @@ static void test_max_age_forcibly_close(grpc_end2end_test_config config) {
 }
 
 static void test_max_age_gracefully_close(grpc_end2end_test_config config) {
-  grpc_end2end_test_fixture f = config.create_fixture(NULL, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
-  grpc_arg server_a[] = {{.type = GRPC_ARG_INTEGER,
-                          .key = GRPC_ARG_MAX_CONNECTION_AGE_MS,
-                          .value.integer = MAX_CONNECTION_AGE_MS},
-                         {.type = GRPC_ARG_INTEGER,
-                          .key = GRPC_ARG_MAX_CONNECTION_AGE_GRACE_MS,
-                          .value.integer = INT_MAX},
-                         {.type = GRPC_ARG_INTEGER,
-                          .key = GRPC_ARG_MAX_CONNECTION_IDLE_MS,
-                          .value.integer = MAX_CONNECTION_IDLE_MS}};
-  grpc_channel_args server_args = {.num_args = GPR_ARRAY_SIZE(server_a),
-                                   .args = server_a};
-
-  config.init_client(&f, NULL);
+  grpc_end2end_test_fixture f = config.create_fixture(nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
+  grpc_arg server_a[3];
+  server_a[0].type = GRPC_ARG_INTEGER;
+  server_a[0].key = const_cast<char*>(GRPC_ARG_MAX_CONNECTION_AGE_MS);
+  server_a[0].value.integer = MAX_CONNECTION_AGE_MS;
+  server_a[1].type = GRPC_ARG_INTEGER;
+  server_a[1].key = const_cast<char*>(GRPC_ARG_MAX_CONNECTION_AGE_GRACE_MS);
+  server_a[1].value.integer = INT_MAX;
+  server_a[2].type = GRPC_ARG_INTEGER;
+  server_a[2].key = const_cast<char*>(GRPC_ARG_MAX_CONNECTION_IDLE_MS);
+  server_a[2].value.integer = MAX_CONNECTION_IDLE_MS;
+  grpc_channel_args server_args = {GPR_ARRAY_SIZE(server_a), server_a};
+
+  config.init_client(&f, nullptr);
   config.init_server(&f, &server_args);
 
-  grpc_call *c;
-  grpc_call *s;
+  grpc_call* c;
+  grpc_call* s;
   gpr_timespec deadline = grpc_timeout_seconds_to_deadline(CALL_DEADLINE_S);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -253,10 +253,10 @@ static void test_max_age_gracefully_close(grpc_end2end_test_config config) {
   int was_cancelled = 2;
 
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -268,27 +268,27 @@ static void test_max_age_gracefully_close(grpc_end2end_test_config config) {
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
-  op->data.send_initial_metadata.metadata = NULL;
+  op->data.send_initial_metadata.metadata = nullptr;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -310,7 +310,7 @@ static void test_max_age_gracefully_close(grpc_end2end_test_config config) {
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -318,14 +318,14 @@ static void test_max_age_gracefully_close(grpc_end2end_test_config config) {
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), true);
diff --git a/test/core/end2end/tests/max_connection_idle.c b/test/core/end2end/tests/max_connection_idle.cc
index f26b0be40e..293ff7d1f2 100644
--- a/test/core/end2end/tests/max_connection_idle.c
+++ b/test/core/end2end/tests/max_connection_idle.cc
@@ -32,23 +32,23 @@
 #define MAX_CONNECTION_IDLE_MS 500
 #define MAX_CONNECTION_AGE_MS 9999
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
     ev = grpc_completion_queue_next(cq, grpc_timeout_seconds_to_deadline(5),
-                                    NULL);
+                                    nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
 static void simple_request_body(grpc_end2end_test_config config,
-                                grpc_end2end_test_fixture *f) {
-  grpc_call *c;
-  grpc_call *s;
-  cq_verifier *cqv = cq_verifier_create(f->cq);
+                                grpc_end2end_test_fixture* f) {
+  grpc_call* c;
+  grpc_call* s;
+  cq_verifier* cqv = cq_verifier_create(f->cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -57,18 +57,18 @@ static void simple_request_body(grpc_end2end_test_config config,
   grpc_call_error error;
   grpc_slice details;
   int was_cancelled = 2;
-  char *peer;
+  char* peer;
 
   gpr_timespec deadline = grpc_timeout_seconds_to_deadline(5);
   c = grpc_channel_create_call(
-      f->client, NULL, GRPC_PROPAGATE_DEFAULTS, f->cq,
+      f->client, nullptr, GRPC_PROPAGATE_DEFAULTS, f->cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   peer = grpc_call_get_peer(c);
-  GPR_ASSERT(peer != NULL);
+  GPR_ASSERT(peer != nullptr);
   gpr_log(GPR_DEBUG, "client_peer_before_call=%s", peer);
   gpr_free(peer);
 
@@ -82,25 +82,25 @@ static void simple_request_body(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -111,11 +111,11 @@ static void simple_request_body(grpc_end2end_test_config config,
   cq_verify(cqv);
 
   peer = grpc_call_get_peer(s);
-  GPR_ASSERT(peer != NULL);
+  GPR_ASSERT(peer != nullptr);
   gpr_log(GPR_DEBUG, "server_peer=%s", peer);
   gpr_free(peer);
   peer = grpc_call_get_peer(c);
-  GPR_ASSERT(peer != NULL);
+  GPR_ASSERT(peer != nullptr);
   gpr_log(GPR_DEBUG, "client_peer=%s", peer);
   gpr_free(peer);
 
@@ -124,7 +124,7 @@ static void simple_request_body(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -132,14 +132,14 @@ static void simple_request_body(grpc_end2end_test_config config,
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -167,23 +167,24 @@ static void simple_request_body(grpc_end2end_test_config config,
 }
 
 static void test_max_connection_idle(grpc_end2end_test_config config) {
-  grpc_end2end_test_fixture f = config.create_fixture(NULL, NULL);
+  grpc_end2end_test_fixture f = config.create_fixture(nullptr, nullptr);
   grpc_connectivity_state state = GRPC_CHANNEL_IDLE;
-  cq_verifier *cqv = cq_verifier_create(f.cq);
-
-  grpc_arg client_a[] = {{.type = GRPC_ARG_INTEGER,
-                          .key = "grpc.testing.fixed_reconnect_backoff_ms",
-                          .value.integer = 1000}};
-  grpc_arg server_a[] = {{.type = GRPC_ARG_INTEGER,
-                          .key = GRPC_ARG_MAX_CONNECTION_IDLE_MS,
-                          .value.integer = MAX_CONNECTION_IDLE_MS},
-                         {.type = GRPC_ARG_INTEGER,
-                          .key = GRPC_ARG_MAX_CONNECTION_AGE_MS,
-                          .value.integer = MAX_CONNECTION_AGE_MS}};
-  grpc_channel_args client_args = {.num_args = GPR_ARRAY_SIZE(client_a),
-                                   .args = client_a};
-  grpc_channel_args server_args = {.num_args = GPR_ARRAY_SIZE(server_a),
-                                   .args = server_a};
+  cq_verifier* cqv = cq_verifier_create(f.cq);
+
+  grpc_arg client_a[1];
+  client_a[0].type = GRPC_ARG_INTEGER;
+  client_a[0].key =
+      const_cast<char*>("grpc.testing.fixed_reconnect_backoff_ms");
+  client_a[0].value.integer = 1000;
+  grpc_arg server_a[2];
+  server_a[0].type = GRPC_ARG_INTEGER;
+  server_a[0].key = const_cast<char*>(GRPC_ARG_MAX_CONNECTION_IDLE_MS);
+  server_a[0].value.integer = MAX_CONNECTION_IDLE_MS;
+  server_a[1].type = GRPC_ARG_INTEGER;
+  server_a[1].key = const_cast<char*>(GRPC_ARG_MAX_CONNECTION_AGE_MS);
+  server_a[1].value.integer = MAX_CONNECTION_AGE_MS;
+  grpc_channel_args client_args = {GPR_ARRAY_SIZE(client_a), client_a};
+  grpc_channel_args server_args = {GPR_ARRAY_SIZE(server_a), server_a};
 
   config.init_client(&f, &client_args);
   config.init_server(&f, &server_args);
diff --git a/test/core/end2end/tests/max_message_length.c b/test/core/end2end/tests/max_message_length.cc
index 01eb8d365e..f1ac27fa7c 100644
--- a/test/core/end2end/tests/max_message_length.c
+++ b/test/core/end2end/tests/max_message_length.cc
@@ -34,18 +34,18 @@
 
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   // We intentionally do not pass the client and server args to
   // create_fixture(), since we don't want the limit enforced on the
   // proxy, only on the backend server.
-  f = config.create_fixture(NULL, NULL);
+  f = config.create_fixture(nullptr, nullptr);
   config.init_server(&f, server_args);
   config.init_client(&f, client_args);
   return f;
@@ -59,31 +59,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->cq, tag(1000));
   grpc_event ev = grpc_completion_queue_next(
-      f->cq, grpc_timeout_seconds_to_deadline(5), NULL);
+      f->cq, grpc_timeout_seconds_to_deadline(5), nullptr);
   GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
   GPR_ASSERT(ev.tag == tag(1000));
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -106,16 +106,16 @@ static void test_max_message_length_on_request(grpc_end2end_test_config config,
           send_limit, use_service_config, use_string_json_value);
 
   grpc_end2end_test_fixture f;
-  grpc_call *c = NULL;
-  grpc_call *s = NULL;
-  cq_verifier *cqv;
+  grpc_call* c = nullptr;
+  grpc_call* s = nullptr;
+  cq_verifier* cqv;
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
-  grpc_byte_buffer *request_payload =
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
-  grpc_byte_buffer *recv_payload = NULL;
+  grpc_byte_buffer* recv_payload = nullptr;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -125,41 +125,44 @@ static void test_max_message_length_on_request(grpc_end2end_test_config config,
   grpc_slice details;
   int was_cancelled = 2;
 
-  grpc_channel_args *client_args = NULL;
-  grpc_channel_args *server_args = NULL;
+  grpc_channel_args* client_args = nullptr;
+  grpc_channel_args* server_args = nullptr;
   if (use_service_config) {
     // We don't currently support service configs on the server side.
     GPR_ASSERT(send_limit);
     grpc_arg arg;
     arg.type = GRPC_ARG_STRING;
-    arg.key = GRPC_ARG_SERVICE_CONFIG;
+    arg.key = const_cast<char*>(GRPC_ARG_SERVICE_CONFIG);
     arg.value.string =
         use_string_json_value
-            ? "{\n"
-              "  \"methodConfig\": [ {\n"
-              "    \"name\": [\n"
-              "      { \"service\": \"service\", \"method\": \"method\" }\n"
-              "    ],\n"
-              "    \"maxRequestMessageBytes\": \"5\"\n"
-              "  } ]\n"
-              "}"
-            : "{\n"
-              "  \"methodConfig\": [ {\n"
-              "    \"name\": [\n"
-              "      { \"service\": \"service\", \"method\": \"method\" }\n"
-              "    ],\n"
-              "    \"maxRequestMessageBytes\": 5\n"
-              "  } ]\n"
-              "}";
-    client_args = grpc_channel_args_copy_and_add(NULL, &arg, 1);
+            ? const_cast<char*>(
+                  "{\n"
+                  "  \"methodConfig\": [ {\n"
+                  "    \"name\": [\n"
+                  "      { \"service\": \"service\", \"method\": \"method\" }\n"
+                  "    ],\n"
+                  "    \"maxRequestMessageBytes\": \"5\"\n"
+                  "  } ]\n"
+                  "}")
+            : const_cast<char*>(
+                  "{\n"
+                  "  \"methodConfig\": [ {\n"
+                  "    \"name\": [\n"
+                  "      { \"service\": \"service\", \"method\": \"method\" }\n"
+                  "    ],\n"
+                  "    \"maxRequestMessageBytes\": 5\n"
+                  "  } ]\n"
+                  "}");
+    client_args = grpc_channel_args_copy_and_add(nullptr, &arg, 1);
   } else {
     // Set limit via channel args.
     grpc_arg arg;
-    arg.key = send_limit ? GRPC_ARG_MAX_SEND_MESSAGE_LENGTH
-                         : GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH;
+    arg.key = send_limit
+                  ? const_cast<char*>(GRPC_ARG_MAX_SEND_MESSAGE_LENGTH)
+                  : const_cast<char*>(GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH);
     arg.type = GRPC_ARG_INTEGER;
     arg.value.integer = 5;
-    grpc_channel_args *args = grpc_channel_args_copy_and_add(NULL, &arg, 1);
+    grpc_channel_args* args = grpc_channel_args_copy_and_add(nullptr, &arg, 1);
     if (send_limit) {
       client_args = args;
     } else {
@@ -171,18 +174,20 @@ static void test_max_message_length_on_request(grpc_end2end_test_config config,
                  server_args);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    if (client_args != NULL) grpc_channel_args_destroy(&exec_ctx, client_args);
-    if (server_args != NULL) grpc_channel_args_destroy(&exec_ctx, server_args);
+    if (client_args != nullptr)
+      grpc_channel_args_destroy(&exec_ctx, client_args);
+    if (server_args != nullptr)
+      grpc_channel_args_destroy(&exec_ctx, server_args);
     grpc_exec_ctx_finish(&exec_ctx);
   }
 
   cqv = cq_verifier_create(f.cq);
 
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/service/method"),
       get_host_override_slice("foo.test.google.fr:1234", config),
-      gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+      gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -195,30 +200,30 @@ static void test_max_message_length_on_request(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   if (send_limit) {
@@ -239,14 +244,14 @@ static void test_max_message_length_on_request(grpc_end2end_test_config config,
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &recv_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -275,7 +280,7 @@ done:
   grpc_byte_buffer_destroy(recv_payload);
 
   grpc_call_unref(c);
-  if (s != NULL) grpc_call_unref(s);
+  if (s != nullptr) grpc_call_unref(s);
 
   cq_verifier_destroy(cqv);
 
@@ -296,16 +301,16 @@ static void test_max_message_length_on_response(grpc_end2end_test_config config,
           send_limit, use_service_config, use_string_json_value);
 
   grpc_end2end_test_fixture f;
-  grpc_call *c = NULL;
-  grpc_call *s = NULL;
-  cq_verifier *cqv;
+  grpc_call* c = nullptr;
+  grpc_call* s = nullptr;
+  cq_verifier* cqv;
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_slice response_payload_slice =
       grpc_slice_from_copied_string("hello world");
-  grpc_byte_buffer *response_payload =
+  grpc_byte_buffer* response_payload =
       grpc_raw_byte_buffer_create(&response_payload_slice, 1);
-  grpc_byte_buffer *recv_payload = NULL;
+  grpc_byte_buffer* recv_payload = nullptr;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -315,15 +320,15 @@ static void test_max_message_length_on_response(grpc_end2end_test_config config,
   grpc_slice details;
   int was_cancelled = 2;
 
-  grpc_channel_args *client_args = NULL;
-  grpc_channel_args *server_args = NULL;
+  grpc_channel_args* client_args = nullptr;
+  grpc_channel_args* server_args = nullptr;
   if (use_service_config) {
     // We don't currently support service configs on the server side.
     GPR_ASSERT(!send_limit);
     grpc_arg arg;
     arg.type = GRPC_ARG_STRING;
-    arg.key = GRPC_ARG_SERVICE_CONFIG;
-    arg.value.string =
+    arg.key = const_cast<char*>(GRPC_ARG_SERVICE_CONFIG);
+    arg.value.string = const_cast<char*>(
         use_string_json_value
             ? "{\n"
               "  \"methodConfig\": [ {\n"
@@ -340,16 +345,17 @@ static void test_max_message_length_on_response(grpc_end2end_test_config config,
               "    ],\n"
               "    \"maxResponseMessageBytes\": 5\n"
               "  } ]\n"
-              "}";
-    client_args = grpc_channel_args_copy_and_add(NULL, &arg, 1);
+              "}");
+    client_args = grpc_channel_args_copy_and_add(nullptr, &arg, 1);
   } else {
     // Set limit via channel args.
     grpc_arg arg;
-    arg.key = send_limit ? GRPC_ARG_MAX_SEND_MESSAGE_LENGTH
-                         : GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH;
+    arg.key = send_limit
+                  ? const_cast<char*>(GRPC_ARG_MAX_SEND_MESSAGE_LENGTH)
+                  : const_cast<char*>(GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH);
     arg.type = GRPC_ARG_INTEGER;
     arg.value.integer = 5;
-    grpc_channel_args *args = grpc_channel_args_copy_and_add(NULL, &arg, 1);
+    grpc_channel_args* args = grpc_channel_args_copy_and_add(nullptr, &arg, 1);
     if (send_limit) {
       server_args = args;
     } else {
@@ -361,17 +367,19 @@ static void test_max_message_length_on_response(grpc_end2end_test_config config,
                  server_args);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    if (client_args != NULL) grpc_channel_args_destroy(&exec_ctx, client_args);
-    if (server_args != NULL) grpc_channel_args_destroy(&exec_ctx, server_args);
+    if (client_args != nullptr)
+      grpc_channel_args_destroy(&exec_ctx, client_args);
+    if (server_args != nullptr)
+      grpc_channel_args_destroy(&exec_ctx, server_args);
     grpc_exec_ctx_finish(&exec_ctx);
   }
   cqv = cq_verifier_create(f.cq);
 
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/service/method"),
       get_host_override_slice("foo.test.google.fr:1234", config),
-      gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+      gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -384,30 +392,30 @@ static void test_max_message_length_on_response(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &recv_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -422,17 +430,17 @@ static void test_max_message_length_on_response(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = response_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -440,9 +448,9 @@ static void test_max_message_length_on_response(grpc_end2end_test_config config,
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -469,7 +477,7 @@ static void test_max_message_length_on_response(grpc_end2end_test_config config,
   grpc_byte_buffer_destroy(recv_payload);
 
   grpc_call_unref(c);
-  if (s != NULL) grpc_call_unref(s);
+  if (s != nullptr) grpc_call_unref(s);
 
   cq_verifier_destroy(cqv);
 
diff --git a/test/core/end2end/tests/negative_deadline.c b/test/core/end2end/tests/negative_deadline.cc
index c8667f4f4d..b793964b48 100644
--- a/test/core/end2end/tests/negative_deadline.c
+++ b/test/core/end2end/tests/negative_deadline.cc
@@ -30,12 +30,12 @@
 #include "src/core/lib/support/string.h"
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -52,31 +52,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -88,10 +88,10 @@ static void end_test(grpc_end2end_test_fixture *f) {
 
 static void simple_request_body(grpc_end2end_test_config config,
                                 grpc_end2end_test_fixture f, size_t num_ops) {
-  grpc_call *c;
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  grpc_call* c;
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_status_code status;
@@ -102,10 +102,10 @@ static void simple_request_body(grpc_end2end_test_config config,
 
   gpr_timespec deadline = gpr_inf_past(GPR_CLOCK_REALTIME);
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -118,24 +118,24 @@ static void simple_request_body(grpc_end2end_test_config config,
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   GPR_ASSERT(num_ops <= (size_t)(op - ops));
-  error = grpc_call_start_batch(c, ops, num_ops, tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, num_ops, tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
@@ -156,7 +156,7 @@ static void test_invoke_simple_request(grpc_end2end_test_config config,
                                        size_t num_ops) {
   grpc_end2end_test_fixture f;
 
-  f = begin_test(config, "test_invoke_simple_request", NULL, NULL);
+  f = begin_test(config, "test_invoke_simple_request", nullptr, nullptr);
   simple_request_body(config, f, num_ops);
   end_test(&f);
   config.tear_down_data(&f);
diff --git a/test/core/end2end/tests/network_status_change.c b/test/core/end2end/tests/network_status_change.cc
index 4d77174e22..7d0318fda6 100644
--- a/test/core/end2end/tests/network_status_change.c
+++ b/test/core/end2end/tests/network_status_change.cc
@@ -31,12 +31,12 @@
 /* this is a private API but exposed here for testing*/
 extern void grpc_network_status_shutdown_all_endpoints();
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -53,31 +53,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(500);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -89,21 +89,21 @@ static void end_test(grpc_end2end_test_fixture *f) {
 
 /* Client sends a request with payload, server reads then returns status. */
 static void test_invoke_network_status_change(grpc_end2end_test_config config) {
-  grpc_call *c;
-  grpc_call *s;
+  grpc_call* c;
+  grpc_call* s;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
-  grpc_byte_buffer *request_payload =
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
   grpc_end2end_test_fixture f =
-      begin_test(config, "test_invoke_request_with_payload", NULL, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+      begin_test(config, "test_invoke_request_with_payload", nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *request_payload_recv = NULL;
+  grpc_byte_buffer* request_payload_recv = nullptr;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
@@ -112,10 +112,10 @@ static void test_invoke_network_status_change(grpc_end2end_test_config config) {
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -128,30 +128,30 @@ static void test_invoke_network_status_change(grpc_end2end_test_config config) {
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(
@@ -164,14 +164,14 @@ static void test_invoke_network_status_change(grpc_end2end_test_config config) {
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &request_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -184,7 +184,7 @@ static void test_invoke_network_status_change(grpc_end2end_test_config config) {
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -192,9 +192,9 @@ static void test_invoke_network_status_change(grpc_end2end_test_config config) {
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(103), 1);
diff --git a/test/core/end2end/tests/no_logging.c b/test/core/end2end/tests/no_logging.cc
index f7d50c24dd..55d211c44a 100644
--- a/test/core/end2end/tests/no_logging.c
+++ b/test/core/end2end/tests/no_logging.cc
@@ -34,12 +34,12 @@
 
 enum { TIMEOUT = 200000 };
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
-extern void gpr_default_log(gpr_log_func_args *args);
+extern "C" void gpr_default_log(gpr_log_func_args* args);
 
-static void test_no_log(gpr_log_func_args *args) {
-  char *message = NULL;
+static void test_no_log(gpr_log_func_args* args) {
+  char* message = nullptr;
   gpr_asprintf(&message, "Unwanted log: %s", args->message);
   args->message = message;
   gpr_default_log(args);
@@ -47,7 +47,7 @@ static void test_no_log(gpr_log_func_args *args) {
   abort();
 }
 
-static void test_no_error_log(gpr_log_func_args *args) {
+static void test_no_error_log(gpr_log_func_args* args) {
   if (args->severity == GPR_LOG_SEVERITY_ERROR) {
     test_no_log(args);
   }
@@ -55,15 +55,15 @@ static void test_no_error_log(gpr_log_func_args *args) {
 
 static gpr_atm g_log_func = (gpr_atm)gpr_default_log;
 
-static void log_dispatcher_func(gpr_log_func_args *args) {
+static void log_dispatcher_func(gpr_log_func_args* args) {
   gpr_log_func log_func = (gpr_log_func)gpr_atm_no_barrier_load(&g_log_func);
   log_func(args);
 }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -80,31 +80,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -116,11 +116,11 @@ static void end_test(grpc_end2end_test_fixture *f) {
 
 static void simple_request_body(grpc_end2end_test_config config,
                                 grpc_end2end_test_fixture f) {
-  grpc_call *c;
-  grpc_call *s;
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  grpc_call* c;
+  grpc_call* s;
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -129,18 +129,18 @@ static void simple_request_body(grpc_end2end_test_config config,
   grpc_call_error error;
   grpc_slice details;
   int was_cancelled = 2;
-  char *peer;
+  char* peer;
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   peer = grpc_call_get_peer(c);
-  GPR_ASSERT(peer != NULL);
+  GPR_ASSERT(peer != nullptr);
   gpr_free(peer);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -153,25 +153,25 @@ static void simple_request_body(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -182,10 +182,10 @@ static void simple_request_body(grpc_end2end_test_config config,
   cq_verify(cqv);
 
   peer = grpc_call_get_peer(s);
-  GPR_ASSERT(peer != NULL);
+  GPR_ASSERT(peer != nullptr);
   gpr_free(peer);
   peer = grpc_call_get_peer(c);
-  GPR_ASSERT(peer != NULL);
+  GPR_ASSERT(peer != nullptr);
   gpr_free(peer);
 
   memset(ops, 0, sizeof(ops));
@@ -193,7 +193,7 @@ static void simple_request_body(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -201,14 +201,14 @@ static void simple_request_body(grpc_end2end_test_config config,
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -239,7 +239,7 @@ static void test_invoke_simple_request(grpc_end2end_test_config config) {
   grpc_end2end_test_fixture f;
 
   f = begin_test(config, "test_invoke_simple_request_with_no_error_logging",
-                 NULL, NULL);
+                 nullptr, nullptr);
   simple_request_body(config, f);
   end_test(&f);
   config.tear_down_data(&f);
@@ -249,7 +249,7 @@ static void test_invoke_10_simple_requests(grpc_end2end_test_config config) {
   int i;
   grpc_end2end_test_fixture f =
       begin_test(config, "test_invoke_10_simple_requests_with_no_error_logging",
-                 NULL, NULL);
+                 nullptr, nullptr);
   for (i = 0; i < 10; i++) {
     simple_request_body(config, f);
     gpr_log(GPR_INFO, "Passed simple request %d", i);
@@ -273,7 +273,7 @@ static void test_no_error_logging_in_entire_process(
 static void test_no_logging_in_one_request(grpc_end2end_test_config config) {
   int i;
   grpc_end2end_test_fixture f =
-      begin_test(config, "test_no_logging_in_last_request", NULL, NULL);
+      begin_test(config, "test_no_logging_in_last_request", nullptr, nullptr);
   for (i = 0; i < 10; i++) {
     simple_request_body(config, f);
   }
diff --git a/test/core/end2end/tests/no_op.c b/test/core/end2end/tests/no_op.cc
index 8400c27486..18c2367ac4 100644
--- a/test/core/end2end/tests/no_op.c
+++ b/test/core/end2end/tests/no_op.cc
@@ -28,12 +28,12 @@
 #include <grpc/support/useful.h>
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -50,31 +50,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -85,7 +85,7 @@ static void end_test(grpc_end2end_test_fixture *f) {
 }
 
 static void test_no_op(grpc_end2end_test_config config) {
-  grpc_end2end_test_fixture f = begin_test(config, "no-op", NULL, NULL);
+  grpc_end2end_test_fixture f = begin_test(config, "no-op", nullptr, nullptr);
   end_test(&f);
   config.tear_down_data(&f);
 }
diff --git a/test/core/end2end/tests/payload.c b/test/core/end2end/tests/payload.cc
index d98eed68e0..2e9513b9cb 100644
--- a/test/core/end2end/tests/payload.c
+++ b/test/core/end2end/tests/payload.cc
@@ -28,12 +28,12 @@
 #include <grpc/support/useful.h>
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -50,31 +50,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -89,9 +89,9 @@ static void end_test(grpc_end2end_test_fixture *f) {
 static grpc_slice generate_random_slice() {
   size_t i;
   static const char chars[] = "abcdefghijklmnopqrstuvwxyz1234567890";
-  char *output;
+  char* output;
   const size_t output_size = 1024 * 1024;
-  output = (char *)gpr_malloc(output_size);
+  output = (char*)gpr_malloc(output_size);
   for (i = 0; i < output_size - 1; ++i) {
     output[i] = chars[rand() % (int)(sizeof(chars) - 1)];
   }
@@ -109,20 +109,20 @@ static void request_response_with_payload(grpc_end2end_test_config config,
   grpc_slice request_payload_slice = generate_random_slice();
   grpc_slice response_payload_slice = generate_random_slice();
 
-  grpc_call *c;
-  grpc_call *s;
-  grpc_byte_buffer *request_payload =
+  grpc_call* c;
+  grpc_call* s;
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
-  grpc_byte_buffer *response_payload =
+  grpc_byte_buffer* response_payload =
       grpc_raw_byte_buffer_create(&response_payload_slice, 1);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *request_payload_recv = NULL;
-  grpc_byte_buffer *response_payload_recv = NULL;
+  grpc_byte_buffer* request_payload_recv = nullptr;
+  grpc_byte_buffer* response_payload_recv = nullptr;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
@@ -131,10 +131,10 @@ static void request_response_with_payload(grpc_end2end_test_config config,
 
   gpr_timespec deadline = n_seconds_from_now(60);
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -147,35 +147,35 @@ static void request_response_with_payload(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &response_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -190,14 +190,14 @@ static void request_response_with_payload(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &request_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -208,12 +208,12 @@ static void request_response_with_payload(grpc_end2end_test_config config,
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = response_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -221,9 +221,9 @@ static void request_response_with_payload(grpc_end2end_test_config config,
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(103), 1);
@@ -262,7 +262,7 @@ static void request_response_with_payload(grpc_end2end_test_config config,
 static void test_invoke_request_response_with_payload(
     grpc_end2end_test_config config) {
   grpc_end2end_test_fixture f = begin_test(
-      config, "test_invoke_request_response_with_payload", NULL, NULL);
+      config, "test_invoke_request_response_with_payload", nullptr, nullptr);
   request_response_with_payload(config, f);
   end_test(&f);
   config.tear_down_data(&f);
@@ -272,7 +272,7 @@ static void test_invoke_10_request_response_with_payload(
     grpc_end2end_test_config config) {
   int i;
   grpc_end2end_test_fixture f = begin_test(
-      config, "test_invoke_10_request_response_with_payload", NULL, NULL);
+      config, "test_invoke_10_request_response_with_payload", nullptr, nullptr);
   for (i = 0; i < 10; i++) {
     request_response_with_payload(config, f);
   }
diff --git a/test/core/end2end/tests/ping.c b/test/core/end2end/tests/ping.cc
index 23c82569ba..725a425fbf 100644
--- a/test/core/end2end/tests/ping.c
+++ b/test/core/end2end/tests/ping.cc
@@ -28,41 +28,41 @@
 
 #define PING_NUM 5
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static void test_ping(grpc_end2end_test_config config,
                       int min_time_between_pings_ms) {
-  grpc_end2end_test_fixture f = config.create_fixture(NULL, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  grpc_end2end_test_fixture f = config.create_fixture(nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_connectivity_state state = GRPC_CHANNEL_IDLE;
   int i;
 
-  grpc_arg client_a[] = {
-      {.type = GRPC_ARG_INTEGER,
-       .key = GRPC_ARG_HTTP2_MIN_SENT_PING_INTERVAL_WITHOUT_DATA_MS,
-       .value.integer = 10},
-      {.type = GRPC_ARG_INTEGER,
-       .key = GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA,
-       .value.integer = 0},
-      {.type = GRPC_ARG_INTEGER,
-       .key = GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS,
-       .value.integer = 1}};
-  grpc_arg server_a[] = {
-      {.type = GRPC_ARG_INTEGER,
-       .key = GRPC_ARG_HTTP2_MIN_RECV_PING_INTERVAL_WITHOUT_DATA_MS,
-       .value.integer = 0},
-      {.type = GRPC_ARG_INTEGER,
-       .key = GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS,
-       .value.integer = 1}};
-  grpc_channel_args client_args = {.num_args = GPR_ARRAY_SIZE(client_a),
-                                   .args = client_a};
-  grpc_channel_args server_args = {.num_args = GPR_ARRAY_SIZE(server_a),
-                                   .args = server_a};
+  grpc_arg client_a[3];
+  client_a[0].type = GRPC_ARG_INTEGER;
+  client_a[0].key =
+      const_cast<char*>(GRPC_ARG_HTTP2_MIN_SENT_PING_INTERVAL_WITHOUT_DATA_MS);
+  client_a[0].value.integer = 10;
+  client_a[1].type = GRPC_ARG_INTEGER;
+  client_a[1].key = const_cast<char*>(GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA);
+  client_a[1].value.integer = 0;
+  client_a[2].type = GRPC_ARG_INTEGER;
+  client_a[2].key = const_cast<char*>(GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS);
+  client_a[2].value.integer = 1;
+  grpc_arg server_a[2];
+  server_a[0].type = GRPC_ARG_INTEGER;
+  server_a[0].key =
+      const_cast<char*>(GRPC_ARG_HTTP2_MIN_RECV_PING_INTERVAL_WITHOUT_DATA_MS);
+  server_a[0].value.integer = 0;
+  server_a[1].type = GRPC_ARG_INTEGER;
+  server_a[1].key = const_cast<char*>(GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS);
+  server_a[1].value.integer = 1;
+  grpc_channel_args client_args = {GPR_ARRAY_SIZE(client_a), client_a};
+  grpc_channel_args server_args = {GPR_ARRAY_SIZE(server_a), server_a};
 
   config.init_client(&f, &client_args);
   config.init_server(&f, &server_args);
 
-  grpc_channel_ping(f.client, f.cq, tag(0), NULL);
+  grpc_channel_ping(f.client, f.cq, tag(0), nullptr);
   CQ_EXPECT_COMPLETION(cqv, tag(0), 0);
 
   /* check that we're still in idle, and start connecting */
@@ -86,7 +86,7 @@ static void test_ping(grpc_end2end_test_config config,
   }
 
   for (i = 1; i <= PING_NUM; i++) {
-    grpc_channel_ping(f.client, f.cq, tag(i), NULL);
+    grpc_channel_ping(f.client, f.cq, tag(i), nullptr);
     CQ_EXPECT_COMPLETION(cqv, tag(i), 1);
     cq_verify(cqv);
   }
diff --git a/test/core/end2end/tests/ping_pong_streaming.c b/test/core/end2end/tests/ping_pong_streaming.cc
index 1c44262c3d..ec7981fdcb 100644
--- a/test/core/end2end/tests/ping_pong_streaming.c
+++ b/test/core/end2end/tests/ping_pong_streaming.cc
@@ -28,12 +28,12 @@
 #include <grpc/support/useful.h>
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -50,31 +50,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -88,12 +88,12 @@ static void end_test(grpc_end2end_test_fixture *f) {
 static void test_pingpong_streaming(grpc_end2end_test_config config,
                                     int messages) {
   grpc_end2end_test_fixture f =
-      begin_test(config, "test_pingpong_streaming", NULL, NULL);
-  grpc_call *c;
-  grpc_call *s;
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+      begin_test(config, "test_pingpong_streaming", nullptr, nullptr);
+  grpc_call* c;
+  grpc_call* s;
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -102,10 +102,10 @@ static void test_pingpong_streaming(grpc_end2end_test_config config,
   grpc_call_error error;
   grpc_slice details;
   int was_cancelled = 2;
-  grpc_byte_buffer *request_payload;
-  grpc_byte_buffer *request_payload_recv;
-  grpc_byte_buffer *response_payload;
-  grpc_byte_buffer *response_payload_recv;
+  grpc_byte_buffer* request_payload;
+  grpc_byte_buffer* request_payload_recv;
+  grpc_byte_buffer* response_payload;
+  grpc_byte_buffer* response_payload_recv;
   int i;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
@@ -114,10 +114,10 @@ static void test_pingpong_streaming(grpc_end2end_test_config config,
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -130,21 +130,21 @@ static void test_pingpong_streaming(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -159,14 +159,14 @@ static void test_pingpong_streaming(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(101), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(101), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   for (i = 0; i < messages; i++) {
@@ -178,14 +178,14 @@ static void test_pingpong_streaming(grpc_end2end_test_config config,
     op->op = GRPC_OP_SEND_MESSAGE;
     op->data.send_message.send_message = request_payload;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
     op->op = GRPC_OP_RECV_MESSAGE;
     op->data.recv_message.recv_message = &response_payload_recv;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), NULL);
+    error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
 
     memset(ops, 0, sizeof(ops));
@@ -193,9 +193,10 @@ static void test_pingpong_streaming(grpc_end2end_test_config config,
     op->op = GRPC_OP_RECV_MESSAGE;
     op->data.recv_message.recv_message = &request_payload_recv;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+    error =
+        grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
     CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
     cq_verify(cqv);
@@ -205,9 +206,10 @@ static void test_pingpong_streaming(grpc_end2end_test_config config,
     op->op = GRPC_OP_SEND_MESSAGE;
     op->data.send_message.send_message = response_payload;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), NULL);
+    error =
+        grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
     CQ_EXPECT_COMPLETION(cqv, tag(103), 1);
     CQ_EXPECT_COMPLETION(cqv, tag(2), 1);
@@ -226,9 +228,9 @@ static void test_pingpong_streaming(grpc_end2end_test_config config,
   op = ops;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(3), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(3), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   memset(ops, 0, sizeof(ops));
@@ -239,9 +241,9 @@ static void test_pingpong_streaming(grpc_end2end_test_config config,
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(104), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(104), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
diff --git a/test/core/end2end/tests/proxy_auth.c b/test/core/end2end/tests/proxy_auth.cc
index d922049bcb..e4b91ab879 100644
--- a/test/core/end2end/tests/proxy_auth.c
+++ b/test/core/end2end/tests/proxy_auth.cc
@@ -35,12 +35,12 @@
 #include "src/core/lib/support/string.h"
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -57,31 +57,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -93,11 +93,11 @@ static void end_test(grpc_end2end_test_fixture *f) {
 
 static void simple_request_body(grpc_end2end_test_config config,
                                 grpc_end2end_test_fixture f) {
-  grpc_call *c;
-  grpc_call *s;
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  grpc_call* c;
+  grpc_call* s;
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -106,18 +106,18 @@ static void simple_request_body(grpc_end2end_test_config config,
   grpc_call_error error;
   grpc_slice details;
   int was_cancelled = 2;
-  char *peer;
+  char* peer;
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   peer = grpc_call_get_peer(c);
-  GPR_ASSERT(peer != NULL);
+  GPR_ASSERT(peer != nullptr);
   gpr_log(GPR_DEBUG, "client_peer_before_call=%s", peer);
   gpr_free(peer);
 
@@ -131,25 +131,25 @@ static void simple_request_body(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -160,11 +160,11 @@ static void simple_request_body(grpc_end2end_test_config config,
   cq_verify(cqv);
 
   peer = grpc_call_get_peer(s);
-  GPR_ASSERT(peer != NULL);
+  GPR_ASSERT(peer != nullptr);
   gpr_log(GPR_DEBUG, "server_peer=%s", peer);
   gpr_free(peer);
   peer = grpc_call_get_peer(c);
-  GPR_ASSERT(peer != NULL);
+  GPR_ASSERT(peer != nullptr);
   gpr_log(GPR_DEBUG, "client_peer=%s", peer);
   gpr_free(peer);
 
@@ -173,7 +173,7 @@ static void simple_request_body(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -181,14 +181,14 @@ static void simple_request_body(grpc_end2end_test_config config,
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -217,12 +217,13 @@ static void simple_request_body(grpc_end2end_test_config config,
 
 static void test_invoke_proxy_auth(grpc_end2end_test_config config) {
   /* Indicate that the proxy requires user auth */
-  grpc_arg client_arg = {.type = GRPC_ARG_STRING,
-                         .key = GRPC_ARG_HTTP_PROXY_AUTH_CREDS,
-                         .value.string = GRPC_TEST_HTTP_PROXY_AUTH_CREDS};
-  grpc_channel_args client_args = {.num_args = 1, .args = &client_arg};
+  grpc_arg client_arg;
+  client_arg.type = GRPC_ARG_STRING;
+  client_arg.key = const_cast<char*>(GRPC_ARG_HTTP_PROXY_AUTH_CREDS);
+  client_arg.value.string = const_cast<char*>(GRPC_TEST_HTTP_PROXY_AUTH_CREDS);
+  grpc_channel_args client_args = {1, &client_arg};
   grpc_end2end_test_fixture f =
-      begin_test(config, "test_invoke_proxy_auth", &client_args, NULL);
+      begin_test(config, "test_invoke_proxy_auth", &client_args, nullptr);
   simple_request_body(config, f);
   end_test(&f);
   config.tear_down_data(&f);
diff --git a/test/core/end2end/tests/registered_call.c b/test/core/end2end/tests/registered_call.cc
index 4598029818..440d817cf1 100644
--- a/test/core/end2end/tests/registered_call.c
+++ b/test/core/end2end/tests/registered_call.cc
@@ -30,12 +30,12 @@
 #include "src/core/lib/support/string.h"
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -52,31 +52,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -87,12 +87,12 @@ static void end_test(grpc_end2end_test_fixture *f) {
 }
 
 static void simple_request_body(grpc_end2end_test_config config,
-                                grpc_end2end_test_fixture f, void *rc) {
-  grpc_call *c;
-  grpc_call *s;
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+                                grpc_end2end_test_fixture f, void* rc) {
+  grpc_call* c;
+  grpc_call* s;
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -104,7 +104,7 @@ static void simple_request_body(grpc_end2end_test_config config,
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_registered_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, rc, deadline, NULL);
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq, rc, deadline, nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -117,25 +117,25 @@ static void simple_request_body(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -150,7 +150,7 @@ static void simple_request_body(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -158,14 +158,14 @@ static void simple_request_body(grpc_end2end_test_config config,
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -193,10 +193,10 @@ static void simple_request_body(grpc_end2end_test_config config,
 
 static void test_invoke_simple_request(grpc_end2end_test_config config) {
   grpc_end2end_test_fixture f =
-      begin_test(config, "test_invoke_simple_request", NULL, NULL);
-  void *rc = grpc_channel_register_call(
+      begin_test(config, "test_invoke_simple_request", nullptr, nullptr);
+  void* rc = grpc_channel_register_call(
       f.client, "/foo",
-      get_host_override_string("foo.test.google.fr:1234", config), NULL);
+      get_host_override_string("foo.test.google.fr:1234", config), nullptr);
 
   simple_request_body(config, f, rc);
   end_test(&f);
@@ -206,10 +206,10 @@ static void test_invoke_simple_request(grpc_end2end_test_config config) {
 static void test_invoke_10_simple_requests(grpc_end2end_test_config config) {
   int i;
   grpc_end2end_test_fixture f =
-      begin_test(config, "test_invoke_10_simple_requests", NULL, NULL);
-  void *rc = grpc_channel_register_call(
+      begin_test(config, "test_invoke_10_simple_requests", nullptr, nullptr);
+  void* rc = grpc_channel_register_call(
       f.client, "/foo",
-      get_host_override_string("foo.test.google.fr:1234", config), NULL);
+      get_host_override_string("foo.test.google.fr:1234", config), nullptr);
 
   for (i = 0; i < 10; i++) {
     simple_request_body(config, f, rc);
diff --git a/test/core/end2end/tests/request_with_flags.c b/test/core/end2end/tests/request_with_flags.cc
index dfb7d58743..984d8b10f1 100644
--- a/test/core/end2end/tests/request_with_flags.c
+++ b/test/core/end2end/tests/request_with_flags.cc
@@ -29,12 +29,12 @@
 #include "src/core/lib/transport/byte_stream.h"
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -51,31 +51,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -86,22 +86,22 @@ static void end_test(grpc_end2end_test_fixture *f) {
 }
 
 static void test_invoke_request_with_flags(
-    grpc_end2end_test_config config, uint32_t *flags_for_op,
+    grpc_end2end_test_config config, uint32_t* flags_for_op,
     grpc_call_error call_start_batch_expected_result) {
-  grpc_call *c;
+  grpc_call* c;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
-  grpc_byte_buffer *request_payload =
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
   grpc_end2end_test_fixture f =
-      begin_test(config, "test_invoke_request_with_flags", NULL, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+      begin_test(config, "test_invoke_request_with_flags", nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *request_payload_recv = NULL;
+  grpc_byte_buffer* request_payload_recv = nullptr;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
@@ -110,10 +110,10 @@ static void test_invoke_request_with_flags(
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -126,31 +126,31 @@ static void test_invoke_request_with_flags(
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = flags_for_op[op->op];
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = flags_for_op[op->op];
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = flags_for_op[op->op];
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = flags_for_op[op->op];
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = flags_for_op[op->op];
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   expectation = call_start_batch_expected_result;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(expectation == error);
 
   if (expectation == GRPC_CALL_OK) {
diff --git a/test/core/end2end/tests/request_with_payload.c b/test/core/end2end/tests/request_with_payload.cc
index 575e54c7d9..b3b9ee5726 100644
--- a/test/core/end2end/tests/request_with_payload.c
+++ b/test/core/end2end/tests/request_with_payload.cc
@@ -28,12 +28,12 @@
 #include <grpc/support/useful.h>
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -50,31 +50,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -86,21 +86,21 @@ static void end_test(grpc_end2end_test_fixture *f) {
 
 /* Client sends a request with payload, server reads then returns status. */
 static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
-  grpc_call *c;
-  grpc_call *s;
+  grpc_call* c;
+  grpc_call* s;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
-  grpc_byte_buffer *request_payload =
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
   grpc_end2end_test_fixture f =
-      begin_test(config, "test_invoke_request_with_payload", NULL, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+      begin_test(config, "test_invoke_request_with_payload", nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *request_payload_recv = NULL;
+  grpc_byte_buffer* request_payload_recv = nullptr;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
@@ -109,10 +109,10 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -125,30 +125,30 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(
@@ -162,14 +162,14 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &request_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -180,7 +180,7 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -188,9 +188,9 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(103), 1);
diff --git a/test/core/end2end/tests/resource_quota_server.c b/test/core/end2end/tests/resource_quota_server.cc
index 93befeee0c..0ee014f97d 100644
--- a/test/core/end2end/tests/resource_quota_server.c
+++ b/test/core/end2end/tests/resource_quota_server.cc
@@ -28,12 +28,12 @@
 #include <grpc/support/useful.h>
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -50,31 +50,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -89,9 +89,9 @@ static void end_test(grpc_end2end_test_fixture *f) {
 static grpc_slice generate_random_slice() {
   size_t i;
   static const char chars[] = "abcdefghijklmnopqrstuvwxyz1234567890";
-  char *output;
+  char* output;
   const size_t output_size = 1024 * 1024;
-  output = (char *)gpr_malloc(output_size);
+  output = (char*)gpr_malloc(output_size);
   for (i = 0; i < output_size - 1; ++i) {
     output[i] = chars[rand() % (int)(sizeof(chars) - 1)];
   }
@@ -106,7 +106,7 @@ void resource_quota_server(grpc_end2end_test_config config) {
       FEATURE_MASK_DOES_NOT_SUPPORT_RESOURCE_QUOTA_SERVER) {
     return;
   }
-  grpc_resource_quota *resource_quota =
+  grpc_resource_quota* resource_quota =
       grpc_resource_quota_create("test_server");
   grpc_resource_quota_resize(resource_quota, 5 * 1024 * 1024);
 
@@ -117,40 +117,40 @@ void resource_quota_server(grpc_end2end_test_config config) {
 #define SERVER_END_BASE_TAG 0x4000
 
   grpc_arg arg;
-  arg.key = GRPC_ARG_RESOURCE_QUOTA;
+  arg.key = const_cast<char*>(GRPC_ARG_RESOURCE_QUOTA);
   arg.type = GRPC_ARG_POINTER;
   arg.value.pointer.p = resource_quota;
   arg.value.pointer.vtable = grpc_resource_quota_arg_vtable();
   grpc_channel_args args = {1, &arg};
 
   grpc_end2end_test_fixture f =
-      begin_test(config, "resource_quota_server", NULL, &args);
+      begin_test(config, "resource_quota_server", nullptr, &args);
 
   /* Create large request and response bodies. These are big enough to require
    * multiple round trips to deliver to the peer, and their exact contents of
    * will be verified on completion. */
   grpc_slice request_payload_slice = generate_random_slice();
 
-  grpc_call **client_calls =
-      (grpc_call **)malloc(sizeof(grpc_call *) * NUM_CALLS);
-  grpc_call **server_calls =
-      (grpc_call **)malloc(sizeof(grpc_call *) * NUM_CALLS);
-  grpc_metadata_array *initial_metadata_recv =
-      (grpc_metadata_array *)malloc(sizeof(grpc_metadata_array) * NUM_CALLS);
-  grpc_metadata_array *trailing_metadata_recv =
-      (grpc_metadata_array *)malloc(sizeof(grpc_metadata_array) * NUM_CALLS);
-  grpc_metadata_array *request_metadata_recv =
-      (grpc_metadata_array *)malloc(sizeof(grpc_metadata_array) * NUM_CALLS);
-  grpc_call_details *call_details =
-      (grpc_call_details *)malloc(sizeof(grpc_call_details) * NUM_CALLS);
-  grpc_status_code *status =
-      (grpc_status_code *)malloc(sizeof(grpc_status_code) * NUM_CALLS);
-  grpc_slice *details = (grpc_slice *)malloc(sizeof(grpc_slice) * NUM_CALLS);
-  grpc_byte_buffer **request_payload =
-      (grpc_byte_buffer **)malloc(sizeof(grpc_byte_buffer *) * NUM_CALLS);
-  grpc_byte_buffer **request_payload_recv =
-      (grpc_byte_buffer **)malloc(sizeof(grpc_byte_buffer *) * NUM_CALLS);
-  int *was_cancelled = (int *)malloc(sizeof(int) * NUM_CALLS);
+  grpc_call** client_calls =
+      (grpc_call**)malloc(sizeof(grpc_call*) * NUM_CALLS);
+  grpc_call** server_calls =
+      (grpc_call**)malloc(sizeof(grpc_call*) * NUM_CALLS);
+  grpc_metadata_array* initial_metadata_recv =
+      (grpc_metadata_array*)malloc(sizeof(grpc_metadata_array) * NUM_CALLS);
+  grpc_metadata_array* trailing_metadata_recv =
+      (grpc_metadata_array*)malloc(sizeof(grpc_metadata_array) * NUM_CALLS);
+  grpc_metadata_array* request_metadata_recv =
+      (grpc_metadata_array*)malloc(sizeof(grpc_metadata_array) * NUM_CALLS);
+  grpc_call_details* call_details =
+      (grpc_call_details*)malloc(sizeof(grpc_call_details) * NUM_CALLS);
+  grpc_status_code* status =
+      (grpc_status_code*)malloc(sizeof(grpc_status_code) * NUM_CALLS);
+  grpc_slice* details = (grpc_slice*)malloc(sizeof(grpc_slice) * NUM_CALLS);
+  grpc_byte_buffer** request_payload =
+      (grpc_byte_buffer**)malloc(sizeof(grpc_byte_buffer*) * NUM_CALLS);
+  grpc_byte_buffer** request_payload_recv =
+      (grpc_byte_buffer**)malloc(sizeof(grpc_byte_buffer*) * NUM_CALLS);
+  int* was_cancelled = (int*)malloc(sizeof(int) * NUM_CALLS);
   grpc_call_error error;
   int pending_client_calls = 0;
   int pending_server_start_calls = 0;
@@ -162,7 +162,7 @@ void resource_quota_server(grpc_end2end_test_config config) {
   int unavailable = 0;
 
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
 
   for (int i = 0; i < NUM_CALLS; i++) {
     grpc_metadata_array_init(&initial_metadata_recv[i]);
@@ -170,7 +170,7 @@ void resource_quota_server(grpc_end2end_test_config config) {
     grpc_metadata_array_init(&request_metadata_recv[i]);
     grpc_call_details_init(&call_details[i]);
     request_payload[i] = grpc_raw_byte_buffer_create(&request_payload_slice, 1);
-    request_payload_recv[i] = NULL;
+    request_payload_recv[i] = nullptr;
     was_cancelled[i] = 0;
   }
 
@@ -185,32 +185,32 @@ void resource_quota_server(grpc_end2end_test_config config) {
 
   for (int i = 0; i < NUM_CALLS; i++) {
     client_calls[i] = grpc_channel_create_call(
-        f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+        f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
         grpc_slice_from_static_string("/foo"),
         get_host_override_slice("foo.test.google.fr", config),
-        n_seconds_from_now(60), NULL);
+        n_seconds_from_now(60), nullptr);
 
     memset(ops, 0, sizeof(ops));
     op = ops;
     op->op = GRPC_OP_SEND_INITIAL_METADATA;
     op->data.send_initial_metadata.count = 0;
     op->flags = GRPC_INITIAL_METADATA_WAIT_FOR_READY;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
     op->op = GRPC_OP_SEND_MESSAGE;
     op->data.send_message.send_message = request_payload[i];
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
     op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
     op->op = GRPC_OP_RECV_INITIAL_METADATA;
     op->data.recv_initial_metadata.recv_initial_metadata =
         &initial_metadata_recv[i];
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
     op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
     op->data.recv_status_on_client.trailing_metadata =
@@ -218,10 +218,10 @@ void resource_quota_server(grpc_end2end_test_config config) {
     op->data.recv_status_on_client.status = &status[i];
     op->data.recv_status_on_client.status_details = &details[i];
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
     error = grpc_call_start_batch(client_calls[i], ops, (size_t)(op - ops),
-                                  tag(CLIENT_BASE_TAG + i), NULL);
+                                  tag(CLIENT_BASE_TAG + i), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
 
     pending_client_calls++;
@@ -231,7 +231,7 @@ void resource_quota_server(grpc_end2end_test_config config) {
              pending_server_end_calls >
          0) {
     grpc_event ev =
-        grpc_completion_queue_next(f.cq, n_seconds_from_now(60), NULL);
+        grpc_completion_queue_next(f.cq, n_seconds_from_now(60), nullptr);
     GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
 
     int ev_tag = (int)(intptr_t)ev.tag;
@@ -278,16 +278,16 @@ void resource_quota_server(grpc_end2end_test_config config) {
       op->op = GRPC_OP_SEND_INITIAL_METADATA;
       op->data.send_initial_metadata.count = 0;
       op->flags = 0;
-      op->reserved = NULL;
+      op->reserved = nullptr;
       op++;
       op->op = GRPC_OP_RECV_MESSAGE;
       op->data.recv_message.recv_message = &request_payload_recv[call_id];
       op->flags = 0;
-      op->reserved = NULL;
+      op->reserved = nullptr;
       op++;
       error =
           grpc_call_start_batch(server_calls[call_id], ops, (size_t)(op - ops),
-                                tag(SERVER_RECV_BASE_TAG + call_id), NULL);
+                                tag(SERVER_RECV_BASE_TAG + call_id), nullptr);
       GPR_ASSERT(GRPC_CALL_OK == error);
 
       GPR_ASSERT(pending_server_start_calls > 0);
@@ -303,12 +303,12 @@ void resource_quota_server(grpc_end2end_test_config config) {
       GPR_ASSERT(call_id < NUM_CALLS);
 
       if (ev.success) {
-        if (request_payload_recv[call_id] != NULL) {
+        if (request_payload_recv[call_id] != nullptr) {
           grpc_byte_buffer_destroy(request_payload_recv[call_id]);
-          request_payload_recv[call_id] = NULL;
+          request_payload_recv[call_id] = nullptr;
         }
       } else {
-        GPR_ASSERT(request_payload_recv[call_id] == NULL);
+        GPR_ASSERT(request_payload_recv[call_id] == nullptr);
       }
 
       memset(ops, 0, sizeof(ops));
@@ -316,7 +316,7 @@ void resource_quota_server(grpc_end2end_test_config config) {
       op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
       op->data.recv_close_on_server.cancelled = &was_cancelled[call_id];
       op->flags = 0;
-      op->reserved = NULL;
+      op->reserved = nullptr;
       op++;
       op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
       op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -324,11 +324,11 @@ void resource_quota_server(grpc_end2end_test_config config) {
       grpc_slice status_details = grpc_slice_from_static_string("xyz");
       op->data.send_status_from_server.status_details = &status_details;
       op->flags = 0;
-      op->reserved = NULL;
+      op->reserved = nullptr;
       op++;
       error =
           grpc_call_start_batch(server_calls[call_id], ops, (size_t)(op - ops),
-                                tag(SERVER_END_BASE_TAG + call_id), NULL);
+                                tag(SERVER_END_BASE_TAG + call_id), nullptr);
       GPR_ASSERT(GRPC_CALL_OK == error);
 
       GPR_ASSERT(pending_server_recv_calls > 0);
diff --git a/test/core/end2end/tests/server_finishes_request.c b/test/core/end2end/tests/server_finishes_request.cc
index 49b9f27396..46b874b569 100644
--- a/test/core/end2end/tests/server_finishes_request.c
+++ b/test/core/end2end/tests/server_finishes_request.cc
@@ -30,12 +30,12 @@
 #include "src/core/lib/support/string.h"
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -52,31 +52,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -88,11 +88,11 @@ static void end_test(grpc_end2end_test_fixture *f) {
 
 static void simple_request_body(grpc_end2end_test_config config,
                                 grpc_end2end_test_fixture f) {
-  grpc_call *c;
-  grpc_call *s;
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  grpc_call* c;
+  grpc_call* s;
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -104,10 +104,10 @@ static void simple_request_body(grpc_end2end_test_config config,
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -120,21 +120,21 @@ static void simple_request_body(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -149,7 +149,7 @@ static void simple_request_body(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -157,14 +157,14 @@ static void simple_request_body(grpc_end2end_test_config config,
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -193,7 +193,7 @@ static void simple_request_body(grpc_end2end_test_config config,
 static void test_invoke_simple_request(grpc_end2end_test_config config) {
   grpc_end2end_test_fixture f;
 
-  f = begin_test(config, "test_invoke_simple_request", NULL, NULL);
+  f = begin_test(config, "test_invoke_simple_request", nullptr, nullptr);
   simple_request_body(config, f);
   end_test(&f);
   config.tear_down_data(&f);
diff --git a/test/core/end2end/tests/shutdown_finishes_calls.c b/test/core/end2end/tests/shutdown_finishes_calls.cc
index f90359f09a..fce23f3b6a 100644
--- a/test/core/end2end/tests/shutdown_finishes_calls.c
+++ b/test/core/end2end/tests/shutdown_finishes_calls.cc
@@ -28,12 +28,12 @@
 #include <grpc/support/useful.h>
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -50,20 +50,20 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_client(f);
 
   grpc_completion_queue_shutdown(f->cq);
@@ -75,13 +75,14 @@ static void end_test(grpc_end2end_test_fixture *f) {
 
 static void test_early_server_shutdown_finishes_inflight_calls(
     grpc_end2end_test_config config) {
-  grpc_call *c;
-  grpc_call *s;
-  grpc_end2end_test_fixture f = begin_test(
-      config, "test_early_server_shutdown_finishes_inflight_calls", NULL, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  grpc_call* c;
+  grpc_call* s;
+  grpc_end2end_test_fixture f =
+      begin_test(config, "test_early_server_shutdown_finishes_inflight_calls",
+                 nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -93,10 +94,10 @@ static void test_early_server_shutdown_finishes_inflight_calls(
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -108,27 +109,27 @@ static void test_early_server_shutdown_finishes_inflight_calls(
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
-  op->data.send_initial_metadata.metadata = NULL;
+  op->data.send_initial_metadata.metadata = nullptr;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -143,9 +144,9 @@ static void test_early_server_shutdown_finishes_inflight_calls(
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   /* shutdown and destroy the server */
diff --git a/test/core/end2end/tests/shutdown_finishes_tags.c b/test/core/end2end/tests/shutdown_finishes_tags.cc
index 7914cc95ba..de64eba612 100644
--- a/test/core/end2end/tests/shutdown_finishes_tags.c
+++ b/test/core/end2end/tests/shutdown_finishes_tags.cc
@@ -28,12 +28,12 @@
 #include <grpc/support/useful.h>
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -50,20 +50,20 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_client(f);
 
   grpc_completion_queue_shutdown(f->cq);
@@ -76,9 +76,9 @@ static void end_test(grpc_end2end_test_fixture *f) {
 static void test_early_server_shutdown_finishes_tags(
     grpc_end2end_test_config config) {
   grpc_end2end_test_fixture f = begin_test(
-      config, "test_early_server_shutdown_finishes_tags", NULL, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
-  grpc_call *s = (grpc_call *)(uintptr_t)1;
+      config, "test_early_server_shutdown_finishes_tags", nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
+  grpc_call* s = (grpc_call*)(uintptr_t)1;
   grpc_call_details call_details;
   grpc_metadata_array request_metadata_recv;
 
@@ -94,7 +94,7 @@ static void test_early_server_shutdown_finishes_tags(
   CQ_EXPECT_COMPLETION(cqv, tag(101), 0);
   CQ_EXPECT_COMPLETION(cqv, tag(1000), 1);
   cq_verify(cqv);
-  GPR_ASSERT(s == NULL);
+  GPR_ASSERT(s == nullptr);
 
   grpc_server_destroy(f.server);
 
diff --git a/test/core/end2end/tests/simple_cacheable_request.c b/test/core/end2end/tests/simple_cacheable_request.cc
index faa5c193dc..d8034dcf6d 100644
--- a/test/core/end2end/tests/simple_cacheable_request.c
+++ b/test/core/end2end/tests/simple_cacheable_request.cc
@@ -30,12 +30,12 @@
 
 enum { TIMEOUT = 200000 };
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -52,31 +52,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -89,43 +89,43 @@ static void end_test(grpc_end2end_test_fixture *f) {
 /* Request/response with metadata and payload.*/
 static void test_cacheable_request_response_with_metadata_and_payload(
     grpc_end2end_test_config config) {
-  grpc_call *c;
-  grpc_call *s;
+  grpc_call* c;
+  grpc_call* s;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
   grpc_slice response_payload_slice =
       grpc_slice_from_copied_string("hello you");
-  grpc_byte_buffer *request_payload =
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
-  grpc_byte_buffer *response_payload =
+  grpc_byte_buffer* response_payload =
       grpc_raw_byte_buffer_create(&response_payload_slice, 1);
   grpc_metadata meta_c[2] = {{grpc_slice_from_static_string("key1"),
                               grpc_slice_from_static_string("val1"),
                               0,
-                              {{NULL, NULL, NULL, NULL}}},
+                              {{nullptr, nullptr, nullptr, nullptr}}},
                              {grpc_slice_from_static_string("key2"),
                               grpc_slice_from_static_string("val2"),
                               0,
-                              {{NULL, NULL, NULL, NULL}}}};
+                              {{nullptr, nullptr, nullptr, nullptr}}}};
   grpc_metadata meta_s[2] = {{grpc_slice_from_static_string("key3"),
                               grpc_slice_from_static_string("val3"),
                               0,
-                              {{NULL, NULL, NULL, NULL}}},
+                              {{nullptr, nullptr, nullptr, nullptr}}},
                              {grpc_slice_from_static_string("key4"),
                               grpc_slice_from_static_string("val4"),
                               0,
-                              {{NULL, NULL, NULL, NULL}}}};
+                              {{nullptr, nullptr, nullptr, nullptr}}}};
   grpc_end2end_test_fixture f = begin_test(
-      config, "test_cacheable_request_response_with_metadata_and_payload", NULL,
-      NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+      config, "test_cacheable_request_response_with_metadata_and_payload",
+      nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *request_payload_recv = NULL;
-  grpc_byte_buffer *response_payload_recv = NULL;
+  grpc_byte_buffer* request_payload_recv = nullptr;
+  grpc_byte_buffer* response_payload_recv = nullptr;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
@@ -134,10 +134,10 @@ static void test_cacheable_request_response_with_metadata_and_payload(
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -151,35 +151,35 @@ static void test_cacheable_request_response_with_metadata_and_payload(
   op->data.send_initial_metadata.count = 2;
   op->data.send_initial_metadata.metadata = meta_c;
   op->flags = GRPC_INITIAL_METADATA_CACHEABLE_REQUEST;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &response_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -195,14 +195,14 @@ static void test_cacheable_request_response_with_metadata_and_payload(
   op->data.send_initial_metadata.count = 2;
   op->data.send_initial_metadata.metadata = meta_s;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &request_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -213,12 +213,12 @@ static void test_cacheable_request_response_with_metadata_and_payload(
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = response_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -226,9 +226,9 @@ static void test_cacheable_request_response_with_metadata_and_payload(
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(103), 1);
diff --git a/test/core/end2end/tests/simple_delayed_request.c b/test/core/end2end/tests/simple_delayed_request.cc
index c3f66a07aa..0ad224f579 100644
--- a/test/core/end2end/tests/simple_delayed_request.c
+++ b/test/core/end2end/tests/simple_delayed_request.cc
@@ -28,7 +28,7 @@
 #include <grpc/support/useful.h>
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static gpr_timespec n_seconds_from_now(int n) {
   return grpc_timeout_seconds_to_deadline(n);
@@ -38,31 +38,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -73,15 +73,15 @@ static void end_test(grpc_end2end_test_fixture *f) {
 }
 
 static void simple_delayed_request_body(grpc_end2end_test_config config,
-                                        grpc_end2end_test_fixture *f,
-                                        grpc_channel_args *client_args,
-                                        grpc_channel_args *server_args,
+                                        grpc_end2end_test_fixture* f,
+                                        grpc_channel_args* client_args,
+                                        grpc_channel_args* server_args,
                                         long delay_us) {
-  grpc_call *c;
-  grpc_call *s;
-  cq_verifier *cqv = cq_verifier_create(f->cq);
+  grpc_call* c;
+  grpc_call* s;
+  cq_verifier* cqv = cq_verifier_create(f->cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -96,10 +96,10 @@ static void simple_delayed_request_body(grpc_end2end_test_config config,
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f->client, NULL, GRPC_PROPAGATE_DEFAULTS, f->cq,
+      f->client, nullptr, GRPC_PROPAGATE_DEFAULTS, f->cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -112,25 +112,25 @@ static void simple_delayed_request_body(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = GRPC_INITIAL_METADATA_WAIT_FOR_READY;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -145,7 +145,7 @@ static void simple_delayed_request_body(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -153,14 +153,14 @@ static void simple_delayed_request_body(grpc_end2end_test_config config,
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -191,16 +191,17 @@ static void test_simple_delayed_request_short(grpc_end2end_test_config config) {
   grpc_channel_args client_args;
   grpc_arg arg_array[1];
   arg_array[0].type = GRPC_ARG_INTEGER;
-  arg_array[0].key = "grpc.testing.fixed_reconnect_backoff_ms";
+  arg_array[0].key =
+      const_cast<char*>("grpc.testing.fixed_reconnect_backoff_ms");
   arg_array[0].value.integer = 1000;
   client_args.args = arg_array;
   client_args.num_args = 1;
 
   gpr_log(GPR_INFO, "Running test: %s/%s", "test_simple_delayed_request_short",
           config.name);
-  f = config.create_fixture(NULL, NULL);
+  f = config.create_fixture(nullptr, nullptr);
 
-  simple_delayed_request_body(config, &f, &client_args, NULL, 100000);
+  simple_delayed_request_body(config, &f, &client_args, nullptr, 100000);
   end_test(&f);
   config.tear_down_data(&f);
 }
@@ -210,16 +211,17 @@ static void test_simple_delayed_request_long(grpc_end2end_test_config config) {
   grpc_channel_args client_args;
   grpc_arg arg_array[1];
   arg_array[0].type = GRPC_ARG_INTEGER;
-  arg_array[0].key = "grpc.testing.fixed_reconnect_backoff_ms";
+  arg_array[0].key =
+      const_cast<char*>("grpc.testing.fixed_reconnect_backoff_ms");
   arg_array[0].value.integer = 1000;
   client_args.args = arg_array;
   client_args.num_args = 1;
 
   gpr_log(GPR_INFO, "Running test: %s/%s", "test_simple_delayed_request_long",
           config.name);
-  f = config.create_fixture(NULL, NULL);
+  f = config.create_fixture(nullptr, nullptr);
   /* This timeout should be longer than a single retry */
-  simple_delayed_request_body(config, &f, &client_args, NULL, 1500000);
+  simple_delayed_request_body(config, &f, &client_args, nullptr, 1500000);
   end_test(&f);
   config.tear_down_data(&f);
 }
diff --git a/test/core/end2end/tests/simple_metadata.c b/test/core/end2end/tests/simple_metadata.cc
index 17e7f696e2..1a741169d4 100644
--- a/test/core/end2end/tests/simple_metadata.c
+++ b/test/core/end2end/tests/simple_metadata.cc
@@ -28,12 +28,12 @@
 #include <grpc/support/useful.h>
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -50,31 +50,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -87,42 +87,43 @@ static void end_test(grpc_end2end_test_fixture *f) {
 /* Request/response with metadata and payload.*/
 static void test_request_response_with_metadata_and_payload(
     grpc_end2end_test_config config) {
-  grpc_call *c;
-  grpc_call *s;
+  grpc_call* c;
+  grpc_call* s;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
   grpc_slice response_payload_slice =
       grpc_slice_from_copied_string("hello you");
-  grpc_byte_buffer *request_payload =
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
-  grpc_byte_buffer *response_payload =
+  grpc_byte_buffer* response_payload =
       grpc_raw_byte_buffer_create(&response_payload_slice, 1);
   grpc_metadata meta_c[2] = {{grpc_slice_from_static_string("key1"),
                               grpc_slice_from_static_string("val1"),
                               0,
-                              {{NULL, NULL, NULL, NULL}}},
+                              {{nullptr, nullptr, nullptr, nullptr}}},
                              {grpc_slice_from_static_string("key2"),
                               grpc_slice_from_static_string("val2"),
                               0,
-                              {{NULL, NULL, NULL, NULL}}}};
+                              {{nullptr, nullptr, nullptr, nullptr}}}};
   grpc_metadata meta_s[2] = {{grpc_slice_from_static_string("key3"),
                               grpc_slice_from_static_string("val3"),
                               0,
-                              {{NULL, NULL, NULL, NULL}}},
+                              {{nullptr, nullptr, nullptr, nullptr}}},
                              {grpc_slice_from_static_string("key4"),
                               grpc_slice_from_static_string("val4"),
                               0,
-                              {{NULL, NULL, NULL, NULL}}}};
-  grpc_end2end_test_fixture f = begin_test(
-      config, "test_request_response_with_metadata_and_payload", NULL, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+                              {{nullptr, nullptr, nullptr, nullptr}}}};
+  grpc_end2end_test_fixture f =
+      begin_test(config, "test_request_response_with_metadata_and_payload",
+                 nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *request_payload_recv = NULL;
-  grpc_byte_buffer *response_payload_recv = NULL;
+  grpc_byte_buffer* request_payload_recv = nullptr;
+  grpc_byte_buffer* response_payload_recv = nullptr;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
@@ -131,10 +132,10 @@ static void test_request_response_with_metadata_and_payload(
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -148,35 +149,35 @@ static void test_request_response_with_metadata_and_payload(
   op->data.send_initial_metadata.count = 2;
   op->data.send_initial_metadata.metadata = meta_c;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &response_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -192,14 +193,14 @@ static void test_request_response_with_metadata_and_payload(
   op->data.send_initial_metadata.count = 2;
   op->data.send_initial_metadata.metadata = meta_s;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &request_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -210,12 +211,12 @@ static void test_request_response_with_metadata_and_payload(
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = response_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -223,9 +224,9 @@ static void test_request_response_with_metadata_and_payload(
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(103), 1);
diff --git a/test/core/end2end/tests/simple_request.c b/test/core/end2end/tests/simple_request.cc
index 7ce7e1f285..ec7425aa09 100644
--- a/test/core/end2end/tests/simple_request.c
+++ b/test/core/end2end/tests/simple_request.cc
@@ -31,12 +31,12 @@
 #include "src/core/lib/support/string.h"
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -53,31 +53,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -89,11 +89,11 @@ static void end_test(grpc_end2end_test_fixture *f) {
 
 static void simple_request_body(grpc_end2end_test_config config,
                                 grpc_end2end_test_fixture f) {
-  grpc_call *c;
-  grpc_call *s;
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  grpc_call* c;
+  grpc_call* s;
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -102,22 +102,24 @@ static void simple_request_body(grpc_end2end_test_config config,
   grpc_call_error error;
   grpc_slice details;
   int was_cancelled = 2;
-  char *peer;
-  grpc_stats_data *before = gpr_malloc(sizeof(grpc_stats_data));
-  grpc_stats_data *after = gpr_malloc(sizeof(grpc_stats_data));
+  char* peer;
+  grpc_stats_data* before =
+      static_cast<grpc_stats_data*>(gpr_malloc(sizeof(grpc_stats_data)));
+  grpc_stats_data* after =
+      static_cast<grpc_stats_data*>(gpr_malloc(sizeof(grpc_stats_data)));
 
   grpc_stats_collect(before);
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   peer = grpc_call_get_peer(c);
-  GPR_ASSERT(peer != NULL);
+  GPR_ASSERT(peer != nullptr);
   gpr_log(GPR_DEBUG, "client_peer_before_call=%s", peer);
   gpr_free(peer);
 
@@ -131,25 +133,25 @@ static void simple_request_body(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -160,11 +162,11 @@ static void simple_request_body(grpc_end2end_test_config config,
   cq_verify(cqv);
 
   peer = grpc_call_get_peer(s);
-  GPR_ASSERT(peer != NULL);
+  GPR_ASSERT(peer != nullptr);
   gpr_log(GPR_DEBUG, "server_peer=%s", peer);
   gpr_free(peer);
   peer = grpc_call_get_peer(c);
-  GPR_ASSERT(peer != NULL);
+  GPR_ASSERT(peer != nullptr);
   gpr_log(GPR_DEBUG, "client_peer=%s", peer);
   gpr_free(peer);
 
@@ -173,7 +175,7 @@ static void simple_request_body(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -181,14 +183,14 @@ static void simple_request_body(grpc_end2end_test_config config,
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -216,7 +218,7 @@ static void simple_request_body(grpc_end2end_test_config config,
 
   grpc_stats_collect(after);
 
-  char *stats = grpc_stats_data_as_json(after);
+  char* stats = grpc_stats_data_as_json(after);
   gpr_log(GPR_DEBUG, "%s", stats);
   gpr_free(stats);
 
@@ -237,7 +239,7 @@ static void simple_request_body(grpc_end2end_test_config config,
 static void test_invoke_simple_request(grpc_end2end_test_config config) {
   grpc_end2end_test_fixture f;
 
-  f = begin_test(config, "test_invoke_simple_request", NULL, NULL);
+  f = begin_test(config, "test_invoke_simple_request", nullptr, nullptr);
   simple_request_body(config, f);
   end_test(&f);
   config.tear_down_data(&f);
@@ -246,7 +248,7 @@ static void test_invoke_simple_request(grpc_end2end_test_config config) {
 static void test_invoke_10_simple_requests(grpc_end2end_test_config config) {
   int i;
   grpc_end2end_test_fixture f =
-      begin_test(config, "test_invoke_10_simple_requests", NULL, NULL);
+      begin_test(config, "test_invoke_10_simple_requests", nullptr, nullptr);
   for (i = 0; i < 10; i++) {
     simple_request_body(config, f);
     gpr_log(GPR_INFO, "Running test: Passed simple request %d", i);
diff --git a/test/core/end2end/tests/stream_compression_compressed_payload.c b/test/core/end2end/tests/stream_compression_compressed_payload.cc
index 8b47741cd4..d73346468a 100644
--- a/test/core/end2end/tests/stream_compression_compressed_payload.c
+++ b/test/core/end2end/tests/stream_compression_compressed_payload.cc
@@ -36,12 +36,12 @@
 #include "src/core/lib/transport/static_metadata.h"
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -58,31 +58,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -93,30 +93,30 @@ static void end_test(grpc_end2end_test_fixture *f) {
 }
 
 static void request_for_disabled_algorithm(
-    grpc_end2end_test_config config, const char *test_name,
+    grpc_end2end_test_config config, const char* test_name,
     uint32_t send_flags_bitmask,
     grpc_stream_compression_algorithm algorithm_to_disable,
     grpc_stream_compression_algorithm requested_client_compression_algorithm,
-    grpc_status_code expected_error, grpc_metadata *client_metadata) {
-  grpc_call *c;
-  grpc_call *s;
+    grpc_status_code expected_error, grpc_metadata* client_metadata) {
+  grpc_call* c;
+  grpc_call* s;
   grpc_slice request_payload_slice;
-  grpc_byte_buffer *request_payload;
-  grpc_channel_args *client_args;
-  grpc_channel_args *server_args;
+  grpc_byte_buffer* request_payload;
+  grpc_channel_args* client_args;
+  grpc_channel_args* server_args;
   grpc_end2end_test_fixture f;
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *request_payload_recv = NULL;
+  grpc_byte_buffer* request_payload_recv = nullptr;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
   grpc_slice details;
   int was_cancelled = 2;
-  cq_verifier *cqv;
+  cq_verifier* cqv;
   char str[1024];
 
   memset(str, 'x', 1023);
@@ -125,9 +125,9 @@ static void request_for_disabled_algorithm(
   request_payload = grpc_raw_byte_buffer_create(&request_payload_slice, 1);
 
   client_args = grpc_channel_args_set_stream_compression_algorithm(
-      NULL, requested_client_compression_algorithm);
+      nullptr, requested_client_compression_algorithm);
   server_args = grpc_channel_args_set_stream_compression_algorithm(
-      NULL, GRPC_STREAM_COMPRESS_NONE);
+      nullptr, GRPC_STREAM_COMPRESS_NONE);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     server_args = grpc_channel_args_stream_compression_algorithm_set_state(
@@ -140,10 +140,10 @@ static void request_for_disabled_algorithm(
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -159,37 +159,37 @@ static void request_for_disabled_algorithm(
   memset(ops, 0, sizeof(ops));
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
-  if (client_metadata != NULL) {
+  if (client_metadata != nullptr) {
     op->data.send_initial_metadata.count = 1;
     op->data.send_initial_metadata.metadata = client_metadata;
   } else {
     op->data.send_initial_metadata.count = 0;
   }
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = send_flags_bitmask;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(101), true);
@@ -200,14 +200,14 @@ static void request_for_disabled_algorithm(
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &request_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), false);
@@ -216,9 +216,9 @@ static void request_for_disabled_algorithm(
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(103), true);
@@ -229,10 +229,10 @@ static void request_for_disabled_algorithm(
   /* with a certain error */
   GPR_ASSERT(status == expected_error);
 
-  const char *algo_name = NULL;
+  const char* algo_name = nullptr;
   GPR_ASSERT(
       grpc_stream_compression_algorithm_name(algorithm_to_disable, &algo_name));
-  char *expected_details = NULL;
+  char* expected_details = nullptr;
   gpr_asprintf(&expected_details,
                "Stream compression algorithm '%s' is disabled.", algo_name);
   /* and we expect a specific reason for it */
@@ -269,7 +269,7 @@ static void request_for_disabled_algorithm(
 }
 
 static void request_with_payload_template(
-    grpc_end2end_test_config config, const char *test_name,
+    grpc_end2end_test_config config, const char* test_name,
     uint32_t client_send_flags_bitmask,
     grpc_stream_compression_algorithm
         default_client_channel_compression_algorithm,
@@ -277,32 +277,32 @@ static void request_with_payload_template(
         default_server_channel_compression_algorithm,
     grpc_stream_compression_algorithm expected_client_compression_algorithm,
     grpc_stream_compression_algorithm expected_server_compression_algorithm,
-    grpc_metadata *client_init_metadata, bool set_server_level,
+    grpc_metadata* client_init_metadata, bool set_server_level,
     grpc_stream_compression_level server_compression_level,
     bool send_message_before_initial_metadata,
     bool set_default_server_message_compression_algorithm,
     grpc_compression_algorithm default_server_message_compression_algorithm) {
-  grpc_call *c;
-  grpc_call *s;
+  grpc_call* c;
+  grpc_call* s;
   grpc_slice request_payload_slice;
-  grpc_byte_buffer *request_payload = NULL;
-  grpc_channel_args *client_args;
-  grpc_channel_args *server_args;
+  grpc_byte_buffer* request_payload = nullptr;
+  grpc_channel_args* client_args;
+  grpc_channel_args* server_args;
   grpc_end2end_test_fixture f;
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *request_payload_recv = NULL;
-  grpc_byte_buffer *response_payload;
-  grpc_byte_buffer *response_payload_recv;
+  grpc_byte_buffer* request_payload_recv = nullptr;
+  grpc_byte_buffer* response_payload;
+  grpc_byte_buffer* response_payload_recv;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
   grpc_slice details;
   int was_cancelled = 2;
-  cq_verifier *cqv;
+  cq_verifier* cqv;
   char request_str[1024];
   char response_str[1024];
 
@@ -317,13 +317,13 @@ static void request_with_payload_template(
       grpc_slice_from_copied_string(response_str);
 
   client_args = grpc_channel_args_set_stream_compression_algorithm(
-      NULL, default_client_channel_compression_algorithm);
+      nullptr, default_client_channel_compression_algorithm);
   if (set_default_server_message_compression_algorithm) {
     server_args = grpc_channel_args_set_compression_algorithm(
-        NULL, default_server_message_compression_algorithm);
+        nullptr, default_server_message_compression_algorithm);
   } else {
     server_args = grpc_channel_args_set_stream_compression_algorithm(
-        NULL, default_server_channel_compression_algorithm);
+        nullptr, default_server_channel_compression_algorithm);
   }
 
   f = begin_test(config, test_name, client_args, server_args);
@@ -331,10 +331,10 @@ static void request_with_payload_template(
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -349,9 +349,9 @@ static void request_with_payload_template(
     op->op = GRPC_OP_SEND_MESSAGE;
     op->data.send_message.send_message = request_payload;
     op->flags = client_send_flags_bitmask;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), NULL);
+    error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
     CQ_EXPECT_COMPLETION(cqv, tag(2), true);
   }
@@ -359,28 +359,28 @@ static void request_with_payload_template(
   memset(ops, 0, sizeof(ops));
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
-  if (client_init_metadata != NULL) {
+  if (client_init_metadata != nullptr) {
     op->data.send_initial_metadata.count = 1;
     op->data.send_initial_metadata.metadata = client_init_metadata;
   } else {
     op->data.send_initial_metadata.count = 0;
   }
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -418,14 +418,14 @@ static void request_with_payload_template(
         server_compression_level;
   }
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(101), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(101), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   for (int i = 0; i < 2; i++) {
@@ -438,9 +438,10 @@ static void request_with_payload_template(
       op->op = GRPC_OP_SEND_MESSAGE;
       op->data.send_message.send_message = request_payload;
       op->flags = client_send_flags_bitmask;
-      op->reserved = NULL;
+      op->reserved = nullptr;
       op++;
-      error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), NULL);
+      error =
+          grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), nullptr);
       GPR_ASSERT(GRPC_CALL_OK == error);
       CQ_EXPECT_COMPLETION(cqv, tag(2), 1);
     }
@@ -450,9 +451,10 @@ static void request_with_payload_template(
     op->op = GRPC_OP_RECV_MESSAGE;
     op->data.recv_message.recv_message = &request_payload_recv;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+    error =
+        grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
 
     CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -466,9 +468,10 @@ static void request_with_payload_template(
     op->op = GRPC_OP_SEND_MESSAGE;
     op->data.send_message.send_message = response_payload;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), NULL);
+    error =
+        grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
 
     memset(ops, 0, sizeof(ops));
@@ -476,9 +479,9 @@ static void request_with_payload_template(
     op->op = GRPC_OP_RECV_MESSAGE;
     op->data.recv_message.recv_message = &response_payload_recv;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(3), NULL);
+    error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(3), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
 
     CQ_EXPECT_COMPLETION(cqv, tag(103), 1);
@@ -501,9 +504,9 @@ static void request_with_payload_template(
   op = ops;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(4), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(4), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   memset(ops, 0, sizeof(ops));
@@ -514,9 +517,9 @@ static void request_with_payload_template(
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(104), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(104), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
@@ -559,7 +562,7 @@ static void test_invoke_request_with_compressed_payload(
   request_with_payload_template(
       config, "test_invoke_request_with_compressed_payload", 0,
       GRPC_STREAM_COMPRESS_GZIP, GRPC_STREAM_COMPRESS_GZIP,
-      GRPC_STREAM_COMPRESS_GZIP, GRPC_STREAM_COMPRESS_GZIP, NULL,
+      GRPC_STREAM_COMPRESS_GZIP, GRPC_STREAM_COMPRESS_GZIP, nullptr,
       false, /* ignored */
       GRPC_STREAM_COMPRESS_LEVEL_NONE, false, false, GRPC_COMPRESS_NONE);
 }
@@ -569,7 +572,7 @@ static void test_invoke_request_with_send_message_before_initial_metadata(
   request_with_payload_template(
       config, "test_invoke_request_with_send_message_before_initial_metadata",
       0, GRPC_STREAM_COMPRESS_GZIP, GRPC_STREAM_COMPRESS_GZIP,
-      GRPC_STREAM_COMPRESS_GZIP, GRPC_STREAM_COMPRESS_GZIP, NULL,
+      GRPC_STREAM_COMPRESS_GZIP, GRPC_STREAM_COMPRESS_GZIP, nullptr,
       false, /* ignored */
       GRPC_STREAM_COMPRESS_LEVEL_NONE, true, false, GRPC_COMPRESS_NONE);
 }
@@ -580,8 +583,8 @@ static void test_invoke_request_with_server_level(
       config, "test_invoke_request_with_server_level", 0,
       GRPC_STREAM_COMPRESS_NONE, GRPC_STREAM_COMPRESS_NONE,
       GRPC_STREAM_COMPRESS_NONE, GRPC_STREAM_COMPRESS_GZIP,
-      /* ignored */ NULL, true, GRPC_STREAM_COMPRESS_LEVEL_HIGH, false, false,
-      GRPC_COMPRESS_NONE);
+      /* ignored */ nullptr, true, GRPC_STREAM_COMPRESS_LEVEL_HIGH, false,
+      false, GRPC_COMPRESS_NONE);
 }
 
 static void test_invoke_request_with_compressed_payload_md_override(
@@ -626,7 +629,7 @@ static void test_invoke_request_with_disabled_algorithm(
   request_for_disabled_algorithm(
       config, "test_invoke_request_with_disabled_algorithm", 0,
       GRPC_STREAM_COMPRESS_GZIP, GRPC_STREAM_COMPRESS_GZIP,
-      GRPC_STATUS_UNIMPLEMENTED, NULL);
+      GRPC_STATUS_UNIMPLEMENTED, nullptr);
 }
 
 static void test_stream_compression_override_message_compression(
@@ -638,7 +641,7 @@ static void test_stream_compression_override_message_compression(
       GRPC_STREAM_COMPRESS_NONE,
       grpc_stream_compression_algorithm_for_level(
           level, (1u << GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT) - 1),
-      /* ignored */ NULL, true, level, false, true, GRPC_COMPRESS_GZIP);
+      /* ignored */ nullptr, true, level, false, true, GRPC_COMPRESS_GZIP);
 }
 
 void stream_compression_compressed_payload(grpc_end2end_test_config config) {
diff --git a/test/core/end2end/tests/stream_compression_payload.c b/test/core/end2end/tests/stream_compression_payload.cc
index e47d2aa93c..924961ea55 100644
--- a/test/core/end2end/tests/stream_compression_payload.c
+++ b/test/core/end2end/tests/stream_compression_payload.cc
@@ -23,7 +23,6 @@
 
 #include <grpc/byte_buffer.h>
 #include <grpc/compression.h>
-#include <grpc/compression.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
@@ -32,12 +31,12 @@
 #include "src/core/lib/surface/call.h"
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -54,31 +53,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -93,9 +92,9 @@ static void end_test(grpc_end2end_test_fixture *f) {
 static grpc_slice generate_random_slice() {
   size_t i;
   static const char chars[] = "abcdefghijklmnopqrstuvwxyz1234567890";
-  char *output;
+  char* output;
   const size_t output_size = 1024 * 1024;
-  output = (char *)gpr_malloc(output_size);
+  output = (char*)gpr_malloc(output_size);
   for (i = 0; i < output_size - 1; ++i) {
     output[i] = chars[rand() % (int)(sizeof(chars) - 1)];
   }
@@ -113,20 +112,20 @@ static void request_response_with_payload(grpc_end2end_test_config config,
   grpc_slice request_payload_slice = generate_random_slice();
   grpc_slice response_payload_slice = generate_random_slice();
 
-  grpc_call *c;
-  grpc_call *s;
-  grpc_byte_buffer *request_payload =
+  grpc_call* c;
+  grpc_call* s;
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
-  grpc_byte_buffer *response_payload =
+  grpc_byte_buffer* response_payload =
       grpc_raw_byte_buffer_create(&response_payload_slice, 1);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *request_payload_recv = NULL;
-  grpc_byte_buffer *response_payload_recv = NULL;
+  grpc_byte_buffer* request_payload_recv = nullptr;
+  grpc_byte_buffer* response_payload_recv = nullptr;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
@@ -135,10 +134,10 @@ static void request_response_with_payload(grpc_end2end_test_config config,
 
   gpr_timespec deadline = n_seconds_from_now(60);
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -151,35 +150,35 @@ static void request_response_with_payload(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &response_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -194,14 +193,14 @@ static void request_response_with_payload(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &request_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -212,12 +211,12 @@ static void request_response_with_payload(grpc_end2end_test_config config,
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = response_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -225,9 +224,9 @@ static void request_response_with_payload(grpc_end2end_test_config config,
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(103), 1);
@@ -265,12 +264,12 @@ static void request_response_with_payload(grpc_end2end_test_config config,
    payload and status. */
 static void test_invoke_request_response_with_payload(
     grpc_end2end_test_config config) {
-  grpc_channel_args *client_args =
+  grpc_channel_args* client_args =
       grpc_channel_args_set_stream_compression_algorithm(
-          NULL, GRPC_STREAM_COMPRESS_GZIP);
-  grpc_channel_args *server_args =
+          nullptr, GRPC_STREAM_COMPRESS_GZIP);
+  grpc_channel_args* server_args =
       grpc_channel_args_set_stream_compression_algorithm(
-          NULL, GRPC_STREAM_COMPRESS_GZIP);
+          nullptr, GRPC_STREAM_COMPRESS_GZIP);
   grpc_end2end_test_fixture f =
       begin_test(config, "test_invoke_request_response_with_payload",
                  client_args, server_args);
@@ -289,7 +288,7 @@ static void test_invoke_10_request_response_with_payload(
     grpc_end2end_test_config config) {
   int i;
   grpc_end2end_test_fixture f = begin_test(
-      config, "test_invoke_10_request_response_with_payload", NULL, NULL);
+      config, "test_invoke_10_request_response_with_payload", nullptr, nullptr);
   for (i = 0; i < 10; i++) {
     request_response_with_payload(config, f);
   }
diff --git a/test/core/end2end/tests/stream_compression_ping_pong_streaming.c b/test/core/end2end/tests/stream_compression_ping_pong_streaming.cc
index 4c1a34cc64..d3b526f04e 100644
--- a/test/core/end2end/tests/stream_compression_ping_pong_streaming.c
+++ b/test/core/end2end/tests/stream_compression_ping_pong_streaming.cc
@@ -31,12 +31,12 @@
 #include "src/core/lib/surface/call.h"
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -53,31 +53,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -90,19 +90,19 @@ static void end_test(grpc_end2end_test_fixture *f) {
 /* Client pings and server pongs. Repeat messages rounds before finishing. */
 static void test_pingpong_streaming(grpc_end2end_test_config config,
                                     int messages) {
-  grpc_channel_args *client_args =
+  grpc_channel_args* client_args =
       grpc_channel_args_set_stream_compression_algorithm(
-          NULL, GRPC_STREAM_COMPRESS_GZIP);
-  grpc_channel_args *server_args =
+          nullptr, GRPC_STREAM_COMPRESS_GZIP);
+  grpc_channel_args* server_args =
       grpc_channel_args_set_stream_compression_algorithm(
-          NULL, GRPC_STREAM_COMPRESS_GZIP);
+          nullptr, GRPC_STREAM_COMPRESS_GZIP);
   grpc_end2end_test_fixture f =
       begin_test(config, "test_pingpong_streaming", client_args, server_args);
-  grpc_call *c;
-  grpc_call *s;
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  grpc_call* c;
+  grpc_call* s;
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
@@ -111,10 +111,10 @@ static void test_pingpong_streaming(grpc_end2end_test_config config,
   grpc_call_error error;
   grpc_slice details;
   int was_cancelled = 2;
-  grpc_byte_buffer *request_payload;
-  grpc_byte_buffer *request_payload_recv;
-  grpc_byte_buffer *response_payload;
-  grpc_byte_buffer *response_payload_recv;
+  grpc_byte_buffer* request_payload;
+  grpc_byte_buffer* request_payload_recv;
+  grpc_byte_buffer* response_payload;
+  grpc_byte_buffer* response_payload_recv;
   int i;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
@@ -123,10 +123,10 @@ static void test_pingpong_streaming(grpc_end2end_test_config config,
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -139,21 +139,21 @@ static void test_pingpong_streaming(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -168,14 +168,14 @@ static void test_pingpong_streaming(grpc_end2end_test_config config,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(101), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(101), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   for (i = 0; i < messages; i++) {
@@ -187,14 +187,14 @@ static void test_pingpong_streaming(grpc_end2end_test_config config,
     op->op = GRPC_OP_SEND_MESSAGE;
     op->data.send_message.send_message = request_payload;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
     op->op = GRPC_OP_RECV_MESSAGE;
     op->data.recv_message.recv_message = &response_payload_recv;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), NULL);
+    error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
 
     memset(ops, 0, sizeof(ops));
@@ -202,9 +202,10 @@ static void test_pingpong_streaming(grpc_end2end_test_config config,
     op->op = GRPC_OP_RECV_MESSAGE;
     op->data.recv_message.recv_message = &request_payload_recv;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+    error =
+        grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
     CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
     cq_verify(cqv);
@@ -214,9 +215,10 @@ static void test_pingpong_streaming(grpc_end2end_test_config config,
     op->op = GRPC_OP_SEND_MESSAGE;
     op->data.send_message.send_message = response_payload;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), NULL);
+    error =
+        grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
     CQ_EXPECT_COMPLETION(cqv, tag(103), 1);
     CQ_EXPECT_COMPLETION(cqv, tag(2), 1);
@@ -235,9 +237,9 @@ static void test_pingpong_streaming(grpc_end2end_test_config config,
   op = ops;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(3), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(3), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   memset(ops, 0, sizeof(ops));
@@ -248,9 +250,9 @@ static void test_pingpong_streaming(grpc_end2end_test_config config,
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(104), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(104), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
diff --git a/test/core/end2end/tests/streaming_error_response.c b/test/core/end2end/tests/streaming_error_response.cc
index 8891b8674c..fe53fda9ef 100644
--- a/test/core/end2end/tests/streaming_error_response.c
+++ b/test/core/end2end/tests/streaming_error_response.cc
@@ -31,12 +31,12 @@
 #include <grpc/support/useful.h>
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args,
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args,
                                             bool request_status_early) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s/request_status_early=%s", test_name,
@@ -55,31 +55,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -91,24 +91,25 @@ static void end_test(grpc_end2end_test_fixture *f) {
 
 /* Client sends a request with payload, server reads then returns status. */
 static void test(grpc_end2end_test_config config, bool request_status_early) {
-  grpc_call *c;
-  grpc_call *s;
+  grpc_call* c;
+  grpc_call* s;
   grpc_slice response_payload1_slice = grpc_slice_from_copied_string("hello");
-  grpc_byte_buffer *response_payload1 =
+  grpc_byte_buffer* response_payload1 =
       grpc_raw_byte_buffer_create(&response_payload1_slice, 1);
   grpc_slice response_payload2_slice = grpc_slice_from_copied_string("world");
-  grpc_byte_buffer *response_payload2 =
+  grpc_byte_buffer* response_payload2 =
       grpc_raw_byte_buffer_create(&response_payload2_slice, 1);
-  grpc_end2end_test_fixture f = begin_test(config, "streaming_error_response",
-                                           NULL, NULL, request_status_early);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+  grpc_end2end_test_fixture f =
+      begin_test(config, "streaming_error_response", nullptr, nullptr,
+                 request_status_early);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *response_payload1_recv = NULL;
-  grpc_byte_buffer *response_payload2_recv = NULL;
+  grpc_byte_buffer* response_payload1_recv = nullptr;
+  grpc_byte_buffer* response_payload2_recv = nullptr;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
@@ -117,10 +118,10 @@ static void test(grpc_end2end_test_config config, bool request_status_early) {
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -148,7 +149,7 @@ static void test(grpc_end2end_test_config config, bool request_status_early) {
     op->data.recv_status_on_client.status_details = &details;
     op++;
   }
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(
@@ -165,7 +166,7 @@ static void test(grpc_end2end_test_config config, bool request_status_early) {
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = response_payload1;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -179,7 +180,7 @@ static void test(grpc_end2end_test_config config, bool request_status_early) {
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = response_payload2;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(103), 1);
@@ -190,7 +191,7 @@ static void test(grpc_end2end_test_config config, bool request_status_early) {
     op->op = GRPC_OP_RECV_MESSAGE;
     op->data.recv_message.recv_message = &response_payload2_recv;
     op++;
-    error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), NULL);
+    error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
 
     CQ_EXPECT_COMPLETION(cqv, tag(2), 1);
@@ -208,7 +209,7 @@ static void test(grpc_end2end_test_config config, bool request_status_early) {
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(104), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(104), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(104), 1);
@@ -225,14 +226,14 @@ static void test(grpc_end2end_test_config config, bool request_status_early) {
     op->data.recv_status_on_client.status = &status;
     op->data.recv_status_on_client.status_details = &details;
     op++;
-    error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(3), NULL);
+    error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(3), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
 
     CQ_EXPECT_COMPLETION(cqv, tag(3), 1);
     cq_verify(cqv);
 
-    GPR_ASSERT(response_payload1_recv != NULL);
-    GPR_ASSERT(response_payload2_recv != NULL);
+    GPR_ASSERT(response_payload1_recv != nullptr);
+    GPR_ASSERT(response_payload2_recv != nullptr);
   }
 
   GPR_ASSERT(status == GRPC_STATUS_FAILED_PRECONDITION);
diff --git a/test/core/end2end/tests/trailing_metadata.c b/test/core/end2end/tests/trailing_metadata.cc
index 7aa78a04b8..afc56c8dfa 100644
--- a/test/core/end2end/tests/trailing_metadata.c
+++ b/test/core/end2end/tests/trailing_metadata.cc
@@ -28,12 +28,12 @@
 #include <grpc/support/useful.h>
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -50,31 +50,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -87,50 +87,51 @@ static void end_test(grpc_end2end_test_fixture *f) {
 /* Request/response with metadata and payload.*/
 static void test_request_response_with_metadata_and_payload(
     grpc_end2end_test_config config) {
-  grpc_call *c;
-  grpc_call *s;
+  grpc_call* c;
+  grpc_call* s;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
   grpc_slice response_payload_slice =
       grpc_slice_from_copied_string("hello you");
-  grpc_byte_buffer *request_payload =
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
-  grpc_byte_buffer *response_payload =
+  grpc_byte_buffer* response_payload =
       grpc_raw_byte_buffer_create(&response_payload_slice, 1);
   grpc_metadata meta_c[2] = {{grpc_slice_from_static_string("key1"),
                               grpc_slice_from_static_string("val1"),
                               0,
-                              {{NULL, NULL, NULL, NULL}}},
+                              {{nullptr, nullptr, nullptr, nullptr}}},
                              {grpc_slice_from_static_string("key2"),
                               grpc_slice_from_static_string("val2"),
                               0,
-                              {{NULL, NULL, NULL, NULL}}}};
+                              {{nullptr, nullptr, nullptr, nullptr}}}};
   grpc_metadata meta_s[2] = {{grpc_slice_from_static_string("key3"),
                               grpc_slice_from_static_string("val3"),
                               0,
-                              {{NULL, NULL, NULL, NULL}}},
+                              {{nullptr, nullptr, nullptr, nullptr}}},
                              {grpc_slice_from_static_string("key4"),
                               grpc_slice_from_static_string("val4"),
                               0,
-                              {{NULL, NULL, NULL, NULL}}}};
+                              {{nullptr, nullptr, nullptr, nullptr}}}};
   grpc_metadata meta_t[2] = {{grpc_slice_from_static_string("key5"),
                               grpc_slice_from_static_string("val5"),
                               0,
-                              {{NULL, NULL, NULL, NULL}}},
+                              {{nullptr, nullptr, nullptr, nullptr}}},
                              {grpc_slice_from_static_string("key6"),
                               grpc_slice_from_static_string("val6"),
                               0,
-                              {{NULL, NULL, NULL, NULL}}}};
-  grpc_end2end_test_fixture f = begin_test(
-      config, "test_request_response_with_metadata_and_payload", NULL, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+                              {{nullptr, nullptr, nullptr, nullptr}}}};
+  grpc_end2end_test_fixture f =
+      begin_test(config, "test_request_response_with_metadata_and_payload",
+                 nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *request_payload_recv = NULL;
-  grpc_byte_buffer *response_payload_recv = NULL;
+  grpc_byte_buffer* request_payload_recv = nullptr;
+  grpc_byte_buffer* response_payload_recv = nullptr;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
@@ -139,10 +140,10 @@ static void test_request_response_with_metadata_and_payload(
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -156,35 +157,35 @@ static void test_request_response_with_metadata_and_payload(
   op->data.send_initial_metadata.count = 2;
   op->data.send_initial_metadata.metadata = meta_c;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = request_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &response_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -200,14 +201,14 @@ static void test_request_response_with_metadata_and_payload(
   op->data.send_initial_metadata.count = 2;
   op->data.send_initial_metadata.metadata = meta_s;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &request_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -218,12 +219,12 @@ static void test_request_response_with_metadata_and_payload(
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
   op->data.send_message.send_message = response_payload;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 2;
@@ -232,9 +233,9 @@ static void test_request_response_with_metadata_and_payload(
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(103), 1);
diff --git a/test/core/end2end/tests/workaround_cronet_compression.c b/test/core/end2end/tests/workaround_cronet_compression.cc
index 44e8e04643..bc4d5079d8 100644
--- a/test/core/end2end/tests/workaround_cronet_compression.c
+++ b/test/core/end2end/tests/workaround_cronet_compression.cc
@@ -36,12 +36,12 @@
 #include "src/core/lib/transport/static_metadata.h"
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -58,31 +58,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -93,36 +93,36 @@ static void end_test(grpc_end2end_test_fixture *f) {
 }
 
 static void request_with_payload_template(
-    grpc_end2end_test_config config, const char *test_name,
+    grpc_end2end_test_config config, const char* test_name,
     uint32_t client_send_flags_bitmask,
     grpc_compression_algorithm default_client_channel_compression_algorithm,
     grpc_compression_algorithm default_server_channel_compression_algorithm,
     grpc_compression_algorithm expected_algorithm_from_client,
     grpc_compression_algorithm expected_algorithm_from_server,
-    grpc_metadata *client_init_metadata, bool set_server_level,
+    grpc_metadata* client_init_metadata, bool set_server_level,
     grpc_compression_level server_compression_level,
-    char *user_agent_override) {
-  grpc_call *c;
-  grpc_call *s;
+    char* user_agent_override) {
+  grpc_call* c;
+  grpc_call* s;
   grpc_slice request_payload_slice;
-  grpc_byte_buffer *request_payload;
-  grpc_channel_args *client_args;
-  grpc_channel_args *server_args;
+  grpc_byte_buffer* request_payload;
+  grpc_channel_args* client_args;
+  grpc_channel_args* server_args;
   grpc_end2end_test_fixture f;
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *request_payload_recv = NULL;
-  grpc_byte_buffer *response_payload;
-  grpc_byte_buffer *response_payload_recv;
+  grpc_byte_buffer* request_payload_recv = nullptr;
+  grpc_byte_buffer* response_payload;
+  grpc_byte_buffer* response_payload_recv;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
   grpc_slice details;
   int was_cancelled = 2;
-  cq_verifier *cqv;
+  cq_verifier* cqv;
   char request_str[1024];
   char response_str[1024];
 
@@ -137,15 +137,15 @@ static void request_with_payload_template(
       grpc_slice_from_copied_string(response_str);
 
   client_args = grpc_channel_args_set_compression_algorithm(
-      NULL, default_client_channel_compression_algorithm);
+      nullptr, default_client_channel_compression_algorithm);
   server_args = grpc_channel_args_set_compression_algorithm(
-      NULL, default_server_channel_compression_algorithm);
+      nullptr, default_server_channel_compression_algorithm);
 
   if (user_agent_override) {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_channel_args *client_args_old = client_args;
+    grpc_channel_args* client_args_old = client_args;
     grpc_arg arg;
-    arg.key = GRPC_ARG_PRIMARY_USER_AGENT_STRING;
+    arg.key = const_cast<char*>(GRPC_ARG_PRIMARY_USER_AGENT_STRING);
     arg.type = GRPC_ARG_STRING;
     arg.value.string = user_agent_override;
     client_args = grpc_channel_args_copy_and_add(client_args_old, &arg, 1);
@@ -158,10 +158,10 @@ static void request_with_payload_template(
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -172,28 +172,28 @@ static void request_with_payload_template(
   memset(ops, 0, sizeof(ops));
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
-  if (client_init_metadata != NULL) {
+  if (client_init_metadata != nullptr) {
     op->data.send_initial_metadata.count = 1;
     op->data.send_initial_metadata.metadata = client_init_metadata;
   } else {
     op->data.send_initial_metadata.count = 0;
   }
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   error =
@@ -222,14 +222,14 @@ static void request_with_payload_template(
         server_compression_level;
   }
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(101), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(101), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   for (int i = 0; i < 2; i++) {
@@ -241,14 +241,14 @@ static void request_with_payload_template(
     op->op = GRPC_OP_SEND_MESSAGE;
     op->data.send_message.send_message = request_payload;
     op->flags = client_send_flags_bitmask;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
     op->op = GRPC_OP_RECV_MESSAGE;
     op->data.recv_message.recv_message = &response_payload_recv;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), NULL);
+    error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
 
     memset(ops, 0, sizeof(ops));
@@ -256,9 +256,10 @@ static void request_with_payload_template(
     op->op = GRPC_OP_RECV_MESSAGE;
     op->data.recv_message.recv_message = &request_payload_recv;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+    error =
+        grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
     CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
     cq_verify(cqv);
@@ -273,9 +274,10 @@ static void request_with_payload_template(
     op->op = GRPC_OP_SEND_MESSAGE;
     op->data.send_message.send_message = response_payload;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), NULL);
+    error =
+        grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
     CQ_EXPECT_COMPLETION(cqv, tag(103), 1);
     CQ_EXPECT_COMPLETION(cqv, tag(2), 1);
@@ -306,9 +308,9 @@ static void request_with_payload_template(
   op = ops;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(3), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(3), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   memset(ops, 0, sizeof(ops));
@@ -319,9 +321,9 @@ static void request_with_payload_template(
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(104), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(104), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
@@ -360,17 +362,20 @@ static void request_with_payload_template(
 }
 
 typedef struct workaround_cronet_compression_config {
-  char *user_agent_override;
+  char* user_agent_override;
   grpc_compression_algorithm expected_algorithm_from_server;
 } workaround_cronet_compression_config;
 
 static workaround_cronet_compression_config workaround_configs[] = {
-    {NULL, GRPC_COMPRESS_GZIP},
-    {"grpc-objc/1.3.0-dev grpc-c/3.0.0-dev (ios; cronet_http; gentle)",
+    {nullptr, GRPC_COMPRESS_GZIP},
+    {const_cast<char*>(
+         "grpc-objc/1.3.0-dev grpc-c/3.0.0-dev (ios; cronet_http; gentle)"),
      GRPC_COMPRESS_NONE},
-    {"grpc-objc/1.3.0-dev grpc-c/3.0.0-dev (ios; chttp2; gentle)",
+    {const_cast<char*>(
+         "grpc-objc/1.3.0-dev grpc-c/3.0.0-dev (ios; chttp2; gentle)"),
      GRPC_COMPRESS_GZIP},
-    {"grpc-objc/1.4.0 grpc-c/3.0.0-dev (ios; cronet_http; gentle)",
+    {const_cast<char*>(
+         "grpc-objc/1.4.0 grpc-c/3.0.0-dev (ios; cronet_http; gentle)"),
      GRPC_COMPRESS_GZIP}};
 static const size_t workaround_configs_num =
     sizeof(workaround_configs) / sizeof(*workaround_configs);
@@ -381,7 +386,7 @@ static void test_workaround_cronet_compression(
     request_with_payload_template(
         config, "test_invoke_request_with_compressed_payload", 0,
         GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP,
-        workaround_configs[i].expected_algorithm_from_server, NULL, false,
+        workaround_configs[i].expected_algorithm_from_server, nullptr, false,
         /* ignored */ GRPC_COMPRESS_LEVEL_NONE,
         workaround_configs[i].user_agent_override);
   }
diff --git a/test/core/end2end/tests/write_buffering.c b/test/core/end2end/tests/write_buffering.cc
index d7d1e5fa3d..40821dd6f0 100644
--- a/test/core/end2end/tests/write_buffering.c
+++ b/test/core/end2end/tests/write_buffering.cc
@@ -28,12 +28,12 @@
 #include <grpc/support/useful.h>
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -50,31 +50,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -86,25 +86,25 @@ static void end_test(grpc_end2end_test_fixture *f) {
 
 /* Client sends a request with payload, server reads then returns status. */
 static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
-  grpc_call *c;
-  grpc_call *s;
+  grpc_call* c;
+  grpc_call* s;
   grpc_slice request_payload_slice1 =
       grpc_slice_from_copied_string("hello world");
-  grpc_byte_buffer *request_payload1 =
+  grpc_byte_buffer* request_payload1 =
       grpc_raw_byte_buffer_create(&request_payload_slice1, 1);
   grpc_slice request_payload_slice2 = grpc_slice_from_copied_string("abc123");
-  grpc_byte_buffer *request_payload2 =
+  grpc_byte_buffer* request_payload2 =
       grpc_raw_byte_buffer_create(&request_payload_slice2, 1);
   grpc_end2end_test_fixture f =
-      begin_test(config, "test_invoke_request_with_payload", NULL, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+      begin_test(config, "test_invoke_request_with_payload", nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *request_payload_recv1 = NULL;
-  grpc_byte_buffer *request_payload_recv2 = NULL;
+  grpc_byte_buffer* request_payload_recv1 = nullptr;
+  grpc_byte_buffer* request_payload_recv2 = nullptr;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
@@ -113,10 +113,10 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -129,7 +129,7 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   memset(ops, 0, sizeof(ops));
@@ -137,9 +137,9 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(
@@ -155,7 +155,7 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
   op->data.send_message.send_message = request_payload1;
   op->flags = GRPC_WRITE_BUFFER_HINT;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(3), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(3), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   memset(ops, 0, sizeof(ops));
@@ -163,7 +163,7 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   /* recv message should not succeed yet - it's buffered at the client still */
@@ -172,7 +172,7 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &request_payload_recv1;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(2), true);
@@ -187,7 +187,7 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
   op->data.send_message.send_message = request_payload2;
   op->flags = 0;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(4), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(4), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   /* now the first send should match up with the first recv */
@@ -201,7 +201,7 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &request_payload_recv2;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(104), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(104), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(104), true);
@@ -211,23 +211,23 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
   op = ops;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(4), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(4), nullptr);
 
   memset(ops, 0, sizeof(ops));
   op = ops;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -235,9 +235,9 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(105), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(105), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(105), 1);
diff --git a/test/core/end2end/tests/write_buffering_at_end.c b/test/core/end2end/tests/write_buffering_at_end.cc
index 6113843390..1b9dc9632b 100644
--- a/test/core/end2end/tests/write_buffering_at_end.c
+++ b/test/core/end2end/tests/write_buffering_at_end.cc
@@ -28,12 +28,12 @@
 #include <grpc/support/useful.h>
 #include "test/core/end2end/cq_verifier.h"
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
-                                            const char *test_name,
-                                            grpc_channel_args *client_args,
-                                            grpc_channel_args *server_args) {
+                                            const char* test_name,
+                                            grpc_channel_args* client_args,
+                                            grpc_channel_args* server_args) {
   grpc_end2end_test_fixture f;
   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
   f = config.create_fixture(client_args, server_args);
@@ -50,31 +50,31 @@ static gpr_timespec five_seconds_from_now(void) {
   return n_seconds_from_now(5);
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), NULL);
+    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void shutdown_server(grpc_end2end_test_fixture *f) {
+static void shutdown_server(grpc_end2end_test_fixture* f) {
   if (!f->server) return;
   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->server);
-  f->server = NULL;
+  f->server = nullptr;
 }
 
-static void shutdown_client(grpc_end2end_test_fixture *f) {
+static void shutdown_client(grpc_end2end_test_fixture* f) {
   if (!f->client) return;
   grpc_channel_destroy(f->client);
-  f->client = NULL;
+  f->client = nullptr;
 }
 
-static void end_test(grpc_end2end_test_fixture *f) {
+static void end_test(grpc_end2end_test_fixture* f) {
   shutdown_server(f);
   shutdown_client(f);
 
@@ -86,22 +86,22 @@ static void end_test(grpc_end2end_test_fixture *f) {
 
 /* Client sends a request with payload, server reads then returns status. */
 static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
-  grpc_call *c;
-  grpc_call *s;
+  grpc_call* c;
+  grpc_call* s;
   grpc_slice request_payload_slice =
       grpc_slice_from_copied_string("hello world");
-  grpc_byte_buffer *request_payload =
+  grpc_byte_buffer* request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
   grpc_end2end_test_fixture f =
-      begin_test(config, "test_invoke_request_with_payload", NULL, NULL);
-  cq_verifier *cqv = cq_verifier_create(f.cq);
+      begin_test(config, "test_invoke_request_with_payload", nullptr, nullptr);
+  cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_metadata_array request_metadata_recv;
-  grpc_byte_buffer *request_payload_recv1 = NULL;
-  grpc_byte_buffer *request_payload_recv2 = NULL;
+  grpc_byte_buffer* request_payload_recv1 = nullptr;
+  grpc_byte_buffer* request_payload_recv2 = nullptr;
   grpc_call_details call_details;
   grpc_status_code status;
   grpc_call_error error;
@@ -110,10 +110,10 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
 
   gpr_timespec deadline = five_seconds_from_now();
   c = grpc_channel_create_call(
-      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+      f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
       get_host_override_slice("foo.test.google.fr:1234", config), deadline,
-      NULL);
+      nullptr);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -126,7 +126,7 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   memset(ops, 0, sizeof(ops));
@@ -134,9 +134,9 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(
@@ -152,7 +152,7 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
   op->data.send_message.send_message = request_payload;
   op->flags = GRPC_WRITE_BUFFER_HINT;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(3), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(3), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   memset(ops, 0, sizeof(ops));
@@ -160,7 +160,7 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   /* recv message should not succeed yet - it's buffered at the client still */
@@ -169,7 +169,7 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &request_payload_recv1;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(2), true);
@@ -182,7 +182,7 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
   op = ops;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(4), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(4), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   /* now the first send should match up with the first recv */
@@ -196,7 +196,7 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &request_payload_recv2;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(104), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(104), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(104), true);
@@ -209,16 +209,16 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(4), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(4), nullptr);
 
   memset(ops, 0, sizeof(ops));
   op = ops;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -226,9 +226,9 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(105), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(105), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(105), 1);
@@ -242,7 +242,7 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
                                 config);
   GPR_ASSERT(was_cancelled == 0);
   GPR_ASSERT(byte_buffer_eq_string(request_payload_recv1, "hello world"));
-  GPR_ASSERT(request_payload_recv2 == NULL);
+  GPR_ASSERT(request_payload_recv2 == nullptr);
 
   grpc_slice_unref(details);
   grpc_metadata_array_destroy(&initial_metadata_recv);
diff --git a/test/core/fling/BUILD b/test/core/fling/BUILD
index 27b2b5bec6..268e94aacc 100644
--- a/test/core/fling/BUILD
+++ b/test/core/fling/BUILD
@@ -23,8 +23,8 @@ load("//test/core/util:grpc_fuzzer.bzl", "grpc_fuzzer")
 grpc_cc_binary(
     name = "client",
     testonly = 1,
-    srcs = ["client.c"],
-    language = "C",
+    srcs = ["client.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -37,8 +37,8 @@ grpc_cc_binary(
 grpc_cc_binary(
     name = "server",
     testonly = 1,
-    srcs = ["server.c"],
-    language = "C",
+    srcs = ["server.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -50,7 +50,7 @@ grpc_cc_binary(
 
 grpc_cc_test(
     name = "fling",
-    srcs = ["fling_test.c"],
+    srcs = ["fling_test.cc"],
     data = [
         ":client",
         ":server",
@@ -66,7 +66,7 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "fling_stream",
-    srcs = ["fling_stream_test.c"],
+    srcs = ["fling_stream_test.cc"],
     data = [
         ":client",
         ":server",
diff --git a/test/core/fling/client.c b/test/core/fling/client.cc
index be7bfc2280..544b66d480 100644
--- a/test/core/fling/client.c
+++ b/test/core/fling/client.cc
@@ -30,20 +30,20 @@
 #include "test/core/util/grpc_profiler.h"
 #include "test/core/util/test_config.h"
 
-static gpr_histogram *histogram;
-static grpc_byte_buffer *the_buffer;
-static grpc_channel *channel;
-static grpc_completion_queue *cq;
-static grpc_call *call;
+static gpr_histogram* histogram;
+static grpc_byte_buffer* the_buffer;
+static grpc_channel* channel;
+static grpc_completion_queue* cq;
+static grpc_call* call;
 static grpc_op ops[6];
 static grpc_op stream_init_ops[2];
 static grpc_op stream_step_ops[2];
 static grpc_metadata_array initial_metadata_recv;
 static grpc_metadata_array trailing_metadata_recv;
-static grpc_byte_buffer *response_payload_recv = NULL;
+static grpc_byte_buffer* response_payload_recv = nullptr;
 static grpc_status_code status;
 static grpc_slice details;
-static grpc_op *op;
+static grpc_op* op;
 
 static void init_ping_pong_request(void) {
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -77,16 +77,16 @@ static void step_ping_pong_request(void) {
   GPR_TIMER_BEGIN("ping_pong", 1);
   grpc_slice host = grpc_slice_from_static_string("localhost");
   call = grpc_channel_create_call(
-      channel, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
+      channel, nullptr, GRPC_PROPAGATE_DEFAULTS, cq,
       grpc_slice_from_static_string("/Reflector/reflectUnary"), &host,
-      gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+      gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(call, ops,
-                                                   (size_t)(op - ops),
-                                                   (void *)1, NULL));
-  grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+                                                   (size_t)(op - ops), (void*)1,
+                                                   nullptr));
+  grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
   grpc_call_unref(call);
   grpc_byte_buffer_destroy(response_payload_recv);
-  call = NULL;
+  call = nullptr;
   GPR_TIMER_END("ping_pong", 1);
 }
 
@@ -96,17 +96,17 @@ static void init_ping_pong_stream(void) {
   grpc_call_error error;
   grpc_slice host = grpc_slice_from_static_string("localhost");
   call = grpc_channel_create_call(
-      channel, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
+      channel, nullptr, GRPC_PROPAGATE_DEFAULTS, cq,
       grpc_slice_from_static_string("/Reflector/reflectStream"), &host,
-      gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+      gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
   stream_init_ops[0].op = GRPC_OP_SEND_INITIAL_METADATA;
   stream_init_ops[0].data.send_initial_metadata.count = 0;
   stream_init_ops[1].op = GRPC_OP_RECV_INITIAL_METADATA;
   stream_init_ops[1].data.recv_initial_metadata.recv_initial_metadata =
       &initial_metadata_recv;
-  error = grpc_call_start_batch(call, stream_init_ops, 2, (void *)1, NULL);
+  error = grpc_call_start_batch(call, stream_init_ops, 2, (void*)1, nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
-  grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+  grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
 
   grpc_metadata_array_init(&initial_metadata_recv);
 
@@ -119,9 +119,9 @@ static void init_ping_pong_stream(void) {
 static void step_ping_pong_stream(void) {
   grpc_call_error error;
   GPR_TIMER_BEGIN("ping_pong", 1);
-  error = grpc_call_start_batch(call, stream_step_ops, 2, (void *)1, NULL);
+  error = grpc_call_start_batch(call, stream_step_ops, 2, (void*)1, nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
-  grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+  grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
   grpc_byte_buffer_destroy(response_payload_recv);
   GPR_TIMER_END("ping_pong", 1);
 }
@@ -132,7 +132,7 @@ static double now(void) {
 }
 
 typedef struct {
-  const char *name;
+  const char* name;
   void (*init)();
   void (*do_one_step)();
 } scenario;
@@ -142,20 +142,20 @@ static const scenario scenarios[] = {
     {"ping-pong-stream", init_ping_pong_stream, step_ping_pong_stream},
 };
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_slice slice = grpc_slice_from_copied_string("x");
   double start, stop;
   unsigned i;
 
-  char *fake_argv[1];
+  char* fake_argv[1];
 
   int payload_size = 1;
   int secure = 0;
-  char *target = "localhost:443";
-  gpr_cmdline *cl;
+  const char* target = "localhost:443";
+  gpr_cmdline* cl;
   grpc_event event;
-  char *scenario_name = "ping-pong-request";
-  scenario sc = {NULL, NULL, NULL};
+  const char* scenario_name = "ping-pong-request";
+  scenario sc = {nullptr, nullptr, nullptr};
 
   gpr_timers_set_log_filename("latency_trace.fling_client.txt");
 
@@ -192,8 +192,8 @@ int main(int argc, char **argv) {
     return 1;
   }
 
-  channel = grpc_insecure_channel_create(target, NULL, NULL);
-  cq = grpc_completion_queue_create_for_next(NULL);
+  channel = grpc_insecure_channel_create(target, nullptr, nullptr);
+  cq = grpc_completion_queue_create_for_next(nullptr);
   the_buffer = grpc_raw_byte_buffer_create(&slice, (size_t)payload_size);
   histogram = gpr_histogram_create(0.01, 60e9);
 
@@ -225,7 +225,7 @@ int main(int argc, char **argv) {
   grpc_completion_queue_shutdown(cq);
   do {
     event = grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME),
-                                       NULL);
+                                       nullptr);
   } while (event.type != GRPC_QUEUE_SHUTDOWN);
   grpc_completion_queue_destroy(cq);
   grpc_byte_buffer_destroy(the_buffer);
diff --git a/test/core/fling/fling_test.c b/test/core/fling/fling_stream_test.cc
index 90b48e7737..b476f2e128 100644
--- a/test/core/fling/fling_test.c
+++ b/test/core/fling/fling_stream_test.cc
@@ -26,12 +26,12 @@
 #include "src/core/lib/support/string.h"
 #include "test/core/util/port.h"
 
-int main(int argc, char **argv) {
-  char *me = argv[0];
-  char *lslash = strrchr(me, '/');
+int main(int argc, char** argv) {
+  char* me = argv[0];
+  char* lslash = strrchr(me, '/');
   char root[1024];
   int port = grpc_pick_unused_port_or_die();
-  char *args[10];
+  char* args[10];
   int status;
   gpr_subprocess *svr, *cli;
   /* figure out where we are */
@@ -44,22 +44,22 @@ int main(int argc, char **argv) {
   /* start the server */
   gpr_asprintf(&args[0], "%s/fling_server%s", root,
                gpr_subprocess_binary_extension());
-  args[1] = "--bind";
+  args[1] = const_cast<char*>("--bind");
   gpr_join_host_port(&args[2], "::", port);
-  args[3] = "--no-secure";
-  svr = gpr_subprocess_create(4, (const char **)args);
+  args[3] = const_cast<char*>("--no-secure");
+  svr = gpr_subprocess_create(4, (const char**)args);
   gpr_free(args[0]);
   gpr_free(args[2]);
 
   /* start the client */
   gpr_asprintf(&args[0], "%s/fling_client%s", root,
                gpr_subprocess_binary_extension());
-  args[1] = "--target";
+  args[1] = const_cast<char*>("--target");
   gpr_join_host_port(&args[2], "127.0.0.1", port);
-  args[3] = "--scenario=ping-pong-request";
-  args[4] = "--no-secure";
-  args[5] = 0;
-  cli = gpr_subprocess_create(6, (const char **)args);
+  args[3] = const_cast<char*>("--scenario=ping-pong-stream");
+  args[4] = const_cast<char*>("--no-secure");
+  args[5] = nullptr;
+  cli = gpr_subprocess_create(6, (const char**)args);
   gpr_free(args[0]);
   gpr_free(args[2]);
 
diff --git a/test/core/fling/fling_stream_test.c b/test/core/fling/fling_test.cc
index 566d9ae6f0..0e8b3c1028 100644
--- a/test/core/fling/fling_stream_test.c
+++ b/test/core/fling/fling_test.cc
@@ -26,12 +26,12 @@
 #include "src/core/lib/support/string.h"
 #include "test/core/util/port.h"
 
-int main(int argc, char **argv) {
-  char *me = argv[0];
-  char *lslash = strrchr(me, '/');
+int main(int argc, const char** argv) {
+  const char* me = argv[0];
+  const char* lslash = strrchr(me, '/');
   char root[1024];
   int port = grpc_pick_unused_port_or_die();
-  char *args[10];
+  char* args[10];
   int status;
   gpr_subprocess *svr, *cli;
   /* figure out where we are */
@@ -44,22 +44,22 @@ int main(int argc, char **argv) {
   /* start the server */
   gpr_asprintf(&args[0], "%s/fling_server%s", root,
                gpr_subprocess_binary_extension());
-  args[1] = "--bind";
+  args[1] = const_cast<char*>("--bind");
   gpr_join_host_port(&args[2], "::", port);
-  args[3] = "--no-secure";
-  svr = gpr_subprocess_create(4, (const char **)args);
+  args[3] = const_cast<char*>("--no-secure");
+  svr = gpr_subprocess_create(4, (const char**)args);
   gpr_free(args[0]);
   gpr_free(args[2]);
 
   /* start the client */
   gpr_asprintf(&args[0], "%s/fling_client%s", root,
                gpr_subprocess_binary_extension());
-  args[1] = "--target";
+  args[1] = const_cast<char*>("--target");
   gpr_join_host_port(&args[2], "127.0.0.1", port);
-  args[3] = "--scenario=ping-pong-stream";
-  args[4] = "--no-secure";
-  args[5] = 0;
-  cli = gpr_subprocess_create(6, (const char **)args);
+  args[3] = const_cast<char*>("--scenario=ping-pong-request");
+  args[4] = const_cast<char*>("--no-secure");
+  args[5] = nullptr;
+  cli = gpr_subprocess_create(6, (const char**)args);
   gpr_free(args[0]);
   gpr_free(args[2]);
 
diff --git a/test/core/fling/server.c b/test/core/fling/server.cc
index b3a7fa21ec..f3a8a1ccf8 100644
--- a/test/core/fling/server.c
+++ b/test/core/fling/server.cc
@@ -40,15 +40,15 @@
 #include "test/core/util/port.h"
 #include "test/core/util/test_config.h"
 
-static grpc_completion_queue *cq;
-static grpc_server *server;
-static grpc_call *call;
+static grpc_completion_queue* cq;
+static grpc_server* server;
+static grpc_call* call;
 static grpc_call_details call_details;
 static grpc_metadata_array request_metadata_recv;
 static grpc_metadata_array initial_metadata_send;
-static grpc_byte_buffer *payload_buffer = NULL;
+static grpc_byte_buffer* payload_buffer = nullptr;
 /* Used to drain the terminal read in unary calls. */
-static grpc_byte_buffer *terminal_buffer = NULL;
+static grpc_byte_buffer* terminal_buffer = nullptr;
 
 static grpc_op read_op;
 static grpc_op metadata_send_op;
@@ -58,7 +58,7 @@ static int was_cancelled = 2;
 static grpc_op unary_ops[6];
 static int got_sigint = 0;
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 typedef enum {
   FLING_SERVER_NEW_REQUEST = 1,
@@ -84,7 +84,7 @@ static void request_call(void) {
 }
 
 static void handle_unary_method(void) {
-  grpc_op *op;
+  grpc_op* op;
   grpc_call_error error;
 
   grpc_metadata_array_init(&initial_metadata_send);
@@ -97,7 +97,7 @@ static void handle_unary_method(void) {
   op->data.recv_message.recv_message = &terminal_buffer;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
-  if (payload_buffer == NULL) {
+  if (payload_buffer == nullptr) {
     gpr_log(GPR_INFO, "NULL payload buffer !!!");
   }
   op->data.send_message.send_message = payload_buffer;
@@ -105,24 +105,24 @@ static void handle_unary_method(void) {
   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   op->data.send_status_from_server.status = GRPC_STATUS_OK;
   op->data.send_status_from_server.trailing_metadata_count = 0;
-  op->data.send_status_from_server.status_details = NULL;
+  op->data.send_status_from_server.status_details = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op++;
 
   error = grpc_call_start_batch(call, unary_ops, (size_t)(op - unary_ops),
-                                tag(FLING_SERVER_BATCH_OPS_FOR_UNARY), NULL);
+                                tag(FLING_SERVER_BATCH_OPS_FOR_UNARY), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 }
 
 static void send_initial_metadata(void) {
   grpc_call_error error;
-  void *tagarg = tag(FLING_SERVER_SEND_INIT_METADATA_FOR_STREAMING);
+  void* tagarg = tag(FLING_SERVER_SEND_INIT_METADATA_FOR_STREAMING);
   grpc_metadata_array_init(&initial_metadata_send);
   metadata_send_op.op = GRPC_OP_SEND_INITIAL_METADATA;
   metadata_send_op.data.send_initial_metadata.count = 0;
-  error = grpc_call_start_batch(call, &metadata_send_op, 1, tagarg, NULL);
+  error = grpc_call_start_batch(call, &metadata_send_op, 1, tagarg, nullptr);
 
   GPR_ASSERT(GRPC_CALL_OK == error);
 }
@@ -132,34 +132,34 @@ static void start_read_op(int t) {
   /* Starting read at server */
   read_op.op = GRPC_OP_RECV_MESSAGE;
   read_op.data.recv_message.recv_message = &payload_buffer;
-  error = grpc_call_start_batch(call, &read_op, 1, tag(t), NULL);
+  error = grpc_call_start_batch(call, &read_op, 1, tag(t), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 }
 
 static void start_write_op(void) {
   grpc_call_error error;
-  void *tagarg = tag(FLING_SERVER_WRITE_FOR_STREAMING);
+  void* tagarg = tag(FLING_SERVER_WRITE_FOR_STREAMING);
   /* Starting write at server */
   write_op.op = GRPC_OP_SEND_MESSAGE;
-  if (payload_buffer == NULL) {
+  if (payload_buffer == nullptr) {
     gpr_log(GPR_INFO, "NULL payload buffer !!!");
   }
   write_op.data.send_message.send_message = payload_buffer;
-  error = grpc_call_start_batch(call, &write_op, 1, tagarg, NULL);
+  error = grpc_call_start_batch(call, &write_op, 1, tagarg, nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 }
 
 static void start_send_status(void) {
   grpc_call_error error;
-  void *tagarg = tag(FLING_SERVER_SEND_STATUS_FOR_STREAMING);
+  void* tagarg = tag(FLING_SERVER_SEND_STATUS_FOR_STREAMING);
   status_op[0].op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   status_op[0].data.send_status_from_server.status = GRPC_STATUS_OK;
   status_op[0].data.send_status_from_server.trailing_metadata_count = 0;
-  status_op[0].data.send_status_from_server.status_details = NULL;
+  status_op[0].data.send_status_from_server.status_details = nullptr;
   status_op[1].op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   status_op[1].data.recv_close_on_server.cancelled = &was_cancelled;
 
-  error = grpc_call_start_batch(call, status_op, 2, tagarg, NULL);
+  error = grpc_call_start_batch(call, status_op, 2, tagarg, nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 }
 
@@ -167,19 +167,19 @@ static void start_send_status(void) {
    When that is resolved, please remove the #include <unistd.h> above. */
 static void sigint_handler(int x) { _exit(0); }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_event ev;
-  call_state *s;
-  char *addr_buf = NULL;
-  gpr_cmdline *cl;
-  grpc_completion_queue *shutdown_cq;
+  call_state* s;
+  char* addr_buf = nullptr;
+  gpr_cmdline* cl;
+  grpc_completion_queue* shutdown_cq;
   int shutdown_started = 0;
   int shutdown_finished = 0;
 
   int secure = 0;
-  char *addr = NULL;
+  const char* addr = nullptr;
 
-  char *fake_argv[1];
+  char* fake_argv[1];
 
   gpr_timers_set_log_filename("latency_trace.fling_server.txt");
 
@@ -196,30 +196,30 @@ int main(int argc, char **argv) {
   gpr_cmdline_parse(cl, argc, argv);
   gpr_cmdline_destroy(cl);
 
-  if (addr == NULL) {
+  if (addr == nullptr) {
     gpr_join_host_port(&addr_buf, "::", grpc_pick_unused_port_or_die());
     addr = addr_buf;
   }
   gpr_log(GPR_INFO, "creating server on: %s", addr);
 
-  cq = grpc_completion_queue_create_for_next(NULL);
+  cq = grpc_completion_queue_create_for_next(nullptr);
   if (secure) {
     grpc_ssl_pem_key_cert_pair pem_key_cert_pair = {test_server1_key,
                                                     test_server1_cert};
-    grpc_server_credentials *ssl_creds = grpc_ssl_server_credentials_create(
-        NULL, &pem_key_cert_pair, 1, 0, NULL);
-    server = grpc_server_create(NULL, NULL);
+    grpc_server_credentials* ssl_creds = grpc_ssl_server_credentials_create(
+        nullptr, &pem_key_cert_pair, 1, 0, nullptr);
+    server = grpc_server_create(nullptr, nullptr);
     GPR_ASSERT(grpc_server_add_secure_http2_port(server, addr, ssl_creds));
     grpc_server_credentials_release(ssl_creds);
   } else {
-    server = grpc_server_create(NULL, NULL);
+    server = grpc_server_create(nullptr, nullptr);
     GPR_ASSERT(grpc_server_add_insecure_http2_port(server, addr));
   }
-  grpc_server_register_completion_queue(server, cq, NULL);
+  grpc_server_register_completion_queue(server, cq, nullptr);
   grpc_server_start(server);
 
   gpr_free(addr_buf);
-  addr = addr_buf = NULL;
+  addr = addr_buf = nullptr;
 
   grpc_call_details_init(&call_details);
 
@@ -231,28 +231,29 @@ int main(int argc, char **argv) {
     if (got_sigint && !shutdown_started) {
       gpr_log(GPR_INFO, "Shutting down due to SIGINT");
 
-      shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
+      shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
       grpc_server_shutdown_and_notify(server, shutdown_cq, tag(1000));
 
-      GPR_ASSERT(
-          grpc_completion_queue_pluck(shutdown_cq, tag(1000),
-                                      grpc_timeout_seconds_to_deadline(5), NULL)
-              .type == GRPC_OP_COMPLETE);
+      GPR_ASSERT(grpc_completion_queue_pluck(
+                     shutdown_cq, tag(1000),
+                     grpc_timeout_seconds_to_deadline(5), nullptr)
+                     .type == GRPC_OP_COMPLETE);
       grpc_completion_queue_destroy(shutdown_cq);
 
       grpc_completion_queue_shutdown(cq);
       shutdown_started = 1;
     }
     ev = grpc_completion_queue_next(
-        cq, gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
-                         gpr_time_from_micros(1000000, GPR_TIMESPAN)),
-        NULL);
-    s = ev.tag;
+        cq,
+        gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
+                     gpr_time_from_micros(1000000, GPR_TIMESPAN)),
+        nullptr);
+    s = static_cast<call_state*>(ev.tag);
     switch (ev.type) {
       case GRPC_OP_COMPLETE:
         switch ((intptr_t)s) {
           case FLING_SERVER_NEW_REQUEST:
-            if (call != NULL) {
+            if (call != nullptr) {
               if (0 == grpc_slice_str_cmp(call_details.method,
                                           "/Reflector/reflectStream")) {
                 /* Received streaming call. Send metadata here. */
@@ -269,7 +270,7 @@ int main(int argc, char **argv) {
              */
             break;
           case FLING_SERVER_READ_FOR_STREAMING:
-            if (payload_buffer != NULL) {
+            if (payload_buffer != nullptr) {
               /* Received payload from client. */
               start_write_op();
             } else {
@@ -280,7 +281,7 @@ int main(int argc, char **argv) {
           case FLING_SERVER_WRITE_FOR_STREAMING:
             /* Write completed at server  */
             grpc_byte_buffer_destroy(payload_buffer);
-            payload_buffer = NULL;
+            payload_buffer = nullptr;
             start_read_op(FLING_SERVER_READ_FOR_STREAMING);
             break;
           case FLING_SERVER_SEND_INIT_METADATA_FOR_STREAMING:
@@ -300,7 +301,7 @@ int main(int argc, char **argv) {
           case FLING_SERVER_BATCH_OPS_FOR_UNARY:
             /* Finished unary call. */
             grpc_byte_buffer_destroy(payload_buffer);
-            payload_buffer = NULL;
+            payload_buffer = nullptr;
             grpc_call_unref(call);
             if (!shutdown_started) request_call();
             break;
diff --git a/test/core/handshake/BUILD b/test/core/handshake/BUILD
index 8e462cfc5b..a3276b9343 100644
--- a/test/core/handshake/BUILD
+++ b/test/core/handshake/BUILD
@@ -20,8 +20,8 @@ licenses(["notice"])  # Apache v2
 
 grpc_cc_test(
     name = "client_ssl",
-    srcs = ["client_ssl.c"],
-    language = "C",
+    srcs = ["client_ssl.cc"],
+    language = "C++",
     data = [
         "//src/core/tsi/test_creds:ca.pem",
         "//src/core/tsi/test_creds:server1.key",
@@ -35,16 +35,47 @@ grpc_cc_test(
     ],
 )
 
+grpc_cc_library(
+    name = "server_ssl_common",
+    hdrs = ["server_ssl_common.h"],
+    srcs = ["server_ssl_common.cc"],
+    deps = [
+        "//:gpr",
+        "//:grpc",
+        "//test/core/util:gpr_test_util",
+        "//test/core/util:grpc_test_util",
+    ],
+)
+
 grpc_cc_test(
     name = "server_ssl",
-    srcs = ["server_ssl.c"],
-    language = "C",
+    srcs = ["server_ssl.cc"],
+    language = "C++",
+    data = [
+        "//src/core/tsi/test_creds:ca.pem",
+        "//src/core/tsi/test_creds:server1.key",
+        "//src/core/tsi/test_creds:server1.pem",
+    ],
+    deps = [
+        ":server_ssl_common",
+        "//:gpr",
+        "//:grpc",
+        "//test/core/util:gpr_test_util",
+        "//test/core/util:grpc_test_util",
+    ],
+)
+
+grpc_cc_test(
+    name = "handshake_server_with_readahead_handshaker",
+    srcs = ["readahead_handshaker_server_ssl.cc"],
+    language = "C++",
     data = [
         "//src/core/tsi/test_creds:ca.pem",
         "//src/core/tsi/test_creds:server1.key",
         "//src/core/tsi/test_creds:server1.pem",
     ],
     deps = [
+        ":server_ssl_common",
         "//:gpr",
         "//:grpc",
         "//test/core/util:gpr_test_util",
diff --git a/test/core/handshake/client_ssl.c b/test/core/handshake/client_ssl.cc
index de660fe1c4..2b149a73b3 100644
--- a/test/core/handshake/client_ssl.c
+++ b/test/core/handshake/client_ssl.cc
@@ -46,13 +46,13 @@
 // Arguments for TLS server thread.
 typedef struct {
   int socket;
-  char *alpn_preferred;
+  char* alpn_preferred;
 } server_args;
 
 // Based on https://wiki.openssl.org/index.php/Simple_TLS_Server.
 // Pick an arbitrary unused port and return it in *out_port. Return
 // an fd>=0 on success.
-static int create_socket(int *out_port) {
+static int create_socket(int* out_port) {
   int s;
   struct sockaddr_in addr;
   socklen_t addr_len;
@@ -68,7 +68,7 @@ static int create_socket(int *out_port) {
     return -1;
   }
 
-  if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+  if (bind(s, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
     perror("Unable to bind");
     gpr_log(GPR_ERROR, "%s", "Unable to bind to any port");
     close(s);
@@ -82,7 +82,7 @@ static int create_socket(int *out_port) {
   }
 
   addr_len = sizeof(addr);
-  if (getsockname(s, (struct sockaddr *)&addr, &addr_len) != 0 ||
+  if (getsockname(s, (struct sockaddr*)&addr, &addr_len) != 0 ||
       addr_len > sizeof(addr)) {
     perror("getsockname");
     gpr_log(GPR_ERROR, "%s", "Unable to get socket local address");
@@ -96,19 +96,19 @@ static int create_socket(int *out_port) {
 
 // Server callback during ALPN negotiation. See man page for
 // SSL_CTX_set_alpn_select_cb.
-static int alpn_select_cb(SSL *ssl, const uint8_t **out, uint8_t *out_len,
-                          const uint8_t *in, unsigned in_len, void *arg) {
-  const uint8_t *alpn_preferred = (const uint8_t *)arg;
+static int alpn_select_cb(SSL* ssl, const uint8_t** out, uint8_t* out_len,
+                          const uint8_t* in, unsigned in_len, void* arg) {
+  const uint8_t* alpn_preferred = (const uint8_t*)arg;
 
   *out = alpn_preferred;
-  *out_len = (uint8_t)strlen((char *)alpn_preferred);
+  *out_len = (uint8_t)strlen((char*)alpn_preferred);
 
   // Validate that the ALPN list includes "h2" and "grpc-exp", that "grpc-exp"
   // precedes "h2".
   bool grpc_exp_seen = false;
   bool h2_seen = false;
-  const char *inp = (const char *)in;
-  const char *in_end = inp + in_len;
+  const char* inp = (const char*)in;
+  const char* in_end = inp + in_len;
   while (inp < in_end) {
     const size_t length = (size_t)*inp++;
     if (length == strlen("grpc-exp") && strncmp(inp, "grpc-exp", length) == 0) {
@@ -132,14 +132,14 @@ static int alpn_select_cb(SSL *ssl, const uint8_t **out, uint8_t *out_len,
 // Minimal TLS server. This is largely based on the example at
 // https://wiki.openssl.org/index.php/Simple_TLS_Server and the gRPC core
 // internals in src/core/tsi/ssl_transport_security.c.
-static void server_thread(void *arg) {
-  const server_args *args = (server_args *)arg;
+static void server_thread(void* arg) {
+  const server_args* args = (server_args*)arg;
 
   SSL_load_error_strings();
   OpenSSL_add_ssl_algorithms();
 
-  const SSL_METHOD *method = TLSv1_2_server_method();
-  SSL_CTX *ctx = SSL_CTX_new(method);
+  const SSL_METHOD* method = TLSv1_2_server_method();
+  SSL_CTX* ctx = SSL_CTX_new(method);
   if (!ctx) {
     perror("Unable to create SSL context");
     ERR_print_errors_fp(stderr);
@@ -158,7 +158,7 @@ static void server_thread(void *arg) {
 
   // Set the cipher list to match the one expressed in
   // src/core/tsi/ssl_transport_security.c.
-  const char *cipher_list =
+  const char* cipher_list =
       "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-"
       "SHA384:ECDHE-RSA-AES256-GCM-SHA384";
   if (!SSL_CTX_set_cipher_list(ctx, cipher_list)) {
@@ -175,14 +175,14 @@ static void server_thread(void *arg) {
   gpr_log(GPR_INFO, "Server listening");
   struct sockaddr_in addr;
   socklen_t len = sizeof(addr);
-  const int client = accept(sock, (struct sockaddr *)&addr, &len);
+  const int client = accept(sock, (struct sockaddr*)&addr, &len);
   if (client < 0) {
     perror("Unable to accept");
     abort();
   }
 
   // Establish a SSL* and accept at SSL layer.
-  SSL *ssl = SSL_new(ctx);
+  SSL* ssl = SSL_new(ctx);
   GPR_ASSERT(ssl);
   SSL_set_fd(ssl, client);
   if (SSL_accept(ssl) <= 0) {
@@ -208,7 +208,7 @@ static void server_thread(void *arg) {
 // establishes a TLS handshake via the core library to the server. The TLS
 // server validates ALPN aspects of the handshake and supplies the protocol
 // specified in the server_alpn_preferred argument to the client.
-static bool client_ssl_test(char *server_alpn_preferred) {
+static bool client_ssl_test(char* server_alpn_preferred) {
   bool success = true;
 
   grpc_init();
@@ -230,8 +230,7 @@ static bool client_ssl_test(char *server_alpn_preferred) {
   gpr_thd_options thdopt = gpr_thd_options_default();
   gpr_thd_id thdid;
   gpr_thd_options_set_joinable(&thdopt);
-  server_args args = {.socket = server_socket,
-                      .alpn_preferred = server_alpn_preferred};
+  server_args args = {server_socket, server_alpn_preferred};
   GPR_ASSERT(gpr_thd_new(&thdid, server_thread, &args, &thdopt));
 
   // Load key pair and establish client SSL credentials.
@@ -243,24 +242,25 @@ static bool client_ssl_test(char *server_alpn_preferred) {
                                grpc_load_file(SSL_CERT_PATH, 1, &cert_slice)));
   GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
                                grpc_load_file(SSL_KEY_PATH, 1, &key_slice)));
-  const char *ca_cert = (const char *)GRPC_SLICE_START_PTR(ca_slice);
-  pem_key_cert_pair.private_key = (const char *)GRPC_SLICE_START_PTR(key_slice);
-  pem_key_cert_pair.cert_chain = (const char *)GRPC_SLICE_START_PTR(cert_slice);
-  grpc_channel_credentials *ssl_creds =
-      grpc_ssl_credentials_create(ca_cert, &pem_key_cert_pair, NULL);
+  const char* ca_cert = (const char*)GRPC_SLICE_START_PTR(ca_slice);
+  pem_key_cert_pair.private_key = (const char*)GRPC_SLICE_START_PTR(key_slice);
+  pem_key_cert_pair.cert_chain = (const char*)GRPC_SLICE_START_PTR(cert_slice);
+  grpc_channel_credentials* ssl_creds =
+      grpc_ssl_credentials_create(ca_cert, &pem_key_cert_pair, nullptr);
 
   // Establish a channel pointing at the TLS server. Since the gRPC runtime is
   // lazy, this won't necessarily establish a connection yet.
-  char *target;
+  char* target;
   gpr_asprintf(&target, "127.0.0.1:%d", port);
-  grpc_arg ssl_name_override = {GRPC_ARG_STRING,
-                                GRPC_SSL_TARGET_NAME_OVERRIDE_ARG,
-                                {"foo.test.google.fr"}};
+  grpc_arg ssl_name_override = {
+      GRPC_ARG_STRING,
+      const_cast<char*>(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG),
+      {const_cast<char*>("foo.test.google.fr")}};
   grpc_channel_args grpc_args;
   grpc_args.num_args = 1;
   grpc_args.args = &ssl_name_override;
-  grpc_channel *channel =
-      grpc_secure_channel_create(ssl_creds, target, &grpc_args, NULL);
+  grpc_channel* channel =
+      grpc_secure_channel_create(ssl_creds, target, &grpc_args, nullptr);
   GPR_ASSERT(channel);
   gpr_free(target);
 
@@ -274,13 +274,13 @@ static bool client_ssl_test(char *server_alpn_preferred) {
   // completed and we know that the client's ALPN list satisfied the server.
   int retries = 10;
   grpc_connectivity_state state = GRPC_CHANNEL_IDLE;
-  grpc_completion_queue *cq = grpc_completion_queue_create_for_next(NULL);
+  grpc_completion_queue* cq = grpc_completion_queue_create_for_next(nullptr);
 
   while (state != GRPC_CHANNEL_READY && retries-- > 0) {
     grpc_channel_watch_connectivity_state(
-        channel, state, grpc_timeout_seconds_to_deadline(3), cq, NULL);
+        channel, state, grpc_timeout_seconds_to_deadline(3), cq, nullptr);
     gpr_timespec cq_deadline = grpc_timeout_seconds_to_deadline(5);
-    grpc_event ev = grpc_completion_queue_next(cq, cq_deadline, NULL);
+    grpc_event ev = grpc_completion_queue_next(cq, cq_deadline, nullptr);
     GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
     state =
         grpc_channel_check_connectivity_state(channel, 0 /* try_to_connect */);
@@ -303,21 +303,21 @@ static bool client_ssl_test(char *server_alpn_preferred) {
   return success;
 }
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
   // Handshake succeeeds when the server has grpc-exp as the ALPN preference.
-  GPR_ASSERT(client_ssl_test("grpc-exp"));
+  GPR_ASSERT(client_ssl_test(const_cast<char*>("grpc-exp")));
   // Handshake succeeeds when the server has h2 as the ALPN preference. This
   // covers legacy gRPC servers which don't support grpc-exp.
-  GPR_ASSERT(client_ssl_test("h2"));
+  GPR_ASSERT(client_ssl_test(const_cast<char*>("h2")));
   // Handshake fails when the server uses a fake protocol as its ALPN
   // preference. This validates the client is correctly validating ALPN returns
   // and sanity checks the client_ssl_test.
-  GPR_ASSERT(!client_ssl_test("foo"));
+  GPR_ASSERT(!client_ssl_test(const_cast<char*>("foo")));
   return 0;
 }
 
 #else /* GRPC_POSIX_SOCKET */
 
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
 
 #endif /* GRPC_POSIX_SOCKET */
diff --git a/test/core/handshake/readahead_handshaker_server_ssl.cc b/test/core/handshake/readahead_handshaker_server_ssl.cc
new file mode 100644
index 0000000000..2810082837
--- /dev/null
+++ b/test/core/handshake/readahead_handshaker_server_ssl.cc
@@ -0,0 +1,103 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <arpa/inet.h>
+#include <openssl/err.h>
+#include <openssl/ssl.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/thd.h>
+#include "src/core/lib/iomgr/load_file.h"
+#include "test/core/util/port.h"
+#include "test/core/util/test_config.h"
+
+#include "src/core/lib/channel/handshaker_factory.h"
+#include "src/core/lib/channel/handshaker_registry.h"
+#include "src/core/lib/security/transport/security_handshaker.h"
+
+#include "test/core/handshake/server_ssl_common.h"
+
+/* The purpose of this test is to exercise the case when a
+ * grpc *security_handshaker* begins its handshake with data already
+ * in the read buffer of the handshaker arg. This scenario is created by
+ * adding a fake "readahead" handshaker at the beginning of the server's
+ * handshaker list, which just reads from the connection and then places
+ * read bytes into the read buffer of the handshake arg (to be passed down
+ * to the security_handshaker). This test is meant to protect code relying on
+ * this functionality that lives outside of this repo. */
+
+static void readahead_handshaker_destroy(grpc_exec_ctx* ctx,
+                                         grpc_handshaker* handshaker) {
+  gpr_free(handshaker);
+}
+
+static void readahead_handshaker_shutdown(grpc_exec_ctx* ctx,
+                                          grpc_handshaker* handshaker,
+                                          grpc_error* error) {}
+
+static void readahead_handshaker_do_handshake(
+    grpc_exec_ctx* ctx, grpc_handshaker* handshaker,
+    grpc_tcp_server_acceptor* acceptor, grpc_closure* on_handshake_done,
+    grpc_handshaker_args* args) {
+  grpc_endpoint_read(ctx, args->endpoint, args->read_buffer, on_handshake_done);
+}
+
+const grpc_handshaker_vtable readahead_handshaker_vtable = {
+    readahead_handshaker_destroy, readahead_handshaker_shutdown,
+    readahead_handshaker_do_handshake};
+
+static grpc_handshaker* readahead_handshaker_create(grpc_exec_ctx* ctx) {
+  grpc_handshaker* h = (grpc_handshaker*)gpr_zalloc(sizeof(grpc_handshaker));
+  grpc_handshaker_init(&readahead_handshaker_vtable, h);
+  return h;
+}
+
+static void readahead_handshaker_factory_add_handshakers(
+    grpc_exec_ctx* exec_ctx, grpc_handshaker_factory* hf,
+    const grpc_channel_args* args, grpc_handshake_manager* handshake_mgr) {
+  grpc_handshake_manager_add(handshake_mgr,
+                             readahead_handshaker_create(exec_ctx));
+}
+
+static void readahead_handshaker_factory_destroy(
+    grpc_exec_ctx* exec_ctx, grpc_handshaker_factory* handshaker_factory) {}
+
+static const grpc_handshaker_factory_vtable
+    readahead_handshaker_factory_vtable = {
+        readahead_handshaker_factory_add_handshakers,
+        readahead_handshaker_factory_destroy};
+
+int main(int argc, char* argv[]) {
+  grpc_handshaker_factory readahead_handshaker_factory = {
+      &readahead_handshaker_factory_vtable};
+  grpc_init();
+  grpc_handshaker_factory_register(true /* at_start */, HANDSHAKER_SERVER,
+                                   &readahead_handshaker_factory);
+  const char* full_alpn_list[] = {"grpc-exp", "h2"};
+  GPR_ASSERT(server_ssl_test(full_alpn_list, 2, "grpc-exp"));
+  grpc_shutdown();
+  return 0;
+}
diff --git a/test/core/handshake/server_ssl.cc b/test/core/handshake/server_ssl.cc
new file mode 100644
index 0000000000..736d3e578e
--- /dev/null
+++ b/test/core/handshake/server_ssl.cc
@@ -0,0 +1,57 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <arpa/inet.h>
+#include <openssl/err.h>
+#include <openssl/ssl.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/thd.h>
+#include "src/core/lib/iomgr/load_file.h"
+#include "test/core/util/port.h"
+#include "test/core/util/test_config.h"
+
+#include "test/core/handshake/server_ssl_common.h"
+
+int main(int argc, char* argv[]) {
+  // Handshake succeeeds when the client supplies the standard ALPN list.
+  const char* full_alpn_list[] = {"grpc-exp", "h2"};
+  GPR_ASSERT(server_ssl_test(full_alpn_list, 2, "grpc-exp"));
+  // Handshake succeeeds when the client supplies only h2 as the ALPN list. This
+  // covers legacy gRPC clients which don't support grpc-exp.
+  const char* h2_only_alpn_list[] = {"h2"};
+  GPR_ASSERT(server_ssl_test(h2_only_alpn_list, 1, "h2"));
+  // Handshake succeeds when the client supplies superfluous ALPN entries and
+  // also when h2 precedes gprc-exp.
+  const char* extra_alpn_list[] = {"foo", "h2", "bar", "grpc-exp"};
+  GPR_ASSERT(server_ssl_test(extra_alpn_list, 4, "h2"));
+  // Handshake fails when the client uses a fake protocol as its only ALPN
+  // preference. This validates the server is correctly validating ALPN
+  // and sanity checks the server_ssl_test.
+  const char* fake_alpn_list[] = {"foo"};
+  GPR_ASSERT(!server_ssl_test(fake_alpn_list, 1, "foo"));
+  return 0;
+}
diff --git a/test/core/handshake/server_ssl.c b/test/core/handshake/server_ssl_common.cc
index 85a8b4de41..599b2814e0 100644
--- a/test/core/handshake/server_ssl.c
+++ b/test/core/handshake/server_ssl_common.cc
@@ -16,6 +16,8 @@
  *
  */
 
+#include "test/core/handshake/server_ssl_common.h"
+
 #include <arpa/inet.h>
 #include <openssl/err.h>
 #include <openssl/ssl.h>
@@ -55,7 +57,7 @@ static int create_socket(int port) {
     return -1;
   }
 
-  if (connect(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+  if (connect(s, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
     perror("Unable to connect");
     return -1;
   }
@@ -64,8 +66,8 @@ static int create_socket(int port) {
 }
 
 // Simple gRPC server. This listens until client_handshake_complete occurs.
-static void server_thread(void *arg) {
-  const int port = *(int *)arg;
+static void server_thread(void* arg) {
+  const int port = *(int*)arg;
 
   // Load key pair and establish server SSL credentials.
   grpc_ssl_pem_key_cert_pair pem_key_cert_pair;
@@ -76,22 +78,22 @@ static void server_thread(void *arg) {
                                grpc_load_file(SSL_CERT_PATH, 1, &cert_slice)));
   GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
                                grpc_load_file(SSL_KEY_PATH, 1, &key_slice)));
-  const char *ca_cert = (const char *)GRPC_SLICE_START_PTR(ca_slice);
-  pem_key_cert_pair.private_key = (const char *)GRPC_SLICE_START_PTR(key_slice);
-  pem_key_cert_pair.cert_chain = (const char *)GRPC_SLICE_START_PTR(cert_slice);
-  grpc_server_credentials *ssl_creds = grpc_ssl_server_credentials_create(
-      ca_cert, &pem_key_cert_pair, 1, 0, NULL);
+  const char* ca_cert = (const char*)GRPC_SLICE_START_PTR(ca_slice);
+  pem_key_cert_pair.private_key = (const char*)GRPC_SLICE_START_PTR(key_slice);
+  pem_key_cert_pair.cert_chain = (const char*)GRPC_SLICE_START_PTR(cert_slice);
+  grpc_server_credentials* ssl_creds = grpc_ssl_server_credentials_create(
+      ca_cert, &pem_key_cert_pair, 1, 0, nullptr);
 
   // Start server listening on local port.
-  char *addr;
+  char* addr;
   gpr_asprintf(&addr, "127.0.0.1:%d", port);
-  grpc_server *server = grpc_server_create(NULL, NULL);
+  grpc_server* server = grpc_server_create(nullptr, nullptr);
   GPR_ASSERT(grpc_server_add_secure_http2_port(server, addr, ssl_creds));
   free(addr);
 
-  grpc_completion_queue *cq = grpc_completion_queue_create_for_next(NULL);
+  grpc_completion_queue* cq = grpc_completion_queue_create_for_next(nullptr);
 
-  grpc_server_register_completion_queue(server, cq, NULL);
+  grpc_server_register_completion_queue(server, cq, nullptr);
   grpc_server_start(server);
 
   // Wait a bounded number of time until client_handshake_complete is set,
@@ -99,16 +101,16 @@ static void server_thread(void *arg) {
   int retries = 10;
   while (!gpr_event_get(&client_handshake_complete) && retries-- > 0) {
     const gpr_timespec cq_deadline = grpc_timeout_seconds_to_deadline(1);
-    grpc_event ev = grpc_completion_queue_next(cq, cq_deadline, NULL);
+    grpc_event ev = grpc_completion_queue_next(cq, cq_deadline, nullptr);
     GPR_ASSERT(ev.type == GRPC_QUEUE_TIMEOUT);
   }
 
   gpr_log(GPR_INFO, "Shutting down server");
-  grpc_server_shutdown_and_notify(server, cq, NULL);
+  grpc_server_shutdown_and_notify(server, cq, nullptr);
   grpc_completion_queue_shutdown(cq);
 
   const gpr_timespec cq_deadline = grpc_timeout_seconds_to_deadline(5);
-  grpc_event ev = grpc_completion_queue_next(cq, cq_deadline, NULL);
+  grpc_event ev = grpc_completion_queue_next(cq, cq_deadline, nullptr);
   GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
 
   grpc_server_destroy(server);
@@ -123,8 +125,8 @@ static void server_thread(void *arg) {
 // TLS handshake via a minimal TLS client. The TLS client has configurable (via
 // alpn_list) ALPN settings and can probe at the supported ALPN preferences
 // using this (via alpn_expected).
-static bool server_ssl_test(const char *alpn_list[], unsigned int alpn_list_len,
-                            const char *alpn_expected) {
+bool server_ssl_test(const char* alpn_list[], unsigned int alpn_list_len,
+                     const char* alpn_expected) {
   bool success = true;
 
   grpc_init();
@@ -140,8 +142,8 @@ static bool server_ssl_test(const char *alpn_list[], unsigned int alpn_list_len,
   SSL_load_error_strings();
   OpenSSL_add_ssl_algorithms();
 
-  const SSL_METHOD *method = TLSv1_2_client_method();
-  SSL_CTX *ctx = SSL_CTX_new(method);
+  const SSL_METHOD* method = TLSv1_2_client_method();
+  SSL_CTX* ctx = SSL_CTX_new(method);
   if (!ctx) {
     perror("Unable to create SSL context");
     ERR_print_errors_fp(stderr);
@@ -160,7 +162,7 @@ static bool server_ssl_test(const char *alpn_list[], unsigned int alpn_list_len,
 
   // Set the cipher list to match the one expressed in
   // src/core/tsi/ssl_transport_security.c.
-  const char *cipher_list =
+  const char* cipher_list =
       "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-"
       "SHA384:ECDHE-RSA-AES256-GCM-SHA384";
   if (!SSL_CTX_set_cipher_list(ctx, cipher_list)) {
@@ -175,8 +177,9 @@ static bool server_ssl_test(const char *alpn_list[], unsigned int alpn_list_len,
   for (unsigned int i = 0; i < alpn_list_len; ++i) {
     alpn_protos_len += (unsigned int)strlen(alpn_list[i]);
   }
-  unsigned char *alpn_protos = gpr_malloc(alpn_protos_len);
-  unsigned char *p = alpn_protos;
+  unsigned char* alpn_protos =
+      static_cast<unsigned char*>(gpr_malloc(alpn_protos_len));
+  unsigned char* p = alpn_protos;
   for (unsigned int i = 0; i < alpn_list_len; ++i) {
     const uint8_t len = (uint8_t)strlen(alpn_list[i]);
     *p++ = len;
@@ -199,7 +202,7 @@ static bool server_ssl_test(const char *alpn_list[], unsigned int alpn_list_len,
   gpr_log(GPR_INFO, "Connected to server on port %d", port);
 
   // Establish a SSL* and connect at SSL layer.
-  SSL *ssl = SSL_new(ctx);
+  SSL* ssl = SSL_new(ctx);
   GPR_ASSERT(ssl);
   SSL_set_fd(ssl, sock);
   if (SSL_connect(ssl) <= 0) {
@@ -209,12 +212,12 @@ static bool server_ssl_test(const char *alpn_list[], unsigned int alpn_list_len,
   } else {
     gpr_log(GPR_INFO, "Handshake successful.");
     // Validate ALPN preferred by server matches alpn_expected.
-    const unsigned char *alpn_selected;
+    const unsigned char* alpn_selected;
     unsigned int alpn_selected_len;
     SSL_get0_alpn_selected(ssl, &alpn_selected, &alpn_selected_len);
     if (strlen(alpn_expected) != alpn_selected_len ||
-        strncmp((const char *)alpn_selected, alpn_expected,
-                alpn_selected_len) != 0) {
+        strncmp((const char*)alpn_selected, alpn_expected, alpn_selected_len) !=
+            0) {
       gpr_log(GPR_ERROR, "Unexpected ALPN protocol preference");
       success = false;
     }
@@ -233,23 +236,3 @@ static bool server_ssl_test(const char *alpn_list[], unsigned int alpn_list_len,
 
   return success;
 }
-
-int main(int argc, char *argv[]) {
-  // Handshake succeeeds when the client supplies the standard ALPN list.
-  const char *full_alpn_list[] = {"grpc-exp", "h2"};
-  GPR_ASSERT(server_ssl_test(full_alpn_list, 2, "grpc-exp"));
-  // Handshake succeeeds when the client supplies only h2 as the ALPN list. This
-  // covers legacy gRPC clients which don't support grpc-exp.
-  const char *h2_only_alpn_list[] = {"h2"};
-  GPR_ASSERT(server_ssl_test(h2_only_alpn_list, 1, "h2"));
-  // Handshake succeeds when the client supplies superfluous ALPN entries and
-  // also when h2 precedes gprc-exp.
-  const char *extra_alpn_list[] = {"foo", "h2", "bar", "grpc-exp"};
-  GPR_ASSERT(server_ssl_test(extra_alpn_list, 4, "h2"));
-  // Handshake fails when the client uses a fake protocol as its only ALPN
-  // preference. This validates the server is correctly validating ALPN
-  // and sanity checks the server_ssl_test.
-  const char *fake_alpn_list[] = {"foo"};
-  GPR_ASSERT(!server_ssl_test(fake_alpn_list, 1, "foo"));
-  return 0;
-}
diff --git a/test/core/handshake/server_ssl_common.h b/test/core/handshake/server_ssl_common.h
new file mode 100644
index 0000000000..77865a408f
--- /dev/null
+++ b/test/core/handshake/server_ssl_common.h
@@ -0,0 +1,36 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef GRPC_SERVER_SSL_COMMON_H
+#define GRPC_SERVER_SSL_COMMON_H
+
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/thd.h>
+#include "src/core/lib/iomgr/load_file.h"
+#include "test/core/util/port.h"
+#include "test/core/util/test_config.h"
+
+bool server_ssl_test(const char* alpn_list[], unsigned int alpn_list_len,
+                     const char* alpn_expected);
+
+#endif  // GRPC_SERVER_SSL_COMMON_H
diff --git a/test/core/http/BUILD b/test/core/http/BUILD
index fffdac5e08..a5ae6272db 100644
--- a/test/core/http/BUILD
+++ b/test/core/http/BUILD
@@ -22,8 +22,8 @@ load("//test/core/util:grpc_fuzzer.bzl", "grpc_fuzzer")
 
 grpc_fuzzer(
     name = "response_fuzzer",
-    srcs = ["response_fuzzer.c"],
-    language = "C",
+    srcs = ["response_fuzzer.cc"],
+    language = "C++",
     corpus = "response_corpus",
     deps = [
         "//:gpr",
@@ -34,8 +34,8 @@ grpc_fuzzer(
 
 grpc_fuzzer(
     name = "request_fuzzer",
-    srcs = ["request_fuzzer.c"],
-    language = "C",
+    srcs = ["request_fuzzer.cc"],
+    language = "C++",
     corpus = "request_corpus",
     deps = [
         "//:gpr",
@@ -64,8 +64,8 @@ load("//test/core/util:grpc_fuzzer.bzl", "grpc_fuzzer")
 
 grpc_cc_test(
     name = "httpcli_test",
-    srcs = ["httpcli_test.c"],
-    language = "C",
+    srcs = ["httpcli_test.cc"],
+    language = "C++",
     data = ["test_server.py"],
     deps = [
         "//:gpr",
@@ -78,8 +78,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "httpscli_test",
-    srcs = ["httpscli_test.c"],
-    language = "C",
+    srcs = ["httpscli_test.cc"],
+    language = "C++",
     data = ["test_server.py"],
     deps = [
         "//:gpr",
@@ -92,8 +92,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "parser_test",
-    srcs = ["parser_test.c"],
-    language = "C",
+    srcs = ["parser_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
diff --git a/test/core/http/format_request_test.c b/test/core/http/format_request_test.cc
index 0279a1b5e3..684738a997 100644
--- a/test/core/http/format_request_test.c
+++ b/test/core/http/format_request_test.cc
@@ -24,13 +24,13 @@
 #include "test/core/util/test_config.h"
 
 static void test_format_get_request(void) {
-  grpc_http_header hdr = {"x-yz", "abc"};
+  grpc_http_header hdr = {const_cast<char*>("x-yz"), const_cast<char*>("abc")};
   grpc_httpcli_request req;
   grpc_slice slice;
 
   memset(&req, 0, sizeof(req));
-  req.host = "example.com";
-  req.http.path = "/index.html";
+  req.host = const_cast<char*>("example.com");
+  req.http.path = const_cast<char*>("/index.html");
   req.http.hdr_count = 1;
   req.http.hdrs = &hdr;
 
@@ -49,15 +49,15 @@ static void test_format_get_request(void) {
 }
 
 static void test_format_post_request(void) {
-  grpc_http_header hdr = {"x-yz", "abc"};
+  grpc_http_header hdr = {const_cast<char*>("x-yz"), const_cast<char*>("abc")};
   grpc_httpcli_request req;
   grpc_slice slice;
   char body_bytes[] = "fake body";
   size_t body_len = 9;
 
   memset(&req, 0, sizeof(req));
-  req.host = "example.com";
-  req.http.path = "/index.html";
+  req.host = const_cast<char*>("example.com");
+  req.http.path = const_cast<char*>("/index.html");
   req.http.hdr_count = 1;
   req.http.hdrs = &hdr;
 
@@ -79,17 +79,17 @@ static void test_format_post_request(void) {
 }
 
 static void test_format_post_request_no_body(void) {
-  grpc_http_header hdr = {"x-yz", "abc"};
+  grpc_http_header hdr = {const_cast<char*>("x-yz"), const_cast<char*>("abc")};
   grpc_httpcli_request req;
   grpc_slice slice;
 
   memset(&req, 0, sizeof(req));
-  req.host = "example.com";
-  req.http.path = "/index.html";
+  req.host = const_cast<char*>("example.com");
+  req.http.path = const_cast<char*>("/index.html");
   req.http.hdr_count = 1;
   req.http.hdrs = &hdr;
 
-  slice = grpc_httpcli_format_post_request(&req, NULL, 0);
+  slice = grpc_httpcli_format_post_request(&req, nullptr, 0);
 
   GPR_ASSERT(0 == grpc_slice_str_cmp(slice,
                                      "POST /index.html HTTP/1.0\r\n"
@@ -110,13 +110,13 @@ static void test_format_post_request_content_type_override(void) {
   char body_bytes[] = "fake%20body";
   size_t body_len = 11;
 
-  hdrs[0].key = "x-yz";
-  hdrs[0].value = "abc";
-  hdrs[1].key = "Content-Type";
-  hdrs[1].value = "application/x-www-form-urlencoded";
+  hdrs[0].key = const_cast<char*>("x-yz");
+  hdrs[0].value = const_cast<char*>("abc");
+  hdrs[1].key = const_cast<char*>("Content-Type");
+  hdrs[1].value = const_cast<char*>("application/x-www-form-urlencoded");
   memset(&req, 0, sizeof(req));
-  req.host = "example.com";
-  req.http.path = "/index.html";
+  req.host = const_cast<char*>("example.com");
+  req.http.path = const_cast<char*>("/index.html");
   req.http.hdr_count = 2;
   req.http.hdrs = hdrs;
 
@@ -137,7 +137,7 @@ static void test_format_post_request_content_type_override(void) {
   grpc_slice_unref(slice);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
 
   test_format_get_request();
diff --git a/test/core/http/httpcli_test.c b/test/core/http/httpcli_test.cc
index cc1c16d695..81e9374819 100644
--- a/test/core/http/httpcli_test.c
+++ b/test/core/http/httpcli_test.cc
@@ -32,7 +32,7 @@
 
 static int g_done = 0;
 static grpc_httpcli_context g_context;
-static gpr_mu *g_mu;
+static gpr_mu* g_mu;
 static grpc_polling_entity g_pops;
 
 static grpc_millis n_seconds_time(int seconds) {
@@ -40,11 +40,11 @@ static grpc_millis n_seconds_time(int seconds) {
       grpc_timeout_seconds_to_deadline(seconds));
 }
 
-static void on_finish(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  const char *expect =
+static void on_finish(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+  const char* expect =
       "<html><head><title>Hello world!</title></head>"
       "<body><p>This is a test</p></body></html>";
-  grpc_http_response *response = arg;
+  grpc_http_response* response = static_cast<grpc_http_response*>(arg);
   GPR_ASSERT(response);
   GPR_ASSERT(response->status == 200);
   GPR_ASSERT(response->body_length == strlen(expect));
@@ -53,13 +53,14 @@ static void on_finish(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
   g_done = 1;
   GPR_ASSERT(GRPC_LOG_IF_ERROR(
       "pollset_kick",
-      grpc_pollset_kick(exec_ctx, grpc_polling_entity_pollset(&g_pops), NULL)));
+      grpc_pollset_kick(exec_ctx, grpc_polling_entity_pollset(&g_pops),
+                        nullptr)));
   gpr_mu_unlock(g_mu);
 }
 
 static void test_get(int port) {
   grpc_httpcli_request req;
-  char *host;
+  char* host;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
   g_done = 0;
@@ -70,12 +71,12 @@ static void test_get(int port) {
 
   memset(&req, 0, sizeof(req));
   req.host = host;
-  req.http.path = "/get";
+  req.http.path = const_cast<char*>("/get");
   req.handshaker = &grpc_httpcli_plaintext;
 
   grpc_http_response response;
   memset(&response, 0, sizeof(response));
-  grpc_resource_quota *resource_quota = grpc_resource_quota_create("test_get");
+  grpc_resource_quota* resource_quota = grpc_resource_quota_create("test_get");
   grpc_httpcli_get(
       &exec_ctx, &g_context, &g_pops, resource_quota, &req, n_seconds_time(15),
       GRPC_CLOSURE_CREATE(on_finish, &response, grpc_schedule_on_exec_ctx),
@@ -83,7 +84,7 @@ static void test_get(int port) {
   grpc_resource_quota_unref_internal(&exec_ctx, resource_quota);
   gpr_mu_lock(g_mu);
   while (!g_done) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     GPR_ASSERT(GRPC_LOG_IF_ERROR(
         "pollset_work",
         grpc_pollset_work(&exec_ctx, grpc_polling_entity_pollset(&g_pops),
@@ -99,7 +100,7 @@ static void test_get(int port) {
 
 static void test_post(int port) {
   grpc_httpcli_request req;
-  char *host;
+  char* host;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
   g_done = 0;
@@ -110,12 +111,12 @@ static void test_post(int port) {
 
   memset(&req, 0, sizeof(req));
   req.host = host;
-  req.http.path = "/post";
+  req.http.path = const_cast<char*>("/post");
   req.handshaker = &grpc_httpcli_plaintext;
 
   grpc_http_response response;
   memset(&response, 0, sizeof(response));
-  grpc_resource_quota *resource_quota = grpc_resource_quota_create("test_post");
+  grpc_resource_quota* resource_quota = grpc_resource_quota_create("test_post");
   grpc_httpcli_post(
       &exec_ctx, &g_context, &g_pops, resource_quota, &req, "hello", 5,
       n_seconds_time(15),
@@ -124,7 +125,7 @@ static void test_post(int port) {
   grpc_resource_quota_unref_internal(&exec_ctx, resource_quota);
   gpr_mu_lock(g_mu);
   while (!g_done) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     GPR_ASSERT(GRPC_LOG_IF_ERROR(
         "pollset_work",
         grpc_pollset_work(&exec_ctx, grpc_polling_entity_pollset(&g_pops),
@@ -138,23 +139,24 @@ static void test_post(int port) {
   grpc_http_response_destroy(&response);
 }
 
-static void destroy_pops(grpc_exec_ctx *exec_ctx, void *p, grpc_error *error) {
-  grpc_pollset_destroy(exec_ctx, grpc_polling_entity_pollset(p));
+static void destroy_pops(grpc_exec_ctx* exec_ctx, void* p, grpc_error* error) {
+  grpc_pollset_destroy(exec_ctx, grpc_polling_entity_pollset(
+                                     static_cast<grpc_polling_entity*>(p)));
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_closure destroyed;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  gpr_subprocess *server;
-  char *me = argv[0];
-  char *lslash = strrchr(me, '/');
-  char *args[4];
+  gpr_subprocess* server;
+  char* me = argv[0];
+  char* lslash = strrchr(me, '/');
+  char* args[4];
   int port = grpc_pick_unused_port_or_die();
   int arg_shift = 0;
   /* figure out where we are */
-  char *root;
+  char* root;
   if (lslash) {
-    root = gpr_malloc((size_t)(lslash - me + 1));
+    root = static_cast<char*>(gpr_malloc((size_t)(lslash - me + 1)));
     memcpy(root, me, (size_t)(lslash - me));
     root[lslash - me] = 0;
   } else {
@@ -171,9 +173,9 @@ int main(int argc, char **argv) {
   }
 
   /* start the server */
-  args[1 + arg_shift] = "--port";
+  args[1 + arg_shift] = const_cast<char*>("--port");
   gpr_asprintf(&args[2 + arg_shift], "%d", port);
-  server = gpr_subprocess_create(3 + arg_shift, (const char **)args);
+  server = gpr_subprocess_create(3 + arg_shift, (const char**)args);
   GPR_ASSERT(server);
   gpr_free(args[0]);
   if (arg_shift) gpr_free(args[1]);
@@ -186,7 +188,8 @@ int main(int argc, char **argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   grpc_httpcli_context_init(&g_context);
-  grpc_pollset *pollset = gpr_zalloc(grpc_pollset_size());
+  grpc_pollset* pollset =
+      static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
   grpc_pollset_init(pollset, &g_mu);
   g_pops = grpc_polling_entity_create_from_pollset(pollset);
 
diff --git a/test/core/http/httpscli_test.c b/test/core/http/httpscli_test.cc
index f8a3cfdd76..da8405c049 100644
--- a/test/core/http/httpscli_test.c
+++ b/test/core/http/httpscli_test.cc
@@ -32,7 +32,7 @@
 
 static int g_done = 0;
 static grpc_httpcli_context g_context;
-static gpr_mu *g_mu;
+static gpr_mu* g_mu;
 static grpc_polling_entity g_pops;
 
 static grpc_millis n_seconds_time(int seconds) {
@@ -40,11 +40,11 @@ static grpc_millis n_seconds_time(int seconds) {
       grpc_timeout_seconds_to_deadline(seconds));
 }
 
-static void on_finish(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  const char *expect =
+static void on_finish(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+  const char* expect =
       "<html><head><title>Hello world!</title></head>"
       "<body><p>This is a test</p></body></html>";
-  grpc_http_response *response = arg;
+  grpc_http_response* response = static_cast<grpc_http_response*>(arg);
   GPR_ASSERT(response);
   GPR_ASSERT(response->status == 200);
   GPR_ASSERT(response->body_length == strlen(expect));
@@ -53,13 +53,14 @@ static void on_finish(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
   g_done = 1;
   GPR_ASSERT(GRPC_LOG_IF_ERROR(
       "pollset_kick",
-      grpc_pollset_kick(exec_ctx, grpc_polling_entity_pollset(&g_pops), NULL)));
+      grpc_pollset_kick(exec_ctx, grpc_polling_entity_pollset(&g_pops),
+                        nullptr)));
   gpr_mu_unlock(g_mu);
 }
 
 static void test_get(int port) {
   grpc_httpcli_request req;
-  char *host;
+  char* host;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
   g_done = 0;
@@ -70,13 +71,13 @@ static void test_get(int port) {
 
   memset(&req, 0, sizeof(req));
   req.host = host;
-  req.ssl_host_override = "foo.test.google.fr";
-  req.http.path = "/get";
+  req.ssl_host_override = const_cast<char*>("foo.test.google.fr");
+  req.http.path = const_cast<char*>("/get");
   req.handshaker = &grpc_httpcli_ssl;
 
   grpc_http_response response;
   memset(&response, 0, sizeof(response));
-  grpc_resource_quota *resource_quota = grpc_resource_quota_create("test_get");
+  grpc_resource_quota* resource_quota = grpc_resource_quota_create("test_get");
   grpc_httpcli_get(
       &exec_ctx, &g_context, &g_pops, resource_quota, &req, n_seconds_time(15),
       GRPC_CLOSURE_CREATE(on_finish, &response, grpc_schedule_on_exec_ctx),
@@ -84,7 +85,7 @@ static void test_get(int port) {
   grpc_resource_quota_unref_internal(&exec_ctx, resource_quota);
   gpr_mu_lock(g_mu);
   while (!g_done) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     GPR_ASSERT(GRPC_LOG_IF_ERROR(
         "pollset_work",
         grpc_pollset_work(&exec_ctx, grpc_polling_entity_pollset(&g_pops),
@@ -100,7 +101,7 @@ static void test_get(int port) {
 
 static void test_post(int port) {
   grpc_httpcli_request req;
-  char *host;
+  char* host;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
   g_done = 0;
@@ -111,13 +112,13 @@ static void test_post(int port) {
 
   memset(&req, 0, sizeof(req));
   req.host = host;
-  req.ssl_host_override = "foo.test.google.fr";
-  req.http.path = "/post";
+  req.ssl_host_override = const_cast<char*>("foo.test.google.fr");
+  req.http.path = const_cast<char*>("/post");
   req.handshaker = &grpc_httpcli_ssl;
 
   grpc_http_response response;
   memset(&response, 0, sizeof(response));
-  grpc_resource_quota *resource_quota = grpc_resource_quota_create("test_post");
+  grpc_resource_quota* resource_quota = grpc_resource_quota_create("test_post");
   grpc_httpcli_post(
       &exec_ctx, &g_context, &g_pops, resource_quota, &req, "hello", 5,
       n_seconds_time(15),
@@ -126,7 +127,7 @@ static void test_post(int port) {
   grpc_resource_quota_unref_internal(&exec_ctx, resource_quota);
   gpr_mu_lock(g_mu);
   while (!g_done) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     GPR_ASSERT(GRPC_LOG_IF_ERROR(
         "pollset_work",
         grpc_pollset_work(&exec_ctx, grpc_polling_entity_pollset(&g_pops),
@@ -140,23 +141,24 @@ static void test_post(int port) {
   grpc_http_response_destroy(&response);
 }
 
-static void destroy_pops(grpc_exec_ctx *exec_ctx, void *p, grpc_error *error) {
-  grpc_pollset_destroy(exec_ctx, grpc_polling_entity_pollset(p));
+static void destroy_pops(grpc_exec_ctx* exec_ctx, void* p, grpc_error* error) {
+  grpc_pollset_destroy(exec_ctx, grpc_polling_entity_pollset(
+                                     static_cast<grpc_polling_entity*>(p)));
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_closure destroyed;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  gpr_subprocess *server;
-  char *me = argv[0];
-  char *lslash = strrchr(me, '/');
-  char *args[5];
+  gpr_subprocess* server;
+  char* me = argv[0];
+  char* lslash = strrchr(me, '/');
+  char* args[5];
   int port = grpc_pick_unused_port_or_die();
   int arg_shift = 0;
   /* figure out where we are */
-  char *root;
+  char* root;
   if (lslash) {
-    root = gpr_malloc((size_t)(lslash - me + 1));
+    root = static_cast<char*>(gpr_malloc((size_t)(lslash - me + 1)));
     memcpy(root, me, (size_t)(lslash - me));
     root[lslash - me] = 0;
   } else {
@@ -173,10 +175,10 @@ int main(int argc, char **argv) {
   }
 
   /* start the server */
-  args[1 + arg_shift] = "--port";
+  args[1 + arg_shift] = const_cast<char*>("--port");
   gpr_asprintf(&args[2 + arg_shift], "%d", port);
-  args[3 + arg_shift] = "--ssl";
-  server = gpr_subprocess_create(4 + arg_shift, (const char **)args);
+  args[3 + arg_shift] = const_cast<char*>("--ssl");
+  server = gpr_subprocess_create(4 + arg_shift, (const char**)args);
   GPR_ASSERT(server);
   gpr_free(args[0]);
   if (arg_shift) gpr_free(args[1]);
@@ -189,7 +191,8 @@ int main(int argc, char **argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   grpc_httpcli_context_init(&g_context);
-  grpc_pollset *pollset = gpr_zalloc(grpc_pollset_size());
+  grpc_pollset* pollset =
+      static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
   grpc_pollset_init(pollset, &g_mu);
   g_pops = grpc_polling_entity_create_from_pollset(pollset);
 
diff --git a/test/core/http/parser_test.c b/test/core/http/parser_test.cc
index a7044c03bc..0b60e369b7 100644
--- a/test/core/http/parser_test.c
+++ b/test/core/http/parser_test.cc
@@ -29,14 +29,16 @@
 #include "test/core/util/test_config.h"
 
 static void test_request_succeeds(grpc_slice_split_mode split_mode,
-                                  char *request_text, char *expect_method,
+                                  const char* request_text,
+                                  const char* expect_method,
                                   grpc_http_version expect_version,
-                                  char *expect_path, char *expect_body, ...) {
+                                  const char* expect_path,
+                                  const char* expect_body, ...) {
   grpc_http_parser parser;
   grpc_slice input_slice = grpc_slice_from_copied_string(request_text);
   size_t num_slices;
   size_t i;
-  grpc_slice *slices;
+  grpc_slice* slices;
   va_list args;
   grpc_http_request request;
   memset(&request, 0, sizeof(request));
@@ -47,7 +49,7 @@ static void test_request_succeeds(grpc_slice_split_mode split_mode,
   grpc_http_parser_init(&parser, GRPC_HTTP_REQUEST, &request);
 
   for (i = 0; i < num_slices; i++) {
-    GPR_ASSERT(grpc_http_parser_parse(&parser, slices[i], NULL) ==
+    GPR_ASSERT(grpc_http_parser_parse(&parser, slices[i], nullptr) ==
                GRPC_ERROR_NONE);
     grpc_slice_unref(slices[i]);
   }
@@ -58,7 +60,7 @@ static void test_request_succeeds(grpc_slice_split_mode split_mode,
   GPR_ASSERT(0 == strcmp(expect_path, request.path));
   GPR_ASSERT(expect_version == request.version);
 
-  if (expect_body != NULL) {
+  if (expect_body != nullptr) {
     GPR_ASSERT(strlen(expect_body) == request.body_length);
     GPR_ASSERT(0 == memcmp(expect_body, request.body, request.body_length));
   } else {
@@ -68,12 +70,12 @@ static void test_request_succeeds(grpc_slice_split_mode split_mode,
   va_start(args, expect_body);
   i = 0;
   for (;;) {
-    char *expect_key;
-    char *expect_value;
-    expect_key = va_arg(args, char *);
+    char* expect_key;
+    char* expect_value;
+    expect_key = va_arg(args, char*);
     if (!expect_key) break;
     GPR_ASSERT(i < request.hdr_count);
-    expect_value = va_arg(args, char *);
+    expect_value = va_arg(args, char*);
     GPR_ASSERT(expect_value);
     GPR_ASSERT(0 == strcmp(expect_key, request.hdrs[i].key));
     GPR_ASSERT(0 == strcmp(expect_value, request.hdrs[i].value));
@@ -87,13 +89,14 @@ static void test_request_succeeds(grpc_slice_split_mode split_mode,
   gpr_free(slices);
 }
 
-static void test_succeeds(grpc_slice_split_mode split_mode, char *response_text,
-                          int expect_status, char *expect_body, ...) {
+static void test_succeeds(grpc_slice_split_mode split_mode,
+                          const char* response_text, int expect_status,
+                          const char* expect_body, ...) {
   grpc_http_parser parser;
   grpc_slice input_slice = grpc_slice_from_copied_string(response_text);
   size_t num_slices;
   size_t i;
-  grpc_slice *slices;
+  grpc_slice* slices;
   va_list args;
   grpc_http_response response;
   memset(&response, 0, sizeof(response));
@@ -104,7 +107,7 @@ static void test_succeeds(grpc_slice_split_mode split_mode, char *response_text,
   grpc_http_parser_init(&parser, GRPC_HTTP_RESPONSE, &response);
 
   for (i = 0; i < num_slices; i++) {
-    GPR_ASSERT(grpc_http_parser_parse(&parser, slices[i], NULL) ==
+    GPR_ASSERT(grpc_http_parser_parse(&parser, slices[i], nullptr) ==
                GRPC_ERROR_NONE);
     grpc_slice_unref(slices[i]);
   }
@@ -112,7 +115,7 @@ static void test_succeeds(grpc_slice_split_mode split_mode, char *response_text,
 
   GPR_ASSERT(GRPC_HTTP_RESPONSE == parser.type);
   GPR_ASSERT(expect_status == response.status);
-  if (expect_body != NULL) {
+  if (expect_body != nullptr) {
     GPR_ASSERT(strlen(expect_body) == response.body_length);
     GPR_ASSERT(0 == memcmp(expect_body, response.body, response.body_length));
   } else {
@@ -122,12 +125,12 @@ static void test_succeeds(grpc_slice_split_mode split_mode, char *response_text,
   va_start(args, expect_body);
   i = 0;
   for (;;) {
-    char *expect_key;
-    char *expect_value;
-    expect_key = va_arg(args, char *);
+    char* expect_key;
+    char* expect_value;
+    expect_key = va_arg(args, char*);
     if (!expect_key) break;
     GPR_ASSERT(i < response.hdr_count);
-    expect_value = va_arg(args, char *);
+    expect_value = va_arg(args, char*);
     GPR_ASSERT(expect_value);
     GPR_ASSERT(0 == strcmp(expect_key, response.hdrs[i].key));
     GPR_ASSERT(0 == strcmp(expect_value, response.hdrs[i].value));
@@ -141,13 +144,14 @@ static void test_succeeds(grpc_slice_split_mode split_mode, char *response_text,
   gpr_free(slices);
 }
 
-static void test_fails(grpc_slice_split_mode split_mode, char *response_text) {
+static void test_fails(grpc_slice_split_mode split_mode,
+                       const char* response_text) {
   grpc_http_parser parser;
   grpc_slice input_slice = grpc_slice_from_copied_string(response_text);
   size_t num_slices;
   size_t i;
-  grpc_slice *slices;
-  grpc_error *error = GRPC_ERROR_NONE;
+  grpc_slice* slices;
+  grpc_error* error = GRPC_ERROR_NONE;
   grpc_http_response response;
   memset(&response, 0, sizeof(response));
 
@@ -158,7 +162,7 @@ static void test_fails(grpc_slice_split_mode split_mode, char *response_text) {
 
   for (i = 0; i < num_slices; i++) {
     if (GRPC_ERROR_NONE == error) {
-      error = grpc_http_parser_parse(&parser, slices[i], NULL);
+      error = grpc_http_parser_parse(&parser, slices[i], nullptr);
     }
     grpc_slice_unref(slices[i]);
   }
@@ -174,13 +178,13 @@ static void test_fails(grpc_slice_split_mode split_mode, char *response_text) {
 }
 
 static void test_request_fails(grpc_slice_split_mode split_mode,
-                               char *request_text) {
+                               const char* request_text) {
   grpc_http_parser parser;
   grpc_slice input_slice = grpc_slice_from_copied_string(request_text);
   size_t num_slices;
   size_t i;
-  grpc_slice *slices;
-  grpc_error *error = GRPC_ERROR_NONE;
+  grpc_slice* slices;
+  grpc_error* error = GRPC_ERROR_NONE;
   grpc_http_request request;
   memset(&request, 0, sizeof(request));
 
@@ -191,7 +195,7 @@ static void test_request_fails(grpc_slice_split_mode split_mode,
 
   for (i = 0; i < num_slices; i++) {
     if (error == GRPC_ERROR_NONE) {
-      error = grpc_http_parser_parse(&parser, slices[i], NULL);
+      error = grpc_http_parser_parse(&parser, slices[i], nullptr);
     }
     grpc_slice_unref(slices[i]);
   }
@@ -206,7 +210,7 @@ static void test_request_fails(grpc_slice_split_mode split_mode,
   gpr_free(slices);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   size_t i;
   const grpc_slice_split_mode split_modes[] = {GRPC_SLICE_SPLIT_IDENTITY,
                                                GRPC_SLICE_SPLIT_ONE_BYTE};
@@ -224,7 +228,7 @@ int main(int argc, char **argv) {
     test_succeeds(split_modes[i],
                   "HTTP/1.0 404 Not Found\r\n"
                   "\r\n",
-                  404, NULL, NULL);
+                  404, nullptr, NULL);
     test_succeeds(split_modes[i],
                   "HTTP/1.1 200 OK\r\n"
                   "xyz: abc\r\n"
@@ -239,7 +243,7 @@ int main(int argc, char **argv) {
     test_request_succeeds(split_modes[i],
                           "GET / HTTP/1.0\r\n"
                           "\r\n",
-                          "GET", GRPC_HTTP_HTTP10, "/", NULL, NULL);
+                          "GET", GRPC_HTTP_HTTP10, "/", nullptr, NULL);
     test_request_succeeds(split_modes[i],
                           "GET / HTTP/1.0\r\n"
                           "\r\n"
@@ -286,7 +290,8 @@ int main(int argc, char **argv) {
     test_request_fails(split_modes[i], "GET / HTTP/1.2\r\n");
     test_request_fails(split_modes[i], "GET / HTTP/1.0\n");
 
-    tmp1 = gpr_malloc(2 * GRPC_HTTP_PARSER_MAX_HEADER_LENGTH);
+    tmp1 =
+        static_cast<char*>(gpr_malloc(2 * GRPC_HTTP_PARSER_MAX_HEADER_LENGTH));
     memset(tmp1, 'a', 2 * GRPC_HTTP_PARSER_MAX_HEADER_LENGTH - 1);
     tmp1[2 * GRPC_HTTP_PARSER_MAX_HEADER_LENGTH - 1] = 0;
     gpr_asprintf(&tmp2, "HTTP/1.0 200 OK\r\nxyz: %s\r\n\r\n", tmp1);
diff --git a/test/core/http/request_fuzzer.c b/test/core/http/request_fuzzer.cc
index aefe9eb0f9..368ac1b49d 100644
--- a/test/core/http/request_fuzzer.c
+++ b/test/core/http/request_fuzzer.cc
@@ -27,13 +27,13 @@
 bool squelch = true;
 bool leak_check = true;
 
-int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   grpc_http_parser parser;
   grpc_http_request request;
   memset(&request, 0, sizeof(request));
   grpc_http_parser_init(&parser, GRPC_HTTP_REQUEST, &request);
-  grpc_slice slice = grpc_slice_from_copied_buffer((const char *)data, size);
-  GRPC_ERROR_UNREF(grpc_http_parser_parse(&parser, slice, NULL));
+  grpc_slice slice = grpc_slice_from_copied_buffer((const char*)data, size);
+  GRPC_ERROR_UNREF(grpc_http_parser_parse(&parser, slice, nullptr));
   GRPC_ERROR_UNREF(grpc_http_parser_eof(&parser));
   grpc_slice_unref(slice);
   grpc_http_parser_destroy(&parser);
diff --git a/test/core/http/response_fuzzer.c b/test/core/http/response_fuzzer.cc
index d5bb67500d..2a793fddd4 100644
--- a/test/core/http/response_fuzzer.c
+++ b/test/core/http/response_fuzzer.cc
@@ -26,13 +26,13 @@
 bool squelch = true;
 bool leak_check = true;
 
-int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   grpc_http_parser parser;
   grpc_http_response response;
   memset(&response, 0, sizeof(response));
   grpc_http_parser_init(&parser, GRPC_HTTP_RESPONSE, &response);
-  grpc_slice slice = grpc_slice_from_copied_buffer((const char *)data, size);
-  GRPC_ERROR_UNREF(grpc_http_parser_parse(&parser, slice, NULL));
+  grpc_slice slice = grpc_slice_from_copied_buffer((const char*)data, size);
+  GRPC_ERROR_UNREF(grpc_http_parser_parse(&parser, slice, nullptr));
   GRPC_ERROR_UNREF(grpc_http_parser_eof(&parser));
   grpc_slice_unref(slice);
   grpc_http_parser_destroy(&parser);
diff --git a/test/core/iomgr/BUILD b/test/core/iomgr/BUILD
index 7620d1de21..41e2607646 100644
--- a/test/core/iomgr/BUILD
+++ b/test/core/iomgr/BUILD
@@ -22,9 +22,9 @@ grpc_package(name = "test/core/iomgr", visibility = "public") # Useful for third
 
 grpc_cc_library(
     name = "endpoint_tests",
-    srcs = ["endpoint_tests.c"],
+    srcs = ["endpoint_tests.cc"],
     hdrs = ["endpoint_tests.h"],
-    language = "C",
+    language = "C++",
     visibility = ["//test:__subpackages__"],
     deps = [
         "//:gpr",
@@ -36,8 +36,8 @@ grpc_cc_library(
 
 grpc_cc_test(
     name = "combiner_test",
-    srcs = ["combiner_test.c"],
-    language = "C",
+    srcs = ["combiner_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -48,8 +48,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "endpoint_pair_test",
-    srcs = ["endpoint_pair_test.c"],
-    language = "C",
+    srcs = ["endpoint_pair_test.cc"],
+    language = "C++",
     deps = [
         ":endpoint_tests",
         "//:gpr",
@@ -61,20 +61,20 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "ev_epollsig_linux_test",
-    srcs = ["ev_epollsig_linux_test.c"],
+    srcs = ["ev_epollsig_linux_test.cc"],
     deps = [
         "//:gpr",
         "//:grpc",
         "//test/core/util:gpr_test_util",
         "//test/core/util:grpc_test_util",
     ],
-    language = "C",
+    language = "C++",
 )
 
 grpc_cc_test(
     name = "fd_conservation_posix_test",
-    srcs = ["fd_conservation_posix_test.c"],
-    language = "C",
+    srcs = ["fd_conservation_posix_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -85,8 +85,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "fd_posix_test",
-    srcs = ["fd_posix_test.c"],
-    language = "C",
+    srcs = ["fd_posix_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -97,8 +97,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "load_file_test",
-    srcs = ["load_file_test.c"],
-    language = "C",
+    srcs = ["load_file_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -109,8 +109,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "pollset_set_test",
-    srcs = ["pollset_set_test.c"],
-    language = "C",
+    srcs = ["pollset_set_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -121,8 +121,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "resolve_address_posix_test",
-    srcs = ["resolve_address_posix_test.c"],
-    language = "C",
+    srcs = ["resolve_address_posix_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -133,8 +133,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "resolve_address_test",
-    srcs = ["resolve_address_test.c"],
-    language = "C",
+    srcs = ["resolve_address_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -145,8 +145,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "resource_quota_test",
-    srcs = ["resource_quota_test.c"],
-    language = "C",
+    srcs = ["resource_quota_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -157,8 +157,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "sockaddr_utils_test",
-    srcs = ["sockaddr_utils_test.c"],
-    language = "C",
+    srcs = ["sockaddr_utils_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -169,8 +169,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "socket_utils_test",
-    srcs = ["socket_utils_test.c"],
-    language = "C",
+    srcs = ["socket_utils_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -181,8 +181,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "tcp_client_posix_test",
-    srcs = ["tcp_client_posix_test.c"],
-    language = "C",
+    srcs = ["tcp_client_posix_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -193,8 +193,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "tcp_posix_test",
-    srcs = ["tcp_posix_test.c"],
-    language = "C",
+    srcs = ["tcp_posix_test.cc"],
+    language = "C++",
     deps = [
         ":endpoint_tests",
         "//:gpr",
@@ -206,8 +206,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "tcp_server_posix_test",
-    srcs = ["tcp_server_posix_test.c"],
-    language = "C",
+    srcs = ["tcp_server_posix_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -218,8 +218,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "time_averaged_stats_test",
-    srcs = ["time_averaged_stats_test.c"],
-    language = "C",
+    srcs = ["time_averaged_stats_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -230,8 +230,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "timer_heap_test",
-    srcs = ["timer_heap_test.c"],
-    language = "C",
+    srcs = ["timer_heap_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -242,8 +242,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "timer_list_test",
-    srcs = ["timer_list_test.c"],
-    language = "C",
+    srcs = ["timer_list_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -254,8 +254,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "udp_server_test",
-    srcs = ["udp_server_test.c"],
-    language = "C",
+    srcs = ["udp_server_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -266,8 +266,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "wakeup_fd_cv_test",
-    srcs = ["wakeup_fd_cv_test.c"],
-    language = "C",
+    srcs = ["wakeup_fd_cv_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
diff --git a/test/core/iomgr/combiner_test.c b/test/core/iomgr/combiner_test.cc
index 38f512de0e..146a6bd553 100644
--- a/test/core/iomgr/combiner_test.c
+++ b/test/core/iomgr/combiner_test.cc
@@ -33,15 +33,15 @@ static void test_no_op(void) {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void set_event_to_true(grpc_exec_ctx *exec_ctx, void *value,
-                              grpc_error *error) {
-  gpr_event_set(value, (void *)1);
+static void set_event_to_true(grpc_exec_ctx* exec_ctx, void* value,
+                              grpc_error* error) {
+  gpr_event_set(static_cast<gpr_event*>(value), (void*)1);
 }
 
 static void test_execute_one(void) {
   gpr_log(GPR_DEBUG, "test_execute_one");
 
-  grpc_combiner *lock = grpc_combiner_create();
+  grpc_combiner* lock = grpc_combiner_create();
   gpr_event done;
   gpr_event_init(&done);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -51,36 +51,36 @@ static void test_execute_one(void) {
                      GRPC_ERROR_NONE);
   grpc_exec_ctx_flush(&exec_ctx);
   GPR_ASSERT(gpr_event_wait(&done, grpc_timeout_seconds_to_deadline(5)) !=
-             NULL);
+             nullptr);
   GRPC_COMBINER_UNREF(&exec_ctx, lock, "test_execute_one");
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
 typedef struct {
   size_t ctr;
-  grpc_combiner *lock;
+  grpc_combiner* lock;
   gpr_event done;
 } thd_args;
 
 typedef struct {
-  size_t *ctr;
+  size_t* ctr;
   size_t value;
 } ex_args;
 
-static void check_one(grpc_exec_ctx *exec_ctx, void *a, grpc_error *error) {
-  ex_args *args = a;
+static void check_one(grpc_exec_ctx* exec_ctx, void* a, grpc_error* error) {
+  ex_args* args = static_cast<ex_args*>(a);
   GPR_ASSERT(*args->ctr == args->value - 1);
   *args->ctr = args->value;
   gpr_free(a);
 }
 
-static void execute_many_loop(void *a) {
-  thd_args *args = a;
+static void execute_many_loop(void* a) {
+  thd_args* args = static_cast<thd_args*>(a);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   size_t n = 1;
   for (size_t i = 0; i < 10; i++) {
     for (size_t j = 0; j < 10000; j++) {
-      ex_args *c = gpr_malloc(sizeof(*c));
+      ex_args* c = static_cast<ex_args*>(gpr_malloc(sizeof(*c)));
       c->ctr = &args->ctr;
       c->value = n++;
       GRPC_CLOSURE_SCHED(&exec_ctx,
@@ -103,7 +103,7 @@ static void execute_many_loop(void *a) {
 static void test_execute_many(void) {
   gpr_log(GPR_DEBUG, "test_execute_many");
 
-  grpc_combiner *lock = grpc_combiner_create();
+  grpc_combiner* lock = grpc_combiner_create();
   gpr_thd_id thds[100];
   thd_args ta[GPR_ARRAY_SIZE(thds)];
   for (size_t i = 0; i < GPR_ARRAY_SIZE(thds); i++) {
@@ -116,7 +116,7 @@ static void test_execute_many(void) {
   }
   for (size_t i = 0; i < GPR_ARRAY_SIZE(thds); i++) {
     GPR_ASSERT(gpr_event_wait(&ta[i].done,
-                              gpr_inf_future(GPR_CLOCK_REALTIME)) != NULL);
+                              gpr_inf_future(GPR_CLOCK_REALTIME)) != nullptr);
     gpr_thd_join(thds[i]);
   }
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -126,21 +126,22 @@ static void test_execute_many(void) {
 
 static gpr_event got_in_finally;
 
-static void in_finally(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  gpr_event_set(&got_in_finally, (void *)1);
+static void in_finally(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+  gpr_event_set(&got_in_finally, (void*)1);
 }
 
-static void add_finally(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
+static void add_finally(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
   GRPC_CLOSURE_SCHED(exec_ctx,
                      GRPC_CLOSURE_CREATE(in_finally, arg,
-                                         grpc_combiner_finally_scheduler(arg)),
+                                         grpc_combiner_finally_scheduler(
+                                             static_cast<grpc_combiner*>(arg))),
                      GRPC_ERROR_NONE);
 }
 
 static void test_execute_finally(void) {
   gpr_log(GPR_DEBUG, "test_execute_finally");
 
-  grpc_combiner *lock = grpc_combiner_create();
+  grpc_combiner* lock = grpc_combiner_create();
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   gpr_event_init(&got_in_finally);
   GRPC_CLOSURE_SCHED(
@@ -149,12 +150,12 @@ static void test_execute_finally(void) {
       GRPC_ERROR_NONE);
   grpc_exec_ctx_flush(&exec_ctx);
   GPR_ASSERT(gpr_event_wait(&got_in_finally,
-                            grpc_timeout_seconds_to_deadline(5)) != NULL);
+                            grpc_timeout_seconds_to_deadline(5)) != nullptr);
   GRPC_COMBINER_UNREF(&exec_ctx, lock, "test_execute_finally");
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   test_no_op();
diff --git a/test/core/iomgr/endpoint_pair_test.c b/test/core/iomgr/endpoint_pair_test.cc
index f2ce3d0d12..30a0cb5924 100644
--- a/test/core/iomgr/endpoint_pair_test.c
+++ b/test/core/iomgr/endpoint_pair_test.cc
@@ -25,8 +25,8 @@
 #include "test/core/iomgr/endpoint_tests.h"
 #include "test/core/util/test_config.h"
 
-static gpr_mu *g_mu;
-static grpc_pollset *g_pollset;
+static gpr_mu* g_mu;
+static grpc_pollset* g_pollset;
 
 static void clean_up(void) {}
 
@@ -34,10 +34,11 @@ static grpc_endpoint_test_fixture create_fixture_endpoint_pair(
     size_t slice_size) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_endpoint_test_fixture f;
-  grpc_arg a[] = {{.key = GRPC_ARG_TCP_READ_CHUNK_SIZE,
-                   .type = GRPC_ARG_INTEGER,
-                   .value.integer = (int)slice_size}};
-  grpc_channel_args args = {.num_args = GPR_ARRAY_SIZE(a), .args = a};
+  grpc_arg a[1];
+  a[0].key = const_cast<char*>(GRPC_ARG_TCP_READ_CHUNK_SIZE);
+  a[0].type = GRPC_ARG_INTEGER;
+  a[0].value.integer = (int)slice_size;
+  grpc_channel_args args = {GPR_ARRAY_SIZE(a), a};
   grpc_endpoint_pair p = grpc_iomgr_create_endpoint_pair("test", &args);
 
   f.client_ep = p.client;
@@ -53,17 +54,17 @@ static grpc_endpoint_test_config configs[] = {
     {"tcp/tcp_socketpair", create_fixture_endpoint_pair, clean_up},
 };
 
-static void destroy_pollset(grpc_exec_ctx *exec_ctx, void *p,
-                            grpc_error *error) {
-  grpc_pollset_destroy(exec_ctx, p);
+static void destroy_pollset(grpc_exec_ctx* exec_ctx, void* p,
+                            grpc_error* error) {
+  grpc_pollset_destroy(exec_ctx, static_cast<grpc_pollset*>(p));
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_closure destroyed;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_test_init(argc, argv);
   grpc_init();
-  g_pollset = gpr_zalloc(grpc_pollset_size());
+  g_pollset = static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
   grpc_pollset_init(g_pollset, &g_mu);
   grpc_endpoint_tests(configs[0], g_pollset, g_mu);
   GRPC_CLOSURE_INIT(&destroyed, destroy_pollset, g_pollset,
diff --git a/test/core/iomgr/endpoint_tests.c b/test/core/iomgr/endpoint_tests.cc
index 61e901f645..026e34105d 100644
--- a/test/core/iomgr/endpoint_tests.c
+++ b/test/core/iomgr/endpoint_tests.cc
@@ -46,14 +46,14 @@
 
 */
 
-static gpr_mu *g_mu;
-static grpc_pollset *g_pollset;
+static gpr_mu* g_mu;
+static grpc_pollset* g_pollset;
 
-size_t count_slices(grpc_slice *slices, size_t nslices, int *current_data) {
+size_t count_slices(grpc_slice* slices, size_t nslices, int* current_data) {
   size_t num_bytes = 0;
   size_t i;
   size_t j;
-  unsigned char *buf;
+  unsigned char* buf;
   for (i = 0; i < nslices; ++i) {
     buf = GRPC_SLICE_START_PTR(slices[i]);
     for (j = 0; j < GRPC_SLICE_LENGTH(slices[i]); ++j) {
@@ -66,7 +66,7 @@ size_t count_slices(grpc_slice *slices, size_t nslices, int *current_data) {
 }
 
 static grpc_endpoint_test_fixture begin_test(grpc_endpoint_test_config config,
-                                             const char *test_name,
+                                             const char* test_name,
                                              size_t slice_size) {
   gpr_log(GPR_INFO, "%s/%s", test_name, config.name);
   return config.create_fixture(slice_size);
@@ -74,14 +74,14 @@ static grpc_endpoint_test_fixture begin_test(grpc_endpoint_test_config config,
 
 static void end_test(grpc_endpoint_test_config config) { config.clean_up(); }
 
-static grpc_slice *allocate_blocks(size_t num_bytes, size_t slice_size,
-                                   size_t *num_blocks, uint8_t *current_data) {
+static grpc_slice* allocate_blocks(size_t num_bytes, size_t slice_size,
+                                   size_t* num_blocks, uint8_t* current_data) {
   size_t nslices = num_bytes / slice_size + (num_bytes % slice_size ? 1 : 0);
-  grpc_slice *slices = (grpc_slice *)gpr_malloc(sizeof(grpc_slice) * nslices);
+  grpc_slice* slices = (grpc_slice*)gpr_malloc(sizeof(grpc_slice) * nslices);
   size_t num_bytes_left = num_bytes;
   size_t i;
   size_t j;
-  unsigned char *buf;
+  unsigned char* buf;
   *num_blocks = nslices;
 
   for (i = 0; i < nslices; ++i) {
@@ -99,8 +99,8 @@ static grpc_slice *allocate_blocks(size_t num_bytes, size_t slice_size,
 }
 
 struct read_and_write_test_state {
-  grpc_endpoint *read_ep;
-  grpc_endpoint *write_ep;
+  grpc_endpoint* read_ep;
+  grpc_endpoint* write_ep;
   size_t target_bytes;
   size_t bytes_read;
   size_t current_write_size;
@@ -115,10 +115,10 @@ struct read_and_write_test_state {
   grpc_closure done_write;
 };
 
-static void read_and_write_test_read_handler(grpc_exec_ctx *exec_ctx,
-                                             void *data, grpc_error *error) {
-  struct read_and_write_test_state *state =
-      (struct read_and_write_test_state *)data;
+static void read_and_write_test_read_handler(grpc_exec_ctx* exec_ctx,
+                                             void* data, grpc_error* error) {
+  struct read_and_write_test_state* state =
+      (struct read_and_write_test_state*)data;
 
   state->bytes_read += count_slices(
       state->incoming.slices, state->incoming.count, &state->current_read_data);
@@ -127,7 +127,7 @@ static void read_and_write_test_read_handler(grpc_exec_ctx *exec_ctx,
     gpr_mu_lock(g_mu);
     state->read_done = 1 + (error == GRPC_ERROR_NONE);
     GRPC_LOG_IF_ERROR("pollset_kick",
-                      grpc_pollset_kick(exec_ctx, g_pollset, NULL));
+                      grpc_pollset_kick(exec_ctx, g_pollset, nullptr));
     gpr_mu_unlock(g_mu);
   } else if (error == GRPC_ERROR_NONE) {
     grpc_endpoint_read(exec_ctx, state->read_ep, &state->incoming,
@@ -135,11 +135,11 @@ static void read_and_write_test_read_handler(grpc_exec_ctx *exec_ctx,
   }
 }
 
-static void read_and_write_test_write_handler(grpc_exec_ctx *exec_ctx,
-                                              void *data, grpc_error *error) {
-  struct read_and_write_test_state *state =
-      (struct read_and_write_test_state *)data;
-  grpc_slice *slices = NULL;
+static void read_and_write_test_write_handler(grpc_exec_ctx* exec_ctx,
+                                              void* data, grpc_error* error) {
+  struct read_and_write_test_state* state =
+      (struct read_and_write_test_state*)data;
+  grpc_slice* slices = nullptr;
   size_t nslices;
 
   if (error == GRPC_ERROR_NONE) {
@@ -164,7 +164,7 @@ static void read_and_write_test_write_handler(grpc_exec_ctx *exec_ctx,
   gpr_mu_lock(g_mu);
   state->write_done = 1 + (error == GRPC_ERROR_NONE);
   GRPC_LOG_IF_ERROR("pollset_kick",
-                    grpc_pollset_kick(exec_ctx, g_pollset, NULL));
+                    grpc_pollset_kick(exec_ctx, g_pollset, nullptr));
   gpr_mu_unlock(g_mu);
 }
 
@@ -181,15 +181,17 @@ static void read_and_write_test(grpc_endpoint_test_config config,
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_millis deadline =
       grpc_timespec_to_millis_round_up(grpc_timeout_seconds_to_deadline(20));
-  gpr_log(GPR_DEBUG, "num_bytes=%" PRIuPTR " write_size=%" PRIuPTR
-                     " slice_size=%" PRIuPTR " shutdown=%d",
+  gpr_log(GPR_DEBUG,
+          "num_bytes=%" PRIuPTR " write_size=%" PRIuPTR " slice_size=%" PRIuPTR
+          " shutdown=%d",
           num_bytes, write_size, slice_size, shutdown);
 
   if (shutdown) {
     gpr_log(GPR_INFO, "Start read and write shutdown test");
   } else {
-    gpr_log(GPR_INFO, "Start read and write test with %" PRIuPTR
-                      " bytes, slice size %" PRIuPTR,
+    gpr_log(GPR_INFO,
+            "Start read and write test with %" PRIuPTR
+            " bytes, slice size %" PRIuPTR,
             num_bytes, slice_size);
   }
 
@@ -235,7 +237,7 @@ static void read_and_write_test(grpc_endpoint_test_config config,
 
   gpr_mu_lock(g_mu);
   while (!state.read_done || !state.write_done) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     GPR_ASSERT(grpc_exec_ctx_now(&exec_ctx) < deadline);
     GPR_ASSERT(GRPC_LOG_IF_ERROR(
         "pollset_work",
@@ -252,16 +254,16 @@ static void read_and_write_test(grpc_endpoint_test_config config,
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void inc_on_failure(grpc_exec_ctx *exec_ctx, void *arg,
-                           grpc_error *error) {
+static void inc_on_failure(grpc_exec_ctx* exec_ctx, void* arg,
+                           grpc_error* error) {
   gpr_mu_lock(g_mu);
-  *(int *)arg += (error != GRPC_ERROR_NONE);
-  GPR_ASSERT(
-      GRPC_LOG_IF_ERROR("kick", grpc_pollset_kick(exec_ctx, g_pollset, NULL)));
+  *(int*)arg += (error != GRPC_ERROR_NONE);
+  GPR_ASSERT(GRPC_LOG_IF_ERROR(
+      "kick", grpc_pollset_kick(exec_ctx, g_pollset, nullptr)));
   gpr_mu_unlock(g_mu);
 }
 
-static void wait_for_fail_count(grpc_exec_ctx *exec_ctx, int *fail_count,
+static void wait_for_fail_count(grpc_exec_ctx* exec_ctx, int* fail_count,
                                 int want_fail_count) {
   grpc_exec_ctx_flush(exec_ctx);
   gpr_mu_lock(g_mu);
@@ -269,7 +271,7 @@ static void wait_for_fail_count(grpc_exec_ctx *exec_ctx, int *fail_count,
       grpc_timespec_to_millis_round_up(grpc_timeout_seconds_to_deadline(10));
   while (grpc_exec_ctx_now(exec_ctx) < deadline &&
          *fail_count < want_fail_count) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     GPR_ASSERT(GRPC_LOG_IF_ERROR(
         "pollset_work",
         grpc_pollset_work(exec_ctx, g_pollset, &worker, deadline)));
@@ -319,7 +321,7 @@ static void multiple_shutdown_test(grpc_endpoint_test_config config) {
 }
 
 void grpc_endpoint_tests(grpc_endpoint_test_config config,
-                         grpc_pollset *pollset, gpr_mu *mu) {
+                         grpc_pollset* pollset, gpr_mu* mu) {
   size_t i;
   g_pollset = pollset;
   g_mu = mu;
@@ -330,6 +332,6 @@ void grpc_endpoint_tests(grpc_endpoint_test_config config,
   for (i = 1; i < 1000; i = GPR_MAX(i + 1, i * 5 / 4)) {
     read_and_write_test(config, 40320, i, i, false);
   }
-  g_pollset = NULL;
-  g_mu = NULL;
+  g_pollset = nullptr;
+  g_mu = nullptr;
 }
diff --git a/test/core/iomgr/endpoint_tests.h b/test/core/iomgr/endpoint_tests.h
index def29d3224..227eeb997c 100644
--- a/test/core/iomgr/endpoint_tests.h
+++ b/test/core/iomgr/endpoint_tests.h
@@ -27,17 +27,17 @@ typedef struct grpc_endpoint_test_config grpc_endpoint_test_config;
 typedef struct grpc_endpoint_test_fixture grpc_endpoint_test_fixture;
 
 struct grpc_endpoint_test_fixture {
-  grpc_endpoint *client_ep;
-  grpc_endpoint *server_ep;
+  grpc_endpoint* client_ep;
+  grpc_endpoint* server_ep;
 };
 
 struct grpc_endpoint_test_config {
-  const char *name;
+  const char* name;
   grpc_endpoint_test_fixture (*create_fixture)(size_t slice_size);
   void (*clean_up)();
 };
 
 void grpc_endpoint_tests(grpc_endpoint_test_config config,
-                         grpc_pollset *pollset, gpr_mu *mu);
+                         grpc_pollset* pollset, gpr_mu* mu);
 
 #endif /* GRPC_TEST_CORE_IOMGR_ENDPOINT_TESTS_H */
diff --git a/test/core/iomgr/error_test.c b/test/core/iomgr/error_test.cc
index 51f8af1957..51f8af1957 100644
--- a/test/core/iomgr/error_test.c
+++ b/test/core/iomgr/error_test.cc
diff --git a/test/core/iomgr/ev_epollsig_linux_test.c b/test/core/iomgr/ev_epollsig_linux_test.cc
index 37aadacd49..ac8b2f43d1 100644
--- a/test/core/iomgr/ev_epollsig_linux_test.c
+++ b/test/core/iomgr/ev_epollsig_linux_test.cc
@@ -36,17 +36,17 @@
 #include "test/core/util/test_config.h"
 
 typedef struct test_pollset {
-  grpc_pollset *pollset;
-  gpr_mu *mu;
+  grpc_pollset* pollset;
+  gpr_mu* mu;
 } test_pollset;
 
 typedef struct test_fd {
   int inner_fd;
-  grpc_fd *fd;
+  grpc_fd* fd;
 } test_fd;
 
 /* num_fds should be an even number */
-static void test_fd_init(test_fd *tfds, int *fds, int num_fds) {
+static void test_fd_init(test_fd* tfds, int* fds, int num_fds) {
   int i;
   int r;
 
@@ -70,7 +70,7 @@ static void test_fd_init(test_fd *tfds, int *fds, int num_fds) {
   }
 }
 
-static void test_fd_cleanup(grpc_exec_ctx *exec_ctx, test_fd *tfds,
+static void test_fd_cleanup(grpc_exec_ctx* exec_ctx, test_fd* tfds,
                             int num_fds) {
   int release_fd;
   int i;
@@ -80,7 +80,7 @@ static void test_fd_cleanup(grpc_exec_ctx *exec_ctx, test_fd *tfds,
                      GRPC_ERROR_CREATE_FROM_STATIC_STRING("test_fd_cleanup"));
     grpc_exec_ctx_flush(exec_ctx);
 
-    grpc_fd_orphan(exec_ctx, tfds[i].fd, NULL, &release_fd,
+    grpc_fd_orphan(exec_ctx, tfds[i].fd, nullptr, &release_fd,
                    false /* already_closed */, "test_fd_cleanup");
     grpc_exec_ctx_flush(exec_ctx);
 
@@ -89,21 +89,22 @@ static void test_fd_cleanup(grpc_exec_ctx *exec_ctx, test_fd *tfds,
   }
 }
 
-static void test_pollset_init(test_pollset *pollsets, int num_pollsets) {
+static void test_pollset_init(test_pollset* pollsets, int num_pollsets) {
   int i;
   for (i = 0; i < num_pollsets; i++) {
-    pollsets[i].pollset = gpr_zalloc(grpc_pollset_size());
+    pollsets[i].pollset =
+        static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
     grpc_pollset_init(pollsets[i].pollset, &pollsets[i].mu);
   }
 }
 
-static void destroy_pollset(grpc_exec_ctx *exec_ctx, void *p,
-                            grpc_error *error) {
-  grpc_pollset_destroy(exec_ctx, p);
+static void destroy_pollset(grpc_exec_ctx* exec_ctx, void* p,
+                            grpc_error* error) {
+  grpc_pollset_destroy(exec_ctx, (grpc_pollset*)p);
 }
 
-static void test_pollset_cleanup(grpc_exec_ctx *exec_ctx,
-                                 test_pollset *pollsets, int num_pollsets) {
+static void test_pollset_cleanup(grpc_exec_ctx* exec_ctx,
+                                 test_pollset* pollsets, int num_pollsets) {
   grpc_closure destroyed;
   int i;
 
@@ -117,16 +118,16 @@ static void test_pollset_cleanup(grpc_exec_ctx *exec_ctx,
   }
 }
 
-/*
- * Cases to test:
- *  case 1) Polling islands of both fd and pollset are NULL
- *  case 2) Polling island of fd is NULL but that of pollset is not-NULL
- *  case 3) Polling island of fd is not-NULL but that of pollset is NULL
- *  case 4) Polling islands of both fd and pollset are not-NULL and:
- *     case 4.1) Polling islands of fd and pollset are equal
- *     case 4.2) Polling islands of fd and pollset are NOT-equal (This results
- *     in a merge)
- * */
+  /*
+   * Cases to test:
+   *  case 1) Polling islands of both fd and pollset are NULL
+   *  case 2) Polling island of fd is NULL but that of pollset is not-NULL
+   *  case 3) Polling island of fd is not-NULL but that of pollset is NULL
+   *  case 4) Polling islands of both fd and pollset are not-NULL and:
+   *     case 4.1) Polling islands of fd and pollset are equal
+   *     case 4.2) Polling islands of fd and pollset are NOT-equal (This results
+   *     in a merge)
+   * */
 
 #define NUM_FDS 8
 #define NUM_POLLSETS 4
@@ -136,7 +137,7 @@ static void test_add_fd_to_pollset() {
   test_fd tfds[NUM_FDS];
   int fds[NUM_FDS];
   test_pollset pollsets[NUM_POLLSETS];
-  void *expected_pi = NULL;
+  void* expected_pi = nullptr;
   int i;
 
   test_fd_init(tfds, fds, NUM_FDS);
@@ -221,21 +222,21 @@ static void test_add_fd_to_pollset() {
 #undef NUM_POLLSETS
 
 typedef struct threading_shared {
-  gpr_mu *mu;
-  grpc_pollset *pollset;
-  grpc_wakeup_fd *wakeup_fd;
-  grpc_fd *wakeup_desc;
+  gpr_mu* mu;
+  grpc_pollset* pollset;
+  grpc_wakeup_fd* wakeup_fd;
+  grpc_fd* wakeup_desc;
   grpc_closure on_wakeup;
   int wakeups;
 } threading_shared;
 
 static __thread int thread_wakeups = 0;
 
-static void test_threading_loop(void *arg) {
-  threading_shared *shared = arg;
+static void test_threading_loop(void* arg) {
+  threading_shared* shared = static_cast<threading_shared*>(arg);
   while (thread_wakeups < 1000000) {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_pollset_worker *worker;
+    grpc_pollset_worker* worker;
     gpr_mu_lock(shared->mu);
     GPR_ASSERT(GRPC_LOG_IF_ERROR(
         "pollset_work", grpc_pollset_work(&exec_ctx, shared->pollset, &worker,
@@ -245,9 +246,9 @@ static void test_threading_loop(void *arg) {
   }
 }
 
-static void test_threading_wakeup(grpc_exec_ctx *exec_ctx, void *arg,
-                                  grpc_error *error) {
-  threading_shared *shared = arg;
+static void test_threading_wakeup(grpc_exec_ctx* exec_ctx, void* arg,
+                                  grpc_error* error) {
+  threading_shared* shared = static_cast<threading_shared*>(arg);
   ++shared->wakeups;
   ++thread_wakeups;
   if (error == GRPC_ERROR_NONE) {
@@ -261,7 +262,7 @@ static void test_threading_wakeup(grpc_exec_ctx *exec_ctx, void *arg,
 
 static void test_threading(void) {
   threading_shared shared;
-  shared.pollset = gpr_zalloc(grpc_pollset_size());
+  shared.pollset = static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
   grpc_pollset_init(shared.pollset, &shared.mu);
 
   gpr_thd_id thds[10];
@@ -294,7 +295,7 @@ static void test_threading(void) {
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_fd_shutdown(&exec_ctx, shared.wakeup_desc, GRPC_ERROR_CANCELLED);
-    grpc_fd_orphan(&exec_ctx, shared.wakeup_desc, NULL, NULL,
+    grpc_fd_orphan(&exec_ctx, shared.wakeup_desc, nullptr, nullptr,
                    false /* already_closed */, "done");
     grpc_pollset_shutdown(&exec_ctx, shared.pollset,
                           GRPC_CLOSURE_CREATE(destroy_pollset, shared.pollset,
@@ -304,14 +305,14 @@ static void test_threading(void) {
   gpr_free(shared.pollset);
 }
 
-int main(int argc, char **argv) {
-  const char *poll_strategy = NULL;
+int main(int argc, char** argv) {
+  const char* poll_strategy = nullptr;
   grpc_test_init(argc, argv);
   grpc_init();
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
   poll_strategy = grpc_get_poll_strategy_name();
-  if (poll_strategy != NULL && strcmp(poll_strategy, "epollsig") == 0) {
+  if (poll_strategy != nullptr && strcmp(poll_strategy, "epollsig") == 0) {
     test_add_fd_to_pollset();
     test_threading();
   } else {
@@ -325,6 +326,6 @@ int main(int argc, char **argv) {
   grpc_shutdown();
   return 0;
 }
-#else /* defined(GRPC_LINUX_EPOLL) */
-int main(int argc, char **argv) { return 0; }
+#else  /* defined(GRPC_LINUX_EPOLL) */
+int main(int argc, char** argv) { return 0; }
 #endif /* !defined(GRPC_LINUX_EPOLL) */
diff --git a/test/core/iomgr/fd_conservation_posix_test.c b/test/core/iomgr/fd_conservation_posix_test.cc
index d29b1e8e41..f46430c611 100644
--- a/test/core/iomgr/fd_conservation_posix_test.c
+++ b/test/core/iomgr/fd_conservation_posix_test.cc
@@ -24,7 +24,7 @@
 #include "src/core/lib/iomgr/iomgr.h"
 #include "test/core/util/test_config.h"
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   int i;
   struct rlimit rlim;
   grpc_endpoint_pair p;
@@ -38,11 +38,11 @@ int main(int argc, char **argv) {
      of descriptors */
   rlim.rlim_cur = rlim.rlim_max = 10;
   GPR_ASSERT(0 == setrlimit(RLIMIT_NOFILE, &rlim));
-  grpc_resource_quota *resource_quota =
+  grpc_resource_quota* resource_quota =
       grpc_resource_quota_create("fd_conservation_posix_test");
 
   for (i = 0; i < 100; i++) {
-    p = grpc_iomgr_create_endpoint_pair("test", NULL);
+    p = grpc_iomgr_create_endpoint_pair("test", nullptr);
     grpc_endpoint_destroy(&exec_ctx, p.client);
     grpc_endpoint_destroy(&exec_ctx, p.server);
     grpc_exec_ctx_flush(&exec_ctx);
diff --git a/test/core/iomgr/fd_posix_test.c b/test/core/iomgr/fd_posix_test.cc
index 1c62f34d3e..a03d841ecd 100644
--- a/test/core/iomgr/fd_posix_test.c
+++ b/test/core/iomgr/fd_posix_test.cc
@@ -46,8 +46,8 @@
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 #include "test/core/util/test_config.h"
 
-static gpr_mu *g_mu;
-static grpc_pollset *g_pollset;
+static gpr_mu* g_mu;
+static grpc_pollset* g_pollset;
 
 /* buffer size used to send and receive data.
    1024 is the minimal value to set TCP send and receive buffer. */
@@ -56,8 +56,8 @@ static grpc_pollset *g_pollset;
 /* Create a test socket with the right properties for testing.
    port is the TCP port to listen or connect to.
    Return a socket FD and sockaddr_in. */
-static void create_test_socket(int port, int *socket_fd,
-                               struct sockaddr_in *sin) {
+static void create_test_socket(int port, int* socket_fd,
+                               struct sockaddr_in* sin) {
   int fd;
   int one = 1;
   int buffer_size_bytes = BUF_SIZE;
@@ -82,20 +82,20 @@ static void create_test_socket(int port, int *socket_fd,
 }
 
 /* Dummy gRPC callback */
-void no_op_cb(void *arg, int success) {}
+void no_op_cb(void* arg, int success) {}
 
 /* =======An upload server to test notify_on_read===========
    The server simply reads and counts a stream of bytes. */
 
 /* An upload server. */
 typedef struct {
-  grpc_fd *em_fd;           /* listening fd */
+  grpc_fd* em_fd;           /* listening fd */
   ssize_t read_bytes_total; /* total number of received bytes */
   int done;                 /* set to 1 when a server finishes serving */
   grpc_closure listen_closure;
 } server;
 
-static void server_init(server *sv) {
+static void server_init(server* sv) {
   sv->read_bytes_total = 0;
   sv->done = 0;
 }
@@ -103,20 +103,20 @@ static void server_init(server *sv) {
 /* An upload session.
    Created when a new upload request arrives in the server. */
 typedef struct {
-  server *sv;              /* not owned by a single session */
-  grpc_fd *em_fd;          /* fd to read upload bytes */
+  server* sv;              /* not owned by a single session */
+  grpc_fd* em_fd;          /* fd to read upload bytes */
   char read_buf[BUF_SIZE]; /* buffer to store upload bytes */
   grpc_closure session_read_closure;
 } session;
 
 /* Called when an upload session can be safely shutdown.
    Close session FD and start to shutdown listen FD. */
-static void session_shutdown_cb(grpc_exec_ctx *exec_ctx, void *arg, /*session */
+static void session_shutdown_cb(grpc_exec_ctx* exec_ctx, void* arg, /*session */
                                 bool success) {
-  session *se = arg;
-  server *sv = se->sv;
-  grpc_fd_orphan(exec_ctx, se->em_fd, NULL, NULL, false /* already_closed */,
-                 "a");
+  session* se = static_cast<session*>(arg);
+  server* sv = se->sv;
+  grpc_fd_orphan(exec_ctx, se->em_fd, nullptr, nullptr,
+                 false /* already_closed */, "a");
   gpr_free(se);
   /* Start to shutdown listen fd. */
   grpc_fd_shutdown(exec_ctx, sv->em_fd,
@@ -124,9 +124,9 @@ static void session_shutdown_cb(grpc_exec_ctx *exec_ctx, void *arg, /*session */
 }
 
 /* Called when data become readable in a session. */
-static void session_read_cb(grpc_exec_ctx *exec_ctx, void *arg, /*session */
-                            grpc_error *error) {
-  session *se = arg;
+static void session_read_cb(grpc_exec_ctx* exec_ctx, void* arg, /*session */
+                            grpc_error* error) {
+  session* se = static_cast<session*>(arg);
   int fd = grpc_fd_wrapped_fd(se->em_fd);
 
   ssize_t read_once = 0;
@@ -169,42 +169,42 @@ static void session_read_cb(grpc_exec_ctx *exec_ctx, void *arg, /*session */
 
 /* Called when the listen FD can be safely shutdown.
    Close listen FD and signal that server can be shutdown. */
-static void listen_shutdown_cb(grpc_exec_ctx *exec_ctx, void *arg /*server */,
+static void listen_shutdown_cb(grpc_exec_ctx* exec_ctx, void* arg /*server */,
                                int success) {
-  server *sv = arg;
+  server* sv = static_cast<server*>(arg);
 
-  grpc_fd_orphan(exec_ctx, sv->em_fd, NULL, NULL, false /* already_closed */,
-                 "b");
+  grpc_fd_orphan(exec_ctx, sv->em_fd, nullptr, nullptr,
+                 false /* already_closed */, "b");
 
   gpr_mu_lock(g_mu);
   sv->done = 1;
-  GPR_ASSERT(GRPC_LOG_IF_ERROR("pollset_kick",
-                               grpc_pollset_kick(exec_ctx, g_pollset, NULL)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR(
+      "pollset_kick", grpc_pollset_kick(exec_ctx, g_pollset, nullptr)));
   gpr_mu_unlock(g_mu);
 }
 
 /* Called when a new TCP connection request arrives in the listening port. */
-static void listen_cb(grpc_exec_ctx *exec_ctx, void *arg, /*=sv_arg*/
-                      grpc_error *error) {
-  server *sv = arg;
+static void listen_cb(grpc_exec_ctx* exec_ctx, void* arg, /*=sv_arg*/
+                      grpc_error* error) {
+  server* sv = static_cast<server*>(arg);
   int fd;
   int flags;
-  session *se;
+  session* se;
   struct sockaddr_storage ss;
   socklen_t slen = sizeof(ss);
-  grpc_fd *listen_em_fd = sv->em_fd;
+  grpc_fd* listen_em_fd = sv->em_fd;
 
   if (error != GRPC_ERROR_NONE) {
     listen_shutdown_cb(exec_ctx, arg, 1);
     return;
   }
 
-  fd = accept(grpc_fd_wrapped_fd(listen_em_fd), (struct sockaddr *)&ss, &slen);
+  fd = accept(grpc_fd_wrapped_fd(listen_em_fd), (struct sockaddr*)&ss, &slen);
   GPR_ASSERT(fd >= 0);
   GPR_ASSERT(fd < FD_SETSIZE);
   flags = fcntl(fd, F_GETFL, 0);
   fcntl(fd, F_SETFL, flags | O_NONBLOCK);
-  se = gpr_malloc(sizeof(*se));
+  se = static_cast<session*>(gpr_malloc(sizeof(*se)));
   se->sv = sv;
   se->em_fd = grpc_fd_create(fd, "listener");
   grpc_pollset_add_fd(exec_ctx, g_pollset, se->em_fd);
@@ -222,7 +222,7 @@ static void listen_cb(grpc_exec_ctx *exec_ctx, void *arg, /*=sv_arg*/
    listen_cb() is registered to be interested in reading from listen_fd.
    When connection request arrives, listen_cb() is called to accept the
    connection request. */
-static int server_start(grpc_exec_ctx *exec_ctx, server *sv) {
+static int server_start(grpc_exec_ctx* exec_ctx, server* sv) {
   int port = 0;
   int fd;
   struct sockaddr_in sin;
@@ -230,8 +230,8 @@ static int server_start(grpc_exec_ctx *exec_ctx, server *sv) {
 
   create_test_socket(port, &fd, &sin);
   addr_len = sizeof(sin);
-  GPR_ASSERT(bind(fd, (struct sockaddr *)&sin, addr_len) == 0);
-  GPR_ASSERT(getsockname(fd, (struct sockaddr *)&sin, &addr_len) == 0);
+  GPR_ASSERT(bind(fd, (struct sockaddr*)&sin, addr_len) == 0);
+  GPR_ASSERT(getsockname(fd, (struct sockaddr*)&sin, &addr_len) == 0);
   port = ntohs(sin.sin_port);
   GPR_ASSERT(listen(fd, MAX_NUM_FD) == 0);
 
@@ -246,11 +246,11 @@ static int server_start(grpc_exec_ctx *exec_ctx, server *sv) {
 }
 
 /* Wait and shutdown a sever. */
-static void server_wait_and_shutdown(server *sv) {
+static void server_wait_and_shutdown(server* sv) {
   gpr_mu_lock(g_mu);
   while (!sv->done) {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     GPR_ASSERT(GRPC_LOG_IF_ERROR(
         "pollset_work", grpc_pollset_work(&exec_ctx, g_pollset, &worker,
                                           GRPC_MILLIS_INF_FUTURE)));
@@ -270,7 +270,7 @@ static void server_wait_and_shutdown(server *sv) {
 
 /* An upload client. */
 typedef struct {
-  grpc_fd *em_fd;
+  grpc_fd* em_fd;
   char write_buf[CLIENT_WRITE_BUF_SIZE];
   ssize_t write_bytes_total;
   /* Number of times that the client fills up the write buffer and calls
@@ -281,7 +281,7 @@ typedef struct {
   grpc_closure write_closure;
 } client;
 
-static void client_init(client *cl) {
+static void client_init(client* cl) {
   memset(cl->write_buf, 0, sizeof(cl->write_buf));
   cl->write_bytes_total = 0;
   cl->client_write_cnt = 0;
@@ -289,20 +289,20 @@ static void client_init(client *cl) {
 }
 
 /* Called when a client upload session is ready to shutdown. */
-static void client_session_shutdown_cb(grpc_exec_ctx *exec_ctx,
-                                       void *arg /*client */, int success) {
-  client *cl = arg;
-  grpc_fd_orphan(exec_ctx, cl->em_fd, NULL, NULL, false /* already_closed */,
-                 "c");
+static void client_session_shutdown_cb(grpc_exec_ctx* exec_ctx,
+                                       void* arg /*client */, int success) {
+  client* cl = static_cast<client*>(arg);
+  grpc_fd_orphan(exec_ctx, cl->em_fd, nullptr, nullptr,
+                 false /* already_closed */, "c");
   cl->done = 1;
-  GPR_ASSERT(GRPC_LOG_IF_ERROR("pollset_kick",
-                               grpc_pollset_kick(exec_ctx, g_pollset, NULL)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR(
+      "pollset_kick", grpc_pollset_kick(exec_ctx, g_pollset, nullptr)));
 }
 
 /* Write as much as possible, then register notify_on_write. */
-static void client_session_write(grpc_exec_ctx *exec_ctx, void *arg, /*client */
-                                 grpc_error *error) {
-  client *cl = arg;
+static void client_session_write(grpc_exec_ctx* exec_ctx, void* arg, /*client */
+                                 grpc_error* error) {
+  client* cl = static_cast<client*>(arg);
   int fd = grpc_fd_wrapped_fd(cl->em_fd);
   ssize_t write_once = 0;
 
@@ -336,11 +336,11 @@ static void client_session_write(grpc_exec_ctx *exec_ctx, void *arg, /*client */
 }
 
 /* Start a client to send a stream of bytes. */
-static void client_start(grpc_exec_ctx *exec_ctx, client *cl, int port) {
+static void client_start(grpc_exec_ctx* exec_ctx, client* cl, int port) {
   int fd;
   struct sockaddr_in sin;
   create_test_socket(port, &fd, &sin);
-  if (connect(fd, (struct sockaddr *)&sin, sizeof(sin)) == -1) {
+  if (connect(fd, (struct sockaddr*)&sin, sizeof(sin)) == -1) {
     if (errno == EINPROGRESS) {
       struct pollfd pfd;
       pfd.fd = fd;
@@ -363,10 +363,10 @@ static void client_start(grpc_exec_ctx *exec_ctx, client *cl, int port) {
 }
 
 /* Wait for the signal to shutdown a client. */
-static void client_wait_and_shutdown(client *cl) {
+static void client_wait_and_shutdown(client* cl) {
   gpr_mu_lock(g_mu);
   while (!cl->done) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     GPR_ASSERT(GRPC_LOG_IF_ERROR(
         "pollset_work", grpc_pollset_work(&exec_ctx, g_pollset, &worker,
@@ -402,31 +402,31 @@ typedef struct fd_change_data {
   grpc_iomgr_cb_func cb_that_ran;
 } fd_change_data;
 
-void init_change_data(fd_change_data *fdc) { fdc->cb_that_ran = NULL; }
+void init_change_data(fd_change_data* fdc) { fdc->cb_that_ran = nullptr; }
 
-void destroy_change_data(fd_change_data *fdc) {}
+void destroy_change_data(fd_change_data* fdc) {}
 
-static void first_read_callback(grpc_exec_ctx *exec_ctx,
-                                void *arg /* fd_change_data */,
-                                grpc_error *error) {
-  fd_change_data *fdc = arg;
+static void first_read_callback(grpc_exec_ctx* exec_ctx,
+                                void* arg /* fd_change_data */,
+                                grpc_error* error) {
+  fd_change_data* fdc = static_cast<fd_change_data*>(arg);
 
   gpr_mu_lock(g_mu);
   fdc->cb_that_ran = first_read_callback;
-  GPR_ASSERT(GRPC_LOG_IF_ERROR("pollset_kick",
-                               grpc_pollset_kick(exec_ctx, g_pollset, NULL)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR(
+      "pollset_kick", grpc_pollset_kick(exec_ctx, g_pollset, nullptr)));
   gpr_mu_unlock(g_mu);
 }
 
-static void second_read_callback(grpc_exec_ctx *exec_ctx,
-                                 void *arg /* fd_change_data */,
-                                 grpc_error *error) {
-  fd_change_data *fdc = arg;
+static void second_read_callback(grpc_exec_ctx* exec_ctx,
+                                 void* arg /* fd_change_data */,
+                                 grpc_error* error) {
+  fd_change_data* fdc = static_cast<fd_change_data*>(arg);
 
   gpr_mu_lock(g_mu);
   fdc->cb_that_ran = second_read_callback;
-  GPR_ASSERT(GRPC_LOG_IF_ERROR("pollset_kick",
-                               grpc_pollset_kick(exec_ctx, g_pollset, NULL)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR(
+      "pollset_kick", grpc_pollset_kick(exec_ctx, g_pollset, nullptr)));
   gpr_mu_unlock(g_mu);
 }
 
@@ -435,7 +435,7 @@ static void second_read_callback(grpc_exec_ctx *exec_ctx,
    point is to have two different function pointers and two different data
    pointers and make sure that changing both really works. */
 static void test_grpc_fd_change(void) {
-  grpc_fd *em_fd;
+  grpc_fd* em_fd;
   fd_change_data a, b;
   int flags;
   int sv[2];
@@ -470,8 +470,8 @@ static void test_grpc_fd_change(void) {
 
   /* And now wait for it to run. */
   gpr_mu_lock(g_mu);
-  while (a.cb_that_ran == NULL) {
-    grpc_pollset_worker *worker = NULL;
+  while (a.cb_that_ran == nullptr) {
+    grpc_pollset_worker* worker = nullptr;
     GPR_ASSERT(GRPC_LOG_IF_ERROR(
         "pollset_work", grpc_pollset_work(&exec_ctx, g_pollset, &worker,
                                           GRPC_MILLIS_INF_FUTURE)));
@@ -494,8 +494,8 @@ static void test_grpc_fd_change(void) {
   GPR_ASSERT(result == 1);
 
   gpr_mu_lock(g_mu);
-  while (b.cb_that_ran == NULL) {
-    grpc_pollset_worker *worker = NULL;
+  while (b.cb_that_ran == nullptr) {
+    grpc_pollset_worker* worker = nullptr;
     GPR_ASSERT(GRPC_LOG_IF_ERROR(
         "pollset_work", grpc_pollset_work(&exec_ctx, g_pollset, &worker,
                                           GRPC_MILLIS_INF_FUTURE)));
@@ -507,24 +507,25 @@ static void test_grpc_fd_change(void) {
   GPR_ASSERT(b.cb_that_ran == second_read_callback);
   gpr_mu_unlock(g_mu);
 
-  grpc_fd_orphan(&exec_ctx, em_fd, NULL, NULL, false /* already_closed */, "d");
+  grpc_fd_orphan(&exec_ctx, em_fd, nullptr, nullptr, false /* already_closed */,
+                 "d");
   grpc_exec_ctx_finish(&exec_ctx);
   destroy_change_data(&a);
   destroy_change_data(&b);
   close(sv[1]);
 }
 
-static void destroy_pollset(grpc_exec_ctx *exec_ctx, void *p,
-                            grpc_error *error) {
-  grpc_pollset_destroy(exec_ctx, p);
+static void destroy_pollset(grpc_exec_ctx* exec_ctx, void* p,
+                            grpc_error* error) {
+  grpc_pollset_destroy(exec_ctx, static_cast<grpc_pollset*>(p));
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_closure destroyed;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_test_init(argc, argv);
   grpc_init();
-  g_pollset = gpr_zalloc(grpc_pollset_size());
+  g_pollset = static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
   grpc_pollset_init(g_pollset, &g_mu);
   test_grpc_fd();
   test_grpc_fd_change();
@@ -540,6 +541,6 @@ int main(int argc, char **argv) {
 
 #else /* GRPC_POSIX_SOCKET */
 
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
 
 #endif /* GRPC_POSIX_SOCKET */
diff --git a/test/core/iomgr/load_file_test.c b/test/core/iomgr/load_file_test.cc
index 537c3430b1..9f360badcc 100644
--- a/test/core/iomgr/load_file_test.c
+++ b/test/core/iomgr/load_file_test.cc
@@ -33,17 +33,17 @@
 static const char prefix[] = "file_test";
 
 static void test_load_empty_file(void) {
-  FILE *tmp = NULL;
+  FILE* tmp = nullptr;
   grpc_slice slice;
   grpc_slice slice_with_null_term;
-  grpc_error *error;
-  char *tmp_name;
+  grpc_error* error;
+  char* tmp_name;
 
   LOG_TEST_NAME("test_load_empty_file");
 
   tmp = gpr_tmpfile(prefix, &tmp_name);
-  GPR_ASSERT(tmp_name != NULL);
-  GPR_ASSERT(tmp != NULL);
+  GPR_ASSERT(tmp_name != nullptr);
+  GPR_ASSERT(tmp != nullptr);
   fclose(tmp);
 
   error = grpc_load_file(tmp_name, 0, &slice);
@@ -62,16 +62,16 @@ static void test_load_empty_file(void) {
 }
 
 static void test_load_failure(void) {
-  FILE *tmp = NULL;
+  FILE* tmp = nullptr;
   grpc_slice slice;
-  grpc_error *error;
-  char *tmp_name;
+  grpc_error* error;
+  char* tmp_name;
 
   LOG_TEST_NAME("test_load_failure");
 
   tmp = gpr_tmpfile(prefix, &tmp_name);
-  GPR_ASSERT(tmp_name != NULL);
-  GPR_ASSERT(tmp != NULL);
+  GPR_ASSERT(tmp_name != nullptr);
+  GPR_ASSERT(tmp != nullptr);
   fclose(tmp);
   remove(tmp_name);
 
@@ -84,18 +84,18 @@ static void test_load_failure(void) {
 }
 
 static void test_load_small_file(void) {
-  FILE *tmp = NULL;
+  FILE* tmp = nullptr;
   grpc_slice slice;
   grpc_slice slice_with_null_term;
-  grpc_error *error;
-  char *tmp_name;
-  const char *blah = "blah";
+  grpc_error* error;
+  char* tmp_name;
+  const char* blah = "blah";
 
   LOG_TEST_NAME("test_load_small_file");
 
   tmp = gpr_tmpfile(prefix, &tmp_name);
-  GPR_ASSERT(tmp_name != NULL);
-  GPR_ASSERT(tmp != NULL);
+  GPR_ASSERT(tmp_name != nullptr);
+  GPR_ASSERT(tmp != nullptr);
   GPR_ASSERT(fwrite(blah, 1, strlen(blah), tmp) == strlen(blah));
   fclose(tmp);
 
@@ -107,7 +107,7 @@ static void test_load_small_file(void) {
   error = grpc_load_file(tmp_name, 1, &slice_with_null_term);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   GPR_ASSERT(GRPC_SLICE_LENGTH(slice_with_null_term) == (strlen(blah) + 1));
-  GPR_ASSERT(strcmp((const char *)GRPC_SLICE_START_PTR(slice_with_null_term),
+  GPR_ASSERT(strcmp((const char*)GRPC_SLICE_START_PTR(slice_with_null_term),
                     blah) == 0);
 
   remove(tmp_name);
@@ -117,13 +117,13 @@ static void test_load_small_file(void) {
 }
 
 static void test_load_big_file(void) {
-  FILE *tmp = NULL;
+  FILE* tmp = nullptr;
   grpc_slice slice;
-  grpc_error *error;
-  char *tmp_name;
+  grpc_error* error;
+  char* tmp_name;
   static const size_t buffer_size = 124631;
-  unsigned char *buffer = gpr_malloc(buffer_size);
-  unsigned char *current;
+  unsigned char* buffer = static_cast<unsigned char*>(gpr_malloc(buffer_size));
+  unsigned char* current;
   size_t i;
 
   LOG_TEST_NAME("test_load_big_file");
@@ -131,8 +131,8 @@ static void test_load_big_file(void) {
   memset(buffer, 42, buffer_size);
 
   tmp = gpr_tmpfile(prefix, &tmp_name);
-  GPR_ASSERT(tmp != NULL);
-  GPR_ASSERT(tmp_name != NULL);
+  GPR_ASSERT(tmp != nullptr);
+  GPR_ASSERT(tmp_name != nullptr);
   GPR_ASSERT(fwrite(buffer, 1, buffer_size, tmp) == buffer_size);
   fclose(tmp);
 
@@ -150,7 +150,7 @@ static void test_load_big_file(void) {
   gpr_free(buffer);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_load_empty_file();
   test_load_failure();
diff --git a/test/core/iomgr/pollset_set_test.c b/test/core/iomgr/pollset_set_test.cc
index cddc146ce0..719eab91fe 100644
--- a/test/core/iomgr/pollset_set_test.c
+++ b/test/core/iomgr/pollset_set_test.cc
@@ -37,20 +37,22 @@
  * test_pollset_set
  */
 
-typedef struct test_pollset_set { grpc_pollset_set *pss; } test_pollset_set;
+typedef struct test_pollset_set {
+  grpc_pollset_set* pss;
+} test_pollset_set;
 
-void init_test_pollset_sets(test_pollset_set *pollset_sets, const int num_pss) {
+void init_test_pollset_sets(test_pollset_set* pollset_sets, const int num_pss) {
   for (int i = 0; i < num_pss; i++) {
     pollset_sets[i].pss = grpc_pollset_set_create();
   }
 }
 
-void cleanup_test_pollset_sets(grpc_exec_ctx *exec_ctx,
-                               test_pollset_set *pollset_sets,
+void cleanup_test_pollset_sets(grpc_exec_ctx* exec_ctx,
+                               test_pollset_set* pollset_sets,
                                const int num_pss) {
   for (int i = 0; i < num_pss; i++) {
     grpc_pollset_set_destroy(exec_ctx, pollset_sets[i].pss);
-    pollset_sets[i].pss = NULL;
+    pollset_sets[i].pss = nullptr;
   }
 }
 
@@ -59,24 +61,25 @@ void cleanup_test_pollset_sets(grpc_exec_ctx *exec_ctx,
  */
 
 typedef struct test_pollset {
-  grpc_pollset *ps;
-  gpr_mu *mu;
+  grpc_pollset* ps;
+  gpr_mu* mu;
 } test_pollset;
 
-static void init_test_pollsets(test_pollset *pollsets, const int num_pollsets) {
+static void init_test_pollsets(test_pollset* pollsets, const int num_pollsets) {
   for (int i = 0; i < num_pollsets; i++) {
-    pollsets[i].ps = gpr_zalloc(grpc_pollset_size());
+    pollsets[i].ps =
+        static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
     grpc_pollset_init(pollsets[i].ps, &pollsets[i].mu);
   }
 }
 
-static void destroy_pollset(grpc_exec_ctx *exec_ctx, void *p,
-                            grpc_error *error) {
-  grpc_pollset_destroy(exec_ctx, p);
+static void destroy_pollset(grpc_exec_ctx* exec_ctx, void* p,
+                            grpc_error* error) {
+  grpc_pollset_destroy(exec_ctx, static_cast<grpc_pollset*>(p));
 }
 
-static void cleanup_test_pollsets(grpc_exec_ctx *exec_ctx,
-                                  test_pollset *pollsets,
+static void cleanup_test_pollsets(grpc_exec_ctx* exec_ctx,
+                                  test_pollset* pollsets,
                                   const int num_pollsets) {
   grpc_closure destroyed;
   for (int i = 0; i < num_pollsets; i++) {
@@ -86,7 +89,7 @@ static void cleanup_test_pollsets(grpc_exec_ctx *exec_ctx,
 
     grpc_exec_ctx_flush(exec_ctx);
     gpr_free(pollsets[i].ps);
-    pollsets[i].ps = NULL;
+    pollsets[i].ps = nullptr;
   }
 }
 
@@ -95,18 +98,18 @@ static void cleanup_test_pollsets(grpc_exec_ctx *exec_ctx,
  */
 
 typedef struct test_fd {
-  grpc_fd *fd;
+  grpc_fd* fd;
   grpc_wakeup_fd wakeup_fd;
 
   bool is_on_readable_called; /* Is on_readable closure is called ? */
   grpc_closure on_readable;   /* Closure to call when this fd is readable */
 } test_fd;
 
-void on_readable(grpc_exec_ctx *exec_ctx, void *tfd, grpc_error *error) {
-  ((test_fd *)tfd)->is_on_readable_called = true;
+void on_readable(grpc_exec_ctx* exec_ctx, void* tfd, grpc_error* error) {
+  ((test_fd*)tfd)->is_on_readable_called = true;
 }
 
-static void reset_test_fd(grpc_exec_ctx *exec_ctx, test_fd *tfd) {
+static void reset_test_fd(grpc_exec_ctx* exec_ctx, test_fd* tfd) {
   tfd->is_on_readable_called = false;
 
   GRPC_CLOSURE_INIT(&tfd->on_readable, on_readable, tfd,
@@ -114,7 +117,7 @@ static void reset_test_fd(grpc_exec_ctx *exec_ctx, test_fd *tfd) {
   grpc_fd_notify_on_read(exec_ctx, tfd->fd, &tfd->on_readable);
 }
 
-static void init_test_fds(grpc_exec_ctx *exec_ctx, test_fd *tfds,
+static void init_test_fds(grpc_exec_ctx* exec_ctx, test_fd* tfds,
                           const int num_fds) {
   for (int i = 0; i < num_fds; i++) {
     GPR_ASSERT(GRPC_ERROR_NONE == grpc_wakeup_fd_init(&tfds[i].wakeup_fd));
@@ -124,7 +127,7 @@ static void init_test_fds(grpc_exec_ctx *exec_ctx, test_fd *tfds,
   }
 }
 
-static void cleanup_test_fds(grpc_exec_ctx *exec_ctx, test_fd *tfds,
+static void cleanup_test_fds(grpc_exec_ctx* exec_ctx, test_fd* tfds,
                              const int num_fds) {
   int release_fd;
 
@@ -138,7 +141,7 @@ static void cleanup_test_fds(grpc_exec_ctx *exec_ctx, test_fd *tfds,
      * grpc_wakeup_fd and we would like to destroy it ourselves (by calling
      * grpc_wakeup_fd_destroy). To prevent grpc_fd from calling close() on the
      * underlying fd, call it with a non-NULL 'release_fd' parameter */
-    grpc_fd_orphan(exec_ctx, tfds[i].fd, NULL, &release_fd,
+    grpc_fd_orphan(exec_ctx, tfds[i].fd, nullptr, &release_fd,
                    false /* already_closed */, "test_fd_cleanup");
     grpc_exec_ctx_flush(exec_ctx);
 
@@ -146,13 +149,13 @@ static void cleanup_test_fds(grpc_exec_ctx *exec_ctx, test_fd *tfds,
   }
 }
 
-static void make_test_fds_readable(test_fd *tfds, const int num_fds) {
+static void make_test_fds_readable(test_fd* tfds, const int num_fds) {
   for (int i = 0; i < num_fds; i++) {
     GPR_ASSERT(GRPC_ERROR_NONE == grpc_wakeup_fd_wakeup(&tfds[i].wakeup_fd));
   }
 }
 
-static void verify_readable_and_reset(grpc_exec_ctx *exec_ctx, test_fd *tfds,
+static void verify_readable_and_reset(grpc_exec_ctx* exec_ctx, test_fd* tfds,
                                       const int num_fds) {
   for (int i = 0; i < num_fds; i++) {
     /* Verify that the on_readable callback was called */
@@ -203,7 +206,7 @@ static void pollset_set_test_basic() {
    *                    +---> FD9 (Added after PS2 is added to PSS0)
    */
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_pollset_worker *worker;
+  grpc_pollset_worker* worker;
   grpc_millis deadline;
 
   test_fd tfds[10];
@@ -308,7 +311,7 @@ void pollset_set_test_dup_fds() {
    *                    +---> FD1
    */
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_pollset_worker *worker;
+  grpc_pollset_worker* worker;
   grpc_millis deadline;
 
   test_fd tfds[3];
@@ -381,7 +384,7 @@ void pollset_set_test_empty_pollset() {
    *                   +---> FD2
    */
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_pollset_worker *worker;
+  grpc_pollset_worker* worker;
   grpc_millis deadline;
 
   test_fd tfds[3];
@@ -430,13 +433,13 @@ void pollset_set_test_empty_pollset() {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_test_init(argc, argv);
   grpc_init();
-  const char *poll_strategy = grpc_get_poll_strategy_name();
+  const char* poll_strategy = grpc_get_poll_strategy_name();
 
-  if (poll_strategy != NULL &&
+  if (poll_strategy != nullptr &&
       (strcmp(poll_strategy, "epollsig") == 0 ||
        strcmp(poll_strategy, "epoll-threadpool") == 0)) {
     pollset_set_test_basic();
@@ -453,6 +456,6 @@ int main(int argc, char **argv) {
   grpc_shutdown();
   return 0;
 }
-#else /* defined(GRPC_LINUX_EPOLL) */
-int main(int argc, char **argv) { return 0; }
+#else  /* defined(GRPC_LINUX_EPOLL) */
+int main(int argc, char** argv) { return 0; }
 #endif /* !defined(GRPC_LINUX_EPOLL) */
diff --git a/test/core/iomgr/resolve_address_posix_test.c b/test/core/iomgr/resolve_address_posix_test.cc
index cb9d6080fb..1a5eb9ace1 100644
--- a/test/core/iomgr/resolve_address_posix_test.c
+++ b/test/core/iomgr/resolve_address_posix_test.cc
@@ -39,31 +39,31 @@ static gpr_timespec test_deadline(void) {
 
 typedef struct args_struct {
   gpr_event ev;
-  grpc_resolved_addresses *addrs;
+  grpc_resolved_addresses* addrs;
   gpr_atm done_atm;
-  gpr_mu *mu;
-  grpc_pollset *pollset;
-  grpc_pollset_set *pollset_set;
+  gpr_mu* mu;
+  grpc_pollset* pollset;
+  grpc_pollset_set* pollset_set;
 } args_struct;
 
-static void do_nothing(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {}
+static void do_nothing(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {}
 
-void args_init(grpc_exec_ctx *exec_ctx, args_struct *args) {
+void args_init(grpc_exec_ctx* exec_ctx, args_struct* args) {
   gpr_event_init(&args->ev);
-  args->pollset = gpr_zalloc(grpc_pollset_size());
+  args->pollset = static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
   grpc_pollset_init(args->pollset, &args->mu);
   args->pollset_set = grpc_pollset_set_create();
   grpc_pollset_set_add_pollset(exec_ctx, args->pollset_set, args->pollset);
-  args->addrs = NULL;
+  args->addrs = nullptr;
 }
 
-void args_finish(grpc_exec_ctx *exec_ctx, args_struct *args) {
+void args_finish(grpc_exec_ctx* exec_ctx, args_struct* args) {
   GPR_ASSERT(gpr_event_wait(&args->ev, test_deadline()));
   grpc_resolved_addresses_destroy(args->addrs);
   grpc_pollset_set_del_pollset(exec_ctx, args->pollset_set, args->pollset);
   grpc_pollset_set_destroy(exec_ctx, args->pollset_set);
   grpc_closure do_nothing_cb;
-  GRPC_CLOSURE_INIT(&do_nothing_cb, do_nothing, NULL,
+  GRPC_CLOSURE_INIT(&do_nothing_cb, do_nothing, nullptr,
                     grpc_schedule_on_exec_ctx);
   grpc_pollset_shutdown(exec_ctx, args->pollset, &do_nothing_cb);
   // exec_ctx needs to be flushed before calling grpc_pollset_destroy()
@@ -77,8 +77,8 @@ static grpc_millis n_sec_deadline(int seconds) {
       grpc_timeout_seconds_to_deadline(seconds));
 }
 
-static void actually_poll(void *argsp) {
-  args_struct *args = argsp;
+static void actually_poll(void* argsp) {
+  args_struct* args = static_cast<args_struct*>(argsp);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_millis deadline = n_sec_deadline(10);
   while (true) {
@@ -89,7 +89,7 @@ static void actually_poll(void *argsp) {
     grpc_millis time_left = deadline - grpc_exec_ctx_now(&exec_ctx);
     gpr_log(GPR_DEBUG, "done=%d, time_left=%" PRIdPTR, done, time_left);
     GPR_ASSERT(time_left >= 0);
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     gpr_mu_lock(args->mu);
     GRPC_LOG_IF_ERROR("pollset_work",
                       grpc_pollset_work(&exec_ctx, args->pollset, &worker,
@@ -97,27 +97,27 @@ static void actually_poll(void *argsp) {
     gpr_mu_unlock(args->mu);
     grpc_exec_ctx_flush(&exec_ctx);
   }
-  gpr_event_set(&args->ev, (void *)1);
+  gpr_event_set(&args->ev, (void*)1);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void poll_pollset_until_request_done(args_struct *args) {
+static void poll_pollset_until_request_done(args_struct* args) {
   gpr_atm_rel_store(&args->done_atm, 0);
   gpr_thd_id id;
-  gpr_thd_new(&id, actually_poll, args, NULL);
+  gpr_thd_new(&id, actually_poll, args, nullptr);
 }
 
-static void must_succeed(grpc_exec_ctx *exec_ctx, void *argsp,
-                         grpc_error *err) {
-  args_struct *args = argsp;
+static void must_succeed(grpc_exec_ctx* exec_ctx, void* argsp,
+                         grpc_error* err) {
+  args_struct* args = static_cast<args_struct*>(argsp);
   GPR_ASSERT(err == GRPC_ERROR_NONE);
-  GPR_ASSERT(args->addrs != NULL);
+  GPR_ASSERT(args->addrs != nullptr);
   GPR_ASSERT(args->addrs->naddrs > 0);
   gpr_atm_rel_store(&args->done_atm, 1);
 }
 
-static void must_fail(grpc_exec_ctx *exec_ctx, void *argsp, grpc_error *err) {
-  args_struct *args = argsp;
+static void must_fail(grpc_exec_ctx* exec_ctx, void* argsp, grpc_error* err) {
+  args_struct* args = static_cast<args_struct*>(argsp);
   GPR_ASSERT(err != GRPC_ERROR_NONE);
   gpr_atm_rel_store(&args->done_atm, 1);
 }
@@ -128,7 +128,7 @@ static void test_unix_socket(void) {
   args_init(&exec_ctx, &args);
   poll_pollset_until_request_done(&args);
   grpc_resolve_address(
-      &exec_ctx, "unix:/path/name", NULL, args.pollset_set,
+      &exec_ctx, "unix:/path/name", nullptr, args.pollset_set,
       GRPC_CLOSURE_CREATE(must_succeed, &args, grpc_schedule_on_exec_ctx),
       &args.addrs);
   args_finish(&exec_ctx, &args);
@@ -141,15 +141,16 @@ static void test_unix_socket_path_name_too_long(void) {
   args_init(&exec_ctx, &args);
   const char prefix[] = "unix:/path/name";
   size_t path_name_length =
-      GPR_ARRAY_SIZE(((struct sockaddr_un *)0)->sun_path) + 6;
-  char *path_name = gpr_malloc(sizeof(char) * path_name_length);
+      GPR_ARRAY_SIZE(((struct sockaddr_un*)nullptr)->sun_path) + 6;
+  char* path_name =
+      static_cast<char*>(gpr_malloc(sizeof(char) * path_name_length));
   memset(path_name, 'a', path_name_length);
   memcpy(path_name, prefix, strlen(prefix) - 1);
   path_name[path_name_length - 1] = '\0';
 
   poll_pollset_until_request_done(&args);
   grpc_resolve_address(
-      &exec_ctx, path_name, NULL, args.pollset_set,
+      &exec_ctx, path_name, nullptr, args.pollset_set,
       GRPC_CLOSURE_CREATE(must_fail, &args, grpc_schedule_on_exec_ctx),
       &args.addrs);
   gpr_free(path_name);
@@ -157,7 +158,7 @@ static void test_unix_socket_path_name_too_long(void) {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
diff --git a/test/core/iomgr/resolve_address_test.c b/test/core/iomgr/resolve_address_test.cc
index 178bbbb95f..1c5aa38a95 100644
--- a/test/core/iomgr/resolve_address_test.c
+++ b/test/core/iomgr/resolve_address_test.cc
@@ -32,32 +32,32 @@ static gpr_timespec test_deadline(void) {
 
 typedef struct args_struct {
   gpr_event ev;
-  grpc_resolved_addresses *addrs;
+  grpc_resolved_addresses* addrs;
   gpr_atm done_atm;
-  gpr_mu *mu;
-  grpc_pollset *pollset;
-  grpc_pollset_set *pollset_set;
+  gpr_mu* mu;
+  grpc_pollset* pollset;
+  grpc_pollset_set* pollset_set;
 } args_struct;
 
-static void do_nothing(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {}
+static void do_nothing(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {}
 
-void args_init(grpc_exec_ctx *exec_ctx, args_struct *args) {
+void args_init(grpc_exec_ctx* exec_ctx, args_struct* args) {
   gpr_event_init(&args->ev);
-  args->pollset = gpr_zalloc(grpc_pollset_size());
+  args->pollset = static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
   grpc_pollset_init(args->pollset, &args->mu);
   args->pollset_set = grpc_pollset_set_create();
   grpc_pollset_set_add_pollset(exec_ctx, args->pollset_set, args->pollset);
-  args->addrs = NULL;
+  args->addrs = nullptr;
   gpr_atm_rel_store(&args->done_atm, 0);
 }
 
-void args_finish(grpc_exec_ctx *exec_ctx, args_struct *args) {
+void args_finish(grpc_exec_ctx* exec_ctx, args_struct* args) {
   GPR_ASSERT(gpr_event_wait(&args->ev, test_deadline()));
   grpc_resolved_addresses_destroy(args->addrs);
   grpc_pollset_set_del_pollset(exec_ctx, args->pollset_set, args->pollset);
   grpc_pollset_set_destroy(exec_ctx, args->pollset_set);
   grpc_closure do_nothing_cb;
-  GRPC_CLOSURE_INIT(&do_nothing_cb, do_nothing, NULL,
+  GRPC_CLOSURE_INIT(&do_nothing_cb, do_nothing, nullptr,
                     grpc_schedule_on_exec_ctx);
   gpr_mu_lock(args->mu);
   grpc_pollset_shutdown(exec_ctx, args->pollset, &do_nothing_cb);
@@ -73,7 +73,7 @@ static grpc_millis n_sec_deadline(int seconds) {
       grpc_timeout_seconds_to_deadline(seconds));
 }
 
-static void poll_pollset_until_request_done(args_struct *args) {
+static void poll_pollset_until_request_done(args_struct* args) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_millis deadline = n_sec_deadline(10);
   while (true) {
@@ -84,7 +84,7 @@ static void poll_pollset_until_request_done(args_struct *args) {
     grpc_millis time_left = deadline - grpc_exec_ctx_now(&exec_ctx);
     gpr_log(GPR_DEBUG, "done=%d, time_left=%" PRIdPTR, done, time_left);
     GPR_ASSERT(time_left >= 0);
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     gpr_mu_lock(args->mu);
     GRPC_LOG_IF_ERROR("pollset_work",
                       grpc_pollset_work(&exec_ctx, args->pollset, &worker,
@@ -92,30 +92,30 @@ static void poll_pollset_until_request_done(args_struct *args) {
     gpr_mu_unlock(args->mu);
     grpc_exec_ctx_flush(&exec_ctx);
   }
-  gpr_event_set(&args->ev, (void *)1);
+  gpr_event_set(&args->ev, (void*)1);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void must_succeed(grpc_exec_ctx *exec_ctx, void *argsp,
-                         grpc_error *err) {
-  args_struct *args = argsp;
+static void must_succeed(grpc_exec_ctx* exec_ctx, void* argsp,
+                         grpc_error* err) {
+  args_struct* args = static_cast<args_struct*>(argsp);
   GPR_ASSERT(err == GRPC_ERROR_NONE);
-  GPR_ASSERT(args->addrs != NULL);
+  GPR_ASSERT(args->addrs != nullptr);
   GPR_ASSERT(args->addrs->naddrs > 0);
   gpr_atm_rel_store(&args->done_atm, 1);
   gpr_mu_lock(args->mu);
   GRPC_LOG_IF_ERROR("pollset_kick",
-                    grpc_pollset_kick(exec_ctx, args->pollset, NULL));
+                    grpc_pollset_kick(exec_ctx, args->pollset, nullptr));
   gpr_mu_unlock(args->mu);
 }
 
-static void must_fail(grpc_exec_ctx *exec_ctx, void *argsp, grpc_error *err) {
-  args_struct *args = argsp;
+static void must_fail(grpc_exec_ctx* exec_ctx, void* argsp, grpc_error* err) {
+  args_struct* args = static_cast<args_struct*>(argsp);
   GPR_ASSERT(err != GRPC_ERROR_NONE);
   gpr_atm_rel_store(&args->done_atm, 1);
   gpr_mu_lock(args->mu);
   GRPC_LOG_IF_ERROR("pollset_kick",
-                    grpc_pollset_kick(exec_ctx, args->pollset, NULL));
+                    grpc_pollset_kick(exec_ctx, args->pollset, nullptr));
   gpr_mu_unlock(args->mu);
 }
 
@@ -124,7 +124,7 @@ static void test_localhost(void) {
   args_struct args;
   args_init(&exec_ctx, &args);
   grpc_resolve_address(
-      &exec_ctx, "localhost:1", NULL, args.pollset_set,
+      &exec_ctx, "localhost:1", nullptr, args.pollset_set,
       GRPC_CLOSURE_CREATE(must_succeed, &args, grpc_schedule_on_exec_ctx),
       &args.addrs);
   grpc_exec_ctx_flush(&exec_ctx);
@@ -166,7 +166,7 @@ static void test_missing_default_port(void) {
   args_struct args;
   args_init(&exec_ctx, &args);
   grpc_resolve_address(
-      &exec_ctx, "localhost", NULL, args.pollset_set,
+      &exec_ctx, "localhost", nullptr, args.pollset_set,
       GRPC_CLOSURE_CREATE(must_fail, &args, grpc_schedule_on_exec_ctx),
       &args.addrs);
   grpc_exec_ctx_flush(&exec_ctx);
@@ -180,7 +180,7 @@ static void test_ipv6_with_port(void) {
   args_struct args;
   args_init(&exec_ctx, &args);
   grpc_resolve_address(
-      &exec_ctx, "[2001:db8::1]:1", NULL, args.pollset_set,
+      &exec_ctx, "[2001:db8::1]:1", nullptr, args.pollset_set,
       GRPC_CLOSURE_CREATE(must_succeed, &args, grpc_schedule_on_exec_ctx),
       &args.addrs);
   grpc_exec_ctx_flush(&exec_ctx);
@@ -190,8 +190,10 @@ 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]",
+  const char* const kCases[] = {
+      "2001:db8::1",
+      "2001:db8::1.2.3.4",
+      "[2001:db8::1]",
   };
   unsigned i;
   for (i = 0; i < sizeof(kCases) / sizeof(*kCases); i++) {
@@ -210,8 +212,9 @@ 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",
+  const char* const kCases[] = {
+      "293.283.1238.3:1",
+      "[2001:db8::11111]:1",
   };
   unsigned i;
   for (i = 0; i < sizeof(kCases) / sizeof(*kCases); i++) {
@@ -219,7 +222,7 @@ static void test_invalid_ip_addresses(void) {
     args_struct args;
     args_init(&exec_ctx, &args);
     grpc_resolve_address(
-        &exec_ctx, kCases[i], NULL, args.pollset_set,
+        &exec_ctx, kCases[i], nullptr, args.pollset_set,
         GRPC_CLOSURE_CREATE(must_fail, &args, grpc_schedule_on_exec_ctx),
         &args.addrs);
     grpc_exec_ctx_flush(&exec_ctx);
@@ -230,7 +233,7 @@ static void test_invalid_ip_addresses(void) {
 }
 
 static void test_unparseable_hostports(void) {
-  const char *const kCases[] = {
+  const char* const kCases[] = {
       "[", "[::1", "[::1]bad", "[1.2.3.4]", "[localhost]", "[localhost]:1",
   };
   unsigned i;
@@ -249,7 +252,7 @@ static void test_unparseable_hostports(void) {
   }
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
diff --git a/test/core/iomgr/resource_quota_test.c b/test/core/iomgr/resource_quota_test.cc
index b588f3d120..6851702e67 100644
--- a/test/core/iomgr/resource_quota_test.c
+++ b/test/core/iomgr/resource_quota_test.cc
@@ -27,14 +27,14 @@
 gpr_mu g_mu;
 gpr_cv g_cv;
 
-static void inc_int_cb(grpc_exec_ctx *exec_ctx, void *a, grpc_error *error) {
+static void inc_int_cb(grpc_exec_ctx* exec_ctx, void* a, grpc_error* error) {
   gpr_mu_lock(&g_mu);
-  ++*(int *)a;
+  ++*(int*)a;
   gpr_cv_signal(&g_cv);
   gpr_mu_unlock(&g_mu);
 }
 
-static void assert_counter_becomes(int *ctr, int value) {
+static void assert_counter_becomes(int* ctr, int value) {
   gpr_mu_lock(&g_mu);
   gpr_timespec deadline = grpc_timeout_seconds_to_deadline(5);
   while (*ctr != value) {
@@ -43,47 +43,49 @@ static void assert_counter_becomes(int *ctr, int value) {
   gpr_mu_unlock(&g_mu);
 }
 
-static void set_event_cb(grpc_exec_ctx *exec_ctx, void *a, grpc_error *error) {
-  gpr_event_set((gpr_event *)a, (void *)1);
+static void set_event_cb(grpc_exec_ctx* exec_ctx, void* a, grpc_error* error) {
+  gpr_event_set((gpr_event*)a, (void*)1);
 }
-grpc_closure *set_event(gpr_event *ev) {
+grpc_closure* set_event(gpr_event* ev) {
   return GRPC_CLOSURE_CREATE(set_event_cb, ev, grpc_schedule_on_exec_ctx);
 }
 
 typedef struct {
   size_t size;
-  grpc_resource_user *resource_user;
-  grpc_closure *then;
+  grpc_resource_user* resource_user;
+  grpc_closure* then;
 } reclaimer_args;
-static void reclaimer_cb(grpc_exec_ctx *exec_ctx, void *args,
-                         grpc_error *error) {
+
+static void reclaimer_cb(grpc_exec_ctx* exec_ctx, void* args,
+                         grpc_error* error) {
   GPR_ASSERT(error == GRPC_ERROR_NONE);
-  reclaimer_args *a = args;
+  reclaimer_args* a = static_cast<reclaimer_args*>(args);
   grpc_resource_user_free(exec_ctx, a->resource_user, a->size);
   grpc_resource_user_finish_reclamation(exec_ctx, a->resource_user);
   GRPC_CLOSURE_RUN(exec_ctx, a->then, GRPC_ERROR_NONE);
   gpr_free(a);
 }
-grpc_closure *make_reclaimer(grpc_resource_user *resource_user, size_t size,
-                             grpc_closure *then) {
-  reclaimer_args *a = gpr_malloc(sizeof(*a));
+
+grpc_closure* make_reclaimer(grpc_resource_user* resource_user, size_t size,
+                             grpc_closure* then) {
+  reclaimer_args* a = static_cast<reclaimer_args*>(gpr_malloc(sizeof(*a)));
   a->size = size;
   a->resource_user = resource_user;
   a->then = then;
   return GRPC_CLOSURE_CREATE(reclaimer_cb, a, grpc_schedule_on_exec_ctx);
 }
 
-static void unused_reclaimer_cb(grpc_exec_ctx *exec_ctx, void *arg,
-                                grpc_error *error) {
+static void unused_reclaimer_cb(grpc_exec_ctx* exec_ctx, void* arg,
+                                grpc_error* error) {
   GPR_ASSERT(error == GRPC_ERROR_CANCELLED);
-  GRPC_CLOSURE_RUN(exec_ctx, arg, GRPC_ERROR_NONE);
+  GRPC_CLOSURE_RUN(exec_ctx, static_cast<grpc_closure*>(arg), GRPC_ERROR_NONE);
 }
-grpc_closure *make_unused_reclaimer(grpc_closure *then) {
+grpc_closure* make_unused_reclaimer(grpc_closure* then) {
   return GRPC_CLOSURE_CREATE(unused_reclaimer_cb, then,
                              grpc_schedule_on_exec_ctx);
 }
 
-static void destroy_user(grpc_resource_user *usr) {
+static void destroy_user(grpc_resource_user* usr) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_resource_user_unref(&exec_ctx, usr);
   grpc_exec_ctx_finish(&exec_ctx);
@@ -96,7 +98,7 @@ static void test_no_op(void) {
 
 static void test_resize_then_destroy(void) {
   gpr_log(GPR_INFO, "** test_resize_then_destroy **");
-  grpc_resource_quota *q =
+  grpc_resource_quota* q =
       grpc_resource_quota_create("test_resize_then_destroy");
   grpc_resource_quota_resize(q, 1024 * 1024);
   grpc_resource_quota_unref(q);
@@ -104,22 +106,22 @@ static void test_resize_then_destroy(void) {
 
 static void test_resource_user_no_op(void) {
   gpr_log(GPR_INFO, "** test_resource_user_no_op **");
-  grpc_resource_quota *q =
+  grpc_resource_quota* q =
       grpc_resource_quota_create("test_resource_user_no_op");
-  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+  grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
   grpc_resource_quota_unref(q);
   destroy_user(usr);
 }
 
 static void test_instant_alloc_then_free(void) {
   gpr_log(GPR_INFO, "** test_instant_alloc_then_free **");
-  grpc_resource_quota *q =
+  grpc_resource_quota* q =
       grpc_resource_quota_create("test_instant_alloc_then_free");
   grpc_resource_quota_resize(q, 1024 * 1024);
-  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+  grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr, 1024, NULL);
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, nullptr);
     grpc_exec_ctx_finish(&exec_ctx);
   }
   {
@@ -133,13 +135,13 @@ static void test_instant_alloc_then_free(void) {
 
 static void test_instant_alloc_free_pair(void) {
   gpr_log(GPR_INFO, "** test_instant_alloc_free_pair **");
-  grpc_resource_quota *q =
+  grpc_resource_quota* q =
       grpc_resource_quota_create("test_instant_alloc_free_pair");
   grpc_resource_quota_resize(q, 1024 * 1024);
-  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+  grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr, 1024, NULL);
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, nullptr);
     grpc_resource_user_free(&exec_ctx, usr, 1024);
     grpc_exec_ctx_finish(&exec_ctx);
   }
@@ -149,10 +151,10 @@ static void test_instant_alloc_free_pair(void) {
 
 static void test_simple_async_alloc(void) {
   gpr_log(GPR_INFO, "** test_simple_async_alloc **");
-  grpc_resource_quota *q =
+  grpc_resource_quota* q =
       grpc_resource_quota_create("test_simple_async_alloc");
   grpc_resource_quota_resize(q, 1024 * 1024);
-  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+  grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
   {
     gpr_event ev;
     gpr_event_init(&ev);
@@ -160,7 +162,7 @@ static void test_simple_async_alloc(void) {
     grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
-               NULL);
+               nullptr);
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -173,10 +175,10 @@ static void test_simple_async_alloc(void) {
 
 static void test_async_alloc_blocked_by_size(void) {
   gpr_log(GPR_INFO, "** test_async_alloc_blocked_by_size **");
-  grpc_resource_quota *q =
+  grpc_resource_quota* q =
       grpc_resource_quota_create("test_async_alloc_blocked_by_size");
   grpc_resource_quota_resize(q, 1);
-  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+  grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
   gpr_event ev;
   gpr_event_init(&ev);
   {
@@ -184,10 +186,11 @@ static void test_async_alloc_blocked_by_size(void) {
     grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(gpr_event_wait(
-                   &ev, grpc_timeout_milliseconds_to_deadline(100)) == NULL);
+                   &ev, grpc_timeout_milliseconds_to_deadline(100)) == nullptr);
   }
   grpc_resource_quota_resize(q, 1024);
-  GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) != NULL);
+  GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+             nullptr);
   ;
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -200,10 +203,10 @@ static void test_async_alloc_blocked_by_size(void) {
 
 static void test_scavenge(void) {
   gpr_log(GPR_INFO, "** test_scavenge **");
-  grpc_resource_quota *q = grpc_resource_quota_create("test_scavenge");
+  grpc_resource_quota* q = grpc_resource_quota_create("test_scavenge");
   grpc_resource_quota_resize(q, 1024);
-  grpc_resource_user *usr1 = grpc_resource_user_create(q, "usr1");
-  grpc_resource_user *usr2 = grpc_resource_user_create(q, "usr2");
+  grpc_resource_user* usr1 = grpc_resource_user_create(q, "usr1");
+  grpc_resource_user* usr2 = grpc_resource_user_create(q, "usr2");
   {
     gpr_event ev;
     gpr_event_init(&ev);
@@ -211,7 +214,7 @@ static void test_scavenge(void) {
     grpc_resource_user_alloc(&exec_ctx, usr1, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
-               NULL);
+               nullptr);
     ;
   }
   {
@@ -226,7 +229,7 @@ static void test_scavenge(void) {
     grpc_resource_user_alloc(&exec_ctx, usr2, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
-               NULL);
+               nullptr);
     ;
   }
   {
@@ -241,10 +244,10 @@ static void test_scavenge(void) {
 
 static void test_scavenge_blocked(void) {
   gpr_log(GPR_INFO, "** test_scavenge_blocked **");
-  grpc_resource_quota *q = grpc_resource_quota_create("test_scavenge_blocked");
+  grpc_resource_quota* q = grpc_resource_quota_create("test_scavenge_blocked");
   grpc_resource_quota_resize(q, 1024);
-  grpc_resource_user *usr1 = grpc_resource_user_create(q, "usr1");
-  grpc_resource_user *usr2 = grpc_resource_user_create(q, "usr2");
+  grpc_resource_user* usr1 = grpc_resource_user_create(q, "usr1");
+  grpc_resource_user* usr2 = grpc_resource_user_create(q, "usr2");
   gpr_event ev;
   {
     gpr_event_init(&ev);
@@ -252,7 +255,7 @@ static void test_scavenge_blocked(void) {
     grpc_resource_user_alloc(&exec_ctx, usr1, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
-               NULL);
+               nullptr);
     ;
   }
   {
@@ -261,14 +264,14 @@ static void test_scavenge_blocked(void) {
     grpc_resource_user_alloc(&exec_ctx, usr2, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(gpr_event_wait(
-                   &ev, grpc_timeout_milliseconds_to_deadline(100)) == NULL);
+                   &ev, grpc_timeout_milliseconds_to_deadline(100)) == nullptr);
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_free(&exec_ctx, usr1, 1024);
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
-               NULL);
+               nullptr);
     ;
   }
   {
@@ -283,10 +286,10 @@ static void test_scavenge_blocked(void) {
 
 static void test_blocked_until_scheduled_reclaim(void) {
   gpr_log(GPR_INFO, "** test_blocked_until_scheduled_reclaim **");
-  grpc_resource_quota *q =
+  grpc_resource_quota* q =
       grpc_resource_quota_create("test_blocked_until_scheduled_reclaim");
   grpc_resource_quota_resize(q, 1024);
-  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+  grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
   {
     gpr_event ev;
     gpr_event_init(&ev);
@@ -294,7 +297,7 @@ static void test_blocked_until_scheduled_reclaim(void) {
     grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
-               NULL);
+               nullptr);
     ;
   }
   gpr_event reclaim_done;
@@ -313,9 +316,9 @@ static void test_blocked_until_scheduled_reclaim(void) {
     grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(gpr_event_wait(&reclaim_done,
-                              grpc_timeout_seconds_to_deadline(5)) != NULL);
+                              grpc_timeout_seconds_to_deadline(5)) != nullptr);
     GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
-               NULL);
+               nullptr);
     ;
   }
   {
@@ -329,11 +332,11 @@ static void test_blocked_until_scheduled_reclaim(void) {
 
 static void test_blocked_until_scheduled_reclaim_and_scavenge(void) {
   gpr_log(GPR_INFO, "** test_blocked_until_scheduled_reclaim_and_scavenge **");
-  grpc_resource_quota *q = grpc_resource_quota_create(
+  grpc_resource_quota* q = grpc_resource_quota_create(
       "test_blocked_until_scheduled_reclaim_and_scavenge");
   grpc_resource_quota_resize(q, 1024);
-  grpc_resource_user *usr1 = grpc_resource_user_create(q, "usr1");
-  grpc_resource_user *usr2 = grpc_resource_user_create(q, "usr2");
+  grpc_resource_user* usr1 = grpc_resource_user_create(q, "usr1");
+  grpc_resource_user* usr2 = grpc_resource_user_create(q, "usr2");
   {
     gpr_event ev;
     gpr_event_init(&ev);
@@ -341,7 +344,7 @@ static void test_blocked_until_scheduled_reclaim_and_scavenge(void) {
     grpc_resource_user_alloc(&exec_ctx, usr1, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
-               NULL);
+               nullptr);
     ;
   }
   gpr_event reclaim_done;
@@ -360,9 +363,9 @@ static void test_blocked_until_scheduled_reclaim_and_scavenge(void) {
     grpc_resource_user_alloc(&exec_ctx, usr2, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(gpr_event_wait(&reclaim_done,
-                              grpc_timeout_seconds_to_deadline(5)) != NULL);
+                              grpc_timeout_seconds_to_deadline(5)) != nullptr);
     GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
-               NULL);
+               nullptr);
     ;
   }
   {
@@ -377,10 +380,10 @@ static void test_blocked_until_scheduled_reclaim_and_scavenge(void) {
 
 static void test_blocked_until_scheduled_destructive_reclaim(void) {
   gpr_log(GPR_INFO, "** test_blocked_until_scheduled_destructive_reclaim **");
-  grpc_resource_quota *q = grpc_resource_quota_create(
+  grpc_resource_quota* q = grpc_resource_quota_create(
       "test_blocked_until_scheduled_destructive_reclaim");
   grpc_resource_quota_resize(q, 1024);
-  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+  grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
   {
     gpr_event ev;
     gpr_event_init(&ev);
@@ -388,7 +391,7 @@ static void test_blocked_until_scheduled_destructive_reclaim(void) {
     grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
-               NULL);
+               nullptr);
     ;
   }
   gpr_event reclaim_done;
@@ -407,9 +410,9 @@ static void test_blocked_until_scheduled_destructive_reclaim(void) {
     grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(gpr_event_wait(&reclaim_done,
-                              grpc_timeout_seconds_to_deadline(5)) != NULL);
+                              grpc_timeout_seconds_to_deadline(5)) != nullptr);
     GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
-               NULL);
+               nullptr);
     ;
   }
   {
@@ -423,10 +426,10 @@ static void test_blocked_until_scheduled_destructive_reclaim(void) {
 
 static void test_unused_reclaim_is_cancelled(void) {
   gpr_log(GPR_INFO, "** test_unused_reclaim_is_cancelled **");
-  grpc_resource_quota *q =
+  grpc_resource_quota* q =
       grpc_resource_quota_create("test_unused_reclaim_is_cancelled");
   grpc_resource_quota_resize(q, 1024);
-  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+  grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
   gpr_event benign_done;
   gpr_event_init(&benign_done);
   gpr_event destructive_done;
@@ -441,25 +444,25 @@ static void test_unused_reclaim_is_cancelled(void) {
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(gpr_event_wait(&benign_done,
                               grpc_timeout_milliseconds_to_deadline(100)) ==
-               NULL);
+               nullptr);
     GPR_ASSERT(gpr_event_wait(&destructive_done,
                               grpc_timeout_milliseconds_to_deadline(100)) ==
-               NULL);
+               nullptr);
   }
   grpc_resource_quota_unref(q);
   destroy_user(usr);
   GPR_ASSERT(gpr_event_wait(&benign_done,
-                            grpc_timeout_seconds_to_deadline(5)) != NULL);
+                            grpc_timeout_seconds_to_deadline(5)) != nullptr);
   GPR_ASSERT(gpr_event_wait(&destructive_done,
-                            grpc_timeout_seconds_to_deadline(5)) != NULL);
+                            grpc_timeout_seconds_to_deadline(5)) != nullptr);
 }
 
 static void test_benign_reclaim_is_preferred(void) {
   gpr_log(GPR_INFO, "** test_benign_reclaim_is_preferred **");
-  grpc_resource_quota *q =
+  grpc_resource_quota* q =
       grpc_resource_quota_create("test_benign_reclaim_is_preferred");
   grpc_resource_quota_resize(q, 1024);
-  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+  grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
   gpr_event benign_done;
   gpr_event_init(&benign_done);
   gpr_event destructive_done;
@@ -471,7 +474,7 @@ static void test_benign_reclaim_is_preferred(void) {
     grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
-               NULL);
+               nullptr);
     ;
   }
   {
@@ -485,10 +488,10 @@ static void test_benign_reclaim_is_preferred(void) {
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(gpr_event_wait(&benign_done,
                               grpc_timeout_milliseconds_to_deadline(100)) ==
-               NULL);
+               nullptr);
     GPR_ASSERT(gpr_event_wait(&destructive_done,
                               grpc_timeout_milliseconds_to_deadline(100)) ==
-               NULL);
+               nullptr);
   }
   {
     gpr_event ev;
@@ -497,12 +500,12 @@ static void test_benign_reclaim_is_preferred(void) {
     grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(gpr_event_wait(&benign_done,
-                              grpc_timeout_seconds_to_deadline(5)) != NULL);
+                              grpc_timeout_seconds_to_deadline(5)) != nullptr);
     GPR_ASSERT(gpr_event_wait(&destructive_done,
                               grpc_timeout_milliseconds_to_deadline(100)) ==
-               NULL);
+               nullptr);
     GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
-               NULL);
+               nullptr);
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -512,17 +515,17 @@ static void test_benign_reclaim_is_preferred(void) {
   grpc_resource_quota_unref(q);
   destroy_user(usr);
   GPR_ASSERT(gpr_event_wait(&benign_done,
-                            grpc_timeout_seconds_to_deadline(5)) != NULL);
+                            grpc_timeout_seconds_to_deadline(5)) != nullptr);
   GPR_ASSERT(gpr_event_wait(&destructive_done,
-                            grpc_timeout_seconds_to_deadline(5)) != NULL);
+                            grpc_timeout_seconds_to_deadline(5)) != nullptr);
 }
 
 static void test_multiple_reclaims_can_be_triggered(void) {
   gpr_log(GPR_INFO, "** test_multiple_reclaims_can_be_triggered **");
-  grpc_resource_quota *q =
+  grpc_resource_quota* q =
       grpc_resource_quota_create("test_multiple_reclaims_can_be_triggered");
   grpc_resource_quota_resize(q, 1024);
-  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+  grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
   gpr_event benign_done;
   gpr_event_init(&benign_done);
   gpr_event destructive_done;
@@ -534,7 +537,7 @@ static void test_multiple_reclaims_can_be_triggered(void) {
     grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
-               NULL);
+               nullptr);
     ;
   }
   {
@@ -548,10 +551,10 @@ static void test_multiple_reclaims_can_be_triggered(void) {
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(gpr_event_wait(&benign_done,
                               grpc_timeout_milliseconds_to_deadline(100)) ==
-               NULL);
+               nullptr);
     GPR_ASSERT(gpr_event_wait(&destructive_done,
                               grpc_timeout_milliseconds_to_deadline(100)) ==
-               NULL);
+               nullptr);
   }
   {
     gpr_event ev;
@@ -560,11 +563,11 @@ static void test_multiple_reclaims_can_be_triggered(void) {
     grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(gpr_event_wait(&benign_done,
-                              grpc_timeout_seconds_to_deadline(5)) != NULL);
+                              grpc_timeout_seconds_to_deadline(5)) != nullptr);
     GPR_ASSERT(gpr_event_wait(&destructive_done,
-                              grpc_timeout_seconds_to_deadline(5)) != NULL);
+                              grpc_timeout_seconds_to_deadline(5)) != nullptr);
     GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
-               NULL);
+               nullptr);
     ;
   }
   {
@@ -575,21 +578,21 @@ static void test_multiple_reclaims_can_be_triggered(void) {
   grpc_resource_quota_unref(q);
   destroy_user(usr);
   GPR_ASSERT(gpr_event_wait(&benign_done,
-                            grpc_timeout_seconds_to_deadline(5)) != NULL);
+                            grpc_timeout_seconds_to_deadline(5)) != nullptr);
   GPR_ASSERT(gpr_event_wait(&destructive_done,
-                            grpc_timeout_seconds_to_deadline(5)) != NULL);
+                            grpc_timeout_seconds_to_deadline(5)) != nullptr);
 }
 
 static void test_resource_user_stays_allocated_until_memory_released(void) {
   gpr_log(GPR_INFO,
           "** test_resource_user_stays_allocated_until_memory_released **");
-  grpc_resource_quota *q = grpc_resource_quota_create(
+  grpc_resource_quota* q = grpc_resource_quota_create(
       "test_resource_user_stays_allocated_until_memory_released");
   grpc_resource_quota_resize(q, 1024 * 1024);
-  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+  grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr, 1024, NULL);
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, nullptr);
     grpc_exec_ctx_finish(&exec_ctx);
   }
   {
@@ -612,12 +615,12 @@ test_resource_user_stays_allocated_and_reclaimers_unrun_until_memory_released(
           "** "
           "test_resource_user_stays_allocated_and_reclaimers_unrun_until_"
           "memory_released **");
-  grpc_resource_quota *q = grpc_resource_quota_create(
+  grpc_resource_quota* q = grpc_resource_quota_create(
       "test_resource_user_stays_allocated_and_reclaimers_unrun_until_memory_"
       "released");
   grpc_resource_quota_resize(q, 1024);
   for (int i = 0; i < 10; i++) {
-    grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+    grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
     gpr_event reclaimer_cancelled;
     gpr_event_init(&reclaimer_cancelled);
     {
@@ -628,7 +631,7 @@ test_resource_user_stays_allocated_and_reclaimers_unrun_until_memory_released(
       grpc_exec_ctx_finish(&exec_ctx);
       GPR_ASSERT(gpr_event_wait(&reclaimer_cancelled,
                                 grpc_timeout_milliseconds_to_deadline(100)) ==
-                 NULL);
+                 nullptr);
     }
     {
       gpr_event allocated;
@@ -636,11 +639,11 @@ test_resource_user_stays_allocated_and_reclaimers_unrun_until_memory_released(
       grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
       grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&allocated));
       grpc_exec_ctx_finish(&exec_ctx);
-      GPR_ASSERT(gpr_event_wait(&allocated,
-                                grpc_timeout_seconds_to_deadline(5)) != NULL);
+      GPR_ASSERT(gpr_event_wait(&allocated, grpc_timeout_seconds_to_deadline(
+                                                5)) != nullptr);
       GPR_ASSERT(gpr_event_wait(&reclaimer_cancelled,
                                 grpc_timeout_milliseconds_to_deadline(100)) ==
-                 NULL);
+                 nullptr);
     }
     {
       grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -648,14 +651,15 @@ test_resource_user_stays_allocated_and_reclaimers_unrun_until_memory_released(
       grpc_exec_ctx_finish(&exec_ctx);
       GPR_ASSERT(gpr_event_wait(&reclaimer_cancelled,
                                 grpc_timeout_milliseconds_to_deadline(100)) ==
-                 NULL);
+                 nullptr);
     }
     {
       grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
       grpc_resource_user_free(&exec_ctx, usr, 1024);
       grpc_exec_ctx_finish(&exec_ctx);
       GPR_ASSERT(gpr_event_wait(&reclaimer_cancelled,
-                                grpc_timeout_seconds_to_deadline(5)) != NULL);
+                                grpc_timeout_seconds_to_deadline(5)) !=
+                 nullptr);
     }
   }
   grpc_resource_quota_unref(q);
@@ -663,10 +667,10 @@ test_resource_user_stays_allocated_and_reclaimers_unrun_until_memory_released(
 
 static void test_reclaimers_can_be_posted_repeatedly(void) {
   gpr_log(GPR_INFO, "** test_reclaimers_can_be_posted_repeatedly **");
-  grpc_resource_quota *q =
+  grpc_resource_quota* q =
       grpc_resource_quota_create("test_reclaimers_can_be_posted_repeatedly");
   grpc_resource_quota_resize(q, 1024);
-  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+  grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
   {
     gpr_event allocated;
     gpr_event_init(&allocated);
@@ -674,7 +678,7 @@ static void test_reclaimers_can_be_posted_repeatedly(void) {
     grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&allocated));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(gpr_event_wait(&allocated,
-                              grpc_timeout_seconds_to_deadline(5)) != NULL);
+                              grpc_timeout_seconds_to_deadline(5)) != nullptr);
   }
   for (int i = 0; i < 10; i++) {
     gpr_event reclaimer_done;
@@ -687,7 +691,7 @@ static void test_reclaimers_can_be_posted_repeatedly(void) {
       grpc_exec_ctx_finish(&exec_ctx);
       GPR_ASSERT(gpr_event_wait(&reclaimer_done,
                                 grpc_timeout_milliseconds_to_deadline(100)) ==
-                 NULL);
+                 nullptr);
     }
     {
       gpr_event allocated;
@@ -695,10 +699,11 @@ static void test_reclaimers_can_be_posted_repeatedly(void) {
       grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
       grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&allocated));
       grpc_exec_ctx_finish(&exec_ctx);
-      GPR_ASSERT(gpr_event_wait(&allocated,
-                                grpc_timeout_seconds_to_deadline(5)) != NULL);
+      GPR_ASSERT(gpr_event_wait(&allocated, grpc_timeout_seconds_to_deadline(
+                                                5)) != nullptr);
       GPR_ASSERT(gpr_event_wait(&reclaimer_done,
-                                grpc_timeout_seconds_to_deadline(5)) != NULL);
+                                grpc_timeout_seconds_to_deadline(5)) !=
+                 nullptr);
     }
   }
   {
@@ -713,10 +718,10 @@ static void test_reclaimers_can_be_posted_repeatedly(void) {
 static void test_one_slice(void) {
   gpr_log(GPR_INFO, "** test_one_slice **");
 
-  grpc_resource_quota *q = grpc_resource_quota_create("test_one_slice");
+  grpc_resource_quota* q = grpc_resource_quota_create("test_one_slice");
   grpc_resource_quota_resize(q, 1024);
 
-  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+  grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
 
   grpc_resource_user_slice_allocator alloc;
   int num_allocs = 0;
@@ -745,11 +750,11 @@ static void test_one_slice(void) {
 static void test_one_slice_deleted_late(void) {
   gpr_log(GPR_INFO, "** test_one_slice_deleted_late **");
 
-  grpc_resource_quota *q =
+  grpc_resource_quota* q =
       grpc_resource_quota_create("test_one_slice_deleted_late");
   grpc_resource_quota_resize(q, 1024);
 
-  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+  grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
 
   grpc_resource_user_slice_allocator alloc;
   int num_allocs = 0;
@@ -782,18 +787,18 @@ static void test_one_slice_deleted_late(void) {
 
 static void test_resize_to_zero(void) {
   gpr_log(GPR_INFO, "** test_resize_to_zero **");
-  grpc_resource_quota *q = grpc_resource_quota_create("test_resize_to_zero");
+  grpc_resource_quota* q = grpc_resource_quota_create("test_resize_to_zero");
   grpc_resource_quota_resize(q, 0);
   grpc_resource_quota_unref(q);
 }
 
 static void test_negative_rq_free_pool(void) {
   gpr_log(GPR_INFO, "** test_negative_rq_free_pool **");
-  grpc_resource_quota *q =
+  grpc_resource_quota* q =
       grpc_resource_quota_create("test_negative_rq_free_pool");
   grpc_resource_quota_resize(q, 1024);
 
-  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+  grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
 
   grpc_resource_user_slice_allocator alloc;
   int num_allocs = 0;
@@ -830,7 +835,7 @@ static void test_negative_rq_free_pool(void) {
   }
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   gpr_mu_init(&g_mu);
diff --git a/test/core/iomgr/sockaddr_utils_test.c b/test/core/iomgr/sockaddr_utils_test.cc
index e4a4ddaa99..a445714851 100644
--- a/test/core/iomgr/sockaddr_utils_test.c
+++ b/test/core/iomgr/sockaddr_utils_test.cc
@@ -20,8 +20,8 @@
    using that endpoint. Because of various transitive includes in uv.h,
    including windows.h on Windows, uv.h must be included before other system
    headers. Therefore, sockaddr.h must always be included first */
-#include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/sockaddr_utils.h"
+#include "src/core/lib/iomgr/sockaddr.h"
 
 #include <errno.h>
 #include <string.h>
@@ -31,9 +31,9 @@
 #include <grpc/support/port_platform.h>
 #include "test/core/util/test_config.h"
 
-static grpc_resolved_address make_addr4(const uint8_t *data, size_t data_len) {
+static grpc_resolved_address make_addr4(const uint8_t* data, size_t data_len) {
   grpc_resolved_address resolved_addr4;
-  struct sockaddr_in *addr4 = (struct sockaddr_in *)resolved_addr4.addr;
+  struct sockaddr_in* addr4 = (struct sockaddr_in*)resolved_addr4.addr;
   memset(&resolved_addr4, 0, sizeof(resolved_addr4));
   addr4->sin_family = AF_INET;
   GPR_ASSERT(data_len == sizeof(addr4->sin_addr.s_addr));
@@ -43,9 +43,9 @@ static grpc_resolved_address make_addr4(const uint8_t *data, size_t data_len) {
   return resolved_addr4;
 }
 
-static grpc_resolved_address make_addr6(const uint8_t *data, size_t data_len) {
+static grpc_resolved_address make_addr6(const uint8_t* data, size_t data_len) {
   grpc_resolved_address resolved_addr6;
-  struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)resolved_addr6.addr;
+  struct sockaddr_in6* addr6 = (struct sockaddr_in6*)resolved_addr6.addr;
   memset(&resolved_addr6, 0, sizeof(resolved_addr6));
   addr6->sin6_family = AF_INET6;
   GPR_ASSERT(data_len == sizeof(addr6->sin6_addr.s6_addr));
@@ -55,8 +55,8 @@ static grpc_resolved_address make_addr6(const uint8_t *data, size_t data_len) {
   return resolved_addr6;
 }
 
-static void set_addr6_scope_id(grpc_resolved_address *addr, uint32_t scope_id) {
-  struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr->addr;
+static void set_addr6_scope_id(grpc_resolved_address* addr, uint32_t scope_id) {
+  struct sockaddr_in6* addr6 = (struct sockaddr_in6*)addr->addr;
   GPR_ASSERT(addr6->sin6_family == AF_INET6);
   addr6->sin6_scope_id = scope_id;
 }
@@ -81,21 +81,21 @@ static void test_sockaddr_is_v4mapped(void) {
 
   /* v4mapped input should succeed. */
   input6 = make_addr6(kMapped, sizeof(kMapped));
-  GPR_ASSERT(grpc_sockaddr_is_v4mapped(&input6, NULL));
+  GPR_ASSERT(grpc_sockaddr_is_v4mapped(&input6, nullptr));
   GPR_ASSERT(grpc_sockaddr_is_v4mapped(&input6, &output4));
   expect4 = make_addr4(kIPv4, sizeof(kIPv4));
   GPR_ASSERT(memcmp(&expect4, &output4, sizeof(expect4)) == 0);
 
   /* Non-v4mapped input should fail. */
   input6 = make_addr6(kNotQuiteMapped, sizeof(kNotQuiteMapped));
-  GPR_ASSERT(!grpc_sockaddr_is_v4mapped(&input6, NULL));
+  GPR_ASSERT(!grpc_sockaddr_is_v4mapped(&input6, nullptr));
   GPR_ASSERT(!grpc_sockaddr_is_v4mapped(&input6, &output4));
   /* Output is unchanged. */
   GPR_ASSERT(memcmp(&expect4, &output4, sizeof(expect4)) == 0);
 
   /* Plain IPv4 input should also fail. */
   input4 = make_addr4(kIPv4, sizeof(kIPv4));
-  GPR_ASSERT(!grpc_sockaddr_is_v4mapped(&input4, NULL));
+  GPR_ASSERT(!grpc_sockaddr_is_v4mapped(&input4, nullptr));
 }
 
 static void test_sockaddr_to_v4mapped(void) {
@@ -128,9 +128,9 @@ static void test_sockaddr_is_wildcard(void) {
   grpc_resolved_address wild6;
   grpc_resolved_address wild_mapped;
   grpc_resolved_address dummy;
-  struct sockaddr_in *wild4_addr;
-  struct sockaddr_in6 *wild6_addr;
-  struct sockaddr_in6 *wild_mapped_addr;
+  struct sockaddr_in* wild4_addr;
+  struct sockaddr_in6* wild6_addr;
+  struct sockaddr_in6* wild_mapped_addr;
   int port;
 
   gpr_log(GPR_INFO, "%s", "test_sockaddr_is_wildcard");
@@ -143,7 +143,7 @@ static void test_sockaddr_is_wildcard(void) {
   port = -1;
   GPR_ASSERT(grpc_sockaddr_is_wildcard(&wild4, &port));
   GPR_ASSERT(port == 555);
-  wild4_addr = (struct sockaddr_in *)&wild4.addr;
+  wild4_addr = (struct sockaddr_in*)&wild4.addr;
   memset(&wild4_addr->sin_addr.s_addr, 0xbd, 1);
   GPR_ASSERT(!grpc_sockaddr_is_wildcard(&wild4, &port));
 
@@ -151,7 +151,7 @@ static void test_sockaddr_is_wildcard(void) {
   port = -1;
   GPR_ASSERT(grpc_sockaddr_is_wildcard(&wild6, &port));
   GPR_ASSERT(port == 555);
-  wild6_addr = (struct sockaddr_in6 *)&wild6.addr;
+  wild6_addr = (struct sockaddr_in6*)&wild6.addr;
   memset(&wild6_addr->sin6_addr.s6_addr, 0xbd, 1);
   GPR_ASSERT(!grpc_sockaddr_is_wildcard(&wild6, &port));
 
@@ -159,7 +159,7 @@ static void test_sockaddr_is_wildcard(void) {
   port = -1;
   GPR_ASSERT(grpc_sockaddr_is_wildcard(&wild_mapped, &port));
   GPR_ASSERT(port == 555);
-  wild_mapped_addr = (struct sockaddr_in6 *)&wild_mapped.addr;
+  wild_mapped_addr = (struct sockaddr_in6*)&wild_mapped.addr;
   memset(&wild_mapped_addr->sin6_addr.s6_addr, 0xbd, 1);
   GPR_ASSERT(!grpc_sockaddr_is_wildcard(&wild_mapped, &port));
 
@@ -170,25 +170,25 @@ static void test_sockaddr_is_wildcard(void) {
   GPR_ASSERT(port == -1);
 }
 
-static void expect_sockaddr_str(const char *expected,
-                                grpc_resolved_address *addr, int normalize) {
+static void expect_sockaddr_str(const char* expected,
+                                grpc_resolved_address* addr, int normalize) {
   int result;
-  char *str;
+  char* str;
   gpr_log(GPR_INFO, "  expect_sockaddr_str(%s)", expected);
   result = grpc_sockaddr_to_string(&str, addr, normalize);
-  GPR_ASSERT(str != NULL);
+  GPR_ASSERT(str != nullptr);
   GPR_ASSERT(result >= 0);
   GPR_ASSERT((size_t)result == strlen(str));
   GPR_ASSERT(strcmp(expected, str) == 0);
   gpr_free(str);
 }
 
-static void expect_sockaddr_uri(const char *expected,
-                                grpc_resolved_address *addr) {
-  char *str;
+static void expect_sockaddr_uri(const char* expected,
+                                grpc_resolved_address* addr) {
+  char* str;
   gpr_log(GPR_INFO, "  expect_sockaddr_uri(%s)", expected);
   str = grpc_sockaddr_to_uri(addr);
-  GPR_ASSERT(str != NULL);
+  GPR_ASSERT(str != nullptr);
   GPR_ASSERT(strcmp(expected, str) == 0);
   gpr_free(str);
 }
@@ -197,7 +197,7 @@ static void test_sockaddr_to_string(void) {
   grpc_resolved_address input4;
   grpc_resolved_address input6;
   grpc_resolved_address dummy;
-  struct sockaddr *dummy_addr;
+  struct sockaddr* dummy_addr;
 
   gpr_log(GPR_INFO, "%s", "test_sockaddr_to_string");
 
@@ -234,18 +234,18 @@ static void test_sockaddr_to_string(void) {
   expect_sockaddr_uri("ipv6:[::fffe:c000:263]:12345", &input6);
 
   memset(&dummy, 0, sizeof(dummy));
-  dummy_addr = (struct sockaddr *)dummy.addr;
+  dummy_addr = (struct sockaddr*)dummy.addr;
   dummy_addr->sa_family = 123;
   expect_sockaddr_str("(sockaddr family=123)", &dummy, 0);
   expect_sockaddr_str("(sockaddr family=123)", &dummy, 1);
-  GPR_ASSERT(grpc_sockaddr_to_uri(&dummy) == NULL);
+  GPR_ASSERT(grpc_sockaddr_to_uri(&dummy) == nullptr);
 }
 
 static void test_sockaddr_set_get_port(void) {
   grpc_resolved_address input4;
   grpc_resolved_address input6;
   grpc_resolved_address dummy;
-  struct sockaddr *dummy_addr;
+  struct sockaddr* dummy_addr;
 
   gpr_log(GPR_DEBUG, "test_sockaddr_set_get_port");
 
@@ -260,13 +260,13 @@ static void test_sockaddr_set_get_port(void) {
   GPR_ASSERT(grpc_sockaddr_get_port(&input6) == 54321);
 
   memset(&dummy, 0, sizeof(dummy));
-  dummy_addr = (struct sockaddr *)dummy.addr;
+  dummy_addr = (struct sockaddr*)dummy.addr;
   dummy_addr->sa_family = 123;
   GPR_ASSERT(grpc_sockaddr_get_port(&dummy) == 0);
   GPR_ASSERT(grpc_sockaddr_set_port(&dummy, 1234) == 0);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
 
   test_sockaddr_is_v4mapped();
diff --git a/test/core/iomgr/socket_utils_test.c b/test/core/iomgr/socket_utils_test.cc
index 30f0c943dc..49c6f799e7 100644
--- a/test/core/iomgr/socket_utils_test.c
+++ b/test/core/iomgr/socket_utils_test.cc
@@ -39,10 +39,10 @@ struct test_socket_mutator {
   int option_value;
 };
 
-static bool mutate_fd(int fd, grpc_socket_mutator *mutator) {
+static bool mutate_fd(int fd, grpc_socket_mutator* mutator) {
   int newval;
   socklen_t intlen = sizeof(newval);
-  struct test_socket_mutator *m = (struct test_socket_mutator *)mutator;
+  struct test_socket_mutator* m = (struct test_socket_mutator*)mutator;
 
   if (0 != setsockopt(fd, IPPROTO_IP, IP_TOS, &m->option_value,
                       sizeof(m->option_value))) {
@@ -57,24 +57,24 @@ static bool mutate_fd(int fd, grpc_socket_mutator *mutator) {
   return true;
 }
 
-static void destroy_test_mutator(grpc_socket_mutator *mutator) {
-  struct test_socket_mutator *m = (struct test_socket_mutator *)mutator;
+static void destroy_test_mutator(grpc_socket_mutator* mutator) {
+  struct test_socket_mutator* m = (struct test_socket_mutator*)mutator;
   gpr_free(m);
 }
 
-static int compare_test_mutator(grpc_socket_mutator *a,
-                                grpc_socket_mutator *b) {
-  struct test_socket_mutator *ma = (struct test_socket_mutator *)a;
-  struct test_socket_mutator *mb = (struct test_socket_mutator *)b;
+static int compare_test_mutator(grpc_socket_mutator* a,
+                                grpc_socket_mutator* b) {
+  struct test_socket_mutator* ma = (struct test_socket_mutator*)a;
+  struct test_socket_mutator* mb = (struct test_socket_mutator*)b;
   return GPR_ICMP(ma->option_value, mb->option_value);
 }
 
 static const grpc_socket_mutator_vtable mutator_vtable = {
     mutate_fd, compare_test_mutator, destroy_test_mutator};
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   int sock;
-  grpc_error *err;
+  grpc_error* err;
   grpc_test_init(argc, argv);
 
   sock = socket(PF_INET, SOCK_STREAM, 0);
@@ -103,20 +103,20 @@ int main(int argc, char **argv) {
   mutator.option_value = IPTOS_LOWDELAY;
   GPR_ASSERT(GRPC_LOG_IF_ERROR(
       "set_socket_with_mutator",
-      grpc_set_socket_with_mutator(sock, (grpc_socket_mutator *)&mutator)));
+      grpc_set_socket_with_mutator(sock, (grpc_socket_mutator*)&mutator)));
 
   mutator.option_value = IPTOS_THROUGHPUT;
   GPR_ASSERT(GRPC_LOG_IF_ERROR(
       "set_socket_with_mutator",
-      grpc_set_socket_with_mutator(sock, (grpc_socket_mutator *)&mutator)));
+      grpc_set_socket_with_mutator(sock, (grpc_socket_mutator*)&mutator)));
 
   mutator.option_value = IPTOS_RELIABILITY;
   GPR_ASSERT(GRPC_LOG_IF_ERROR(
       "set_socket_with_mutator",
-      grpc_set_socket_with_mutator(sock, (grpc_socket_mutator *)&mutator)));
+      grpc_set_socket_with_mutator(sock, (grpc_socket_mutator*)&mutator)));
 
   mutator.option_value = -1;
-  err = grpc_set_socket_with_mutator(sock, (grpc_socket_mutator *)&mutator);
+  err = grpc_set_socket_with_mutator(sock, (grpc_socket_mutator*)&mutator);
   GPR_ASSERT(err != GRPC_ERROR_NONE);
   GRPC_ERROR_UNREF(err);
 
@@ -127,6 +127,6 @@ int main(int argc, char **argv) {
 
 #else /* GRPC_POSIX_SOCKET */
 
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
 
 #endif /* GRPC_POSIX_SOCKET */
diff --git a/test/core/iomgr/tcp_client_posix_test.c b/test/core/iomgr/tcp_client_posix_test.cc
index b8b76d1c42..9fb1a2d770 100644
--- a/test/core/iomgr/tcp_client_posix_test.c
+++ b/test/core/iomgr/tcp_client_posix_test.cc
@@ -40,11 +40,11 @@
 #include "src/core/lib/iomgr/timer.h"
 #include "test/core/util/test_config.h"
 
-static grpc_pollset_set *g_pollset_set;
-static gpr_mu *g_mu;
-static grpc_pollset *g_pollset;
+static grpc_pollset_set* g_pollset_set;
+static gpr_mu* g_mu;
+static grpc_pollset* g_pollset;
 static int g_connections_complete = 0;
-static grpc_endpoint *g_connecting = NULL;
+static grpc_endpoint* g_connecting = nullptr;
 
 static grpc_millis test_deadline(void) {
   return grpc_timespec_to_millis_round_up(grpc_timeout_seconds_to_deadline(10));
@@ -54,33 +54,33 @@ static void finish_connection() {
   gpr_mu_lock(g_mu);
   g_connections_complete++;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  GPR_ASSERT(GRPC_LOG_IF_ERROR("pollset_kick",
-                               grpc_pollset_kick(&exec_ctx, g_pollset, NULL)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR(
+      "pollset_kick", grpc_pollset_kick(&exec_ctx, g_pollset, nullptr)));
   grpc_exec_ctx_finish(&exec_ctx);
   gpr_mu_unlock(g_mu);
 }
 
-static void must_succeed(grpc_exec_ctx *exec_ctx, void *arg,
-                         grpc_error *error) {
-  GPR_ASSERT(g_connecting != NULL);
+static void must_succeed(grpc_exec_ctx* exec_ctx, void* arg,
+                         grpc_error* error) {
+  GPR_ASSERT(g_connecting != nullptr);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   grpc_endpoint_shutdown(
       exec_ctx, g_connecting,
       GRPC_ERROR_CREATE_FROM_STATIC_STRING("must_succeed called"));
   grpc_endpoint_destroy(exec_ctx, g_connecting);
-  g_connecting = NULL;
+  g_connecting = nullptr;
   finish_connection();
 }
 
-static void must_fail(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  GPR_ASSERT(g_connecting == NULL);
+static void must_fail(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+  GPR_ASSERT(g_connecting == nullptr);
   GPR_ASSERT(error != GRPC_ERROR_NONE);
   finish_connection();
 }
 
 void test_succeeds(void) {
   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 svr_fd;
   int r;
   int connections_complete_before;
@@ -97,7 +97,7 @@ void test_succeeds(void) {
   svr_fd = socket(AF_INET, SOCK_STREAM, 0);
   GPR_ASSERT(svr_fd >= 0);
   GPR_ASSERT(
-      0 == bind(svr_fd, (struct sockaddr *)addr, (socklen_t)resolved_addr.len));
+      0 == bind(svr_fd, (struct sockaddr*)addr, (socklen_t)resolved_addr.len));
   GPR_ASSERT(0 == listen(svr_fd, 1));
 
   gpr_mu_lock(g_mu);
@@ -105,17 +105,16 @@ void test_succeeds(void) {
   gpr_mu_unlock(g_mu);
 
   /* connect to it */
-  GPR_ASSERT(getsockname(svr_fd, (struct sockaddr *)addr,
-                         (socklen_t *)&resolved_addr.len) == 0);
-  GRPC_CLOSURE_INIT(&done, must_succeed, NULL, grpc_schedule_on_exec_ctx);
-  grpc_tcp_client_connect(&exec_ctx, &done, &g_connecting, g_pollset_set, NULL,
-                          &resolved_addr, GRPC_MILLIS_INF_FUTURE);
+  GPR_ASSERT(getsockname(svr_fd, (struct sockaddr*)addr,
+                         (socklen_t*)&resolved_addr.len) == 0);
+  GRPC_CLOSURE_INIT(&done, must_succeed, nullptr, grpc_schedule_on_exec_ctx);
+  grpc_tcp_client_connect(&exec_ctx, &done, &g_connecting, g_pollset_set,
+                          nullptr, &resolved_addr, GRPC_MILLIS_INF_FUTURE);
 
   /* await the connection */
   do {
     resolved_addr.len = sizeof(addr);
-    r = accept(svr_fd, (struct sockaddr *)addr,
-               (socklen_t *)&resolved_addr.len);
+    r = accept(svr_fd, (struct sockaddr*)addr, (socklen_t*)&resolved_addr.len);
   } while (r == -1 && errno == EINTR);
   GPR_ASSERT(r >= 0);
   close(r);
@@ -123,7 +122,7 @@ void test_succeeds(void) {
   gpr_mu_lock(g_mu);
 
   while (g_connections_complete == connections_complete_before) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     GPR_ASSERT(GRPC_LOG_IF_ERROR(
         "pollset_work",
         grpc_pollset_work(&exec_ctx, g_pollset, &worker,
@@ -141,7 +140,7 @@ void test_succeeds(void) {
 
 void test_fails(void) {
   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 connections_complete_before;
   grpc_closure done;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -157,15 +156,15 @@ void test_fails(void) {
   gpr_mu_unlock(g_mu);
 
   /* connect to a broken address */
-  GRPC_CLOSURE_INIT(&done, must_fail, NULL, grpc_schedule_on_exec_ctx);
-  grpc_tcp_client_connect(&exec_ctx, &done, &g_connecting, g_pollset_set, NULL,
-                          &resolved_addr, GRPC_MILLIS_INF_FUTURE);
+  GRPC_CLOSURE_INIT(&done, must_fail, nullptr, grpc_schedule_on_exec_ctx);
+  grpc_tcp_client_connect(&exec_ctx, &done, &g_connecting, g_pollset_set,
+                          nullptr, &resolved_addr, GRPC_MILLIS_INF_FUTURE);
 
   gpr_mu_lock(g_mu);
 
   /* wait for the connection callback to finish */
   while (g_connections_complete == connections_complete_before) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     grpc_millis polling_deadline = test_deadline();
     switch (grpc_timer_check(&exec_ctx, &polling_deadline)) {
       case GRPC_TIMERS_FIRED:
@@ -188,18 +187,18 @@ void test_fails(void) {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void destroy_pollset(grpc_exec_ctx *exec_ctx, void *p,
-                            grpc_error *error) {
-  grpc_pollset_destroy(exec_ctx, p);
+static void destroy_pollset(grpc_exec_ctx* exec_ctx, void* p,
+                            grpc_error* error) {
+  grpc_pollset_destroy(exec_ctx, static_cast<grpc_pollset*>(p));
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_closure destroyed;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_test_init(argc, argv);
   grpc_init();
   g_pollset_set = grpc_pollset_set_create();
-  g_pollset = gpr_zalloc(grpc_pollset_size());
+  g_pollset = static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
   grpc_pollset_init(g_pollset, &g_mu);
   grpc_pollset_set_add_pollset(&exec_ctx, g_pollset_set, g_pollset);
   grpc_exec_ctx_finish(&exec_ctx);
@@ -218,6 +217,6 @@ int main(int argc, char **argv) {
 
 #else /* GRPC_POSIX_SOCKET */
 
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
 
 #endif /* GRPC_POSIX_SOCKET */
diff --git a/test/core/iomgr/tcp_client_uv_test.c b/test/core/iomgr/tcp_client_uv_test.cc
index edfccbe867..101d7bf6b5 100644
--- a/test/core/iomgr/tcp_client_uv_test.c
+++ b/test/core/iomgr/tcp_client_uv_test.cc
@@ -37,16 +37,16 @@
 #include "src/core/lib/iomgr/timer.h"
 #include "test/core/util/test_config.h"
 
-static gpr_mu *g_mu;
-static grpc_pollset *g_pollset;
+static gpr_mu* g_mu;
+static grpc_pollset* g_pollset;
 static int g_connections_complete = 0;
-static grpc_endpoint *g_connecting = NULL;
+static grpc_endpoint* g_connecting = NULL;
 
 static grpc_millis test_deadline(void) {
   return grpc_timespec_to_millis_round_up(grpc_timeout_seconds_to_deadline(10));
 }
 
-static void finish_connection(grpc_exec_ctx *exec_ctx) {
+static void finish_connection(grpc_exec_ctx* exec_ctx) {
   gpr_mu_lock(g_mu);
   g_connections_complete++;
   GPR_ASSERT(GRPC_LOG_IF_ERROR("pollset_kick",
@@ -54,8 +54,8 @@ static void finish_connection(grpc_exec_ctx *exec_ctx) {
   gpr_mu_unlock(g_mu);
 }
 
-static void must_succeed(grpc_exec_ctx *exec_ctx, void *arg,
-                         grpc_error *error) {
+static void must_succeed(grpc_exec_ctx* exec_ctx, void* arg,
+                         grpc_error* error) {
   GPR_ASSERT(g_connecting != NULL);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   grpc_endpoint_shutdown(
@@ -66,26 +66,27 @@ static void must_succeed(grpc_exec_ctx *exec_ctx, void *arg,
   finish_connection(exec_ctx);
 }
 
-static void must_fail(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
+static void must_fail(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
   GPR_ASSERT(g_connecting == NULL);
   GPR_ASSERT(error != GRPC_ERROR_NONE);
   finish_connection(exec_ctx);
 }
 
-static void close_cb(uv_handle_t *handle) { gpr_free(handle); }
+static void close_cb(uv_handle_t* handle) { gpr_free(handle); }
 
-static void connection_cb(uv_stream_t *server, int status) {
-  uv_tcp_t *client_handle = gpr_malloc(sizeof(uv_tcp_t));
+static void connection_cb(uv_stream_t* server, int status) {
+  uv_tcp_t* client_handle =
+      static_cast<uv_tcp_t*>(gpr_malloc(sizeof(uv_tcp_t)));
   GPR_ASSERT(0 == status);
   GPR_ASSERT(0 == uv_tcp_init(uv_default_loop(), client_handle));
-  GPR_ASSERT(0 == uv_accept(server, (uv_stream_t *)client_handle));
-  uv_close((uv_handle_t *)client_handle, close_cb);
+  GPR_ASSERT(0 == uv_accept(server, (uv_stream_t*)client_handle));
+  uv_close((uv_handle_t*)client_handle, close_cb);
 }
 
 void test_succeeds(void) {
   grpc_resolved_address resolved_addr;
-  struct sockaddr_in *addr = (struct sockaddr_in *)resolved_addr.addr;
-  uv_tcp_t *svr_handle = gpr_malloc(sizeof(uv_tcp_t));
+  struct sockaddr_in* addr = (struct sockaddr_in*)resolved_addr.addr;
+  uv_tcp_t* svr_handle = static_cast<uv_tcp_t*>(gpr_malloc(sizeof(uv_tcp_t)));
   int connections_complete_before;
   grpc_closure done;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -98,16 +99,16 @@ void test_succeeds(void) {
 
   /* create a dummy server */
   GPR_ASSERT(0 == uv_tcp_init(uv_default_loop(), svr_handle));
-  GPR_ASSERT(0 == uv_tcp_bind(svr_handle, (struct sockaddr *)addr, 0));
-  GPR_ASSERT(0 == uv_listen((uv_stream_t *)svr_handle, 1, connection_cb));
+  GPR_ASSERT(0 == uv_tcp_bind(svr_handle, (struct sockaddr*)addr, 0));
+  GPR_ASSERT(0 == uv_listen((uv_stream_t*)svr_handle, 1, connection_cb));
 
   gpr_mu_lock(g_mu);
   connections_complete_before = g_connections_complete;
   gpr_mu_unlock(g_mu);
 
   /* connect to it */
-  GPR_ASSERT(uv_tcp_getsockname(svr_handle, (struct sockaddr *)addr,
-                                (int *)&resolved_addr.len) == 0);
+  GPR_ASSERT(uv_tcp_getsockname(svr_handle, (struct sockaddr*)addr,
+                                (int*)&resolved_addr.len) == 0);
   GRPC_CLOSURE_INIT(&done, must_succeed, NULL, grpc_schedule_on_exec_ctx);
   grpc_tcp_client_connect(&exec_ctx, &done, &g_connecting, NULL, NULL,
                           &resolved_addr, GRPC_MILLIS_INF_FUTURE);
@@ -115,7 +116,7 @@ void test_succeeds(void) {
   gpr_mu_lock(g_mu);
 
   while (g_connections_complete == connections_complete_before) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = NULL;
     GPR_ASSERT(GRPC_LOG_IF_ERROR(
         "pollset_work",
         grpc_pollset_work(&exec_ctx, g_pollset, &worker,
@@ -127,7 +128,7 @@ void test_succeeds(void) {
   }
 
   // This will get cleaned up when the pollset runs again or gets shutdown
-  uv_close((uv_handle_t *)svr_handle, close_cb);
+  uv_close((uv_handle_t*)svr_handle, close_cb);
 
   gpr_mu_unlock(g_mu);
 
@@ -136,7 +137,7 @@ void test_succeeds(void) {
 
 void test_fails(void) {
   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 connections_complete_before;
   grpc_closure done;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -160,7 +161,7 @@ void test_fails(void) {
 
   /* wait for the connection callback to finish */
   while (g_connections_complete == connections_complete_before) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = NULL;
     gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC);
     grpc_millis polling_deadline = test_deadline();
     switch (grpc_timer_check(&exec_ctx, &polling_deadline)) {
@@ -184,17 +185,17 @@ void test_fails(void) {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void destroy_pollset(grpc_exec_ctx *exec_ctx, void *p,
-                            grpc_error *error) {
-  grpc_pollset_destroy(exec_ctx, p);
+static void destroy_pollset(grpc_exec_ctx* exec_ctx, void* p,
+                            grpc_error* error) {
+  grpc_pollset_destroy(exec_ctx, static_cast<grpc_pollset*>(p));
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_closure destroyed;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_test_init(argc, argv);
   grpc_init();
-  g_pollset = gpr_malloc(grpc_pollset_size());
+  g_pollset = static_cast<grpc_pollset*>(gpr_malloc(grpc_pollset_size()));
   grpc_pollset_init(g_pollset, &g_mu);
   grpc_exec_ctx_finish(&exec_ctx);
   test_succeeds();
@@ -211,6 +212,6 @@ int main(int argc, char **argv) {
 
 #else /* GRPC_UV */
 
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
 
 #endif /* GRPC_UV */
diff --git a/test/core/iomgr/tcp_posix_test.c b/test/core/iomgr/tcp_posix_test.cc
index 6501160c6f..7986dc2b19 100644
--- a/test/core/iomgr/tcp_posix_test.c
+++ b/test/core/iomgr/tcp_posix_test.cc
@@ -40,8 +40,8 @@
 #include "test/core/iomgr/endpoint_tests.h"
 #include "test/core/util/test_config.h"
 
-static gpr_mu *g_mu;
-static grpc_pollset *g_pollset;
+static gpr_mu* g_mu;
+static grpc_pollset* g_pollset;
 
 /*
    General test notes:
@@ -89,7 +89,7 @@ static ssize_t fill_socket(int fd) {
 static size_t fill_socket_partial(int fd, size_t bytes) {
   ssize_t write_bytes;
   size_t total_bytes = 0;
-  unsigned char *buf = (unsigned char *)gpr_malloc(bytes);
+  unsigned char* buf = (unsigned char*)gpr_malloc(bytes);
   unsigned i;
   for (i = 0; i < bytes; ++i) {
     buf[i] = (uint8_t)(i % 256);
@@ -108,18 +108,18 @@ static size_t fill_socket_partial(int fd, size_t bytes) {
 }
 
 struct read_socket_state {
-  grpc_endpoint *ep;
+  grpc_endpoint* ep;
   size_t read_bytes;
   size_t target_read_bytes;
   grpc_slice_buffer incoming;
   grpc_closure read_cb;
 };
 
-static size_t count_slices(grpc_slice *slices, size_t nslices,
-                           int *current_data) {
+static size_t count_slices(grpc_slice* slices, size_t nslices,
+                           int* current_data) {
   size_t num_bytes = 0;
   unsigned i, j;
-  unsigned char *buf;
+  unsigned char* buf;
   for (i = 0; i < nslices; ++i) {
     buf = GRPC_SLICE_START_PTR(slices[i]);
     for (j = 0; j < GRPC_SLICE_LENGTH(slices[i]); ++j) {
@@ -131,9 +131,9 @@ static size_t count_slices(grpc_slice *slices, size_t nslices,
   return num_bytes;
 }
 
-static void read_cb(grpc_exec_ctx *exec_ctx, void *user_data,
-                    grpc_error *error) {
-  struct read_socket_state *state = (struct read_socket_state *)user_data;
+static void read_cb(grpc_exec_ctx* exec_ctx, void* user_data,
+                    grpc_error* error) {
+  struct read_socket_state* state = (struct read_socket_state*)user_data;
   size_t read_bytes;
   int current_data;
 
@@ -147,8 +147,8 @@ static void read_cb(grpc_exec_ctx *exec_ctx, void *user_data,
   gpr_log(GPR_INFO, "Read %" PRIuPTR " bytes of %" PRIuPTR, read_bytes,
           state->target_read_bytes);
   if (state->read_bytes >= state->target_read_bytes) {
-    GPR_ASSERT(GRPC_LOG_IF_ERROR("kick",
-                                 grpc_pollset_kick(exec_ctx, g_pollset, NULL)));
+    GPR_ASSERT(GRPC_LOG_IF_ERROR(
+        "kick", grpc_pollset_kick(exec_ctx, g_pollset, nullptr)));
     gpr_mu_unlock(g_mu);
   } else {
     grpc_endpoint_read(exec_ctx, state->ep, &state->incoming, &state->read_cb);
@@ -159,7 +159,7 @@ static void read_cb(grpc_exec_ctx *exec_ctx, void *user_data,
 /* Write to a socket, then read from it using the grpc_tcp API. */
 static void read_test(size_t num_bytes, size_t slice_size) {
   int sv[2];
-  grpc_endpoint *ep;
+  grpc_endpoint* ep;
   struct read_socket_state state;
   size_t written_bytes;
   grpc_millis deadline =
@@ -171,10 +171,10 @@ static void read_test(size_t num_bytes, size_t slice_size) {
 
   create_sockets(sv);
 
-  grpc_arg a[] = {{.key = GRPC_ARG_TCP_READ_CHUNK_SIZE,
-                   .type = GRPC_ARG_INTEGER,
-                   .value.integer = (int)slice_size}};
-  grpc_channel_args args = {.num_args = GPR_ARRAY_SIZE(a), .args = a};
+  grpc_arg a[1];
+  a[0].key = const_cast<char*>(GRPC_ARG_TCP_READ_CHUNK_SIZE);
+  a[0].type = GRPC_ARG_INTEGER, a[0].value.integer = (int)slice_size;
+  grpc_channel_args args = {GPR_ARRAY_SIZE(a), a};
   ep = grpc_tcp_create(&exec_ctx, grpc_fd_create(sv[1], "read_test"), &args,
                        "test");
   grpc_endpoint_add_to_pollset(&exec_ctx, ep, g_pollset);
@@ -192,7 +192,7 @@ static void read_test(size_t num_bytes, size_t slice_size) {
 
   gpr_mu_lock(g_mu);
   while (state.read_bytes < state.target_read_bytes) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     GPR_ASSERT(GRPC_LOG_IF_ERROR(
         "pollset_work",
         grpc_pollset_work(&exec_ctx, g_pollset, &worker, deadline)));
@@ -212,7 +212,7 @@ static void read_test(size_t num_bytes, size_t slice_size) {
    API. */
 static void large_read_test(size_t slice_size) {
   int sv[2];
-  grpc_endpoint *ep;
+  grpc_endpoint* ep;
   struct read_socket_state state;
   ssize_t written_bytes;
   grpc_millis deadline =
@@ -223,10 +223,11 @@ static void large_read_test(size_t slice_size) {
 
   create_sockets(sv);
 
-  grpc_arg a[] = {{.key = GRPC_ARG_TCP_READ_CHUNK_SIZE,
-                   .type = GRPC_ARG_INTEGER,
-                   .value.integer = (int)slice_size}};
-  grpc_channel_args args = {.num_args = GPR_ARRAY_SIZE(a), .args = a};
+  grpc_arg a[1];
+  a[0].key = const_cast<char*>(GRPC_ARG_TCP_READ_CHUNK_SIZE);
+  a[0].type = GRPC_ARG_INTEGER;
+  a[0].value.integer = (int)slice_size;
+  grpc_channel_args args = {GPR_ARRAY_SIZE(a), a};
   ep = grpc_tcp_create(&exec_ctx, grpc_fd_create(sv[1], "large_read_test"),
                        &args, "test");
   grpc_endpoint_add_to_pollset(&exec_ctx, ep, g_pollset);
@@ -244,7 +245,7 @@ static void large_read_test(size_t slice_size) {
 
   gpr_mu_lock(g_mu);
   while (state.read_bytes < state.target_read_bytes) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     GPR_ASSERT(GRPC_LOG_IF_ERROR(
         "pollset_work",
         grpc_pollset_work(&exec_ctx, g_pollset, &worker, deadline)));
@@ -261,17 +262,17 @@ static void large_read_test(size_t slice_size) {
 }
 
 struct write_socket_state {
-  grpc_endpoint *ep;
+  grpc_endpoint* ep;
   int write_done;
 };
 
-static grpc_slice *allocate_blocks(size_t num_bytes, size_t slice_size,
-                                   size_t *num_blocks, uint8_t *current_data) {
+static grpc_slice* allocate_blocks(size_t num_bytes, size_t slice_size,
+                                   size_t* num_blocks, uint8_t* current_data) {
   size_t nslices = num_bytes / slice_size + (num_bytes % slice_size ? 1u : 0u);
-  grpc_slice *slices = (grpc_slice *)gpr_malloc(sizeof(grpc_slice) * nslices);
+  grpc_slice* slices = (grpc_slice*)gpr_malloc(sizeof(grpc_slice) * nslices);
   size_t num_bytes_left = num_bytes;
   unsigned i, j;
-  unsigned char *buf;
+  unsigned char* buf;
   *num_blocks = nslices;
 
   for (i = 0; i < nslices; ++i) {
@@ -288,21 +289,21 @@ static grpc_slice *allocate_blocks(size_t num_bytes, size_t slice_size,
   return slices;
 }
 
-static void write_done(grpc_exec_ctx *exec_ctx,
-                       void *user_data /* write_socket_state */,
-                       grpc_error *error) {
-  struct write_socket_state *state = (struct write_socket_state *)user_data;
+static void write_done(grpc_exec_ctx* exec_ctx,
+                       void* user_data /* write_socket_state */,
+                       grpc_error* error) {
+  struct write_socket_state* state = (struct write_socket_state*)user_data;
   gpr_log(GPR_INFO, "Write done callback called");
   gpr_mu_lock(g_mu);
   gpr_log(GPR_INFO, "Signalling write done");
   state->write_done = 1;
-  GPR_ASSERT(GRPC_LOG_IF_ERROR("pollset_kick",
-                               grpc_pollset_kick(exec_ctx, g_pollset, NULL)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR(
+      "pollset_kick", grpc_pollset_kick(exec_ctx, g_pollset, nullptr)));
   gpr_mu_unlock(g_mu);
 }
 
 void drain_socket_blocking(int fd, size_t num_bytes, size_t read_size) {
-  unsigned char *buf = (unsigned char *)gpr_malloc(read_size);
+  unsigned char* buf = (unsigned char*)gpr_malloc(read_size);
   ssize_t bytes_read;
   size_t bytes_left = num_bytes;
   int flags;
@@ -314,7 +315,7 @@ void drain_socket_blocking(int fd, size_t num_bytes, size_t read_size) {
   GPR_ASSERT(fcntl(fd, F_SETFL, flags & ~O_NONBLOCK) == 0);
 
   for (;;) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     gpr_mu_lock(g_mu);
     GPR_ASSERT(GRPC_LOG_IF_ERROR(
         "pollset_work",
@@ -346,10 +347,10 @@ void drain_socket_blocking(int fd, size_t num_bytes, size_t read_size) {
    socket in parallel with the read. */
 static void write_test(size_t num_bytes, size_t slice_size) {
   int sv[2];
-  grpc_endpoint *ep;
+  grpc_endpoint* ep;
   struct write_socket_state state;
   size_t num_blocks;
-  grpc_slice *slices;
+  grpc_slice* slices;
   uint8_t current_data = 0;
   grpc_slice_buffer outgoing;
   grpc_closure write_done_closure;
@@ -363,10 +364,10 @@ static void write_test(size_t num_bytes, size_t slice_size) {
 
   create_sockets(sv);
 
-  grpc_arg a[] = {{.key = GRPC_ARG_TCP_READ_CHUNK_SIZE,
-                   .type = GRPC_ARG_INTEGER,
-                   .value.integer = (int)slice_size}};
-  grpc_channel_args args = {.num_args = GPR_ARRAY_SIZE(a), .args = a};
+  grpc_arg a[1];
+  a[0].key = const_cast<char*>(GRPC_ARG_TCP_READ_CHUNK_SIZE);
+  a[0].type = GRPC_ARG_INTEGER, a[0].value.integer = (int)slice_size;
+  grpc_channel_args args = {GPR_ARRAY_SIZE(a), a};
   ep = grpc_tcp_create(&exec_ctx, grpc_fd_create(sv[1], "write_test"), &args,
                        "test");
   grpc_endpoint_add_to_pollset(&exec_ctx, ep, g_pollset);
@@ -385,7 +386,7 @@ static void write_test(size_t num_bytes, size_t slice_size) {
   drain_socket_blocking(sv[0], num_bytes, num_bytes);
   gpr_mu_lock(g_mu);
   for (;;) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     if (state.write_done) {
       break;
     }
@@ -404,18 +405,18 @@ static void write_test(size_t num_bytes, size_t slice_size) {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-void on_fd_released(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *errors) {
-  int *done = (int *)arg;
+void on_fd_released(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* errors) {
+  int* done = (int*)arg;
   *done = 1;
-  GPR_ASSERT(GRPC_LOG_IF_ERROR("pollset_kick",
-                               grpc_pollset_kick(exec_ctx, g_pollset, NULL)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR(
+      "pollset_kick", grpc_pollset_kick(exec_ctx, g_pollset, nullptr)));
 }
 
 /* Do a read_test, then release fd and try to read/write again. Verify that
    grpc_tcp_fd() is available before the fd is released. */
 static void release_fd_test(size_t num_bytes, size_t slice_size) {
   int sv[2];
-  grpc_endpoint *ep;
+  grpc_endpoint* ep;
   struct read_socket_state state;
   size_t written_bytes;
   int fd;
@@ -433,10 +434,11 @@ static void release_fd_test(size_t num_bytes, size_t slice_size) {
 
   create_sockets(sv);
 
-  grpc_arg a[] = {{.key = GRPC_ARG_TCP_READ_CHUNK_SIZE,
-                   .type = GRPC_ARG_INTEGER,
-                   .value.integer = (int)slice_size}};
-  grpc_channel_args args = {.num_args = GPR_ARRAY_SIZE(a), .args = a};
+  grpc_arg a[1];
+  a[0].key = const_cast<char*>(GRPC_ARG_TCP_READ_CHUNK_SIZE);
+  a[0].type = GRPC_ARG_INTEGER;
+  a[0].value.integer = (int)slice_size;
+  grpc_channel_args args = {GPR_ARRAY_SIZE(a), a};
   ep = grpc_tcp_create(&exec_ctx, grpc_fd_create(sv[1], "read_test"), &args,
                        "test");
   GPR_ASSERT(grpc_tcp_fd(ep) == sv[1] && sv[1] >= 0);
@@ -455,7 +457,7 @@ static void release_fd_test(size_t num_bytes, size_t slice_size) {
 
   gpr_mu_lock(g_mu);
   while (state.read_bytes < state.target_read_bytes) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     GPR_ASSERT(GRPC_LOG_IF_ERROR(
         "pollset_work",
         grpc_pollset_work(&exec_ctx, g_pollset, &worker, deadline)));
@@ -473,7 +475,7 @@ static void release_fd_test(size_t num_bytes, size_t slice_size) {
   grpc_exec_ctx_flush(&exec_ctx);
   gpr_mu_lock(g_mu);
   while (!fd_released_done) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     GPR_ASSERT(GRPC_LOG_IF_ERROR(
         "pollset_work",
         grpc_pollset_work(&exec_ctx, g_pollset, &worker, deadline)));
@@ -523,12 +525,13 @@ static grpc_endpoint_test_fixture create_fixture_tcp_socketpair(
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
   create_sockets(sv);
-  grpc_resource_quota *resource_quota =
+  grpc_resource_quota* resource_quota =
       grpc_resource_quota_create("tcp_posix_test_socketpair");
-  grpc_arg a[] = {{.key = GRPC_ARG_TCP_READ_CHUNK_SIZE,
-                   .type = GRPC_ARG_INTEGER,
-                   .value.integer = (int)slice_size}};
-  grpc_channel_args args = {.num_args = GPR_ARRAY_SIZE(a), .args = a};
+  grpc_arg a[1];
+  a[0].key = const_cast<char*>(GRPC_ARG_TCP_READ_CHUNK_SIZE);
+  a[0].type = GRPC_ARG_INTEGER;
+  a[0].value.integer = (int)slice_size;
+  grpc_channel_args args = {GPR_ARRAY_SIZE(a), a};
   f.client_ep = grpc_tcp_create(
       &exec_ctx, grpc_fd_create(sv[0], "fixture:client"), &args, "test");
   f.server_ep = grpc_tcp_create(
@@ -546,17 +549,17 @@ static grpc_endpoint_test_config configs[] = {
     {"tcp/tcp_socketpair", create_fixture_tcp_socketpair, clean_up},
 };
 
-static void destroy_pollset(grpc_exec_ctx *exec_ctx, void *p,
-                            grpc_error *error) {
-  grpc_pollset_destroy(exec_ctx, (grpc_pollset *)p);
+static void destroy_pollset(grpc_exec_ctx* exec_ctx, void* p,
+                            grpc_error* error) {
+  grpc_pollset_destroy(exec_ctx, (grpc_pollset*)p);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_closure destroyed;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_test_init(argc, argv);
   grpc_init();
-  g_pollset = (grpc_pollset *)gpr_zalloc(grpc_pollset_size());
+  g_pollset = (grpc_pollset*)gpr_zalloc(grpc_pollset_size());
   grpc_pollset_init(g_pollset, &g_mu);
   grpc_endpoint_tests(configs[0], g_pollset, g_mu);
   run_tests();
@@ -572,6 +575,6 @@ int main(int argc, char **argv) {
 
 #else /* GRPC_POSIX_SOCKET */
 
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
 
 #endif /* GRPC_POSIX_SOCKET */
diff --git a/test/core/iomgr/tcp_server_posix_test.c b/test/core/iomgr/tcp_server_posix_test.cc
index 782dfb413a..48d8d425a5 100644
--- a/test/core/iomgr/tcp_server_posix_test.c
+++ b/test/core/iomgr/tcp_server_posix_test.cc
@@ -47,20 +47,20 @@
 
 #define LOG_TEST(x) gpr_log(GPR_INFO, "%s", #x)
 
-static gpr_mu *g_mu;
-static grpc_pollset *g_pollset;
+static gpr_mu* g_mu;
+static grpc_pollset* g_pollset;
 static int g_nconnects = 0;
 
 typedef struct {
   /* Owns a ref to server. */
-  grpc_tcp_server *server;
+  grpc_tcp_server* server;
   unsigned port_index;
   unsigned fd_index;
   int server_fd;
 } on_connect_result;
 
 typedef struct {
-  grpc_tcp_server *server;
+  grpc_tcp_server* server;
 
   /* arg is this server_weak_ref. */
   grpc_closure server_shutdown;
@@ -78,10 +78,10 @@ typedef struct {
   test_addr addrs[MAX_ADDRS];
 } test_addrs;
 
-static on_connect_result g_result = {NULL, 0, 0, -1};
+static on_connect_result g_result = {nullptr, 0, 0, -1};
 
 static char family_name_buf[1024];
-static const char *sock_family_name(int family) {
+static const char* sock_family_name(int family) {
   if (family == AF_INET) {
     return "AF_INET";
   } else if (family == AF_INET6) {
@@ -94,15 +94,15 @@ static const char *sock_family_name(int family) {
   }
 }
 
-static void on_connect_result_init(on_connect_result *result) {
-  result->server = NULL;
+static void on_connect_result_init(on_connect_result* result) {
+  result->server = nullptr;
   result->port_index = 0;
   result->fd_index = 0;
   result->server_fd = -1;
 }
 
-static void on_connect_result_set(on_connect_result *result,
-                                  const grpc_tcp_server_acceptor *acceptor) {
+static void on_connect_result_set(on_connect_result* result,
+                                  const grpc_tcp_server_acceptor* acceptor) {
   result->server = grpc_tcp_server_ref(acceptor->from_server);
   result->port_index = acceptor->port_index;
   result->fd_index = acceptor->fd_index;
@@ -110,14 +110,14 @@ static void on_connect_result_set(on_connect_result *result,
       result->server, acceptor->port_index, acceptor->fd_index);
 }
 
-static void server_weak_ref_shutdown(grpc_exec_ctx *exec_ctx, void *arg,
-                                     grpc_error *error) {
-  server_weak_ref *weak_ref = arg;
-  weak_ref->server = NULL;
+static void server_weak_ref_shutdown(grpc_exec_ctx* exec_ctx, void* arg,
+                                     grpc_error* error) {
+  server_weak_ref* weak_ref = static_cast<server_weak_ref*>(arg);
+  weak_ref->server = nullptr;
 }
 
-static void server_weak_ref_init(server_weak_ref *weak_ref) {
-  weak_ref->server = NULL;
+static void server_weak_ref_init(server_weak_ref* weak_ref) {
+  weak_ref->server = nullptr;
   GRPC_CLOSURE_INIT(&weak_ref->server_shutdown, server_weak_ref_shutdown,
                     weak_ref, grpc_schedule_on_exec_ctx);
 }
@@ -127,14 +127,14 @@ static void server_weak_ref_init(server_weak_ref *weak_ref) {
    weak_ref->server_shutdown has returned. A strong ref on grpc_tcp_server
    should be held until server_weak_ref_set() returns to avoid a race where the
    server is deleted before the shutdown_starting cb is added. */
-static void server_weak_ref_set(server_weak_ref *weak_ref,
-                                grpc_tcp_server *server) {
+static void server_weak_ref_set(server_weak_ref* weak_ref,
+                                grpc_tcp_server* server) {
   grpc_tcp_server_shutdown_starting_add(server, &weak_ref->server_shutdown);
   weak_ref->server = server;
 }
 
-static void test_addr_init_str(test_addr *addr) {
-  char *str = NULL;
+static void test_addr_init_str(test_addr* addr) {
+  char* str = nullptr;
   if (grpc_sockaddr_to_string(&str, &addr->addr, 0) != -1) {
     size_t str_len;
     memcpy(addr->str, str, (str_len = strnlen(str, sizeof(addr->str) - 1)));
@@ -145,9 +145,9 @@ static void test_addr_init_str(test_addr *addr) {
   }
 }
 
-static void on_connect(grpc_exec_ctx *exec_ctx, void *arg, grpc_endpoint *tcp,
-                       grpc_pollset *pollset,
-                       grpc_tcp_server_acceptor *acceptor) {
+static void on_connect(grpc_exec_ctx* exec_ctx, void* arg, grpc_endpoint* tcp,
+                       grpc_pollset* pollset,
+                       grpc_tcp_server_acceptor* acceptor) {
   grpc_endpoint_shutdown(exec_ctx, tcp,
                          GRPC_ERROR_CREATE_FROM_STATIC_STRING("Connected"));
   grpc_endpoint_destroy(exec_ctx, tcp);
@@ -159,27 +159,27 @@ static void on_connect(grpc_exec_ctx *exec_ctx, void *arg, grpc_endpoint *tcp,
   gpr_mu_lock(g_mu);
   g_result = temp_result;
   g_nconnects++;
-  GPR_ASSERT(GRPC_LOG_IF_ERROR("pollset_kick",
-                               grpc_pollset_kick(exec_ctx, g_pollset, NULL)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR(
+      "pollset_kick", grpc_pollset_kick(exec_ctx, g_pollset, nullptr)));
   gpr_mu_unlock(g_mu);
 }
 
 static void test_no_op(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_tcp_server *s;
+  grpc_tcp_server* s;
   GPR_ASSERT(GRPC_ERROR_NONE ==
-             grpc_tcp_server_create(&exec_ctx, NULL, NULL, &s));
+             grpc_tcp_server_create(&exec_ctx, nullptr, nullptr, &s));
   grpc_tcp_server_unref(&exec_ctx, s);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
 static void test_no_op_with_start(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_tcp_server *s;
+  grpc_tcp_server* s;
   GPR_ASSERT(GRPC_ERROR_NONE ==
-             grpc_tcp_server_create(&exec_ctx, NULL, NULL, &s));
+             grpc_tcp_server_create(&exec_ctx, nullptr, nullptr, &s));
   LOG_TEST("test_no_op_with_start");
-  grpc_tcp_server_start(&exec_ctx, s, NULL, 0, on_connect, NULL);
+  grpc_tcp_server_start(&exec_ctx, s, nullptr, 0, on_connect, nullptr);
   grpc_tcp_server_unref(&exec_ctx, s);
   grpc_exec_ctx_finish(&exec_ctx);
 }
@@ -187,10 +187,10 @@ static void test_no_op_with_start(void) {
 static void test_no_op_with_port(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_resolved_address resolved_addr;
-  struct sockaddr_in *addr = (struct sockaddr_in *)resolved_addr.addr;
-  grpc_tcp_server *s;
+  struct sockaddr_in* addr = (struct sockaddr_in*)resolved_addr.addr;
+  grpc_tcp_server* s;
   GPR_ASSERT(GRPC_ERROR_NONE ==
-             grpc_tcp_server_create(&exec_ctx, NULL, NULL, &s));
+             grpc_tcp_server_create(&exec_ctx, nullptr, nullptr, &s));
   LOG_TEST("test_no_op_with_port");
 
   memset(&resolved_addr, 0, sizeof(resolved_addr));
@@ -208,10 +208,10 @@ static void test_no_op_with_port(void) {
 static void test_no_op_with_port_and_start(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_resolved_address resolved_addr;
-  struct sockaddr_in *addr = (struct sockaddr_in *)resolved_addr.addr;
-  grpc_tcp_server *s;
+  struct sockaddr_in* addr = (struct sockaddr_in*)resolved_addr.addr;
+  grpc_tcp_server* s;
   GPR_ASSERT(GRPC_ERROR_NONE ==
-             grpc_tcp_server_create(&exec_ctx, NULL, NULL, &s));
+             grpc_tcp_server_create(&exec_ctx, nullptr, nullptr, &s));
   LOG_TEST("test_no_op_with_port_and_start");
   int port = -1;
 
@@ -222,20 +222,20 @@ static void test_no_op_with_port_and_start(void) {
                  GRPC_ERROR_NONE &&
              port > 0);
 
-  grpc_tcp_server_start(&exec_ctx, s, NULL, 0, on_connect, NULL);
+  grpc_tcp_server_start(&exec_ctx, s, nullptr, 0, on_connect, nullptr);
 
   grpc_tcp_server_unref(&exec_ctx, s);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static grpc_error *tcp_connect(grpc_exec_ctx *exec_ctx, const test_addr *remote,
-                               on_connect_result *result) {
+static grpc_error* tcp_connect(grpc_exec_ctx* exec_ctx, const test_addr* remote,
+                               on_connect_result* result) {
   grpc_millis deadline =
       grpc_timespec_to_millis_round_up(grpc_timeout_seconds_to_deadline(10));
   int clifd;
   int nconnects_before;
-  const struct sockaddr *remote_addr =
-      (const struct sockaddr *)remote->addr.addr;
+  const struct sockaddr* remote_addr =
+      (const struct sockaddr*)remote->addr.addr;
 
   gpr_log(GPR_INFO, "Connecting to %s", remote->str);
   gpr_mu_lock(g_mu);
@@ -255,8 +255,8 @@ static grpc_error *tcp_connect(grpc_exec_ctx *exec_ctx, const test_addr *remote,
   gpr_log(GPR_DEBUG, "wait");
   while (g_nconnects == nconnects_before &&
          deadline > grpc_exec_ctx_now(exec_ctx)) {
-    grpc_pollset_worker *worker = NULL;
-    grpc_error *err;
+    grpc_pollset_worker* worker = nullptr;
+    grpc_error* err;
     if ((err = grpc_pollset_work(exec_ctx, g_pollset, &worker, deadline)) !=
         GRPC_ERROR_NONE) {
       gpr_mu_unlock(g_mu);
@@ -290,24 +290,24 @@ static grpc_error *tcp_connect(grpc_exec_ctx *exec_ctx, const test_addr *remote,
    each destination address, set grpc_resolved_address::len=0 for failures, but
    don't fail the overall unitest. */
 static void test_connect(size_t num_connects,
-                         const grpc_channel_args *channel_args,
-                         test_addrs *dst_addrs, bool test_dst_addrs) {
+                         const grpc_channel_args* channel_args,
+                         test_addrs* dst_addrs, bool test_dst_addrs) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_resolved_address resolved_addr;
   grpc_resolved_address resolved_addr1;
-  struct sockaddr_storage *const addr =
-      (struct sockaddr_storage *)resolved_addr.addr;
-  struct sockaddr_storage *const addr1 =
-      (struct sockaddr_storage *)resolved_addr1.addr;
+  struct sockaddr_storage* const addr =
+      (struct sockaddr_storage*)resolved_addr.addr;
+  struct sockaddr_storage* const addr1 =
+      (struct sockaddr_storage*)resolved_addr1.addr;
   unsigned svr_fd_count;
   int port;
   int svr_port;
   unsigned svr1_fd_count;
   int svr1_port;
-  grpc_tcp_server *s;
+  grpc_tcp_server* s;
   const unsigned num_ports = 2;
   GPR_ASSERT(GRPC_ERROR_NONE ==
-             grpc_tcp_server_create(&exec_ctx, NULL, channel_args, &s));
+             grpc_tcp_server_create(&exec_ctx, nullptr, channel_args, &s));
   unsigned port_num;
   server_weak_ref weak_ref;
   server_weak_ref_init(&weak_ref);
@@ -316,8 +316,8 @@ static void test_connect(size_t num_connects,
   gpr_log(GPR_INFO,
           "clients=%lu, num chan args=%lu, remote IP=%s, test_dst_addrs=%d",
           (unsigned long)num_connects,
-          (unsigned long)(channel_args != NULL ? channel_args->num_args : 0),
-          dst_addrs != NULL ? "<specific>" : "::", test_dst_addrs);
+          (unsigned long)(channel_args != nullptr ? channel_args->num_args : 0),
+          dst_addrs != nullptr ? "<specific>" : "::", test_dst_addrs);
   memset(&resolved_addr, 0, sizeof(resolved_addr));
   memset(&resolved_addr1, 0, sizeof(resolved_addr1));
   resolved_addr.len = sizeof(struct sockaddr_storage);
@@ -352,9 +352,9 @@ static void test_connect(size_t num_connects,
   svr1_fd_count = grpc_tcp_server_port_fd_count(s, 1);
   GPR_ASSERT(svr1_fd_count >= 1);
 
-  grpc_tcp_server_start(&exec_ctx, s, &g_pollset, 1, on_connect, NULL);
+  grpc_tcp_server_start(&exec_ctx, s, &g_pollset, 1, on_connect, nullptr);
 
-  if (dst_addrs != NULL) {
+  if (dst_addrs != nullptr) {
     int ports[] = {svr_port, svr1_port};
     for (port_num = 0; port_num < num_ports; ++port_num) {
       size_t dst_idx;
@@ -362,7 +362,7 @@ static void test_connect(size_t num_connects,
       for (dst_idx = 0; dst_idx < dst_addrs->naddrs; ++dst_idx) {
         test_addr dst = dst_addrs->addrs[dst_idx];
         on_connect_result result;
-        grpc_error *err;
+        grpc_error* err;
         if (dst.addr.len == 0) {
           gpr_log(GPR_DEBUG, "Skipping test of non-functional local IP %s",
                   dst.str);
@@ -394,8 +394,8 @@ static void test_connect(size_t num_connects,
         test_addr dst;
         GPR_ASSERT(fd >= 0);
         dst.addr.len = sizeof(dst.addr.addr);
-        GPR_ASSERT(getsockname(fd, (struct sockaddr *)dst.addr.addr,
-                               (socklen_t *)&dst.addr.len) == 0);
+        GPR_ASSERT(getsockname(fd, (struct sockaddr*)dst.addr.addr,
+                               (socklen_t*)&dst.addr.len) == 0);
         GPR_ASSERT(dst.addr.len <= sizeof(dst.addr.addr));
         test_addr_init_str(&dst);
         gpr_log(GPR_INFO, "(%d, %d) fd %d family %s listening on %s", port_num,
@@ -417,34 +417,37 @@ static void test_connect(size_t num_connects,
     }
   }
   /* Weak ref to server valid until final unref. */
-  GPR_ASSERT(weak_ref.server != NULL);
+  GPR_ASSERT(weak_ref.server != nullptr);
   GPR_ASSERT(grpc_tcp_server_port_fd(s, 0, 0) >= 0);
 
   grpc_tcp_server_unref(&exec_ctx, s);
   grpc_exec_ctx_finish(&exec_ctx);
 
   /* Weak ref lost. */
-  GPR_ASSERT(weak_ref.server == NULL);
+  GPR_ASSERT(weak_ref.server == nullptr);
 }
 
-static void destroy_pollset(grpc_exec_ctx *exec_ctx, void *p,
-                            grpc_error *error) {
-  grpc_pollset_destroy(exec_ctx, p);
+static void destroy_pollset(grpc_exec_ctx* exec_ctx, void* p,
+                            grpc_error* error) {
+  grpc_pollset_destroy(exec_ctx, static_cast<grpc_pollset*>(p));
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_closure destroyed;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_arg chan_args[] = {
-      {GRPC_ARG_INTEGER, GRPC_ARG_EXPAND_WILDCARD_ADDRS, {.integer = 1}}};
+  grpc_arg chan_args[1];
+  chan_args[0].type = GRPC_ARG_INTEGER;
+  chan_args[0].key = const_cast<char*>(GRPC_ARG_EXPAND_WILDCARD_ADDRS);
+  chan_args[0].value.integer = 1;
   const grpc_channel_args channel_args = {1, chan_args};
-  struct ifaddrs *ifa = NULL;
-  struct ifaddrs *ifa_it;
+  struct ifaddrs* ifa = nullptr;
+  struct ifaddrs* ifa_it;
   // Zalloc dst_addrs to avoid oversized frames.
-  test_addrs *dst_addrs = gpr_zalloc(sizeof(*dst_addrs));
+  test_addrs* dst_addrs =
+      static_cast<test_addrs*>(gpr_zalloc(sizeof(*dst_addrs)));
   grpc_test_init(argc, argv);
   grpc_init();
-  g_pollset = gpr_zalloc(grpc_pollset_size());
+  g_pollset = static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
   grpc_pollset_init(g_pollset, &g_mu);
 
   test_no_op();
@@ -452,14 +455,14 @@ int main(int argc, char **argv) {
   test_no_op_with_port();
   test_no_op_with_port_and_start();
 
-  if (getifaddrs(&ifa) != 0 || ifa == NULL) {
+  if (getifaddrs(&ifa) != 0 || ifa == nullptr) {
     gpr_log(GPR_ERROR, "getifaddrs: %s", strerror(errno));
     return EXIT_FAILURE;
   }
   dst_addrs->naddrs = 0;
-  for (ifa_it = ifa; ifa_it != NULL && dst_addrs->naddrs < MAX_ADDRS;
+  for (ifa_it = ifa; ifa_it != nullptr && dst_addrs->naddrs < MAX_ADDRS;
        ifa_it = ifa_it->ifa_next) {
-    if (ifa_it->ifa_addr == NULL) {
+    if (ifa_it->ifa_addr == nullptr) {
       continue;
     } else if (ifa_it->ifa_addr->sa_family == AF_INET) {
       dst_addrs->addrs[dst_addrs->naddrs].addr.len = sizeof(struct sockaddr_in);
@@ -477,15 +480,15 @@ int main(int argc, char **argv) {
     ++dst_addrs->naddrs;
   }
   freeifaddrs(ifa);
-  ifa = NULL;
+  ifa = nullptr;
 
   /* Connect to same addresses as listeners. */
-  test_connect(1, NULL, NULL, false);
-  test_connect(10, NULL, NULL, false);
+  test_connect(1, nullptr, nullptr, false);
+  test_connect(10, nullptr, nullptr, false);
 
   /* Set dst_addrs->addrs[i].len=0 for dst_addrs that are unreachable with a
      "::" listener. */
-  test_connect(1, NULL, dst_addrs, true);
+  test_connect(1, nullptr, dst_addrs, true);
 
   /* Test connect(2) with dst_addrs. */
   test_connect(1, &channel_args, dst_addrs, false);
@@ -504,6 +507,6 @@ int main(int argc, char **argv) {
 
 #else /* GRPC_POSIX_SOCKET */
 
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
 
 #endif /* GRPC_POSIX_SOCKET */
diff --git a/test/core/iomgr/tcp_server_uv_test.c b/test/core/iomgr/tcp_server_uv_test.cc
index 9fafd3177a..dd047a0498 100644
--- a/test/core/iomgr/tcp_server_uv_test.c
+++ b/test/core/iomgr/tcp_server_uv_test.cc
@@ -41,19 +41,19 @@
 
 #define LOG_TEST(x) gpr_log(GPR_INFO, "%s", #x)
 
-static gpr_mu *g_mu;
-static grpc_pollset *g_pollset;
+static gpr_mu* g_mu;
+static grpc_pollset* g_pollset;
 static int g_nconnects = 0;
 
 typedef struct on_connect_result {
   /* Owns a ref to server. */
-  grpc_tcp_server *server;
+  grpc_tcp_server* server;
   unsigned port_index;
   unsigned fd_index;
 } on_connect_result;
 
 typedef struct server_weak_ref {
-  grpc_tcp_server *server;
+  grpc_tcp_server* server;
 
   /* arg is this server_weak_ref. */
   grpc_closure server_shutdown;
@@ -61,26 +61,26 @@ typedef struct server_weak_ref {
 
 static on_connect_result g_result = {NULL, 0, 0};
 
-static void on_connect_result_init(on_connect_result *result) {
+static void on_connect_result_init(on_connect_result* result) {
   result->server = NULL;
   result->port_index = 0;
   result->fd_index = 0;
 }
 
-static void on_connect_result_set(on_connect_result *result,
-                                  const grpc_tcp_server_acceptor *acceptor) {
+static void on_connect_result_set(on_connect_result* result,
+                                  const grpc_tcp_server_acceptor* acceptor) {
   result->server = grpc_tcp_server_ref(acceptor->from_server);
   result->port_index = acceptor->port_index;
   result->fd_index = acceptor->fd_index;
 }
 
-static void server_weak_ref_shutdown(grpc_exec_ctx *exec_ctx, void *arg,
-                                     grpc_error *error) {
-  server_weak_ref *weak_ref = arg;
+static void server_weak_ref_shutdown(grpc_exec_ctx* exec_ctx, void* arg,
+                                     grpc_error* error) {
+  server_weak_ref* weak_ref = static_cast<server_weak_ref*>(arg);
   weak_ref->server = NULL;
 }
 
-static void server_weak_ref_init(server_weak_ref *weak_ref) {
+static void server_weak_ref_init(server_weak_ref* weak_ref) {
   weak_ref->server = NULL;
   GRPC_CLOSURE_INIT(&weak_ref->server_shutdown, server_weak_ref_shutdown,
                     weak_ref, grpc_schedule_on_exec_ctx);
@@ -91,15 +91,15 @@ static void server_weak_ref_init(server_weak_ref *weak_ref) {
    weak_ref->server_shutdown has returned. A strong ref on grpc_tcp_server
    should be held until server_weak_ref_set() returns to avoid a race where the
    server is deleted before the shutdown_starting cb is added. */
-static void server_weak_ref_set(server_weak_ref *weak_ref,
-                                grpc_tcp_server *server) {
+static void server_weak_ref_set(server_weak_ref* weak_ref,
+                                grpc_tcp_server* server) {
   grpc_tcp_server_shutdown_starting_add(server, &weak_ref->server_shutdown);
   weak_ref->server = server;
 }
 
-static void on_connect(grpc_exec_ctx *exec_ctx, void *arg, grpc_endpoint *tcp,
-                       grpc_pollset *pollset,
-                       grpc_tcp_server_acceptor *acceptor) {
+static void on_connect(grpc_exec_ctx* exec_ctx, void* arg, grpc_endpoint* tcp,
+                       grpc_pollset* pollset,
+                       grpc_tcp_server_acceptor* acceptor) {
   grpc_endpoint_shutdown(exec_ctx, tcp,
                          GRPC_ERROR_CREATE_FROM_STATIC_STRING("Connected"));
   grpc_endpoint_destroy(exec_ctx, tcp);
@@ -118,7 +118,7 @@ static void on_connect(grpc_exec_ctx *exec_ctx, void *arg, grpc_endpoint *tcp,
 
 static void test_no_op(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_tcp_server *s;
+  grpc_tcp_server* s;
   GPR_ASSERT(GRPC_ERROR_NONE ==
              grpc_tcp_server_create(&exec_ctx, NULL, NULL, &s));
   grpc_tcp_server_unref(&exec_ctx, s);
@@ -127,7 +127,7 @@ static void test_no_op(void) {
 
 static void test_no_op_with_start(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_tcp_server *s;
+  grpc_tcp_server* s;
   GPR_ASSERT(GRPC_ERROR_NONE ==
              grpc_tcp_server_create(&exec_ctx, NULL, NULL, &s));
   LOG_TEST("test_no_op_with_start");
@@ -139,8 +139,8 @@ static void test_no_op_with_start(void) {
 static void test_no_op_with_port(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_resolved_address resolved_addr;
-  struct sockaddr_in *addr = (struct sockaddr_in *)resolved_addr.addr;
-  grpc_tcp_server *s;
+  struct sockaddr_in* addr = (struct sockaddr_in*)resolved_addr.addr;
+  grpc_tcp_server* s;
   GPR_ASSERT(GRPC_ERROR_NONE ==
              grpc_tcp_server_create(&exec_ctx, NULL, NULL, &s));
   LOG_TEST("test_no_op_with_port");
@@ -160,8 +160,8 @@ static void test_no_op_with_port(void) {
 static void test_no_op_with_port_and_start(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_resolved_address resolved_addr;
-  struct sockaddr_in *addr = (struct sockaddr_in *)resolved_addr.addr;
-  grpc_tcp_server *s;
+  struct sockaddr_in* addr = (struct sockaddr_in*)resolved_addr.addr;
+  grpc_tcp_server* s;
   GPR_ASSERT(GRPC_ERROR_NONE ==
              grpc_tcp_server_create(&exec_ctx, NULL, NULL, &s));
   LOG_TEST("test_no_op_with_port_and_start");
@@ -180,18 +180,20 @@ static void test_no_op_with_port_and_start(void) {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void connect_cb(uv_connect_t *req, int status) {
+static void connect_cb(uv_connect_t* req, int status) {
   GPR_ASSERT(status == 0);
   gpr_free(req);
 }
 
-static void close_cb(uv_handle_t *handle) { gpr_free(handle); }
+static void close_cb(uv_handle_t* handle) { gpr_free(handle); }
 
-static void tcp_connect(grpc_exec_ctx *exec_ctx, const struct sockaddr *remote,
-                        socklen_t remote_len, on_connect_result *result) {
+static void tcp_connect(grpc_exec_ctx* exec_ctx, const struct sockaddr* remote,
+                        socklen_t remote_len, on_connect_result* result) {
   gpr_timespec deadline = grpc_timeout_seconds_to_deadline(10);
-  uv_tcp_t *client_handle = gpr_malloc(sizeof(uv_tcp_t));
-  uv_connect_t *req = gpr_malloc(sizeof(uv_connect_t));
+  uv_tcp_t* client_handle =
+      static_cast<uv_tcp_t*>(gpr_malloc(sizeof(uv_tcp_t)));
+  uv_connect_t* req =
+      static_cast<uv_connect_t*>(gpr_malloc(sizeof(uv_connect_t)));
   int nconnects_before;
 
   gpr_mu_lock(g_mu);
@@ -203,7 +205,7 @@ static void tcp_connect(grpc_exec_ctx *exec_ctx, const struct sockaddr *remote,
   gpr_log(GPR_DEBUG, "wait");
   while (g_nconnects == nconnects_before &&
          gpr_time_cmp(deadline, gpr_now(deadline.clock_type)) > 0) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = NULL;
     GPR_ASSERT(GRPC_LOG_IF_ERROR(
         "pollset_work",
         grpc_pollset_work(exec_ctx, g_pollset, &worker,
@@ -214,7 +216,7 @@ static void tcp_connect(grpc_exec_ctx *exec_ctx, const struct sockaddr *remote,
   }
   gpr_log(GPR_DEBUG, "wait done");
   GPR_ASSERT(g_nconnects == nconnects_before + 1);
-  uv_close((uv_handle_t *)client_handle, close_cb);
+  uv_close((uv_handle_t*)client_handle, close_cb);
   *result = g_result;
 
   gpr_mu_unlock(g_mu);
@@ -225,12 +227,12 @@ static void test_connect(unsigned n) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_resolved_address resolved_addr;
   grpc_resolved_address resolved_addr1;
-  struct sockaddr_storage *addr = (struct sockaddr_storage *)resolved_addr.addr;
-  struct sockaddr_storage *addr1 =
-      (struct sockaddr_storage *)resolved_addr1.addr;
+  struct sockaddr_storage* addr = (struct sockaddr_storage*)resolved_addr.addr;
+  struct sockaddr_storage* addr1 =
+      (struct sockaddr_storage*)resolved_addr1.addr;
   int svr_port;
   int svr1_port;
-  grpc_tcp_server *s;
+  grpc_tcp_server* s;
   GPR_ASSERT(GRPC_ERROR_NONE ==
              grpc_tcp_server_create(&exec_ctx, NULL, NULL, &s));
   unsigned i;
@@ -246,7 +248,7 @@ static void test_connect(unsigned n) {
   GPR_ASSERT(GRPC_ERROR_NONE ==
              grpc_tcp_server_add_port(s, &resolved_addr, &svr_port));
   GPR_ASSERT(svr_port > 0);
-  GPR_ASSERT((uv_ip6_addr("::", svr_port, (struct sockaddr_in6 *)addr)) == 0);
+  GPR_ASSERT((uv_ip6_addr("::", svr_port, (struct sockaddr_in6*)addr)) == 0);
   /* Cannot use wildcard (port==0), because add_port() will try to reuse the
      same port as a previous add_port(). */
   svr1_port = grpc_pick_unused_port_or_die();
@@ -257,13 +259,13 @@ static void test_connect(unsigned n) {
 
   grpc_tcp_server_start(&exec_ctx, s, &g_pollset, 1, on_connect, NULL);
 
-  GPR_ASSERT(uv_ip6_addr("::", svr_port, (struct sockaddr_in6 *)addr1) == 0);
+  GPR_ASSERT(uv_ip6_addr("::", svr_port, (struct sockaddr_in6*)addr1) == 0);
 
   for (i = 0; i < n; i++) {
     on_connect_result result;
     on_connect_result_init(&result);
-    tcp_connect(&exec_ctx, (struct sockaddr *)addr,
-                (socklen_t)resolved_addr.len, &result);
+    tcp_connect(&exec_ctx, (struct sockaddr*)addr, (socklen_t)resolved_addr.len,
+                &result);
     GPR_ASSERT(result.port_index == 0);
     GPR_ASSERT(result.server == s);
     if (weak_ref.server == NULL) {
@@ -272,7 +274,7 @@ static void test_connect(unsigned n) {
     grpc_tcp_server_unref(&exec_ctx, result.server);
 
     on_connect_result_init(&result);
-    tcp_connect(&exec_ctx, (struct sockaddr *)addr1,
+    tcp_connect(&exec_ctx, (struct sockaddr*)addr1,
                 (socklen_t)resolved_addr1.len, &result);
     GPR_ASSERT(result.port_index == 1);
     GPR_ASSERT(result.server == s);
@@ -289,17 +291,17 @@ static void test_connect(unsigned n) {
   GPR_ASSERT(weak_ref.server == NULL);
 }
 
-static void destroy_pollset(grpc_exec_ctx *exec_ctx, void *p,
-                            grpc_error *error) {
-  grpc_pollset_destroy(exec_ctx, p);
+static void destroy_pollset(grpc_exec_ctx* exec_ctx, void* p,
+                            grpc_error* error) {
+  grpc_pollset_destroy(exec_ctx, static_cast<grpc_pollset*>(p));
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_closure destroyed;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_test_init(argc, argv);
   grpc_init();
-  g_pollset = gpr_malloc(grpc_pollset_size());
+  g_pollset = static_cast<grpc_pollset*>(gpr_malloc(grpc_pollset_size()));
   grpc_pollset_init(g_pollset, &g_mu);
 
   test_no_op();
@@ -320,6 +322,6 @@ int main(int argc, char **argv) {
 
 #else /* GRPC_UV */
 
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
 
 #endif /* GRPC_UV */
diff --git a/test/core/iomgr/time_averaged_stats_test.c b/test/core/iomgr/time_averaged_stats_test.cc
index 508e3c5bf8..b932e62d1f 100644
--- a/test/core/iomgr/time_averaged_stats_test.c
+++ b/test/core/iomgr/time_averaged_stats_test.cc
@@ -179,7 +179,7 @@ static void some_regress_some_persist_test(void) {
   EXPECT_DOUBLE_EQ(2.8304, tas.aggregate_total_weight);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   no_regress_no_persist_test_1();
   no_regress_no_persist_test_2();
diff --git a/test/core/iomgr/timer_heap_test.c b/test/core/iomgr/timer_heap_test.cc
index ee5a474fd1..f0ab4343cb 100644
--- a/test/core/iomgr/timer_heap_test.c
+++ b/test/core/iomgr/timer_heap_test.cc
@@ -34,8 +34,9 @@
 
 static gpr_atm random_deadline(void) { return rand(); }
 
-static grpc_timer *create_test_elements(size_t num_elements) {
-  grpc_timer *elems = gpr_malloc(num_elements * sizeof(grpc_timer));
+static grpc_timer* create_test_elements(size_t num_elements) {
+  grpc_timer* elems =
+      static_cast<grpc_timer*>(gpr_malloc(num_elements * sizeof(grpc_timer)));
   size_t i;
   for (i = 0; i < num_elements; i++) {
     elems[i].deadline = random_deadline();
@@ -43,7 +44,7 @@ static grpc_timer *create_test_elements(size_t num_elements) {
   return elems;
 }
 
-static int contains(grpc_timer_heap *pq, grpc_timer *el) {
+static int contains(grpc_timer_heap* pq, grpc_timer* el) {
   size_t i;
   for (i = 0; i < pq->timer_count; i++) {
     if (pq->timers[i] == el) return 1;
@@ -51,7 +52,7 @@ static int contains(grpc_timer_heap *pq, grpc_timer *el) {
   return 0;
 }
 
-static void check_valid(grpc_timer_heap *pq) {
+static void check_valid(grpc_timer_heap* pq) {
   size_t i;
   for (i = 0; i < pq->timer_count; ++i) {
     size_t left_child = 1u + 2u * i;
@@ -74,8 +75,8 @@ static void test1(void) {
   const size_t num_test_elements = 200;
   const size_t num_test_operations = 10000;
   size_t i;
-  grpc_timer *test_elements = create_test_elements(num_test_elements);
-  uint8_t *inpq = gpr_malloc(num_test_elements);
+  grpc_timer* test_elements = create_test_elements(num_test_elements);
+  uint8_t* inpq = static_cast<uint8_t*>(gpr_malloc(num_test_elements));
 
   gpr_log(GPR_INFO, "test1");
 
@@ -102,7 +103,7 @@ static void test1(void) {
 
   for (i = 0; i < num_test_operations; ++i) {
     size_t elem_num = (size_t)rand() % num_test_elements;
-    grpc_timer *el = &test_elements[elem_num];
+    grpc_timer* el = &test_elements[elem_num];
     if (!inpq[elem_num]) { /* not in pq */
       GPR_ASSERT(!contains(&pq, el));
       el->deadline = random_deadline();
@@ -133,9 +134,10 @@ typedef struct {
   bool inserted;
 } elem_struct;
 
-static elem_struct *search_elems(elem_struct *elems, size_t count,
+static elem_struct* search_elems(elem_struct* elems, size_t count,
                                  bool inserted) {
-  size_t *search_order = gpr_malloc(count * sizeof(*search_order));
+  size_t* search_order =
+      static_cast<size_t*>(gpr_malloc(count * sizeof(*search_order)));
   for (size_t i = 0; i < count; i++) {
     search_order[i] = i;
   }
@@ -144,8 +146,8 @@ static elem_struct *search_elems(elem_struct *elems, size_t count,
     size_t b = (size_t)rand() % count;
     GPR_SWAP(size_t, search_order[a], search_order[b]);
   }
-  elem_struct *out = NULL;
-  for (size_t i = 0; out == NULL && i < count; i++) {
+  elem_struct* out = nullptr;
+  for (size_t i = 0; out == nullptr && i < count; i++) {
     if (elems[search_order[i]].inserted == inserted) {
       out = &elems[search_order[i]];
     }
@@ -160,7 +162,8 @@ static void test2(void) {
   grpc_timer_heap pq;
 
   static const size_t elems_size = 1000;
-  elem_struct *elems = gpr_malloc(elems_size * sizeof(elem_struct));
+  elem_struct* elems =
+      static_cast<elem_struct*>(gpr_malloc(elems_size * sizeof(elem_struct)));
   size_t num_inserted = 0;
 
   grpc_timer_heap_init(&pq);
@@ -170,8 +173,8 @@ static void test2(void) {
     int r = rand() % 1000;
     if (r <= 550) {
       /* 55% of the time we try to add something */
-      elem_struct *el = search_elems(elems, GPR_ARRAY_SIZE(elems), false);
-      if (el != NULL) {
+      elem_struct* el = search_elems(elems, GPR_ARRAY_SIZE(elems), false);
+      if (el != nullptr) {
         el->elem.deadline = random_deadline();
         grpc_timer_heap_add(&pq, &el->elem);
         el->inserted = true;
@@ -180,8 +183,8 @@ static void test2(void) {
       }
     } else if (r <= 650) {
       /* 10% of the time we try to remove something */
-      elem_struct *el = search_elems(elems, GPR_ARRAY_SIZE(elems), true);
-      if (el != NULL) {
+      elem_struct* el = search_elems(elems, GPR_ARRAY_SIZE(elems), true);
+      if (el != nullptr) {
         grpc_timer_heap_remove(&pq, &el->elem);
         el->inserted = false;
         num_inserted--;
@@ -190,7 +193,7 @@ static void test2(void) {
     } else {
       /* the remaining times we pop */
       if (num_inserted > 0) {
-        grpc_timer *top = grpc_timer_heap_top(&pq);
+        grpc_timer* top = grpc_timer_heap_top(&pq);
         grpc_timer_heap_pop(&pq);
         for (size_t i = 0; i < elems_size; i++) {
           if (top == &elems[i].elem) {
@@ -204,10 +207,10 @@ static void test2(void) {
     }
 
     if (num_inserted) {
-      gpr_atm *min_deadline = NULL;
+      gpr_atm* min_deadline = nullptr;
       for (size_t i = 0; i < elems_size; i++) {
         if (elems[i].inserted) {
-          if (min_deadline == NULL) {
+          if (min_deadline == nullptr) {
             min_deadline = &elems[i].elem.deadline;
           } else {
             if (elems[i].elem.deadline < *min_deadline) {
@@ -246,7 +249,7 @@ static void shrink_test(void) {
 
   /* Remove elements until the Size is 1/4 the original size. */
   while (pq.timer_count > num_elements / 4) {
-    grpc_timer *const te = pq.timers[pq.timer_count - 1];
+    grpc_timer* const te = pq.timers[pq.timer_count - 1];
     grpc_timer_heap_remove(&pq, te);
     gpr_free(te);
   }
@@ -263,7 +266,7 @@ static void shrink_test(void) {
   expected_size = pq.timer_count;
   while (pq.timer_count > 0) {
     const size_t which = (size_t)rand() % pq.timer_count;
-    grpc_timer *te = pq.timers[which];
+    grpc_timer* te = pq.timers[which];
     grpc_timer_heap_remove(&pq, te);
     gpr_free(te);
     expected_size--;
@@ -283,7 +286,7 @@ static void shrink_test(void) {
   grpc_timer_heap_destroy(&pq);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   int i;
 
   grpc_test_init(argc, argv);
@@ -299,6 +302,6 @@ int main(int argc, char **argv) {
 
 #else /* GRPC_TIMER_USE_GENERIC */
 
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
 
 #endif /* GRPC_TIMER_USE_GENERIC */
diff --git a/test/core/iomgr/timer_list_test.c b/test/core/iomgr/timer_list_test.cc
index c3d9f9d88d..d74ea4fc96 100644
--- a/test/core/iomgr/timer_list_test.c
+++ b/test/core/iomgr/timer_list_test.cc
@@ -28,15 +28,16 @@
 #include <grpc/support/log.h>
 #include "src/core/lib/debug/trace.h"
 #include "test/core/util/test_config.h"
+#include "test/core/util/tracer_util.h"
 
 #define MAX_CB 30
 
-extern grpc_tracer_flag grpc_timer_trace;
-extern grpc_tracer_flag grpc_timer_check_trace;
+extern grpc_core::TraceFlag grpc_timer_trace;
+extern grpc_core::TraceFlag grpc_timer_check_trace;
 
 static int cb_called[MAX_CB][2];
 
-static void cb(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
+static void cb(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
   cb_called[(intptr_t)arg][error == GRPC_ERROR_NONE]++;
 }
 
@@ -48,29 +49,29 @@ static void add_test(void) {
   gpr_log(GPR_INFO, "add_test");
 
   grpc_timer_list_init(&exec_ctx);
-  grpc_timer_trace.value = 1;
-  grpc_timer_check_trace.value = 1;
+  grpc_core::testing::grpc_tracer_enable_flag(&grpc_timer_trace);
+  grpc_core::testing::grpc_tracer_enable_flag(&grpc_timer_check_trace);
   memset(cb_called, 0, sizeof(cb_called));
 
   grpc_millis start = grpc_exec_ctx_now(&exec_ctx);
 
   /* 10 ms timers.  will expire in the current epoch */
   for (i = 0; i < 10; i++) {
-    grpc_timer_init(&exec_ctx, &timers[i], start + 10,
-                    GRPC_CLOSURE_CREATE(cb, (void *)(intptr_t)i,
-                                        grpc_schedule_on_exec_ctx));
+    grpc_timer_init(
+        &exec_ctx, &timers[i], start + 10,
+        GRPC_CLOSURE_CREATE(cb, (void*)(intptr_t)i, grpc_schedule_on_exec_ctx));
   }
 
   /* 1010 ms timers.  will expire in the next epoch */
   for (i = 10; i < 20; i++) {
-    grpc_timer_init(&exec_ctx, &timers[i], start + 1010,
-                    GRPC_CLOSURE_CREATE(cb, (void *)(intptr_t)i,
-                                        grpc_schedule_on_exec_ctx));
+    grpc_timer_init(
+        &exec_ctx, &timers[i], start + 1010,
+        GRPC_CLOSURE_CREATE(cb, (void*)(intptr_t)i, grpc_schedule_on_exec_ctx));
   }
 
   /* collect timers.  Only the first batch should be ready. */
   exec_ctx.now = start + 500;
-  GPR_ASSERT(grpc_timer_check(&exec_ctx, NULL) == GRPC_TIMERS_FIRED);
+  GPR_ASSERT(grpc_timer_check(&exec_ctx, nullptr) == GRPC_TIMERS_FIRED);
   grpc_exec_ctx_finish(&exec_ctx);
   for (i = 0; i < 20; i++) {
     GPR_ASSERT(cb_called[i][1] == (i < 10));
@@ -78,7 +79,7 @@ static void add_test(void) {
   }
 
   exec_ctx.now = start + 600;
-  GPR_ASSERT(grpc_timer_check(&exec_ctx, NULL) ==
+  GPR_ASSERT(grpc_timer_check(&exec_ctx, nullptr) ==
              GRPC_TIMERS_CHECKED_AND_EMPTY);
   grpc_exec_ctx_finish(&exec_ctx);
   for (i = 0; i < 30; i++) {
@@ -88,7 +89,7 @@ static void add_test(void) {
 
   /* collect the rest of the timers */
   exec_ctx.now = start + 1500;
-  GPR_ASSERT(grpc_timer_check(&exec_ctx, NULL) == GRPC_TIMERS_FIRED);
+  GPR_ASSERT(grpc_timer_check(&exec_ctx, nullptr) == GRPC_TIMERS_FIRED);
   grpc_exec_ctx_finish(&exec_ctx);
   for (i = 0; i < 30; i++) {
     GPR_ASSERT(cb_called[i][1] == (i < 20));
@@ -96,7 +97,7 @@ static void add_test(void) {
   }
 
   exec_ctx.now = start + 1600;
-  GPR_ASSERT(grpc_timer_check(&exec_ctx, NULL) ==
+  GPR_ASSERT(grpc_timer_check(&exec_ctx, nullptr) ==
              GRPC_TIMERS_CHECKED_AND_EMPTY);
   for (i = 0; i < 30; i++) {
     GPR_ASSERT(cb_called[i][1] == (i < 20));
@@ -117,27 +118,27 @@ void destruction_test(void) {
   exec_ctx.now_is_valid = true;
   exec_ctx.now = 0;
   grpc_timer_list_init(&exec_ctx);
-  grpc_timer_trace.value = 1;
-  grpc_timer_check_trace.value = 1;
+  grpc_core::testing::grpc_tracer_enable_flag(&grpc_timer_trace);
+  grpc_core::testing::grpc_tracer_enable_flag(&grpc_timer_check_trace);
   memset(cb_called, 0, sizeof(cb_called));
 
   grpc_timer_init(
       &exec_ctx, &timers[0], 100,
-      GRPC_CLOSURE_CREATE(cb, (void *)(intptr_t)0, grpc_schedule_on_exec_ctx));
+      GRPC_CLOSURE_CREATE(cb, (void*)(intptr_t)0, grpc_schedule_on_exec_ctx));
   grpc_timer_init(
       &exec_ctx, &timers[1], 3,
-      GRPC_CLOSURE_CREATE(cb, (void *)(intptr_t)1, grpc_schedule_on_exec_ctx));
+      GRPC_CLOSURE_CREATE(cb, (void*)(intptr_t)1, grpc_schedule_on_exec_ctx));
   grpc_timer_init(
       &exec_ctx, &timers[2], 100,
-      GRPC_CLOSURE_CREATE(cb, (void *)(intptr_t)2, grpc_schedule_on_exec_ctx));
+      GRPC_CLOSURE_CREATE(cb, (void*)(intptr_t)2, grpc_schedule_on_exec_ctx));
   grpc_timer_init(
       &exec_ctx, &timers[3], 3,
-      GRPC_CLOSURE_CREATE(cb, (void *)(intptr_t)3, grpc_schedule_on_exec_ctx));
+      GRPC_CLOSURE_CREATE(cb, (void*)(intptr_t)3, grpc_schedule_on_exec_ctx));
   grpc_timer_init(
       &exec_ctx, &timers[4], 1,
-      GRPC_CLOSURE_CREATE(cb, (void *)(intptr_t)4, grpc_schedule_on_exec_ctx));
+      GRPC_CLOSURE_CREATE(cb, (void*)(intptr_t)4, grpc_schedule_on_exec_ctx));
   exec_ctx.now = 2;
-  GPR_ASSERT(grpc_timer_check(&exec_ctx, NULL) == GRPC_TIMERS_FIRED);
+  GPR_ASSERT(grpc_timer_check(&exec_ctx, nullptr) == GRPC_TIMERS_FIRED);
   grpc_exec_ctx_finish(&exec_ctx);
   GPR_ASSERT(1 == cb_called[4][1]);
   grpc_timer_cancel(&exec_ctx, &timers[0]);
@@ -152,7 +153,7 @@ void destruction_test(void) {
   GPR_ASSERT(1 == cb_called[2][0]);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   gpr_set_log_verbosity(GPR_LOG_SEVERITY_DEBUG);
   add_test();
@@ -162,6 +163,6 @@ int main(int argc, char **argv) {
 
 #else /* GRPC_TIMER_USE_GENERIC */
 
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
 
 #endif /* GRPC_TIMER_USE_GENERIC */
diff --git a/test/core/iomgr/udp_server_test.c b/test/core/iomgr/udp_server_test.cc
index 2e44d0abc8..803f017106 100644
--- a/test/core/iomgr/udp_server_test.c
+++ b/test/core/iomgr/udp_server_test.cc
@@ -43,14 +43,14 @@
 
 #define LOG_TEST(x) gpr_log(GPR_INFO, "%s", #x)
 
-static grpc_pollset *g_pollset;
-static gpr_mu *g_mu;
+static grpc_pollset* g_pollset;
+static gpr_mu* g_mu;
 static int g_number_of_reads = 0;
 static int g_number_of_writes = 0;
 static int g_number_of_bytes_read = 0;
 static int g_number_of_orphan_calls = 0;
 
-static void on_read(grpc_exec_ctx *exec_ctx, grpc_fd *emfd, void *user_data) {
+static void on_read(grpc_exec_ctx* exec_ctx, grpc_fd* emfd, void* user_data) {
   char read_buffer[512];
   ssize_t byte_count;
 
@@ -61,22 +61,22 @@ static void on_read(grpc_exec_ctx *exec_ctx, grpc_fd *emfd, void *user_data) {
   g_number_of_reads++;
   g_number_of_bytes_read += (int)byte_count;
 
-  GPR_ASSERT(GRPC_LOG_IF_ERROR("pollset_kick",
-                               grpc_pollset_kick(exec_ctx, g_pollset, NULL)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR(
+      "pollset_kick", grpc_pollset_kick(exec_ctx, g_pollset, nullptr)));
   gpr_mu_unlock(g_mu);
 }
 
-static void on_write(grpc_exec_ctx *exec_ctx, grpc_fd *emfd, void *user_data) {
+static void on_write(grpc_exec_ctx* exec_ctx, grpc_fd* emfd, void* user_data) {
   gpr_mu_lock(g_mu);
   g_number_of_writes++;
 
-  GPR_ASSERT(GRPC_LOG_IF_ERROR("pollset_kick",
-                               grpc_pollset_kick(exec_ctx, g_pollset, NULL)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR(
+      "pollset_kick", grpc_pollset_kick(exec_ctx, g_pollset, nullptr)));
   gpr_mu_unlock(g_mu);
 }
 
-static void on_fd_orphaned(grpc_exec_ctx *exec_ctx, grpc_fd *emfd,
-                           grpc_closure *closure, void *user_data) {
+static void on_fd_orphaned(grpc_exec_ctx* exec_ctx, grpc_fd* emfd,
+                           grpc_closure* closure, void* user_data) {
   gpr_log(GPR_INFO, "gRPC FD about to be orphaned: %d",
           grpc_fd_wrapped_fd(emfd));
   g_number_of_orphan_calls++;
@@ -89,27 +89,27 @@ struct test_socket_factory {
 };
 typedef struct test_socket_factory test_socket_factory;
 
-static int test_socket_factory_socket(grpc_socket_factory *factory, int domain,
+static int test_socket_factory_socket(grpc_socket_factory* factory, int domain,
                                       int type, int protocol) {
-  test_socket_factory *f = (test_socket_factory *)factory;
+  test_socket_factory* f = (test_socket_factory*)factory;
   f->number_of_socket_calls++;
   return socket(domain, type, protocol);
 }
 
-static int test_socket_factory_bind(grpc_socket_factory *factory, int sockfd,
-                                    const grpc_resolved_address *addr) {
-  test_socket_factory *f = (test_socket_factory *)factory;
+static int test_socket_factory_bind(grpc_socket_factory* factory, int sockfd,
+                                    const grpc_resolved_address* addr) {
+  test_socket_factory* f = (test_socket_factory*)factory;
   f->number_of_bind_calls++;
-  return bind(sockfd, (struct sockaddr *)addr->addr, (socklen_t)addr->len);
+  return bind(sockfd, (struct sockaddr*)addr->addr, (socklen_t)addr->len);
 }
 
-static int test_socket_factory_compare(grpc_socket_factory *a,
-                                       grpc_socket_factory *b) {
+static int test_socket_factory_compare(grpc_socket_factory* a,
+                                       grpc_socket_factory* b) {
   return GPR_ICMP(a, b);
 }
 
-static void test_socket_factory_destroy(grpc_socket_factory *factory) {
-  test_socket_factory *f = (test_socket_factory *)factory;
+static void test_socket_factory_destroy(grpc_socket_factory* factory) {
+  test_socket_factory* f = (test_socket_factory*)factory;
   gpr_free(f);
 }
 
@@ -117,8 +117,9 @@ static const grpc_socket_factory_vtable test_socket_factory_vtable = {
     test_socket_factory_socket, test_socket_factory_bind,
     test_socket_factory_compare, test_socket_factory_destroy};
 
-static test_socket_factory *test_socket_factory_create(void) {
-  test_socket_factory *factory = gpr_malloc(sizeof(test_socket_factory));
+static test_socket_factory* test_socket_factory_create(void) {
+  test_socket_factory* factory = static_cast<test_socket_factory*>(
+      gpr_malloc(sizeof(test_socket_factory)));
   grpc_socket_factory_init(&factory->base, &test_socket_factory_vtable);
   factory->number_of_socket_calls = 0;
   factory->number_of_bind_calls = 0;
@@ -127,17 +128,17 @@ static test_socket_factory *test_socket_factory_create(void) {
 
 static void test_no_op(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_udp_server *s = grpc_udp_server_create(NULL);
-  grpc_udp_server_destroy(&exec_ctx, s, NULL);
+  grpc_udp_server* s = grpc_udp_server_create(nullptr);
+  grpc_udp_server_destroy(&exec_ctx, s, nullptr);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
 static void test_no_op_with_start(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_udp_server *s = grpc_udp_server_create(NULL);
+  grpc_udp_server* s = grpc_udp_server_create(nullptr);
   LOG_TEST("test_no_op_with_start");
-  grpc_udp_server_start(&exec_ctx, s, NULL, 0, NULL);
-  grpc_udp_server_destroy(&exec_ctx, s, NULL);
+  grpc_udp_server_start(&exec_ctx, s, nullptr, 0, nullptr);
+  grpc_udp_server_destroy(&exec_ctx, s, nullptr);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
@@ -145,8 +146,8 @@ static void test_no_op_with_port(void) {
   g_number_of_orphan_calls = 0;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_resolved_address resolved_addr;
-  struct sockaddr_in *addr = (struct sockaddr_in *)resolved_addr.addr;
-  grpc_udp_server *s = grpc_udp_server_create(NULL);
+  struct sockaddr_in* addr = (struct sockaddr_in*)resolved_addr.addr;
+  grpc_udp_server* s = grpc_udp_server_create(nullptr);
   LOG_TEST("test_no_op_with_port");
 
   memset(&resolved_addr, 0, sizeof(resolved_addr));
@@ -155,7 +156,7 @@ static void test_no_op_with_port(void) {
   GPR_ASSERT(grpc_udp_server_add_port(s, &resolved_addr, on_read, on_write,
                                       on_fd_orphaned));
 
-  grpc_udp_server_destroy(&exec_ctx, s, NULL);
+  grpc_udp_server_destroy(&exec_ctx, s, nullptr);
   grpc_exec_ctx_finish(&exec_ctx);
 
   /* The server had a single FD, which should have been orphaned. */
@@ -166,14 +167,14 @@ static void test_no_op_with_port_and_socket_factory(void) {
   g_number_of_orphan_calls = 0;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   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;
 
-  test_socket_factory *socket_factory = test_socket_factory_create();
+  test_socket_factory* socket_factory = test_socket_factory_create();
   grpc_arg socket_factory_arg =
       grpc_socket_factory_to_arg(&socket_factory->base);
-  grpc_channel_args *channel_args =
-      grpc_channel_args_copy_and_add(NULL, &socket_factory_arg, 1);
-  grpc_udp_server *s = grpc_udp_server_create(channel_args);
+  grpc_channel_args* channel_args =
+      grpc_channel_args_copy_and_add(nullptr, &socket_factory_arg, 1);
+  grpc_udp_server* s = grpc_udp_server_create(channel_args);
   grpc_channel_args_destroy(&exec_ctx, channel_args);
 
   LOG_TEST("test_no_op_with_port_and_socket_factory");
@@ -186,7 +187,7 @@ static void test_no_op_with_port_and_socket_factory(void) {
   GPR_ASSERT(socket_factory->number_of_socket_calls == 1);
   GPR_ASSERT(socket_factory->number_of_bind_calls == 1);
 
-  grpc_udp_server_destroy(&exec_ctx, s, NULL);
+  grpc_udp_server_destroy(&exec_ctx, s, nullptr);
   grpc_exec_ctx_finish(&exec_ctx);
   grpc_socket_factory_unref(&socket_factory->base);
 
@@ -198,8 +199,8 @@ static void test_no_op_with_port_and_start(void) {
   g_number_of_orphan_calls = 0;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_resolved_address resolved_addr;
-  struct sockaddr_in *addr = (struct sockaddr_in *)resolved_addr.addr;
-  grpc_udp_server *s = grpc_udp_server_create(NULL);
+  struct sockaddr_in* addr = (struct sockaddr_in*)resolved_addr.addr;
+  grpc_udp_server* s = grpc_udp_server_create(nullptr);
   LOG_TEST("test_no_op_with_port_and_start");
 
   memset(&resolved_addr, 0, sizeof(resolved_addr));
@@ -208,9 +209,9 @@ static void test_no_op_with_port_and_start(void) {
   GPR_ASSERT(grpc_udp_server_add_port(s, &resolved_addr, on_read, on_write,
                                       on_fd_orphaned));
 
-  grpc_udp_server_start(&exec_ctx, s, NULL, 0, NULL);
+  grpc_udp_server_start(&exec_ctx, s, nullptr, 0, nullptr);
 
-  grpc_udp_server_destroy(&exec_ctx, s, NULL);
+  grpc_udp_server_destroy(&exec_ctx, s, nullptr);
   grpc_exec_ctx_finish(&exec_ctx);
 
   /* The server had a single FD, which is orphaned exactly once in *
@@ -221,13 +222,13 @@ static void test_no_op_with_port_and_start(void) {
 static void test_receive(int number_of_clients) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_resolved_address resolved_addr;
-  struct sockaddr_storage *addr = (struct sockaddr_storage *)resolved_addr.addr;
+  struct sockaddr_storage* addr = (struct sockaddr_storage*)resolved_addr.addr;
   int clifd, svrfd;
-  grpc_udp_server *s = grpc_udp_server_create(NULL);
+  grpc_udp_server* s = grpc_udp_server_create(nullptr);
   int i;
   int number_of_reads_before;
   grpc_millis deadline;
-  grpc_pollset *pollsets[1];
+  grpc_pollset* pollsets[1];
   LOG_TEST("test_receive");
   gpr_log(GPR_INFO, "clients=%d", number_of_clients);
 
@@ -242,12 +243,12 @@ static void test_receive(int number_of_clients) {
 
   svrfd = grpc_udp_server_get_fd(s, 0);
   GPR_ASSERT(svrfd >= 0);
-  GPR_ASSERT(getsockname(svrfd, (struct sockaddr *)addr,
-                         (socklen_t *)&resolved_addr.len) == 0);
+  GPR_ASSERT(getsockname(svrfd, (struct sockaddr*)addr,
+                         (socklen_t*)&resolved_addr.len) == 0);
   GPR_ASSERT(resolved_addr.len <= sizeof(struct sockaddr_storage));
 
   pollsets[0] = g_pollset;
-  grpc_udp_server_start(&exec_ctx, s, pollsets, 1, NULL);
+  grpc_udp_server_start(&exec_ctx, s, pollsets, 1, nullptr);
 
   gpr_mu_lock(g_mu);
 
@@ -259,12 +260,12 @@ static void test_receive(int number_of_clients) {
     /* Create a socket, send a packet to the UDP server. */
     clifd = socket(addr->ss_family, SOCK_DGRAM, 0);
     GPR_ASSERT(clifd >= 0);
-    GPR_ASSERT(connect(clifd, (struct sockaddr *)addr,
+    GPR_ASSERT(connect(clifd, (struct sockaddr*)addr,
                        (socklen_t)resolved_addr.len) == 0);
     GPR_ASSERT(5 == write(clifd, "hello", 5));
     while (g_number_of_reads == number_of_reads_before &&
            deadline > grpc_exec_ctx_now(&exec_ctx)) {
-      grpc_pollset_worker *worker = NULL;
+      grpc_pollset_worker* worker = nullptr;
       GPR_ASSERT(GRPC_LOG_IF_ERROR(
           "pollset_work",
           grpc_pollset_work(&exec_ctx, g_pollset, &worker, deadline)));
@@ -279,7 +280,7 @@ static void test_receive(int number_of_clients) {
 
   gpr_mu_unlock(g_mu);
 
-  grpc_udp_server_destroy(&exec_ctx, s, NULL);
+  grpc_udp_server_destroy(&exec_ctx, s, nullptr);
   grpc_exec_ctx_finish(&exec_ctx);
 
   /* The server had a single FD, which is orphaned exactly once in *
@@ -290,17 +291,17 @@ static void test_receive(int number_of_clients) {
   GPR_ASSERT(g_number_of_writes > 0);
 }
 
-static void destroy_pollset(grpc_exec_ctx *exec_ctx, void *p,
-                            grpc_error *error) {
-  grpc_pollset_destroy(exec_ctx, p);
+static void destroy_pollset(grpc_exec_ctx* exec_ctx, void* p,
+                            grpc_error* error) {
+  grpc_pollset_destroy(exec_ctx, static_cast<grpc_pollset*>(p));
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_closure destroyed;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_test_init(argc, argv);
   grpc_init();
-  g_pollset = gpr_zalloc(grpc_pollset_size());
+  g_pollset = static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
   grpc_pollset_init(g_pollset, &g_mu);
 
   test_no_op();
@@ -322,6 +323,6 @@ int main(int argc, char **argv) {
 
 #else /* GRPC_POSIX_SOCKET */
 
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
 
 #endif /* GRPC_POSIX_SOCKET */
diff --git a/test/core/iomgr/wakeup_fd_cv_test.c b/test/core/iomgr/wakeup_fd_cv_test.cc
index 0b211274f2..dc1d77a0ab 100644
--- a/test/core/iomgr/wakeup_fd_cv_test.c
+++ b/test/core/iomgr/wakeup_fd_cv_test.cc
@@ -32,7 +32,7 @@
 #include "src/core/lib/support/env.h"
 
 typedef struct poll_args {
-  struct pollfd *fds;
+  struct pollfd* fds;
   nfds_t nfds;
   int timeout;
   int result;
@@ -57,7 +57,7 @@ void reset_socket_event() {
 }
 
 // Mocks posix poll() function
-int mock_poll(struct pollfd *fds, nfds_t nfds, int timeout) {
+int mock_poll(struct pollfd* fds, nfds_t nfds, int timeout) {
   int res = 0;
   gpr_timespec poll_time;
   gpr_mu_lock(&poll_mu);
@@ -84,8 +84,8 @@ int mock_poll(struct pollfd *fds, nfds_t nfds, int timeout) {
   return res;
 }
 
-void background_poll(void *args) {
-  poll_args *pargs = (poll_args *)args;
+void background_poll(void* args) {
+  poll_args* pargs = (poll_args*)args;
   pargs->result = grpc_poll_function(pargs->fds, pargs->nfds, pargs->timeout);
 }
 
@@ -211,7 +211,7 @@ void test_poll_cv_trigger(void) {
   GPR_ASSERT(pfds[5].revents == 0);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   gpr_setenv("GRPC_POLL_STRATEGY", "poll-cv");
   grpc_poll_function = &mock_poll;
   gpr_mu_init(&poll_mu);
@@ -229,6 +229,6 @@ int main(int argc, char **argv) {
 
 #else /* GRPC_POSIX_SOCKET */
 
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
 
 #endif /* GRPC_POSIX_SOCKET */
diff --git a/test/core/json/BUILD b/test/core/json/BUILD
index 3ff7918677..b8b36c0652 100644
--- a/test/core/json/BUILD
+++ b/test/core/json/BUILD
@@ -22,8 +22,8 @@ load("//test/core/util:grpc_fuzzer.bzl", "grpc_fuzzer")
 
 grpc_fuzzer(
     name = "json_fuzzer",
-    srcs = ["fuzzer.c"],
-    language = "C",
+    srcs = ["fuzzer.cc"],
+    language = "C++",
     corpus = "corpus",
     deps = [
         "//:gpr",
@@ -35,8 +35,8 @@ grpc_fuzzer(
 grpc_cc_binary(
     name = "json_rewrite",
     testonly = 1,
-    srcs = ["json_rewrite.c"],
-    language = "C",
+    srcs = ["json_rewrite.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -47,8 +47,8 @@ grpc_cc_binary(
 
 grpc_cc_test(
     name = "json_rewrite_test",
-    srcs = ["json_rewrite_test.c"],
-    language = "C",
+    srcs = ["json_rewrite_test.cc"],
+    language = "C++",
     data = [
         "rewrite_test_input.json",
         "rewrite_test_output_condensed.json",
@@ -65,8 +65,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "json_stream_error_test",
-    srcs = ["json_stream_error_test.c"],
-    language = "C",
+    srcs = ["json_stream_error_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -77,8 +77,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "json_test",
-    srcs = ["json_test.c"],
-    language = "C",
+    srcs = ["json_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
diff --git a/test/core/json/fuzzer.c b/test/core/json/fuzzer.cc
index b825904d41..6dafabb95b 100644
--- a/test/core/json/fuzzer.c
+++ b/test/core/json/fuzzer.cc
@@ -29,13 +29,13 @@
 bool squelch = true;
 bool leak_check = true;
 
-int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
-  char *s;
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  char* s;
   struct grpc_memory_counters counters;
   grpc_memory_counters_init();
-  s = gpr_malloc(size);
+  s = static_cast<char*>(gpr_malloc(size));
   memcpy(s, data, size);
-  grpc_json *x;
+  grpc_json* x;
   if ((x = grpc_json_parse_string_with_len(s, size))) {
     grpc_json_destroy(x);
   }
diff --git a/test/core/json/json_rewrite.c b/test/core/json/json_rewrite.cc
index dfe32f5adf..6891a57f9f 100644
--- a/test/core/json/json_rewrite.c
+++ b/test/core/json/json_rewrite.cc
@@ -26,37 +26,39 @@
 #include "src/core/lib/json/json_reader.h"
 #include "src/core/lib/json/json_writer.h"
 
-typedef struct json_writer_userdata { FILE *out; } json_writer_userdata;
+typedef struct json_writer_userdata {
+  FILE* out;
+} json_writer_userdata;
 
 typedef struct stacked_container {
   grpc_json_type type;
-  struct stacked_container *next;
+  struct stacked_container* next;
 } stacked_container;
 
 typedef struct json_reader_userdata {
-  FILE *in;
-  grpc_json_writer *writer;
-  char *scratchpad;
-  char *ptr;
+  FILE* in;
+  grpc_json_writer* writer;
+  char* scratchpad;
+  char* ptr;
   size_t free_space;
   size_t allocated;
   size_t string_len;
-  stacked_container *top;
+  stacked_container* top;
 } json_reader_userdata;
 
-static void json_writer_output_char(void *userdata, char c) {
-  json_writer_userdata *state = userdata;
+static void json_writer_output_char(void* userdata, char c) {
+  json_writer_userdata* state = static_cast<json_writer_userdata*>(userdata);
   fputc(c, state->out);
 }
 
-static void json_writer_output_string(void *userdata, const char *str) {
-  json_writer_userdata *state = userdata;
+static void json_writer_output_string(void* userdata, const char* str) {
+  json_writer_userdata* state = static_cast<json_writer_userdata*>(userdata);
   fputs(str, state->out);
 }
 
-static void json_writer_output_string_with_len(void *userdata, const char *str,
+static void json_writer_output_string_with_len(void* userdata, const char* str,
                                                size_t len) {
-  json_writer_userdata *state = userdata;
+  json_writer_userdata* state = static_cast<json_writer_userdata*>(userdata);
   fwrite(str, len, 1, state->out);
 }
 
@@ -64,29 +66,30 @@ grpc_json_writer_vtable writer_vtable = {json_writer_output_char,
                                          json_writer_output_string,
                                          json_writer_output_string_with_len};
 
-static void check_string(json_reader_userdata *state, size_t needed) {
+static void check_string(json_reader_userdata* state, size_t needed) {
   if (state->free_space >= needed) return;
   needed -= state->free_space;
   needed = (needed + 0xffu) & ~0xffu;
-  state->scratchpad = gpr_realloc(state->scratchpad, state->allocated + needed);
+  state->scratchpad = static_cast<char*>(
+      gpr_realloc(state->scratchpad, state->allocated + needed));
   state->free_space += needed;
   state->allocated += needed;
 }
 
-static void json_reader_string_clear(void *userdata) {
-  json_reader_userdata *state = userdata;
+static void json_reader_string_clear(void* userdata) {
+  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
   state->free_space = state->allocated;
   state->string_len = 0;
 }
 
-static void json_reader_string_add_char(void *userdata, uint32_t c) {
-  json_reader_userdata *state = userdata;
+static void json_reader_string_add_char(void* userdata, uint32_t c) {
+  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
   check_string(state, 1);
   GPR_ASSERT(c < 256);
   state->scratchpad[state->string_len++] = (char)c;
 }
 
-static void json_reader_string_add_utf32(void *userdata, uint32_t c) {
+static void json_reader_string_add_utf32(void* userdata, uint32_t c) {
   if (c <= 0x7f) {
     json_reader_string_add_char(userdata, c);
   } else if (c <= 0x7ff) {
@@ -113,18 +116,19 @@ static void json_reader_string_add_utf32(void *userdata, uint32_t c) {
   }
 }
 
-static uint32_t json_reader_read_char(void *userdata) {
+static uint32_t json_reader_read_char(void* userdata) {
   int r;
-  json_reader_userdata *state = userdata;
+  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
 
   r = fgetc(state->in);
   if (r == EOF) r = GRPC_JSON_READ_CHAR_EOF;
   return (uint32_t)r;
 }
 
-static void json_reader_container_begins(void *userdata, grpc_json_type type) {
-  json_reader_userdata *state = userdata;
-  stacked_container *container = gpr_malloc(sizeof(stacked_container));
+static void json_reader_container_begins(void* userdata, grpc_json_type type) {
+  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
+  stacked_container* container =
+      static_cast<stacked_container*>(gpr_malloc(sizeof(stacked_container)));
 
   container->type = type;
   container->next = state->top;
@@ -133,9 +137,9 @@ static void json_reader_container_begins(void *userdata, grpc_json_type type) {
   grpc_json_writer_container_begins(state->writer, type);
 }
 
-static grpc_json_type json_reader_container_ends(void *userdata) {
-  json_reader_userdata *state = userdata;
-  stacked_container *container = state->top;
+static grpc_json_type json_reader_container_ends(void* userdata) {
+  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
+  stacked_container* container = state->top;
 
   grpc_json_writer_container_ends(state->writer, container->type);
   state->top = container->next;
@@ -143,22 +147,22 @@ static grpc_json_type json_reader_container_ends(void *userdata) {
   return state->top ? state->top->type : GRPC_JSON_TOP_LEVEL;
 }
 
-static void json_reader_set_key(void *userdata) {
-  json_reader_userdata *state = userdata;
+static void json_reader_set_key(void* userdata) {
+  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
   json_reader_string_add_char(userdata, 0);
 
   grpc_json_writer_object_key(state->writer, state->scratchpad);
 }
 
-static void json_reader_set_string(void *userdata) {
-  json_reader_userdata *state = userdata;
+static void json_reader_set_string(void* userdata) {
+  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
   json_reader_string_add_char(userdata, 0);
 
   grpc_json_writer_value_string(state->writer, state->scratchpad);
 }
 
-static int json_reader_set_number(void *userdata) {
-  json_reader_userdata *state = userdata;
+static int json_reader_set_number(void* userdata) {
+  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
 
   grpc_json_writer_value_raw_with_len(state->writer, state->scratchpad,
                                       state->string_len);
@@ -166,20 +170,20 @@ static int json_reader_set_number(void *userdata) {
   return 1;
 }
 
-static void json_reader_set_true(void *userdata) {
-  json_reader_userdata *state = userdata;
+static void json_reader_set_true(void* userdata) {
+  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
 
   grpc_json_writer_value_raw_with_len(state->writer, "true", 4);
 }
 
-static void json_reader_set_false(void *userdata) {
-  json_reader_userdata *state = userdata;
+static void json_reader_set_false(void* userdata) {
+  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
 
   grpc_json_writer_value_raw_with_len(state->writer, "false", 5);
 }
 
-static void json_reader_set_null(void *userdata) {
-  json_reader_userdata *state = userdata;
+static void json_reader_set_null(void* userdata) {
+  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
 
   grpc_json_writer_value_raw_with_len(state->writer, "null", 4);
 }
@@ -192,7 +196,7 @@ static grpc_json_reader_vtable reader_vtable = {
     json_reader_set_number,       json_reader_set_true,
     json_reader_set_false,        json_reader_set_null};
 
-int rewrite(FILE *in, FILE *out, int indent) {
+int rewrite(FILE* in, FILE* out, int indent) {
   grpc_json_writer writer;
   grpc_json_reader reader;
   grpc_json_reader_status status;
@@ -201,8 +205,8 @@ int rewrite(FILE *in, FILE *out, int indent) {
 
   reader_user.writer = &writer;
   reader_user.in = in;
-  reader_user.top = NULL;
-  reader_user.scratchpad = NULL;
+  reader_user.top = nullptr;
+  reader_user.scratchpad = nullptr;
   reader_user.string_len = 0;
   reader_user.free_space = 0;
   reader_user.allocated = 0;
@@ -216,7 +220,7 @@ int rewrite(FILE *in, FILE *out, int indent) {
 
   free(reader_user.scratchpad);
   while (reader_user.top) {
-    stacked_container *container = reader_user.top;
+    stacked_container* container = reader_user.top;
     reader_user.top = container->next;
     free(container);
   }
@@ -224,12 +228,12 @@ int rewrite(FILE *in, FILE *out, int indent) {
   return status == GRPC_JSON_DONE;
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   int indent = 2;
-  gpr_cmdline *cl;
+  gpr_cmdline* cl;
 
-  cl = gpr_cmdline_create(NULL);
-  gpr_cmdline_add_int(cl, "indent", NULL, &indent);
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_int(cl, "indent", nullptr, &indent);
   gpr_cmdline_parse(cl, argc, argv);
   gpr_cmdline_destroy(cl);
 
diff --git a/test/core/json/json_rewrite_test.c b/test/core/json/json_rewrite_test.cc
index a654971b34..3104afc442 100644
--- a/test/core/json/json_rewrite_test.c
+++ b/test/core/json/json_rewrite_test.cc
@@ -27,27 +27,29 @@
 #include "src/core/lib/json/json_reader.h"
 #include "src/core/lib/json/json_writer.h"
 
-typedef struct json_writer_userdata { FILE *cmp; } json_writer_userdata;
+typedef struct json_writer_userdata {
+  FILE* cmp;
+} json_writer_userdata;
 
 typedef struct stacked_container {
   grpc_json_type type;
-  struct stacked_container *next;
+  struct stacked_container* next;
 } stacked_container;
 
 typedef struct json_reader_userdata {
-  FILE *in;
-  grpc_json_writer *writer;
-  char *scratchpad;
-  char *ptr;
+  FILE* in;
+  grpc_json_writer* writer;
+  char* scratchpad;
+  char* ptr;
   size_t free_space;
   size_t allocated;
   size_t string_len;
-  stacked_container *top;
+  stacked_container* top;
   int did_eagain;
 } json_reader_userdata;
 
-static void json_writer_output_char(void *userdata, char c) {
-  json_writer_userdata *state = userdata;
+static void json_writer_output_char(void* userdata, char c) {
+  json_writer_userdata* state = static_cast<json_writer_userdata*>(userdata);
   int cmp = fgetc(state->cmp);
 
   /* treat CRLF as LF */
@@ -57,13 +59,13 @@ static void json_writer_output_char(void *userdata, char c) {
   GPR_ASSERT(cmp == c);
 }
 
-static void json_writer_output_string(void *userdata, const char *str) {
+static void json_writer_output_string(void* userdata, const char* str) {
   while (*str) {
     json_writer_output_char(userdata, *str++);
   }
 }
 
-static void json_writer_output_string_with_len(void *userdata, const char *str,
+static void json_writer_output_string_with_len(void* userdata, const char* str,
                                                size_t len) {
   size_t i;
   for (i = 0; i < len; i++) {
@@ -75,29 +77,30 @@ grpc_json_writer_vtable writer_vtable = {json_writer_output_char,
                                          json_writer_output_string,
                                          json_writer_output_string_with_len};
 
-static void check_string(json_reader_userdata *state, size_t needed) {
+static void check_string(json_reader_userdata* state, size_t needed) {
   if (state->free_space >= needed) return;
   needed -= state->free_space;
   needed = (needed + 0xffu) & ~0xffu;
-  state->scratchpad = gpr_realloc(state->scratchpad, state->allocated + needed);
+  state->scratchpad = static_cast<char*>(
+      gpr_realloc(state->scratchpad, state->allocated + needed));
   state->free_space += needed;
   state->allocated += needed;
 }
 
-static void json_reader_string_clear(void *userdata) {
-  json_reader_userdata *state = userdata;
+static void json_reader_string_clear(void* userdata) {
+  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
   state->free_space = state->allocated;
   state->string_len = 0;
 }
 
-static void json_reader_string_add_char(void *userdata, uint32_t c) {
-  json_reader_userdata *state = userdata;
+static void json_reader_string_add_char(void* userdata, uint32_t c) {
+  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
   check_string(state, 1);
   GPR_ASSERT(c <= 256);
   state->scratchpad[state->string_len++] = (char)c;
 }
 
-static void json_reader_string_add_utf32(void *userdata, uint32_t c) {
+static void json_reader_string_add_utf32(void* userdata, uint32_t c) {
   if (c <= 0x7f) {
     json_reader_string_add_char(userdata, c);
   } else if (c <= 0x7ffu) {
@@ -124,9 +127,9 @@ static void json_reader_string_add_utf32(void *userdata, uint32_t c) {
   }
 }
 
-static uint32_t json_reader_read_char(void *userdata) {
+static uint32_t json_reader_read_char(void* userdata) {
   int r;
-  json_reader_userdata *state = userdata;
+  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
 
   if (!state->did_eagain) {
     state->did_eagain = 1;
@@ -140,9 +143,10 @@ static uint32_t json_reader_read_char(void *userdata) {
   return (uint32_t)r;
 }
 
-static void json_reader_container_begins(void *userdata, grpc_json_type type) {
-  json_reader_userdata *state = userdata;
-  stacked_container *container = gpr_malloc(sizeof(stacked_container));
+static void json_reader_container_begins(void* userdata, grpc_json_type type) {
+  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
+  stacked_container* container =
+      static_cast<stacked_container*>(gpr_malloc(sizeof(stacked_container)));
 
   container->type = type;
   container->next = state->top;
@@ -151,9 +155,9 @@ static void json_reader_container_begins(void *userdata, grpc_json_type type) {
   grpc_json_writer_container_begins(state->writer, type);
 }
 
-static grpc_json_type json_reader_container_ends(void *userdata) {
-  json_reader_userdata *state = userdata;
-  stacked_container *container = state->top;
+static grpc_json_type json_reader_container_ends(void* userdata) {
+  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
+  stacked_container* container = state->top;
 
   grpc_json_writer_container_ends(state->writer, container->type);
   state->top = container->next;
@@ -161,22 +165,22 @@ static grpc_json_type json_reader_container_ends(void *userdata) {
   return state->top ? state->top->type : GRPC_JSON_TOP_LEVEL;
 }
 
-static void json_reader_set_key(void *userdata) {
-  json_reader_userdata *state = userdata;
+static void json_reader_set_key(void* userdata) {
+  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
   json_reader_string_add_char(userdata, 0);
 
   grpc_json_writer_object_key(state->writer, state->scratchpad);
 }
 
-static void json_reader_set_string(void *userdata) {
-  json_reader_userdata *state = userdata;
+static void json_reader_set_string(void* userdata) {
+  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
   json_reader_string_add_char(userdata, 0);
 
   grpc_json_writer_value_string(state->writer, state->scratchpad);
 }
 
-static int json_reader_set_number(void *userdata) {
-  json_reader_userdata *state = userdata;
+static int json_reader_set_number(void* userdata) {
+  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
 
   grpc_json_writer_value_raw_with_len(state->writer, state->scratchpad,
                                       state->string_len);
@@ -184,20 +188,20 @@ static int json_reader_set_number(void *userdata) {
   return 1;
 }
 
-static void json_reader_set_true(void *userdata) {
-  json_reader_userdata *state = userdata;
+static void json_reader_set_true(void* userdata) {
+  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
 
   grpc_json_writer_value_raw_with_len(state->writer, "true", 4);
 }
 
-static void json_reader_set_false(void *userdata) {
-  json_reader_userdata *state = userdata;
+static void json_reader_set_false(void* userdata) {
+  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
 
   grpc_json_writer_value_raw_with_len(state->writer, "false", 5);
 }
 
-static void json_reader_set_null(void *userdata) {
-  json_reader_userdata *state = userdata;
+static void json_reader_set_null(void* userdata) {
+  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
 
   grpc_json_writer_value_raw_with_len(state->writer, "null", 4);
 }
@@ -210,7 +214,7 @@ static grpc_json_reader_vtable reader_vtable = {
     json_reader_set_number,       json_reader_set_true,
     json_reader_set_false,        json_reader_set_null};
 
-int rewrite_and_compare(FILE *in, FILE *cmp, int indent) {
+int rewrite_and_compare(FILE* in, FILE* cmp, int indent) {
   grpc_json_writer writer;
   grpc_json_reader reader;
   grpc_json_reader_status status;
@@ -222,8 +226,8 @@ int rewrite_and_compare(FILE *in, FILE *cmp, int indent) {
 
   reader_user.writer = &writer;
   reader_user.in = in;
-  reader_user.top = NULL;
-  reader_user.scratchpad = NULL;
+  reader_user.top = nullptr;
+  reader_user.scratchpad = nullptr;
   reader_user.string_len = 0;
   reader_user.free_space = 0;
   reader_user.allocated = 0;
@@ -240,7 +244,7 @@ int rewrite_and_compare(FILE *in, FILE *cmp, int indent) {
 
   free(reader_user.scratchpad);
   while (reader_user.top) {
-    stacked_container *container = reader_user.top;
+    stacked_container* container = reader_user.top;
     reader_user.top = container->next;
     free(container);
   }
@@ -249,8 +253,8 @@ int rewrite_and_compare(FILE *in, FILE *cmp, int indent) {
 }
 
 typedef struct test_file {
-  const char *input;
-  const char *cmp;
+  const char* input;
+  const char* cmp;
   int indent;
 } test_file;
 
@@ -269,9 +273,9 @@ void test_rewrites() {
   unsigned i;
 
   for (i = 0; i < GPR_ARRAY_SIZE(test_files); i++) {
-    test_file *test = test_files + i;
-    FILE *input = fopen(test->input, "rb");
-    FILE *cmp = fopen(test->cmp, "rb");
+    test_file* test = test_files + i;
+    FILE* input = fopen(test->input, "rb");
+    FILE* cmp = fopen(test->cmp, "rb");
     int status;
     gpr_log(GPR_INFO, "Testing file %s against %s using indent=%i", test->input,
             test->cmp, test->indent);
@@ -282,7 +286,7 @@ void test_rewrites() {
   }
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_rewrites();
   gpr_log(GPR_INFO, "json_rewrite_test success");
diff --git a/test/core/json/json_stream_error_test.c b/test/core/json/json_stream_error_test.cc
index 379cd5d078..b367d3fbf7 100644
--- a/test/core/json/json_stream_error_test.c
+++ b/test/core/json/json_stream_error_test.cc
@@ -29,27 +29,27 @@
 
 static int g_string_clear_once = 0;
 
-static void string_clear(void *userdata) {
+static void string_clear(void* userdata) {
   GPR_ASSERT(!g_string_clear_once);
   g_string_clear_once = 1;
 }
 
-static uint32_t read_char(void *userdata) { return GRPC_JSON_READ_CHAR_ERROR; }
+static uint32_t read_char(void* userdata) { return GRPC_JSON_READ_CHAR_ERROR; }
 
 static grpc_json_reader_vtable reader_vtable = {
-    string_clear, NULL, NULL, read_char, NULL, NULL,
-    NULL,         NULL, NULL, NULL,      NULL, NULL};
+    string_clear, nullptr, nullptr, read_char, nullptr, nullptr,
+    nullptr,      nullptr, nullptr, nullptr,   nullptr, nullptr};
 
 static void read_error() {
   grpc_json_reader reader;
   grpc_json_reader_status status;
-  grpc_json_reader_init(&reader, &reader_vtable, NULL);
+  grpc_json_reader_init(&reader, &reader_vtable, nullptr);
 
   status = grpc_json_reader_run(&reader);
   GPR_ASSERT(status == GRPC_JSON_READ_ERROR);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   read_error();
   gpr_log(GPR_INFO, "json_stream_error success");
diff --git a/test/core/json/json_test.c b/test/core/json/json_test.cc
index bbc6f7a4e6..18b9c55ee7 100644
--- a/test/core/json/json_test.c
+++ b/test/core/json/json_test.cc
@@ -28,8 +28,8 @@
 #include "test/core/util/test_config.h"
 
 typedef struct testing_pair {
-  const char *input;
-  const char *output;
+  const char* input;
+  const char* output;
 } testing_pair;
 
 static testing_pair testing_pairs[] = {
@@ -52,7 +52,8 @@ static testing_pair testing_pairs[] = {
     {"{\"\\ud834\\udd1e\":0}", "{\"\\ud834\\udd1e\":0}"},
     /* Testing nested empty containers. */
     {
-        " [ [ ] , { } , [ ] ] ", "[[],{},[]]",
+        " [ [ ] , { } , [ ] ] ",
+        "[[],{},[]]",
     },
     /* Testing escapes and control chars in key strings. */
     {" { \"\\u007f\x7f\\n\\r\\\"\\f\\b\\\\a , b\": 1, \"\": 0 } ",
@@ -69,86 +70,86 @@ static testing_pair testing_pairs[] = {
     /* Testing invalid parsing. */
 
     /* Testing plain invalid things, exercising the state machine. */
-    {"\\", NULL},
-    {"nu ll", NULL},
-    {"{\"foo\": bar}", NULL},
-    {"{\"foo\": bar\"x\"}", NULL},
-    {"fals", NULL},
-    {"0,0 ", NULL},
-    {"\"foo\",[]", NULL},
+    {"\\", nullptr},
+    {"nu ll", nullptr},
+    {"{\"foo\": bar}", nullptr},
+    {"{\"foo\": bar\"x\"}", nullptr},
+    {"fals", nullptr},
+    {"0,0 ", nullptr},
+    {"\"foo\",[]", nullptr},
     /* Testing unterminated string. */
-    {"\"\\x", NULL},
+    {"\"\\x", nullptr},
     /* Testing invalid UTF-16 number. */
-    {"\"\\u123x", NULL},
-    {"{\"\\u123x", NULL},
+    {"\"\\u123x", nullptr},
+    {"{\"\\u123x", nullptr},
     /* Testing imbalanced surrogate pairs. */
-    {"\"\\ud834f", NULL},
-    {"{\"\\ud834f\":0}", NULL},
-    {"\"\\ud834\\n", NULL},
-    {"{\"\\ud834\\n\":0}", NULL},
-    {"\"\\udd1ef", NULL},
-    {"{\"\\udd1ef\":0}", NULL},
-    {"\"\\ud834\\ud834\"", NULL},
-    {"{\"\\ud834\\ud834\"\":0}", NULL},
-    {"\"\\ud834\\u1234\"", NULL},
-    {"{\"\\ud834\\u1234\"\":0}", NULL},
-    {"\"\\ud834]\"", NULL},
-    {"{\"\\ud834]\"\":0}", NULL},
-    {"\"\\ud834 \"", NULL},
-    {"{\"\\ud834 \"\":0}", NULL},
-    {"\"\\ud834\\\\\"", NULL},
-    {"{\"\\ud834\\\\\"\":0}", NULL},
+    {"\"\\ud834f", nullptr},
+    {"{\"\\ud834f\":0}", nullptr},
+    {"\"\\ud834\\n", nullptr},
+    {"{\"\\ud834\\n\":0}", nullptr},
+    {"\"\\udd1ef", nullptr},
+    {"{\"\\udd1ef\":0}", nullptr},
+    {"\"\\ud834\\ud834\"", nullptr},
+    {"{\"\\ud834\\ud834\"\":0}", nullptr},
+    {"\"\\ud834\\u1234\"", nullptr},
+    {"{\"\\ud834\\u1234\"\":0}", nullptr},
+    {"\"\\ud834]\"", nullptr},
+    {"{\"\\ud834]\"\":0}", nullptr},
+    {"\"\\ud834 \"", nullptr},
+    {"{\"\\ud834 \"\":0}", nullptr},
+    {"\"\\ud834\\\\\"", nullptr},
+    {"{\"\\ud834\\\\\"\":0}", nullptr},
     /* Testing embedded invalid whitechars. */
-    {"\"\n\"", NULL},
-    {"\"\t\"", NULL},
+    {"\"\n\"", nullptr},
+    {"\"\t\"", nullptr},
     /* Testing empty json data. */
-    {"", NULL},
+    {"", nullptr},
     /* Testing extra characters after end of parsing. */
-    {"{},", NULL},
+    {"{},", nullptr},
     /* Testing imbalanced containers. */
-    {"{}}", NULL},
-    {"[]]", NULL},
-    {"{{}", NULL},
-    {"[[]", NULL},
-    {"[}", NULL},
-    {"{]", NULL},
+    {"{}}", nullptr},
+    {"[]]", nullptr},
+    {"{{}", nullptr},
+    {"[[]", nullptr},
+    {"[}", nullptr},
+    {"{]", nullptr},
     /* Testing bad containers. */
-    {"{x}", NULL},
-    {"{x=0,y}", NULL},
+    {"{x}", nullptr},
+    {"{x=0,y}", nullptr},
     /* Testing trailing comma. */
-    {"{,}", NULL},
-    {"[1,2,3,4,]", NULL},
-    {"{\"a\": 1, }", NULL},
+    {"{,}", nullptr},
+    {"[1,2,3,4,]", nullptr},
+    {"{\"a\": 1, }", nullptr},
     /* Testing after-ending characters. */
-    {"{}x", NULL},
+    {"{}x", nullptr},
     /* Testing having a key syntax in an array. */
-    {"[\"x\":0]", NULL},
+    {"[\"x\":0]", nullptr},
     /* Testing invalid numbers. */
-    {"1.", NULL},
-    {"1e", NULL},
-    {".12", NULL},
-    {"1.x", NULL},
-    {"1.12x", NULL},
-    {"1ex", NULL},
-    {"1e12x", NULL},
-    {".12x", NULL},
-    {"000", NULL},
+    {"1.", nullptr},
+    {"1e", nullptr},
+    {".12", nullptr},
+    {"1.x", nullptr},
+    {"1.12x", nullptr},
+    {"1ex", nullptr},
+    {"1e12x", nullptr},
+    {".12x", nullptr},
+    {"000", nullptr},
 };
 
 static void test_pairs() {
   unsigned i;
 
   for (i = 0; i < GPR_ARRAY_SIZE(testing_pairs); i++) {
-    testing_pair *pair = testing_pairs + i;
-    char *scratchpad = gpr_strdup(pair->input);
-    grpc_json *json;
+    testing_pair* pair = testing_pairs + i;
+    char* scratchpad = gpr_strdup(pair->input);
+    grpc_json* json;
 
     gpr_log(GPR_INFO, "parsing string %i - should %s", i,
             pair->output ? "succeed" : "fail");
     json = grpc_json_parse_string(scratchpad);
 
     if (pair->output) {
-      char *output;
+      char* output;
 
       GPR_ASSERT(json);
       output = grpc_json_dump_to_string(json, 0);
@@ -168,9 +169,9 @@ static void test_pairs() {
 }
 
 static void test_atypical() {
-  char *scratchpad = gpr_strdup("[[],[],[]]");
-  grpc_json *json = grpc_json_parse_string(scratchpad);
-  grpc_json *brother;
+  char* scratchpad = gpr_strdup("[[],[],[]]");
+  grpc_json* json = grpc_json_parse_string(scratchpad);
+  grpc_json* brother;
 
   GPR_ASSERT(json);
   GPR_ASSERT(json->child);
@@ -182,7 +183,7 @@ static void test_atypical() {
   gpr_free(scratchpad);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_pairs();
   test_atypical();
diff --git a/test/core/memory_usage/client.c b/test/core/memory_usage/client.cc
index 6392554d85..eb90067970 100644
--- a/test/core/memory_usage/client.c
+++ b/test/core/memory_usage/client.cc
@@ -33,15 +33,15 @@
 #include "test/core/util/memory_counters.h"
 #include "test/core/util/test_config.h"
 
-static grpc_channel *channel;
-static grpc_completion_queue *cq;
+static grpc_channel* channel;
+static grpc_completion_queue* cq;
 static grpc_op metadata_ops[2];
 static grpc_op status_ops[2];
 static grpc_op snapshot_ops[6];
-static grpc_op *op;
+static grpc_op* op;
 
 typedef struct {
-  grpc_call *call;
+  grpc_call* call;
   grpc_metadata_array initial_metadata_recv;
   grpc_status_code status;
   grpc_slice details;
@@ -52,7 +52,7 @@ typedef struct {
 // calls and 1 extra for the snapshot calls.
 static fling_call calls[10001];
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 // A call is intentionally divided into two steps. First step is to initiate a
 // call (i.e send and recv metadata). A call is outstanding after we initated,
@@ -73,15 +73,15 @@ static void init_ping_pong_request(int call_idx) {
 
   grpc_slice hostname = grpc_slice_from_static_string("localhost");
   calls[call_idx].call = grpc_channel_create_call(
-      channel, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
+      channel, nullptr, GRPC_PROPAGATE_DEFAULTS, cq,
       grpc_slice_from_static_string("/Reflector/reflectUnary"), &hostname,
-      gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+      gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
 
   GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(calls[call_idx].call,
                                                    metadata_ops,
                                                    (size_t)(op - metadata_ops),
-                                                   tag(call_idx), NULL));
-  grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+                                                   tag(call_idx), nullptr));
+  grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
 }
 
 // Second step is to finish the call (i.e recv status) and destroy the call.
@@ -100,13 +100,13 @@ static void finish_ping_pong_request(int call_idx) {
   GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(calls[call_idx].call,
                                                    status_ops,
                                                    (size_t)(op - status_ops),
-                                                   tag(call_idx), NULL));
-  grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+                                                   tag(call_idx), nullptr));
+  grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
   grpc_metadata_array_destroy(&calls[call_idx].initial_metadata_recv);
   grpc_metadata_array_destroy(&calls[call_idx].trailing_metadata_recv);
   grpc_slice_unref(calls[call_idx].details);
   grpc_call_unref(calls[call_idx].call);
-  calls[call_idx].call = NULL;
+  calls[call_idx].call = nullptr;
 }
 
 static struct grpc_memory_counters send_snapshot_request(int call_idx,
@@ -114,7 +114,7 @@ static struct grpc_memory_counters send_snapshot_request(int call_idx,
   grpc_metadata_array_init(&calls[call_idx].initial_metadata_recv);
   grpc_metadata_array_init(&calls[call_idx].trailing_metadata_recv);
 
-  grpc_byte_buffer *response_payload_recv = NULL;
+  grpc_byte_buffer* response_payload_recv = nullptr;
   memset(snapshot_ops, 0, sizeof(snapshot_ops));
   op = snapshot_ops;
 
@@ -140,12 +140,13 @@ static struct grpc_memory_counters send_snapshot_request(int call_idx,
 
   grpc_slice hostname = grpc_slice_from_static_string("localhost");
   calls[call_idx].call = grpc_channel_create_call(
-      channel, NULL, GRPC_PROPAGATE_DEFAULTS, cq, call_type, &hostname,
-      gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
-  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(
-                                 calls[call_idx].call, snapshot_ops,
-                                 (size_t)(op - snapshot_ops), (void *)0, NULL));
-  grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+      channel, nullptr, GRPC_PROPAGATE_DEFAULTS, cq, call_type, &hostname,
+      gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(calls[call_idx].call,
+                                                   snapshot_ops,
+                                                   (size_t)(op - snapshot_ops),
+                                                   (void*)nullptr, nullptr));
+  grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
 
   grpc_byte_buffer_reader reader;
   grpc_byte_buffer_reader_init(&reader, response_payload_recv);
@@ -153,16 +154,16 @@ static struct grpc_memory_counters send_snapshot_request(int call_idx,
 
   struct grpc_memory_counters snapshot;
   snapshot.total_size_absolute =
-      ((struct grpc_memory_counters *)GRPC_SLICE_START_PTR(response))
+      ((struct grpc_memory_counters*)GRPC_SLICE_START_PTR(response))
           ->total_size_absolute;
   snapshot.total_allocs_absolute =
-      ((struct grpc_memory_counters *)GRPC_SLICE_START_PTR(response))
+      ((struct grpc_memory_counters*)GRPC_SLICE_START_PTR(response))
           ->total_allocs_absolute;
   snapshot.total_size_relative =
-      ((struct grpc_memory_counters *)GRPC_SLICE_START_PTR(response))
+      ((struct grpc_memory_counters*)GRPC_SLICE_START_PTR(response))
           ->total_size_relative;
   snapshot.total_allocs_relative =
-      ((struct grpc_memory_counters *)GRPC_SLICE_START_PTR(response))
+      ((struct grpc_memory_counters*)GRPC_SLICE_START_PTR(response))
           ->total_allocs_relative;
 
   grpc_metadata_array_destroy(&calls[call_idx].initial_metadata_recv);
@@ -173,18 +174,18 @@ static struct grpc_memory_counters send_snapshot_request(int call_idx,
   grpc_slice_unref(calls[call_idx].details);
   calls[call_idx].details = grpc_empty_slice();
   grpc_call_unref(calls[call_idx].call);
-  calls[call_idx].call = NULL;
+  calls[call_idx].call = nullptr;
 
   return snapshot;
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_memory_counters_init();
   grpc_slice slice = grpc_slice_from_copied_string("x");
-  char *fake_argv[1];
+  char* fake_argv[1];
 
-  char *target = "localhost:443";
-  gpr_cmdline *cl;
+  const char* target = "localhost:443";
+  gpr_cmdline* cl;
   grpc_event event;
 
   grpc_init();
@@ -208,11 +209,11 @@ int main(int argc, char **argv) {
     calls[k].details = grpc_empty_slice();
   }
 
-  cq = grpc_completion_queue_create_for_next(NULL);
+  cq = grpc_completion_queue_create_for_next(nullptr);
 
   struct grpc_memory_counters client_channel_start =
       grpc_memory_counters_snapshot();
-  channel = grpc_insecure_channel_create(target, NULL, NULL);
+  channel = grpc_insecure_channel_create(target, nullptr, nullptr);
 
   int call_idx = 0;
 
@@ -251,9 +252,10 @@ int main(int argc, char **argv) {
 
   do {
     event = grpc_completion_queue_next(
-        cq, gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
-                         gpr_time_from_micros(10000, GPR_TIMESPAN)),
-        NULL);
+        cq,
+        gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
+                     gpr_time_from_micros(10000, GPR_TIMESPAN)),
+        nullptr);
   } while (event.type != GRPC_QUEUE_TIMEOUT);
 
   // second step - recv status and destroy call
@@ -273,7 +275,7 @@ int main(int argc, char **argv) {
 
   do {
     event = grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME),
-                                       NULL);
+                                       nullptr);
   } while (event.type != GRPC_QUEUE_SHUTDOWN);
   grpc_slice_unref(slice);
 
@@ -301,11 +303,11 @@ int main(int argc, char **argv) {
           server_calls_end.total_size_relative -
               after_server_create.total_size_relative);
 
-  const char *csv_file = "memory_usage.csv";
-  FILE *csv = fopen(csv_file, "w");
+  const char* csv_file = "memory_usage.csv";
+  FILE* csv = fopen(csv_file, "w");
   if (csv) {
-    char *env_build = gpr_getenv("BUILD_NUMBER");
-    char *env_job = gpr_getenv("JOB_NAME");
+    char* env_build = gpr_getenv("BUILD_NUMBER");
+    char* env_job = gpr_getenv("JOB_NAME");
     fprintf(csv, "%f,%zi,%zi,%f,%zi,%s,%s\n",
             (double)(client_calls_inflight.total_size_relative -
                      client_benchmark_calls_start.total_size_relative) /
@@ -319,7 +321,8 @@ int main(int argc, char **argv) {
                 benchmark_iterations,
             server_calls_end.total_size_relative -
                 after_server_create.total_size_relative,
-            env_build == NULL ? "" : env_build, env_job == NULL ? "" : env_job);
+            env_build == nullptr ? "" : env_build,
+            env_job == nullptr ? "" : env_job);
     fclose(csv);
     gpr_log(GPR_INFO, "Summary written to %s", csv_file);
   }
diff --git a/test/core/memory_usage/memory_usage_test.c b/test/core/memory_usage/memory_usage_test.cc
index f4ee6c65e3..58e31c9531 100644
--- a/test/core/memory_usage/memory_usage_test.c
+++ b/test/core/memory_usage/memory_usage_test.cc
@@ -26,12 +26,12 @@
 #include "src/core/lib/support/string.h"
 #include "test/core/util/port.h"
 
-int main(int argc, char **argv) {
-  char *me = argv[0];
-  char *lslash = strrchr(me, '/');
+int main(int argc, char** argv) {
+  char* me = argv[0];
+  char* lslash = strrchr(me, '/');
   char root[1024];
   int port = grpc_pick_unused_port_or_die();
-  char *args[10];
+  char* args[10];
   int status;
   gpr_subprocess *svr, *cli;
   /* figure out where we are */
@@ -44,21 +44,21 @@ int main(int argc, char **argv) {
   /* start the server */
   gpr_asprintf(&args[0], "%s/memory_profile_server%s", root,
                gpr_subprocess_binary_extension());
-  args[1] = "--bind";
+  args[1] = const_cast<char*>("--bind");
   gpr_join_host_port(&args[2], "::", port);
-  args[3] = "--no-secure";
-  svr = gpr_subprocess_create(4, (const char **)args);
+  args[3] = const_cast<char*>("--no-secure");
+  svr = gpr_subprocess_create(4, (const char**)args);
   gpr_free(args[0]);
   gpr_free(args[2]);
 
   /* start the client */
   gpr_asprintf(&args[0], "%s/memory_profile_client%s", root,
                gpr_subprocess_binary_extension());
-  args[1] = "--target";
+  args[1] = const_cast<char*>("--target");
   gpr_join_host_port(&args[2], "127.0.0.1", port);
-  args[3] = "--warmup=1000";
-  args[4] = "--benchmark=9000";
-  cli = gpr_subprocess_create(5, (const char **)args);
+  args[3] = const_cast<char*>("--warmup=1000");
+  args[4] = const_cast<char*>("--benchmark=9000");
+  cli = gpr_subprocess_create(5, (const char**)args);
   gpr_free(args[0]);
   gpr_free(args[2]);
 
diff --git a/test/core/memory_usage/server.c b/test/core/memory_usage/server.cc
index b25341ead2..60ebcece3e 100644
--- a/test/core/memory_usage/server.c
+++ b/test/core/memory_usage/server.cc
@@ -39,17 +39,17 @@
 #include "test/core/util/port.h"
 #include "test/core/util/test_config.h"
 
-static grpc_completion_queue *cq;
-static grpc_server *server;
+static grpc_completion_queue* cq;
+static grpc_server* server;
 static grpc_op metadata_ops[2];
 static grpc_op snapshot_ops[5];
 static grpc_op status_op;
 static int got_sigint = 0;
-static grpc_byte_buffer *payload_buffer = NULL;
-static grpc_byte_buffer *terminal_buffer = NULL;
+static grpc_byte_buffer* payload_buffer = nullptr;
+static grpc_byte_buffer* terminal_buffer = nullptr;
 static int was_cancelled = 2;
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 typedef enum {
   FLING_SERVER_NEW_REQUEST = 1,
@@ -62,7 +62,7 @@ typedef enum {
 
 typedef struct {
   fling_server_tags state;
-  grpc_call *call;
+  grpc_call* call;
   grpc_call_details call_details;
   grpc_metadata_array request_metadata_recv;
   grpc_metadata_array initial_metadata_send;
@@ -82,33 +82,35 @@ static void request_call_unary(int call_idx) {
       &calls[call_idx].request_metadata_recv, cq, cq, &calls[call_idx]);
 }
 
-static void send_initial_metadata_unary(void *tag) {
-  grpc_metadata_array_init(&(*(fling_call *)tag).initial_metadata_send);
+static void send_initial_metadata_unary(void* tag) {
+  grpc_metadata_array_init(&(*(fling_call*)tag).initial_metadata_send);
   metadata_ops[0].op = GRPC_OP_SEND_INITIAL_METADATA;
   metadata_ops[0].data.send_initial_metadata.count = 0;
 
-  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch((*(fling_call *)tag).call,
-                                                   metadata_ops, 1, tag, NULL));
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch((*(fling_call*)tag).call,
+                                                   metadata_ops, 1, tag,
+                                                   nullptr));
 }
 
-static void send_status(void *tag) {
+static void send_status(void* tag) {
   status_op.op = GRPC_OP_SEND_STATUS_FROM_SERVER;
   status_op.data.send_status_from_server.status = GRPC_STATUS_OK;
   status_op.data.send_status_from_server.trailing_metadata_count = 0;
   grpc_slice details = grpc_slice_from_static_string("");
   status_op.data.send_status_from_server.status_details = &details;
 
-  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch((*(fling_call *)tag).call,
-                                                   &status_op, 1, tag, NULL));
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch((*(fling_call*)tag).call,
+                                                   &status_op, 1, tag,
+                                                   nullptr));
 }
 
-static void send_snapshot(void *tag, struct grpc_memory_counters *snapshot) {
-  grpc_op *op;
+static void send_snapshot(void* tag, struct grpc_memory_counters* snapshot) {
+  grpc_op* op;
 
   grpc_slice snapshot_slice =
       grpc_slice_new(snapshot, sizeof(*snapshot), gpr_free);
   payload_buffer = grpc_raw_byte_buffer_create(&snapshot_slice, 1);
-  grpc_metadata_array_init(&(*(fling_call *)tag).initial_metadata_send);
+  grpc_metadata_array_init(&(*(fling_call*)tag).initial_metadata_send);
 
   op = snapshot_ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
@@ -118,7 +120,7 @@ static void send_snapshot(void *tag, struct grpc_memory_counters *snapshot) {
   op->data.recv_message.recv_message = &terminal_buffer;
   op++;
   op->op = GRPC_OP_SEND_MESSAGE;
-  if (payload_buffer == NULL) {
+  if (payload_buffer == nullptr) {
     gpr_log(GPR_INFO, "NULL payload buffer !!!");
   }
   op->data.send_message.send_message = payload_buffer;
@@ -134,26 +136,26 @@ static void send_snapshot(void *tag, struct grpc_memory_counters *snapshot) {
   op++;
 
   GPR_ASSERT(GRPC_CALL_OK ==
-             grpc_call_start_batch((*(fling_call *)tag).call, snapshot_ops,
-                                   (size_t)(op - snapshot_ops), tag, NULL));
+             grpc_call_start_batch((*(fling_call*)tag).call, snapshot_ops,
+                                   (size_t)(op - snapshot_ops), tag, nullptr));
 }
 /* We have some sort of deadlock, so let's not exit gracefully for now.
    When that is resolved, please remove the #include <unistd.h> above. */
 static void sigint_handler(int x) { _exit(0); }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_memory_counters_init();
   grpc_event ev;
-  char *addr_buf = NULL;
-  gpr_cmdline *cl;
-  grpc_completion_queue *shutdown_cq;
+  char* addr_buf = nullptr;
+  gpr_cmdline* cl;
+  grpc_completion_queue* shutdown_cq;
   int shutdown_started = 0;
   int shutdown_finished = 0;
 
   int secure = 0;
-  char *addr = NULL;
+  const char* addr = nullptr;
 
-  char *fake_argv[1];
+  char* fake_argv[1];
 
   GPR_ASSERT(argc >= 1);
   fake_argv[0] = argv[0];
@@ -168,37 +170,37 @@ int main(int argc, char **argv) {
   gpr_cmdline_parse(cl, argc, argv);
   gpr_cmdline_destroy(cl);
 
-  if (addr == NULL) {
+  if (addr == nullptr) {
     gpr_join_host_port(&addr_buf, "::", grpc_pick_unused_port_or_die());
     addr = addr_buf;
   }
   gpr_log(GPR_INFO, "creating server on: %s", addr);
 
-  cq = grpc_completion_queue_create_for_next(NULL);
+  cq = grpc_completion_queue_create_for_next(nullptr);
 
   struct grpc_memory_counters before_server_create =
       grpc_memory_counters_snapshot();
   if (secure) {
     grpc_ssl_pem_key_cert_pair pem_key_cert_pair = {test_server1_key,
                                                     test_server1_cert};
-    grpc_server_credentials *ssl_creds = grpc_ssl_server_credentials_create(
-        NULL, &pem_key_cert_pair, 1, 0, NULL);
-    server = grpc_server_create(NULL, NULL);
+    grpc_server_credentials* ssl_creds = grpc_ssl_server_credentials_create(
+        nullptr, &pem_key_cert_pair, 1, 0, nullptr);
+    server = grpc_server_create(nullptr, nullptr);
     GPR_ASSERT(grpc_server_add_secure_http2_port(server, addr, ssl_creds));
     grpc_server_credentials_release(ssl_creds);
   } else {
-    server = grpc_server_create(NULL, NULL);
+    server = grpc_server_create(nullptr, nullptr);
     GPR_ASSERT(grpc_server_add_insecure_http2_port(server, addr));
   }
 
-  grpc_server_register_completion_queue(server, cq, NULL);
+  grpc_server_register_completion_queue(server, cq, nullptr);
   grpc_server_start(server);
 
   struct grpc_memory_counters after_server_create =
       grpc_memory_counters_snapshot();
 
   gpr_free(addr_buf);
-  addr = addr_buf = NULL;
+  addr = addr_buf = nullptr;
 
   // initialize call instances
   for (int i = 0; i < (int)(sizeof(calls) / sizeof(fling_call)); i++) {
@@ -217,21 +219,22 @@ int main(int argc, char **argv) {
     if (got_sigint && !shutdown_started) {
       gpr_log(GPR_INFO, "Shutting down due to SIGINT");
 
-      shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
+      shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
       grpc_server_shutdown_and_notify(server, shutdown_cq, tag(1000));
-      GPR_ASSERT(
-          grpc_completion_queue_pluck(shutdown_cq, tag(1000),
-                                      grpc_timeout_seconds_to_deadline(5), NULL)
-              .type == GRPC_OP_COMPLETE);
+      GPR_ASSERT(grpc_completion_queue_pluck(
+                     shutdown_cq, tag(1000),
+                     grpc_timeout_seconds_to_deadline(5), nullptr)
+                     .type == GRPC_OP_COMPLETE);
       grpc_completion_queue_destroy(shutdown_cq);
       grpc_completion_queue_shutdown(cq);
       shutdown_started = 1;
     }
     ev = grpc_completion_queue_next(
-        cq, gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
-                         gpr_time_from_micros(1000000, GPR_TIMESPAN)),
-        NULL);
-    fling_call *s = ev.tag;
+        cq,
+        gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
+                     gpr_time_from_micros(1000000, GPR_TIMESPAN)),
+        nullptr);
+    fling_call* s = static_cast<fling_call*>(ev.tag);
     switch (ev.type) {
       case GRPC_OP_COMPLETE:
         switch (s->state) {
@@ -293,8 +296,8 @@ int main(int argc, char **argv) {
             grpc_call_details_destroy(&s->call_details);
             grpc_metadata_array_destroy(&s->initial_metadata_send);
             grpc_metadata_array_destroy(&s->request_metadata_recv);
-            terminal_buffer = NULL;
-            payload_buffer = NULL;
+            terminal_buffer = nullptr;
+            payload_buffer = nullptr;
             break;
         }
         break;
diff --git a/test/core/nanopb/BUILD b/test/core/nanopb/BUILD
index f332207e2d..1497f829ab 100644
--- a/test/core/nanopb/BUILD
+++ b/test/core/nanopb/BUILD
@@ -22,8 +22,8 @@ load("//test/core/util:grpc_fuzzer.bzl", "grpc_fuzzer")
 
 grpc_fuzzer(
     name = "fuzzer_response",
-    srcs = ["fuzzer_response.c"],
-    language = "C",
+    srcs = ["fuzzer_response.cc"],
+    language = "C++",
     corpus = "corpus_response",
     deps = [
         "//:gpr",
@@ -34,8 +34,8 @@ grpc_fuzzer(
 
 grpc_fuzzer(
     name = "fuzzer_serverlist",
-    srcs = ["fuzzer_serverlist.c"],
-    language = "C",
+    srcs = ["fuzzer_serverlist.cc"],
+    language = "C++",
     corpus = "corpus_serverlist",
     deps = [
         "//:gpr",
diff --git a/test/core/nanopb/fuzzer_response.c b/test/core/nanopb/fuzzer_response.cc
index c9b63979a1..7039c801cb 100644
--- a/test/core/nanopb/fuzzer_response.c
+++ b/test/core/nanopb/fuzzer_response.cc
@@ -26,12 +26,12 @@
 bool squelch = true;
 bool leak_check = true;
 
-static void dont_log(gpr_log_func_args *args) {}
+static void dont_log(gpr_log_func_args* args) {}
 
-int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   if (squelch) gpr_set_log_function(dont_log);
-  grpc_slice slice = grpc_slice_from_copied_buffer((const char *)data, size);
-  grpc_grpclb_initial_response *response;
+  grpc_slice slice = grpc_slice_from_copied_buffer((const char*)data, size);
+  grpc_grpclb_initial_response* response;
   if ((response = grpc_grpclb_initial_response_parse(slice))) {
     grpc_grpclb_initial_response_destroy(response);
   }
diff --git a/test/core/nanopb/fuzzer_serverlist.c b/test/core/nanopb/fuzzer_serverlist.cc
index dd70f0c331..0a6b1767a1 100644
--- a/test/core/nanopb/fuzzer_serverlist.c
+++ b/test/core/nanopb/fuzzer_serverlist.cc
@@ -26,12 +26,12 @@
 bool squelch = true;
 bool leak_check = true;
 
-static void dont_log(gpr_log_func_args *args) {}
+static void dont_log(gpr_log_func_args* args) {}
 
-int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   if (squelch) gpr_set_log_function(dont_log);
-  grpc_slice slice = grpc_slice_from_copied_buffer((const char *)data, size);
-  grpc_grpclb_serverlist *serverlist;
+  grpc_slice slice = grpc_slice_from_copied_buffer((const char*)data, size);
+  grpc_grpclb_serverlist* serverlist;
   if ((serverlist = grpc_grpclb_response_parse_serverlist(slice))) {
     grpc_grpclb_destroy_serverlist(serverlist);
   }
diff --git a/test/core/network_benchmarks/BUILD b/test/core/network_benchmarks/BUILD
index 0e15393030..e1b4953608 100644
--- a/test/core/network_benchmarks/BUILD
+++ b/test/core/network_benchmarks/BUILD
@@ -22,8 +22,8 @@ licenses(["notice"])  # Apache v2
 
 grpc_cc_binary(
     name = "low_level_ping_pong",
-    srcs = ["low_level_ping_pong.c"],
-    language = "C",
+    srcs = ["low_level_ping_pong.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
diff --git a/test/core/network_benchmarks/low_level_ping_pong.c b/test/core/network_benchmarks/low_level_ping_pong.cc
index 1550003eb9..687395d916 100644
--- a/test/core/network_benchmarks/low_level_ping_pong.c
+++ b/test/core/network_benchmarks/low_level_ping_pong.cc
@@ -52,11 +52,11 @@ typedef struct fd_pair {
 typedef struct thread_args {
   fd_pair fds;
   size_t msg_size;
-  int (*read_bytes)(struct thread_args *args, char *buf);
-  int (*write_bytes)(struct thread_args *args, char *buf);
-  int (*setup)(struct thread_args *args);
+  int (*read_bytes)(struct thread_args* args, char* buf);
+  int (*write_bytes)(struct thread_args* args, char* buf);
+  int (*setup)(struct thread_args* args);
   int epoll_fd;
-  char *strategy_name;
+  const char* strategy_name;
 } thread_args;
 
 /*
@@ -67,7 +67,7 @@ typedef struct thread_args {
  */
 
 /* Basic call to read() */
-static int read_bytes(int fd, char *buf, size_t read_size, int spin) {
+static int read_bytes(int fd, char* buf, size_t read_size, int spin) {
   size_t bytes_read = 0;
   ssize_t err;
   do {
@@ -89,16 +89,16 @@ static int read_bytes(int fd, char *buf, size_t read_size, int spin) {
   return 0;
 }
 
-static int blocking_read_bytes(thread_args *args, char *buf) {
+static int blocking_read_bytes(thread_args* args, char* buf) {
   return read_bytes(args->fds.read_fd, buf, args->msg_size, 0);
 }
 
-static int spin_read_bytes(thread_args *args, char *buf) {
+static int spin_read_bytes(thread_args* args, char* buf) {
   return read_bytes(args->fds.read_fd, buf, args->msg_size, 1);
 }
 
 /* Call poll() to monitor a non-blocking fd */
-static int poll_read_bytes(int fd, char *buf, size_t read_size, int spin) {
+static int poll_read_bytes(int fd, char* buf, size_t read_size, int spin) {
   struct pollfd pfd;
   size_t bytes_read = 0;
   int err;
@@ -131,17 +131,17 @@ static int poll_read_bytes(int fd, char *buf, size_t read_size, int spin) {
   return 0;
 }
 
-static int poll_read_bytes_blocking(struct thread_args *args, char *buf) {
+static int poll_read_bytes_blocking(struct thread_args* args, char* buf) {
   return poll_read_bytes(args->fds.read_fd, buf, args->msg_size, 0);
 }
 
-static int poll_read_bytes_spin(struct thread_args *args, char *buf) {
+static int poll_read_bytes_spin(struct thread_args* args, char* buf) {
   return poll_read_bytes(args->fds.read_fd, buf, args->msg_size, 1);
 }
 
 #ifdef __linux__
 /* Call epoll_wait() to monitor a non-blocking fd */
-static int epoll_read_bytes(struct thread_args *args, char *buf, int spin) {
+static int epoll_read_bytes(struct thread_args* args, char* buf, int spin) {
   struct epoll_event ev;
   size_t bytes_read = 0;
   int err;
@@ -174,11 +174,11 @@ static int epoll_read_bytes(struct thread_args *args, char *buf, int spin) {
   return 0;
 }
 
-static int epoll_read_bytes_blocking(struct thread_args *args, char *buf) {
+static int epoll_read_bytes_blocking(struct thread_args* args, char* buf) {
   return epoll_read_bytes(args, buf, 0);
 }
 
-static int epoll_read_bytes_spin(struct thread_args *args, char *buf) {
+static int epoll_read_bytes_spin(struct thread_args* args, char* buf) {
   return epoll_read_bytes(args, buf, 1);
 }
 #endif /* __linux__ */
@@ -187,7 +187,7 @@ static int epoll_read_bytes_spin(struct thread_args *args, char *buf) {
    At this point we only have one strategy, since in the common case these
    writes go directly out to the kernel.
  */
-static int blocking_write_bytes(struct thread_args *args, char *buf) {
+static int blocking_write_bytes(struct thread_args* args, char* buf) {
   size_t bytes_written = 0;
   ssize_t err;
   size_t write_size = args->msg_size;
@@ -214,7 +214,7 @@ static int blocking_write_bytes(struct thread_args *args, char *buf) {
    These are called at the beginning of the client and server thread, depending
    on the scenario we're using.
  */
-static int set_socket_nonblocking(thread_args *args) {
+static int set_socket_nonblocking(thread_args* args) {
   if (!GRPC_LOG_IF_ERROR("Unable to set read socket nonblocking",
                          grpc_set_socket_nonblocking(args->fds.read_fd, 1))) {
     return -1;
@@ -226,11 +226,11 @@ static int set_socket_nonblocking(thread_args *args) {
   return 0;
 }
 
-static int do_nothing(thread_args *args) { return 0; }
+static int do_nothing(thread_args* args) { return 0; }
 
 #ifdef __linux__
 /* Special case for epoll, where we need to create the fd ahead of time. */
-static int epoll_setup(thread_args *args) {
+static int epoll_setup(thread_args* args) {
   int epoll_fd;
   struct epoll_event ev;
   set_socket_nonblocking(args);
@@ -251,8 +251,8 @@ static int epoll_setup(thread_args *args) {
 }
 #endif
 
-static void server_thread(thread_args *args) {
-  char *buf = gpr_malloc(args->msg_size);
+static void server_thread(thread_args* args) {
+  char* buf = static_cast<char*>(gpr_malloc(args->msg_size));
   if (args->setup(args) < 0) {
     gpr_log(GPR_ERROR, "Setup failed");
   }
@@ -270,12 +270,12 @@ static void server_thread(thread_args *args) {
   }
 }
 
-static void server_thread_wrap(void *arg) {
-  thread_args *args = arg;
+static void server_thread_wrap(void* arg) {
+  thread_args* args = static_cast<thread_args*>(arg);
   server_thread(args);
 }
 
-static void print_histogram(gpr_histogram *histogram) {
+static void print_histogram(gpr_histogram* histogram) {
   /* TODO(klempner): Print more detailed information, such as detailed histogram
      buckets */
   gpr_log(GPR_INFO, "latency (50/95/99/99.9): %f/%f/%f/%f",
@@ -290,10 +290,10 @@ static double now(void) {
   return 1e9 * (double)tv.tv_sec + (double)tv.tv_nsec;
 }
 
-static void client_thread(thread_args *args) {
-  char *buf = gpr_malloc(args->msg_size * sizeof(char));
+static void client_thread(thread_args* args) {
+  char* buf = static_cast<char*>(gpr_malloc(args->msg_size * sizeof(char)));
   memset(buf, 0, args->msg_size * sizeof(char));
-  gpr_histogram *histogram = gpr_histogram_create(0.01, 60e9);
+  gpr_histogram* histogram = gpr_histogram_create(0.01, 60e9);
   double start_time;
   double end_time;
   double interval;
@@ -326,7 +326,7 @@ error:
 }
 
 /* This roughly matches tcp_server's create_listening_socket */
-static int create_listening_socket(struct sockaddr *port, socklen_t len) {
+static int create_listening_socket(struct sockaddr* port, socklen_t len) {
   int fd = socket(port->sa_family, SOCK_STREAM, 0);
   if (fd < 0) {
     gpr_log(GPR_ERROR, "Unable to create socket: %s", strerror(errno));
@@ -370,7 +370,7 @@ error:
   return -1;
 }
 
-static int connect_client(struct sockaddr *addr, socklen_t len) {
+static int connect_client(struct sockaddr* addr, socklen_t len) {
   int fd = socket(addr->sa_family, SOCK_STREAM, 0);
   int err;
   if (fd < 0) {
@@ -405,7 +405,7 @@ error:
 }
 
 static int accept_server(int listen_fd) {
-  int fd = accept(listen_fd, NULL, NULL);
+  int fd = accept(listen_fd, nullptr, nullptr);
   if (fd < 0) {
     gpr_log(GPR_ERROR, "Accept failed: %s", strerror(errno));
     return -1;
@@ -413,13 +413,13 @@ static int accept_server(int listen_fd) {
   return fd;
 }
 
-static int create_sockets_tcp(fd_pair *client_fds, fd_pair *server_fds) {
+static int create_sockets_tcp(fd_pair* client_fds, fd_pair* server_fds) {
   int listen_fd = -1;
   int client_fd = -1;
   int server_fd = -1;
 
   struct sockaddr_in port;
-  struct sockaddr *sa_port = (struct sockaddr *)&port;
+  struct sockaddr* sa_port = (struct sockaddr*)&port;
 
   port.sin_family = AF_INET;
   port.sin_port = 0;
@@ -463,7 +463,7 @@ error:
   return -1;
 }
 
-static int create_sockets_socketpair(fd_pair *client_fds, fd_pair *server_fds) {
+static int create_sockets_socketpair(fd_pair* client_fds, fd_pair* server_fds) {
   int fds[2];
   if (socketpair(AF_UNIX, SOCK_STREAM, 0, fds) < 0) {
     gpr_log(GPR_ERROR, "socketpair: %s", strerror(errno));
@@ -477,7 +477,7 @@ static int create_sockets_socketpair(fd_pair *client_fds, fd_pair *server_fds) {
   return 0;
 }
 
-static int create_sockets_pipe(fd_pair *client_fds, fd_pair *server_fds) {
+static int create_sockets_pipe(fd_pair* client_fds, fd_pair* server_fds) {
   int cfds[2];
   int sfds[2];
   if (pipe(cfds) < 0) {
@@ -497,7 +497,7 @@ static int create_sockets_pipe(fd_pair *client_fds, fd_pair *server_fds) {
   return 0;
 }
 
-static const char *read_strategy_usage =
+static const char* read_strategy_usage =
     "Strategy for doing reads, which is one of:\n"
     "  blocking: blocking read calls\n"
     "  same_thread_poll: poll() call on same thread \n"
@@ -511,13 +511,13 @@ static const char *read_strategy_usage =
 #endif
     "";
 
-static const char *socket_type_usage =
+static const char* socket_type_usage =
     "Type of socket used, one of:\n"
     "  tcp: fds are endpoints of a TCP connection\n"
     "  socketpair: fds come from socketpair()\n"
     "  pipe: fds come from pipe()\n";
 
-void print_usage(char *argv0) {
+void print_usage(char* argv0) {
   fprintf(stderr, "%s usage:\n\n", argv0);
   fprintf(stderr, "%s read_strategy socket_type msg_size\n\n", argv0);
   fprintf(stderr, "where read_strategy is one of:\n");
@@ -538,9 +538,9 @@ void print_usage(char *argv0) {
 }
 
 typedef struct test_strategy {
-  char *name;
-  int (*read_strategy)(struct thread_args *args, char *buf);
-  int (*setup)(struct thread_args *args);
+  const char* name;
+  int (*read_strategy)(struct thread_args* args, char* buf);
+  int (*setup)(struct thread_args* args);
 } test_strategy;
 
 static test_strategy test_strategies[] = {
@@ -553,9 +553,10 @@ static test_strategy test_strategies[] = {
     {"spin_read", spin_read_bytes, set_socket_nonblocking},
     {"spin_poll", poll_read_bytes_spin, set_socket_nonblocking}};
 
-static char *socket_types[] = {"tcp", "socketpair", "pipe"};
+static const char* socket_types[] = {"tcp", "socketpair", "pipe"};
 
-int create_socket(char *socket_type, fd_pair *client_fds, fd_pair *server_fds) {
+int create_socket(const char* socket_type, fd_pair* client_fds,
+                  fd_pair* server_fds) {
   if (strcmp(socket_type, "tcp") == 0) {
     create_sockets_tcp(client_fds, server_fds);
   } else if (strcmp(socket_type, "socketpair") == 0) {
@@ -569,8 +570,8 @@ int create_socket(char *socket_type, fd_pair *client_fds, fd_pair *server_fds) {
   return 0;
 }
 
-static int run_benchmark(char *socket_type, thread_args *client_args,
-                         thread_args *server_args) {
+static int run_benchmark(const char* socket_type, thread_args* client_args,
+                         thread_args* server_args) {
   gpr_thd_id tid;
   int rv = 0;
 
@@ -582,7 +583,7 @@ static int run_benchmark(char *socket_type, thread_args *client_args,
   gpr_log(GPR_INFO, "Starting test %s %s %zu", client_args->strategy_name,
           socket_type, client_args->msg_size);
 
-  gpr_thd_new(&tid, server_thread_wrap, server_args, NULL);
+  gpr_thd_new(&tid, server_thread_wrap, server_args, nullptr);
   client_thread(client_args);
   return 0;
 }
@@ -591,12 +592,14 @@ static int run_all_benchmarks(size_t msg_size) {
   int error = 0;
   size_t i;
   for (i = 0; i < GPR_ARRAY_SIZE(test_strategies); ++i) {
-    test_strategy *strategy = &test_strategies[i];
+    test_strategy* strategy = &test_strategies[i];
     size_t j;
     for (j = 0; j < GPR_ARRAY_SIZE(socket_types); ++j) {
-      thread_args *client_args = gpr_malloc(sizeof(thread_args));
-      thread_args *server_args = gpr_malloc(sizeof(thread_args));
-      char *socket_type = socket_types[j];
+      thread_args* client_args =
+          static_cast<thread_args*>(gpr_malloc(sizeof(thread_args)));
+      thread_args* server_args =
+          static_cast<thread_args*>(gpr_malloc(sizeof(thread_args)));
+      const char* socket_type = socket_types[j];
 
       client_args->read_bytes = strategy->read_strategy;
       client_args->write_bytes = blocking_write_bytes;
@@ -617,17 +620,19 @@ static int run_all_benchmarks(size_t msg_size) {
   return error;
 }
 
-int main(int argc, char **argv) {
-  thread_args *client_args = gpr_malloc(sizeof(thread_args));
-  thread_args *server_args = gpr_malloc(sizeof(thread_args));
+int main(int argc, char** argv) {
+  thread_args* client_args =
+      static_cast<thread_args*>(gpr_malloc(sizeof(thread_args)));
+  thread_args* server_args =
+      static_cast<thread_args*>(gpr_malloc(sizeof(thread_args)));
   int msg_size = -1;
-  char *read_strategy = NULL;
-  char *socket_type = NULL;
+  const char* read_strategy = nullptr;
+  const char* socket_type = nullptr;
   size_t i;
-  const test_strategy *strategy = NULL;
+  const test_strategy* strategy = nullptr;
   int error = 0;
 
-  gpr_cmdline *cmdline =
+  gpr_cmdline* cmdline =
       gpr_cmdline_create("low_level_ping_pong network benchmarking tool");
 
   gpr_cmdline_add_int(cmdline, "msg_size", "Size of sent messages", &msg_size);
@@ -642,12 +647,12 @@ int main(int argc, char **argv) {
     msg_size = 50;
   }
 
-  if (read_strategy == NULL) {
+  if (read_strategy == nullptr) {
     gpr_log(GPR_INFO, "No strategy specified, running all benchmarks");
     return run_all_benchmarks((size_t)msg_size);
   }
 
-  if (socket_type == NULL) {
+  if (socket_type == nullptr) {
     socket_type = "tcp";
   }
   if (msg_size <= 0) {
@@ -661,7 +666,7 @@ int main(int argc, char **argv) {
       strategy = &test_strategies[i];
     }
   }
-  if (strategy == NULL) {
+  if (strategy == nullptr) {
     fprintf(stderr, "Invalid read strategy %s\n", read_strategy);
     return -1;
   }
diff --git a/test/core/security/BUILD b/test/core/security/BUILD
index dc41759922..7cd3ae58da 100644
--- a/test/core/security/BUILD
+++ b/test/core/security/BUILD
@@ -22,8 +22,8 @@ load("//test/core/util:grpc_fuzzer.bzl", "grpc_fuzzer")
 
 grpc_fuzzer(
     name = "ssl_server_fuzzer",
-    srcs = ["ssl_server_fuzzer.c"],
-    language = "C",
+    srcs = ["ssl_server_fuzzer.cc"],
+    language = "C++",
     corpus = "corpus",
     deps = [
         "//:gpr",
@@ -35,17 +35,17 @@ grpc_fuzzer(
 
 grpc_cc_library(
     name = "oauth2_utils",
-    srcs = ["oauth2_utils.c"],
+    srcs = ["oauth2_utils.cc"],
     hdrs = ["oauth2_utils.h"],
-    language = "C",
+    language = "C++",
     deps = ["//:grpc"],
     visibility = ["//test/cpp:__subpackages__"],
 )
 
 grpc_cc_test(
     name = "auth_context_test",
-    srcs = ["auth_context_test.c"],
-    language = "C",
+    srcs = ["auth_context_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -56,8 +56,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "credentials_test",
-    srcs = ["credentials_test.c"],
-    language = "C",
+    srcs = ["credentials_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -68,8 +68,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "secure_endpoint_test",
-    srcs = ["secure_endpoint_test.c"],
-    language = "C",
+    srcs = ["secure_endpoint_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -81,8 +81,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "security_connector_test",
-    srcs = ["security_connector_test.c"],
-    language = "C",
+    srcs = ["security_connector_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -91,10 +91,22 @@ grpc_cc_test(
     ],
 )
 
+grpc_cc_test(
+    name = "ssl_credentials_test",
+    srcs = ["ssl_credentials_test.cc"],
+    language = "C++",
+    deps = [
+        "//:gpr",
+        "//:grpc",
+        "//test/core/util:gpr_test_util",
+        "//test/core/util:grpc_test_util",
+    ]
+)
+
 grpc_cc_binary(
     name = "create_jwt",
-    srcs = ["create_jwt.c"],
-    language = "C",
+    srcs = ["create_jwt.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -103,8 +115,8 @@ grpc_cc_binary(
 
 grpc_cc_binary(
     name = "fetch_oauth2",
-    srcs = ["fetch_oauth2.c"],
-    language = "C",
+    srcs = ["fetch_oauth2.cc"],
+    language = "C++",
     deps = [
         ":oauth2_utils",
         "//:gpr",
@@ -114,8 +126,8 @@ grpc_cc_binary(
 
 grpc_cc_binary(
     name = "verify_jwt",
-    srcs = ["verify_jwt.c"],
-    language = "C",
+    srcs = ["verify_jwt.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
diff --git a/test/core/security/auth_context_test.c b/test/core/security/auth_context_test.cc
index 88daf28c99..d8e41326c0 100644
--- a/test/core/security/auth_context_test.c
+++ b/test/core/security/auth_context_test.cc
@@ -25,31 +25,31 @@
 #include <grpc/support/log.h>
 
 static void test_empty_context(void) {
-  grpc_auth_context *ctx = grpc_auth_context_create(NULL);
+  grpc_auth_context* ctx = grpc_auth_context_create(nullptr);
   grpc_auth_property_iterator it;
 
   gpr_log(GPR_INFO, "test_empty_context");
-  GPR_ASSERT(ctx != NULL);
-  GPR_ASSERT(grpc_auth_context_peer_identity_property_name(ctx) == NULL);
+  GPR_ASSERT(ctx != nullptr);
+  GPR_ASSERT(grpc_auth_context_peer_identity_property_name(ctx) == nullptr);
   it = grpc_auth_context_peer_identity(ctx);
-  GPR_ASSERT(grpc_auth_property_iterator_next(&it) == NULL);
+  GPR_ASSERT(grpc_auth_property_iterator_next(&it) == nullptr);
   it = grpc_auth_context_property_iterator(ctx);
-  GPR_ASSERT(grpc_auth_property_iterator_next(&it) == NULL);
+  GPR_ASSERT(grpc_auth_property_iterator_next(&it) == nullptr);
   it = grpc_auth_context_find_properties_by_name(ctx, "foo");
-  GPR_ASSERT(grpc_auth_property_iterator_next(&it) == NULL);
+  GPR_ASSERT(grpc_auth_property_iterator_next(&it) == nullptr);
   GPR_ASSERT(grpc_auth_context_set_peer_identity_property_name(ctx, "bar") ==
              0);
-  GPR_ASSERT(grpc_auth_context_peer_identity_property_name(ctx) == NULL);
+  GPR_ASSERT(grpc_auth_context_peer_identity_property_name(ctx) == nullptr);
   GRPC_AUTH_CONTEXT_UNREF(ctx, "test");
 }
 
 static void test_simple_context(void) {
-  grpc_auth_context *ctx = grpc_auth_context_create(NULL);
+  grpc_auth_context* ctx = grpc_auth_context_create(nullptr);
   grpc_auth_property_iterator it;
   size_t i;
 
   gpr_log(GPR_INFO, "test_simple_context");
-  GPR_ASSERT(ctx != NULL);
+  GPR_ASSERT(ctx != nullptr);
   grpc_auth_context_add_cstring_property(ctx, "name", "chapi");
   grpc_auth_context_add_cstring_property(ctx, "name", "chapo");
   grpc_auth_context_add_cstring_property(ctx, "foo", "bar");
@@ -61,29 +61,29 @@ static void test_simple_context(void) {
       strcmp(grpc_auth_context_peer_identity_property_name(ctx), "name") == 0);
   it = grpc_auth_context_property_iterator(ctx);
   for (i = 0; i < ctx->properties.count; i++) {
-    const grpc_auth_property *p = grpc_auth_property_iterator_next(&it);
+    const grpc_auth_property* p = grpc_auth_property_iterator_next(&it);
     GPR_ASSERT(p == &ctx->properties.array[i]);
   }
-  GPR_ASSERT(grpc_auth_property_iterator_next(&it) == NULL);
+  GPR_ASSERT(grpc_auth_property_iterator_next(&it) == nullptr);
 
   it = grpc_auth_context_find_properties_by_name(ctx, "foo");
   GPR_ASSERT(grpc_auth_property_iterator_next(&it) ==
              &ctx->properties.array[2]);
-  GPR_ASSERT(grpc_auth_property_iterator_next(&it) == NULL);
+  GPR_ASSERT(grpc_auth_property_iterator_next(&it) == nullptr);
 
   it = grpc_auth_context_peer_identity(ctx);
   GPR_ASSERT(grpc_auth_property_iterator_next(&it) ==
              &ctx->properties.array[0]);
   GPR_ASSERT(grpc_auth_property_iterator_next(&it) ==
              &ctx->properties.array[1]);
-  GPR_ASSERT(grpc_auth_property_iterator_next(&it) == NULL);
+  GPR_ASSERT(grpc_auth_property_iterator_next(&it) == nullptr);
 
   GRPC_AUTH_CONTEXT_UNREF(ctx, "test");
 }
 
 static void test_chained_context(void) {
-  grpc_auth_context *chained = grpc_auth_context_create(NULL);
-  grpc_auth_context *ctx = grpc_auth_context_create(chained);
+  grpc_auth_context* chained = grpc_auth_context_create(nullptr);
+  grpc_auth_context* ctx = grpc_auth_context_create(chained);
   grpc_auth_property_iterator it;
   size_t i;
 
@@ -101,21 +101,21 @@ static void test_chained_context(void) {
       strcmp(grpc_auth_context_peer_identity_property_name(ctx), "name") == 0);
   it = grpc_auth_context_property_iterator(ctx);
   for (i = 0; i < ctx->properties.count; i++) {
-    const grpc_auth_property *p = grpc_auth_property_iterator_next(&it);
+    const grpc_auth_property* p = grpc_auth_property_iterator_next(&it);
     GPR_ASSERT(p == &ctx->properties.array[i]);
   }
   for (i = 0; i < chained->properties.count; i++) {
-    const grpc_auth_property *p = grpc_auth_property_iterator_next(&it);
+    const grpc_auth_property* p = grpc_auth_property_iterator_next(&it);
     GPR_ASSERT(p == &chained->properties.array[i]);
   }
-  GPR_ASSERT(grpc_auth_property_iterator_next(&it) == NULL);
+  GPR_ASSERT(grpc_auth_property_iterator_next(&it) == nullptr);
 
   it = grpc_auth_context_find_properties_by_name(ctx, "foo");
   GPR_ASSERT(grpc_auth_property_iterator_next(&it) ==
              &ctx->properties.array[2]);
   GPR_ASSERT(grpc_auth_property_iterator_next(&it) ==
              &chained->properties.array[1]);
-  GPR_ASSERT(grpc_auth_property_iterator_next(&it) == NULL);
+  GPR_ASSERT(grpc_auth_property_iterator_next(&it) == nullptr);
 
   it = grpc_auth_context_peer_identity(ctx);
   GPR_ASSERT(grpc_auth_property_iterator_next(&it) ==
@@ -124,12 +124,12 @@ static void test_chained_context(void) {
              &ctx->properties.array[1]);
   GPR_ASSERT(grpc_auth_property_iterator_next(&it) ==
              &chained->properties.array[0]);
-  GPR_ASSERT(grpc_auth_property_iterator_next(&it) == NULL);
+  GPR_ASSERT(grpc_auth_property_iterator_next(&it) == nullptr);
 
   GRPC_AUTH_CONTEXT_UNREF(ctx, "test");
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_empty_context();
   test_simple_context();
diff --git a/test/core/security/create_jwt.c b/test/core/security/create_jwt.cc
index 93ea27f425..867a8ba575 100644
--- a/test/core/security/create_jwt.c
+++ b/test/core/security/create_jwt.cc
@@ -27,25 +27,25 @@
 #include <grpc/support/cmdline.h>
 #include <grpc/support/log.h>
 
-void create_jwt(const char *json_key_file_path, const char *service_url,
-                const char *scope) {
+void create_jwt(const char* json_key_file_path, const char* service_url,
+                const char* scope) {
   grpc_auth_json_key key;
-  char *jwt;
+  char* jwt;
   grpc_slice json_key_data;
   GPR_ASSERT(GRPC_LOG_IF_ERROR(
       "load_file", grpc_load_file(json_key_file_path, 1, &json_key_data)));
   key = grpc_auth_json_key_create_from_string(
-      (const char *)GRPC_SLICE_START_PTR(json_key_data));
+      (const char*)GRPC_SLICE_START_PTR(json_key_data));
   grpc_slice_unref(json_key_data);
   if (!grpc_auth_json_key_is_valid(&key)) {
     fprintf(stderr, "Could not parse json key.\n");
     exit(1);
   }
   jwt = grpc_jwt_encode_and_sign(
-      &key, service_url == NULL ? GRPC_JWT_OAUTH2_AUDIENCE : service_url,
+      &key, service_url == nullptr ? GRPC_JWT_OAUTH2_AUDIENCE : service_url,
       grpc_max_auth_token_lifetime(), scope);
   grpc_auth_json_key_destruct(&key);
-  if (jwt == NULL) {
+  if (jwt == nullptr) {
     fprintf(stderr, "Could not create JWT.\n");
     exit(1);
   }
@@ -53,12 +53,12 @@ void create_jwt(const char *json_key_file_path, const char *service_url,
   gpr_free(jwt);
 }
 
-int main(int argc, char **argv) {
-  char *scope = NULL;
-  char *json_key_file_path = NULL;
-  char *service_url = NULL;
+int main(int argc, char** argv) {
+  const char* scope = nullptr;
+  const char* json_key_file_path = nullptr;
+  const char* service_url = nullptr;
   grpc_init();
-  gpr_cmdline *cl = gpr_cmdline_create("create_jwt");
+  gpr_cmdline* cl = gpr_cmdline_create("create_jwt");
   gpr_cmdline_add_string(cl, "json_key", "File path of the json key.",
                          &json_key_file_path);
   gpr_cmdline_add_string(cl, "scope",
@@ -70,17 +70,17 @@ int main(int argc, char **argv) {
                          &service_url);
   gpr_cmdline_parse(cl, argc, argv);
 
-  if (json_key_file_path == NULL) {
+  if (json_key_file_path == nullptr) {
     fprintf(stderr, "Missing --json_key option.\n");
     exit(1);
   }
-  if (scope != NULL) {
-    if (service_url != NULL) {
+  if (scope != nullptr) {
+    if (service_url != nullptr) {
       fprintf(stderr,
               "Options --scope and --service_url are mutually exclusive.\n");
       exit(1);
     }
-  } else if (service_url == NULL) {
+  } else if (service_url == nullptr) {
     fprintf(stderr, "Need one of --service_url or --scope options.\n");
     exit(1);
   }
diff --git a/test/core/security/credentials_test.c b/test/core/security/credentials_test.cc
index 34f310142c..64d383ad0a 100644
--- a/test/core/security/credentials_test.c
+++ b/test/core/security/credentials_test.cc
@@ -24,6 +24,8 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include <grpc/slice.h>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -35,6 +37,7 @@
 #include "src/core/lib/security/credentials/google_default/google_default_credentials.h"
 #include "src/core/lib/security/credentials/jwt/jwt_credentials.h"
 #include "src/core/lib/security/credentials/oauth2/oauth2_credentials.h"
+#include "src/core/lib/security/transport/auth_filters.h"
 #include "src/core/lib/support/env.h"
 #include "src/core/lib/support/string.h"
 #include "src/core/lib/support/tmpfile.h"
@@ -42,9 +45,10 @@
 
 /* -- Mock channel credentials. -- */
 
-static grpc_channel_credentials *grpc_mock_channel_credentials_create(
-    const grpc_channel_credentials_vtable *vtable) {
-  grpc_channel_credentials *c = gpr_malloc(sizeof(*c));
+static grpc_channel_credentials* grpc_mock_channel_credentials_create(
+    const grpc_channel_credentials_vtable* vtable) {
+  grpc_channel_credentials* c =
+      static_cast<grpc_channel_credentials*>(gpr_malloc(sizeof(*c)));
   memset(c, 0, sizeof(*c));
   c->type = "mock";
   c->vtable = vtable;
@@ -118,12 +122,12 @@ static const char test_method[] = "ThisIsNotAMethod";
 
 /* -- Utils. -- */
 
-static char *test_json_key_str(void) {
+static char* test_json_key_str(void) {
   size_t result_len = strlen(test_json_key_str_part1) +
                       strlen(test_json_key_str_part2) +
                       strlen(test_json_key_str_part3);
-  char *result = gpr_malloc(result_len + 1);
-  char *current = result;
+  char* result = static_cast<char*>(gpr_malloc(result_len + 1));
+  char* current = result;
   strcpy(result, test_json_key_str_part1);
   current += strlen(test_json_key_str_part1);
   strcpy(current, test_json_key_str_part2);
@@ -132,11 +136,11 @@ static char *test_json_key_str(void) {
   return result;
 }
 
-static grpc_httpcli_response http_response(int status, const char *body) {
+static grpc_httpcli_response http_response(int status, const char* body) {
   grpc_httpcli_response response;
   memset(&response, 0, sizeof(grpc_httpcli_response));
   response.status = status;
-  response.body = gpr_strdup((char *)body);
+  response.body = gpr_strdup((char*)body);
   response.body_length = strlen(body);
   return response;
 }
@@ -147,7 +151,7 @@ static void test_empty_md_array(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_credentials_mdelem_array md_array;
   memset(&md_array, 0, sizeof(md_array));
-  GPR_ASSERT(md_array.md == NULL);
+  GPR_ASSERT(md_array.md == nullptr);
   GPR_ASSERT(md_array.size == 0);
   grpc_credentials_mdelem_array_destroy(&exec_ctx, &md_array);
   grpc_exec_ctx_finish(&exec_ctx);
@@ -157,8 +161,8 @@ static void test_add_to_empty_md_array(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_credentials_mdelem_array md_array;
   memset(&md_array, 0, sizeof(md_array));
-  const char *key = "hello";
-  const char *value = "there blah blah blah blah blah blah blah";
+  const char* key = "hello";
+  const char* value = "there blah blah blah blah blah blah blah";
   grpc_mdelem md =
       grpc_mdelem_from_slices(&exec_ctx, grpc_slice_from_copied_string(key),
                               grpc_slice_from_copied_string(value));
@@ -174,8 +178,8 @@ static void test_add_abunch_to_md_array(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_credentials_mdelem_array md_array;
   memset(&md_array, 0, sizeof(md_array));
-  const char *key = "hello";
-  const char *value = "there blah blah blah blah blah blah blah";
+  const char* key = "hello";
+  const char* value = "there blah blah blah blah blah blah blah";
   grpc_mdelem md =
       grpc_mdelem_from_slices(&exec_ctx, grpc_slice_from_copied_string(key),
                               grpc_slice_from_copied_string(value));
@@ -299,22 +303,22 @@ static void test_oauth2_token_fetcher_creds_parsing_missing_token_lifetime(
 }
 
 typedef struct {
-  const char *key;
-  const char *value;
+  const char* key;
+  const char* value;
 } expected_md;
 
 typedef struct {
-  grpc_error *expected_error;
-  const expected_md *expected;
+  grpc_error* expected_error;
+  const expected_md* expected;
   size_t expected_size;
   grpc_credentials_mdelem_array md_array;
   grpc_closure on_request_metadata;
-  grpc_call_credentials *creds;
+  grpc_call_credentials* creds;
   grpc_polling_entity pollent;
 } request_metadata_state;
 
-static void check_metadata(const expected_md *expected,
-                           grpc_credentials_mdelem_array *md_array) {
+static void check_metadata(const expected_md* expected,
+                           grpc_credentials_mdelem_array* md_array) {
   for (size_t i = 0; i < md_array->size; ++i) {
     size_t j;
     for (j = 0; j < md_array->size; ++j) {
@@ -332,9 +336,9 @@ static void check_metadata(const expected_md *expected,
   }
 }
 
-static void check_request_metadata(grpc_exec_ctx *exec_ctx, void *arg,
-                                   grpc_error *error) {
-  request_metadata_state *state = (request_metadata_state *)arg;
+static void check_request_metadata(grpc_exec_ctx* exec_ctx, void* arg,
+                                   grpc_error* error) {
+  request_metadata_state* state = (request_metadata_state*)arg;
   gpr_log(GPR_INFO, "expected_error: %s",
           grpc_error_string(state->expected_error));
   gpr_log(GPR_INFO, "actual_error: %s", grpc_error_string(error));
@@ -360,10 +364,11 @@ static void check_request_metadata(grpc_exec_ctx *exec_ctx, void *arg,
   gpr_free(state);
 }
 
-static request_metadata_state *make_request_metadata_state(
-    grpc_error *expected_error, const expected_md *expected,
+static request_metadata_state* make_request_metadata_state(
+    grpc_error* expected_error, const expected_md* expected,
     size_t expected_size) {
-  request_metadata_state *state = gpr_zalloc(sizeof(*state));
+  request_metadata_state* state =
+      static_cast<request_metadata_state*>(gpr_zalloc(sizeof(*state)));
   state->expected_error = expected_error;
   state->expected = expected;
   state->expected_size = expected_size;
@@ -374,11 +379,11 @@ static request_metadata_state *make_request_metadata_state(
   return state;
 }
 
-static void run_request_metadata_test(grpc_exec_ctx *exec_ctx,
-                                      grpc_call_credentials *creds,
+static void run_request_metadata_test(grpc_exec_ctx* exec_ctx,
+                                      grpc_call_credentials* creds,
                                       grpc_auth_metadata_context auth_md_ctx,
-                                      request_metadata_state *state) {
-  grpc_error *error = GRPC_ERROR_NONE;
+                                      request_metadata_state* state) {
+  grpc_error* error = GRPC_ERROR_NONE;
   if (grpc_call_credentials_get_request_metadata(
           exec_ctx, creds, &state->pollent, auth_md_ctx, &state->md_array,
           &state->on_request_metadata, &error)) {
@@ -394,13 +399,13 @@ static void test_google_iam_creds(void) {
                         test_google_iam_authorization_token},
                        {GRPC_IAM_AUTHORITY_SELECTOR_METADATA_KEY,
                         test_google_iam_authority_selector}};
-  request_metadata_state *state =
+  request_metadata_state* state =
       make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd));
-  grpc_call_credentials *creds = grpc_google_iam_credentials_create(
+  grpc_call_credentials* creds = grpc_google_iam_credentials_create(
       test_google_iam_authorization_token, test_google_iam_authority_selector,
-      NULL);
-  grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, NULL,
-                                            NULL};
+      nullptr);
+  grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method,
+                                            nullptr, nullptr};
   run_request_metadata_test(&exec_ctx, creds, auth_md_ctx, state);
   grpc_call_credentials_unref(&exec_ctx, creds);
   grpc_exec_ctx_finish(&exec_ctx);
@@ -409,12 +414,12 @@ static void test_google_iam_creds(void) {
 static void test_access_token_creds(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   expected_md emd[] = {{GRPC_AUTHORIZATION_METADATA_KEY, "Bearer blah"}};
-  request_metadata_state *state =
+  request_metadata_state* state =
       make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd));
-  grpc_call_credentials *creds =
-      grpc_access_token_credentials_create("blah", NULL);
-  grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, NULL,
-                                            NULL};
+  grpc_call_credentials* creds =
+      grpc_access_token_credentials_create("blah", nullptr);
+  grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method,
+                                            nullptr, nullptr};
   GPR_ASSERT(strcmp(creds->type, GRPC_CALL_CREDENTIALS_TYPE_OAUTH2) == 0);
   run_request_metadata_test(&exec_ctx, creds, auth_md_ctx, state);
   grpc_call_credentials_unref(&exec_ctx, creds);
@@ -422,32 +427,32 @@ static void test_access_token_creds(void) {
 }
 
 static grpc_security_status check_channel_oauth2_create_security_connector(
-    grpc_exec_ctx *exec_ctx, grpc_channel_credentials *c,
-    grpc_call_credentials *call_creds, const char *target,
-    const grpc_channel_args *args, grpc_channel_security_connector **sc,
-    grpc_channel_args **new_args) {
+    grpc_exec_ctx* exec_ctx, grpc_channel_credentials* c,
+    grpc_call_credentials* call_creds, const char* target,
+    const grpc_channel_args* args, grpc_channel_security_connector** sc,
+    grpc_channel_args** new_args) {
   GPR_ASSERT(strcmp(c->type, "mock") == 0);
-  GPR_ASSERT(call_creds != NULL);
+  GPR_ASSERT(call_creds != nullptr);
   GPR_ASSERT(strcmp(call_creds->type, GRPC_CALL_CREDENTIALS_TYPE_OAUTH2) == 0);
   return GRPC_SECURITY_OK;
 }
 
 static void test_channel_oauth2_composite_creds(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_channel_args *new_args;
+  grpc_channel_args* new_args;
   grpc_channel_credentials_vtable vtable = {
-      NULL, check_channel_oauth2_create_security_connector, NULL};
-  grpc_channel_credentials *channel_creds =
+      nullptr, check_channel_oauth2_create_security_connector, nullptr};
+  grpc_channel_credentials* channel_creds =
       grpc_mock_channel_credentials_create(&vtable);
-  grpc_call_credentials *oauth2_creds =
-      grpc_access_token_credentials_create("blah", NULL);
-  grpc_channel_credentials *channel_oauth2_creds =
+  grpc_call_credentials* oauth2_creds =
+      grpc_access_token_credentials_create("blah", nullptr);
+  grpc_channel_credentials* channel_oauth2_creds =
       grpc_composite_channel_credentials_create(channel_creds, oauth2_creds,
-                                                NULL);
+                                                nullptr);
   grpc_channel_credentials_release(channel_creds);
   grpc_call_credentials_release(oauth2_creds);
   GPR_ASSERT(grpc_channel_credentials_create_security_connector(
-                 &exec_ctx, channel_oauth2_creds, NULL, NULL, NULL,
+                 &exec_ctx, channel_oauth2_creds, nullptr, nullptr, nullptr,
                  &new_args) == GRPC_SECURITY_OK);
   grpc_channel_credentials_release(channel_oauth2_creds);
   grpc_exec_ctx_finish(&exec_ctx);
@@ -461,23 +466,23 @@ static void test_oauth2_google_iam_composite_creds(void) {
        test_google_iam_authorization_token},
       {GRPC_IAM_AUTHORITY_SELECTOR_METADATA_KEY,
        test_google_iam_authority_selector}};
-  request_metadata_state *state =
+  request_metadata_state* state =
       make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd));
-  grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, NULL,
-                                            NULL};
-  grpc_call_credentials *oauth2_creds = grpc_md_only_test_credentials_create(
+  grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method,
+                                            nullptr, nullptr};
+  grpc_call_credentials* oauth2_creds = grpc_md_only_test_credentials_create(
       &exec_ctx, "authorization", test_oauth2_bearer_token, 0);
-  grpc_call_credentials *google_iam_creds = grpc_google_iam_credentials_create(
+  grpc_call_credentials* google_iam_creds = grpc_google_iam_credentials_create(
       test_google_iam_authorization_token, test_google_iam_authority_selector,
-      NULL);
-  grpc_call_credentials *composite_creds =
+      nullptr);
+  grpc_call_credentials* composite_creds =
       grpc_composite_call_credentials_create(oauth2_creds, google_iam_creds,
-                                             NULL);
+                                             nullptr);
   grpc_call_credentials_unref(&exec_ctx, oauth2_creds);
   grpc_call_credentials_unref(&exec_ctx, google_iam_creds);
   GPR_ASSERT(
       strcmp(composite_creds->type, GRPC_CALL_CREDENTIALS_TYPE_COMPOSITE) == 0);
-  const grpc_call_credentials_array *creds_array =
+  const grpc_call_credentials_array* creds_array =
       grpc_composite_call_credentials_get_credentials(composite_creds);
   GPR_ASSERT(creds_array->num_creds == 2);
   GPR_ASSERT(strcmp(creds_array->creds_array[0]->type,
@@ -491,13 +496,13 @@ static void test_oauth2_google_iam_composite_creds(void) {
 
 static grpc_security_status
 check_channel_oauth2_google_iam_create_security_connector(
-    grpc_exec_ctx *exec_ctx, grpc_channel_credentials *c,
-    grpc_call_credentials *call_creds, const char *target,
-    const grpc_channel_args *args, grpc_channel_security_connector **sc,
-    grpc_channel_args **new_args) {
-  const grpc_call_credentials_array *creds_array;
+    grpc_exec_ctx* exec_ctx, grpc_channel_credentials* c,
+    grpc_call_credentials* call_creds, const char* target,
+    const grpc_channel_args* args, grpc_channel_security_connector** sc,
+    grpc_channel_args** new_args) {
+  const grpc_call_credentials_array* creds_array;
   GPR_ASSERT(strcmp(c->type, "mock") == 0);
-  GPR_ASSERT(call_creds != NULL);
+  GPR_ASSERT(call_creds != nullptr);
   GPR_ASSERT(strcmp(call_creds->type, GRPC_CALL_CREDENTIALS_TYPE_COMPOSITE) ==
              0);
   creds_array = grpc_composite_call_credentials_get_credentials(call_creds);
@@ -510,29 +515,30 @@ check_channel_oauth2_google_iam_create_security_connector(
 
 static void test_channel_oauth2_google_iam_composite_creds(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_channel_args *new_args;
+  grpc_channel_args* new_args;
   grpc_channel_credentials_vtable vtable = {
-      NULL, check_channel_oauth2_google_iam_create_security_connector, NULL};
-  grpc_channel_credentials *channel_creds =
+      nullptr, check_channel_oauth2_google_iam_create_security_connector,
+      nullptr};
+  grpc_channel_credentials* channel_creds =
       grpc_mock_channel_credentials_create(&vtable);
-  grpc_call_credentials *oauth2_creds =
-      grpc_access_token_credentials_create("blah", NULL);
-  grpc_channel_credentials *channel_oauth2_creds =
+  grpc_call_credentials* oauth2_creds =
+      grpc_access_token_credentials_create("blah", nullptr);
+  grpc_channel_credentials* channel_oauth2_creds =
       grpc_composite_channel_credentials_create(channel_creds, oauth2_creds,
-                                                NULL);
-  grpc_call_credentials *google_iam_creds = grpc_google_iam_credentials_create(
+                                                nullptr);
+  grpc_call_credentials* google_iam_creds = grpc_google_iam_credentials_create(
       test_google_iam_authorization_token, test_google_iam_authority_selector,
-      NULL);
-  grpc_channel_credentials *channel_oauth2_iam_creds =
+      nullptr);
+  grpc_channel_credentials* channel_oauth2_iam_creds =
       grpc_composite_channel_credentials_create(channel_oauth2_creds,
-                                                google_iam_creds, NULL);
+                                                google_iam_creds, nullptr);
   grpc_channel_credentials_release(channel_creds);
   grpc_call_credentials_release(oauth2_creds);
   grpc_channel_credentials_release(channel_oauth2_creds);
   grpc_call_credentials_release(google_iam_creds);
 
   GPR_ASSERT(grpc_channel_credentials_create_security_connector(
-                 &exec_ctx, channel_oauth2_iam_creds, NULL, NULL, NULL,
+                 &exec_ctx, channel_oauth2_iam_creds, nullptr, nullptr, nullptr,
                  &new_args) == GRPC_SECURITY_OK);
 
   grpc_channel_credentials_release(channel_oauth2_iam_creds);
@@ -540,7 +546,7 @@ static void test_channel_oauth2_google_iam_composite_creds(void) {
 }
 
 static void validate_compute_engine_http_request(
-    const grpc_httpcli_request *request) {
+    const grpc_httpcli_request* request) {
   GPR_ASSERT(request->handshaker != &grpc_httpcli_ssl);
   GPR_ASSERT(strcmp(request->host, "metadata.google.internal") == 0);
   GPR_ASSERT(
@@ -553,9 +559,9 @@ static void validate_compute_engine_http_request(
 }
 
 static int compute_engine_httpcli_get_success_override(
-    grpc_exec_ctx *exec_ctx, const grpc_httpcli_request *request,
-    grpc_millis deadline, grpc_closure *on_done,
-    grpc_httpcli_response *response) {
+    grpc_exec_ctx* exec_ctx, const grpc_httpcli_request* request,
+    grpc_millis deadline, grpc_closure* on_done,
+    grpc_httpcli_response* response) {
   validate_compute_engine_http_request(request);
   *response = http_response(200, valid_oauth2_json_response);
   GRPC_CLOSURE_SCHED(exec_ctx, on_done, GRPC_ERROR_NONE);
@@ -563,9 +569,9 @@ static int compute_engine_httpcli_get_success_override(
 }
 
 static int compute_engine_httpcli_get_failure_override(
-    grpc_exec_ctx *exec_ctx, const grpc_httpcli_request *request,
-    grpc_millis deadline, grpc_closure *on_done,
-    grpc_httpcli_response *response) {
+    grpc_exec_ctx* exec_ctx, const grpc_httpcli_request* request,
+    grpc_millis deadline, grpc_closure* on_done,
+    grpc_httpcli_response* response) {
   validate_compute_engine_http_request(request);
   *response = http_response(403, "Not Authorized.");
   GRPC_CLOSURE_SCHED(exec_ctx, on_done, GRPC_ERROR_NONE);
@@ -573,19 +579,19 @@ static int compute_engine_httpcli_get_failure_override(
 }
 
 static int httpcli_post_should_not_be_called(
-    grpc_exec_ctx *exec_ctx, const grpc_httpcli_request *request,
-    const char *body_bytes, size_t body_size, grpc_millis deadline,
-    grpc_closure *on_done, grpc_httpcli_response *response) {
-  GPR_ASSERT("HTTP POST should not be called" == NULL);
+    grpc_exec_ctx* exec_ctx, const grpc_httpcli_request* request,
+    const char* body_bytes, size_t body_size, grpc_millis deadline,
+    grpc_closure* on_done, grpc_httpcli_response* response) {
+  GPR_ASSERT("HTTP POST should not be called" == nullptr);
   return 1;
 }
 
-static int httpcli_get_should_not_be_called(grpc_exec_ctx *exec_ctx,
-                                            const grpc_httpcli_request *request,
+static int httpcli_get_should_not_be_called(grpc_exec_ctx* exec_ctx,
+                                            const grpc_httpcli_request* request,
                                             grpc_millis deadline,
-                                            grpc_closure *on_done,
-                                            grpc_httpcli_response *response) {
-  GPR_ASSERT("HTTP GET should not be called" == NULL);
+                                            grpc_closure* on_done,
+                                            grpc_httpcli_response* response) {
+  GPR_ASSERT("HTTP GET should not be called" == nullptr);
   return 1;
 }
 
@@ -593,13 +599,13 @@ static void test_compute_engine_creds_success(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   expected_md emd[] = {
       {"authorization", "Bearer ya29.AHES6ZRN3-HlhAPya30GnW_bHSb_"}};
-  grpc_call_credentials *creds =
-      grpc_google_compute_engine_credentials_create(NULL);
-  grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, NULL,
-                                            NULL};
+  grpc_call_credentials* creds =
+      grpc_google_compute_engine_credentials_create(nullptr);
+  grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method,
+                                            nullptr, nullptr};
 
   /* First request: http get should be called. */
-  request_metadata_state *state =
+  request_metadata_state* state =
       make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd));
   grpc_httpcli_set_override(compute_engine_httpcli_get_success_override,
                             httpcli_post_should_not_be_called);
@@ -615,33 +621,33 @@ static void test_compute_engine_creds_success(void) {
   grpc_exec_ctx_flush(&exec_ctx);
 
   grpc_call_credentials_unref(&exec_ctx, creds);
-  grpc_httpcli_set_override(NULL, NULL);
+  grpc_httpcli_set_override(nullptr, nullptr);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
 static void test_compute_engine_creds_failure(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  request_metadata_state *state = make_request_metadata_state(
+  request_metadata_state* state = make_request_metadata_state(
       GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           "Error occured when fetching oauth2 token."),
-      NULL, 0);
-  grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, NULL,
-                                            NULL};
-  grpc_call_credentials *creds =
-      grpc_google_compute_engine_credentials_create(NULL);
+      nullptr, 0);
+  grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method,
+                                            nullptr, nullptr};
+  grpc_call_credentials* creds =
+      grpc_google_compute_engine_credentials_create(nullptr);
   grpc_httpcli_set_override(compute_engine_httpcli_get_failure_override,
                             httpcli_post_should_not_be_called);
   run_request_metadata_test(&exec_ctx, creds, auth_md_ctx, state);
   grpc_call_credentials_unref(&exec_ctx, creds);
-  grpc_httpcli_set_override(NULL, NULL);
+  grpc_httpcli_set_override(nullptr, nullptr);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
 static void validate_refresh_token_http_request(
-    const grpc_httpcli_request *request, const char *body, size_t body_size) {
+    const grpc_httpcli_request* request, const char* body, size_t body_size) {
   /* The content of the assertion is tested extensively in json_token_test. */
-  char *expected_body = NULL;
-  GPR_ASSERT(body != NULL);
+  char* expected_body = nullptr;
+  GPR_ASSERT(body != nullptr);
   GPR_ASSERT(body_size != 0);
   gpr_asprintf(&expected_body, GRPC_REFRESH_TOKEN_POST_BODY_FORMAT_STRING,
                "32555999999.apps.googleusercontent.com",
@@ -661,9 +667,9 @@ static void validate_refresh_token_http_request(
 }
 
 static int refresh_token_httpcli_post_success(
-    grpc_exec_ctx *exec_ctx, const grpc_httpcli_request *request,
-    const char *body, size_t body_size, grpc_millis deadline,
-    grpc_closure *on_done, grpc_httpcli_response *response) {
+    grpc_exec_ctx* exec_ctx, const grpc_httpcli_request* request,
+    const char* body, size_t body_size, grpc_millis deadline,
+    grpc_closure* on_done, grpc_httpcli_response* response) {
   validate_refresh_token_http_request(request, body, body_size);
   *response = http_response(200, valid_oauth2_json_response);
   GRPC_CLOSURE_SCHED(exec_ctx, on_done, GRPC_ERROR_NONE);
@@ -671,9 +677,9 @@ static int refresh_token_httpcli_post_success(
 }
 
 static int refresh_token_httpcli_post_failure(
-    grpc_exec_ctx *exec_ctx, const grpc_httpcli_request *request,
-    const char *body, size_t body_size, grpc_millis deadline,
-    grpc_closure *on_done, grpc_httpcli_response *response) {
+    grpc_exec_ctx* exec_ctx, const grpc_httpcli_request* request,
+    const char* body, size_t body_size, grpc_millis deadline,
+    grpc_closure* on_done, grpc_httpcli_response* response) {
   validate_refresh_token_http_request(request, body, body_size);
   *response = http_response(403, "Not Authorized.");
   GRPC_CLOSURE_SCHED(exec_ctx, on_done, GRPC_ERROR_NONE);
@@ -684,13 +690,13 @@ static void test_refresh_token_creds_success(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   expected_md emd[] = {
       {"authorization", "Bearer ya29.AHES6ZRN3-HlhAPya30GnW_bHSb_"}};
-  grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, NULL,
-                                            NULL};
-  grpc_call_credentials *creds = grpc_google_refresh_token_credentials_create(
-      test_refresh_token_str, NULL);
+  grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method,
+                                            nullptr, nullptr};
+  grpc_call_credentials* creds = grpc_google_refresh_token_credentials_create(
+      test_refresh_token_str, nullptr);
 
   /* First request: http get should be called. */
-  request_metadata_state *state =
+  request_metadata_state* state =
       make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd));
   grpc_httpcli_set_override(httpcli_get_should_not_be_called,
                             refresh_token_httpcli_post_success);
@@ -706,88 +712,88 @@ static void test_refresh_token_creds_success(void) {
   grpc_exec_ctx_flush(&exec_ctx);
 
   grpc_call_credentials_unref(&exec_ctx, creds);
-  grpc_httpcli_set_override(NULL, NULL);
+  grpc_httpcli_set_override(nullptr, nullptr);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
 static void test_refresh_token_creds_failure(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  request_metadata_state *state = make_request_metadata_state(
+  request_metadata_state* state = make_request_metadata_state(
       GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           "Error occured when fetching oauth2 token."),
-      NULL, 0);
-  grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, NULL,
-                                            NULL};
-  grpc_call_credentials *creds = grpc_google_refresh_token_credentials_create(
-      test_refresh_token_str, NULL);
+      nullptr, 0);
+  grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method,
+                                            nullptr, nullptr};
+  grpc_call_credentials* creds = grpc_google_refresh_token_credentials_create(
+      test_refresh_token_str, nullptr);
   grpc_httpcli_set_override(httpcli_get_should_not_be_called,
                             refresh_token_httpcli_post_failure);
   run_request_metadata_test(&exec_ctx, creds, auth_md_ctx, state);
   grpc_call_credentials_unref(&exec_ctx, creds);
-  grpc_httpcli_set_override(NULL, NULL);
+  grpc_httpcli_set_override(nullptr, nullptr);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
 static void validate_jwt_encode_and_sign_params(
-    const grpc_auth_json_key *json_key, const char *scope,
+    const grpc_auth_json_key* json_key, const char* scope,
     gpr_timespec token_lifetime) {
   GPR_ASSERT(grpc_auth_json_key_is_valid(json_key));
-  GPR_ASSERT(json_key->private_key != NULL);
+  GPR_ASSERT(json_key->private_key != nullptr);
   GPR_ASSERT(RSA_check_key(json_key->private_key));
-  GPR_ASSERT(json_key->type != NULL &&
+  GPR_ASSERT(json_key->type != nullptr &&
              strcmp(json_key->type, "service_account") == 0);
-  GPR_ASSERT(json_key->private_key_id != NULL &&
+  GPR_ASSERT(json_key->private_key_id != nullptr &&
              strcmp(json_key->private_key_id,
                     "e6b5137873db8d2ef81e06a47289e6434ec8a165") == 0);
-  GPR_ASSERT(json_key->client_id != NULL &&
+  GPR_ASSERT(json_key->client_id != nullptr &&
              strcmp(json_key->client_id,
                     "777-abaslkan11hlb6nmim3bpspl31ud.apps."
                     "googleusercontent.com") == 0);
-  GPR_ASSERT(json_key->client_email != NULL &&
+  GPR_ASSERT(json_key->client_email != nullptr &&
              strcmp(json_key->client_email,
                     "777-abaslkan11hlb6nmim3bpspl31ud@developer."
                     "gserviceaccount.com") == 0);
-  if (scope != NULL) GPR_ASSERT(strcmp(scope, test_scope) == 0);
+  if (scope != nullptr) GPR_ASSERT(strcmp(scope, test_scope) == 0);
   GPR_ASSERT(!gpr_time_cmp(token_lifetime, grpc_max_auth_token_lifetime()));
 }
 
-static char *encode_and_sign_jwt_success(const grpc_auth_json_key *json_key,
-                                         const char *audience,
+static char* encode_and_sign_jwt_success(const grpc_auth_json_key* json_key,
+                                         const char* audience,
                                          gpr_timespec token_lifetime,
-                                         const char *scope) {
+                                         const char* scope) {
   validate_jwt_encode_and_sign_params(json_key, scope, token_lifetime);
   return gpr_strdup(test_signed_jwt);
 }
 
-static char *encode_and_sign_jwt_failure(const grpc_auth_json_key *json_key,
-                                         const char *audience,
+static char* encode_and_sign_jwt_failure(const grpc_auth_json_key* json_key,
+                                         const char* audience,
                                          gpr_timespec token_lifetime,
-                                         const char *scope) {
+                                         const char* scope) {
   validate_jwt_encode_and_sign_params(json_key, scope, token_lifetime);
-  return NULL;
+  return nullptr;
 }
 
-static char *encode_and_sign_jwt_should_not_be_called(
-    const grpc_auth_json_key *json_key, const char *audience,
-    gpr_timespec token_lifetime, const char *scope) {
-  GPR_ASSERT("grpc_jwt_encode_and_sign should not be called" == NULL);
-  return NULL;
+static char* encode_and_sign_jwt_should_not_be_called(
+    const grpc_auth_json_key* json_key, const char* audience,
+    gpr_timespec token_lifetime, const char* scope) {
+  GPR_ASSERT("grpc_jwt_encode_and_sign should not be called" == nullptr);
+  return nullptr;
 }
 
-static grpc_service_account_jwt_access_credentials *creds_as_jwt(
-    grpc_call_credentials *creds) {
-  GPR_ASSERT(creds != NULL);
+static grpc_service_account_jwt_access_credentials* creds_as_jwt(
+    grpc_call_credentials* creds) {
+  GPR_ASSERT(creds != nullptr);
   GPR_ASSERT(strcmp(creds->type, GRPC_CALL_CREDENTIALS_TYPE_JWT) == 0);
-  return (grpc_service_account_jwt_access_credentials *)creds;
+  return (grpc_service_account_jwt_access_credentials*)creds;
 }
 
 static void test_jwt_creds_lifetime(void) {
-  char *json_key_string = test_json_key_str();
+  char* json_key_string = test_json_key_str();
 
   // Max lifetime.
-  grpc_call_credentials *jwt_creds =
+  grpc_call_credentials* jwt_creds =
       grpc_service_account_jwt_access_credentials_create(
-          json_key_string, grpc_max_auth_token_lifetime(), NULL);
+          json_key_string, grpc_max_auth_token_lifetime(), nullptr);
   GPR_ASSERT(gpr_time_cmp(creds_as_jwt(jwt_creds)->jwt_lifetime,
                           grpc_max_auth_token_lifetime()) == 0);
   grpc_call_credentials_release(jwt_creds);
@@ -796,7 +802,7 @@ static void test_jwt_creds_lifetime(void) {
   gpr_timespec token_lifetime = {10, 0, GPR_TIMESPAN};
   GPR_ASSERT(gpr_time_cmp(grpc_max_auth_token_lifetime(), token_lifetime) > 0);
   jwt_creds = grpc_service_account_jwt_access_credentials_create(
-      json_key_string, token_lifetime, NULL);
+      json_key_string, token_lifetime, nullptr);
   GPR_ASSERT(
       gpr_time_cmp(creds_as_jwt(jwt_creds)->jwt_lifetime, token_lifetime) == 0);
   grpc_call_credentials_release(jwt_creds);
@@ -805,7 +811,7 @@ static void test_jwt_creds_lifetime(void) {
   gpr_timespec add_to_max = {10, 0, GPR_TIMESPAN};
   token_lifetime = gpr_time_add(grpc_max_auth_token_lifetime(), add_to_max);
   jwt_creds = grpc_service_account_jwt_access_credentials_create(
-      json_key_string, token_lifetime, NULL);
+      json_key_string, token_lifetime, nullptr);
   GPR_ASSERT(gpr_time_cmp(creds_as_jwt(jwt_creds)->jwt_lifetime,
                           grpc_max_auth_token_lifetime()) == 0);
   grpc_call_credentials_release(jwt_creds);
@@ -814,19 +820,19 @@ static void test_jwt_creds_lifetime(void) {
 }
 
 static void test_jwt_creds_success(void) {
-  char *json_key_string = test_json_key_str();
+  char* json_key_string = test_json_key_str();
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, NULL,
-                                            NULL};
-  char *expected_md_value;
+  grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method,
+                                            nullptr, nullptr};
+  char* expected_md_value;
   gpr_asprintf(&expected_md_value, "Bearer %s", test_signed_jwt);
   expected_md emd[] = {{"authorization", expected_md_value}};
-  grpc_call_credentials *creds =
+  grpc_call_credentials* creds =
       grpc_service_account_jwt_access_credentials_create(
-          json_key_string, grpc_max_auth_token_lifetime(), NULL);
+          json_key_string, grpc_max_auth_token_lifetime(), nullptr);
 
   /* First request: jwt_encode_and_sign should be called. */
-  request_metadata_state *state =
+  request_metadata_state* state =
       make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd));
   grpc_jwt_encode_and_sign_set_override(encode_and_sign_jwt_success);
   run_request_metadata_test(&exec_ctx, creds, auth_md_ctx, state);
@@ -852,37 +858,38 @@ static void test_jwt_creds_success(void) {
   grpc_call_credentials_unref(&exec_ctx, creds);
   gpr_free(json_key_string);
   gpr_free(expected_md_value);
-  grpc_jwt_encode_and_sign_set_override(NULL);
+  grpc_jwt_encode_and_sign_set_override(nullptr);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
 static void test_jwt_creds_signing_failure(void) {
-  char *json_key_string = test_json_key_str();
+  char* json_key_string = test_json_key_str();
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, NULL,
-                                            NULL};
-  request_metadata_state *state = make_request_metadata_state(
-      GRPC_ERROR_CREATE_FROM_STATIC_STRING("Could not generate JWT."), NULL, 0);
-  grpc_call_credentials *creds =
+  grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method,
+                                            nullptr, nullptr};
+  request_metadata_state* state = make_request_metadata_state(
+      GRPC_ERROR_CREATE_FROM_STATIC_STRING("Could not generate JWT."), nullptr,
+      0);
+  grpc_call_credentials* creds =
       grpc_service_account_jwt_access_credentials_create(
-          json_key_string, grpc_max_auth_token_lifetime(), NULL);
+          json_key_string, grpc_max_auth_token_lifetime(), nullptr);
 
   grpc_jwt_encode_and_sign_set_override(encode_and_sign_jwt_failure);
   run_request_metadata_test(&exec_ctx, creds, auth_md_ctx, state);
 
   gpr_free(json_key_string);
   grpc_call_credentials_unref(&exec_ctx, creds);
-  grpc_jwt_encode_and_sign_set_override(NULL);
+  grpc_jwt_encode_and_sign_set_override(nullptr);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
 static void set_google_default_creds_env_var_with_file_contents(
-    const char *file_prefix, const char *contents) {
+    const char* file_prefix, const char* contents) {
   size_t contents_len = strlen(contents);
-  char *creds_file_name;
-  FILE *creds_file = gpr_tmpfile(file_prefix, &creds_file_name);
-  GPR_ASSERT(creds_file_name != NULL);
-  GPR_ASSERT(creds_file != NULL);
+  char* creds_file_name;
+  FILE* creds_file = gpr_tmpfile(file_prefix, &creds_file_name);
+  GPR_ASSERT(creds_file_name != nullptr);
+  GPR_ASSERT(creds_file != nullptr);
   GPR_ASSERT(fwrite(contents, 1, contents_len, creds_file) == contents_len);
   fclose(creds_file);
   gpr_setenv(GRPC_GOOGLE_CREDENTIALS_ENV_VAR, creds_file_name);
@@ -891,17 +898,17 @@ static void set_google_default_creds_env_var_with_file_contents(
 
 static void test_google_default_creds_auth_key(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_service_account_jwt_access_credentials *jwt;
-  grpc_composite_channel_credentials *creds;
-  char *json_key = test_json_key_str();
+  grpc_service_account_jwt_access_credentials* jwt;
+  grpc_composite_channel_credentials* creds;
+  char* json_key = test_json_key_str();
   grpc_flush_cached_google_default_credentials();
   set_google_default_creds_env_var_with_file_contents(
       "json_key_google_default_creds", json_key);
   gpr_free(json_key);
-  creds = (grpc_composite_channel_credentials *)
+  creds = (grpc_composite_channel_credentials*)
       grpc_google_default_credentials_create();
-  GPR_ASSERT(creds != NULL);
-  jwt = (grpc_service_account_jwt_access_credentials *)creds->call_creds;
+  GPR_ASSERT(creds != nullptr);
+  jwt = (grpc_service_account_jwt_access_credentials*)creds->call_creds;
   GPR_ASSERT(
       strcmp(jwt->key.client_id,
              "777-abaslkan11hlb6nmim3bpspl31ud.apps.googleusercontent.com") ==
@@ -913,15 +920,15 @@ static void test_google_default_creds_auth_key(void) {
 
 static void test_google_default_creds_refresh_token(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_google_refresh_token_credentials *refresh;
-  grpc_composite_channel_credentials *creds;
+  grpc_google_refresh_token_credentials* refresh;
+  grpc_composite_channel_credentials* creds;
   grpc_flush_cached_google_default_credentials();
   set_google_default_creds_env_var_with_file_contents(
       "refresh_token_google_default_creds", test_refresh_token_str);
-  creds = (grpc_composite_channel_credentials *)
+  creds = (grpc_composite_channel_credentials*)
       grpc_google_default_credentials_create();
-  GPR_ASSERT(creds != NULL);
-  refresh = (grpc_google_refresh_token_credentials *)creds->call_creds;
+  GPR_ASSERT(creds != nullptr);
+  refresh = (grpc_google_refresh_token_credentials*)creds->call_creds;
   GPR_ASSERT(strcmp(refresh->refresh_token.client_id,
                     "32555999999.apps.googleusercontent.com") == 0);
   grpc_channel_credentials_unref(&exec_ctx, &creds->base);
@@ -930,11 +937,12 @@ static void test_google_default_creds_refresh_token(void) {
 }
 
 static int default_creds_gce_detection_httpcli_get_success_override(
-    grpc_exec_ctx *exec_ctx, const grpc_httpcli_request *request,
-    grpc_millis deadline, grpc_closure *on_done,
-    grpc_httpcli_response *response) {
+    grpc_exec_ctx* exec_ctx, const grpc_httpcli_request* request,
+    grpc_millis deadline, grpc_closure* on_done,
+    grpc_httpcli_response* response) {
   *response = http_response(200, "");
-  grpc_http_header *headers = gpr_malloc(sizeof(*headers) * 1);
+  grpc_http_header* headers =
+      static_cast<grpc_http_header*>(gpr_malloc(sizeof(*headers) * 1));
   headers[0].key = gpr_strdup("Metadata-Flavor");
   headers[0].value = gpr_strdup("Google");
   response->hdr_count = 1;
@@ -945,16 +953,16 @@ static int default_creds_gce_detection_httpcli_get_success_override(
   return 1;
 }
 
-static char *null_well_known_creds_path_getter(void) { return NULL; }
+static char* null_well_known_creds_path_getter(void) { return nullptr; }
 
 static void test_google_default_creds_gce(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   expected_md emd[] = {
       {"authorization", "Bearer ya29.AHES6ZRN3-HlhAPya30GnW_bHSb_"}};
-  request_metadata_state *state =
+  request_metadata_state* state =
       make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd));
-  grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, NULL,
-                                            NULL};
+  grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method,
+                                            nullptr, nullptr};
   grpc_flush_cached_google_default_credentials();
   gpr_setenv(GRPC_GOOGLE_CREDENTIALS_ENV_VAR, ""); /* Reset. */
   grpc_override_well_known_credentials_path_getter(
@@ -964,13 +972,13 @@ static void test_google_default_creds_gce(void) {
   grpc_httpcli_set_override(
       default_creds_gce_detection_httpcli_get_success_override,
       httpcli_post_should_not_be_called);
-  grpc_composite_channel_credentials *creds =
-      (grpc_composite_channel_credentials *)
+  grpc_composite_channel_credentials* creds =
+      (grpc_composite_channel_credentials*)
           grpc_google_default_credentials_create();
 
   /* Verify that the default creds actually embeds a GCE creds. */
-  GPR_ASSERT(creds != NULL);
-  GPR_ASSERT(creds->call_creds != NULL);
+  GPR_ASSERT(creds != nullptr);
+  GPR_ASSERT(creds->call_creds != nullptr);
   grpc_httpcli_set_override(compute_engine_httpcli_get_success_override,
                             httpcli_post_should_not_be_called);
   run_request_metadata_test(&exec_ctx, creds->call_creds, auth_md_ctx, state);
@@ -981,22 +989,22 @@ static void test_google_default_creds_gce(void) {
      GCE detection should not occur anymore either. */
   grpc_httpcli_set_override(httpcli_get_should_not_be_called,
                             httpcli_post_should_not_be_called);
-  grpc_channel_credentials *cached_creds =
+  grpc_channel_credentials* cached_creds =
       grpc_google_default_credentials_create();
   GPR_ASSERT(cached_creds == &creds->base);
 
   /* Cleanup. */
   grpc_channel_credentials_unref(&exec_ctx, cached_creds);
   grpc_channel_credentials_unref(&exec_ctx, &creds->base);
-  grpc_httpcli_set_override(NULL, NULL);
-  grpc_override_well_known_credentials_path_getter(NULL);
+  grpc_httpcli_set_override(nullptr, nullptr);
+  grpc_override_well_known_credentials_path_getter(nullptr);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
 static int default_creds_gce_detection_httpcli_get_failure_override(
-    grpc_exec_ctx *exec_ctx, const grpc_httpcli_request *request,
-    grpc_millis deadline, grpc_closure *on_done,
-    grpc_httpcli_response *response) {
+    grpc_exec_ctx* exec_ctx, const grpc_httpcli_request* request,
+    grpc_millis deadline, grpc_closure* on_done,
+    grpc_httpcli_response* response) {
   /* No magic header. */
   GPR_ASSERT(strcmp(request->http.path, "/") == 0);
   GPR_ASSERT(strcmp(request->host, "metadata.google.internal") == 0);
@@ -1015,16 +1023,16 @@ static void test_no_google_default_creds(void) {
   grpc_httpcli_set_override(
       default_creds_gce_detection_httpcli_get_failure_override,
       httpcli_post_should_not_be_called);
-  GPR_ASSERT(grpc_google_default_credentials_create() == NULL);
+  GPR_ASSERT(grpc_google_default_credentials_create() == nullptr);
 
   /* Try a cached one. GCE detection should not occur anymore. */
   grpc_httpcli_set_override(httpcli_get_should_not_be_called,
                             httpcli_post_should_not_be_called);
-  GPR_ASSERT(grpc_google_default_credentials_create() == NULL);
+  GPR_ASSERT(grpc_google_default_credentials_create() == nullptr);
 
   /* Cleanup. */
-  grpc_httpcli_set_override(NULL, NULL);
-  grpc_override_well_known_credentials_path_getter(NULL);
+  grpc_httpcli_set_override(nullptr, nullptr);
+  grpc_override_well_known_credentials_path_getter(nullptr);
 }
 
 typedef enum {
@@ -1036,18 +1044,18 @@ typedef enum {
 static const expected_md plugin_md[] = {{"foo", "bar"}, {"hi", "there"}};
 
 static int plugin_get_metadata_success(
-    void *state, grpc_auth_metadata_context context,
-    grpc_credentials_plugin_metadata_cb cb, void *user_data,
+    void* state, grpc_auth_metadata_context context,
+    grpc_credentials_plugin_metadata_cb cb, void* user_data,
     grpc_metadata creds_md[GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX],
-    size_t *num_creds_md, grpc_status_code *status,
-    const char **error_details) {
+    size_t* num_creds_md, grpc_status_code* status,
+    const char** error_details) {
   GPR_ASSERT(strcmp(context.service_url, test_service_url) == 0);
   GPR_ASSERT(strcmp(context.method_name, test_method) == 0);
-  GPR_ASSERT(context.channel_auth_context == NULL);
-  GPR_ASSERT(context.reserved == NULL);
+  GPR_ASSERT(context.channel_auth_context == nullptr);
+  GPR_ASSERT(context.reserved == nullptr);
   GPR_ASSERT(GPR_ARRAY_SIZE(plugin_md) <
              GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX);
-  plugin_state *s = (plugin_state *)state;
+  plugin_state* s = (plugin_state*)state;
   *s = PLUGIN_GET_METADATA_CALLED_STATE;
   for (size_t i = 0; i < GPR_ARRAY_SIZE(plugin_md); ++i) {
     memset(&creds_md[i], 0, sizeof(grpc_metadata));
@@ -1058,27 +1066,27 @@ static int plugin_get_metadata_success(
   return true;  // Synchronous return.
 }
 
-static const char *plugin_error_details = "Could not get metadata for plugin.";
+static const char* plugin_error_details = "Could not get metadata for plugin.";
 
 static int plugin_get_metadata_failure(
-    void *state, grpc_auth_metadata_context context,
-    grpc_credentials_plugin_metadata_cb cb, void *user_data,
+    void* state, grpc_auth_metadata_context context,
+    grpc_credentials_plugin_metadata_cb cb, void* user_data,
     grpc_metadata creds_md[GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX],
-    size_t *num_creds_md, grpc_status_code *status,
-    const char **error_details) {
+    size_t* num_creds_md, grpc_status_code* status,
+    const char** error_details) {
   GPR_ASSERT(strcmp(context.service_url, test_service_url) == 0);
   GPR_ASSERT(strcmp(context.method_name, test_method) == 0);
-  GPR_ASSERT(context.channel_auth_context == NULL);
-  GPR_ASSERT(context.reserved == NULL);
-  plugin_state *s = (plugin_state *)state;
+  GPR_ASSERT(context.channel_auth_context == nullptr);
+  GPR_ASSERT(context.reserved == nullptr);
+  plugin_state* s = (plugin_state*)state;
   *s = PLUGIN_GET_METADATA_CALLED_STATE;
   *status = GRPC_STATUS_UNAUTHENTICATED;
   *error_details = gpr_strdup(plugin_error_details);
   return true;  // Synchronous return.
 }
 
-static void plugin_destroy(void *state) {
-  plugin_state *s = (plugin_state *)state;
+static void plugin_destroy(void* state) {
+  plugin_state* s = (plugin_state*)state;
   *s = PLUGIN_DESTROY_CALLED_STATE;
 }
 
@@ -1086,17 +1094,17 @@ static void test_metadata_plugin_success(void) {
   plugin_state state = PLUGIN_INITIAL_STATE;
   grpc_metadata_credentials_plugin plugin;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, NULL,
-                                            NULL};
-  request_metadata_state *md_state = make_request_metadata_state(
+  grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method,
+                                            nullptr, nullptr};
+  request_metadata_state* md_state = make_request_metadata_state(
       GRPC_ERROR_NONE, plugin_md, GPR_ARRAY_SIZE(plugin_md));
 
   plugin.state = &state;
   plugin.get_metadata = plugin_get_metadata_success;
   plugin.destroy = plugin_destroy;
 
-  grpc_call_credentials *creds =
-      grpc_metadata_credentials_create_from_plugin(plugin, NULL);
+  grpc_call_credentials* creds =
+      grpc_metadata_credentials_create_from_plugin(plugin, nullptr);
   GPR_ASSERT(state == PLUGIN_INITIAL_STATE);
   run_request_metadata_test(&exec_ctx, creds, auth_md_ctx, md_state);
   GPR_ASSERT(state == PLUGIN_GET_METADATA_CALLED_STATE);
@@ -1109,22 +1117,22 @@ static void test_metadata_plugin_failure(void) {
   plugin_state state = PLUGIN_INITIAL_STATE;
   grpc_metadata_credentials_plugin plugin;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, NULL,
-                                            NULL};
-  char *expected_error;
+  grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method,
+                                            nullptr, nullptr};
+  char* expected_error;
   gpr_asprintf(&expected_error,
                "Getting metadata from plugin failed with error: %s",
                plugin_error_details);
-  request_metadata_state *md_state = make_request_metadata_state(
-      GRPC_ERROR_CREATE_FROM_COPIED_STRING(expected_error), NULL, 0);
+  request_metadata_state* md_state = make_request_metadata_state(
+      GRPC_ERROR_CREATE_FROM_COPIED_STRING(expected_error), nullptr, 0);
   gpr_free(expected_error);
 
   plugin.state = &state;
   plugin.get_metadata = plugin_get_metadata_failure;
   plugin.destroy = plugin_destroy;
 
-  grpc_call_credentials *creds =
-      grpc_metadata_credentials_create_from_plugin(plugin, NULL);
+  grpc_call_credentials* creds =
+      grpc_metadata_credentials_create_from_plugin(plugin, nullptr);
   GPR_ASSERT(state == PLUGIN_INITIAL_STATE);
   run_request_metadata_test(&exec_ctx, creds, auth_md_ctx, md_state);
   GPR_ASSERT(state == PLUGIN_GET_METADATA_CALLED_STATE);
@@ -1134,15 +1142,15 @@ static void test_metadata_plugin_failure(void) {
 }
 
 static void test_get_well_known_google_credentials_file_path(void) {
-  char *path;
-  char *home = gpr_getenv("HOME");
+  char* path;
+  char* home = gpr_getenv("HOME");
   path = grpc_get_well_known_google_credentials_file_path();
-  GPR_ASSERT(path != NULL);
+  GPR_ASSERT(path != nullptr);
   gpr_free(path);
 #if defined(GPR_POSIX_ENV) || defined(GPR_LINUX_ENV)
   unsetenv("HOME");
   path = grpc_get_well_known_google_credentials_file_path();
-  GPR_ASSERT(path == NULL);
+  GPR_ASSERT(path == nullptr);
   gpr_setenv("HOME", home);
   gpr_free(path);
 #endif /* GPR_POSIX_ENV || GPR_LINUX_ENV */
@@ -1152,20 +1160,20 @@ static void test_get_well_known_google_credentials_file_path(void) {
 static void test_channel_creds_duplicate_without_call_creds(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
-  grpc_channel_credentials *channel_creds =
+  grpc_channel_credentials* channel_creds =
       grpc_fake_transport_security_credentials_create();
 
-  grpc_channel_credentials *dup =
+  grpc_channel_credentials* dup =
       grpc_channel_credentials_duplicate_without_call_credentials(
           channel_creds);
   GPR_ASSERT(dup == channel_creds);
   grpc_channel_credentials_unref(&exec_ctx, dup);
 
-  grpc_call_credentials *call_creds =
-      grpc_access_token_credentials_create("blah", NULL);
-  grpc_channel_credentials *composite_creds =
+  grpc_call_credentials* call_creds =
+      grpc_access_token_credentials_create("blah", nullptr);
+  grpc_channel_credentials* composite_creds =
       grpc_composite_channel_credentials_create(channel_creds, call_creds,
-                                                NULL);
+                                                nullptr);
   grpc_call_credentials_unref(&exec_ctx, call_creds);
   dup = grpc_channel_credentials_duplicate_without_call_credentials(
       composite_creds);
@@ -1178,7 +1186,78 @@ static void test_channel_creds_duplicate_without_call_creds(void) {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-int main(int argc, char **argv) {
+typedef struct {
+  const char* url_scheme;
+  const char* call_host;
+  const char* call_method;
+  const char* desired_service_url;
+  const char* desired_method_name;
+} auth_metadata_context_test_case;
+
+static void test_auth_metadata_context(void) {
+  auth_metadata_context_test_case test_cases[] = {
+      // No service nor method.
+      {"https", "www.foo.com", "", "https://www.foo.com", ""},
+      // No method.
+      {"https", "www.foo.com", "/Service", "https://www.foo.com/Service", ""},
+      // Empty service and method.
+      {"https", "www.foo.com", "//", "https://www.foo.com/", ""},
+      // Empty method.
+      {"https", "www.foo.com", "/Service/", "https://www.foo.com/Service", ""},
+      // Malformed url.
+      {"https", "www.foo.com:", "/Service/", "https://www.foo.com:/Service",
+       ""},
+      // https, default explicit port.
+      {"https", "www.foo.com:443", "/Service/FooMethod",
+       "https://www.foo.com/Service", "FooMethod"},
+      // https, default implicit port.
+      {"https", "www.foo.com", "/Service/FooMethod",
+       "https://www.foo.com/Service", "FooMethod"},
+      // https with ipv6 literal, default explicit port.
+      {"https", "[1080:0:0:0:8:800:200C:417A]:443", "/Service/FooMethod",
+       "https://[1080:0:0:0:8:800:200C:417A]/Service", "FooMethod"},
+      // https with ipv6 literal, default implicit port.
+      {"https", "[1080:0:0:0:8:800:200C:443]", "/Service/FooMethod",
+       "https://[1080:0:0:0:8:800:200C:443]/Service", "FooMethod"},
+      // https, custom port.
+      {"https", "www.foo.com:8888", "/Service/FooMethod",
+       "https://www.foo.com:8888/Service", "FooMethod"},
+      // https with ipv6 literal, custom port.
+      {"https", "[1080:0:0:0:8:800:200C:417A]:8888", "/Service/FooMethod",
+       "https://[1080:0:0:0:8:800:200C:417A]:8888/Service", "FooMethod"},
+      // custom url scheme, https default port.
+      {"blah", "www.foo.com:443", "/Service/FooMethod",
+       "blah://www.foo.com:443/Service", "FooMethod"}};
+  for (uint32_t i = 0; i < GPR_ARRAY_SIZE(test_cases); i++) {
+    const char* url_scheme = test_cases[i].url_scheme;
+    grpc_slice call_host =
+        grpc_slice_from_copied_string(test_cases[i].call_host);
+    grpc_slice call_method =
+        grpc_slice_from_copied_string(test_cases[i].call_method);
+    grpc_auth_metadata_context auth_md_context;
+    memset(&auth_md_context, 0, sizeof(auth_md_context));
+    grpc_auth_metadata_context_build(url_scheme, call_host, call_method,
+                                     nullptr, &auth_md_context);
+    if (strcmp(auth_md_context.service_url,
+               test_cases[i].desired_service_url) != 0) {
+      gpr_log(GPR_ERROR, "Invalid service url, want: %s, got %s.",
+              test_cases[i].desired_service_url, auth_md_context.service_url);
+      GPR_ASSERT(false);
+    }
+    if (strcmp(auth_md_context.method_name,
+               test_cases[i].desired_method_name) != 0) {
+      gpr_log(GPR_ERROR, "Invalid method name, want: %s, got %s.",
+              test_cases[i].desired_method_name, auth_md_context.method_name);
+      GPR_ASSERT(false);
+    }
+    GPR_ASSERT(auth_md_context.channel_auth_context == nullptr);
+    grpc_slice_unref(call_host);
+    grpc_slice_unref(call_method);
+    grpc_auth_metadata_context_reset(&auth_md_context);
+  }
+}
+
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   test_empty_md_array();
@@ -1211,6 +1290,7 @@ int main(int argc, char **argv) {
   test_metadata_plugin_failure();
   test_get_well_known_google_credentials_file_path();
   test_channel_creds_duplicate_without_call_creds();
+  test_auth_metadata_context();
   grpc_shutdown();
   return 0;
 }
diff --git a/test/core/security/fetch_oauth2.c b/test/core/security/fetch_oauth2.cc
index 3998cb51cd..cb28a0487c 100644
--- a/test/core/security/fetch_oauth2.c
+++ b/test/core/security/fetch_oauth2.cc
@@ -31,24 +31,24 @@
 #include "src/core/lib/security/credentials/credentials.h"
 #include "test/core/security/oauth2_utils.h"
 
-static grpc_call_credentials *create_refresh_token_creds(
-    const char *json_refresh_token_file_path) {
+static grpc_call_credentials* create_refresh_token_creds(
+    const char* json_refresh_token_file_path) {
   grpc_slice refresh_token;
   GPR_ASSERT(GRPC_LOG_IF_ERROR(
       "load_file",
       grpc_load_file(json_refresh_token_file_path, 1, &refresh_token)));
   return grpc_google_refresh_token_credentials_create(
-      (const char *)GRPC_SLICE_START_PTR(refresh_token), NULL);
+      (const char*)GRPC_SLICE_START_PTR(refresh_token), nullptr);
 }
 
-int main(int argc, char **argv) {
-  grpc_call_credentials *creds = NULL;
-  char *json_key_file_path = NULL;
-  char *json_refresh_token_file_path = NULL;
-  char *token = NULL;
+int main(int argc, char** argv) {
+  grpc_call_credentials* creds = nullptr;
+  char* json_key_file_path = nullptr;
+  const char* json_refresh_token_file_path = nullptr;
+  char* token = nullptr;
   int use_gce = 0;
-  char *scope = NULL;
-  gpr_cmdline *cl = gpr_cmdline_create("fetch_oauth2");
+  char* scope = nullptr;
+  gpr_cmdline* cl = gpr_cmdline_create("fetch_oauth2");
   gpr_cmdline_add_string(cl, "json_refresh_token",
                          "File path of the json refresh token.",
                          &json_refresh_token_file_path);
@@ -60,26 +60,27 @@ int main(int argc, char **argv) {
 
   grpc_init();
 
-  if (json_key_file_path != NULL && json_refresh_token_file_path != NULL) {
+  if (json_key_file_path != nullptr &&
+      json_refresh_token_file_path != nullptr) {
     gpr_log(GPR_ERROR,
             "--json_key and --json_refresh_token are mutually exclusive.");
     exit(1);
   }
 
   if (use_gce) {
-    if (json_key_file_path != NULL || scope != NULL) {
+    if (json_key_file_path != nullptr || scope != nullptr) {
       gpr_log(GPR_INFO,
               "Ignoring json key and scope to get a token from the GCE "
               "metadata server.");
     }
-    creds = grpc_google_compute_engine_credentials_create(NULL);
-    if (creds == NULL) {
+    creds = grpc_google_compute_engine_credentials_create(nullptr);
+    if (creds == nullptr) {
       gpr_log(GPR_ERROR, "Could not create gce credentials.");
       exit(1);
     }
-  } else if (json_refresh_token_file_path != NULL) {
+  } else if (json_refresh_token_file_path != nullptr) {
     creds = create_refresh_token_creds(json_refresh_token_file_path);
-    if (creds == NULL) {
+    if (creds == nullptr) {
       gpr_log(GPR_ERROR,
               "Could not create refresh token creds. %s does probably not "
               "contain a valid json refresh token.",
@@ -90,10 +91,10 @@ int main(int argc, char **argv) {
     gpr_log(GPR_ERROR, "Missing --gce or --json_refresh_token option.");
     exit(1);
   }
-  GPR_ASSERT(creds != NULL);
+  GPR_ASSERT(creds != nullptr);
 
   token = grpc_test_fetch_oauth2_token_with_credentials(creds);
-  if (token != NULL) {
+  if (token != nullptr) {
     printf("Got token: %s.\n", token);
     gpr_free(token);
   }
diff --git a/test/core/security/json_token_test.c b/test/core/security/json_token_test.cc
index 6573f70e72..0b6ccd5e37 100644
--- a/test/core/security/json_token_test.c
+++ b/test/core/security/json_token_test.cc
@@ -77,12 +77,13 @@ static const char test_scope[] = "myperm1 myperm2";
 
 static const char test_service_url[] = "https://foo.com/foo.v1";
 
-static char *test_json_key_str(const char *bad_part3) {
-  const char *part3 = bad_part3 != NULL ? bad_part3 : test_json_key_str_part3;
+static char* test_json_key_str(const char* bad_part3) {
+  const char* part3 =
+      bad_part3 != nullptr ? bad_part3 : test_json_key_str_part3;
   size_t result_len = strlen(test_json_key_str_part1) +
                       strlen(test_json_key_str_part2) + strlen(part3);
-  char *result = gpr_malloc(result_len + 1);
-  char *current = result;
+  char* result = static_cast<char*>(gpr_malloc(result_len + 1));
+  char* current = result;
   strcpy(result, test_json_key_str_part1);
   current += strlen(test_json_key_str_part1);
   strcpy(current, test_json_key_str_part2);
@@ -92,24 +93,24 @@ static char *test_json_key_str(const char *bad_part3) {
 }
 
 static void test_parse_json_key_success(void) {
-  char *json_string = test_json_key_str(NULL);
+  char* json_string = test_json_key_str(nullptr);
   grpc_auth_json_key json_key =
       grpc_auth_json_key_create_from_string(json_string);
   GPR_ASSERT(grpc_auth_json_key_is_valid(&json_key));
-  GPR_ASSERT(json_key.type != NULL &&
+  GPR_ASSERT(json_key.type != nullptr &&
              strcmp(json_key.type, "service_account") == 0);
-  GPR_ASSERT(json_key.private_key_id != NULL &&
+  GPR_ASSERT(json_key.private_key_id != nullptr &&
              strcmp(json_key.private_key_id,
                     "e6b5137873db8d2ef81e06a47289e6434ec8a165") == 0);
-  GPR_ASSERT(json_key.client_id != NULL &&
+  GPR_ASSERT(json_key.client_id != nullptr &&
              strcmp(json_key.client_id,
                     "777-abaslkan11hlb6nmim3bpspl31ud.apps."
                     "googleusercontent.com") == 0);
-  GPR_ASSERT(json_key.client_email != NULL &&
+  GPR_ASSERT(json_key.client_email != nullptr &&
              strcmp(json_key.client_email,
                     "777-abaslkan11hlb6nmim3bpspl31ud@developer."
                     "gserviceaccount.com") == 0);
-  GPR_ASSERT(json_key.private_key != NULL);
+  GPR_ASSERT(json_key.private_key != nullptr);
   gpr_free(json_string);
   grpc_auth_json_key_destruct(&json_key);
 }
@@ -122,7 +123,7 @@ static void test_parse_json_key_failure_bad_json(void) {
       "com\", \"client_id\": "
       "\"777-abaslkan11hlb6nmim3bpspl31ud.apps.googleusercontent."
       "com\", \"type\": \"service_account\" ";
-  char *json_string = test_json_key_str(non_closing_part3);
+  char* json_string = test_json_key_str(non_closing_part3);
   grpc_auth_json_key json_key =
       grpc_auth_json_key_create_from_string(json_string);
   GPR_ASSERT(!grpc_auth_json_key_is_valid(&json_key));
@@ -138,7 +139,7 @@ static void test_parse_json_key_failure_no_type(void) {
       "com\", \"client_id\": "
       "\"777-abaslkan11hlb6nmim3bpspl31ud.apps.googleusercontent."
       "com\" }";
-  char *json_string = test_json_key_str(no_type_part3);
+  char* json_string = test_json_key_str(no_type_part3);
   grpc_auth_json_key json_key =
       grpc_auth_json_key_create_from_string(json_string);
   GPR_ASSERT(!grpc_auth_json_key_is_valid(&json_key));
@@ -153,7 +154,7 @@ static void test_parse_json_key_failure_no_client_id(void) {
       "\"777-abaslkan11hlb6nmim3bpspl31ud@developer.gserviceaccount."
       "com\", "
       "\"type\": \"service_account\" }";
-  char *json_string = test_json_key_str(no_client_id_part3);
+  char* json_string = test_json_key_str(no_client_id_part3);
   grpc_auth_json_key json_key =
       grpc_auth_json_key_create_from_string(json_string);
   GPR_ASSERT(!grpc_auth_json_key_is_valid(&json_key));
@@ -167,7 +168,7 @@ static void test_parse_json_key_failure_no_client_email(void) {
       "\"client_id\": "
       "\"777-abaslkan11hlb6nmim3bpspl31ud.apps.googleusercontent."
       "com\", \"type\": \"service_account\" }";
-  char *json_string = test_json_key_str(no_client_email_part3);
+  char* json_string = test_json_key_str(no_client_email_part3);
   grpc_auth_json_key json_key =
       grpc_auth_json_key_create_from_string(json_string);
   GPR_ASSERT(!grpc_auth_json_key_is_valid(&json_key));
@@ -182,7 +183,7 @@ static void test_parse_json_key_failure_no_private_key_id(void) {
       "com\", \"client_id\": "
       "\"777-abaslkan11hlb6nmim3bpspl31ud.apps.googleusercontent."
       "com\", \"type\": \"service_account\" }";
-  char *json_string = test_json_key_str(no_private_key_id_part3);
+  char* json_string = test_json_key_str(no_private_key_id_part3);
   grpc_auth_json_key json_key =
       grpc_auth_json_key_create_from_string(json_string);
   GPR_ASSERT(!grpc_auth_json_key_is_valid(&json_key));
@@ -204,20 +205,20 @@ static void test_parse_json_key_failure_no_private_key(void) {
   grpc_auth_json_key_destruct(&json_key);
 }
 
-static grpc_json *parse_json_part_from_jwt(const char *str, size_t len,
-                                           char **scratchpad) {
+static grpc_json* parse_json_part_from_jwt(const char* str, size_t len,
+                                           char** scratchpad) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  char *b64;
-  char *decoded;
-  grpc_json *json;
+  char* b64;
+  char* decoded;
+  grpc_json* json;
   grpc_slice slice;
-  b64 = gpr_malloc(len + 1);
+  b64 = static_cast<char*>(gpr_malloc(len + 1));
   strncpy(b64, str, len);
   b64[len] = '\0';
   slice = grpc_base64_decode(&exec_ctx, b64, 1);
   GPR_ASSERT(!GRPC_SLICE_IS_EMPTY(slice));
-  decoded = gpr_malloc(GRPC_SLICE_LENGTH(slice) + 1);
-  strncpy(decoded, (const char *)GRPC_SLICE_START_PTR(slice),
+  decoded = static_cast<char*>(gpr_malloc(GRPC_SLICE_LENGTH(slice) + 1));
+  strncpy(decoded, (const char*)GRPC_SLICE_START_PTR(slice),
           GRPC_SLICE_LENGTH(slice));
   decoded[GRPC_SLICE_LENGTH(slice)] = '\0';
   json = grpc_json_parse_string(decoded);
@@ -228,11 +229,11 @@ static grpc_json *parse_json_part_from_jwt(const char *str, size_t len,
   return json;
 }
 
-static void check_jwt_header(grpc_json *header) {
-  grpc_json *ptr;
-  grpc_json *alg = NULL;
-  grpc_json *typ = NULL;
-  grpc_json *kid = NULL;
+static void check_jwt_header(grpc_json* header) {
+  grpc_json* ptr;
+  grpc_json* alg = nullptr;
+  grpc_json* typ = nullptr;
+  grpc_json* kid = nullptr;
 
   for (ptr = header->child; ptr; ptr = ptr->next) {
     if (strcmp(ptr->key, "alg") == 0) {
@@ -243,32 +244,32 @@ static void check_jwt_header(grpc_json *header) {
       kid = ptr;
     }
   }
-  GPR_ASSERT(alg != NULL);
+  GPR_ASSERT(alg != nullptr);
   GPR_ASSERT(alg->type == GRPC_JSON_STRING);
   GPR_ASSERT(strcmp(alg->value, "RS256") == 0);
 
-  GPR_ASSERT(typ != NULL);
+  GPR_ASSERT(typ != nullptr);
   GPR_ASSERT(typ->type == GRPC_JSON_STRING);
   GPR_ASSERT(strcmp(typ->value, "JWT") == 0);
 
-  GPR_ASSERT(kid != NULL);
+  GPR_ASSERT(kid != nullptr);
   GPR_ASSERT(kid->type == GRPC_JSON_STRING);
   GPR_ASSERT(strcmp(kid->value, "e6b5137873db8d2ef81e06a47289e6434ec8a165") ==
              0);
 }
 
-static void check_jwt_claim(grpc_json *claim, const char *expected_audience,
-                            const char *expected_scope) {
+static void check_jwt_claim(grpc_json* claim, const char* expected_audience,
+                            const char* expected_scope) {
   gpr_timespec expiration = gpr_time_0(GPR_CLOCK_REALTIME);
   gpr_timespec issue_time = gpr_time_0(GPR_CLOCK_REALTIME);
   gpr_timespec parsed_lifetime;
-  grpc_json *iss = NULL;
-  grpc_json *scope = NULL;
-  grpc_json *aud = NULL;
-  grpc_json *exp = NULL;
-  grpc_json *iat = NULL;
-  grpc_json *sub = NULL;
-  grpc_json *ptr;
+  grpc_json* iss = nullptr;
+  grpc_json* scope = nullptr;
+  grpc_json* aud = nullptr;
+  grpc_json* exp = nullptr;
+  grpc_json* iat = nullptr;
+  grpc_json* sub = nullptr;
+  grpc_json* ptr;
 
   for (ptr = claim->child; ptr; ptr = ptr->next) {
     if (strcmp(ptr->key, "iss") == 0) {
@@ -286,7 +287,7 @@ static void check_jwt_claim(grpc_json *claim, const char *expected_audience,
     }
   }
 
-  GPR_ASSERT(iss != NULL);
+  GPR_ASSERT(iss != nullptr);
   GPR_ASSERT(iss->type == GRPC_JSON_STRING);
   GPR_ASSERT(
       strcmp(
@@ -294,117 +295,118 @@ static void check_jwt_claim(grpc_json *claim, const char *expected_audience,
           "777-abaslkan11hlb6nmim3bpspl31ud@developer.gserviceaccount.com") ==
       0);
 
-  if (expected_scope != NULL) {
-    GPR_ASSERT(scope != NULL);
-    GPR_ASSERT(sub == NULL);
+  if (expected_scope != nullptr) {
+    GPR_ASSERT(scope != nullptr);
+    GPR_ASSERT(sub == nullptr);
     GPR_ASSERT(scope->type == GRPC_JSON_STRING);
     GPR_ASSERT(strcmp(scope->value, expected_scope) == 0);
   } else {
     /* Claims without scope must have a sub. */
-    GPR_ASSERT(scope == NULL);
-    GPR_ASSERT(sub != NULL);
+    GPR_ASSERT(scope == nullptr);
+    GPR_ASSERT(sub != nullptr);
     GPR_ASSERT(sub->type == GRPC_JSON_STRING);
     GPR_ASSERT(strcmp(iss->value, sub->value) == 0);
   }
 
-  GPR_ASSERT(aud != NULL);
+  GPR_ASSERT(aud != nullptr);
   GPR_ASSERT(aud->type == GRPC_JSON_STRING);
   GPR_ASSERT(strcmp(aud->value, expected_audience) == 0);
 
-  GPR_ASSERT(exp != NULL);
+  GPR_ASSERT(exp != nullptr);
   GPR_ASSERT(exp->type == GRPC_JSON_NUMBER);
-  expiration.tv_sec = strtol(exp->value, NULL, 10);
+  expiration.tv_sec = strtol(exp->value, nullptr, 10);
 
-  GPR_ASSERT(iat != NULL);
+  GPR_ASSERT(iat != nullptr);
   GPR_ASSERT(iat->type == GRPC_JSON_NUMBER);
-  issue_time.tv_sec = strtol(iat->value, NULL, 10);
+  issue_time.tv_sec = strtol(iat->value, nullptr, 10);
 
   parsed_lifetime = gpr_time_sub(expiration, issue_time);
   GPR_ASSERT(parsed_lifetime.tv_sec == grpc_max_auth_token_lifetime().tv_sec);
 }
 
-static void check_jwt_signature(const char *b64_signature, RSA *rsa_key,
-                                const char *signed_data,
+static void check_jwt_signature(const char* b64_signature, RSA* rsa_key,
+                                const char* signed_data,
                                 size_t signed_data_size) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
-  EVP_MD_CTX *md_ctx = EVP_MD_CTX_create();
-  EVP_PKEY *key = EVP_PKEY_new();
+  EVP_MD_CTX* md_ctx = EVP_MD_CTX_create();
+  EVP_PKEY* key = EVP_PKEY_new();
 
   grpc_slice sig = grpc_base64_decode(&exec_ctx, b64_signature, 1);
   GPR_ASSERT(!GRPC_SLICE_IS_EMPTY(sig));
   GPR_ASSERT(GRPC_SLICE_LENGTH(sig) == 128);
 
-  GPR_ASSERT(md_ctx != NULL);
-  GPR_ASSERT(key != NULL);
+  GPR_ASSERT(md_ctx != nullptr);
+  GPR_ASSERT(key != nullptr);
   EVP_PKEY_set1_RSA(key, rsa_key);
 
-  GPR_ASSERT(EVP_DigestVerifyInit(md_ctx, NULL, EVP_sha256(), NULL, key) == 1);
+  GPR_ASSERT(
+      EVP_DigestVerifyInit(md_ctx, nullptr, EVP_sha256(), nullptr, key) == 1);
   GPR_ASSERT(EVP_DigestVerifyUpdate(md_ctx, signed_data, signed_data_size) ==
              1);
   GPR_ASSERT(EVP_DigestVerifyFinal(md_ctx, GRPC_SLICE_START_PTR(sig),
                                    GRPC_SLICE_LENGTH(sig)) == 1);
 
   grpc_slice_unref_internal(&exec_ctx, sig);
-  if (key != NULL) EVP_PKEY_free(key);
-  if (md_ctx != NULL) EVP_MD_CTX_destroy(md_ctx);
+  if (key != nullptr) EVP_PKEY_free(key);
+  if (md_ctx != nullptr) EVP_MD_CTX_destroy(md_ctx);
 
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static char *service_account_creds_jwt_encode_and_sign(
-    const grpc_auth_json_key *key) {
+static char* service_account_creds_jwt_encode_and_sign(
+    const grpc_auth_json_key* key) {
   return grpc_jwt_encode_and_sign(key, GRPC_JWT_OAUTH2_AUDIENCE,
                                   grpc_max_auth_token_lifetime(), test_scope);
 }
 
-static char *jwt_creds_jwt_encode_and_sign(const grpc_auth_json_key *key) {
+static char* jwt_creds_jwt_encode_and_sign(const grpc_auth_json_key* key) {
   return grpc_jwt_encode_and_sign(key, test_service_url,
-                                  grpc_max_auth_token_lifetime(), NULL);
+                                  grpc_max_auth_token_lifetime(), nullptr);
 }
 
-static void service_account_creds_check_jwt_claim(grpc_json *claim) {
+static void service_account_creds_check_jwt_claim(grpc_json* claim) {
   check_jwt_claim(claim, GRPC_JWT_OAUTH2_AUDIENCE, test_scope);
 }
 
-static void jwt_creds_check_jwt_claim(grpc_json *claim) {
-  check_jwt_claim(claim, test_service_url, NULL);
+static void jwt_creds_check_jwt_claim(grpc_json* claim) {
+  check_jwt_claim(claim, test_service_url, nullptr);
 }
 
 static void test_jwt_encode_and_sign(
-    char *(*jwt_encode_and_sign_func)(const grpc_auth_json_key *),
-    void (*check_jwt_claim_func)(grpc_json *)) {
-  char *json_string = test_json_key_str(NULL);
-  grpc_json *parsed_header = NULL;
-  grpc_json *parsed_claim = NULL;
-  char *scratchpad;
+    char* (*jwt_encode_and_sign_func)(const grpc_auth_json_key*),
+    void (*check_jwt_claim_func)(grpc_json*)) {
+  char* json_string = test_json_key_str(nullptr);
+  grpc_json* parsed_header = nullptr;
+  grpc_json* parsed_claim = nullptr;
+  char* scratchpad;
   grpc_auth_json_key json_key =
       grpc_auth_json_key_create_from_string(json_string);
-  const char *b64_signature;
+  const char* b64_signature;
   size_t offset = 0;
-  char *jwt = jwt_encode_and_sign_func(&json_key);
-  const char *dot = strchr(jwt, '.');
-  GPR_ASSERT(dot != NULL);
+  char* jwt = jwt_encode_and_sign_func(&json_key);
+  const char* dot = strchr(jwt, '.');
+  GPR_ASSERT(dot != nullptr);
   parsed_header =
       parse_json_part_from_jwt(jwt, (size_t)(dot - jwt), &scratchpad);
-  GPR_ASSERT(parsed_header != NULL);
+  GPR_ASSERT(parsed_header != nullptr);
   check_jwt_header(parsed_header);
   offset = (size_t)(dot - jwt) + 1;
   grpc_json_destroy(parsed_header);
   gpr_free(scratchpad);
 
   dot = strchr(jwt + offset, '.');
-  GPR_ASSERT(dot != NULL);
+  GPR_ASSERT(dot != nullptr);
   parsed_claim = parse_json_part_from_jwt(
       jwt + offset, (size_t)(dot - (jwt + offset)), &scratchpad);
-  GPR_ASSERT(parsed_claim != NULL);
+  GPR_ASSERT(parsed_claim != nullptr);
   check_jwt_claim_func(parsed_claim);
   offset = (size_t)(dot - jwt) + 1;
   grpc_json_destroy(parsed_claim);
   gpr_free(scratchpad);
 
   dot = strchr(jwt + offset, '.');
-  GPR_ASSERT(dot == NULL); /* no more part. */
+  GPR_ASSERT(dot == nullptr); /* no more part. */
   b64_signature = jwt + offset;
   check_jwt_signature(b64_signature, json_key.private_key, jwt, offset - 1);
 
@@ -427,15 +429,15 @@ static void test_parse_refresh_token_success(void) {
   grpc_auth_refresh_token refresh_token =
       grpc_auth_refresh_token_create_from_string(test_refresh_token_str);
   GPR_ASSERT(grpc_auth_refresh_token_is_valid(&refresh_token));
-  GPR_ASSERT(refresh_token.type != NULL &&
+  GPR_ASSERT(refresh_token.type != nullptr &&
              (strcmp(refresh_token.type, "authorized_user") == 0));
-  GPR_ASSERT(refresh_token.client_id != NULL &&
+  GPR_ASSERT(refresh_token.client_id != nullptr &&
              (strcmp(refresh_token.client_id,
                      "32555999999.apps.googleusercontent.com") == 0));
   GPR_ASSERT(
-      refresh_token.client_secret != NULL &&
+      refresh_token.client_secret != nullptr &&
       (strcmp(refresh_token.client_secret, "EmssLNjJy1332hD4KFsecret") == 0));
-  GPR_ASSERT(refresh_token.refresh_token != NULL &&
+  GPR_ASSERT(refresh_token.refresh_token != nullptr &&
              (strcmp(refresh_token.refresh_token,
                      "1/Blahblasj424jladJDSGNf-u4Sua3HDA2ngjd42") == 0));
   grpc_auth_refresh_token_destruct(&refresh_token);
@@ -481,7 +483,7 @@ static void test_parse_refresh_token_failure_no_refresh_token(void) {
   GPR_ASSERT(!grpc_auth_refresh_token_is_valid(&refresh_token));
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_parse_json_key_success();
   test_parse_json_key_failure_bad_json();
diff --git a/test/core/security/jwt_verifier_test.c b/test/core/security/jwt_verifier_test.cc
index a4bfe0130e..df0ebe5607 100644
--- a/test/core/security/jwt_verifier_test.c
+++ b/test/core/security/jwt_verifier_test.cc
@@ -167,19 +167,19 @@ static const char invalid_claims[] =
 
 typedef struct {
   grpc_jwt_verifier_status expected_status;
-  const char *expected_issuer;
-  const char *expected_subject;
+  const char* expected_issuer;
+  const char* expected_subject;
 } verifier_test_config;
 
 static void test_jwt_issuer_email_domain(void) {
-  const char *d = grpc_jwt_issuer_email_domain("https://foo.com");
-  GPR_ASSERT(d == NULL);
+  const char* d = grpc_jwt_issuer_email_domain("https://foo.com");
+  GPR_ASSERT(d == nullptr);
   d = grpc_jwt_issuer_email_domain("foo.com");
-  GPR_ASSERT(d == NULL);
+  GPR_ASSERT(d == nullptr);
   d = grpc_jwt_issuer_email_domain("");
-  GPR_ASSERT(d == NULL);
+  GPR_ASSERT(d == nullptr);
   d = grpc_jwt_issuer_email_domain("@");
-  GPR_ASSERT(d == NULL);
+  GPR_ASSERT(d == nullptr);
   d = grpc_jwt_issuer_email_domain("bar@foo");
   GPR_ASSERT(strcmp(d, "foo") == 0);
   d = grpc_jwt_issuer_email_domain("bar@foo.com");
@@ -196,22 +196,22 @@ static void test_jwt_issuer_email_domain(void) {
   d = grpc_jwt_issuer_email_domain("@foo");
   GPR_ASSERT(strcmp(d, "foo") == 0);
   d = grpc_jwt_issuer_email_domain("bar@.");
-  GPR_ASSERT(d != NULL);
+  GPR_ASSERT(d != nullptr);
   d = grpc_jwt_issuer_email_domain("bar@..");
-  GPR_ASSERT(d != NULL);
+  GPR_ASSERT(d != nullptr);
   d = grpc_jwt_issuer_email_domain("bar@...");
-  GPR_ASSERT(d != NULL);
+  GPR_ASSERT(d != nullptr);
 }
 
 static void test_claims_success(void) {
-  grpc_jwt_claims *claims;
+  grpc_jwt_claims* claims;
   grpc_slice s = grpc_slice_from_copied_string(claims_without_time_constraint);
-  grpc_json *json = grpc_json_parse_string_with_len(
-      (char *)GRPC_SLICE_START_PTR(s), GRPC_SLICE_LENGTH(s));
-  GPR_ASSERT(json != NULL);
+  grpc_json* json = grpc_json_parse_string_with_len(
+      (char*)GRPC_SLICE_START_PTR(s), GRPC_SLICE_LENGTH(s));
+  GPR_ASSERT(json != nullptr);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   claims = grpc_jwt_claims_from_json(&exec_ctx, json, s);
-  GPR_ASSERT(claims != NULL);
+  GPR_ASSERT(claims != nullptr);
   GPR_ASSERT(grpc_jwt_claims_json(claims) == json);
   GPR_ASSERT(strcmp(grpc_jwt_claims_audience(claims), "https://foo.com") == 0);
   GPR_ASSERT(strcmp(grpc_jwt_claims_issuer(claims), "blah.foo.com") == 0);
@@ -224,17 +224,17 @@ static void test_claims_success(void) {
 }
 
 static void test_expired_claims_failure(void) {
-  grpc_jwt_claims *claims;
+  grpc_jwt_claims* claims;
   grpc_slice s = grpc_slice_from_copied_string(expired_claims);
-  grpc_json *json = grpc_json_parse_string_with_len(
-      (char *)GRPC_SLICE_START_PTR(s), GRPC_SLICE_LENGTH(s));
+  grpc_json* json = grpc_json_parse_string_with_len(
+      (char*)GRPC_SLICE_START_PTR(s), GRPC_SLICE_LENGTH(s));
   gpr_timespec exp_iat = {100, 0, GPR_CLOCK_REALTIME};
   gpr_timespec exp_exp = {120, 0, GPR_CLOCK_REALTIME};
   gpr_timespec exp_nbf = {60, 0, GPR_CLOCK_REALTIME};
-  GPR_ASSERT(json != NULL);
+  GPR_ASSERT(json != nullptr);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   claims = grpc_jwt_claims_from_json(&exec_ctx, json, s);
-  GPR_ASSERT(claims != NULL);
+  GPR_ASSERT(claims != nullptr);
   GPR_ASSERT(grpc_jwt_claims_json(claims) == json);
   GPR_ASSERT(strcmp(grpc_jwt_claims_audience(claims), "https://foo.com") == 0);
   GPR_ASSERT(strcmp(grpc_jwt_claims_issuer(claims), "blah.foo.com") == 0);
@@ -252,22 +252,22 @@ static void test_expired_claims_failure(void) {
 
 static void test_invalid_claims_failure(void) {
   grpc_slice s = grpc_slice_from_copied_string(invalid_claims);
-  grpc_json *json = grpc_json_parse_string_with_len(
-      (char *)GRPC_SLICE_START_PTR(s), GRPC_SLICE_LENGTH(s));
+  grpc_json* json = grpc_json_parse_string_with_len(
+      (char*)GRPC_SLICE_START_PTR(s), GRPC_SLICE_LENGTH(s));
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  GPR_ASSERT(grpc_jwt_claims_from_json(&exec_ctx, json, s) == NULL);
+  GPR_ASSERT(grpc_jwt_claims_from_json(&exec_ctx, json, s) == nullptr);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
 static void test_bad_audience_claims_failure(void) {
-  grpc_jwt_claims *claims;
+  grpc_jwt_claims* claims;
   grpc_slice s = grpc_slice_from_copied_string(claims_without_time_constraint);
-  grpc_json *json = grpc_json_parse_string_with_len(
-      (char *)GRPC_SLICE_START_PTR(s), GRPC_SLICE_LENGTH(s));
-  GPR_ASSERT(json != NULL);
+  grpc_json* json = grpc_json_parse_string_with_len(
+      (char*)GRPC_SLICE_START_PTR(s), GRPC_SLICE_LENGTH(s));
+  GPR_ASSERT(json != nullptr);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   claims = grpc_jwt_claims_from_json(&exec_ctx, json, s);
-  GPR_ASSERT(claims != NULL);
+  GPR_ASSERT(claims != nullptr);
   GPR_ASSERT(grpc_jwt_claims_check(claims, "https://bar.com") ==
              GRPC_JWT_VERIFIER_BAD_AUDIENCE);
   grpc_jwt_claims_destroy(&exec_ctx, claims);
@@ -275,25 +275,25 @@ static void test_bad_audience_claims_failure(void) {
 }
 
 static void test_bad_subject_claims_failure(void) {
-  grpc_jwt_claims *claims;
+  grpc_jwt_claims* claims;
   grpc_slice s = grpc_slice_from_copied_string(claims_with_bad_subject);
-  grpc_json *json = grpc_json_parse_string_with_len(
-      (char *)GRPC_SLICE_START_PTR(s), GRPC_SLICE_LENGTH(s));
-  GPR_ASSERT(json != NULL);
+  grpc_json* json = grpc_json_parse_string_with_len(
+      (char*)GRPC_SLICE_START_PTR(s), GRPC_SLICE_LENGTH(s));
+  GPR_ASSERT(json != nullptr);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   claims = grpc_jwt_claims_from_json(&exec_ctx, json, s);
-  GPR_ASSERT(claims != NULL);
+  GPR_ASSERT(claims != nullptr);
   GPR_ASSERT(grpc_jwt_claims_check(claims, "https://foo.com") ==
              GRPC_JWT_VERIFIER_BAD_SUBJECT);
   grpc_jwt_claims_destroy(&exec_ctx, claims);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static char *json_key_str(const char *last_part) {
+static char* json_key_str(const char* last_part) {
   size_t result_len = strlen(json_key_str_part1) + strlen(json_key_str_part2) +
                       strlen(last_part);
-  char *result = gpr_malloc(result_len + 1);
-  char *current = result;
+  char* result = static_cast<char*>(gpr_malloc(result_len + 1));
+  char* current = result;
   strcpy(result, json_key_str_part1);
   current += strlen(json_key_str_part1);
   strcpy(current, json_key_str_part2);
@@ -302,18 +302,18 @@ static char *json_key_str(const char *last_part) {
   return result;
 }
 
-static char *good_google_email_keys(void) {
+static char* good_google_email_keys(void) {
   size_t result_len = strlen(good_google_email_keys_part1) +
                       strlen(good_google_email_keys_part2);
-  char *result = gpr_malloc(result_len + 1);
-  char *current = result;
+  char* result = static_cast<char*>(gpr_malloc(result_len + 1));
+  char* current = result;
   strcpy(result, good_google_email_keys_part1);
   current += strlen(good_google_email_keys_part1);
   strcpy(current, good_google_email_keys_part2);
   return result;
 }
 
-static grpc_httpcli_response http_response(int status, char *body) {
+static grpc_httpcli_response http_response(int status, char* body) {
   grpc_httpcli_response response;
   memset(&response, 0, sizeof(grpc_httpcli_response));
   response.status = status;
@@ -323,17 +323,17 @@ static grpc_httpcli_response http_response(int status, char *body) {
 }
 
 static int httpcli_post_should_not_be_called(
-    grpc_exec_ctx *exec_ctx, const grpc_httpcli_request *request,
-    const char *body_bytes, size_t body_size, grpc_millis deadline,
-    grpc_closure *on_done, grpc_httpcli_response *response) {
-  GPR_ASSERT("HTTP POST should not be called" == NULL);
+    grpc_exec_ctx* exec_ctx, const grpc_httpcli_request* request,
+    const char* body_bytes, size_t body_size, grpc_millis deadline,
+    grpc_closure* on_done, grpc_httpcli_response* response) {
+  GPR_ASSERT("HTTP POST should not be called" == nullptr);
   return 1;
 }
 
 static int httpcli_get_google_keys_for_email(
-    grpc_exec_ctx *exec_ctx, const grpc_httpcli_request *request,
-    grpc_millis deadline, grpc_closure *on_done,
-    grpc_httpcli_response *response) {
+    grpc_exec_ctx* exec_ctx, const grpc_httpcli_request* request,
+    grpc_millis deadline, grpc_closure* on_done,
+    grpc_httpcli_response* response) {
   *response = http_response(200, good_google_email_keys());
   GPR_ASSERT(request->handshaker == &grpc_httpcli_ssl);
   GPR_ASSERT(strcmp(request->host, "www.googleapis.com") == 0);
@@ -345,42 +345,42 @@ static int httpcli_get_google_keys_for_email(
   return 1;
 }
 
-static void on_verification_success(grpc_exec_ctx *exec_ctx, void *user_data,
+static void on_verification_success(grpc_exec_ctx* exec_ctx, void* user_data,
                                     grpc_jwt_verifier_status status,
-                                    grpc_jwt_claims *claims) {
+                                    grpc_jwt_claims* claims) {
   GPR_ASSERT(status == GRPC_JWT_VERIFIER_OK);
-  GPR_ASSERT(claims != NULL);
-  GPR_ASSERT(user_data == (void *)expected_user_data);
+  GPR_ASSERT(claims != nullptr);
+  GPR_ASSERT(user_data == (void*)expected_user_data);
   GPR_ASSERT(strcmp(grpc_jwt_claims_audience(claims), expected_audience) == 0);
   grpc_jwt_claims_destroy(exec_ctx, claims);
 }
 
 static void test_jwt_verifier_google_email_issuer_success(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_jwt_verifier *verifier = grpc_jwt_verifier_create(NULL, 0);
-  char *jwt = NULL;
-  char *key_str = json_key_str(json_key_str_part3_for_google_email_issuer);
+  grpc_jwt_verifier* verifier = grpc_jwt_verifier_create(nullptr, 0);
+  char* jwt = nullptr;
+  char* key_str = json_key_str(json_key_str_part3_for_google_email_issuer);
   grpc_auth_json_key key = grpc_auth_json_key_create_from_string(key_str);
   gpr_free(key_str);
   GPR_ASSERT(grpc_auth_json_key_is_valid(&key));
   grpc_httpcli_set_override(httpcli_get_google_keys_for_email,
                             httpcli_post_should_not_be_called);
   jwt = grpc_jwt_encode_and_sign(&key, expected_audience, expected_lifetime,
-                                 NULL);
+                                 nullptr);
   grpc_auth_json_key_destruct(&key);
-  GPR_ASSERT(jwt != NULL);
-  grpc_jwt_verifier_verify(&exec_ctx, verifier, NULL, jwt, expected_audience,
-                           on_verification_success, (void *)expected_user_data);
+  GPR_ASSERT(jwt != nullptr);
+  grpc_jwt_verifier_verify(&exec_ctx, verifier, nullptr, jwt, expected_audience,
+                           on_verification_success, (void*)expected_user_data);
   grpc_jwt_verifier_destroy(&exec_ctx, verifier);
   grpc_exec_ctx_finish(&exec_ctx);
   gpr_free(jwt);
-  grpc_httpcli_set_override(NULL, NULL);
+  grpc_httpcli_set_override(nullptr, nullptr);
 }
 
 static int httpcli_get_custom_keys_for_email(
-    grpc_exec_ctx *exec_ctx, const grpc_httpcli_request *request,
-    grpc_millis deadline, grpc_closure *on_done,
-    grpc_httpcli_response *response) {
+    grpc_exec_ctx* exec_ctx, const grpc_httpcli_request* request,
+    grpc_millis deadline, grpc_closure* on_done,
+    grpc_httpcli_response* response) {
   *response = http_response(200, gpr_strdup(good_jwk_set));
   GPR_ASSERT(request->handshaker == &grpc_httpcli_ssl);
   GPR_ASSERT(strcmp(request->host, "keys.bar.com") == 0);
@@ -391,30 +391,30 @@ static int httpcli_get_custom_keys_for_email(
 
 static void test_jwt_verifier_custom_email_issuer_success(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_jwt_verifier *verifier = grpc_jwt_verifier_create(&custom_mapping, 1);
-  char *jwt = NULL;
-  char *key_str = json_key_str(json_key_str_part3_for_custom_email_issuer);
+  grpc_jwt_verifier* verifier = grpc_jwt_verifier_create(&custom_mapping, 1);
+  char* jwt = nullptr;
+  char* key_str = json_key_str(json_key_str_part3_for_custom_email_issuer);
   grpc_auth_json_key key = grpc_auth_json_key_create_from_string(key_str);
   gpr_free(key_str);
   GPR_ASSERT(grpc_auth_json_key_is_valid(&key));
   grpc_httpcli_set_override(httpcli_get_custom_keys_for_email,
                             httpcli_post_should_not_be_called);
   jwt = grpc_jwt_encode_and_sign(&key, expected_audience, expected_lifetime,
-                                 NULL);
+                                 nullptr);
   grpc_auth_json_key_destruct(&key);
-  GPR_ASSERT(jwt != NULL);
-  grpc_jwt_verifier_verify(&exec_ctx, verifier, NULL, jwt, expected_audience,
-                           on_verification_success, (void *)expected_user_data);
+  GPR_ASSERT(jwt != nullptr);
+  grpc_jwt_verifier_verify(&exec_ctx, verifier, nullptr, jwt, expected_audience,
+                           on_verification_success, (void*)expected_user_data);
   grpc_jwt_verifier_destroy(&exec_ctx, verifier);
   grpc_exec_ctx_finish(&exec_ctx);
   gpr_free(jwt);
-  grpc_httpcli_set_override(NULL, NULL);
+  grpc_httpcli_set_override(nullptr, nullptr);
 }
 
-static int httpcli_get_jwk_set(grpc_exec_ctx *exec_ctx,
-                               const grpc_httpcli_request *request,
-                               grpc_millis deadline, grpc_closure *on_done,
-                               grpc_httpcli_response *response) {
+static int httpcli_get_jwk_set(grpc_exec_ctx* exec_ctx,
+                               const grpc_httpcli_request* request,
+                               grpc_millis deadline, grpc_closure* on_done,
+                               grpc_httpcli_response* response) {
   *response = http_response(200, gpr_strdup(good_jwk_set));
   GPR_ASSERT(request->handshaker == &grpc_httpcli_ssl);
   GPR_ASSERT(strcmp(request->host, "www.googleapis.com") == 0);
@@ -423,11 +423,11 @@ static int httpcli_get_jwk_set(grpc_exec_ctx *exec_ctx,
   return 1;
 }
 
-static int httpcli_get_openid_config(grpc_exec_ctx *exec_ctx,
-                                     const grpc_httpcli_request *request,
+static int httpcli_get_openid_config(grpc_exec_ctx* exec_ctx,
+                                     const grpc_httpcli_request* request,
                                      grpc_millis deadline,
-                                     grpc_closure *on_done,
-                                     grpc_httpcli_response *response) {
+                                     grpc_closure* on_done,
+                                     grpc_httpcli_response* response) {
   *response = http_response(200, gpr_strdup(good_openid_config));
   GPR_ASSERT(request->handshaker == &grpc_httpcli_ssl);
   GPR_ASSERT(strcmp(request->host, "accounts.google.com") == 0);
@@ -440,39 +440,39 @@ static int httpcli_get_openid_config(grpc_exec_ctx *exec_ctx,
 
 static void test_jwt_verifier_url_issuer_success(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_jwt_verifier *verifier = grpc_jwt_verifier_create(NULL, 0);
-  char *jwt = NULL;
-  char *key_str = json_key_str(json_key_str_part3_for_url_issuer);
+  grpc_jwt_verifier* verifier = grpc_jwt_verifier_create(nullptr, 0);
+  char* jwt = nullptr;
+  char* key_str = json_key_str(json_key_str_part3_for_url_issuer);
   grpc_auth_json_key key = grpc_auth_json_key_create_from_string(key_str);
   gpr_free(key_str);
   GPR_ASSERT(grpc_auth_json_key_is_valid(&key));
   grpc_httpcli_set_override(httpcli_get_openid_config,
                             httpcli_post_should_not_be_called);
   jwt = grpc_jwt_encode_and_sign(&key, expected_audience, expected_lifetime,
-                                 NULL);
+                                 nullptr);
   grpc_auth_json_key_destruct(&key);
-  GPR_ASSERT(jwt != NULL);
-  grpc_jwt_verifier_verify(&exec_ctx, verifier, NULL, jwt, expected_audience,
-                           on_verification_success, (void *)expected_user_data);
+  GPR_ASSERT(jwt != nullptr);
+  grpc_jwt_verifier_verify(&exec_ctx, verifier, nullptr, jwt, expected_audience,
+                           on_verification_success, (void*)expected_user_data);
   grpc_jwt_verifier_destroy(&exec_ctx, verifier);
   grpc_exec_ctx_finish(&exec_ctx);
   gpr_free(jwt);
-  grpc_httpcli_set_override(NULL, NULL);
+  grpc_httpcli_set_override(nullptr, nullptr);
 }
 
-static void on_verification_key_retrieval_error(grpc_exec_ctx *exec_ctx,
-                                                void *user_data,
+static void on_verification_key_retrieval_error(grpc_exec_ctx* exec_ctx,
+                                                void* user_data,
                                                 grpc_jwt_verifier_status status,
-                                                grpc_jwt_claims *claims) {
+                                                grpc_jwt_claims* claims) {
   GPR_ASSERT(status == GRPC_JWT_VERIFIER_KEY_RETRIEVAL_ERROR);
-  GPR_ASSERT(claims == NULL);
-  GPR_ASSERT(user_data == (void *)expected_user_data);
+  GPR_ASSERT(claims == nullptr);
+  GPR_ASSERT(user_data == (void*)expected_user_data);
 }
 
-static int httpcli_get_bad_json(grpc_exec_ctx *exec_ctx,
-                                const grpc_httpcli_request *request,
-                                grpc_millis deadline, grpc_closure *on_done,
-                                grpc_httpcli_response *response) {
+static int httpcli_get_bad_json(grpc_exec_ctx* exec_ctx,
+                                const grpc_httpcli_request* request,
+                                grpc_millis deadline, grpc_closure* on_done,
+                                grpc_httpcli_response* response) {
   *response = http_response(200, gpr_strdup("{\"bad\": \"stuff\"}"));
   GPR_ASSERT(request->handshaker == &grpc_httpcli_ssl);
   GRPC_CLOSURE_SCHED(exec_ctx, on_done, GRPC_ERROR_NONE);
@@ -481,56 +481,56 @@ static int httpcli_get_bad_json(grpc_exec_ctx *exec_ctx,
 
 static void test_jwt_verifier_url_issuer_bad_config(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_jwt_verifier *verifier = grpc_jwt_verifier_create(NULL, 0);
-  char *jwt = NULL;
-  char *key_str = json_key_str(json_key_str_part3_for_url_issuer);
+  grpc_jwt_verifier* verifier = grpc_jwt_verifier_create(nullptr, 0);
+  char* jwt = nullptr;
+  char* key_str = json_key_str(json_key_str_part3_for_url_issuer);
   grpc_auth_json_key key = grpc_auth_json_key_create_from_string(key_str);
   gpr_free(key_str);
   GPR_ASSERT(grpc_auth_json_key_is_valid(&key));
   grpc_httpcli_set_override(httpcli_get_bad_json,
                             httpcli_post_should_not_be_called);
   jwt = grpc_jwt_encode_and_sign(&key, expected_audience, expected_lifetime,
-                                 NULL);
+                                 nullptr);
   grpc_auth_json_key_destruct(&key);
-  GPR_ASSERT(jwt != NULL);
-  grpc_jwt_verifier_verify(&exec_ctx, verifier, NULL, jwt, expected_audience,
+  GPR_ASSERT(jwt != nullptr);
+  grpc_jwt_verifier_verify(&exec_ctx, verifier, nullptr, jwt, expected_audience,
                            on_verification_key_retrieval_error,
-                           (void *)expected_user_data);
+                           (void*)expected_user_data);
   grpc_jwt_verifier_destroy(&exec_ctx, verifier);
   grpc_exec_ctx_finish(&exec_ctx);
   gpr_free(jwt);
-  grpc_httpcli_set_override(NULL, NULL);
+  grpc_httpcli_set_override(nullptr, nullptr);
 }
 
 static void test_jwt_verifier_bad_json_key(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_jwt_verifier *verifier = grpc_jwt_verifier_create(NULL, 0);
-  char *jwt = NULL;
-  char *key_str = json_key_str(json_key_str_part3_for_google_email_issuer);
+  grpc_jwt_verifier* verifier = grpc_jwt_verifier_create(nullptr, 0);
+  char* jwt = nullptr;
+  char* key_str = json_key_str(json_key_str_part3_for_google_email_issuer);
   grpc_auth_json_key key = grpc_auth_json_key_create_from_string(key_str);
   gpr_free(key_str);
   GPR_ASSERT(grpc_auth_json_key_is_valid(&key));
   grpc_httpcli_set_override(httpcli_get_bad_json,
                             httpcli_post_should_not_be_called);
   jwt = grpc_jwt_encode_and_sign(&key, expected_audience, expected_lifetime,
-                                 NULL);
+                                 nullptr);
   grpc_auth_json_key_destruct(&key);
-  GPR_ASSERT(jwt != NULL);
-  grpc_jwt_verifier_verify(&exec_ctx, verifier, NULL, jwt, expected_audience,
+  GPR_ASSERT(jwt != nullptr);
+  grpc_jwt_verifier_verify(&exec_ctx, verifier, nullptr, jwt, expected_audience,
                            on_verification_key_retrieval_error,
-                           (void *)expected_user_data);
+                           (void*)expected_user_data);
   grpc_jwt_verifier_destroy(&exec_ctx, verifier);
   grpc_exec_ctx_finish(&exec_ctx);
   gpr_free(jwt);
-  grpc_httpcli_set_override(NULL, NULL);
+  grpc_httpcli_set_override(nullptr, nullptr);
 }
 
-static void corrupt_jwt_sig(char *jwt) {
+static void corrupt_jwt_sig(char* jwt) {
   grpc_slice sig;
-  char *bad_b64_sig;
-  uint8_t *sig_bytes;
-  char *last_dot = strrchr(jwt, '.');
-  GPR_ASSERT(last_dot != NULL);
+  char* bad_b64_sig;
+  uint8_t* sig_bytes;
+  char* last_dot = strrchr(jwt, '.');
+  GPR_ASSERT(last_dot != nullptr);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     sig = grpc_base64_decode(&exec_ctx, last_dot + 1, 1);
@@ -546,74 +546,74 @@ static void corrupt_jwt_sig(char *jwt) {
   grpc_slice_unref(sig);
 }
 
-static void on_verification_bad_signature(grpc_exec_ctx *exec_ctx,
-                                          void *user_data,
+static void on_verification_bad_signature(grpc_exec_ctx* exec_ctx,
+                                          void* user_data,
                                           grpc_jwt_verifier_status status,
-                                          grpc_jwt_claims *claims) {
+                                          grpc_jwt_claims* claims) {
   GPR_ASSERT(status == GRPC_JWT_VERIFIER_BAD_SIGNATURE);
-  GPR_ASSERT(claims == NULL);
-  GPR_ASSERT(user_data == (void *)expected_user_data);
+  GPR_ASSERT(claims == nullptr);
+  GPR_ASSERT(user_data == (void*)expected_user_data);
 }
 
 static void test_jwt_verifier_bad_signature(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_jwt_verifier *verifier = grpc_jwt_verifier_create(NULL, 0);
-  char *jwt = NULL;
-  char *key_str = json_key_str(json_key_str_part3_for_url_issuer);
+  grpc_jwt_verifier* verifier = grpc_jwt_verifier_create(nullptr, 0);
+  char* jwt = nullptr;
+  char* key_str = json_key_str(json_key_str_part3_for_url_issuer);
   grpc_auth_json_key key = grpc_auth_json_key_create_from_string(key_str);
   gpr_free(key_str);
   GPR_ASSERT(grpc_auth_json_key_is_valid(&key));
   grpc_httpcli_set_override(httpcli_get_openid_config,
                             httpcli_post_should_not_be_called);
   jwt = grpc_jwt_encode_and_sign(&key, expected_audience, expected_lifetime,
-                                 NULL);
+                                 nullptr);
   grpc_auth_json_key_destruct(&key);
   corrupt_jwt_sig(jwt);
-  GPR_ASSERT(jwt != NULL);
-  grpc_jwt_verifier_verify(&exec_ctx, verifier, NULL, jwt, expected_audience,
+  GPR_ASSERT(jwt != nullptr);
+  grpc_jwt_verifier_verify(&exec_ctx, verifier, nullptr, jwt, expected_audience,
                            on_verification_bad_signature,
-                           (void *)expected_user_data);
+                           (void*)expected_user_data);
   gpr_free(jwt);
   grpc_jwt_verifier_destroy(&exec_ctx, verifier);
   grpc_exec_ctx_finish(&exec_ctx);
-  grpc_httpcli_set_override(NULL, NULL);
+  grpc_httpcli_set_override(nullptr, nullptr);
 }
 
-static int httpcli_get_should_not_be_called(grpc_exec_ctx *exec_ctx,
-                                            const grpc_httpcli_request *request,
+static int httpcli_get_should_not_be_called(grpc_exec_ctx* exec_ctx,
+                                            const grpc_httpcli_request* request,
                                             grpc_millis deadline,
-                                            grpc_closure *on_done,
-                                            grpc_httpcli_response *response) {
+                                            grpc_closure* on_done,
+                                            grpc_httpcli_response* response) {
   GPR_ASSERT(0);
   return 1;
 }
 
-static void on_verification_bad_format(grpc_exec_ctx *exec_ctx, void *user_data,
+static void on_verification_bad_format(grpc_exec_ctx* exec_ctx, void* user_data,
                                        grpc_jwt_verifier_status status,
-                                       grpc_jwt_claims *claims) {
+                                       grpc_jwt_claims* claims) {
   GPR_ASSERT(status == GRPC_JWT_VERIFIER_BAD_FORMAT);
-  GPR_ASSERT(claims == NULL);
-  GPR_ASSERT(user_data == (void *)expected_user_data);
+  GPR_ASSERT(claims == nullptr);
+  GPR_ASSERT(user_data == (void*)expected_user_data);
 }
 
 static void test_jwt_verifier_bad_format(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_jwt_verifier *verifier = grpc_jwt_verifier_create(NULL, 0);
+  grpc_jwt_verifier* verifier = grpc_jwt_verifier_create(nullptr, 0);
   grpc_httpcli_set_override(httpcli_get_should_not_be_called,
                             httpcli_post_should_not_be_called);
-  grpc_jwt_verifier_verify(&exec_ctx, verifier, NULL, "bad jwt",
+  grpc_jwt_verifier_verify(&exec_ctx, verifier, nullptr, "bad jwt",
                            expected_audience, on_verification_bad_format,
-                           (void *)expected_user_data);
+                           (void*)expected_user_data);
   grpc_jwt_verifier_destroy(&exec_ctx, verifier);
   grpc_exec_ctx_finish(&exec_ctx);
-  grpc_httpcli_set_override(NULL, NULL);
+  grpc_httpcli_set_override(nullptr, nullptr);
 }
 
 /* find verification key: bad jks, cannot find key in jks */
 /* bad signature custom provided email*/
 /* bad key */
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   test_jwt_issuer_email_domain();
diff --git a/test/core/security/oauth2_utils.c b/test/core/security/oauth2_utils.cc
index 73d6c5bc7d..602041eecc 100644
--- a/test/core/security/oauth2_utils.c
+++ b/test/core/security/oauth2_utils.cc
@@ -30,26 +30,26 @@
 #include "src/core/lib/security/credentials/credentials.h"
 
 typedef struct {
-  gpr_mu *mu;
+  gpr_mu* mu;
   grpc_polling_entity pops;
   bool is_done;
-  char *token;
+  char* token;
 
   grpc_credentials_mdelem_array md_array;
   grpc_closure closure;
 } oauth2_request;
 
-static void on_oauth2_response(grpc_exec_ctx *exec_ctx, void *arg,
-                               grpc_error *error) {
-  oauth2_request *request = (oauth2_request *)arg;
-  char *token = NULL;
+static void on_oauth2_response(grpc_exec_ctx* exec_ctx, void* arg,
+                               grpc_error* error) {
+  oauth2_request* request = (oauth2_request*)arg;
+  char* token = nullptr;
   grpc_slice token_slice;
   if (error != GRPC_ERROR_NONE) {
     gpr_log(GPR_ERROR, "Fetching token failed: %s", grpc_error_string(error));
   } else {
     GPR_ASSERT(request->md_array.size == 1);
     token_slice = GRPC_MDVALUE(request->md_array.md[0]);
-    token = (char *)gpr_malloc(GRPC_SLICE_LENGTH(token_slice) + 1);
+    token = (char*)gpr_malloc(GRPC_SLICE_LENGTH(token_slice) + 1);
     memcpy(token, GRPC_SLICE_START_PTR(token_slice),
            GRPC_SLICE_LENGTH(token_slice));
     token[GRPC_SLICE_LENGTH(token_slice)] = '\0';
@@ -61,33 +61,33 @@ static void on_oauth2_response(grpc_exec_ctx *exec_ctx, void *arg,
   GRPC_LOG_IF_ERROR(
       "pollset_kick",
       grpc_pollset_kick(exec_ctx, grpc_polling_entity_pollset(&request->pops),
-                        NULL));
+                        nullptr));
   gpr_mu_unlock(request->mu);
 }
 
-static void do_nothing(grpc_exec_ctx *exec_ctx, void *unused,
-                       grpc_error *error) {}
+static void do_nothing(grpc_exec_ctx* exec_ctx, void* unused,
+                       grpc_error* error) {}
 
-char *grpc_test_fetch_oauth2_token_with_credentials(
-    grpc_call_credentials *creds) {
+char* grpc_test_fetch_oauth2_token_with_credentials(
+    grpc_call_credentials* creds) {
   oauth2_request request;
   memset(&request, 0, sizeof(request));
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_closure do_nothing_closure;
-  grpc_auth_metadata_context null_ctx = {"", "", NULL, NULL};
+  grpc_auth_metadata_context null_ctx = {"", "", nullptr, nullptr};
 
-  grpc_pollset *pollset = (grpc_pollset *)gpr_zalloc(grpc_pollset_size());
+  grpc_pollset* pollset = (grpc_pollset*)gpr_zalloc(grpc_pollset_size());
   grpc_pollset_init(pollset, &request.mu);
   request.pops = grpc_polling_entity_create_from_pollset(pollset);
   request.is_done = false;
 
-  GRPC_CLOSURE_INIT(&do_nothing_closure, do_nothing, NULL,
+  GRPC_CLOSURE_INIT(&do_nothing_closure, do_nothing, nullptr,
                     grpc_schedule_on_exec_ctx);
 
   GRPC_CLOSURE_INIT(&request.closure, on_oauth2_response, &request,
                     grpc_schedule_on_exec_ctx);
 
-  grpc_error *error = GRPC_ERROR_NONE;
+  grpc_error* error = GRPC_ERROR_NONE;
   if (grpc_call_credentials_get_request_metadata(
           &exec_ctx, creds, &request.pops, null_ctx, &request.md_array,
           &request.closure, &error)) {
@@ -99,7 +99,7 @@ char *grpc_test_fetch_oauth2_token_with_credentials(
 
   gpr_mu_lock(request.mu);
   while (!request.is_done) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     if (!GRPC_LOG_IF_ERROR(
             "pollset_work",
             grpc_pollset_work(&exec_ctx,
diff --git a/test/core/security/oauth2_utils.h b/test/core/security/oauth2_utils.h
index 15f68bd6d8..5ad2e398e1 100644
--- a/test/core/security/oauth2_utils.h
+++ b/test/core/security/oauth2_utils.h
@@ -21,17 +21,9 @@
 
 #include "src/core/lib/security/credentials/credentials.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /* Fetch oauth2 access token with a credentials object. Does not take ownership.
    Returns NULL on a failure. The caller should call gpr_free on the token. */
-char *grpc_test_fetch_oauth2_token_with_credentials(
-    grpc_call_credentials *creds);
-
-#ifdef __cplusplus
-}
-#endif
+char* grpc_test_fetch_oauth2_token_with_credentials(
+    grpc_call_credentials* creds);
 
 #endif /* GRPC_TEST_CORE_SECURITY_OAUTH2_UTILS_H */
diff --git a/test/core/security/print_google_default_creds_token.c b/test/core/security/print_google_default_creds_token.cc
index 29c38dfdf8..f4acf023bd 100644
--- a/test/core/security/print_google_default_creds_token.c
+++ b/test/core/security/print_google_default_creds_token.cc
@@ -33,7 +33,7 @@
 #include "src/core/lib/support/string.h"
 
 typedef struct {
-  gpr_mu *mu;
+  gpr_mu* mu;
   grpc_polling_entity pops;
   bool is_done;
 
@@ -41,13 +41,13 @@ typedef struct {
   grpc_closure on_request_metadata;
 } synchronizer;
 
-static void on_metadata_response(grpc_exec_ctx *exec_ctx, void *arg,
-                                 grpc_error *error) {
-  synchronizer *sync = arg;
+static void on_metadata_response(grpc_exec_ctx* exec_ctx, void* arg,
+                                 grpc_error* error) {
+  synchronizer* sync = static_cast<synchronizer*>(arg);
   if (error != GRPC_ERROR_NONE) {
     fprintf(stderr, "Fetching token failed: %s\n", grpc_error_string(error));
   } else {
-    char *token;
+    char* token;
     GPR_ASSERT(sync->md_array.size == 1);
     token = grpc_slice_to_c_string(GRPC_MDVALUE(sync->md_array.md[0]));
     printf("\nGot token: %s\n\n", token);
@@ -58,18 +58,20 @@ static void on_metadata_response(grpc_exec_ctx *exec_ctx, void *arg,
   GRPC_LOG_IF_ERROR(
       "pollset_kick",
       grpc_pollset_kick(exec_ctx, grpc_polling_entity_pollset(&sync->pops),
-                        NULL));
+                        nullptr));
   gpr_mu_unlock(sync->mu);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   int result = 0;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   synchronizer sync;
-  grpc_channel_credentials *creds = NULL;
-  char *service_url = "https://test.foo.google.com/Foo";
+  grpc_channel_credentials* creds = nullptr;
+  const char* service_url = "https://test.foo.google.com/Foo";
   grpc_auth_metadata_context context;
-  gpr_cmdline *cl = gpr_cmdline_create("print_google_default_creds_token");
+  gpr_cmdline* cl = gpr_cmdline_create("print_google_default_creds_token");
+  grpc_pollset* pollset = nullptr;
+  grpc_error* error = nullptr;
   gpr_cmdline_add_string(cl, "service_url",
                          "Service URL for the token request.", &service_url);
   gpr_cmdline_parse(cl, argc, argv);
@@ -79,23 +81,23 @@ int main(int argc, char **argv) {
   grpc_init();
 
   creds = grpc_google_default_credentials_create();
-  if (creds == NULL) {
+  if (creds == nullptr) {
     fprintf(stderr, "\nCould not find default credentials.\n\n");
     result = 1;
     goto end;
   }
 
   memset(&sync, 0, sizeof(sync));
-  grpc_pollset *pollset = gpr_zalloc(grpc_pollset_size());
+  pollset = (grpc_pollset*)gpr_zalloc(grpc_pollset_size());
   grpc_pollset_init(pollset, &sync.mu);
   sync.pops = grpc_polling_entity_create_from_pollset(pollset);
   sync.is_done = false;
   GRPC_CLOSURE_INIT(&sync.on_request_metadata, on_metadata_response, &sync,
                     grpc_schedule_on_exec_ctx);
 
-  grpc_error *error = GRPC_ERROR_NONE;
+  error = GRPC_ERROR_NONE;
   if (grpc_call_credentials_get_request_metadata(
-          &exec_ctx, ((grpc_composite_channel_credentials *)creds)->call_creds,
+          &exec_ctx, ((grpc_composite_channel_credentials*)creds)->call_creds,
           &sync.pops, context, &sync.md_array, &sync.on_request_metadata,
           &error)) {
     // Synchronous response.  Invoke callback directly.
@@ -105,7 +107,7 @@ int main(int argc, char **argv) {
 
   gpr_mu_lock(sync.mu);
   while (!sync.is_done) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     if (!GRPC_LOG_IF_ERROR(
             "pollset_work",
             grpc_pollset_work(&exec_ctx,
diff --git a/test/core/security/secure_endpoint_test.c b/test/core/security/secure_endpoint_test.cc
index 839a05fa9b..a12af02479 100644
--- a/test/core/security/secure_endpoint_test.c
+++ b/test/core/security/secure_endpoint_test.cc
@@ -32,30 +32,33 @@
 #include "src/core/tsi/fake_transport_security.h"
 #include "test/core/util/test_config.h"
 
-static gpr_mu *g_mu;
-static grpc_pollset *g_pollset;
+static gpr_mu* g_mu;
+static grpc_pollset* g_pollset;
 
 static grpc_endpoint_test_fixture secure_endpoint_create_fixture_tcp_socketpair(
-    size_t slice_size, grpc_slice *leftover_slices, size_t leftover_nslices,
+    size_t slice_size, grpc_slice* leftover_slices, size_t leftover_nslices,
     bool use_zero_copy_protector) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  tsi_frame_protector *fake_read_protector =
-      tsi_create_fake_frame_protector(NULL);
-  tsi_frame_protector *fake_write_protector =
-      tsi_create_fake_frame_protector(NULL);
-  tsi_zero_copy_grpc_protector *fake_read_zero_copy_protector =
-      use_zero_copy_protector ? tsi_create_fake_zero_copy_grpc_protector(NULL)
-                              : NULL;
-  tsi_zero_copy_grpc_protector *fake_write_zero_copy_protector =
-      use_zero_copy_protector ? tsi_create_fake_zero_copy_grpc_protector(NULL)
-                              : NULL;
+  tsi_frame_protector* fake_read_protector =
+      tsi_create_fake_frame_protector(nullptr);
+  tsi_frame_protector* fake_write_protector =
+      tsi_create_fake_frame_protector(nullptr);
+  tsi_zero_copy_grpc_protector* fake_read_zero_copy_protector =
+      use_zero_copy_protector
+          ? tsi_create_fake_zero_copy_grpc_protector(nullptr)
+          : nullptr;
+  tsi_zero_copy_grpc_protector* fake_write_zero_copy_protector =
+      use_zero_copy_protector
+          ? tsi_create_fake_zero_copy_grpc_protector(nullptr)
+          : nullptr;
   grpc_endpoint_test_fixture f;
   grpc_endpoint_pair tcp;
 
-  grpc_arg a[] = {{.key = GRPC_ARG_TCP_READ_CHUNK_SIZE,
-                   .type = GRPC_ARG_INTEGER,
-                   .value.integer = (int)slice_size}};
-  grpc_channel_args args = {.num_args = GPR_ARRAY_SIZE(a), .args = a};
+  grpc_arg a[1];
+  a[0].key = const_cast<char*>(GRPC_ARG_TCP_READ_CHUNK_SIZE);
+  a[0].type = GRPC_ARG_INTEGER;
+  a[0].value.integer = (int)slice_size;
+  grpc_channel_args args = {GPR_ARRAY_SIZE(a), a};
   tcp = grpc_iomgr_create_endpoint_pair("fixture", &args);
   grpc_endpoint_add_to_pollset(&exec_ctx, tcp.client, g_pollset);
   grpc_endpoint_add_to_pollset(&exec_ctx, tcp.server, g_pollset);
@@ -63,19 +66,19 @@ static grpc_endpoint_test_fixture secure_endpoint_create_fixture_tcp_socketpair(
   if (leftover_nslices == 0) {
     f.client_ep = grpc_secure_endpoint_create(fake_read_protector,
                                               fake_read_zero_copy_protector,
-                                              tcp.client, NULL, 0);
+                                              tcp.client, nullptr, 0);
   } else {
     unsigned i;
     tsi_result result;
     size_t still_pending_size;
     size_t total_buffer_size = 8192;
     size_t buffer_size = total_buffer_size;
-    uint8_t *encrypted_buffer = (uint8_t *)gpr_malloc(buffer_size);
-    uint8_t *cur = encrypted_buffer;
+    uint8_t* encrypted_buffer = (uint8_t*)gpr_malloc(buffer_size);
+    uint8_t* cur = encrypted_buffer;
     grpc_slice encrypted_leftover;
     for (i = 0; i < leftover_nslices; i++) {
       grpc_slice plain = leftover_slices[i];
-      uint8_t *message_bytes = GRPC_SLICE_START_PTR(plain);
+      uint8_t* message_bytes = GRPC_SLICE_START_PTR(plain);
       size_t message_size = GRPC_SLICE_LENGTH(plain);
       while (message_size > 0) {
         size_t protected_buffer_size_to_send = buffer_size;
@@ -103,7 +106,7 @@ static grpc_endpoint_test_fixture secure_endpoint_create_fixture_tcp_socketpair(
       buffer_size -= protected_buffer_size_to_send;
     } while (still_pending_size > 0);
     encrypted_leftover = grpc_slice_from_copied_buffer(
-        (const char *)encrypted_buffer, total_buffer_size - buffer_size);
+        (const char*)encrypted_buffer, total_buffer_size - buffer_size);
     f.client_ep = grpc_secure_endpoint_create(
         fake_read_protector, fake_read_zero_copy_protector, tcp.client,
         &encrypted_leftover, 1);
@@ -113,21 +116,21 @@ static grpc_endpoint_test_fixture secure_endpoint_create_fixture_tcp_socketpair(
 
   f.server_ep = grpc_secure_endpoint_create(fake_write_protector,
                                             fake_write_zero_copy_protector,
-                                            tcp.server, NULL, 0);
+                                            tcp.server, nullptr, 0);
   grpc_exec_ctx_finish(&exec_ctx);
   return f;
 }
 
 static grpc_endpoint_test_fixture
 secure_endpoint_create_fixture_tcp_socketpair_noleftover(size_t slice_size) {
-  return secure_endpoint_create_fixture_tcp_socketpair(slice_size, NULL, 0,
+  return secure_endpoint_create_fixture_tcp_socketpair(slice_size, nullptr, 0,
                                                        false);
 }
 
 static grpc_endpoint_test_fixture
 secure_endpoint_create_fixture_tcp_socketpair_noleftover_zero_copy(
     size_t slice_size) {
-  return secure_endpoint_create_fixture_tcp_socketpair(slice_size, NULL, 0,
+  return secure_endpoint_create_fixture_tcp_socketpair(slice_size, nullptr, 0,
                                                        true);
 }
 
@@ -162,9 +165,9 @@ static grpc_endpoint_test_config configs[] = {
      clean_up},
 };
 
-static void inc_call_ctr(grpc_exec_ctx *exec_ctx, void *arg,
-                         grpc_error *error) {
-  ++*(int *)arg;
+static void inc_call_ctr(grpc_exec_ctx* exec_ctx, void* arg,
+                         grpc_error* error) {
+  ++*(int*)arg;
 }
 
 static void test_leftover(grpc_endpoint_test_config config, size_t slice_size) {
@@ -200,18 +203,18 @@ static void test_leftover(grpc_endpoint_test_config config, size_t slice_size) {
   clean_up();
 }
 
-static void destroy_pollset(grpc_exec_ctx *exec_ctx, void *p,
-                            grpc_error *error) {
-  grpc_pollset_destroy(exec_ctx, (grpc_pollset *)p);
+static void destroy_pollset(grpc_exec_ctx* exec_ctx, void* p,
+                            grpc_error* error) {
+  grpc_pollset_destroy(exec_ctx, (grpc_pollset*)p);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_closure destroyed;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_test_init(argc, argv);
 
   grpc_init();
-  g_pollset = (grpc_pollset *)gpr_zalloc(grpc_pollset_size());
+  g_pollset = (grpc_pollset*)gpr_zalloc(grpc_pollset_size());
   grpc_pollset_init(g_pollset, &g_mu);
   grpc_endpoint_tests(configs[0], g_pollset, g_mu);
   grpc_endpoint_tests(configs[1], g_pollset, g_mu);
diff --git a/test/core/security/security_connector_test.c b/test/core/security/security_connector_test.cc
index eecf0f462b..9a68e176db 100644
--- a/test/core/security/security_connector_test.c
+++ b/test/core/security/security_connector_test.cc
@@ -35,25 +35,25 @@
 #include "src/core/tsi/transport_security.h"
 #include "test/core/util/test_config.h"
 
-static int check_transport_security_type(const grpc_auth_context *ctx) {
+static int check_transport_security_type(const grpc_auth_context* ctx) {
   grpc_auth_property_iterator it = grpc_auth_context_find_properties_by_name(
       ctx, GRPC_TRANSPORT_SECURITY_TYPE_PROPERTY_NAME);
-  const grpc_auth_property *prop = grpc_auth_property_iterator_next(&it);
-  if (prop == NULL) return 0;
+  const grpc_auth_property* prop = grpc_auth_property_iterator_next(&it);
+  if (prop == nullptr) return 0;
   if (strncmp(prop->value, GRPC_SSL_TRANSPORT_SECURITY_TYPE,
               prop->value_length) != 0) {
     return 0;
   }
   /* Check that we have only one property with this name. */
-  if (grpc_auth_property_iterator_next(&it) != NULL) return 0;
+  if (grpc_auth_property_iterator_next(&it) != nullptr) return 0;
   return 1;
 }
 
-static int check_peer_property(const tsi_peer *peer,
-                               const tsi_peer_property *expected) {
+static int check_peer_property(const tsi_peer* peer,
+                               const tsi_peer_property* expected) {
   size_t i;
   for (i = 0; i < peer->property_count; i++) {
-    const tsi_peer_property *prop = &peer->properties[i];
+    const tsi_peer_property* prop = &peer->properties[i];
     if ((strcmp(prop->name, expected->name) == 0) &&
         (prop->value.length == expected->value.length) &&
         (memcmp(prop->value.data, expected->value.data,
@@ -64,12 +64,12 @@ static int check_peer_property(const tsi_peer *peer,
   return 0; /* Not found... */
 }
 
-static int check_ssl_peer_equivalence(const tsi_peer *original,
-                                      const tsi_peer *reconstructed) {
+static int check_ssl_peer_equivalence(const tsi_peer* original,
+                                      const tsi_peer* reconstructed) {
   /* The reconstructed peer only has CN, SAN and pem cert properties. */
   size_t i;
   for (i = 0; i < original->property_count; i++) {
-    const tsi_peer_property *prop = &original->properties[i];
+    const tsi_peer_property* prop = &original->properties[i];
     if ((strcmp(prop->name, TSI_X509_SUBJECT_COMMON_NAME_PEER_PROPERTY) == 0) ||
         (strcmp(prop->name, TSI_X509_SUBJECT_ALTERNATIVE_NAME_PEER_PROPERTY) ==
          0) ||
@@ -83,13 +83,13 @@ static int check_ssl_peer_equivalence(const tsi_peer *original,
 static void test_unauthenticated_ssl_peer(void) {
   tsi_peer peer;
   tsi_peer rpeer;
-  grpc_auth_context *ctx;
+  grpc_auth_context* ctx;
   GPR_ASSERT(tsi_construct_peer(1, &peer) == TSI_OK);
   GPR_ASSERT(tsi_construct_string_peer_property_from_cstring(
                  TSI_CERTIFICATE_TYPE_PEER_PROPERTY, TSI_X509_CERTIFICATE_TYPE,
                  &peer.properties[0]) == TSI_OK);
   ctx = tsi_ssl_peer_to_auth_context(&peer);
-  GPR_ASSERT(ctx != NULL);
+  GPR_ASSERT(ctx != nullptr);
   GPR_ASSERT(!grpc_auth_context_peer_is_authenticated(ctx));
   GPR_ASSERT(check_transport_security_type(ctx));
 
@@ -101,18 +101,18 @@ static void test_unauthenticated_ssl_peer(void) {
   GRPC_AUTH_CONTEXT_UNREF(ctx, "test");
 }
 
-static int check_identity(const grpc_auth_context *ctx,
-                          const char *expected_property_name,
-                          const char **expected_identities,
+static int check_identity(const grpc_auth_context* ctx,
+                          const char* expected_property_name,
+                          const char** expected_identities,
                           size_t num_identities) {
   grpc_auth_property_iterator it;
-  const grpc_auth_property *prop;
+  const grpc_auth_property* prop;
   size_t i;
   GPR_ASSERT(grpc_auth_context_peer_is_authenticated(ctx));
   it = grpc_auth_context_peer_identity(ctx);
   for (i = 0; i < num_identities; i++) {
     prop = grpc_auth_property_iterator_next(&it);
-    if (prop == NULL) {
+    if (prop == nullptr) {
       gpr_log(GPR_ERROR, "Expected identity value %s not found.",
               expected_identities[i]);
       return 0;
@@ -131,12 +131,12 @@ static int check_identity(const grpc_auth_context *ctx,
   return 1;
 }
 
-static int check_x509_cn(const grpc_auth_context *ctx,
-                         const char *expected_cn) {
+static int check_x509_cn(const grpc_auth_context* ctx,
+                         const char* expected_cn) {
   grpc_auth_property_iterator it = grpc_auth_context_find_properties_by_name(
       ctx, GRPC_X509_CN_PROPERTY_NAME);
-  const grpc_auth_property *prop = grpc_auth_property_iterator_next(&it);
-  if (prop == NULL) {
+  const grpc_auth_property* prop = grpc_auth_property_iterator_next(&it);
+  if (prop == nullptr) {
     gpr_log(GPR_ERROR, "CN property not found.");
     return 0;
   }
@@ -144,19 +144,19 @@ static int check_x509_cn(const grpc_auth_context *ctx,
     gpr_log(GPR_ERROR, "Expected CN %s and got %s", expected_cn, prop->value);
     return 0;
   }
-  if (grpc_auth_property_iterator_next(&it) != NULL) {
+  if (grpc_auth_property_iterator_next(&it) != nullptr) {
     gpr_log(GPR_ERROR, "Expected only one property for CN.");
     return 0;
   }
   return 1;
 }
 
-static int check_x509_pem_cert(const grpc_auth_context *ctx,
-                               const char *expected_pem_cert) {
+static int check_x509_pem_cert(const grpc_auth_context* ctx,
+                               const char* expected_pem_cert) {
   grpc_auth_property_iterator it = grpc_auth_context_find_properties_by_name(
       ctx, GRPC_X509_PEM_CERT_PROPERTY_NAME);
-  const grpc_auth_property *prop = grpc_auth_property_iterator_next(&it);
-  if (prop == NULL) {
+  const grpc_auth_property* prop = grpc_auth_property_iterator_next(&it);
+  if (prop == nullptr) {
     gpr_log(GPR_ERROR, "Pem certificate property not found.");
     return 0;
   }
@@ -165,7 +165,7 @@ static int check_x509_pem_cert(const grpc_auth_context *ctx,
             prop->value);
     return 0;
   }
-  if (grpc_auth_property_iterator_next(&it) != NULL) {
+  if (grpc_auth_property_iterator_next(&it) != nullptr) {
     gpr_log(GPR_ERROR, "Expected only one property for pem cert.");
     return 0;
   }
@@ -175,9 +175,9 @@ static int check_x509_pem_cert(const grpc_auth_context *ctx,
 static void test_cn_only_ssl_peer_to_auth_context(void) {
   tsi_peer peer;
   tsi_peer rpeer;
-  grpc_auth_context *ctx;
-  const char *expected_cn = "cn1";
-  const char *expected_pem_cert = "pem_cert1";
+  grpc_auth_context* ctx;
+  const char* expected_cn = "cn1";
+  const char* expected_pem_cert = "pem_cert1";
   GPR_ASSERT(tsi_construct_peer(3, &peer) == TSI_OK);
   GPR_ASSERT(tsi_construct_string_peer_property_from_cstring(
                  TSI_CERTIFICATE_TYPE_PEER_PROPERTY, TSI_X509_CERTIFICATE_TYPE,
@@ -189,7 +189,7 @@ static void test_cn_only_ssl_peer_to_auth_context(void) {
                  TSI_X509_PEM_CERT_PROPERTY, expected_pem_cert,
                  &peer.properties[2]) == TSI_OK);
   ctx = tsi_ssl_peer_to_auth_context(&peer);
-  GPR_ASSERT(ctx != NULL);
+  GPR_ASSERT(ctx != nullptr);
   GPR_ASSERT(grpc_auth_context_peer_is_authenticated(ctx));
   GPR_ASSERT(check_identity(ctx, GRPC_X509_CN_PROPERTY_NAME, &expected_cn, 1));
   GPR_ASSERT(check_transport_security_type(ctx));
@@ -207,10 +207,10 @@ static void test_cn_only_ssl_peer_to_auth_context(void) {
 static void test_cn_and_one_san_ssl_peer_to_auth_context(void) {
   tsi_peer peer;
   tsi_peer rpeer;
-  grpc_auth_context *ctx;
-  const char *expected_cn = "cn1";
-  const char *expected_san = "san1";
-  const char *expected_pem_cert = "pem_cert1";
+  grpc_auth_context* ctx;
+  const char* expected_cn = "cn1";
+  const char* expected_san = "san1";
+  const char* expected_pem_cert = "pem_cert1";
   GPR_ASSERT(tsi_construct_peer(4, &peer) == TSI_OK);
   GPR_ASSERT(tsi_construct_string_peer_property_from_cstring(
                  TSI_CERTIFICATE_TYPE_PEER_PROPERTY, TSI_X509_CERTIFICATE_TYPE,
@@ -225,7 +225,7 @@ static void test_cn_and_one_san_ssl_peer_to_auth_context(void) {
                  TSI_X509_PEM_CERT_PROPERTY, expected_pem_cert,
                  &peer.properties[3]) == TSI_OK);
   ctx = tsi_ssl_peer_to_auth_context(&peer);
-  GPR_ASSERT(ctx != NULL);
+  GPR_ASSERT(ctx != nullptr);
   GPR_ASSERT(grpc_auth_context_peer_is_authenticated(ctx));
   GPR_ASSERT(
       check_identity(ctx, GRPC_X509_SAN_PROPERTY_NAME, &expected_san, 1));
@@ -244,10 +244,10 @@ static void test_cn_and_one_san_ssl_peer_to_auth_context(void) {
 static void test_cn_and_multiple_sans_ssl_peer_to_auth_context(void) {
   tsi_peer peer;
   tsi_peer rpeer;
-  grpc_auth_context *ctx;
-  const char *expected_cn = "cn1";
-  const char *expected_sans[] = {"san1", "san2", "san3"};
-  const char *expected_pem_cert = "pem_cert1";
+  grpc_auth_context* ctx;
+  const char* expected_cn = "cn1";
+  const char* expected_sans[] = {"san1", "san2", "san3"};
+  const char* expected_pem_cert = "pem_cert1";
   size_t i;
   GPR_ASSERT(tsi_construct_peer(3 + GPR_ARRAY_SIZE(expected_sans), &peer) ==
              TSI_OK);
@@ -266,7 +266,7 @@ static void test_cn_and_multiple_sans_ssl_peer_to_auth_context(void) {
                    expected_sans[i], &peer.properties[3 + i]) == TSI_OK);
   }
   ctx = tsi_ssl_peer_to_auth_context(&peer);
-  GPR_ASSERT(ctx != NULL);
+  GPR_ASSERT(ctx != nullptr);
   GPR_ASSERT(grpc_auth_context_peer_is_authenticated(ctx));
   GPR_ASSERT(check_identity(ctx, GRPC_X509_SAN_PROPERTY_NAME, expected_sans,
                             GPR_ARRAY_SIZE(expected_sans)));
@@ -286,10 +286,10 @@ static void test_cn_and_multiple_sans_and_others_ssl_peer_to_auth_context(
     void) {
   tsi_peer peer;
   tsi_peer rpeer;
-  grpc_auth_context *ctx;
-  const char *expected_cn = "cn1";
-  const char *expected_pem_cert = "pem_cert1";
-  const char *expected_sans[] = {"san1", "san2", "san3"};
+  grpc_auth_context* ctx;
+  const char* expected_cn = "cn1";
+  const char* expected_pem_cert = "pem_cert1";
+  const char* expected_sans[] = {"san1", "san2", "san3"};
   size_t i;
   GPR_ASSERT(tsi_construct_peer(5 + GPR_ARRAY_SIZE(expected_sans), &peer) ==
              TSI_OK);
@@ -312,7 +312,7 @@ static void test_cn_and_multiple_sans_and_others_ssl_peer_to_auth_context(
                    expected_sans[i], &peer.properties[5 + i]) == TSI_OK);
   }
   ctx = tsi_ssl_peer_to_auth_context(&peer);
-  GPR_ASSERT(ctx != NULL);
+  GPR_ASSERT(ctx != nullptr);
   GPR_ASSERT(grpc_auth_context_peer_is_authenticated(ctx));
   GPR_ASSERT(check_identity(ctx, GRPC_X509_SAN_PROPERTY_NAME, expected_sans,
                             GPR_ARRAY_SIZE(expected_sans)));
@@ -328,24 +328,24 @@ static void test_cn_and_multiple_sans_and_others_ssl_peer_to_auth_context(
   GRPC_AUTH_CONTEXT_UNREF(ctx, "test");
 }
 
-static const char *roots_for_override_api = "roots for override api";
+static const char* roots_for_override_api = "roots for override api";
 
 static grpc_ssl_roots_override_result override_roots_success(
-    char **pem_root_certs) {
+    char** pem_root_certs) {
   *pem_root_certs = gpr_strdup(roots_for_override_api);
   return GRPC_SSL_ROOTS_OVERRIDE_OK;
 }
 
 static grpc_ssl_roots_override_result override_roots_permanent_failure(
-    char **pem_root_certs) {
+    char** pem_root_certs) {
   return GRPC_SSL_ROOTS_OVERRIDE_FAIL_PERMANENTLY;
 }
 
 static void test_default_ssl_roots(void) {
-  const char *roots_for_env_var = "roots for env var";
+  const char* roots_for_env_var = "roots for env var";
 
-  char *roots_env_var_file_path;
-  FILE *roots_env_var_file =
+  char* roots_env_var_file_path;
+  FILE* roots_env_var_file =
       gpr_tmpfile("test_roots_for_env_var", &roots_env_var_file_path);
   fwrite(roots_for_env_var, 1, strlen(roots_for_env_var), roots_env_var_file);
   fclose(roots_env_var_file);
@@ -355,7 +355,7 @@ static void test_default_ssl_roots(void) {
   gpr_setenv(GRPC_DEFAULT_SSL_ROOTS_FILE_PATH_ENV_VAR, "");
   grpc_set_ssl_roots_override_callback(override_roots_success);
   grpc_slice roots = grpc_get_default_ssl_roots_for_testing();
-  char *roots_contents = grpc_slice_to_c_string(roots);
+  char* roots_contents = grpc_slice_to_c_string(roots);
   grpc_slice_unref(roots);
   GPR_ASSERT(strcmp(roots_contents, roots_for_override_api) == 0);
   gpr_free(roots_contents);
@@ -389,7 +389,7 @@ static void test_default_ssl_roots(void) {
   gpr_free(roots_env_var_file_path);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
 
diff --git a/test/core/security/ssl_credentials_test.cc b/test/core/security/ssl_credentials_test.cc
new file mode 100644
index 0000000000..9edcf42d3a
--- /dev/null
+++ b/test/core/security/ssl_credentials_test.cc
@@ -0,0 +1,66 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include <grpc/grpc_security.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+
+#include "src/core/lib/security/credentials/ssl/ssl_credentials.h"
+#include "src/core/tsi/ssl_transport_security.h"
+#include "test/core/util/test_config.h"
+
+static void test_convert_grpc_to_tsi_cert_pairs() {
+  grpc_ssl_pem_key_cert_pair grpc_pairs[] = {{"private_key1", "cert_chain1"},
+                                             {"private_key2", "cert_chain2"},
+                                             {"private_key3", "cert_chain3"}};
+  const size_t num_pairs = 3;
+
+  {
+    tsi_ssl_pem_key_cert_pair* tsi_pairs =
+        grpc_convert_grpc_to_tsi_cert_pairs(grpc_pairs, 0);
+    GPR_ASSERT(tsi_pairs == nullptr);
+  }
+
+  {
+    tsi_ssl_pem_key_cert_pair* tsi_pairs =
+        grpc_convert_grpc_to_tsi_cert_pairs(grpc_pairs, num_pairs);
+
+    GPR_ASSERT(tsi_pairs != nullptr);
+    for (size_t i = 0; i < num_pairs; i++) {
+      GPR_ASSERT(strncmp(grpc_pairs[i].private_key, tsi_pairs[i].private_key,
+                         strlen(grpc_pairs[i].private_key)) == 0);
+      GPR_ASSERT(strncmp(grpc_pairs[i].cert_chain, tsi_pairs[i].cert_chain,
+                         strlen(grpc_pairs[i].cert_chain)) == 0);
+    }
+
+    grpc_tsi_ssl_pem_key_cert_pairs_destroy(tsi_pairs, num_pairs);
+  }
+}
+
+int main(int argc, char** argv) {
+  grpc_test_init(argc, argv);
+  grpc_init();
+
+  test_convert_grpc_to_tsi_cert_pairs();
+
+  grpc_shutdown();
+  return 0;
+}
diff --git a/test/core/security/ssl_server_fuzzer.c b/test/core/security/ssl_server_fuzzer.cc
index f9b754b8f2..bbb2f6013e 100644
--- a/test/core/security/ssl_server_fuzzer.c
+++ b/test/core/security/ssl_server_fuzzer.cc
@@ -34,38 +34,39 @@ bool leak_check = false;
 
 static void discard_write(grpc_slice slice) {}
 
-static void dont_log(gpr_log_func_args *args) {}
+static void dont_log(gpr_log_func_args* args) {}
 
 struct handshake_state {
   bool done_callback_called;
 };
 
-static void on_handshake_done(grpc_exec_ctx *exec_ctx, void *arg,
-                              grpc_error *error) {
-  grpc_handshaker_args *args = arg;
-  struct handshake_state *state = args->user_data;
+static void on_handshake_done(grpc_exec_ctx* exec_ctx, void* arg,
+                              grpc_error* error) {
+  grpc_handshaker_args* args = static_cast<grpc_handshaker_args*>(arg);
+  struct handshake_state* state =
+      static_cast<struct handshake_state*>(args->user_data);
   GPR_ASSERT(state->done_callback_called == false);
   state->done_callback_called = true;
   // The fuzzer should not pass the handshake.
   GPR_ASSERT(error != GRPC_ERROR_NONE);
 }
 
-int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   struct grpc_memory_counters counters;
   if (squelch) gpr_set_log_function(dont_log);
   if (leak_check) grpc_memory_counters_init();
   grpc_init();
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
-  grpc_resource_quota *resource_quota =
+  grpc_resource_quota* resource_quota =
       grpc_resource_quota_create("ssl_server_fuzzer");
-  grpc_endpoint *mock_endpoint =
+  grpc_endpoint* mock_endpoint =
       grpc_mock_endpoint_create(discard_write, resource_quota);
   grpc_resource_quota_unref_internal(&exec_ctx, resource_quota);
 
   grpc_mock_endpoint_put_read(
       &exec_ctx, mock_endpoint,
-      grpc_slice_from_copied_buffer((const char *)data, size));
+      grpc_slice_from_copied_buffer((const char*)data, size));
 
   // Load key pair and establish server SSL credentials.
   grpc_ssl_pem_key_cert_pair pem_key_cert_pair;
@@ -73,14 +74,14 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   ca_slice = grpc_slice_from_static_string(test_root_cert);
   cert_slice = grpc_slice_from_static_string(test_server1_cert);
   key_slice = grpc_slice_from_static_string(test_server1_key);
-  const char *ca_cert = (const char *)GRPC_SLICE_START_PTR(ca_slice);
-  pem_key_cert_pair.private_key = (const char *)GRPC_SLICE_START_PTR(key_slice);
-  pem_key_cert_pair.cert_chain = (const char *)GRPC_SLICE_START_PTR(cert_slice);
-  grpc_server_credentials *creds = grpc_ssl_server_credentials_create(
-      ca_cert, &pem_key_cert_pair, 1, 0, NULL);
+  const char* ca_cert = (const char*)GRPC_SLICE_START_PTR(ca_slice);
+  pem_key_cert_pair.private_key = (const char*)GRPC_SLICE_START_PTR(key_slice);
+  pem_key_cert_pair.cert_chain = (const char*)GRPC_SLICE_START_PTR(cert_slice);
+  grpc_server_credentials* creds = grpc_ssl_server_credentials_create(
+      ca_cert, &pem_key_cert_pair, 1, 0, nullptr);
 
   // Create security connector
-  grpc_server_security_connector *sc = NULL;
+  grpc_server_security_connector* sc = nullptr;
   grpc_security_status status =
       grpc_server_credentials_create_security_connector(&exec_ctx, creds, &sc);
   GPR_ASSERT(status == GRPC_SECURITY_OK);
@@ -88,11 +89,11 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
 
   struct handshake_state state;
   state.done_callback_called = false;
-  grpc_handshake_manager *handshake_mgr = grpc_handshake_manager_create();
+  grpc_handshake_manager* handshake_mgr = grpc_handshake_manager_create();
   grpc_server_security_connector_add_handshakers(&exec_ctx, sc, handshake_mgr);
   grpc_handshake_manager_do_handshake(
-      &exec_ctx, handshake_mgr, mock_endpoint, NULL /* channel_args */,
-      deadline, NULL /* acceptor */, on_handshake_done, &state);
+      &exec_ctx, handshake_mgr, mock_endpoint, nullptr /* channel_args */,
+      deadline, nullptr /* acceptor */, on_handshake_done, &state);
   grpc_exec_ctx_flush(&exec_ctx);
 
   // If the given string happens to be part of the correct client hello, the
diff --git a/test/core/security/verify_jwt.c b/test/core/security/verify_jwt.cc
index cec6fb94b4..787d58bc37 100644
--- a/test/core/security/verify_jwt.c
+++ b/test/core/security/verify_jwt.cc
@@ -30,36 +30,36 @@
 #include "src/core/lib/security/credentials/jwt/jwt_verifier.h"
 
 typedef struct {
-  grpc_pollset *pollset;
-  gpr_mu *mu;
+  grpc_pollset* pollset;
+  gpr_mu* mu;
   int is_done;
   int success;
 } synchronizer;
 
-static void print_usage_and_exit(gpr_cmdline *cl, const char *argv0) {
-  char *usage = gpr_cmdline_usage_string(cl, argv0);
+static void print_usage_and_exit(gpr_cmdline* cl, const char* argv0) {
+  char* usage = gpr_cmdline_usage_string(cl, argv0);
   fprintf(stderr, "%s", usage);
   gpr_free(usage);
   gpr_cmdline_destroy(cl);
   exit(1);
 }
 
-static void on_jwt_verification_done(grpc_exec_ctx *exec_ctx, void *user_data,
+static void on_jwt_verification_done(grpc_exec_ctx* exec_ctx, void* user_data,
                                      grpc_jwt_verifier_status status,
-                                     grpc_jwt_claims *claims) {
-  synchronizer *sync = user_data;
+                                     grpc_jwt_claims* claims) {
+  synchronizer* sync = static_cast<synchronizer*>(user_data);
 
   sync->success = (status == GRPC_JWT_VERIFIER_OK);
   if (sync->success) {
-    char *claims_str;
-    GPR_ASSERT(claims != NULL);
+    char* claims_str;
+    GPR_ASSERT(claims != nullptr);
     claims_str =
-        grpc_json_dump_to_string((grpc_json *)grpc_jwt_claims_json(claims), 2);
+        grpc_json_dump_to_string((grpc_json*)grpc_jwt_claims_json(claims), 2);
     printf("Claims: \n\n%s\n", claims_str);
     gpr_free(claims_str);
     grpc_jwt_claims_destroy(exec_ctx, claims);
   } else {
-    GPR_ASSERT(claims == NULL);
+    GPR_ASSERT(claims == nullptr);
     fprintf(stderr, "Verification failed with error %s\n",
             grpc_jwt_verifier_status_to_string(status));
   }
@@ -67,16 +67,16 @@ static void on_jwt_verification_done(grpc_exec_ctx *exec_ctx, void *user_data,
   gpr_mu_lock(sync->mu);
   sync->is_done = 1;
   GRPC_LOG_IF_ERROR("pollset_kick",
-                    grpc_pollset_kick(exec_ctx, sync->pollset, NULL));
+                    grpc_pollset_kick(exec_ctx, sync->pollset, nullptr));
   gpr_mu_unlock(sync->mu);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   synchronizer sync;
-  grpc_jwt_verifier *verifier;
-  gpr_cmdline *cl;
-  char *jwt = NULL;
-  char *aud = NULL;
+  grpc_jwt_verifier* verifier;
+  gpr_cmdline* cl;
+  const char* jwt = nullptr;
+  const char* aud = nullptr;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
   grpc_init();
@@ -84,15 +84,15 @@ int main(int argc, char **argv) {
   gpr_cmdline_add_string(cl, "jwt", "JSON web token to verify", &jwt);
   gpr_cmdline_add_string(cl, "aud", "Audience for the JWT", &aud);
   gpr_cmdline_parse(cl, argc, argv);
-  if (jwt == NULL || aud == NULL) {
+  if (jwt == nullptr || aud == nullptr) {
     print_usage_and_exit(cl, argv[0]);
   }
 
-  verifier = grpc_jwt_verifier_create(NULL, 0);
+  verifier = grpc_jwt_verifier_create(nullptr, 0);
 
   grpc_init();
 
-  sync.pollset = gpr_zalloc(grpc_pollset_size());
+  sync.pollset = static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
   grpc_pollset_init(sync.pollset, &sync.mu);
   sync.is_done = 0;
 
@@ -101,7 +101,7 @@ int main(int argc, char **argv) {
 
   gpr_mu_lock(sync.mu);
   while (!sync.is_done) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     if (!GRPC_LOG_IF_ERROR("pollset_work",
                            grpc_pollset_work(&exec_ctx, sync.pollset, &worker,
                                              GRPC_MILLIS_INF_FUTURE)))
diff --git a/test/core/slice/BUILD b/test/core/slice/BUILD
index ad2308a4d6..ba2b553e0b 100644
--- a/test/core/slice/BUILD
+++ b/test/core/slice/BUILD
@@ -22,8 +22,8 @@ load("//test/core/util:grpc_fuzzer.bzl", "grpc_fuzzer")
 
 grpc_fuzzer(
     name = "percent_encode_fuzzer",
-    srcs = ["percent_encode_fuzzer.c"],
-    language = "C",
+    srcs = ["percent_encode_fuzzer.cc"],
+    language = "C++",
     corpus = "percent_encode_corpus",
     deps = [
         "//:gpr",
@@ -34,8 +34,8 @@ grpc_fuzzer(
 
 grpc_fuzzer(
     name = "percent_decode_fuzzer",
-    srcs = ["percent_decode_fuzzer.c"],
-    language = "C",
+    srcs = ["percent_decode_fuzzer.cc"],
+    language = "C++",
     corpus = "percent_decode_corpus",
     deps = [
         "//:gpr",
@@ -46,8 +46,8 @@ grpc_fuzzer(
 
 grpc_cc_test(
     name = "percent_encoding_test",
-    srcs = ["percent_encoding_test.c"],
-    language = "C",
+    srcs = ["percent_encoding_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -58,15 +58,15 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "slice_test",
-    srcs = ["slice_test.c"],
+    srcs = ["slice_test.cc"],
     deps = ["//:grpc", "//test/core/util:grpc_test_util", "//:gpr", "//test/core/util:gpr_test_util"],
-    language = "C",
+    language = "C++",
 )
 
 grpc_cc_test(
     name = "slice_string_helpers_test",
-    srcs = ["slice_string_helpers_test.c"],
-    language = "C",
+    srcs = ["slice_string_helpers_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -77,22 +77,22 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "slice_buffer_test",
-    srcs = ["slice_buffer_test.c"],
+    srcs = ["slice_buffer_test.cc"],
     deps = ["//:grpc", "//test/core/util:grpc_test_util", "//:gpr", "//test/core/util:gpr_test_util"],
-    language = "C",
+    language = "C++",
 )
 
 grpc_cc_test(
     name = "slice_hash_table_test",
-    srcs = ["slice_hash_table_test.c"],
+    srcs = ["slice_hash_table_test.cc"],
     deps = ["//:grpc", "//test/core/util:grpc_test_util", "//:gpr", "//test/core/util:gpr_test_util"],
-    language = "C",
+    language = "C++",
 )
 
 grpc_cc_test(
     name = "b64_test",
-    srcs = ["b64_test.c"],
-    language = "C",
+    srcs = ["b64_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
diff --git a/test/core/slice/b64_test.c b/test/core/slice/b64_test.cc
index bd375aa6a7..479198f9f9 100644
--- a/test/core/slice/b64_test.c
+++ b/test/core/slice/b64_test.cc
@@ -27,8 +27,8 @@
 #include "src/core/lib/slice/slice_internal.h"
 #include "test/core/util/test_config.h"
 
-static int buffers_are_equal(const unsigned char *buf1,
-                             const unsigned char *buf2, size_t size) {
+static int buffers_are_equal(const unsigned char* buf1,
+                             const unsigned char* buf2, size_t size) {
   size_t i;
   for (i = 0; i < size; i++) {
     if (buf1[i] != buf2[i]) {
@@ -41,13 +41,13 @@ static int buffers_are_equal(const unsigned char *buf1,
 }
 
 static void test_simple_encode_decode_b64(int url_safe, int multiline) {
-  const char *hello = "hello";
-  char *hello_b64 =
+  const char* hello = "hello";
+  char* hello_b64 =
       grpc_base64_encode(hello, strlen(hello), url_safe, multiline);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_slice hello_slice = grpc_base64_decode(&exec_ctx, hello_b64, url_safe);
   GPR_ASSERT(GRPC_SLICE_LENGTH(hello_slice) == strlen(hello));
-  GPR_ASSERT(strncmp((const char *)GRPC_SLICE_START_PTR(hello_slice), hello,
+  GPR_ASSERT(strncmp((const char*)GRPC_SLICE_START_PTR(hello_slice), hello,
                      GRPC_SLICE_LENGTH(hello_slice)) == 0);
 
   grpc_slice_unref_internal(&exec_ctx, hello_slice);
@@ -58,7 +58,7 @@ static void test_simple_encode_decode_b64(int url_safe, int multiline) {
 static void test_full_range_encode_decode_b64(int url_safe, int multiline) {
   unsigned char orig[256];
   size_t i;
-  char *b64;
+  char* b64;
   grpc_slice orig_decoded;
   for (i = 0; i < sizeof(orig); i++) orig[i] = (uint8_t)i;
 
@@ -111,7 +111,7 @@ static void test_full_range_encode_decode_b64_urlsafe_multiline(void) {
 static void test_url_safe_unsafe_mismatch_failure(void) {
   unsigned char orig[256];
   size_t i;
-  char *b64;
+  char* b64;
   grpc_slice orig_decoded;
   int url_safe = 1;
   for (i = 0; i < sizeof(orig); i++) orig[i] = (uint8_t)i;
@@ -132,7 +132,7 @@ static void test_url_safe_unsafe_mismatch_failure(void) {
 }
 
 static void test_rfc4648_test_vectors(void) {
-  char *b64;
+  char* b64;
 
   b64 = grpc_base64_encode("", 0, 0, 0);
   GPR_ASSERT(strcmp("", b64) == 0);
@@ -202,7 +202,7 @@ static void test_unpadded_decode(void) {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_simple_encode_decode_b64_no_multiline();
   test_simple_encode_decode_b64_multiline();
diff --git a/test/core/slice/percent_decode_fuzzer.c b/test/core/slice/percent_decode_fuzzer.cc
index ad4e3fed7a..3603177c47 100644
--- a/test/core/slice/percent_decode_fuzzer.c
+++ b/test/core/slice/percent_decode_fuzzer.cc
@@ -29,10 +29,10 @@
 bool squelch = true;
 bool leak_check = true;
 
-int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   struct grpc_memory_counters counters;
   grpc_memory_counters_init();
-  grpc_slice input = grpc_slice_from_copied_buffer((const char *)data, size);
+  grpc_slice input = grpc_slice_from_copied_buffer((const char*)data, size);
   grpc_slice output;
   if (grpc_strict_percent_decode_slice(
           input, grpc_url_percent_encoding_unreserved_bytes, &output)) {
diff --git a/test/core/slice/percent_encode_fuzzer.c b/test/core/slice/percent_encode_fuzzer.cc
index db3dc3bb3f..c8e3849fc8 100644
--- a/test/core/slice/percent_encode_fuzzer.c
+++ b/test/core/slice/percent_encode_fuzzer.cc
@@ -29,10 +29,10 @@
 bool squelch = true;
 bool leak_check = true;
 
-static void test(const uint8_t *data, size_t size, const uint8_t *dict) {
+static void test(const uint8_t* data, size_t size, const uint8_t* dict) {
   struct grpc_memory_counters counters;
   grpc_memory_counters_init();
-  grpc_slice input = grpc_slice_from_copied_buffer((const char *)data, size);
+  grpc_slice input = grpc_slice_from_copied_buffer((const char*)data, size);
   grpc_slice output = grpc_percent_encode_slice(input, dict);
   grpc_slice decoded_output;
   // encoder must always produce decodable output
@@ -51,7 +51,7 @@ static void test(const uint8_t *data, size_t size, const uint8_t *dict) {
   GPR_ASSERT(counters.total_size_relative == 0);
 }
 
-int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   test(data, size, grpc_url_percent_encoding_unreserved_bytes);
   test(data, size, grpc_compatible_percent_encoding_unreserved_bytes);
   return 0;
diff --git a/test/core/slice/percent_encoding_test.c b/test/core/slice/percent_encoding_test.cc
index fcc8d33db3..253240faad 100644
--- a/test/core/slice/percent_encoding_test.c
+++ b/test/core/slice/percent_encoding_test.cc
@@ -33,10 +33,10 @@
                             permissive_unencoded,                      \
                             sizeof(permissive_unencoded) - 1, dict)
 
-static void test_vector(const char *raw, size_t raw_length, const char *encoded,
-                        size_t encoded_length, const uint8_t *dict) {
-  char *raw_msg = gpr_dump(raw, raw_length, GPR_DUMP_HEX | GPR_DUMP_ASCII);
-  char *encoded_msg =
+static void test_vector(const char* raw, size_t raw_length, const char* encoded,
+                        size_t encoded_length, const uint8_t* dict) {
+  char* raw_msg = gpr_dump(raw, raw_length, GPR_DUMP_HEX | GPR_DUMP_ASCII);
+  char* encoded_msg =
       gpr_dump(encoded, encoded_length, GPR_DUMP_HEX | GPR_DUMP_ASCII);
   gpr_log(GPR_DEBUG, "Trial:\nraw = %s\nencoded = %s", raw_msg, encoded_msg);
   gpr_free(raw_msg);
@@ -52,11 +52,11 @@ static void test_vector(const char *raw, size_t raw_length, const char *encoded,
   grpc_slice encoded2raw_permissive_slice =
       grpc_permissive_percent_decode_slice(encoded_slice);
 
-  char *raw2encoded_msg =
+  char* raw2encoded_msg =
       grpc_dump_slice(raw2encoded_slice, GPR_DUMP_HEX | GPR_DUMP_ASCII);
-  char *encoded2raw_msg =
+  char* encoded2raw_msg =
       grpc_dump_slice(encoded2raw_slice, GPR_DUMP_HEX | GPR_DUMP_ASCII);
-  char *encoded2raw_permissive_msg = grpc_dump_slice(
+  char* encoded2raw_permissive_msg = grpc_dump_slice(
       encoded2raw_permissive_slice, GPR_DUMP_HEX | GPR_DUMP_ASCII);
   gpr_log(GPR_DEBUG,
           "Result:\nraw2encoded = %s\nencoded2raw = %s\nencoded2raw_permissive "
@@ -77,15 +77,15 @@ static void test_vector(const char *raw, size_t raw_length, const char *encoded,
   grpc_slice_unref(encoded_slice);
 }
 
-static void test_nonconformant_vector(const char *encoded,
+static void test_nonconformant_vector(const char* encoded,
                                       size_t encoded_length,
-                                      const char *permissive_unencoded,
+                                      const char* permissive_unencoded,
                                       size_t permissive_unencoded_length,
-                                      const uint8_t *dict) {
-  char *permissive_unencoded_msg =
+                                      const uint8_t* dict) {
+  char* permissive_unencoded_msg =
       gpr_dump(permissive_unencoded, permissive_unencoded_length,
                GPR_DUMP_HEX | GPR_DUMP_ASCII);
-  char *encoded_msg =
+  char* encoded_msg =
       gpr_dump(encoded, encoded_length, GPR_DUMP_HEX | GPR_DUMP_ASCII);
   gpr_log(GPR_DEBUG, "Trial:\nraw = %s\nencoded = %s", permissive_unencoded_msg,
           encoded_msg);
@@ -102,7 +102,7 @@ static void test_nonconformant_vector(const char *encoded,
   grpc_slice encoded2raw_permissive_slice =
       grpc_permissive_percent_decode_slice(encoded_slice);
 
-  char *encoded2raw_permissive_msg = grpc_dump_slice(
+  char* encoded2raw_permissive_msg = grpc_dump_slice(
       encoded2raw_permissive_slice, GPR_DUMP_HEX | GPR_DUMP_ASCII);
   gpr_log(GPR_DEBUG, "Result:\nencoded2raw_permissive = %s",
           encoded2raw_permissive_msg);
@@ -116,7 +116,7 @@ static void test_nonconformant_vector(const char *encoded,
   grpc_slice_unref(encoded_slice);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   TEST_VECTOR(
       "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.~",
diff --git a/test/core/slice/slice_buffer_test.c b/test/core/slice/slice_buffer_test.cc
index 2fba496bd0..338e8079dc 100644
--- a/test/core/slice/slice_buffer_test.c
+++ b/test/core/slice/slice_buffer_test.cc
@@ -104,7 +104,7 @@ void test_slice_buffer_move_first() {
   GPR_ASSERT(dst.length == dst_len);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
 
   test_slice_buffer_add();
diff --git a/test/core/slice/slice_hash_table_test.c b/test/core/slice/slice_hash_table_test.cc
index f3689aac64..0ee4e8617d 100644
--- a/test/core/slice/slice_hash_table_test.c
+++ b/test/core/slice/slice_hash_table_test.cc
@@ -28,8 +28,8 @@
 #include "test/core/util/test_config.h"
 
 typedef struct {
-  char* key;
-  char* value;
+  const char* key;
+  const char* value;
 } test_entry;
 
 static void populate_entries(const test_entry* input, size_t num_entries,
@@ -44,8 +44,9 @@ static void check_values(const test_entry* input, size_t num_entries,
                          grpc_slice_hash_table* table) {
   for (size_t i = 0; i < num_entries; ++i) {
     grpc_slice key = grpc_slice_from_static_string(input[i].key);
-    char* actual = grpc_slice_hash_table_get(table, key);
-    GPR_ASSERT(actual != NULL);
+    const char* actual =
+        static_cast<const char*>(grpc_slice_hash_table_get(table, key));
+    GPR_ASSERT(actual != nullptr);
     GPR_ASSERT(strcmp(actual, input[i].value) == 0);
     grpc_slice_unref(key);
   }
@@ -54,7 +55,7 @@ static void check_values(const test_entry* input, size_t num_entries,
 static void check_non_existent_value(const char* key_string,
                                      grpc_slice_hash_table* table) {
   grpc_slice key = grpc_slice_from_static_string(key_string);
-  GPR_ASSERT(grpc_slice_hash_table_get(table, key) == NULL);
+  GPR_ASSERT(grpc_slice_hash_table_get(table, key) == nullptr);
   grpc_slice_unref(key);
 }
 
@@ -67,7 +68,8 @@ static grpc_slice_hash_table* create_table_from_entries(
     int (*value_cmp_fn)(void*, void*)) {
   // Construct table.
   grpc_slice_hash_table_entry* entries =
-      gpr_zalloc(sizeof(*entries) * num_test_entries);
+      static_cast<grpc_slice_hash_table_entry*>(
+          gpr_zalloc(sizeof(*entries) * num_test_entries));
   populate_entries(test_entries, num_test_entries, entries);
   grpc_slice_hash_table* table = grpc_slice_hash_table_create(
       num_test_entries, entries, destroy_string, value_cmp_fn);
@@ -114,7 +116,7 @@ static void test_slice_hash_table() {
   };
   const size_t num_entries = GPR_ARRAY_SIZE(test_entries);
   grpc_slice_hash_table* table =
-      create_table_from_entries(test_entries, num_entries, NULL);
+      create_table_from_entries(test_entries, num_entries, nullptr);
   // Check contents of table.
   check_values(test_entries, num_entries, table);
   check_non_existent_value("XX", table);
@@ -125,8 +127,8 @@ static void test_slice_hash_table() {
 }
 
 static int value_cmp_fn(void* a, void* b) {
-  const char* a_str = a;
-  const char* b_str = b;
+  const char* a_str = static_cast<const char*>(a);
+  const char* b_str = static_cast<const char*>(b);
   return strcmp(a_str, b_str);
 }
 
diff --git a/test/core/slice/slice_string_helpers_test.c b/test/core/slice/slice_string_helpers_test.cc
index 504acf8f84..260f8c80d5 100644
--- a/test/core/slice/slice_string_helpers_test.c
+++ b/test/core/slice/slice_string_helpers_test.cc
@@ -34,16 +34,16 @@
 #define LOG_TEST_NAME(x) gpr_log(GPR_INFO, "%s", x)
 
 static void expect_slice_dump(grpc_slice slice, uint32_t flags,
-                              const char *result) {
-  char *got = grpc_dump_slice(slice, flags);
+                              const char* result) {
+  char* got = grpc_dump_slice(slice, flags);
   GPR_ASSERT(0 == strcmp(got, result));
   gpr_free(got);
   grpc_slice_unref(slice);
 }
 
 static void test_dump_slice(void) {
-  static const char *text = "HELLO WORLD!";
-  static const char *long_text =
+  static const char* text = "HELLO WORLD!";
+  static const char* long_text =
       "It was a bright cold day in April, and the clocks were striking "
       "thirteen. Winston Smith, his chin nuzzled into his breast in an effort "
       "to escape the vile wind, slipped quickly through the glass doors of "
@@ -62,12 +62,13 @@ static void test_dump_slice(void) {
 }
 
 static void test_strsplit(void) {
-  grpc_slice_buffer *parts;
+  grpc_slice_buffer* parts;
   grpc_slice str;
 
   LOG_TEST_NAME("test_strsplit");
 
-  parts = gpr_malloc(sizeof(grpc_slice_buffer));
+  parts =
+      static_cast<grpc_slice_buffer*>(gpr_malloc(sizeof(grpc_slice_buffer)));
   grpc_slice_buffer_init(parts);
 
   str = grpc_slice_from_copied_string("one, two, three, four");
@@ -127,7 +128,7 @@ static void test_strsplit(void) {
   gpr_free(parts);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_dump_slice();
   test_strsplit();
diff --git a/test/core/slice/slice_test.c b/test/core/slice/slice_test.cc
index cda37fb8d9..02f6b1ea79 100644
--- a/test/core/slice/slice_test.c
+++ b/test/core/slice/slice_test.cc
@@ -43,17 +43,17 @@ static void test_slice_malloc_returns_something_sensible(void) {
     slice = grpc_slice_malloc(length);
     /* If there is a length, slice.data must be non-NULL. If length is zero
        we don't care. */
-    if (length) {
-      GPR_ASSERT(GRPC_SLICE_START_PTR(slice));
+    if (length > GRPC_SLICE_INLINED_SIZE) {
+      GPR_ASSERT(slice.data.refcounted.bytes);
     }
     /* Returned slice length must be what was requested. */
     GPR_ASSERT(GRPC_SLICE_LENGTH(slice) == length);
     /* If the slice has a refcount, it must be destroyable. */
     if (slice.refcount) {
-      GPR_ASSERT(slice.refcount->vtable != NULL);
-      GPR_ASSERT(slice.refcount->vtable->ref != NULL);
-      GPR_ASSERT(slice.refcount->vtable->unref != NULL);
-      GPR_ASSERT(slice.refcount->vtable->hash != NULL);
+      GPR_ASSERT(slice.refcount->vtable != nullptr);
+      GPR_ASSERT(slice.refcount->vtable->ref != nullptr);
+      GPR_ASSERT(slice.refcount->vtable->unref != nullptr);
+      GPR_ASSERT(slice.refcount->vtable->hash != nullptr);
     }
     /* We must be able to write to every byte of the data */
     for (i = 0; i < length; i++) {
@@ -64,7 +64,7 @@ static void test_slice_malloc_returns_something_sensible(void) {
   }
 }
 
-static void do_nothing(void *ignored) {}
+static void do_nothing(void* ignored) {}
 
 static void test_slice_new_returns_something_sensible(void) {
   uint8_t x;
@@ -77,7 +77,7 @@ static void test_slice_new_returns_something_sensible(void) {
 }
 
 /* destroy function that sets a mark to indicate it was called. */
-static void set_mark(void *p) { *((int *)p) = 1; }
+static void set_mark(void* p) { *((int*)p) = 1; }
 
 static void test_slice_new_with_user_data(void) {
   int marker = 0;
@@ -99,7 +99,7 @@ static void test_slice_new_with_user_data(void) {
 
 static int do_nothing_with_len_1_calls = 0;
 
-static void do_nothing_with_len_1(void *ignored, size_t len) {
+static void do_nothing_with_len_1(void* ignored, size_t len) {
   GPR_ASSERT(len == 1);
   do_nothing_with_len_1_calls++;
 }
@@ -228,7 +228,7 @@ static void test_slice_split_tail_works(size_t length) {
 }
 
 static void test_slice_from_copied_string_works(void) {
-  static const char *text = "HELLO WORLD!";
+  static const char* text = "HELLO WORLD!";
   grpc_slice slice;
 
   LOG_TEST_NAME("test_slice_from_copied_string_works");
@@ -289,7 +289,7 @@ static void test_static_slice_copy_interning(void) {
   grpc_shutdown();
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   unsigned length;
   grpc_test_init(argc, argv);
   test_slice_malloc_returns_something_sensible();
diff --git a/test/core/statistics/census_log_tests.c b/test/core/statistics/census_log_tests.c
deleted file mode 100644
index 229a5e55f9..0000000000
--- a/test/core/statistics/census_log_tests.c
+++ /dev/null
@@ -1,576 +0,0 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include "src/core/ext/census/census_log.h"
-#include <grpc/support/cpu.h>
-#include <grpc/support/log.h>
-#include <grpc/support/port_platform.h>
-#include <grpc/support/sync.h>
-#include <grpc/support/thd.h>
-#include <grpc/support/time.h>
-#include <grpc/support/useful.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "test/core/util/test_config.h"
-
-/* Fills in 'record' of size 'size'. Each byte in record is filled in with the
-   same value. The value is extracted from 'record' pointer. */
-static void write_record(char *record, size_t size) {
-  char data = (uintptr_t)record % 255;
-  memset(record, data, size);
-}
-
-/* Reads fixed size records. Returns the number of records read in
-   'num_records'. */
-static void read_records(size_t record_size, const char *buffer,
-                         size_t buffer_size, int32_t *num_records) {
-  int32_t ix;
-  GPR_ASSERT(buffer_size >= record_size);
-  GPR_ASSERT(buffer_size % record_size == 0);
-  *num_records = buffer_size / record_size;
-  for (ix = 0; ix < *num_records; ++ix) {
-    size_t jx;
-    const char *record = buffer + (record_size * ix);
-    char data = (uintptr_t)record % 255;
-    for (jx = 0; jx < record_size; ++jx) {
-      GPR_ASSERT(data == record[jx]);
-    }
-  }
-}
-
-/* Tries to write the specified number of records. Stops when the log gets
-   full. Returns the number of records written. Spins for random
-   number of times, up to 'max_spin_count', between writes. */
-static size_t write_records_to_log(int writer_id, int32_t record_size,
-                                   int32_t num_records,
-                                   int32_t max_spin_count) {
-  int32_t ix;
-  int counter = 0;
-  for (ix = 0; ix < num_records; ++ix) {
-    int32_t jx;
-    int32_t spin_count = max_spin_count ? rand() % max_spin_count : 0;
-    char *record;
-    if (counter++ == num_records / 10) {
-      printf("   Writer %d: %d out of %d written\n", writer_id, ix,
-             num_records);
-      counter = 0;
-    }
-    record = (char *)(census_log_start_write(record_size));
-    if (record == NULL) {
-      return ix;
-    }
-    write_record(record, record_size);
-    census_log_end_write(record, record_size);
-    for (jx = 0; jx < spin_count; ++jx) {
-      GPR_ASSERT(jx >= 0);
-    }
-  }
-  return num_records;
-}
-
-/* Performs a single read iteration. Returns the number of records read. */
-static size_t perform_read_iteration(size_t record_size) {
-  const void *read_buffer = NULL;
-  size_t bytes_available;
-  size_t records_read = 0;
-  census_log_init_reader();
-  while ((read_buffer = census_log_read_next(&bytes_available))) {
-    int32_t num_records = 0;
-    read_records(record_size, (const char *)read_buffer, bytes_available,
-                 &num_records);
-    records_read += num_records;
-  }
-  return records_read;
-}
-
-/* Asserts that the log is empty. */
-static void assert_log_empty(void) {
-  size_t bytes_available;
-  census_log_init_reader();
-  GPR_ASSERT(census_log_read_next(&bytes_available) == NULL);
-}
-
-/* Given log size and record size, computes the minimum usable space. */
-static int32_t min_usable_space(size_t log_size, size_t record_size) {
-  int32_t usable_space;
-  int32_t num_blocks =
-      GPR_MAX(log_size / CENSUS_LOG_MAX_RECORD_SIZE, gpr_cpu_num_cores());
-  int32_t waste_per_block = CENSUS_LOG_MAX_RECORD_SIZE % record_size;
-  /* In the worst case, all except one core-local block is full. */
-  int32_t num_full_blocks = num_blocks - 1;
-  usable_space = (int32_t)log_size -
-                 (num_full_blocks * CENSUS_LOG_MAX_RECORD_SIZE) -
-                 ((num_blocks - num_full_blocks) * waste_per_block);
-  GPR_ASSERT(usable_space > 0);
-  return usable_space;
-}
-
-/* Fills the log and verifies data. If 'no fragmentation' is true, records
-   are sized such that CENSUS_LOG_2_MAX_RECORD_SIZE is a multiple of record
-   size. If not a circular log, verifies that the number of records written
-   match the number of records read. */
-static void fill_log(size_t log_size, int no_fragmentation, int circular_log) {
-  int size;
-  int32_t records_written;
-  int32_t usable_space;
-  int32_t records_read;
-  if (no_fragmentation) {
-    int log2size = rand() % (CENSUS_LOG_2_MAX_RECORD_SIZE + 1);
-    size = (1 << log2size);
-  } else {
-    while (1) {
-      size = 1 + (rand() % CENSUS_LOG_MAX_RECORD_SIZE);
-      if (CENSUS_LOG_MAX_RECORD_SIZE % size) {
-        break;
-      }
-    }
-  }
-  printf("   Fill record size: %d\n", size);
-  records_written = write_records_to_log(
-      0 /* writer id */, size, (log_size / size) * 2, 0 /* spin count */);
-  usable_space = min_usable_space(log_size, size);
-  GPR_ASSERT(records_written * size >= usable_space);
-  records_read = perform_read_iteration(size);
-  if (!circular_log) {
-    GPR_ASSERT(records_written == records_read);
-  }
-  assert_log_empty();
-}
-
-/* Structure to pass args to writer_thread */
-typedef struct writer_thread_args {
-  /* Index of this thread in the writers vector. */
-  int index;
-  /* Record size. */
-  size_t record_size;
-  /* Number of records to write. */
-  int32_t num_records;
-  /* Used to signal when writer is complete */
-  gpr_cv *done;
-  gpr_mu *mu;
-  int *count;
-} writer_thread_args;
-
-/* Writes the given number of records of random size (up to kMaxRecordSize) and
-   random data to the specified log. */
-static void writer_thread(void *arg) {
-  writer_thread_args *args = (writer_thread_args *)arg;
-  /* Maximum number of times to spin between writes. */
-  static const int32_t MAX_SPIN_COUNT = 50;
-  int records_written = 0;
-  printf("   Writer: %d\n", args->index);
-  while (records_written < args->num_records) {
-    records_written += write_records_to_log(args->index, args->record_size,
-                                            args->num_records - records_written,
-                                            MAX_SPIN_COUNT);
-    if (records_written < args->num_records) {
-      /* Ran out of log space. Sleep for a bit and let the reader catch up.
-         This should never happen for circular logs. */
-      printf("   Writer stalled due to out-of-space: %d out of %d written\n",
-             records_written, args->num_records);
-      gpr_sleep_until(grpc_timeout_milliseconds_to_deadline(10));
-    }
-  }
-  /* Done. Decrement count and signal. */
-  gpr_mu_lock(args->mu);
-  (*args->count)--;
-  gpr_cv_broadcast(args->done);
-  printf("   Writer done: %d\n", args->index);
-  gpr_mu_unlock(args->mu);
-}
-
-/* struct to pass args to reader_thread */
-typedef struct reader_thread_args {
-  /* Record size. */
-  size_t record_size;
-  /* Interval between read iterations. */
-  int32_t read_iteration_interval_in_msec;
-  /* Total number of records. */
-  int32_t total_records;
-  /* Signalled when reader should stop. */
-  gpr_cv stop;
-  int stop_flag;
-  /* Used to signal when reader has finished */
-  gpr_cv *done;
-  gpr_mu *mu;
-  int running;
-} reader_thread_args;
-
-/* Reads and verifies the specified number of records. Reader can also be
-   stopped via gpr_cv_signal(&args->stop). Sleeps for 'read_interval_in_msec'
-   between read iterations. */
-static void reader_thread(void *arg) {
-  int32_t records_read = 0;
-  reader_thread_args *args = (reader_thread_args *)arg;
-  int32_t num_iterations = 0;
-  gpr_timespec interval;
-  int counter = 0;
-  printf("   Reader starting\n");
-  interval = gpr_time_from_micros(
-      (int64_t)args->read_iteration_interval_in_msec * 1000, GPR_TIMESPAN);
-  gpr_mu_lock(args->mu);
-  while (!args->stop_flag && records_read < args->total_records) {
-    gpr_cv_wait(&args->stop, args->mu, interval);
-    if (!args->stop_flag) {
-      records_read += perform_read_iteration(args->record_size);
-      GPR_ASSERT(records_read <= args->total_records);
-      if (counter++ == 100000) {
-        printf("   Reader: %d out of %d read\n", records_read,
-               args->total_records);
-        counter = 0;
-      }
-      ++num_iterations;
-    }
-  }
-  /* Done */
-  args->running = 0;
-  gpr_cv_broadcast(args->done);
-  printf("   Reader: records: %d, iterations: %d\n", records_read,
-         num_iterations);
-  gpr_mu_unlock(args->mu);
-}
-
-/* Creates NUM_WRITERS writers where each writer writes NUM_RECORDS_PER_WRITER
-   records. Also, starts a reader that iterates over and reads blocks every
-   READ_ITERATION_INTERVAL_IN_MSEC. */
-/* Number of writers. */
-#define NUM_WRITERS 5
-static void multiple_writers_single_reader(int circular_log) {
-  /* Sleep interval between read iterations. */
-  static const int32_t READ_ITERATION_INTERVAL_IN_MSEC = 10;
-  /* Number of records written by each writer. */
-  static const int32_t NUM_RECORDS_PER_WRITER = 10 * 1024 * 1024;
-  /* Maximum record size. */
-  static const size_t MAX_RECORD_SIZE = 10;
-  int ix;
-  gpr_thd_id id;
-  gpr_cv writers_done;
-  int writers_count = NUM_WRITERS;
-  gpr_mu writers_mu; /* protects writers_done and writers_count */
-  writer_thread_args writers[NUM_WRITERS];
-  gpr_cv reader_done;
-  gpr_mu reader_mu; /* protects reader_done and reader.running */
-  reader_thread_args reader;
-  int32_t record_size = 1 + rand() % MAX_RECORD_SIZE;
-  printf("   Record size: %d\n", record_size);
-  /* Create and start writers. */
-  gpr_cv_init(&writers_done);
-  gpr_mu_init(&writers_mu);
-  for (ix = 0; ix < NUM_WRITERS; ++ix) {
-    writers[ix].index = ix;
-    writers[ix].record_size = record_size;
-    writers[ix].num_records = NUM_RECORDS_PER_WRITER;
-    writers[ix].done = &writers_done;
-    writers[ix].count = &writers_count;
-    writers[ix].mu = &writers_mu;
-    gpr_thd_new(&id, &writer_thread, &writers[ix], NULL);
-  }
-  /* Start reader. */
-  reader.record_size = record_size;
-  reader.read_iteration_interval_in_msec = READ_ITERATION_INTERVAL_IN_MSEC;
-  reader.total_records = NUM_WRITERS * NUM_RECORDS_PER_WRITER;
-  reader.stop_flag = 0;
-  gpr_cv_init(&reader.stop);
-  gpr_cv_init(&reader_done);
-  reader.done = &reader_done;
-  gpr_mu_init(&reader_mu);
-  reader.mu = &reader_mu;
-  reader.running = 1;
-  gpr_thd_new(&id, &reader_thread, &reader, NULL);
-  /* Wait for writers to finish. */
-  gpr_mu_lock(&writers_mu);
-  while (writers_count != 0) {
-    gpr_cv_wait(&writers_done, &writers_mu, gpr_inf_future(GPR_CLOCK_REALTIME));
-  }
-  gpr_mu_unlock(&writers_mu);
-  gpr_mu_destroy(&writers_mu);
-  gpr_cv_destroy(&writers_done);
-  gpr_mu_lock(&reader_mu);
-  if (circular_log) {
-    /* Stop reader. */
-    reader.stop_flag = 1;
-    gpr_cv_signal(&reader.stop);
-  }
-  /* wait for reader to finish */
-  while (reader.running) {
-    gpr_cv_wait(&reader_done, &reader_mu, gpr_inf_future(GPR_CLOCK_REALTIME));
-  }
-  if (circular_log) {
-    /* Assert that there were no out-of-space errors. */
-    GPR_ASSERT(0 == census_log_out_of_space_count());
-  }
-  gpr_mu_unlock(&reader_mu);
-  gpr_mu_destroy(&reader_mu);
-  gpr_cv_destroy(&reader_done);
-  printf("   Reader: finished\n");
-}
-
-/* Log sizes to use for all tests. */
-#define LOG_SIZE_IN_MB 1
-#define LOG_SIZE_IN_BYTES (LOG_SIZE_IN_MB << 20)
-
-static void setup_test(int circular_log) {
-  census_log_initialize(LOG_SIZE_IN_MB, circular_log);
-  GPR_ASSERT(census_log_remaining_space() == LOG_SIZE_IN_BYTES);
-}
-
-/* Attempts to create a record of invalid size (size >
-   CENSUS_LOG_MAX_RECORD_SIZE). */
-void test_invalid_record_size(void) {
-  static const size_t INVALID_SIZE = CENSUS_LOG_MAX_RECORD_SIZE + 1;
-  static const size_t VALID_SIZE = 1;
-  void *record;
-  printf("Starting test: invalid record size\n");
-  setup_test(0);
-  record = census_log_start_write(INVALID_SIZE);
-  GPR_ASSERT(record == NULL);
-  /* Now try writing a valid record. */
-  record = census_log_start_write(VALID_SIZE);
-  GPR_ASSERT(record != NULL);
-  census_log_end_write(record, VALID_SIZE);
-  /* Verifies that available space went down by one block. In theory, this
-     check can fail if the thread is context switched to a new CPU during the
-     start_write execution (multiple blocks get allocated), but this has not
-     been observed in practice. */
-  GPR_ASSERT(LOG_SIZE_IN_BYTES - CENSUS_LOG_MAX_RECORD_SIZE ==
-             census_log_remaining_space());
-  census_log_shutdown();
-}
-
-/* Tests end_write() with a different size than what was specified in
-   start_write(). */
-void test_end_write_with_different_size(void) {
-  static const size_t START_WRITE_SIZE = 10;
-  static const size_t END_WRITE_SIZE = 7;
-  void *record_written;
-  const void *record_read;
-  size_t bytes_available;
-  printf("Starting test: end write with different size\n");
-  setup_test(0);
-  record_written = census_log_start_write(START_WRITE_SIZE);
-  GPR_ASSERT(record_written != NULL);
-  census_log_end_write(record_written, END_WRITE_SIZE);
-  census_log_init_reader();
-  record_read = census_log_read_next(&bytes_available);
-  GPR_ASSERT(record_written == record_read);
-  GPR_ASSERT(END_WRITE_SIZE == bytes_available);
-  assert_log_empty();
-  census_log_shutdown();
-}
-
-/* Verifies that pending records are not available via read_next(). */
-void test_read_pending_record(void) {
-  static const size_t PR_RECORD_SIZE = 1024;
-  size_t bytes_available;
-  const void *record_read;
-  void *record_written;
-  printf("Starting test: read pending record\n");
-  setup_test(0);
-  /* Start a write. */
-  record_written = census_log_start_write(PR_RECORD_SIZE);
-  GPR_ASSERT(record_written != NULL);
-  /* As write is pending, read should fail. */
-  census_log_init_reader();
-  record_read = census_log_read_next(&bytes_available);
-  GPR_ASSERT(record_read == NULL);
-  /* A read followed by end_write() should succeed. */
-  census_log_end_write(record_written, PR_RECORD_SIZE);
-  census_log_init_reader();
-  record_read = census_log_read_next(&bytes_available);
-  GPR_ASSERT(record_written == record_read);
-  GPR_ASSERT(PR_RECORD_SIZE == bytes_available);
-  assert_log_empty();
-  census_log_shutdown();
-}
-
-/* Tries reading beyond pending write. */
-void test_read_beyond_pending_record(void) {
-  /* Start a write. */
-  uint32_t incomplete_record_size = 10;
-  uint32_t complete_record_size = 20;
-  size_t bytes_available;
-  void *complete_record;
-  const void *record_read;
-  void *incomplete_record;
-  printf("Starting test: read beyond pending record\n");
-  setup_test(0);
-  incomplete_record = census_log_start_write(incomplete_record_size);
-  GPR_ASSERT(incomplete_record != NULL);
-  complete_record = census_log_start_write(complete_record_size);
-  GPR_ASSERT(complete_record != NULL);
-  GPR_ASSERT(complete_record != incomplete_record);
-  census_log_end_write(complete_record, complete_record_size);
-  /* Now iterate over blocks to read completed records. */
-  census_log_init_reader();
-  record_read = census_log_read_next(&bytes_available);
-  GPR_ASSERT(complete_record == record_read);
-  GPR_ASSERT(complete_record_size == bytes_available);
-  /* Complete first record. */
-  census_log_end_write(incomplete_record, incomplete_record_size);
-  /* Have read past the incomplete record, so read_next() should return NULL. */
-  /* NB: this test also assumes our thread did not get switched to a different
-     CPU between the two start_write calls */
-  record_read = census_log_read_next(&bytes_available);
-  GPR_ASSERT(record_read == NULL);
-  /* Reset reader to get the newly completed record. */
-  census_log_init_reader();
-  record_read = census_log_read_next(&bytes_available);
-  GPR_ASSERT(incomplete_record == record_read);
-  GPR_ASSERT(incomplete_record_size == bytes_available);
-  assert_log_empty();
-  census_log_shutdown();
-}
-
-/* Tests scenario where block being read is detached from a core and put on the
-   dirty list. */
-void test_detached_while_reading(void) {
-  static const size_t DWR_RECORD_SIZE = 10;
-  size_t bytes_available;
-  const void *record_read;
-  void *record_written;
-  uint32_t block_read = 0;
-  printf("Starting test: detached while reading\n");
-  setup_test(0);
-  /* Start a write. */
-  record_written = census_log_start_write(DWR_RECORD_SIZE);
-  GPR_ASSERT(record_written != NULL);
-  census_log_end_write(record_written, DWR_RECORD_SIZE);
-  /* Read this record. */
-  census_log_init_reader();
-  record_read = census_log_read_next(&bytes_available);
-  GPR_ASSERT(record_read != NULL);
-  GPR_ASSERT(DWR_RECORD_SIZE == bytes_available);
-  /* Now fill the log. This will move the block being read from core-local
-     array to the dirty list. */
-  while ((record_written = census_log_start_write(DWR_RECORD_SIZE))) {
-    census_log_end_write(record_written, DWR_RECORD_SIZE);
-  }
-
-  /* In this iteration, read_next() should only traverse blocks in the
-     core-local array. Therefore, we expect at most gpr_cpu_num_cores() more
-     blocks. As log is full, if read_next() is traversing the dirty list, we
-     will get more than gpr_cpu_num_cores() blocks. */
-  while ((record_read = census_log_read_next(&bytes_available))) {
-    ++block_read;
-    GPR_ASSERT(block_read <= gpr_cpu_num_cores());
-  }
-  census_log_shutdown();
-}
-
-/* Fills non-circular log with records sized such that size is a multiple of
-   CENSUS_LOG_MAX_RECORD_SIZE (no per-block fragmentation). */
-void test_fill_log_no_fragmentation(void) {
-  const int circular = 0;
-  printf("Starting test: fill log no fragmentation\n");
-  setup_test(circular);
-  fill_log(LOG_SIZE_IN_BYTES, 1 /* no fragmentation */, circular);
-  census_log_shutdown();
-}
-
-/* Fills circular log with records sized such that size is a multiple of
-   CENSUS_LOG_MAX_RECORD_SIZE (no per-block fragmentation). */
-void test_fill_circular_log_no_fragmentation(void) {
-  const int circular = 1;
-  printf("Starting test: fill circular log no fragmentation\n");
-  setup_test(circular);
-  fill_log(LOG_SIZE_IN_BYTES, 1 /* no fragmentation */, circular);
-  census_log_shutdown();
-}
-
-/* Fills non-circular log with records that may straddle end of a block. */
-void test_fill_log_with_straddling_records(void) {
-  const int circular = 0;
-  printf("Starting test: fill log with straddling records\n");
-  setup_test(circular);
-  fill_log(LOG_SIZE_IN_BYTES, 0 /* block straddling records */, circular);
-  census_log_shutdown();
-}
-
-/* Fills circular log with records that may straddle end of a block. */
-void test_fill_circular_log_with_straddling_records(void) {
-  const int circular = 1;
-  printf("Starting test: fill circular log with straddling records\n");
-  setup_test(circular);
-  fill_log(LOG_SIZE_IN_BYTES, 0 /* block straddling records */, circular);
-  census_log_shutdown();
-}
-
-/* Tests scenario where multiple writers and a single reader are using a log
-   that is configured to discard old records. */
-void test_multiple_writers_circular_log(void) {
-  const int circular = 1;
-  printf("Starting test: multiple writers circular log\n");
-  setup_test(circular);
-  multiple_writers_single_reader(circular);
-  census_log_shutdown();
-}
-
-/* Tests scenario where multiple writers and a single reader are using a log
-   that is configured to discard old records. */
-void test_multiple_writers(void) {
-  const int circular = 0;
-  printf("Starting test: multiple writers\n");
-  setup_test(circular);
-  multiple_writers_single_reader(circular);
-  census_log_shutdown();
-}
-
-/* Repeat the straddling records and multiple writers tests with a small log. */
-void test_small_log(void) {
-  size_t log_size;
-  const int circular = 0;
-  printf("Starting test: small log\n");
-  census_log_initialize(0, circular);
-  log_size = census_log_remaining_space();
-  GPR_ASSERT(log_size > 0);
-  fill_log(log_size, 0, circular);
-  census_log_shutdown();
-  census_log_initialize(0, circular);
-  multiple_writers_single_reader(circular);
-  census_log_shutdown();
-}
-
-void test_performance(void) {
-  int write_size = 1;
-  for (; write_size < CENSUS_LOG_MAX_RECORD_SIZE; write_size *= 2) {
-    gpr_timespec write_time;
-    gpr_timespec start_time;
-    double write_time_micro = 0.0;
-    int nrecords = 0;
-    setup_test(0);
-    start_time = gpr_now(GPR_CLOCK_REALTIME);
-    while (1) {
-      void *record = census_log_start_write(write_size);
-      if (record == NULL) {
-        break;
-      }
-      census_log_end_write(record, write_size);
-      nrecords++;
-    }
-    write_time = gpr_time_sub(gpr_now(GPR_CLOCK_REALTIME), start_time);
-    write_time_micro = write_time.tv_sec * 1000000 + write_time.tv_nsec / 1000;
-    census_log_shutdown();
-    printf(
-        "Wrote %d %d byte records in %.3g microseconds: %g records/us "
-        "(%g ns/record), %g gigabytes/s\n",
-        nrecords, write_size, write_time_micro, nrecords / write_time_micro,
-        1000 * write_time_micro / nrecords,
-        (write_size * nrecords) / write_time_micro / 1000);
-  }
-}
diff --git a/test/core/statistics/census_stub_test.c b/test/core/statistics/census_stub_test.cc
index f38d571abd..507ae0a9fa 100644
--- a/test/core/statistics/census_stub_test.c
+++ b/test/core/statistics/census_stub_test.cc
@@ -28,7 +28,7 @@
 /* Tests census noop stubs in a simulated rpc flow */
 void test_census_stubs(void) {
   census_op_id op_id;
-  census_rpc_stats *stats = census_rpc_stats_create_empty();
+  census_rpc_stats* stats = census_rpc_stats_create_empty();
   census_aggregated_rpc_stats data_map = {0, NULL};
 
   /* Initializes census library at server start up time. */
@@ -55,7 +55,7 @@ void test_census_stubs(void) {
   census_shutdown();
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_census_stubs();
   return 0;
diff --git a/test/core/statistics/hash_table_test.c b/test/core/statistics/hash_table_test.c
deleted file mode 100644
index d714e15091..0000000000
--- a/test/core/statistics/hash_table_test.c
+++ /dev/null
@@ -1,286 +0,0 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "src/core/ext/census/hash_table.h"
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/time.h>
-#include "src/core/lib/support/murmur_hash.h"
-#include "src/core/lib/support/string.h"
-#include "test/core/util/test_config.h"
-
-static uint64_t hash64(const void *k) {
-  size_t len = strlen(k);
-  uint64_t higher = gpr_murmur_hash3((const char *)k, len / 2, 0);
-  return higher << 32 |
-         gpr_murmur_hash3((const char *)(k) + len / 2, len - len / 2, 0);
-}
-
-static int cmp_str_keys(const void *k1, const void *k2) {
-  return strcmp((const char *)k1, (const char *)k2);
-}
-
-static uint64_t force_collision(const void *k) {
-  return (1997 + hash64(k) % 3);
-}
-
-static void free_data(void *data) { gpr_free(data); }
-
-/* Basic tests that empty hash table can be created and destroyed. */
-static void test_create_table(void) {
-  /* Create table with uint64 key type */
-  census_ht *ht = NULL;
-  census_ht_option ht_options = {
-      CENSUS_HT_UINT64, 1999, NULL, NULL, NULL, NULL};
-  ht = census_ht_create(&ht_options);
-  GPR_ASSERT(ht != NULL);
-  GPR_ASSERT(census_ht_get_size(ht) == 0);
-  census_ht_destroy(ht);
-  /* Create table with pointer key type */
-  ht = NULL;
-  ht_options.key_type = CENSUS_HT_POINTER;
-  ht_options.hash = &hash64;
-  ht_options.compare_keys = &cmp_str_keys;
-  ht = census_ht_create(&ht_options);
-  GPR_ASSERT(ht != NULL);
-  GPR_ASSERT(census_ht_get_size(ht) == 0);
-  census_ht_destroy(ht);
-}
-
-static void test_table_with_int_key(void) {
-  census_ht_option opt = {CENSUS_HT_UINT64, 7, NULL, NULL, NULL, NULL};
-  census_ht *ht = census_ht_create(&opt);
-  uint64_t i = 0;
-  uint64_t sum_of_keys = 0;
-  size_t num_elements;
-  census_ht_kv *elements = NULL;
-  GPR_ASSERT(ht != NULL);
-  GPR_ASSERT(census_ht_get_size(ht) == 0);
-  elements = census_ht_get_all_elements(ht, &num_elements);
-  GPR_ASSERT(num_elements == 0);
-  GPR_ASSERT(elements == NULL);
-  for (i = 0; i < 20; ++i) {
-    census_ht_key key;
-    key.val = i;
-    census_ht_insert(ht, key, (void *)(intptr_t)i);
-    GPR_ASSERT(census_ht_get_size(ht) == i + 1);
-  }
-  for (i = 0; i < 20; i++) {
-    uint64_t *val = NULL;
-    census_ht_key key;
-    key.val = i;
-    val = census_ht_find(ht, key);
-    GPR_ASSERT(val == (void *)(intptr_t)i);
-  }
-  elements = census_ht_get_all_elements(ht, &num_elements);
-  GPR_ASSERT(elements != NULL);
-  GPR_ASSERT(num_elements == 20);
-  for (i = 0; i < num_elements; i++) {
-    sum_of_keys += elements[i].k.val;
-  }
-  GPR_ASSERT(sum_of_keys == 190);
-  gpr_free(elements);
-  census_ht_destroy(ht);
-}
-
-/* Test that there is no memory leak when keys and values are owned by table. */
-static void test_value_and_key_deleter(void) {
-  census_ht_option opt = {CENSUS_HT_POINTER, 7,          &hash64,
-                          &cmp_str_keys,     &free_data, &free_data};
-  census_ht *ht = census_ht_create(&opt);
-  census_ht_key key;
-  char *val = NULL;
-  char *val2 = NULL;
-  key.ptr = gpr_malloc(100);
-  val = gpr_malloc(10);
-  strcpy(val, "value");
-  strcpy(key.ptr, "some string as a key");
-  GPR_ASSERT(ht != NULL);
-  GPR_ASSERT(census_ht_get_size(ht) == 0);
-  census_ht_insert(ht, key, val);
-  GPR_ASSERT(census_ht_get_size(ht) == 1);
-  val = census_ht_find(ht, key);
-  GPR_ASSERT(val != NULL);
-  GPR_ASSERT(strcmp(val, "value") == 0);
-  /* Insert same key different value, old value is overwritten. */
-  val2 = gpr_malloc(10);
-  strcpy(val2, "v2");
-  census_ht_insert(ht, key, val2);
-  GPR_ASSERT(census_ht_get_size(ht) == 1);
-  val2 = census_ht_find(ht, key);
-  GPR_ASSERT(val2 != NULL);
-  GPR_ASSERT(strcmp(val2, "v2") == 0);
-  census_ht_destroy(ht);
-}
-
-/* Test simple insert and erase operations. */
-static void test_simple_add_and_erase(void) {
-  census_ht_option opt = {CENSUS_HT_UINT64, 7, NULL, NULL, NULL, NULL};
-  census_ht *ht = census_ht_create(&opt);
-  GPR_ASSERT(ht != NULL);
-  GPR_ASSERT(census_ht_get_size(ht) == 0);
-  {
-    census_ht_key key;
-    int val = 3;
-    key.val = 2;
-    census_ht_insert(ht, key, (void *)&val);
-    GPR_ASSERT(census_ht_get_size(ht) == 1);
-    census_ht_erase(ht, key);
-    GPR_ASSERT(census_ht_get_size(ht) == 0);
-    /* Erasing a key from an empty table should be noop. */
-    census_ht_erase(ht, key);
-    GPR_ASSERT(census_ht_get_size(ht) == 0);
-    /* Erasing a non-existant key from a table should be noop. */
-    census_ht_insert(ht, key, (void *)&val);
-    key.val = 3;
-    census_ht_insert(ht, key, (void *)&val);
-    key.val = 9;
-    census_ht_insert(ht, key, (void *)&val);
-    GPR_ASSERT(census_ht_get_size(ht) == 3);
-    key.val = 1;
-    census_ht_erase(ht, key);
-    /* size unchanged after deleting non-existant key. */
-    GPR_ASSERT(census_ht_get_size(ht) == 3);
-    /* size decrease by 1 after deleting an existant key. */
-    key.val = 2;
-    census_ht_erase(ht, key);
-    GPR_ASSERT(census_ht_get_size(ht) == 2);
-  }
-  census_ht_destroy(ht);
-}
-
-static void test_insertion_and_deletion_with_high_collision_rate(void) {
-  census_ht_option opt = {CENSUS_HT_POINTER, 13,   &force_collision,
-                          &cmp_str_keys,     NULL, NULL};
-  census_ht *ht = census_ht_create(&opt);
-  char key_str[1000][GPR_LTOA_MIN_BUFSIZE];
-  uint64_t val = 0;
-  unsigned i = 0;
-  for (i = 0; i < 1000; i++) {
-    census_ht_key key;
-    key.ptr = key_str[i];
-    gpr_ltoa(i, key_str[i]);
-    census_ht_insert(ht, key, (void *)(&val));
-    gpr_log(GPR_INFO, "%d\n", i);
-    GPR_ASSERT(census_ht_get_size(ht) == (i + 1));
-  }
-  for (i = 0; i < 1000; i++) {
-    census_ht_key key;
-    key.ptr = key_str[i];
-    census_ht_erase(ht, key);
-    GPR_ASSERT(census_ht_get_size(ht) == (999 - i));
-  }
-  census_ht_destroy(ht);
-}
-
-static void test_table_with_string_key(void) {
-  census_ht_option opt = {CENSUS_HT_POINTER, 7,    &hash64,
-                          &cmp_str_keys,     NULL, NULL};
-  census_ht *ht = census_ht_create(&opt);
-  const char *keys[] = {
-      "k1", "a",   "000", "apple", "banana_a_long_long_long_banana",
-      "%$", "111", "foo", "b"};
-  const int vals[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
-  int i = 0;
-  GPR_ASSERT(ht != NULL);
-  GPR_ASSERT(census_ht_get_size(ht) == 0);
-  for (i = 0; i < 9; i++) {
-    census_ht_key key;
-    key.ptr = (void *)(keys[i]);
-    census_ht_insert(ht, key, (void *)(vals + i));
-  }
-  GPR_ASSERT(census_ht_get_size(ht) == 9);
-  for (i = 0; i < 9; i++) {
-    census_ht_key key;
-    int *val_ptr;
-    key.ptr = (void *)(keys[i]);
-    val_ptr = census_ht_find(ht, key);
-    GPR_ASSERT(*val_ptr == vals[i]);
-  }
-  {
-    /* inserts duplicate keys */
-    census_ht_key key;
-    int *val_ptr = NULL;
-    key.ptr = (void *)(keys[2]);
-    census_ht_insert(ht, key, (void *)(vals + 8));
-    /* expect value to be over written by new insertion */
-    GPR_ASSERT(census_ht_get_size(ht) == 9);
-    val_ptr = census_ht_find(ht, key);
-    GPR_ASSERT(*val_ptr == vals[8]);
-  }
-  for (i = 0; i < 9; i++) {
-    census_ht_key key;
-    int *val_ptr;
-    uint32_t expected_tbl_sz = 9 - i;
-    GPR_ASSERT(census_ht_get_size(ht) == expected_tbl_sz);
-    key.ptr = (void *)(keys[i]);
-    val_ptr = census_ht_find(ht, key);
-    GPR_ASSERT(val_ptr != NULL);
-    census_ht_erase(ht, key);
-    GPR_ASSERT(census_ht_get_size(ht) == expected_tbl_sz - 1);
-    val_ptr = census_ht_find(ht, key);
-    GPR_ASSERT(val_ptr == NULL);
-  }
-  census_ht_destroy(ht);
-}
-
-static void test_insertion_with_same_key(void) {
-  census_ht_option opt = {CENSUS_HT_UINT64, 11, NULL, NULL, NULL, NULL};
-  census_ht *ht = census_ht_create(&opt);
-  census_ht_key key;
-  const char vals[] = {'a', 'b', 'c'};
-  char *val_ptr;
-  key.val = 3;
-  census_ht_insert(ht, key, (void *)&(vals[0]));
-  GPR_ASSERT(census_ht_get_size(ht) == 1);
-  val_ptr = (char *)census_ht_find(ht, key);
-  GPR_ASSERT(val_ptr != NULL);
-  GPR_ASSERT(*val_ptr == 'a');
-  key.val = 4;
-  val_ptr = (char *)census_ht_find(ht, key);
-  GPR_ASSERT(val_ptr == NULL);
-  key.val = 3;
-  census_ht_insert(ht, key, (void *)&(vals[1]));
-  GPR_ASSERT(census_ht_get_size(ht) == 1);
-  val_ptr = (char *)census_ht_find(ht, key);
-  GPR_ASSERT(val_ptr != NULL);
-  GPR_ASSERT(*val_ptr == 'b');
-  census_ht_insert(ht, key, (void *)&(vals[2]));
-  GPR_ASSERT(census_ht_get_size(ht) == 1);
-  val_ptr = (char *)census_ht_find(ht, key);
-  GPR_ASSERT(val_ptr != NULL);
-  GPR_ASSERT(*val_ptr == 'c');
-  census_ht_destroy(ht);
-}
-
-int main(int argc, char **argv) {
-  grpc_test_init(argc, argv);
-  test_create_table();
-  test_simple_add_and_erase();
-  test_table_with_int_key();
-  test_table_with_string_key();
-  test_value_and_key_deleter();
-  test_insertion_with_same_key();
-  test_insertion_and_deletion_with_high_collision_rate();
-  return 0;
-}
diff --git a/test/core/statistics/multiple_writers_circular_buffer_test.c b/test/core/statistics/multiple_writers_circular_buffer_test.cc
index 8abd76c3d1..6d3411289e 100644
--- a/test/core/statistics/multiple_writers_circular_buffer_test.c
+++ b/test/core/statistics/multiple_writers_circular_buffer_test.cc
@@ -23,7 +23,7 @@
 #include <grpc/support/time.h>
 #include "test/core/util/test_config.h"
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   srand(gpr_now(GPR_CLOCK_REALTIME).tv_nsec);
   test_multiple_writers_circular_log();
diff --git a/test/core/statistics/multiple_writers_test.c b/test/core/statistics/multiple_writers_test.cc
index de800e0d8a..47410ab105 100644
--- a/test/core/statistics/multiple_writers_test.c
+++ b/test/core/statistics/multiple_writers_test.cc
@@ -23,7 +23,7 @@
 #include <grpc/support/time.h>
 #include "test/core/util/test_config.h"
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   srand(gpr_now(GPR_CLOCK_REALTIME).tv_nsec);
   test_multiple_writers();
diff --git a/test/core/statistics/performance_test.c b/test/core/statistics/performance_test.cc
index 6104acb612..9d4fd6ef90 100644
--- a/test/core/statistics/performance_test.c
+++ b/test/core/statistics/performance_test.cc
@@ -23,7 +23,7 @@
 #include <grpc/support/time.h>
 #include "test/core/util/test_config.h"
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   srand(gpr_now(GPR_CLOCK_REALTIME).tv_nsec);
   test_performance();
diff --git a/test/core/statistics/quick_test.c b/test/core/statistics/quick_test.cc
index 1e044b6b59..91ecdde818 100644
--- a/test/core/statistics/quick_test.c
+++ b/test/core/statistics/quick_test.cc
@@ -23,7 +23,7 @@
 #include <grpc/support/time.h>
 #include "test/core/util/test_config.h"
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   srand(gpr_now(GPR_CLOCK_REALTIME).tv_nsec);
   test_invalid_record_size();
diff --git a/test/core/statistics/rpc_stats_test.c b/test/core/statistics/rpc_stats_test.cc
index 01ac5a19ab..aead5cfdca 100644
--- a/test/core/statistics/rpc_stats_test.c
+++ b/test/core/statistics/rpc_stats_test.cc
@@ -39,7 +39,7 @@ static void test_init_shutdown(void) {
 }
 
 static void test_create_and_destroy(void) {
-  census_rpc_stats *stats = NULL;
+  census_rpc_stats* stats = NULL;
   census_aggregated_rpc_stats agg_stats = {0, NULL};
 
   stats = census_rpc_stats_create_empty();
@@ -54,7 +54,7 @@ static void test_create_and_destroy(void) {
   GPR_ASSERT(agg_stats.num_entries == 0);
   GPR_ASSERT(agg_stats.stats == NULL);
   agg_stats.num_entries = 1;
-  agg_stats.stats = (census_per_method_rpc_stats *)gpr_malloc(
+  agg_stats.stats = (census_per_method_rpc_stats*)gpr_malloc(
       sizeof(census_per_method_rpc_stats));
   agg_stats.stats[0].method = gpr_strdup("foo");
   census_aggregated_rpc_stats_set_empty(&agg_stats);
@@ -172,7 +172,7 @@ static void test_record_stats_with_trace_store_uninitialized(void) {
   census_stats_store_shutdown();
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_init_shutdown();
   test_create_and_destroy();
diff --git a/test/core/statistics/small_log_test.c b/test/core/statistics/small_log_test.cc
index 4bcc35c37e..fb8dfc9988 100644
--- a/test/core/statistics/small_log_test.c
+++ b/test/core/statistics/small_log_test.cc
@@ -23,7 +23,7 @@
 #include <grpc/support/time.h>
 #include "test/core/util/test_config.h"
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   srand(gpr_now(GPR_CLOCK_REALTIME).tv_nsec);
   test_small_log();
diff --git a/test/core/statistics/trace_test.c b/test/core/statistics/trace_test.c
deleted file mode 100644
index 63da9f71d3..0000000000
--- a/test/core/statistics/trace_test.c
+++ /dev/null
@@ -1,240 +0,0 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <stdio.h>
-#include <string.h>
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/port_platform.h>
-#include <grpc/support/sync.h>
-#include <grpc/support/thd.h>
-#include <grpc/support/time.h>
-#include <grpc/support/useful.h>
-#include "src/core/ext/census/census_interface.h"
-#include "src/core/ext/census/census_tracing.h"
-#include "src/core/ext/census/census_tracing.h"
-#include "test/core/util/test_config.h"
-
-/* Ensure all possible state transitions are called without causing problem */
-static void test_init_shutdown(void) {
-  census_tracing_init();
-  census_tracing_init();
-  census_tracing_shutdown();
-  census_tracing_shutdown();
-  census_tracing_init();
-}
-
-static void test_start_op_generates_locally_unique_ids(void) {
-/* Check that ids generated within window size of 1000 are unique.
-   TODO(hongyu): Replace O(n^2) duplicate detection algorithm with O(nlogn)
-   algorithm. Enhance the test to larger window size (>10^6) */
-#define WINDOW_SIZE 1000
-  census_op_id ids[WINDOW_SIZE];
-  int i;
-  census_init();
-  for (i = 0; i < WINDOW_SIZE; i++) {
-    ids[i] = census_tracing_start_op();
-    census_tracing_end_op(ids[i]);
-  }
-  for (i = 0; i < WINDOW_SIZE - 1; i++) {
-    int j;
-    for (j = i + 1; j < WINDOW_SIZE; j++) {
-      GPR_ASSERT(ids[i].upper != ids[j].upper || ids[i].lower != ids[j].lower);
-    }
-  }
-#undef WINDOW_SIZE
-  census_shutdown();
-}
-
-static void test_get_trace_method_name(void) {
-  census_op_id id;
-  const char write_name[] = "service/method";
-  census_tracing_init();
-  id = census_tracing_start_op();
-  census_add_method_tag(id, write_name);
-  census_internal_lock_trace_store();
-  {
-    const char *read_name =
-        census_get_trace_method_name(census_get_trace_obj_locked(id));
-    GPR_ASSERT(strcmp(read_name, write_name) == 0);
-  }
-  census_internal_unlock_trace_store();
-  census_tracing_shutdown();
-}
-
-typedef struct thd_arg {
-  int num_done;
-  gpr_cv done;
-  gpr_mu mu;
-} thd_arg;
-
-static void mimic_trace_op_sequences(void *arg) {
-  census_op_id id;
-  const char *method_name = "service_foo/method_bar";
-  int i = 0;
-  const int num_iter = 200;
-  thd_arg *args = (thd_arg *)arg;
-  GPR_ASSERT(args != NULL);
-  gpr_log(GPR_INFO, "Start trace op sequence thread.");
-  for (i = 0; i < num_iter; i++) {
-    id = census_tracing_start_op();
-    census_add_method_tag(id, method_name);
-    /* pretend doing 1us work. */
-    gpr_sleep_until(GRPC_TIMEOUT_MICROS_TO_DEADLINE(1));
-    census_tracing_end_op(id);
-  }
-  gpr_log(GPR_INFO, "End trace op sequence thread.");
-  gpr_mu_lock(&args->mu);
-  args->num_done += 1;
-  gpr_cv_broadcast(&args->done);
-  gpr_mu_unlock(&args->mu);
-}
-
-static void test_concurrency(void) {
-#define NUM_THREADS 1000
-  gpr_thd_id tid[NUM_THREADS];
-  int i = 0;
-  thd_arg arg;
-  arg.num_done = 0;
-  gpr_mu_init(&arg.mu);
-  gpr_cv_init(&arg.done);
-  census_tracing_init();
-  for (i = 0; i < NUM_THREADS; ++i) {
-    gpr_thd_new(tid + i, mimic_trace_op_sequences, &arg, NULL);
-  }
-  gpr_mu_lock(&arg.mu);
-  while (arg.num_done < NUM_THREADS) {
-    gpr_log(GPR_INFO, "num done %d", arg.num_done);
-    gpr_cv_wait(&arg.done, &arg.mu, gpr_inf_future(GPR_CLOCK_REALTIME));
-  }
-  gpr_mu_unlock(&arg.mu);
-  census_tracing_shutdown();
-#undef NUM_THREADS
-}
-
-static void test_add_method_tag_to_unknown_op_id(void) {
-  census_op_id unknown_id = {0xDEAD, 0xBEEF};
-  int ret = 0;
-  census_tracing_init();
-  ret = census_add_method_tag(unknown_id, "foo");
-  GPR_ASSERT(ret != 0);
-  census_tracing_shutdown();
-}
-
-static void test_trace_print(void) {
-  census_op_id id;
-  int i;
-  const char *annotation_txt[4] = {"abc", "", "$%^ *()_"};
-  char long_txt[CENSUS_MAX_ANNOTATION_LENGTH + 10];
-
-  memset(long_txt, 'a', GPR_ARRAY_SIZE(long_txt));
-  long_txt[CENSUS_MAX_ANNOTATION_LENGTH + 9] = '\0';
-  annotation_txt[3] = long_txt;
-
-  census_tracing_init();
-  id = census_tracing_start_op();
-  /* Adds large number of annotations to each trace */
-  for (i = 0; i < 1000; i++) {
-    census_tracing_print(id,
-                         annotation_txt[i % GPR_ARRAY_SIZE(annotation_txt)]);
-  }
-  census_tracing_end_op(id);
-
-  census_tracing_shutdown();
-}
-
-/* Returns 1 if two ids are equal, otherwise returns 0. */
-static int ids_equal(census_op_id id1, census_op_id id2) {
-  return (id1.upper == id2.upper) && (id1.lower == id2.lower);
-}
-
-static void test_get_active_ops(void) {
-  census_op_id id_1, id_2, id_3;
-  census_trace_obj **active_ops;
-  const char *annotation_txt[] = {"annotation 1", "a2"};
-  int i = 0;
-  int n = 0;
-
-  gpr_log(GPR_INFO, "test_get_active_ops");
-  census_tracing_init();
-  /* No active ops before calling start_op(). */
-  active_ops = census_get_active_ops(&n);
-  GPR_ASSERT(active_ops == NULL);
-  GPR_ASSERT(n == 0);
-
-  /* Starts one op */
-  id_1 = census_tracing_start_op();
-  census_add_method_tag(id_1, "foo_1");
-  active_ops = census_get_active_ops(&n);
-  GPR_ASSERT(active_ops != NULL);
-  GPR_ASSERT(n == 1);
-  GPR_ASSERT(ids_equal(active_ops[0]->id, id_1));
-  census_trace_obj_destroy(active_ops[0]);
-  gpr_free(active_ops);
-  active_ops = NULL;
-
-  /* Start the second and the third ops */
-  id_2 = census_tracing_start_op();
-  census_add_method_tag(id_2, "foo_2");
-  id_3 = census_tracing_start_op();
-  census_add_method_tag(id_3, "foo_3");
-
-  active_ops = census_get_active_ops(&n);
-  GPR_ASSERT(n == 3);
-  for (i = 0; i < 3; i++) {
-    census_trace_obj_destroy(active_ops[i]);
-  }
-  gpr_free(active_ops);
-  active_ops = NULL;
-
-  /* End the second op  and add annotations to the third ops */
-  census_tracing_end_op(id_2);
-  census_tracing_print(id_3, annotation_txt[0]);
-  census_tracing_print(id_3, annotation_txt[1]);
-
-  active_ops = census_get_active_ops(&n);
-  GPR_ASSERT(active_ops != NULL);
-  GPR_ASSERT(n == 2);
-  for (i = 0; i < 2; i++) {
-    census_trace_obj_destroy(active_ops[i]);
-  }
-  gpr_free(active_ops);
-  active_ops = NULL;
-
-  /* End all ops. */
-  census_tracing_end_op(id_1);
-  census_tracing_end_op(id_3);
-  active_ops = census_get_active_ops(&n);
-  GPR_ASSERT(active_ops == NULL);
-  GPR_ASSERT(n == 0);
-
-  census_tracing_shutdown();
-}
-
-int main(int argc, char **argv) {
-  grpc_test_init(argc, argv);
-  test_init_shutdown();
-  test_start_op_generates_locally_unique_ids();
-  test_get_trace_method_name();
-  test_concurrency();
-  test_add_method_tag_to_unknown_op_id();
-  test_trace_print();
-  test_get_active_ops();
-  return 0;
-}
diff --git a/test/core/statistics/window_stats_test.c b/test/core/statistics/window_stats_test.c
deleted file mode 100644
index 254c14a6a8..0000000000
--- a/test/core/statistics/window_stats_test.c
+++ /dev/null
@@ -1,303 +0,0 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include "src/core/ext/census/window_stats.h"
-#include <grpc/support/log.h>
-#include <grpc/support/time.h>
-#include <stdlib.h>
-#include "test/core/util/test_config.h"
-
-typedef struct test_stat {
-  double value1;
-  int value2;
-} test_stat;
-
-void add_test_stat(void *base, const void *addme) {
-  test_stat *b = (test_stat *)base;
-  const test_stat *a = (const test_stat *)addme;
-  b->value1 += a->value1;
-  b->value2 += a->value2;
-}
-
-void add_proportion_test_stat(double p, void *base, const void *addme) {
-  test_stat *b = (test_stat *)base;
-  const test_stat *a = (const test_stat *)addme;
-  b->value1 += p * a->value1;
-  b->value2 += p * a->value2 + 0.5; /* +0.5 is poor mans (no c99) round() */
-}
-
-const struct census_window_stats_stat_info kMyStatInfo = {
-    sizeof(test_stat), NULL, add_test_stat, add_proportion_test_stat};
-
-const gpr_timespec kMilliSecInterval = {0, 1000000};
-const gpr_timespec kSecInterval = {1, 0};
-const gpr_timespec kMinInterval = {60, 0};
-const gpr_timespec kHourInterval = {3600, 0};
-const gpr_timespec kPrimeInterval = {0, 101};
-
-static int compare_double(double a, double b, double epsilon) {
-  if (a >= b) {
-    return (a > b + epsilon) ? 1 : 0;
-  } else {
-    return (b > a + epsilon) ? -1 : 0;
-  }
-}
-
-void empty_test(void) {
-  census_window_stats_sums result;
-  const gpr_timespec zero = {0, 0};
-  test_stat sum;
-  struct census_window_stats *stats =
-      census_window_stats_create(1, &kMinInterval, 5, &kMyStatInfo);
-  GPR_ASSERT(stats != NULL);
-  result.statistic = &sum;
-  census_window_stats_get_sums(stats, zero, &result);
-  GPR_ASSERT(result.count == 0 && sum.value1 == 0 && sum.value2 == 0);
-  census_window_stats_get_sums(stats, gpr_now(GPR_CLOCK_REALTIME), &result);
-  GPR_ASSERT(result.count == 0 && sum.value1 == 0 && sum.value2 == 0);
-  census_window_stats_destroy(stats);
-}
-
-void one_interval_test(void) {
-  const test_stat value = {0.1, 4};
-  const double epsilon = 1e10 - 11;
-  gpr_timespec when = {0, 0};
-  census_window_stats_sums result;
-  test_stat sum;
-  /* granularity == 5 so width of internal windows should be 12s */
-  struct census_window_stats *stats =
-      census_window_stats_create(1, &kMinInterval, 5, &kMyStatInfo);
-  GPR_ASSERT(stats != NULL);
-  /* phase 1: insert a single value at t=0s, and check that various measurement
-     times result in expected output values */
-  census_window_stats_add(stats, when, &value);
-  result.statistic = &sum;
-  /* when = 0s, values extracted should be everything */
-  census_window_stats_get_sums(stats, when, &result);
-  GPR_ASSERT(compare_double(result.count, 1, epsilon) == 0 &&
-             compare_double(sum.value1, value.value1, epsilon) == 0 &&
-             sum.value2 == value.value2);
-  /* when = 6,30,60s, should be all of the data */
-  when.tv_sec = 6;
-  census_window_stats_get_sums(stats, when, &result);
-  GPR_ASSERT(compare_double(result.count, 1.0, epsilon) == 0 &&
-             compare_double(sum.value1, value.value1, epsilon) == 0 &&
-             sum.value2 == value.value2);
-  /* when == 30s,60s, should be all of the data */
-  when.tv_sec = 30;
-  census_window_stats_get_sums(stats, when, &result);
-  GPR_ASSERT(compare_double(result.count, 1.0, epsilon) == 0 &&
-             compare_double(sum.value1, value.value1, epsilon) == 0 &&
-             sum.value2 == value.value2);
-  when.tv_sec = 60;
-  census_window_stats_get_sums(stats, when, &result);
-  GPR_ASSERT(compare_double(result.count, 1.0, epsilon) == 0 &&
-             compare_double(sum.value1, value.value1, epsilon) == 0 &&
-             sum.value2 == value.value2);
-  /* when = 66s, should be half (only take half of bottom bucket) */
-  when.tv_sec = 66;
-  census_window_stats_get_sums(stats, when, &result);
-  GPR_ASSERT(compare_double(result.count, 0.5, epsilon) == 0 &&
-             compare_double(sum.value1, value.value1 / 2, epsilon) == 0 &&
-             sum.value2 == value.value2 / 2);
-  /* when = 72s, should be completely out of window */
-  when.tv_sec = 72;
-  census_window_stats_get_sums(stats, when, &result);
-  GPR_ASSERT(compare_double(result.count, 0, epsilon) == 0 &&
-             compare_double(sum.value1, 0, epsilon) == 0 && sum.value2 == 0);
-
-  /* phase 2: tear down and do as before, but inserting two values */
-  census_window_stats_destroy(stats);
-  stats = census_window_stats_create(1, &kMinInterval, 5, &kMyStatInfo);
-  GPR_ASSERT(stats != NULL);
-  when.tv_sec = 0;
-  when.tv_nsec = 17;
-  census_window_stats_add(stats, when, &value);
-  when.tv_sec = 1;
-  census_window_stats_add(stats, when, &value);
-  when.tv_sec = 0;
-  census_window_stats_get_sums(stats, when, &result);
-  GPR_ASSERT(compare_double(result.count, 0, epsilon) == 0 &&
-             compare_double(sum.value1, 0, epsilon) == 0 && sum.value2 == 0);
-  /* time = 3s, 30s, should get all data */
-  when.tv_sec = 3;
-  census_window_stats_get_sums(stats, when, &result);
-  GPR_ASSERT(compare_double(result.count, 2, epsilon) == 0 &&
-             compare_double(sum.value1, 2 * value.value1, epsilon) == 0 &&
-             sum.value2 == 2 * value.value2);
-  when.tv_sec = 30;
-  census_window_stats_get_sums(stats, when, &result);
-  GPR_ASSERT(compare_double(result.count, 2, epsilon) == 0 &&
-             compare_double(sum.value1, 2 * value.value1, epsilon) == 0 &&
-             sum.value2 == 2 * value.value2);
-
-  /* phase 3: insert into "middle" bucket, and force a shift, pushing out
-     the two values in bottom bucket */
-  when.tv_sec = 30;
-  census_window_stats_add(stats, when, &value);
-  when.tv_sec = 76;
-  census_window_stats_add(stats, when, &value);
-  when.tv_sec = 0;
-  census_window_stats_get_sums(stats, when, &result);
-  GPR_ASSERT(result.count == 0 && sum.value1 == 0 && sum.value2 == 0);
-  when.tv_sec = 30;
-  census_window_stats_get_sums(stats, when, &result);
-  /* half of the single value in the 30 second bucket */
-  GPR_ASSERT(compare_double(result.count, 0.5, epsilon) == 0 &&
-             compare_double(sum.value1, value.value1 / 2, epsilon) == 0 &&
-             sum.value2 == value.value2 / 2);
-  when.tv_sec = 74;
-  census_window_stats_get_sums(stats, when, &result);
-  /* half of the 76 second bucket, all of the 30 second bucket */
-  GPR_ASSERT(compare_double(result.count, 1.5, epsilon) == 0 &&
-             compare_double(sum.value1, value.value1 * 1.5, epsilon) == 0 &&
-             sum.value2 == value.value2 / 2 * 3);
-  when.tv_sec = 76;
-  census_window_stats_get_sums(stats, when, &result);
-  /* >=76s, get all of the 76 second bucket, all of the 30 second bucket */
-  GPR_ASSERT(compare_double(result.count, 2, epsilon) == 0 &&
-             compare_double(sum.value1, value.value1 * 2, epsilon) == 0 &&
-             sum.value2 == value.value2 * 2);
-  when.tv_sec = 78;
-  census_window_stats_get_sums(stats, when, &result);
-  /* half of the 76 second bucket, all of the 30 second bucket */
-  GPR_ASSERT(compare_double(result.count, 2, epsilon) == 0 &&
-             compare_double(sum.value1, value.value1 * 2, epsilon) == 0 &&
-             sum.value2 == value.value2 * 2);
-  census_window_stats_destroy(stats);
-}
-
-void many_interval_test(void) {
-  gpr_timespec intervals[4];
-  const test_stat value = {123.45, 8};
-  const double epsilon = 1e10 - 11;
-  gpr_timespec when = {3600, 0}; /* one hour */
-  census_window_stats_sums result[4];
-  test_stat sums[4];
-  int i;
-  struct census_window_stats *stats;
-  intervals[0] = kMilliSecInterval;
-  intervals[1] = kSecInterval;
-  intervals[2] = kMinInterval;
-  intervals[3] = kHourInterval;
-  for (i = 0; i < 4; i++) {
-    result[i].statistic = &sums[i];
-  }
-  stats = census_window_stats_create(4, intervals, 100, &kMyStatInfo);
-  GPR_ASSERT(stats != NULL);
-  /* add 10 stats within half of each time range */
-  for (i = 0; i < 10; i++) {
-    when.tv_sec += 180; /* covers 30 min of one hour range */
-    census_window_stats_add(stats, when, &value);
-  }
-  when.tv_sec += 120;
-  for (i = 0; i < 10; i++) {
-    when.tv_sec += 3; /* covers 30 sec of one minute range */
-    census_window_stats_add(stats, when, &value);
-  }
-  when.tv_sec += 2;
-  for (i = 0; i < 10; i++) {
-    when.tv_nsec += 50000000; /* covers 0.5s of 1s range */
-    census_window_stats_add(stats, when, &value);
-  }
-  when.tv_nsec += 2000000;
-  for (i = 0; i < 10; i++) {
-    when.tv_nsec += 50000; /* covers 0.5 ms of 1 ms range */
-    census_window_stats_add(stats, when, &value);
-  }
-  when.tv_nsec += 20000;
-  census_window_stats_get_sums(stats, when, result);
-  GPR_ASSERT(compare_double(result[0].count, 10, epsilon) == 0 &&
-             compare_double(sums[0].value1, value.value1 * 10, epsilon) == 0 &&
-             sums[0].value2 == value.value2 * 10);
-  when.tv_nsec += 20000000;
-  census_window_stats_get_sums(stats, when, result);
-  GPR_ASSERT(compare_double(result[1].count, 20, epsilon) == 0 &&
-             compare_double(sums[1].value1, value.value1 * 20, epsilon) == 0 &&
-             sums[1].value2 == value.value2 * 20);
-  when.tv_sec += 2;
-  census_window_stats_get_sums(stats, when, result);
-  GPR_ASSERT(compare_double(result[2].count, 30, epsilon) == 0 &&
-             compare_double(sums[2].value1, value.value1 * 30, epsilon) == 0 &&
-             sums[2].value2 == value.value2 * 30);
-  when.tv_sec += 72;
-  census_window_stats_get_sums(stats, when, result);
-  GPR_ASSERT(compare_double(result[3].count, 40, epsilon) == 0 &&
-             compare_double(sums[3].value1, value.value1 * 40, epsilon) == 0 &&
-             sums[3].value2 == value.value2 * 40);
-  census_window_stats_destroy(stats);
-}
-
-void rolling_time_test(void) {
-  const test_stat value = {0.1, 4};
-  gpr_timespec when = {0, 0};
-  census_window_stats_sums result;
-  test_stat sum;
-  int i;
-  gpr_timespec increment = {0, 0};
-  struct census_window_stats *stats =
-      census_window_stats_create(1, &kMinInterval, 7, &kMyStatInfo);
-  GPR_ASSERT(stats != NULL);
-  srand(gpr_now(GPR_CLOCK_REALTIME).tv_nsec);
-  for (i = 0; i < 100000; i++) {
-    increment.tv_nsec = rand() % 100000000; /* up to 1/10th second */
-    when = gpr_time_add(when, increment);
-    census_window_stats_add(stats, when, &value);
-  }
-  result.statistic = &sum;
-  census_window_stats_get_sums(stats, when, &result);
-  /* With 1/20th second average between samples, we expect 20*60 = 1200
-     samples on average. Make sure we are within 100 of that. */
-  GPR_ASSERT(compare_double(result.count, 1200, 100) == 0);
-  census_window_stats_destroy(stats);
-}
-
-#include <stdio.h>
-void infinite_interval_test(void) {
-  const test_stat value = {0.1, 4};
-  gpr_timespec when = {0, 0};
-  census_window_stats_sums result;
-  test_stat sum;
-  int i;
-  const int count = 100000;
-  gpr_timespec increment = {0, 0};
-  struct census_window_stats *stats = census_window_stats_create(
-      1, &gpr_inf_future(GPR_CLOCK_REALTIME), 10, &kMyStatInfo);
-  srand(gpr_now(GPR_CLOCK_REALTIME).tv_nsec);
-  for (i = 0; i < count; i++) {
-    increment.tv_sec = rand() % 21600; /* 6 hours */
-    when = gpr_time_add(when, increment);
-    census_window_stats_add(stats, when, &value);
-  }
-  result.statistic = &sum;
-  census_window_stats_get_sums(stats, when, &result);
-  /* The only thing it makes sense to compare for "infinite" periods is the
-     total counts */
-  GPR_ASSERT(result.count == count);
-  census_window_stats_destroy(stats);
-}
-
-int main(int argc, char *argv[]) {
-  grpc_test_init(argc, argv);
-  empty_test();
-  one_interval_test();
-  many_interval_test();
-  rolling_time_test();
-  infinite_interval_test();
-  return 0;
-}
diff --git a/test/core/support/BUILD b/test/core/support/BUILD
index 3bdc1c4186..69512cd9a9 100644
--- a/test/core/support/BUILD
+++ b/test/core/support/BUILD
@@ -20,8 +20,8 @@ grpc_package(name = "test/core/support")
 
 grpc_cc_test(
     name = "alloc_test",
-    srcs = ["alloc_test.c"],
-    language = "C",
+    srcs = ["alloc_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//test/core/util:gpr_test_util",
@@ -30,8 +30,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "avl_test",
-    srcs = ["avl_test.c"],
-    language = "C",
+    srcs = ["avl_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//test/core/util:gpr_test_util",
@@ -40,8 +40,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "cmdline_test",
-    srcs = ["cmdline_test.c"],
-    language = "C",
+    srcs = ["cmdline_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//test/core/util:gpr_test_util",
@@ -50,8 +50,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "cpu_test",
-    srcs = ["cpu_test.c"],
-    language = "C",
+    srcs = ["cpu_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//test/core/util:gpr_test_util",
@@ -60,8 +60,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "env_test",
-    srcs = ["env_test.c"],
-    language = "C",
+    srcs = ["env_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//test/core/util:gpr_test_util",
@@ -70,8 +70,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "histogram_test",
-    srcs = ["histogram_test.c"],
-    language = "C",
+    srcs = ["histogram_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//test/core/util:gpr_test_util",
@@ -80,8 +80,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "host_port_test",
-    srcs = ["host_port_test.c"],
-    language = "C",
+    srcs = ["host_port_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//test/core/util:gpr_test_util",
@@ -90,8 +90,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "log_test",
-    srcs = ["log_test.c"],
-    language = "C",
+    srcs = ["log_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//test/core/util:gpr_test_util",
@@ -100,8 +100,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "mpscq_test",
-    srcs = ["mpscq_test.c"],
-    language = "C",
+    srcs = ["mpscq_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//test/core/util:gpr_test_util",
@@ -110,8 +110,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "murmur_hash_test",
-    srcs = ["murmur_hash_test.c"],
-    language = "C",
+    srcs = ["murmur_hash_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//test/core/util:gpr_test_util",
@@ -120,8 +120,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "stack_lockfree_test",
-    srcs = ["stack_lockfree_test.c"],
-    language = "C",
+    srcs = ["stack_lockfree_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//test/core/util:gpr_test_util",
@@ -130,8 +130,18 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "string_test",
-    srcs = ["string_test.c"],
-    language = "C",
+    srcs = ["string_test.cc"],
+    language = "C++",
+    deps = [
+        "//:gpr",
+        "//test/core/util:gpr_test_util",
+    ],
+)
+
+grpc_cc_test(
+    name = "manual_constructor_test",
+    srcs = ["manual_constructor_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//test/core/util:gpr_test_util",
@@ -140,8 +150,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "spinlock_test",
-    srcs = ["spinlock_test.c"],
-    language = "C",
+    srcs = ["spinlock_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//test/core/util:gpr_test_util",
@@ -150,8 +160,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "sync_test",
-    srcs = ["sync_test.c"],
-    language = "C",
+    srcs = ["sync_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//test/core/util:gpr_test_util",
@@ -160,8 +170,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "thd_test",
-    srcs = ["thd_test.c"],
-    language = "C",
+    srcs = ["thd_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//test/core/util:gpr_test_util",
@@ -170,8 +180,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "time_test",
-    srcs = ["time_test.c"],
-    language = "C",
+    srcs = ["time_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//test/core/util:gpr_test_util",
@@ -180,8 +190,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "tls_test",
-    srcs = ["tls_test.c"],
-    language = "C",
+    srcs = ["tls_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//test/core/util:gpr_test_util",
@@ -190,8 +200,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "useful_test",
-    srcs = ["useful_test.c"],
-    language = "C",
+    srcs = ["useful_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//test/core/util:gpr_test_util",
diff --git a/test/core/support/alloc_test.c b/test/core/support/alloc_test.cc
index 088ae7d944..6074c6e6e7 100644
--- a/test/core/support/alloc_test.c
+++ b/test/core/support/alloc_test.cc
@@ -20,35 +20,35 @@
 #include <grpc/support/log.h>
 #include "test/core/util/test_config.h"
 
-static void *fake_malloc(size_t size) { return (void *)size; }
+static void* fake_malloc(size_t size) { return (void*)size; }
 
-static void *fake_realloc(void *addr, size_t size) { return (void *)size; }
+static void* fake_realloc(void* addr, size_t size) { return (void*)size; }
 
-static void fake_free(void *addr) {
-  *((intptr_t *)addr) = (intptr_t)0xdeadd00d;
-}
+static void fake_free(void* addr) { *((intptr_t*)addr) = (intptr_t)0xdeadd00d; }
 
 static void test_custom_allocs() {
   const gpr_allocation_functions default_fns = gpr_get_allocation_functions();
   intptr_t addr_to_free = 0;
-  char *i;
-  gpr_allocation_functions fns = {fake_malloc, NULL, fake_realloc, fake_free};
+  char* i;
+  gpr_allocation_functions fns = {fake_malloc, nullptr, fake_realloc,
+                                  fake_free};
 
   gpr_set_allocation_functions(fns);
-  GPR_ASSERT((void *)(size_t)0xdeadbeef == gpr_malloc(0xdeadbeef));
-  GPR_ASSERT((void *)(size_t)0xcafed00d == gpr_realloc(0, 0xcafed00d));
+  GPR_ASSERT((void*)(size_t)0xdeadbeef == gpr_malloc(0xdeadbeef));
+  GPR_ASSERT((void*)(size_t)0xcafed00d == gpr_realloc(nullptr, 0xcafed00d));
 
   gpr_free(&addr_to_free);
   GPR_ASSERT(addr_to_free == (intptr_t)0xdeadd00d);
 
   /* Restore and check we don't get funky values and that we don't leak */
   gpr_set_allocation_functions(default_fns);
-  GPR_ASSERT((void *)sizeof(*i) != (i = gpr_malloc(sizeof(*i))));
-  GPR_ASSERT((void *)2 != (i = gpr_realloc(i, 2)));
+  GPR_ASSERT((void*)sizeof(*i) !=
+             (i = static_cast<char*>(gpr_malloc(sizeof(*i)))));
+  GPR_ASSERT((void*)2 != (i = static_cast<char*>(gpr_realloc(i, 2))));
   gpr_free(i);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_custom_allocs();
   return 0;
diff --git a/test/core/support/arena_test.c b/test/core/support/arena_test.cc
index afb309280f..244d860639 100644
--- a/test/core/support/arena_test.c
+++ b/test/core/support/arena_test.cc
@@ -32,10 +32,10 @@
 
 static void test_noop(void) { gpr_arena_destroy(gpr_arena_create(1)); }
 
-static void test(const char *name, size_t init_size, const size_t *allocs,
+static void test(const char* name, size_t init_size, const size_t* allocs,
                  size_t nallocs) {
   gpr_strvec v;
-  char *s;
+  char* s;
   gpr_strvec_init(&v);
   gpr_asprintf(&s, "test '%s': %" PRIdPTR " <- {", name, init_size);
   gpr_strvec_add(&v, s);
@@ -44,13 +44,13 @@ static void test(const char *name, size_t init_size, const size_t *allocs,
     gpr_strvec_add(&v, s);
   }
   gpr_strvec_add(&v, gpr_strdup("}"));
-  s = gpr_strvec_flatten(&v, NULL);
+  s = gpr_strvec_flatten(&v, nullptr);
   gpr_strvec_destroy(&v);
   gpr_log(GPR_INFO, "%s", s);
   gpr_free(s);
 
-  gpr_arena *a = gpr_arena_create(init_size);
-  void **ps = gpr_zalloc(sizeof(*ps) * nallocs);
+  gpr_arena* a = gpr_arena_create(init_size);
+  void** ps = static_cast<void**>(gpr_zalloc(sizeof(*ps) * nallocs));
   for (size_t i = 0; i < nallocs; i++) {
     ps[i] = gpr_arena_alloc(a, allocs[i]);
     // ensure no duplicate results
@@ -71,20 +71,20 @@ static void test(const char *name, size_t init_size, const size_t *allocs,
 #define CONCURRENT_TEST_THREADS 100
 
 size_t concurrent_test_iterations() {
-  if (sizeof(void *) < 8) return 1000;
+  if (sizeof(void*) < 8) return 1000;
   return 100000;
 }
 
 typedef struct {
   gpr_event ev_start;
-  gpr_arena *arena;
+  gpr_arena* arena;
 } concurrent_test_args;
 
-static void concurrent_test_body(void *arg) {
-  concurrent_test_args *a = arg;
+static void concurrent_test_body(void* arg) {
+  concurrent_test_args* a = static_cast<concurrent_test_args*>(arg);
   gpr_event_wait(&a->ev_start, gpr_inf_future(GPR_CLOCK_REALTIME));
   for (size_t i = 0; i < concurrent_test_iterations(); i++) {
-    *(char *)gpr_arena_alloc(a->arena, 1) = (char)i;
+    *(char*)gpr_arena_alloc(a->arena, 1) = (char)i;
   }
 }
 
@@ -103,7 +103,7 @@ static void concurrent_test(void) {
     gpr_thd_new(&thds[i], concurrent_test_body, &args, &opt);
   }
 
-  gpr_event_set(&args.ev_start, (void *)1);
+  gpr_event_set(&args.ev_start, (void*)1);
 
   for (int i = 0; i < CONCURRENT_TEST_THREADS; i++) {
     gpr_thd_join(thds[i]);
@@ -112,7 +112,7 @@ static void concurrent_test(void) {
   gpr_arena_destroy(args.arena);
 }
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
   grpc_test_init(argc, argv);
 
   test_noop();
diff --git a/test/core/support/avl_test.c b/test/core/support/avl_test.c
deleted file mode 100644
index 37424d6405..0000000000
--- a/test/core/support/avl_test.c
+++ /dev/null
@@ -1,3659 +0,0 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <grpc/support/avl.h>
-
-#include <stdio.h>
-#include <string.h>
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/useful.h>
-
-#include "test/core/util/test_config.h"
-
-static int *box(int x) {
-  int *b = gpr_malloc(sizeof(*b));
-  *b = x;
-  return b;
-}
-
-static long int_compare(void *int1, void *int2, void *unused) {
-  return (*(int *)int1) - (*(int *)int2);
-}
-static void *int_copy(void *p, void *unused) { return box(*(int *)p); }
-
-static void destroy(void *p, void *unused) { gpr_free(p); }
-
-static const gpr_avl_vtable int_int_vtable = {destroy, int_copy, int_compare,
-                                              destroy, int_copy};
-
-static void check_get(gpr_avl avl, int key, int value) {
-  int *k = box(key);
-  GPR_ASSERT(*(int *)gpr_avl_get(avl, k, NULL) == value);
-  gpr_free(k);
-}
-
-static void check_negget(gpr_avl avl, int key) {
-  int *k = box(key);
-  GPR_ASSERT(gpr_avl_get(avl, k, NULL) == NULL);
-  gpr_free(k);
-}
-
-static gpr_avl remove_int(gpr_avl avl, int key) {
-  int *k = box(key);
-  avl = gpr_avl_remove(avl, k, NULL);
-  gpr_free(k);
-  return avl;
-}
-
-static void test_get(void) {
-  gpr_avl avl;
-  gpr_log(GPR_DEBUG, "test_get");
-  avl = gpr_avl_create(&int_int_vtable);
-  avl = gpr_avl_add(avl, box(1), box(11), NULL);
-  avl = gpr_avl_add(avl, box(2), box(22), NULL);
-  avl = gpr_avl_add(avl, box(3), box(33), NULL);
-  check_get(avl, 1, 11);
-  check_get(avl, 2, 22);
-  check_get(avl, 3, 33);
-  check_negget(avl, 4);
-  gpr_avl_unref(avl, NULL);
-}
-
-static void test_ll(void) {
-  gpr_avl avl;
-  gpr_log(GPR_DEBUG, "test_ll");
-  avl = gpr_avl_create(&int_int_vtable);
-  avl = gpr_avl_add(avl, box(5), box(1), NULL);
-  avl = gpr_avl_add(avl, box(4), box(2), NULL);
-  avl = gpr_avl_add(avl, box(3), box(3), NULL);
-  GPR_ASSERT(*(int *)avl.root->key == 4);
-  GPR_ASSERT(*(int *)avl.root->left->key == 3);
-  GPR_ASSERT(*(int *)avl.root->right->key == 5);
-  gpr_avl_unref(avl, NULL);
-}
-
-static void test_lr(void) {
-  gpr_avl avl;
-  gpr_log(GPR_DEBUG, "test_lr");
-  avl = gpr_avl_create(&int_int_vtable);
-  avl = gpr_avl_add(avl, box(5), box(1), NULL);
-  avl = gpr_avl_add(avl, box(3), box(2), NULL);
-  avl = gpr_avl_add(avl, box(4), box(3), NULL);
-  GPR_ASSERT(*(int *)avl.root->key == 4);
-  GPR_ASSERT(*(int *)avl.root->left->key == 3);
-  GPR_ASSERT(*(int *)avl.root->right->key == 5);
-  gpr_avl_unref(avl, NULL);
-}
-
-static void test_rr(void) {
-  gpr_avl avl;
-  gpr_log(GPR_DEBUG, "test_rr");
-  avl = gpr_avl_create(&int_int_vtable);
-  avl = gpr_avl_add(avl, box(3), box(1), NULL);
-  avl = gpr_avl_add(avl, box(4), box(2), NULL);
-  avl = gpr_avl_add(avl, box(5), box(3), NULL);
-  GPR_ASSERT(*(int *)avl.root->key == 4);
-  GPR_ASSERT(*(int *)avl.root->left->key == 3);
-  GPR_ASSERT(*(int *)avl.root->right->key == 5);
-  gpr_avl_unref(avl, NULL);
-}
-
-static void test_rl(void) {
-  gpr_avl avl;
-  gpr_log(GPR_DEBUG, "test_rl");
-  avl = gpr_avl_create(&int_int_vtable);
-  avl = gpr_avl_add(avl, box(3), box(1), NULL);
-  avl = gpr_avl_add(avl, box(5), box(2), NULL);
-  avl = gpr_avl_add(avl, box(4), box(3), NULL);
-  GPR_ASSERT(*(int *)avl.root->key == 4);
-  GPR_ASSERT(*(int *)avl.root->left->key == 3);
-  GPR_ASSERT(*(int *)avl.root->right->key == 5);
-  gpr_avl_unref(avl, NULL);
-}
-
-static void test_unbalanced(void) {
-  gpr_avl avl;
-  gpr_log(GPR_DEBUG, "test_unbalanced");
-  avl = gpr_avl_create(&int_int_vtable);
-  avl = gpr_avl_add(avl, box(5), box(1), NULL);
-  avl = gpr_avl_add(avl, box(4), box(2), NULL);
-  avl = gpr_avl_add(avl, box(3), box(3), NULL);
-  avl = gpr_avl_add(avl, box(2), box(4), NULL);
-  avl = gpr_avl_add(avl, box(1), box(5), NULL);
-  GPR_ASSERT(*(int *)avl.root->key == 4);
-  GPR_ASSERT(*(int *)avl.root->left->key == 2);
-  GPR_ASSERT(*(int *)avl.root->left->left->key == 1);
-  GPR_ASSERT(*(int *)avl.root->left->right->key == 3);
-  GPR_ASSERT(*(int *)avl.root->right->key == 5);
-  gpr_avl_unref(avl, NULL);
-}
-
-static void test_replace(void) {
-  gpr_avl avl;
-  gpr_log(GPR_DEBUG, "test_replace");
-  avl = gpr_avl_create(&int_int_vtable);
-  avl = gpr_avl_add(avl, box(1), box(1), NULL);
-  avl = gpr_avl_add(avl, box(1), box(2), NULL);
-  check_get(avl, 1, 2);
-  check_negget(avl, 2);
-  gpr_avl_unref(avl, NULL);
-}
-
-static void test_remove(void) {
-  gpr_avl avl;
-  gpr_avl avl3, avl4, avl5, avln;
-  gpr_log(GPR_DEBUG, "test_remove");
-  avl = gpr_avl_create(&int_int_vtable);
-  avl = gpr_avl_add(avl, box(3), box(1), NULL);
-  avl = gpr_avl_add(avl, box(4), box(2), NULL);
-  avl = gpr_avl_add(avl, box(5), box(3), NULL);
-
-  avl3 = remove_int(gpr_avl_ref(avl, NULL), 3);
-  avl4 = remove_int(gpr_avl_ref(avl, NULL), 4);
-  avl5 = remove_int(gpr_avl_ref(avl, NULL), 5);
-  avln = remove_int(gpr_avl_ref(avl, NULL), 1);
-
-  gpr_avl_unref(avl, NULL);
-
-  check_negget(avl3, 3);
-  check_get(avl3, 4, 2);
-  check_get(avl3, 5, 3);
-  gpr_avl_unref(avl3, NULL);
-
-  check_get(avl4, 3, 1);
-  check_negget(avl4, 4);
-  check_get(avl4, 5, 3);
-  gpr_avl_unref(avl4, NULL);
-
-  check_get(avl5, 3, 1);
-  check_get(avl5, 4, 2);
-  check_negget(avl5, 5);
-  gpr_avl_unref(avl5, NULL);
-
-  check_get(avln, 3, 1);
-  check_get(avln, 4, 2);
-  check_get(avln, 5, 3);
-  gpr_avl_unref(avln, NULL);
-}
-
-static void test_badcase1(void) {
-  gpr_avl avl;
-
-  gpr_log(GPR_DEBUG, "test_badcase1");
-
-  avl = gpr_avl_create(&int_int_vtable);
-  avl = gpr_avl_add(avl, box(88), box(1), NULL);
-  avl = remove_int(avl, 643);
-  avl = remove_int(avl, 983);
-  avl = gpr_avl_add(avl, box(985), box(4), NULL);
-  avl = gpr_avl_add(avl, box(640), box(5), NULL);
-  avl = gpr_avl_add(avl, box(41), box(6), NULL);
-  avl = gpr_avl_add(avl, box(112), box(7), NULL);
-  avl = gpr_avl_add(avl, box(342), box(8), NULL);
-  avl = remove_int(avl, 1013);
-  avl = gpr_avl_add(avl, box(434), box(10), NULL);
-  avl = gpr_avl_add(avl, box(520), box(11), NULL);
-  avl = gpr_avl_add(avl, box(231), box(12), NULL);
-  avl = gpr_avl_add(avl, box(852), box(13), NULL);
-  avl = remove_int(avl, 461);
-  avl = gpr_avl_add(avl, box(108), box(15), NULL);
-  avl = gpr_avl_add(avl, box(806), box(16), NULL);
-  avl = gpr_avl_add(avl, box(827), box(17), NULL);
-  avl = remove_int(avl, 796);
-  avl = gpr_avl_add(avl, box(340), box(19), NULL);
-  avl = gpr_avl_add(avl, box(498), box(20), NULL);
-  avl = gpr_avl_add(avl, box(203), box(21), NULL);
-  avl = gpr_avl_add(avl, box(751), box(22), NULL);
-  avl = gpr_avl_add(avl, box(150), box(23), NULL);
-  avl = remove_int(avl, 237);
-  avl = gpr_avl_add(avl, box(830), box(25), NULL);
-  avl = remove_int(avl, 1007);
-  avl = remove_int(avl, 394);
-  avl = gpr_avl_add(avl, box(65), box(28), NULL);
-  avl = remove_int(avl, 904);
-  avl = remove_int(avl, 123);
-  avl = gpr_avl_add(avl, box(238), box(31), NULL);
-  avl = gpr_avl_add(avl, box(184), box(32), NULL);
-  avl = remove_int(avl, 331);
-  avl = gpr_avl_add(avl, box(827), box(34), NULL);
-
-  check_get(avl, 830, 25);
-
-  gpr_avl_unref(avl, NULL);
-}
-
-static void test_badcase2(void) {
-  gpr_avl avl;
-
-  gpr_log(GPR_DEBUG, "test_badcase2");
-
-  avl = gpr_avl_create(&int_int_vtable);
-  avl = gpr_avl_add(avl, box(288), box(1), NULL);
-  avl = remove_int(avl, 415);
-  avl = gpr_avl_add(avl, box(953), box(3), NULL);
-  avl = gpr_avl_add(avl, box(101), box(4), NULL);
-  avl = gpr_avl_add(avl, box(516), box(5), NULL);
-  avl = gpr_avl_add(avl, box(547), box(6), NULL);
-  avl = gpr_avl_add(avl, box(467), box(7), NULL);
-  avl = gpr_avl_add(avl, box(793), box(8), NULL);
-  avl = remove_int(avl, 190);
-  avl = gpr_avl_add(avl, box(687), box(10), NULL);
-  avl = gpr_avl_add(avl, box(242), box(11), NULL);
-  avl = gpr_avl_add(avl, box(142), box(12), NULL);
-  avl = remove_int(avl, 705);
-  avl = remove_int(avl, 578);
-  avl = remove_int(avl, 767);
-  avl = remove_int(avl, 183);
-  avl = gpr_avl_add(avl, box(950), box(17), NULL);
-  avl = gpr_avl_add(avl, box(622), box(18), NULL);
-  avl = remove_int(avl, 513);
-  avl = remove_int(avl, 429);
-  avl = gpr_avl_add(avl, box(205), box(21), NULL);
-  avl = remove_int(avl, 663);
-  avl = remove_int(avl, 953);
-  avl = remove_int(avl, 892);
-  avl = gpr_avl_add(avl, box(236), box(25), NULL);
-  avl = remove_int(avl, 982);
-  avl = remove_int(avl, 201);
-  avl = remove_int(avl, 684);
-  avl = gpr_avl_add(avl, box(572), box(29), NULL);
-  avl = remove_int(avl, 817);
-  avl = gpr_avl_add(avl, box(970), box(31), NULL);
-  avl = remove_int(avl, 347);
-  avl = remove_int(avl, 574);
-  avl = gpr_avl_add(avl, box(752), box(34), NULL);
-  avl = gpr_avl_add(avl, box(670), box(35), NULL);
-  avl = gpr_avl_add(avl, box(69), box(36), NULL);
-  avl = remove_int(avl, 111);
-  avl = remove_int(avl, 523);
-  avl = gpr_avl_add(avl, box(141), box(39), NULL);
-  avl = remove_int(avl, 159);
-  avl = gpr_avl_add(avl, box(947), box(41), NULL);
-  avl = gpr_avl_add(avl, box(855), box(42), NULL);
-  avl = remove_int(avl, 218);
-  avl = remove_int(avl, 6);
-  avl = gpr_avl_add(avl, box(753), box(45), NULL);
-  avl = remove_int(avl, 82);
-  avl = remove_int(avl, 799);
-  avl = gpr_avl_add(avl, box(572), box(48), NULL);
-  avl = remove_int(avl, 376);
-  avl = remove_int(avl, 413);
-  avl = gpr_avl_add(avl, box(458), box(51), NULL);
-  avl = remove_int(avl, 897);
-  avl = gpr_avl_add(avl, box(191), box(53), NULL);
-  avl = gpr_avl_add(avl, box(609), box(54), NULL);
-  avl = remove_int(avl, 787);
-  avl = remove_int(avl, 710);
-  avl = remove_int(avl, 886);
-  avl = remove_int(avl, 835);
-  avl = remove_int(avl, 33);
-  avl = gpr_avl_add(avl, box(871), box(60), NULL);
-  avl = remove_int(avl, 641);
-  avl = gpr_avl_add(avl, box(462), box(62), NULL);
-  avl = remove_int(avl, 359);
-  avl = remove_int(avl, 767);
-  avl = gpr_avl_add(avl, box(310), box(65), NULL);
-  avl = remove_int(avl, 757);
-  avl = remove_int(avl, 639);
-  avl = remove_int(avl, 314);
-  avl = gpr_avl_add(avl, box(2), box(69), NULL);
-  avl = remove_int(avl, 138);
-  avl = gpr_avl_add(avl, box(669), box(71), NULL);
-  avl = remove_int(avl, 477);
-  avl = gpr_avl_add(avl, box(366), box(73), NULL);
-  avl = gpr_avl_add(avl, box(612), box(74), NULL);
-  avl = gpr_avl_add(avl, box(106), box(75), NULL);
-  avl = remove_int(avl, 161);
-  avl = gpr_avl_add(avl, box(388), box(77), NULL);
-  avl = gpr_avl_add(avl, box(141), box(78), NULL);
-  avl = remove_int(avl, 633);
-  avl = remove_int(avl, 459);
-  avl = gpr_avl_add(avl, box(40), box(81), NULL);
-  avl = remove_int(avl, 689);
-  avl = gpr_avl_add(avl, box(823), box(83), NULL);
-  avl = remove_int(avl, 485);
-  avl = gpr_avl_add(avl, box(903), box(85), NULL);
-  avl = gpr_avl_add(avl, box(592), box(86), NULL);
-  avl = remove_int(avl, 448);
-  avl = gpr_avl_add(avl, box(56), box(88), NULL);
-  avl = remove_int(avl, 333);
-  avl = gpr_avl_add(avl, box(189), box(90), NULL);
-  avl = gpr_avl_add(avl, box(103), box(91), NULL);
-  avl = remove_int(avl, 164);
-  avl = remove_int(avl, 974);
-  avl = gpr_avl_add(avl, box(215), box(94), NULL);
-  avl = remove_int(avl, 189);
-  avl = remove_int(avl, 504);
-  avl = gpr_avl_add(avl, box(868), box(97), NULL);
-  avl = remove_int(avl, 909);
-  avl = remove_int(avl, 148);
-  avl = remove_int(avl, 469);
-  avl = gpr_avl_add(avl, box(994), box(101), NULL);
-  avl = gpr_avl_add(avl, box(576), box(102), NULL);
-  avl = remove_int(avl, 82);
-  avl = remove_int(avl, 209);
-  avl = gpr_avl_add(avl, box(276), box(105), NULL);
-  avl = remove_int(avl, 856);
-  avl = gpr_avl_add(avl, box(750), box(107), NULL);
-  avl = remove_int(avl, 871);
-  avl = gpr_avl_add(avl, box(301), box(109), NULL);
-  avl = remove_int(avl, 260);
-  avl = remove_int(avl, 737);
-  avl = remove_int(avl, 719);
-  avl = gpr_avl_add(avl, box(933), box(113), NULL);
-  avl = gpr_avl_add(avl, box(225), box(114), NULL);
-  avl = gpr_avl_add(avl, box(975), box(115), NULL);
-  avl = gpr_avl_add(avl, box(86), box(116), NULL);
-  avl = remove_int(avl, 732);
-  avl = gpr_avl_add(avl, box(340), box(118), NULL);
-  avl = gpr_avl_add(avl, box(271), box(119), NULL);
-  avl = remove_int(avl, 206);
-  avl = gpr_avl_add(avl, box(949), box(121), NULL);
-  avl = gpr_avl_add(avl, box(927), box(122), NULL);
-  avl = gpr_avl_add(avl, box(34), box(123), NULL);
-  avl = gpr_avl_add(avl, box(351), box(124), NULL);
-  avl = remove_int(avl, 836);
-  avl = gpr_avl_add(avl, box(825), box(126), NULL);
-  avl = gpr_avl_add(avl, box(352), box(127), NULL);
-  avl = remove_int(avl, 107);
-  avl = remove_int(avl, 101);
-  avl = gpr_avl_add(avl, box(320), box(130), NULL);
-  avl = gpr_avl_add(avl, box(3), box(131), NULL);
-  avl = remove_int(avl, 998);
-  avl = remove_int(avl, 44);
-  avl = gpr_avl_add(avl, box(525), box(134), NULL);
-  avl = gpr_avl_add(avl, box(864), box(135), NULL);
-  avl = gpr_avl_add(avl, box(863), box(136), NULL);
-  avl = remove_int(avl, 770);
-  avl = gpr_avl_add(avl, box(440), box(138), NULL);
-  avl = remove_int(avl, 516);
-  avl = gpr_avl_add(avl, box(116), box(140), NULL);
-  avl = remove_int(avl, 380);
-  avl = gpr_avl_add(avl, box(878), box(142), NULL);
-  avl = remove_int(avl, 439);
-  avl = gpr_avl_add(avl, box(994), box(144), NULL);
-  avl = remove_int(avl, 294);
-  avl = remove_int(avl, 593);
-  avl = gpr_avl_add(avl, box(696), box(147), NULL);
-  avl = remove_int(avl, 8);
-  avl = gpr_avl_add(avl, box(881), box(149), NULL);
-  avl = remove_int(avl, 32);
-  avl = remove_int(avl, 242);
-  avl = gpr_avl_add(avl, box(487), box(152), NULL);
-  avl = gpr_avl_add(avl, box(637), box(153), NULL);
-  avl = gpr_avl_add(avl, box(793), box(154), NULL);
-  avl = gpr_avl_add(avl, box(696), box(155), NULL);
-  avl = remove_int(avl, 458);
-  avl = gpr_avl_add(avl, box(828), box(157), NULL);
-  avl = remove_int(avl, 784);
-  avl = remove_int(avl, 274);
-  avl = gpr_avl_add(avl, box(783), box(160), NULL);
-  avl = remove_int(avl, 21);
-  avl = gpr_avl_add(avl, box(866), box(162), NULL);
-  avl = remove_int(avl, 919);
-  avl = gpr_avl_add(avl, box(435), box(164), NULL);
-  avl = remove_int(avl, 385);
-  avl = gpr_avl_add(avl, box(475), box(166), NULL);
-  avl = remove_int(avl, 339);
-  avl = gpr_avl_add(avl, box(615), box(168), NULL);
-  avl = remove_int(avl, 866);
-  avl = remove_int(avl, 82);
-  avl = remove_int(avl, 271);
-  avl = gpr_avl_add(avl, box(590), box(172), NULL);
-  avl = gpr_avl_add(avl, box(852), box(173), NULL);
-  avl = remove_int(avl, 318);
-  avl = remove_int(avl, 82);
-  avl = gpr_avl_add(avl, box(672), box(176), NULL);
-  avl = remove_int(avl, 430);
-  avl = gpr_avl_add(avl, box(821), box(178), NULL);
-  avl = gpr_avl_add(avl, box(365), box(179), NULL);
-  avl = remove_int(avl, 78);
-  avl = gpr_avl_add(avl, box(700), box(181), NULL);
-  avl = gpr_avl_add(avl, box(353), box(182), NULL);
-  avl = remove_int(avl, 492);
-  avl = gpr_avl_add(avl, box(991), box(184), NULL);
-  avl = remove_int(avl, 330);
-  avl = gpr_avl_add(avl, box(873), box(186), NULL);
-  avl = remove_int(avl, 589);
-  avl = gpr_avl_add(avl, box(676), box(188), NULL);
-  avl = gpr_avl_add(avl, box(790), box(189), NULL);
-  avl = remove_int(avl, 521);
-  avl = remove_int(avl, 47);
-  avl = gpr_avl_add(avl, box(976), box(192), NULL);
-  avl = gpr_avl_add(avl, box(683), box(193), NULL);
-  avl = remove_int(avl, 803);
-  avl = remove_int(avl, 1006);
-  avl = gpr_avl_add(avl, box(775), box(196), NULL);
-  avl = gpr_avl_add(avl, box(411), box(197), NULL);
-  avl = gpr_avl_add(avl, box(697), box(198), NULL);
-  avl = remove_int(avl, 50);
-  avl = gpr_avl_add(avl, box(213), box(200), NULL);
-  avl = remove_int(avl, 714);
-  avl = gpr_avl_add(avl, box(981), box(202), NULL);
-  avl = gpr_avl_add(avl, box(502), box(203), NULL);
-  avl = gpr_avl_add(avl, box(697), box(204), NULL);
-  avl = gpr_avl_add(avl, box(603), box(205), NULL);
-  avl = gpr_avl_add(avl, box(117), box(206), NULL);
-  avl = remove_int(avl, 363);
-  avl = gpr_avl_add(avl, box(104), box(208), NULL);
-  avl = remove_int(avl, 842);
-  avl = gpr_avl_add(avl, box(48), box(210), NULL);
-  avl = remove_int(avl, 764);
-  avl = gpr_avl_add(avl, box(482), box(212), NULL);
-  avl = gpr_avl_add(avl, box(928), box(213), NULL);
-  avl = gpr_avl_add(avl, box(30), box(214), NULL);
-  avl = gpr_avl_add(avl, box(820), box(215), NULL);
-  avl = gpr_avl_add(avl, box(334), box(216), NULL);
-  avl = remove_int(avl, 306);
-  avl = gpr_avl_add(avl, box(789), box(218), NULL);
-  avl = remove_int(avl, 924);
-  avl = gpr_avl_add(avl, box(53), box(220), NULL);
-  avl = remove_int(avl, 657);
-  avl = gpr_avl_add(avl, box(130), box(222), NULL);
-  avl = gpr_avl_add(avl, box(239), box(223), NULL);
-  avl = remove_int(avl, 20);
-  avl = gpr_avl_add(avl, box(117), box(225), NULL);
-  avl = remove_int(avl, 882);
-  avl = remove_int(avl, 891);
-  avl = gpr_avl_add(avl, box(9), box(228), NULL);
-  avl = gpr_avl_add(avl, box(496), box(229), NULL);
-  avl = gpr_avl_add(avl, box(750), box(230), NULL);
-  avl = gpr_avl_add(avl, box(283), box(231), NULL);
-  avl = gpr_avl_add(avl, box(802), box(232), NULL);
-  avl = remove_int(avl, 352);
-  avl = gpr_avl_add(avl, box(374), box(234), NULL);
-  avl = gpr_avl_add(avl, box(6), box(235), NULL);
-  avl = gpr_avl_add(avl, box(756), box(236), NULL);
-  avl = gpr_avl_add(avl, box(597), box(237), NULL);
-  avl = gpr_avl_add(avl, box(661), box(238), NULL);
-  avl = remove_int(avl, 96);
-  avl = gpr_avl_add(avl, box(894), box(240), NULL);
-  avl = remove_int(avl, 749);
-  avl = gpr_avl_add(avl, box(71), box(242), NULL);
-  avl = remove_int(avl, 68);
-  avl = gpr_avl_add(avl, box(388), box(244), NULL);
-  avl = remove_int(avl, 119);
-  avl = remove_int(avl, 856);
-  avl = gpr_avl_add(avl, box(176), box(247), NULL);
-  avl = gpr_avl_add(avl, box(993), box(248), NULL);
-  avl = remove_int(avl, 178);
-  avl = remove_int(avl, 781);
-  avl = remove_int(avl, 771);
-  avl = remove_int(avl, 848);
-  avl = remove_int(avl, 376);
-  avl = remove_int(avl, 157);
-  avl = remove_int(avl, 142);
-  avl = remove_int(avl, 686);
-  avl = gpr_avl_add(avl, box(779), box(257), NULL);
-  avl = gpr_avl_add(avl, box(484), box(258), NULL);
-  avl = remove_int(avl, 837);
-  avl = gpr_avl_add(avl, box(388), box(260), NULL);
-  avl = remove_int(avl, 987);
-  avl = gpr_avl_add(avl, box(336), box(262), NULL);
-  avl = remove_int(avl, 855);
-  avl = gpr_avl_add(avl, box(668), box(264), NULL);
-  avl = remove_int(avl, 648);
-  avl = gpr_avl_add(avl, box(193), box(266), NULL);
-  avl = remove_int(avl, 939);
-  avl = gpr_avl_add(avl, box(740), box(268), NULL);
-  avl = gpr_avl_add(avl, box(503), box(269), NULL);
-  avl = gpr_avl_add(avl, box(765), box(270), NULL);
-  avl = remove_int(avl, 924);
-  avl = remove_int(avl, 513);
-  avl = gpr_avl_add(avl, box(161), box(273), NULL);
-  avl = gpr_avl_add(avl, box(502), box(274), NULL);
-  avl = gpr_avl_add(avl, box(846), box(275), NULL);
-  avl = remove_int(avl, 931);
-  avl = gpr_avl_add(avl, box(87), box(277), NULL);
-  avl = gpr_avl_add(avl, box(949), box(278), NULL);
-  avl = gpr_avl_add(avl, box(548), box(279), NULL);
-  avl = gpr_avl_add(avl, box(951), box(280), NULL);
-  avl = remove_int(avl, 1018);
-  avl = remove_int(avl, 568);
-  avl = gpr_avl_add(avl, box(138), box(283), NULL);
-  avl = gpr_avl_add(avl, box(202), box(284), NULL);
-  avl = gpr_avl_add(avl, box(157), box(285), NULL);
-  avl = gpr_avl_add(avl, box(264), box(286), NULL);
-  avl = gpr_avl_add(avl, box(370), box(287), NULL);
-  avl = remove_int(avl, 736);
-  avl = remove_int(avl, 751);
-  avl = remove_int(avl, 506);
-  avl = remove_int(avl, 81);
-  avl = remove_int(avl, 358);
-  avl = remove_int(avl, 657);
-  avl = remove_int(avl, 86);
-  avl = gpr_avl_add(avl, box(876), box(295), NULL);
-  avl = remove_int(avl, 354);
-  avl = gpr_avl_add(avl, box(134), box(297), NULL);
-  avl = remove_int(avl, 781);
-  avl = remove_int(avl, 183);
-  avl = gpr_avl_add(avl, box(914), box(300), NULL);
-  avl = remove_int(avl, 926);
-  avl = remove_int(avl, 398);
-  avl = remove_int(avl, 932);
-  avl = remove_int(avl, 804);
-  avl = remove_int(avl, 326);
-  avl = gpr_avl_add(avl, box(208), box(306), NULL);
-  avl = gpr_avl_add(avl, box(699), box(307), NULL);
-  avl = remove_int(avl, 576);
-  avl = remove_int(avl, 850);
-  avl = remove_int(avl, 514);
-  avl = remove_int(avl, 676);
-  avl = remove_int(avl, 549);
-  avl = remove_int(avl, 767);
-  avl = gpr_avl_add(avl, box(58), box(314), NULL);
-  avl = gpr_avl_add(avl, box(265), box(315), NULL);
-  avl = gpr_avl_add(avl, box(268), box(316), NULL);
-  avl = gpr_avl_add(avl, box(103), box(317), NULL);
-  avl = gpr_avl_add(avl, box(440), box(318), NULL);
-  avl = remove_int(avl, 777);
-  avl = gpr_avl_add(avl, box(670), box(320), NULL);
-  avl = remove_int(avl, 506);
-  avl = remove_int(avl, 487);
-  avl = gpr_avl_add(avl, box(421), box(323), NULL);
-  avl = remove_int(avl, 514);
-  avl = gpr_avl_add(avl, box(701), box(325), NULL);
-  avl = remove_int(avl, 949);
-  avl = remove_int(avl, 872);
-  avl = remove_int(avl, 139);
-  avl = gpr_avl_add(avl, box(781), box(329), NULL);
-  avl = gpr_avl_add(avl, box(543), box(330), NULL);
-  avl = gpr_avl_add(avl, box(147), box(331), NULL);
-  avl = remove_int(avl, 190);
-  avl = gpr_avl_add(avl, box(453), box(333), NULL);
-  avl = remove_int(avl, 262);
-  avl = remove_int(avl, 850);
-  avl = remove_int(avl, 286);
-  avl = remove_int(avl, 787);
-  avl = gpr_avl_add(avl, box(514), box(338), NULL);
-  avl = remove_int(avl, 812);
-  avl = gpr_avl_add(avl, box(431), box(340), NULL);
-  avl = gpr_avl_add(avl, box(8), box(341), NULL);
-  avl = remove_int(avl, 843);
-  avl = gpr_avl_add(avl, box(831), box(343), NULL);
-  avl = remove_int(avl, 472);
-  avl = remove_int(avl, 157);
-  avl = gpr_avl_add(avl, box(612), box(346), NULL);
-  avl = gpr_avl_add(avl, box(802), box(347), NULL);
-  avl = remove_int(avl, 554);
-  avl = gpr_avl_add(avl, box(409), box(349), NULL);
-  avl = gpr_avl_add(avl, box(439), box(350), NULL);
-  avl = gpr_avl_add(avl, box(725), box(351), NULL);
-  avl = gpr_avl_add(avl, box(568), box(352), NULL);
-  avl = remove_int(avl, 475);
-  avl = remove_int(avl, 672);
-  avl = remove_int(avl, 62);
-  avl = remove_int(avl, 753);
-  avl = gpr_avl_add(avl, box(435), box(357), NULL);
-  avl = gpr_avl_add(avl, box(950), box(358), NULL);
-  avl = gpr_avl_add(avl, box(532), box(359), NULL);
-  avl = gpr_avl_add(avl, box(832), box(360), NULL);
-  avl = remove_int(avl, 390);
-  avl = gpr_avl_add(avl, box(993), box(362), NULL);
-  avl = remove_int(avl, 198);
-  avl = remove_int(avl, 401);
-  avl = gpr_avl_add(avl, box(316), box(365), NULL);
-  avl = remove_int(avl, 843);
-  avl = gpr_avl_add(avl, box(541), box(367), NULL);
-  avl = gpr_avl_add(avl, box(505), box(368), NULL);
-  avl = remove_int(avl, 445);
-  avl = remove_int(avl, 256);
-  avl = gpr_avl_add(avl, box(232), box(371), NULL);
-  avl = remove_int(avl, 577);
-  avl = remove_int(avl, 558);
-  avl = gpr_avl_add(avl, box(910), box(374), NULL);
-  avl = remove_int(avl, 902);
-  avl = remove_int(avl, 755);
-  avl = remove_int(avl, 114);
-  avl = remove_int(avl, 438);
-  avl = remove_int(avl, 224);
-  avl = gpr_avl_add(avl, box(920), box(380), NULL);
-  avl = gpr_avl_add(avl, box(655), box(381), NULL);
-  avl = remove_int(avl, 557);
-  avl = remove_int(avl, 102);
-  avl = remove_int(avl, 165);
-  avl = gpr_avl_add(avl, box(191), box(385), NULL);
-  avl = remove_int(avl, 30);
-  avl = gpr_avl_add(avl, box(406), box(387), NULL);
-  avl = gpr_avl_add(avl, box(66), box(388), NULL);
-  avl = gpr_avl_add(avl, box(87), box(389), NULL);
-  avl = remove_int(avl, 7);
-  avl = remove_int(avl, 671);
-  avl = gpr_avl_add(avl, box(234), box(392), NULL);
-  avl = remove_int(avl, 463);
-  avl = gpr_avl_add(avl, box(75), box(394), NULL);
-  avl = gpr_avl_add(avl, box(487), box(395), NULL);
-  avl = remove_int(avl, 203);
-  avl = gpr_avl_add(avl, box(711), box(397), NULL);
-  avl = remove_int(avl, 291);
-  avl = remove_int(avl, 798);
-  avl = remove_int(avl, 337);
-  avl = gpr_avl_add(avl, box(877), box(401), NULL);
-  avl = gpr_avl_add(avl, box(388), box(402), NULL);
-  avl = remove_int(avl, 975);
-  avl = gpr_avl_add(avl, box(200), box(404), NULL);
-  avl = gpr_avl_add(avl, box(408), box(405), NULL);
-  avl = gpr_avl_add(avl, box(3), box(406), NULL);
-  avl = gpr_avl_add(avl, box(971), box(407), NULL);
-  avl = remove_int(avl, 841);
-  avl = remove_int(avl, 910);
-  avl = remove_int(avl, 74);
-  avl = remove_int(avl, 888);
-  avl = gpr_avl_add(avl, box(492), box(412), NULL);
-  avl = remove_int(avl, 14);
-  avl = remove_int(avl, 364);
-  avl = gpr_avl_add(avl, box(215), box(415), NULL);
-  avl = remove_int(avl, 778);
-  avl = remove_int(avl, 45);
-  avl = gpr_avl_add(avl, box(328), box(418), NULL);
-  avl = gpr_avl_add(avl, box(597), box(419), NULL);
-  avl = remove_int(avl, 34);
-  avl = gpr_avl_add(avl, box(736), box(421), NULL);
-  avl = remove_int(avl, 37);
-  avl = gpr_avl_add(avl, box(275), box(423), NULL);
-  avl = gpr_avl_add(avl, box(70), box(424), NULL);
-  avl = gpr_avl_add(avl, box(771), box(425), NULL);
-  avl = remove_int(avl, 536);
-  avl = remove_int(avl, 421);
-  avl = gpr_avl_add(avl, box(186), box(428), NULL);
-  avl = gpr_avl_add(avl, box(788), box(429), NULL);
-  avl = gpr_avl_add(avl, box(224), box(430), NULL);
-  avl = remove_int(avl, 228);
-  avl = gpr_avl_add(avl, box(48), box(432), NULL);
-  avl = gpr_avl_add(avl, box(120), box(433), NULL);
-  avl = gpr_avl_add(avl, box(269), box(434), NULL);
-  avl = gpr_avl_add(avl, box(904), box(435), NULL);
-  avl = remove_int(avl, 699);
-  avl = gpr_avl_add(avl, box(340), box(437), NULL);
-  avl = remove_int(avl, 276);
-  avl = gpr_avl_add(avl, box(591), box(439), NULL);
-  avl = gpr_avl_add(avl, box(778), box(440), NULL);
-  avl = remove_int(avl, 490);
-  avl = remove_int(avl, 973);
-  avl = gpr_avl_add(avl, box(294), box(443), NULL);
-  avl = gpr_avl_add(avl, box(323), box(444), NULL);
-  avl = remove_int(avl, 685);
-  avl = gpr_avl_add(avl, box(38), box(446), NULL);
-  avl = gpr_avl_add(avl, box(525), box(447), NULL);
-  avl = remove_int(avl, 162);
-  avl = gpr_avl_add(avl, box(462), box(449), NULL);
-  avl = gpr_avl_add(avl, box(340), box(450), NULL);
-  avl = remove_int(avl, 734);
-  avl = remove_int(avl, 959);
-  avl = gpr_avl_add(avl, box(752), box(453), NULL);
-  avl = gpr_avl_add(avl, box(667), box(454), NULL);
-  avl = remove_int(avl, 558);
-  avl = remove_int(avl, 657);
-  avl = gpr_avl_add(avl, box(711), box(457), NULL);
-  avl = remove_int(avl, 937);
-  avl = gpr_avl_add(avl, box(741), box(459), NULL);
-  avl = gpr_avl_add(avl, box(40), box(460), NULL);
-  avl = remove_int(avl, 784);
-  avl = gpr_avl_add(avl, box(292), box(462), NULL);
-  avl = remove_int(avl, 164);
-  avl = remove_int(avl, 931);
-  avl = remove_int(avl, 886);
-  avl = gpr_avl_add(avl, box(968), box(466), NULL);
-  avl = remove_int(avl, 263);
-  avl = gpr_avl_add(avl, box(647), box(468), NULL);
-  avl = gpr_avl_add(avl, box(92), box(469), NULL);
-  avl = remove_int(avl, 310);
-  avl = gpr_avl_add(avl, box(711), box(471), NULL);
-  avl = gpr_avl_add(avl, box(675), box(472), NULL);
-  avl = remove_int(avl, 549);
-  avl = gpr_avl_add(avl, box(380), box(474), NULL);
-  avl = remove_int(avl, 825);
-  avl = gpr_avl_add(avl, box(668), box(476), NULL);
-  avl = remove_int(avl, 498);
-  avl = gpr_avl_add(avl, box(870), box(478), NULL);
-  avl = gpr_avl_add(avl, box(391), box(479), NULL);
-  avl = gpr_avl_add(avl, box(264), box(480), NULL);
-  avl = remove_int(avl, 1);
-  avl = remove_int(avl, 849);
-  avl = remove_int(avl, 88);
-  avl = remove_int(avl, 255);
-  avl = remove_int(avl, 763);
-  avl = remove_int(avl, 831);
-  avl = gpr_avl_add(avl, box(508), box(487), NULL);
-  avl = remove_int(avl, 849);
-  avl = remove_int(avl, 47);
-  avl = gpr_avl_add(avl, box(299), box(490), NULL);
-  avl = remove_int(avl, 625);
-  avl = remove_int(avl, 433);
-  avl = remove_int(avl, 904);
-  avl = remove_int(avl, 761);
-  avl = gpr_avl_add(avl, box(33), box(495), NULL);
-  avl = gpr_avl_add(avl, box(524), box(496), NULL);
-  avl = remove_int(avl, 210);
-  avl = remove_int(avl, 299);
-  avl = gpr_avl_add(avl, box(823), box(499), NULL);
-  avl = remove_int(avl, 479);
-  avl = remove_int(avl, 96);
-  avl = remove_int(avl, 1013);
-  avl = gpr_avl_add(avl, box(768), box(503), NULL);
-  avl = remove_int(avl, 638);
-  avl = remove_int(avl, 20);
-  avl = gpr_avl_add(avl, box(663), box(506), NULL);
-  avl = remove_int(avl, 882);
-  avl = gpr_avl_add(avl, box(745), box(508), NULL);
-  avl = remove_int(avl, 352);
-  avl = gpr_avl_add(avl, box(10), box(510), NULL);
-  avl = remove_int(avl, 484);
-  avl = gpr_avl_add(avl, box(420), box(512), NULL);
-  avl = gpr_avl_add(avl, box(884), box(513), NULL);
-  avl = gpr_avl_add(avl, box(993), box(514), NULL);
-  avl = gpr_avl_add(avl, box(251), box(515), NULL);
-  avl = remove_int(avl, 222);
-  avl = gpr_avl_add(avl, box(734), box(517), NULL);
-  avl = gpr_avl_add(avl, box(952), box(518), NULL);
-  avl = remove_int(avl, 26);
-  avl = remove_int(avl, 270);
-  avl = remove_int(avl, 481);
-  avl = remove_int(avl, 693);
-  avl = remove_int(avl, 1006);
-  avl = gpr_avl_add(avl, box(77), box(524), NULL);
-  avl = remove_int(avl, 897);
-  avl = gpr_avl_add(avl, box(719), box(526), NULL);
-  avl = gpr_avl_add(avl, box(622), box(527), NULL);
-  avl = remove_int(avl, 28);
-  avl = remove_int(avl, 836);
-  avl = remove_int(avl, 142);
-  avl = gpr_avl_add(avl, box(445), box(531), NULL);
-  avl = gpr_avl_add(avl, box(410), box(532), NULL);
-  avl = remove_int(avl, 575);
-  avl = gpr_avl_add(avl, box(634), box(534), NULL);
-  avl = gpr_avl_add(avl, box(906), box(535), NULL);
-  avl = remove_int(avl, 649);
-  avl = gpr_avl_add(avl, box(813), box(537), NULL);
-  avl = remove_int(avl, 702);
-  avl = remove_int(avl, 732);
-  avl = gpr_avl_add(avl, box(105), box(540), NULL);
-  avl = gpr_avl_add(avl, box(867), box(541), NULL);
-  avl = remove_int(avl, 964);
-  avl = remove_int(avl, 941);
-  avl = gpr_avl_add(avl, box(947), box(544), NULL);
-  avl = remove_int(avl, 990);
-  avl = gpr_avl_add(avl, box(816), box(546), NULL);
-  avl = remove_int(avl, 429);
-  avl = remove_int(avl, 567);
-  avl = remove_int(avl, 541);
-  avl = remove_int(avl, 583);
-  avl = gpr_avl_add(avl, box(57), box(551), NULL);
-  avl = gpr_avl_add(avl, box(786), box(552), NULL);
-  avl = gpr_avl_add(avl, box(526), box(553), NULL);
-  avl = remove_int(avl, 642);
-  avl = remove_int(avl, 220);
-  avl = remove_int(avl, 840);
-  avl = remove_int(avl, 548);
-  avl = gpr_avl_add(avl, box(528), box(558), NULL);
-  avl = gpr_avl_add(avl, box(749), box(559), NULL);
-  avl = gpr_avl_add(avl, box(194), box(560), NULL);
-  avl = remove_int(avl, 517);
-  avl = gpr_avl_add(avl, box(102), box(562), NULL);
-  avl = remove_int(avl, 189);
-  avl = gpr_avl_add(avl, box(927), box(564), NULL);
-  avl = remove_int(avl, 846);
-  avl = remove_int(avl, 130);
-  avl = gpr_avl_add(avl, box(694), box(567), NULL);
-  avl = remove_int(avl, 750);
-  avl = gpr_avl_add(avl, box(357), box(569), NULL);
-  avl = remove_int(avl, 431);
-  avl = remove_int(avl, 91);
-  avl = gpr_avl_add(avl, box(640), box(572), NULL);
-  avl = remove_int(avl, 4);
-  avl = gpr_avl_add(avl, box(81), box(574), NULL);
-  avl = gpr_avl_add(avl, box(595), box(575), NULL);
-  avl = remove_int(avl, 444);
-  avl = remove_int(avl, 262);
-  avl = remove_int(avl, 11);
-  avl = gpr_avl_add(avl, box(192), box(579), NULL);
-  avl = gpr_avl_add(avl, box(158), box(580), NULL);
-  avl = remove_int(avl, 401);
-  avl = remove_int(avl, 918);
-  avl = gpr_avl_add(avl, box(180), box(583), NULL);
-  avl = remove_int(avl, 268);
-  avl = gpr_avl_add(avl, box(1012), box(585), NULL);
-  avl = gpr_avl_add(avl, box(90), box(586), NULL);
-  avl = gpr_avl_add(avl, box(946), box(587), NULL);
-  avl = remove_int(avl, 719);
-  avl = gpr_avl_add(avl, box(874), box(589), NULL);
-  avl = gpr_avl_add(avl, box(679), box(590), NULL);
-  avl = remove_int(avl, 53);
-  avl = remove_int(avl, 534);
-  avl = gpr_avl_add(avl, box(646), box(593), NULL);
-  avl = gpr_avl_add(avl, box(767), box(594), NULL);
-  avl = gpr_avl_add(avl, box(460), box(595), NULL);
-  avl = gpr_avl_add(avl, box(852), box(596), NULL);
-  avl = gpr_avl_add(avl, box(189), box(597), NULL);
-  avl = remove_int(avl, 932);
-  avl = remove_int(avl, 366);
-  avl = remove_int(avl, 907);
-  avl = gpr_avl_add(avl, box(875), box(601), NULL);
-  avl = gpr_avl_add(avl, box(434), box(602), NULL);
-  avl = gpr_avl_add(avl, box(704), box(603), NULL);
-  avl = gpr_avl_add(avl, box(724), box(604), NULL);
-  avl = gpr_avl_add(avl, box(930), box(605), NULL);
-  avl = gpr_avl_add(avl, box(1000), box(606), NULL);
-  avl = remove_int(avl, 479);
-  avl = gpr_avl_add(avl, box(275), box(608), NULL);
-  avl = remove_int(avl, 32);
-  avl = gpr_avl_add(avl, box(939), box(610), NULL);
-  avl = remove_int(avl, 943);
-  avl = remove_int(avl, 329);
-  avl = gpr_avl_add(avl, box(490), box(613), NULL);
-  avl = remove_int(avl, 477);
-  avl = remove_int(avl, 414);
-  avl = remove_int(avl, 187);
-  avl = remove_int(avl, 334);
-  avl = gpr_avl_add(avl, box(40), box(618), NULL);
-  avl = remove_int(avl, 751);
-  avl = gpr_avl_add(avl, box(568), box(620), NULL);
-  avl = gpr_avl_add(avl, box(120), box(621), NULL);
-  avl = gpr_avl_add(avl, box(617), box(622), NULL);
-  avl = gpr_avl_add(avl, box(32), box(623), NULL);
-  avl = remove_int(avl, 701);
-  avl = gpr_avl_add(avl, box(910), box(625), NULL);
-  avl = remove_int(avl, 557);
-  avl = remove_int(avl, 361);
-  avl = remove_int(avl, 937);
-  avl = remove_int(avl, 100);
-  avl = remove_int(avl, 684);
-  avl = gpr_avl_add(avl, box(751), box(631), NULL);
-  avl = remove_int(avl, 781);
-  avl = remove_int(avl, 469);
-  avl = remove_int(avl, 75);
-  avl = remove_int(avl, 561);
-  avl = gpr_avl_add(avl, box(854), box(636), NULL);
-  avl = remove_int(avl, 164);
-  avl = remove_int(avl, 258);
-  avl = remove_int(avl, 315);
-  avl = remove_int(avl, 261);
-  avl = gpr_avl_add(avl, box(552), box(641), NULL);
-  avl = gpr_avl_add(avl, box(6), box(642), NULL);
-  avl = gpr_avl_add(avl, box(680), box(643), NULL);
-  avl = remove_int(avl, 741);
-  avl = remove_int(avl, 309);
-  avl = remove_int(avl, 272);
-  avl = gpr_avl_add(avl, box(249), box(647), NULL);
-  avl = remove_int(avl, 97);
-  avl = remove_int(avl, 850);
-  avl = gpr_avl_add(avl, box(915), box(650), NULL);
-  avl = gpr_avl_add(avl, box(816), box(651), NULL);
-  avl = gpr_avl_add(avl, box(45), box(652), NULL);
-  avl = gpr_avl_add(avl, box(168), box(653), NULL);
-  avl = remove_int(avl, 153);
-  avl = remove_int(avl, 239);
-  avl = gpr_avl_add(avl, box(684), box(656), NULL);
-  avl = gpr_avl_add(avl, box(208), box(657), NULL);
-  avl = gpr_avl_add(avl, box(681), box(658), NULL);
-  avl = gpr_avl_add(avl, box(609), box(659), NULL);
-  avl = gpr_avl_add(avl, box(645), box(660), NULL);
-  avl = remove_int(avl, 799);
-  avl = gpr_avl_add(avl, box(955), box(662), NULL);
-  avl = gpr_avl_add(avl, box(946), box(663), NULL);
-  avl = gpr_avl_add(avl, box(744), box(664), NULL);
-  avl = gpr_avl_add(avl, box(201), box(665), NULL);
-  avl = gpr_avl_add(avl, box(136), box(666), NULL);
-  avl = remove_int(avl, 357);
-  avl = gpr_avl_add(avl, box(974), box(668), NULL);
-  avl = remove_int(avl, 485);
-  avl = gpr_avl_add(avl, box(1009), box(670), NULL);
-  avl = gpr_avl_add(avl, box(517), box(671), NULL);
-  avl = remove_int(avl, 491);
-  avl = gpr_avl_add(avl, box(336), box(673), NULL);
-  avl = gpr_avl_add(avl, box(589), box(674), NULL);
-  avl = remove_int(avl, 546);
-  avl = remove_int(avl, 840);
-  avl = remove_int(avl, 104);
-  avl = remove_int(avl, 347);
-  avl = gpr_avl_add(avl, box(801), box(679), NULL);
-  avl = remove_int(avl, 799);
-  avl = remove_int(avl, 702);
-  avl = remove_int(avl, 996);
-  avl = remove_int(avl, 93);
-  avl = gpr_avl_add(avl, box(561), box(684), NULL);
-  avl = gpr_avl_add(avl, box(25), box(685), NULL);
-  avl = remove_int(avl, 278);
-  avl = gpr_avl_add(avl, box(191), box(687), NULL);
-  avl = remove_int(avl, 243);
-  avl = remove_int(avl, 918);
-  avl = remove_int(avl, 449);
-  avl = gpr_avl_add(avl, box(19), box(691), NULL);
-  avl = gpr_avl_add(avl, box(762), box(692), NULL);
-  avl = gpr_avl_add(avl, box(13), box(693), NULL);
-  avl = gpr_avl_add(avl, box(151), box(694), NULL);
-  avl = gpr_avl_add(avl, box(152), box(695), NULL);
-  avl = gpr_avl_add(avl, box(793), box(696), NULL);
-  avl = remove_int(avl, 862);
-  avl = remove_int(avl, 890);
-  avl = gpr_avl_add(avl, box(687), box(699), NULL);
-  avl = gpr_avl_add(avl, box(509), box(700), NULL);
-  avl = gpr_avl_add(avl, box(973), box(701), NULL);
-  avl = remove_int(avl, 230);
-  avl = gpr_avl_add(avl, box(532), box(703), NULL);
-  avl = remove_int(avl, 668);
-  avl = gpr_avl_add(avl, box(281), box(705), NULL);
-  avl = gpr_avl_add(avl, box(867), box(706), NULL);
-  avl = gpr_avl_add(avl, box(359), box(707), NULL);
-  avl = remove_int(avl, 425);
-  avl = gpr_avl_add(avl, box(691), box(709), NULL);
-  avl = gpr_avl_add(avl, box(163), box(710), NULL);
-  avl = gpr_avl_add(avl, box(502), box(711), NULL);
-  avl = remove_int(avl, 674);
-  avl = gpr_avl_add(avl, box(697), box(713), NULL);
-  avl = remove_int(avl, 271);
-  avl = gpr_avl_add(avl, box(968), box(715), NULL);
-  avl = gpr_avl_add(avl, box(48), box(716), NULL);
-  avl = remove_int(avl, 543);
-  avl = gpr_avl_add(avl, box(35), box(718), NULL);
-  avl = gpr_avl_add(avl, box(751), box(719), NULL);
-  avl = gpr_avl_add(avl, box(478), box(720), NULL);
-  avl = remove_int(avl, 797);
-  avl = remove_int(avl, 309);
-  avl = gpr_avl_add(avl, box(927), box(723), NULL);
-  avl = remove_int(avl, 504);
-  avl = gpr_avl_add(avl, box(286), box(725), NULL);
-  avl = gpr_avl_add(avl, box(413), box(726), NULL);
-  avl = gpr_avl_add(avl, box(599), box(727), NULL);
-  avl = remove_int(avl, 105);
-  avl = remove_int(avl, 605);
-  avl = gpr_avl_add(avl, box(632), box(730), NULL);
-  avl = gpr_avl_add(avl, box(133), box(731), NULL);
-  avl = remove_int(avl, 443);
-  avl = gpr_avl_add(avl, box(958), box(733), NULL);
-  avl = gpr_avl_add(avl, box(729), box(734), NULL);
-  avl = remove_int(avl, 158);
-  avl = gpr_avl_add(avl, box(694), box(736), NULL);
-  avl = gpr_avl_add(avl, box(505), box(737), NULL);
-  avl = remove_int(avl, 63);
-  avl = remove_int(avl, 714);
-  avl = gpr_avl_add(avl, box(1002), box(740), NULL);
-  avl = remove_int(avl, 211);
-  avl = gpr_avl_add(avl, box(765), box(742), NULL);
-  avl = gpr_avl_add(avl, box(455), box(743), NULL);
-  avl = remove_int(avl, 59);
-  avl = remove_int(avl, 224);
-  avl = gpr_avl_add(avl, box(586), box(746), NULL);
-  avl = gpr_avl_add(avl, box(348), box(747), NULL);
-  avl = remove_int(avl, 10);
-  avl = remove_int(avl, 484);
-  avl = gpr_avl_add(avl, box(968), box(750), NULL);
-  avl = gpr_avl_add(avl, box(923), box(751), NULL);
-  avl = remove_int(avl, 573);
-  avl = remove_int(avl, 617);
-  avl = gpr_avl_add(avl, box(812), box(754), NULL);
-  avl = gpr_avl_add(avl, box(179), box(755), NULL);
-  avl = remove_int(avl, 284);
-  avl = remove_int(avl, 157);
-  avl = remove_int(avl, 177);
-  avl = remove_int(avl, 896);
-  avl = gpr_avl_add(avl, box(649), box(760), NULL);
-  avl = gpr_avl_add(avl, box(927), box(761), NULL);
-  avl = gpr_avl_add(avl, box(454), box(762), NULL);
-  avl = gpr_avl_add(avl, box(217), box(763), NULL);
-  avl = remove_int(avl, 534);
-  avl = gpr_avl_add(avl, box(180), box(765), NULL);
-  avl = gpr_avl_add(avl, box(319), box(766), NULL);
-  avl = remove_int(avl, 92);
-  avl = gpr_avl_add(avl, box(483), box(768), NULL);
-  avl = remove_int(avl, 504);
-  avl = remove_int(avl, 1017);
-  avl = remove_int(avl, 37);
-  avl = remove_int(avl, 50);
-  avl = gpr_avl_add(avl, box(302), box(773), NULL);
-  avl = remove_int(avl, 807);
-  avl = gpr_avl_add(avl, box(463), box(775), NULL);
-  avl = gpr_avl_add(avl, box(271), box(776), NULL);
-  avl = gpr_avl_add(avl, box(644), box(777), NULL);
-  avl = remove_int(avl, 618);
-  avl = gpr_avl_add(avl, box(166), box(779), NULL);
-  avl = gpr_avl_add(avl, box(538), box(780), NULL);
-  avl = remove_int(avl, 606);
-  avl = gpr_avl_add(avl, box(425), box(782), NULL);
-  avl = remove_int(avl, 725);
-  avl = remove_int(avl, 383);
-  avl = gpr_avl_add(avl, box(155), box(785), NULL);
-  avl = remove_int(avl, 889);
-  avl = gpr_avl_add(avl, box(653), box(787), NULL);
-  avl = remove_int(avl, 386);
-  avl = gpr_avl_add(avl, box(142), box(789), NULL);
-  avl = remove_int(avl, 107);
-  avl = remove_int(avl, 603);
-  avl = remove_int(avl, 971);
-  avl = gpr_avl_add(avl, box(80), box(793), NULL);
-  avl = gpr_avl_add(avl, box(61), box(794), NULL);
-  avl = gpr_avl_add(avl, box(693), box(795), NULL);
-  avl = gpr_avl_add(avl, box(592), box(796), NULL);
-  avl = gpr_avl_add(avl, box(433), box(797), NULL);
-  avl = gpr_avl_add(avl, box(973), box(798), NULL);
-  avl = remove_int(avl, 901);
-  avl = remove_int(avl, 340);
-  avl = remove_int(avl, 709);
-  avl = gpr_avl_add(avl, box(224), box(802), NULL);
-  avl = remove_int(avl, 120);
-  avl = remove_int(avl, 271);
-  avl = gpr_avl_add(avl, box(780), box(805), NULL);
-  avl = gpr_avl_add(avl, box(867), box(806), NULL);
-  avl = gpr_avl_add(avl, box(756), box(807), NULL);
-  avl = gpr_avl_add(avl, box(583), box(808), NULL);
-  avl = gpr_avl_add(avl, box(356), box(809), NULL);
-  avl = gpr_avl_add(avl, box(58), box(810), NULL);
-  avl = remove_int(avl, 219);
-  avl = gpr_avl_add(avl, box(301), box(812), NULL);
-  avl = remove_int(avl, 643);
-  avl = remove_int(avl, 787);
-  avl = remove_int(avl, 583);
-  avl = remove_int(avl, 552);
-  avl = remove_int(avl, 308);
-  avl = remove_int(avl, 608);
-  avl = remove_int(avl, 363);
-  avl = remove_int(avl, 690);
-  avl = gpr_avl_add(avl, box(233), box(821), NULL);
-  avl = gpr_avl_add(avl, box(479), box(822), NULL);
-  avl = gpr_avl_add(avl, box(323), box(823), NULL);
-  avl = gpr_avl_add(avl, box(802), box(824), NULL);
-  avl = remove_int(avl, 682);
-  avl = remove_int(avl, 705);
-  avl = remove_int(avl, 487);
-  avl = gpr_avl_add(avl, box(530), box(828), NULL);
-  avl = gpr_avl_add(avl, box(232), box(829), NULL);
-  avl = remove_int(avl, 627);
-  avl = gpr_avl_add(avl, box(396), box(831), NULL);
-  avl = gpr_avl_add(avl, box(61), box(832), NULL);
-  avl = gpr_avl_add(avl, box(932), box(833), NULL);
-  avl = gpr_avl_add(avl, box(108), box(834), NULL);
-  avl = gpr_avl_add(avl, box(524), box(835), NULL);
-  avl = remove_int(avl, 390);
-  avl = remove_int(avl, 307);
-  avl = gpr_avl_add(avl, box(722), box(838), NULL);
-  avl = gpr_avl_add(avl, box(907), box(839), NULL);
-  avl = remove_int(avl, 286);
-  avl = remove_int(avl, 337);
-  avl = remove_int(avl, 443);
-  avl = gpr_avl_add(avl, box(973), box(843), NULL);
-  avl = remove_int(avl, 930);
-  avl = remove_int(avl, 242);
-  avl = gpr_avl_add(avl, box(997), box(846), NULL);
-  avl = gpr_avl_add(avl, box(689), box(847), NULL);
-  avl = remove_int(avl, 318);
-  avl = gpr_avl_add(avl, box(703), box(849), NULL);
-  avl = gpr_avl_add(avl, box(868), box(850), NULL);
-  avl = gpr_avl_add(avl, box(200), box(851), NULL);
-  avl = gpr_avl_add(avl, box(960), box(852), NULL);
-  avl = gpr_avl_add(avl, box(80), box(853), NULL);
-  avl = remove_int(avl, 113);
-  avl = gpr_avl_add(avl, box(135), box(855), NULL);
-  avl = remove_int(avl, 529);
-  avl = gpr_avl_add(avl, box(366), box(857), NULL);
-  avl = remove_int(avl, 272);
-  avl = gpr_avl_add(avl, box(921), box(859), NULL);
-  avl = remove_int(avl, 497);
-  avl = gpr_avl_add(avl, box(712), box(861), NULL);
-  avl = remove_int(avl, 777);
-  avl = remove_int(avl, 505);
-  avl = remove_int(avl, 974);
-  avl = remove_int(avl, 497);
-  avl = gpr_avl_add(avl, box(388), box(866), NULL);
-  avl = gpr_avl_add(avl, box(29), box(867), NULL);
-  avl = gpr_avl_add(avl, box(180), box(868), NULL);
-  avl = gpr_avl_add(avl, box(983), box(869), NULL);
-  avl = gpr_avl_add(avl, box(72), box(870), NULL);
-  avl = gpr_avl_add(avl, box(693), box(871), NULL);
-  avl = gpr_avl_add(avl, box(567), box(872), NULL);
-  avl = remove_int(avl, 549);
-  avl = remove_int(avl, 351);
-  avl = gpr_avl_add(avl, box(1019), box(875), NULL);
-  avl = remove_int(avl, 585);
-  avl = remove_int(avl, 294);
-  avl = remove_int(avl, 61);
-  avl = gpr_avl_add(avl, box(409), box(879), NULL);
-  avl = gpr_avl_add(avl, box(984), box(880), NULL);
-  avl = gpr_avl_add(avl, box(830), box(881), NULL);
-  avl = remove_int(avl, 579);
-  avl = gpr_avl_add(avl, box(672), box(883), NULL);
-  avl = remove_int(avl, 968);
-
-  gpr_avl_unref(avl, NULL);
-}
-
-static void test_badcase3(void) {
-  gpr_avl avl;
-
-  gpr_log(GPR_DEBUG, "test_badcase3");
-
-  avl = gpr_avl_create(&int_int_vtable);
-  avl = remove_int(avl, 624);
-  avl = gpr_avl_add(avl, box(59), box(2), NULL);
-  avl = gpr_avl_add(avl, box(494), box(3), NULL);
-  avl = gpr_avl_add(avl, box(226), box(4), NULL);
-  avl = remove_int(avl, 524);
-  avl = gpr_avl_add(avl, box(540), box(6), NULL);
-  avl = remove_int(avl, 1008);
-  avl = gpr_avl_add(avl, box(502), box(8), NULL);
-  avl = remove_int(avl, 267);
-  avl = remove_int(avl, 764);
-  avl = remove_int(avl, 443);
-  avl = gpr_avl_add(avl, box(8), box(12), NULL);
-  avl = remove_int(avl, 291);
-  avl = remove_int(avl, 796);
-  avl = remove_int(avl, 1002);
-  avl = gpr_avl_add(avl, box(778), box(16), NULL);
-  avl = remove_int(avl, 621);
-  avl = remove_int(avl, 891);
-  avl = remove_int(avl, 880);
-  avl = gpr_avl_add(avl, box(197), box(20), NULL);
-  avl = gpr_avl_add(avl, box(441), box(21), NULL);
-  avl = gpr_avl_add(avl, box(719), box(22), NULL);
-  avl = remove_int(avl, 109);
-  avl = gpr_avl_add(avl, box(458), box(24), NULL);
-  avl = remove_int(avl, 86);
-  avl = gpr_avl_add(avl, box(897), box(26), NULL);
-  avl = gpr_avl_add(avl, box(997), box(27), NULL);
-  avl = remove_int(avl, 235);
-  avl = remove_int(avl, 425);
-  avl = remove_int(avl, 186);
-  avl = gpr_avl_add(avl, box(887), box(31), NULL);
-  avl = gpr_avl_add(avl, box(1005), box(32), NULL);
-  avl = gpr_avl_add(avl, box(778), box(33), NULL);
-  avl = gpr_avl_add(avl, box(575), box(34), NULL);
-  avl = remove_int(avl, 966);
-  avl = remove_int(avl, 1015);
-  avl = gpr_avl_add(avl, box(486), box(37), NULL);
-  avl = gpr_avl_add(avl, box(809), box(38), NULL);
-  avl = gpr_avl_add(avl, box(907), box(39), NULL);
-  avl = gpr_avl_add(avl, box(971), box(40), NULL);
-  avl = remove_int(avl, 441);
-  avl = remove_int(avl, 498);
-  avl = gpr_avl_add(avl, box(727), box(43), NULL);
-  avl = remove_int(avl, 679);
-  avl = remove_int(avl, 740);
-  avl = remove_int(avl, 532);
-  avl = gpr_avl_add(avl, box(805), box(47), NULL);
-  avl = remove_int(avl, 64);
-  avl = gpr_avl_add(avl, box(362), box(49), NULL);
-  avl = gpr_avl_add(avl, box(170), box(50), NULL);
-  avl = gpr_avl_add(avl, box(389), box(51), NULL);
-  avl = gpr_avl_add(avl, box(689), box(52), NULL);
-  avl = remove_int(avl, 871);
-  avl = gpr_avl_add(avl, box(447), box(54), NULL);
-  avl = remove_int(avl, 718);
-  avl = gpr_avl_add(avl, box(724), box(56), NULL);
-  avl = remove_int(avl, 215);
-  avl = gpr_avl_add(avl, box(550), box(58), NULL);
-  avl = remove_int(avl, 932);
-  avl = gpr_avl_add(avl, box(47), box(60), NULL);
-  avl = remove_int(avl, 46);
-  avl = remove_int(avl, 229);
-  avl = gpr_avl_add(avl, box(68), box(63), NULL);
-  avl = gpr_avl_add(avl, box(387), box(64), NULL);
-  avl = remove_int(avl, 933);
-  avl = remove_int(avl, 736);
-  avl = remove_int(avl, 719);
-  avl = gpr_avl_add(avl, box(150), box(68), NULL);
-  avl = remove_int(avl, 875);
-  avl = remove_int(avl, 298);
-  avl = gpr_avl_add(avl, box(991), box(71), NULL);
-  avl = remove_int(avl, 705);
-  avl = gpr_avl_add(avl, box(197), box(73), NULL);
-  avl = gpr_avl_add(avl, box(101), box(74), NULL);
-  avl = remove_int(avl, 436);
-  avl = gpr_avl_add(avl, box(755), box(76), NULL);
-  avl = gpr_avl_add(avl, box(727), box(77), NULL);
-  avl = remove_int(avl, 309);
-  avl = remove_int(avl, 253);
-  avl = gpr_avl_add(avl, box(203), box(80), NULL);
-  avl = remove_int(avl, 231);
-  avl = gpr_avl_add(avl, box(461), box(82), NULL);
-  avl = remove_int(avl, 316);
-  avl = remove_int(avl, 493);
-  avl = gpr_avl_add(avl, box(184), box(85), NULL);
-  avl = remove_int(avl, 737);
-  avl = gpr_avl_add(avl, box(790), box(87), NULL);
-  avl = gpr_avl_add(avl, box(335), box(88), NULL);
-  avl = remove_int(avl, 649);
-  avl = gpr_avl_add(avl, box(69), box(90), NULL);
-  avl = remove_int(avl, 585);
-  avl = remove_int(avl, 543);
-  avl = gpr_avl_add(avl, box(784), box(93), NULL);
-  avl = gpr_avl_add(avl, box(60), box(94), NULL);
-  avl = gpr_avl_add(avl, box(525), box(95), NULL);
-  avl = gpr_avl_add(avl, box(177), box(96), NULL);
-  avl = gpr_avl_add(avl, box(178), box(97), NULL);
-  avl = gpr_avl_add(avl, box(683), box(98), NULL);
-  avl = gpr_avl_add(avl, box(226), box(99), NULL);
-  avl = gpr_avl_add(avl, box(662), box(100), NULL);
-  avl = remove_int(avl, 944);
-  avl = gpr_avl_add(avl, box(562), box(102), NULL);
-  avl = gpr_avl_add(avl, box(793), box(103), NULL);
-  avl = remove_int(avl, 673);
-  avl = gpr_avl_add(avl, box(310), box(105), NULL);
-  avl = remove_int(avl, 479);
-  avl = remove_int(avl, 543);
-  avl = remove_int(avl, 159);
-  avl = remove_int(avl, 850);
-  avl = gpr_avl_add(avl, box(318), box(110), NULL);
-  avl = gpr_avl_add(avl, box(483), box(111), NULL);
-  avl = gpr_avl_add(avl, box(84), box(112), NULL);
-  avl = remove_int(avl, 109);
-  avl = gpr_avl_add(avl, box(132), box(114), NULL);
-  avl = gpr_avl_add(avl, box(920), box(115), NULL);
-  avl = remove_int(avl, 746);
-  avl = gpr_avl_add(avl, box(145), box(117), NULL);
-  avl = gpr_avl_add(avl, box(526), box(118), NULL);
-  avl = remove_int(avl, 158);
-  avl = gpr_avl_add(avl, box(332), box(120), NULL);
-  avl = gpr_avl_add(avl, box(918), box(121), NULL);
-  avl = remove_int(avl, 339);
-  avl = gpr_avl_add(avl, box(809), box(123), NULL);
-  avl = gpr_avl_add(avl, box(742), box(124), NULL);
-  avl = gpr_avl_add(avl, box(718), box(125), NULL);
-  avl = remove_int(avl, 988);
-  avl = remove_int(avl, 531);
-  avl = remove_int(avl, 840);
-  avl = gpr_avl_add(avl, box(816), box(129), NULL);
-  avl = gpr_avl_add(avl, box(976), box(130), NULL);
-  avl = remove_int(avl, 743);
-  avl = remove_int(avl, 528);
-  avl = remove_int(avl, 982);
-  avl = gpr_avl_add(avl, box(803), box(134), NULL);
-  avl = gpr_avl_add(avl, box(205), box(135), NULL);
-  avl = gpr_avl_add(avl, box(584), box(136), NULL);
-  avl = remove_int(avl, 923);
-  avl = remove_int(avl, 538);
-  avl = remove_int(avl, 398);
-  avl = remove_int(avl, 320);
-  avl = remove_int(avl, 292);
-  avl = gpr_avl_add(avl, box(270), box(142), NULL);
-  avl = gpr_avl_add(avl, box(333), box(143), NULL);
-  avl = remove_int(avl, 439);
-  avl = gpr_avl_add(avl, box(35), box(145), NULL);
-  avl = gpr_avl_add(avl, box(837), box(146), NULL);
-  avl = remove_int(avl, 65);
-  avl = remove_int(avl, 642);
-  avl = remove_int(avl, 371);
-  avl = remove_int(avl, 140);
-  avl = remove_int(avl, 533);
-  avl = remove_int(avl, 676);
-  avl = gpr_avl_add(avl, box(624), box(153), NULL);
-  avl = gpr_avl_add(avl, box(116), box(154), NULL);
-  avl = gpr_avl_add(avl, box(446), box(155), NULL);
-  avl = remove_int(avl, 91);
-  avl = remove_int(avl, 721);
-  avl = remove_int(avl, 537);
-  avl = gpr_avl_add(avl, box(448), box(159), NULL);
-  avl = remove_int(avl, 155);
-  avl = remove_int(avl, 344);
-  avl = remove_int(avl, 237);
-  avl = gpr_avl_add(avl, box(309), box(163), NULL);
-  avl = gpr_avl_add(avl, box(434), box(164), NULL);
-  avl = gpr_avl_add(avl, box(277), box(165), NULL);
-  avl = remove_int(avl, 233);
-  avl = gpr_avl_add(avl, box(275), box(167), NULL);
-  avl = gpr_avl_add(avl, box(218), box(168), NULL);
-  avl = gpr_avl_add(avl, box(76), box(169), NULL);
-  avl = gpr_avl_add(avl, box(898), box(170), NULL);
-  avl = remove_int(avl, 771);
-  avl = gpr_avl_add(avl, box(237), box(172), NULL);
-  avl = remove_int(avl, 327);
-  avl = gpr_avl_add(avl, box(499), box(174), NULL);
-  avl = remove_int(avl, 727);
-  avl = remove_int(avl, 234);
-  avl = remove_int(avl, 623);
-  avl = remove_int(avl, 458);
-  avl = remove_int(avl, 326);
-  avl = remove_int(avl, 589);
-  avl = gpr_avl_add(avl, box(442), box(181), NULL);
-  avl = remove_int(avl, 389);
-  avl = gpr_avl_add(avl, box(708), box(183), NULL);
-  avl = gpr_avl_add(avl, box(594), box(184), NULL);
-  avl = gpr_avl_add(avl, box(942), box(185), NULL);
-  avl = gpr_avl_add(avl, box(282), box(186), NULL);
-  avl = remove_int(avl, 434);
-  avl = remove_int(avl, 134);
-  avl = remove_int(avl, 270);
-  avl = remove_int(avl, 512);
-  avl = remove_int(avl, 265);
-  avl = remove_int(avl, 21);
-  avl = remove_int(avl, 193);
-  avl = remove_int(avl, 797);
-  avl = remove_int(avl, 347);
-  avl = gpr_avl_add(avl, box(99), box(196), NULL);
-  avl = gpr_avl_add(avl, box(161), box(197), NULL);
-  avl = remove_int(avl, 484);
-  avl = gpr_avl_add(avl, box(72), box(199), NULL);
-  avl = remove_int(avl, 629);
-  avl = gpr_avl_add(avl, box(522), box(201), NULL);
-  avl = remove_int(avl, 679);
-  avl = gpr_avl_add(avl, box(407), box(203), NULL);
-  avl = remove_int(avl, 693);
-  avl = gpr_avl_add(avl, box(424), box(205), NULL);
-  avl = gpr_avl_add(avl, box(651), box(206), NULL);
-  avl = gpr_avl_add(avl, box(927), box(207), NULL);
-  avl = remove_int(avl, 553);
-  avl = gpr_avl_add(avl, box(128), box(209), NULL);
-  avl = gpr_avl_add(avl, box(616), box(210), NULL);
-  avl = gpr_avl_add(avl, box(690), box(211), NULL);
-  avl = remove_int(avl, 241);
-  avl = remove_int(avl, 179);
-  avl = gpr_avl_add(avl, box(697), box(214), NULL);
-  avl = remove_int(avl, 779);
-  avl = gpr_avl_add(avl, box(241), box(216), NULL);
-  avl = remove_int(avl, 190);
-  avl = remove_int(avl, 210);
-  avl = gpr_avl_add(avl, box(711), box(219), NULL);
-  avl = remove_int(avl, 251);
-  avl = remove_int(avl, 61);
-  avl = gpr_avl_add(avl, box(800), box(222), NULL);
-  avl = remove_int(avl, 551);
-  avl = gpr_avl_add(avl, box(61), box(224), NULL);
-  avl = gpr_avl_add(avl, box(656), box(225), NULL);
-  avl = remove_int(avl, 130);
-  avl = remove_int(avl, 368);
-  avl = remove_int(avl, 150);
-  avl = remove_int(avl, 73);
-  avl = gpr_avl_add(avl, box(799), box(230), NULL);
-  avl = gpr_avl_add(avl, box(125), box(231), NULL);
-  avl = remove_int(avl, 107);
-  avl = gpr_avl_add(avl, box(938), box(233), NULL);
-  avl = gpr_avl_add(avl, box(914), box(234), NULL);
-  avl = gpr_avl_add(avl, box(197), box(235), NULL);
-  avl = remove_int(avl, 736);
-  avl = gpr_avl_add(avl, box(20), box(237), NULL);
-  avl = remove_int(avl, 224);
-  avl = remove_int(avl, 841);
-  avl = gpr_avl_add(avl, box(226), box(240), NULL);
-  avl = remove_int(avl, 963);
-  avl = remove_int(avl, 796);
-  avl = remove_int(avl, 728);
-  avl = gpr_avl_add(avl, box(855), box(244), NULL);
-  avl = gpr_avl_add(avl, box(769), box(245), NULL);
-  avl = gpr_avl_add(avl, box(631), box(246), NULL);
-  avl = remove_int(avl, 648);
-  avl = gpr_avl_add(avl, box(187), box(248), NULL);
-  avl = gpr_avl_add(avl, box(31), box(249), NULL);
-  avl = remove_int(avl, 163);
-  avl = gpr_avl_add(avl, box(218), box(251), NULL);
-  avl = gpr_avl_add(avl, box(488), box(252), NULL);
-  avl = gpr_avl_add(avl, box(387), box(253), NULL);
-  avl = gpr_avl_add(avl, box(809), box(254), NULL);
-  avl = gpr_avl_add(avl, box(997), box(255), NULL);
-  avl = remove_int(avl, 678);
-  avl = gpr_avl_add(avl, box(368), box(257), NULL);
-  avl = gpr_avl_add(avl, box(220), box(258), NULL);
-  avl = gpr_avl_add(avl, box(373), box(259), NULL);
-  avl = remove_int(avl, 874);
-  avl = remove_int(avl, 682);
-  avl = remove_int(avl, 1014);
-  avl = remove_int(avl, 195);
-  avl = gpr_avl_add(avl, box(868), box(264), NULL);
-  avl = remove_int(avl, 254);
-  avl = remove_int(avl, 456);
-  avl = gpr_avl_add(avl, box(906), box(267), NULL);
-  avl = remove_int(avl, 711);
-  avl = gpr_avl_add(avl, box(632), box(269), NULL);
-  avl = remove_int(avl, 474);
-  avl = gpr_avl_add(avl, box(508), box(271), NULL);
-  avl = gpr_avl_add(avl, box(518), box(272), NULL);
-  avl = remove_int(avl, 579);
-  avl = remove_int(avl, 948);
-  avl = gpr_avl_add(avl, box(789), box(275), NULL);
-  avl = gpr_avl_add(avl, box(48), box(276), NULL);
-  avl = gpr_avl_add(avl, box(256), box(277), NULL);
-  avl = gpr_avl_add(avl, box(754), box(278), NULL);
-  avl = remove_int(avl, 215);
-  avl = gpr_avl_add(avl, box(679), box(280), NULL);
-  avl = gpr_avl_add(avl, box(606), box(281), NULL);
-  avl = remove_int(avl, 941);
-  avl = remove_int(avl, 31);
-  avl = gpr_avl_add(avl, box(758), box(284), NULL);
-  avl = remove_int(avl, 101);
-  avl = gpr_avl_add(avl, box(244), box(286), NULL);
-  avl = gpr_avl_add(avl, box(337), box(287), NULL);
-  avl = gpr_avl_add(avl, box(461), box(288), NULL);
-  avl = remove_int(avl, 476);
-  avl = gpr_avl_add(avl, box(845), box(290), NULL);
-  avl = remove_int(avl, 160);
-  avl = gpr_avl_add(avl, box(690), box(292), NULL);
-  avl = remove_int(avl, 931);
-  avl = gpr_avl_add(avl, box(869), box(294), NULL);
-  avl = gpr_avl_add(avl, box(1019), box(295), NULL);
-  avl = remove_int(avl, 591);
-  avl = remove_int(avl, 635);
-  avl = remove_int(avl, 67);
-  avl = gpr_avl_add(avl, box(113), box(299), NULL);
-  avl = remove_int(avl, 305);
-  avl = gpr_avl_add(avl, box(10), box(301), NULL);
-  avl = remove_int(avl, 823);
-  avl = remove_int(avl, 288);
-  avl = remove_int(avl, 239);
-  avl = gpr_avl_add(avl, box(646), box(305), NULL);
-  avl = gpr_avl_add(avl, box(1006), box(306), NULL);
-  avl = gpr_avl_add(avl, box(954), box(307), NULL);
-  avl = gpr_avl_add(avl, box(199), box(308), NULL);
-  avl = gpr_avl_add(avl, box(69), box(309), NULL);
-  avl = gpr_avl_add(avl, box(984), box(310), NULL);
-  avl = remove_int(avl, 568);
-  avl = remove_int(avl, 666);
-  avl = remove_int(avl, 37);
-  avl = gpr_avl_add(avl, box(845), box(314), NULL);
-  avl = remove_int(avl, 535);
-  avl = remove_int(avl, 365);
-  avl = remove_int(avl, 676);
-  avl = remove_int(avl, 892);
-  avl = remove_int(avl, 425);
-  avl = remove_int(avl, 704);
-  avl = remove_int(avl, 168);
-  avl = gpr_avl_add(avl, box(853), box(322), NULL);
-  avl = gpr_avl_add(avl, box(335), box(323), NULL);
-  avl = gpr_avl_add(avl, box(961), box(324), NULL);
-  avl = gpr_avl_add(avl, box(73), box(325), NULL);
-  avl = remove_int(avl, 469);
-  avl = gpr_avl_add(avl, box(449), box(327), NULL);
-  avl = remove_int(avl, 821);
-  avl = gpr_avl_add(avl, box(845), box(329), NULL);
-  avl = remove_int(avl, 637);
-  avl = gpr_avl_add(avl, box(769), box(331), NULL);
-  avl = gpr_avl_add(avl, box(901), box(332), NULL);
-  avl = remove_int(avl, 142);
-  avl = remove_int(avl, 361);
-  avl = remove_int(avl, 876);
-  avl = gpr_avl_add(avl, box(614), box(336), NULL);
-  avl = gpr_avl_add(avl, box(729), box(337), NULL);
-  avl = remove_int(avl, 120);
-  avl = remove_int(avl, 473);
-  avl = remove_int(avl, 445);
-  avl = gpr_avl_add(avl, box(978), box(341), NULL);
-  avl = gpr_avl_add(avl, box(164), box(342), NULL);
-  avl = gpr_avl_add(avl, box(1), box(343), NULL);
-  avl = remove_int(avl, 890);
-  avl = gpr_avl_add(avl, box(605), box(345), NULL);
-  avl = gpr_avl_add(avl, box(178), box(346), NULL);
-  avl = gpr_avl_add(avl, box(481), box(347), NULL);
-  avl = gpr_avl_add(avl, box(772), box(348), NULL);
-  avl = remove_int(avl, 824);
-  avl = remove_int(avl, 167);
-  avl = remove_int(avl, 151);
-  avl = gpr_avl_add(avl, box(698), box(352), NULL);
-  avl = gpr_avl_add(avl, box(202), box(353), NULL);
-  avl = gpr_avl_add(avl, box(921), box(354), NULL);
-  avl = gpr_avl_add(avl, box(875), box(355), NULL);
-  avl = remove_int(avl, 197);
-  avl = remove_int(avl, 232);
-  avl = gpr_avl_add(avl, box(209), box(358), NULL);
-  avl = remove_int(avl, 324);
-  avl = remove_int(avl, 56);
-  avl = remove_int(avl, 579);
-  avl = remove_int(avl, 255);
-  avl = remove_int(avl, 290);
-  avl = gpr_avl_add(avl, box(661), box(364), NULL);
-  avl = gpr_avl_add(avl, box(113), box(365), NULL);
-  avl = remove_int(avl, 767);
-  avl = gpr_avl_add(avl, box(586), box(367), NULL);
-  avl = gpr_avl_add(avl, box(121), box(368), NULL);
-  avl = remove_int(avl, 235);
-  avl = remove_int(avl, 439);
-  avl = remove_int(avl, 360);
-  avl = gpr_avl_add(avl, box(916), box(372), NULL);
-  avl = remove_int(avl, 999);
-  avl = gpr_avl_add(avl, box(825), box(374), NULL);
-  avl = gpr_avl_add(avl, box(177), box(375), NULL);
-  avl = remove_int(avl, 204);
-  avl = remove_int(avl, 92);
-  avl = gpr_avl_add(avl, box(794), box(378), NULL);
-  avl = gpr_avl_add(avl, box(463), box(379), NULL);
-  avl = gpr_avl_add(avl, box(472), box(380), NULL);
-  avl = remove_int(avl, 235);
-  avl = gpr_avl_add(avl, box(840), box(382), NULL);
-  avl = remove_int(avl, 657);
-  avl = gpr_avl_add(avl, box(586), box(384), NULL);
-  avl = gpr_avl_add(avl, box(979), box(385), NULL);
-  avl = remove_int(avl, 979);
-  avl = gpr_avl_add(avl, box(639), box(387), NULL);
-  avl = remove_int(avl, 907);
-  avl = remove_int(avl, 973);
-  avl = gpr_avl_add(avl, box(913), box(390), NULL);
-  avl = gpr_avl_add(avl, box(566), box(391), NULL);
-  avl = gpr_avl_add(avl, box(883), box(392), NULL);
-  avl = gpr_avl_add(avl, box(552), box(393), NULL);
-  avl = gpr_avl_add(avl, box(16), box(394), NULL);
-  avl = remove_int(avl, 60);
-  avl = gpr_avl_add(avl, box(567), box(396), NULL);
-  avl = gpr_avl_add(avl, box(705), box(397), NULL);
-  avl = gpr_avl_add(avl, box(94), box(398), NULL);
-  avl = remove_int(avl, 321);
-  avl = gpr_avl_add(avl, box(207), box(400), NULL);
-  avl = gpr_avl_add(avl, box(682), box(401), NULL);
-  avl = gpr_avl_add(avl, box(592), box(402), NULL);
-  avl = gpr_avl_add(avl, box(10), box(403), NULL);
-  avl = remove_int(avl, 911);
-  avl = remove_int(avl, 161);
-  avl = gpr_avl_add(avl, box(86), box(406), NULL);
-  avl = remove_int(avl, 893);
-  avl = remove_int(avl, 362);
-  avl = gpr_avl_add(avl, box(599), box(409), NULL);
-  avl = remove_int(avl, 413);
-  avl = gpr_avl_add(avl, box(867), box(411), NULL);
-  avl = remove_int(avl, 955);
-  avl = gpr_avl_add(avl, box(341), box(413), NULL);
-  avl = gpr_avl_add(avl, box(887), box(414), NULL);
-  avl = remove_int(avl, 706);
-  avl = gpr_avl_add(avl, box(939), box(416), NULL);
-  avl = remove_int(avl, 233);
-  avl = remove_int(avl, 662);
-  avl = remove_int(avl, 984);
-  avl = remove_int(avl, 203);
-  avl = gpr_avl_add(avl, box(326), box(421), NULL);
-  avl = remove_int(avl, 848);
-  avl = gpr_avl_add(avl, box(235), box(423), NULL);
-  avl = remove_int(avl, 617);
-  avl = gpr_avl_add(avl, box(565), box(425), NULL);
-  avl = remove_int(avl, 469);
-  avl = gpr_avl_add(avl, box(988), box(427), NULL);
-  avl = remove_int(avl, 957);
-  avl = gpr_avl_add(avl, box(426), box(429), NULL);
-  avl = remove_int(avl, 967);
-  avl = gpr_avl_add(avl, box(890), box(431), NULL);
-  avl = gpr_avl_add(avl, box(473), box(432), NULL);
-  avl = remove_int(avl, 367);
-  avl = remove_int(avl, 344);
-  avl = remove_int(avl, 660);
-  avl = remove_int(avl, 448);
-  avl = remove_int(avl, 837);
-  avl = remove_int(avl, 158);
-  avl = gpr_avl_add(avl, box(459), box(439), NULL);
-  avl = remove_int(avl, 882);
-  avl = remove_int(avl, 782);
-  avl = gpr_avl_add(avl, box(408), box(442), NULL);
-  avl = gpr_avl_add(avl, box(728), box(443), NULL);
-  avl = remove_int(avl, 27);
-  avl = gpr_avl_add(avl, box(137), box(445), NULL);
-  avl = gpr_avl_add(avl, box(239), box(446), NULL);
-  avl = remove_int(avl, 854);
-  avl = gpr_avl_add(avl, box(104), box(448), NULL);
-  avl = gpr_avl_add(avl, box(823), box(449), NULL);
-  avl = gpr_avl_add(avl, box(524), box(450), NULL);
-  avl = gpr_avl_add(avl, box(995), box(451), NULL);
-  avl = remove_int(avl, 422);
-  avl = remove_int(avl, 220);
-  avl = gpr_avl_add(avl, box(856), box(454), NULL);
-  avl = remove_int(avl, 332);
-  avl = gpr_avl_add(avl, box(679), box(456), NULL);
-  avl = remove_int(avl, 18);
-  avl = gpr_avl_add(avl, box(837), box(458), NULL);
-  avl = remove_int(avl, 405);
-  avl = remove_int(avl, 877);
-  avl = remove_int(avl, 835);
-  avl = gpr_avl_add(avl, box(547), box(462), NULL);
-  avl = remove_int(avl, 805);
-  avl = remove_int(avl, 862);
-  avl = gpr_avl_add(avl, box(75), box(465), NULL);
-  avl = remove_int(avl, 41);
-  avl = gpr_avl_add(avl, box(310), box(467), NULL);
-  avl = remove_int(avl, 855);
-  avl = gpr_avl_add(avl, box(20), box(469), NULL);
-  avl = remove_int(avl, 186);
-  avl = remove_int(avl, 378);
-  avl = remove_int(avl, 442);
-  avl = remove_int(avl, 930);
-  avl = gpr_avl_add(avl, box(118), box(474), NULL);
-  avl = gpr_avl_add(avl, box(96), box(475), NULL);
-  avl = remove_int(avl, 854);
-  avl = gpr_avl_add(avl, box(65), box(477), NULL);
-  avl = gpr_avl_add(avl, box(573), box(478), NULL);
-  avl = gpr_avl_add(avl, box(4), box(479), NULL);
-  avl = gpr_avl_add(avl, box(451), box(480), NULL);
-  avl = gpr_avl_add(avl, box(774), box(481), NULL);
-  avl = gpr_avl_add(avl, box(126), box(482), NULL);
-  avl = remove_int(avl, 956);
-  avl = remove_int(avl, 591);
-  avl = remove_int(avl, 644);
-  avl = gpr_avl_add(avl, box(304), box(486), NULL);
-  avl = remove_int(avl, 620);
-  avl = remove_int(avl, 394);
-  avl = gpr_avl_add(avl, box(1002), box(489), NULL);
-  avl = gpr_avl_add(avl, box(837), box(490), NULL);
-  avl = remove_int(avl, 485);
-  avl = gpr_avl_add(avl, box(1005), box(492), NULL);
-  avl = remove_int(avl, 21);
-  avl = gpr_avl_add(avl, box(396), box(494), NULL);
-  avl = remove_int(avl, 966);
-  avl = gpr_avl_add(avl, box(105), box(496), NULL);
-  avl = gpr_avl_add(avl, box(316), box(497), NULL);
-  avl = remove_int(avl, 776);
-  avl = gpr_avl_add(avl, box(188), box(499), NULL);
-  avl = remove_int(avl, 200);
-  avl = gpr_avl_add(avl, box(98), box(501), NULL);
-  avl = gpr_avl_add(avl, box(831), box(502), NULL);
-  avl = gpr_avl_add(avl, box(227), box(503), NULL);
-  avl = gpr_avl_add(avl, box(220), box(504), NULL);
-  avl = remove_int(avl, 715);
-  avl = remove_int(avl, 279);
-  avl = gpr_avl_add(avl, box(701), box(507), NULL);
-  avl = gpr_avl_add(avl, box(726), box(508), NULL);
-  avl = gpr_avl_add(avl, box(815), box(509), NULL);
-  avl = gpr_avl_add(avl, box(749), box(510), NULL);
-  avl = remove_int(avl, 946);
-  avl = remove_int(avl, 449);
-  avl = remove_int(avl, 62);
-  avl = remove_int(avl, 487);
-  avl = gpr_avl_add(avl, box(545), box(515), NULL);
-  avl = remove_int(avl, 59);
-  avl = gpr_avl_add(avl, box(168), box(517), NULL);
-  avl = remove_int(avl, 337);
-  avl = gpr_avl_add(avl, box(69), box(519), NULL);
-  avl = remove_int(avl, 600);
-  avl = gpr_avl_add(avl, box(591), box(521), NULL);
-  avl = gpr_avl_add(avl, box(960), box(522), NULL);
-  avl = gpr_avl_add(avl, box(116), box(523), NULL);
-  avl = remove_int(avl, 991);
-  avl = gpr_avl_add(avl, box(760), box(525), NULL);
-  avl = gpr_avl_add(avl, box(664), box(526), NULL);
-  avl = gpr_avl_add(avl, box(547), box(527), NULL);
-  avl = remove_int(avl, 922);
-  avl = gpr_avl_add(avl, box(290), box(529), NULL);
-  avl = gpr_avl_add(avl, box(859), box(530), NULL);
-  avl = gpr_avl_add(avl, box(49), box(531), NULL);
-  avl = remove_int(avl, 455);
-  avl = remove_int(avl, 786);
-  avl = gpr_avl_add(avl, box(613), box(534), NULL);
-  avl = gpr_avl_add(avl, box(326), box(535), NULL);
-  avl = remove_int(avl, 615);
-  avl = gpr_avl_add(avl, box(45), box(537), NULL);
-  avl = gpr_avl_add(avl, box(162), box(538), NULL);
-  avl = gpr_avl_add(avl, box(189), box(539), NULL);
-  avl = remove_int(avl, 68);
-  avl = remove_int(avl, 846);
-  avl = gpr_avl_add(avl, box(608), box(542), NULL);
-  avl = remove_int(avl, 821);
-  avl = gpr_avl_add(avl, box(978), box(544), NULL);
-  avl = gpr_avl_add(avl, box(892), box(545), NULL);
-  avl = remove_int(avl, 924);
-  avl = gpr_avl_add(avl, box(708), box(547), NULL);
-  avl = remove_int(avl, 135);
-  avl = remove_int(avl, 124);
-  avl = gpr_avl_add(avl, box(301), box(550), NULL);
-  avl = gpr_avl_add(avl, box(939), box(551), NULL);
-  avl = gpr_avl_add(avl, box(344), box(552), NULL);
-  avl = remove_int(avl, 443);
-  avl = remove_int(avl, 122);
-  avl = gpr_avl_add(avl, box(636), box(555), NULL);
-  avl = remove_int(avl, 558);
-  avl = gpr_avl_add(avl, box(923), box(557), NULL);
-  avl = remove_int(avl, 827);
-  avl = gpr_avl_add(avl, box(649), box(559), NULL);
-  avl = gpr_avl_add(avl, box(808), box(560), NULL);
-  avl = remove_int(avl, 570);
-  avl = remove_int(avl, 434);
-  avl = gpr_avl_add(avl, box(40), box(563), NULL);
-  avl = gpr_avl_add(avl, box(725), box(564), NULL);
-  avl = remove_int(avl, 295);
-  avl = remove_int(avl, 615);
-  avl = remove_int(avl, 919);
-  avl = remove_int(avl, 170);
-  avl = remove_int(avl, 442);
-  avl = remove_int(avl, 971);
-  avl = gpr_avl_add(avl, box(483), box(571), NULL);
-  avl = gpr_avl_add(avl, box(512), box(572), NULL);
-  avl = remove_int(avl, 648);
-  avl = remove_int(avl, 78);
-  avl = remove_int(avl, 72);
-  avl = remove_int(avl, 790);
-  avl = remove_int(avl, 571);
-  avl = gpr_avl_add(avl, box(898), box(578), NULL);
-  avl = remove_int(avl, 770);
-  avl = remove_int(avl, 776);
-  avl = gpr_avl_add(avl, box(602), box(581), NULL);
-  avl = remove_int(avl, 251);
-  avl = gpr_avl_add(avl, box(303), box(583), NULL);
-  avl = remove_int(avl, 837);
-  avl = gpr_avl_add(avl, box(714), box(585), NULL);
-  avl = remove_int(avl, 800);
-  avl = gpr_avl_add(avl, box(266), box(587), NULL);
-  avl = gpr_avl_add(avl, box(555), box(588), NULL);
-  avl = remove_int(avl, 604);
-  avl = remove_int(avl, 163);
-  avl = remove_int(avl, 497);
-  avl = gpr_avl_add(avl, box(296), box(592), NULL);
-  avl = remove_int(avl, 129);
-  avl = gpr_avl_add(avl, box(656), box(594), NULL);
-  avl = remove_int(avl, 769);
-  avl = remove_int(avl, 941);
-  avl = gpr_avl_add(avl, box(775), box(597), NULL);
-  avl = gpr_avl_add(avl, box(846), box(598), NULL);
-  avl = remove_int(avl, 591);
-  avl = remove_int(avl, 801);
-  avl = remove_int(avl, 419);
-  avl = remove_int(avl, 455);
-  avl = gpr_avl_add(avl, box(866), box(603), NULL);
-  avl = gpr_avl_add(avl, box(575), box(604), NULL);
-  avl = gpr_avl_add(avl, box(620), box(605), NULL);
-  avl = remove_int(avl, 100);
-  avl = remove_int(avl, 667);
-  avl = gpr_avl_add(avl, box(138), box(608), NULL);
-  avl = gpr_avl_add(avl, box(566), box(609), NULL);
-  avl = gpr_avl_add(avl, box(673), box(610), NULL);
-  avl = gpr_avl_add(avl, box(178), box(611), NULL);
-  avl = remove_int(avl, 659);
-  avl = gpr_avl_add(avl, box(759), box(613), NULL);
-  avl = gpr_avl_add(avl, box(1008), box(614), NULL);
-  avl = remove_int(avl, 116);
-  avl = gpr_avl_add(avl, box(608), box(616), NULL);
-  avl = gpr_avl_add(avl, box(339), box(617), NULL);
-  avl = gpr_avl_add(avl, box(197), box(618), NULL);
-  avl = remove_int(avl, 25);
-  avl = remove_int(avl, 628);
-  avl = gpr_avl_add(avl, box(487), box(621), NULL);
-  avl = remove_int(avl, 739);
-  avl = remove_int(avl, 100);
-  avl = remove_int(avl, 928);
-  avl = gpr_avl_add(avl, box(647), box(625), NULL);
-  avl = remove_int(avl, 978);
-  avl = remove_int(avl, 143);
-  avl = remove_int(avl, 755);
-  avl = gpr_avl_add(avl, box(71), box(629), NULL);
-  avl = remove_int(avl, 205);
-  avl = gpr_avl_add(avl, box(501), box(631), NULL);
-  avl = remove_int(avl, 723);
-  avl = remove_int(avl, 852);
-  avl = remove_int(avl, 1021);
-  avl = remove_int(avl, 670);
-  avl = remove_int(avl, 500);
-  avl = gpr_avl_add(avl, box(330), box(637), NULL);
-  avl = remove_int(avl, 264);
-  avl = gpr_avl_add(avl, box(69), box(639), NULL);
-  avl = remove_int(avl, 73);
-  avl = gpr_avl_add(avl, box(745), box(641), NULL);
-  avl = remove_int(avl, 518);
-  avl = remove_int(avl, 641);
-  avl = remove_int(avl, 768);
-  avl = gpr_avl_add(avl, box(988), box(645), NULL);
-  avl = gpr_avl_add(avl, box(899), box(646), NULL);
-  avl = remove_int(avl, 763);
-  avl = remove_int(avl, 281);
-  avl = remove_int(avl, 496);
-  avl = gpr_avl_add(avl, box(445), box(650), NULL);
-  avl = remove_int(avl, 905);
-  avl = gpr_avl_add(avl, box(275), box(652), NULL);
-  avl = gpr_avl_add(avl, box(137), box(653), NULL);
-  avl = remove_int(avl, 642);
-  avl = gpr_avl_add(avl, box(708), box(655), NULL);
-  avl = remove_int(avl, 922);
-  avl = gpr_avl_add(avl, box(743), box(657), NULL);
-  avl = remove_int(avl, 295);
-  avl = remove_int(avl, 665);
-  avl = remove_int(avl, 48);
-  avl = gpr_avl_add(avl, box(1012), box(661), NULL);
-  avl = remove_int(avl, 71);
-  avl = remove_int(avl, 523);
-  avl = gpr_avl_add(avl, box(319), box(664), NULL);
-  avl = remove_int(avl, 632);
-  avl = gpr_avl_add(avl, box(137), box(666), NULL);
-  avl = gpr_avl_add(avl, box(686), box(667), NULL);
-  avl = gpr_avl_add(avl, box(724), box(668), NULL);
-  avl = gpr_avl_add(avl, box(952), box(669), NULL);
-  avl = gpr_avl_add(avl, box(5), box(670), NULL);
-  avl = remove_int(avl, 35);
-  avl = gpr_avl_add(avl, box(43), box(672), NULL);
-  avl = gpr_avl_add(avl, box(320), box(673), NULL);
-  avl = gpr_avl_add(avl, box(115), box(674), NULL);
-  avl = remove_int(avl, 377);
-  avl = remove_int(avl, 591);
-  avl = remove_int(avl, 87);
-  avl = remove_int(avl, 93);
-  avl = gpr_avl_add(avl, box(1016), box(679), NULL);
-  avl = gpr_avl_add(avl, box(605), box(680), NULL);
-  avl = gpr_avl_add(avl, box(152), box(681), NULL);
-  avl = gpr_avl_add(avl, box(113), box(682), NULL);
-  avl = remove_int(avl, 131);
-  avl = remove_int(avl, 637);
-  avl = gpr_avl_add(avl, box(156), box(685), NULL);
-  avl = remove_int(avl, 696);
-  avl = gpr_avl_add(avl, box(546), box(687), NULL);
-  avl = remove_int(avl, 970);
-  avl = remove_int(avl, 53);
-  avl = remove_int(avl, 827);
-  avl = remove_int(avl, 224);
-  avl = remove_int(avl, 796);
-  avl = remove_int(avl, 34);
-  avl = remove_int(avl, 922);
-  avl = remove_int(avl, 277);
-  avl = remove_int(avl, 650);
-  avl = remove_int(avl, 222);
-  avl = remove_int(avl, 244);
-  avl = remove_int(avl, 576);
-  avl = remove_int(avl, 413);
-  avl = gpr_avl_add(avl, box(500), box(701), NULL);
-  avl = remove_int(avl, 924);
-  avl = gpr_avl_add(avl, box(825), box(703), NULL);
-  avl = remove_int(avl, 888);
-  avl = remove_int(avl, 931);
-  avl = gpr_avl_add(avl, box(285), box(706), NULL);
-  avl = remove_int(avl, 62);
-  avl = remove_int(avl, 444);
-  avl = remove_int(avl, 946);
-  avl = gpr_avl_add(avl, box(122), box(710), NULL);
-  avl = gpr_avl_add(avl, box(846), box(711), NULL);
-  avl = remove_int(avl, 628);
-  avl = gpr_avl_add(avl, box(511), box(713), NULL);
-  avl = gpr_avl_add(avl, box(398), box(714), NULL);
-  avl = remove_int(avl, 730);
-  avl = gpr_avl_add(avl, box(797), box(716), NULL);
-  avl = remove_int(avl, 897);
-  avl = remove_int(avl, 228);
-  avl = remove_int(avl, 544);
-  avl = remove_int(avl, 552);
-  avl = remove_int(avl, 783);
-  avl = remove_int(avl, 583);
-  avl = remove_int(avl, 894);
-  avl = remove_int(avl, 942);
-  avl = gpr_avl_add(avl, box(346), box(725), NULL);
-  avl = gpr_avl_add(avl, box(1015), box(726), NULL);
-  avl = remove_int(avl, 813);
-  avl = gpr_avl_add(avl, box(213), box(728), NULL);
-  avl = remove_int(avl, 468);
-  avl = remove_int(avl, 365);
-  avl = remove_int(avl, 399);
-  avl = gpr_avl_add(avl, box(380), box(732), NULL);
-  avl = remove_int(avl, 835);
-  avl = remove_int(avl, 970);
-  avl = gpr_avl_add(avl, box(700), box(735), NULL);
-  avl = gpr_avl_add(avl, box(807), box(736), NULL);
-  avl = remove_int(avl, 312);
-  avl = remove_int(avl, 282);
-  avl = remove_int(avl, 370);
-  avl = remove_int(avl, 999);
-  avl = remove_int(avl, 241);
-  avl = remove_int(avl, 884);
-  avl = gpr_avl_add(avl, box(587), box(743), NULL);
-  avl = gpr_avl_add(avl, box(332), box(744), NULL);
-  avl = remove_int(avl, 686);
-  avl = remove_int(avl, 206);
-  avl = remove_int(avl, 835);
-  avl = gpr_avl_add(avl, box(334), box(748), NULL);
-  avl = remove_int(avl, 171);
-  avl = gpr_avl_add(avl, box(1002), box(750), NULL);
-  avl = gpr_avl_add(avl, box(779), box(751), NULL);
-  avl = gpr_avl_add(avl, box(307), box(752), NULL);
-  avl = gpr_avl_add(avl, box(127), box(753), NULL);
-  avl = gpr_avl_add(avl, box(251), box(754), NULL);
-  avl = remove_int(avl, 790);
-  avl = remove_int(avl, 189);
-  avl = remove_int(avl, 193);
-  avl = remove_int(avl, 38);
-  avl = remove_int(avl, 124);
-  avl = gpr_avl_add(avl, box(812), box(760), NULL);
-  avl = remove_int(avl, 43);
-  avl = gpr_avl_add(avl, box(871), box(762), NULL);
-  avl = gpr_avl_add(avl, box(580), box(763), NULL);
-  avl = remove_int(avl, 501);
-  avl = remove_int(avl, 462);
-  avl = remove_int(avl, 599);
-  avl = gpr_avl_add(avl, box(240), box(767), NULL);
-  avl = gpr_avl_add(avl, box(285), box(768), NULL);
-  avl = gpr_avl_add(avl, box(472), box(769), NULL);
-  avl = remove_int(avl, 865);
-  avl = remove_int(avl, 763);
-  avl = remove_int(avl, 245);
-  avl = remove_int(avl, 80);
-  avl = remove_int(avl, 713);
-  avl = remove_int(avl, 654);
-  avl = remove_int(avl, 1014);
-  avl = gpr_avl_add(avl, box(495), box(777), NULL);
-  avl = gpr_avl_add(avl, box(552), box(778), NULL);
-  avl = remove_int(avl, 19);
-  avl = remove_int(avl, 803);
-  avl = gpr_avl_add(avl, box(508), box(781), NULL);
-  avl = remove_int(avl, 699);
-  avl = remove_int(avl, 260);
-  avl = remove_int(avl, 92);
-  avl = remove_int(avl, 497);
-  avl = gpr_avl_add(avl, box(970), box(786), NULL);
-  avl = remove_int(avl, 987);
-  avl = remove_int(avl, 168);
-  avl = remove_int(avl, 476);
-  avl = remove_int(avl, 248);
-  avl = gpr_avl_add(avl, box(358), box(791), NULL);
-  avl = remove_int(avl, 804);
-  avl = remove_int(avl, 77);
-  avl = remove_int(avl, 905);
-  avl = remove_int(avl, 362);
-  avl = gpr_avl_add(avl, box(578), box(796), NULL);
-  avl = remove_int(avl, 38);
-  avl = remove_int(avl, 595);
-  avl = gpr_avl_add(avl, box(213), box(799), NULL);
-  avl = remove_int(avl, 7);
-  avl = remove_int(avl, 620);
-  avl = gpr_avl_add(avl, box(946), box(802), NULL);
-  avl = remove_int(avl, 145);
-  avl = gpr_avl_add(avl, box(628), box(804), NULL);
-  avl = remove_int(avl, 972);
-  avl = gpr_avl_add(avl, box(728), box(806), NULL);
-  avl = remove_int(avl, 91);
-  avl = gpr_avl_add(avl, box(136), box(808), NULL);
-  avl = gpr_avl_add(avl, box(841), box(809), NULL);
-  avl = gpr_avl_add(avl, box(265), box(810), NULL);
-  avl = gpr_avl_add(avl, box(701), box(811), NULL);
-  avl = gpr_avl_add(avl, box(27), box(812), NULL);
-  avl = remove_int(avl, 72);
-  avl = remove_int(avl, 14);
-  avl = gpr_avl_add(avl, box(286), box(815), NULL);
-  avl = remove_int(avl, 996);
-  avl = remove_int(avl, 998);
-  avl = gpr_avl_add(avl, box(466), box(818), NULL);
-  avl = remove_int(avl, 1009);
-  avl = remove_int(avl, 741);
-  avl = remove_int(avl, 947);
-  avl = remove_int(avl, 241);
-  avl = remove_int(avl, 954);
-  avl = remove_int(avl, 183);
-  avl = remove_int(avl, 395);
-  avl = remove_int(avl, 951);
-  avl = gpr_avl_add(avl, box(267), box(827), NULL);
-  avl = remove_int(avl, 812);
-  avl = gpr_avl_add(avl, box(577), box(829), NULL);
-  avl = remove_int(avl, 624);
-  avl = remove_int(avl, 847);
-  avl = remove_int(avl, 745);
-  avl = gpr_avl_add(avl, box(491), box(833), NULL);
-  avl = gpr_avl_add(avl, box(941), box(834), NULL);
-  avl = remove_int(avl, 258);
-  avl = gpr_avl_add(avl, box(410), box(836), NULL);
-  avl = gpr_avl_add(avl, box(80), box(837), NULL);
-  avl = gpr_avl_add(avl, box(196), box(838), NULL);
-  avl = gpr_avl_add(avl, box(5), box(839), NULL);
-  avl = remove_int(avl, 782);
-  avl = gpr_avl_add(avl, box(827), box(841), NULL);
-  avl = remove_int(avl, 472);
-  avl = remove_int(avl, 664);
-  avl = gpr_avl_add(avl, box(409), box(844), NULL);
-  avl = gpr_avl_add(avl, box(62), box(845), NULL);
-  avl = remove_int(avl, 56);
-  avl = remove_int(avl, 606);
-  avl = remove_int(avl, 707);
-  avl = remove_int(avl, 989);
-  avl = remove_int(avl, 549);
-  avl = remove_int(avl, 259);
-  avl = gpr_avl_add(avl, box(405), box(852), NULL);
-  avl = remove_int(avl, 587);
-  avl = remove_int(avl, 350);
-  avl = gpr_avl_add(avl, box(980), box(855), NULL);
-  avl = gpr_avl_add(avl, box(992), box(856), NULL);
-  avl = gpr_avl_add(avl, box(818), box(857), NULL);
-  avl = remove_int(avl, 853);
-  avl = remove_int(avl, 701);
-  avl = gpr_avl_add(avl, box(675), box(860), NULL);
-  avl = remove_int(avl, 248);
-  avl = remove_int(avl, 649);
-  avl = gpr_avl_add(avl, box(508), box(863), NULL);
-  avl = remove_int(avl, 927);
-  avl = gpr_avl_add(avl, box(957), box(865), NULL);
-  avl = gpr_avl_add(avl, box(698), box(866), NULL);
-  avl = gpr_avl_add(avl, box(388), box(867), NULL);
-  avl = gpr_avl_add(avl, box(532), box(868), NULL);
-  avl = gpr_avl_add(avl, box(681), box(869), NULL);
-  avl = remove_int(avl, 544);
-  avl = remove_int(avl, 991);
-  avl = remove_int(avl, 397);
-  avl = gpr_avl_add(avl, box(954), box(873), NULL);
-  avl = gpr_avl_add(avl, box(219), box(874), NULL);
-  avl = gpr_avl_add(avl, box(465), box(875), NULL);
-  avl = remove_int(avl, 371);
-  avl = gpr_avl_add(avl, box(601), box(877), NULL);
-  avl = gpr_avl_add(avl, box(543), box(878), NULL);
-  avl = remove_int(avl, 329);
-  avl = gpr_avl_add(avl, box(560), box(880), NULL);
-  avl = remove_int(avl, 898);
-  avl = gpr_avl_add(avl, box(455), box(882), NULL);
-  avl = remove_int(avl, 313);
-  avl = gpr_avl_add(avl, box(215), box(884), NULL);
-  avl = remove_int(avl, 846);
-  avl = gpr_avl_add(avl, box(608), box(886), NULL);
-  avl = remove_int(avl, 248);
-  avl = gpr_avl_add(avl, box(575), box(888), NULL);
-  avl = remove_int(avl, 207);
-  avl = remove_int(avl, 810);
-  avl = remove_int(avl, 665);
-  avl = remove_int(avl, 361);
-  avl = gpr_avl_add(avl, box(154), box(893), NULL);
-  avl = gpr_avl_add(avl, box(329), box(894), NULL);
-  avl = gpr_avl_add(avl, box(326), box(895), NULL);
-  avl = remove_int(avl, 746);
-  avl = remove_int(avl, 99);
-  avl = gpr_avl_add(avl, box(464), box(898), NULL);
-  avl = gpr_avl_add(avl, box(141), box(899), NULL);
-  avl = remove_int(avl, 383);
-  avl = gpr_avl_add(avl, box(414), box(901), NULL);
-  avl = gpr_avl_add(avl, box(777), box(902), NULL);
-  avl = remove_int(avl, 972);
-  avl = remove_int(avl, 841);
-  avl = remove_int(avl, 100);
-  avl = gpr_avl_add(avl, box(828), box(906), NULL);
-  avl = remove_int(avl, 785);
-  avl = gpr_avl_add(avl, box(1008), box(908), NULL);
-  avl = gpr_avl_add(avl, box(46), box(909), NULL);
-  avl = remove_int(avl, 399);
-  avl = gpr_avl_add(avl, box(178), box(911), NULL);
-  avl = gpr_avl_add(avl, box(573), box(912), NULL);
-  avl = remove_int(avl, 299);
-  avl = gpr_avl_add(avl, box(690), box(914), NULL);
-  avl = gpr_avl_add(avl, box(692), box(915), NULL);
-  avl = remove_int(avl, 404);
-  avl = remove_int(avl, 16);
-  avl = remove_int(avl, 746);
-  avl = remove_int(avl, 486);
-  avl = remove_int(avl, 119);
-  avl = gpr_avl_add(avl, box(167), box(921), NULL);
-  avl = remove_int(avl, 328);
-  avl = gpr_avl_add(avl, box(89), box(923), NULL);
-  avl = remove_int(avl, 867);
-  avl = remove_int(avl, 626);
-  avl = remove_int(avl, 507);
-  avl = gpr_avl_add(avl, box(365), box(927), NULL);
-  avl = gpr_avl_add(avl, box(58), box(928), NULL);
-  avl = gpr_avl_add(avl, box(70), box(929), NULL);
-  avl = remove_int(avl, 81);
-  avl = remove_int(avl, 797);
-  avl = gpr_avl_add(avl, box(846), box(932), NULL);
-  avl = remove_int(avl, 642);
-  avl = gpr_avl_add(avl, box(777), box(934), NULL);
-  avl = remove_int(avl, 107);
-  avl = gpr_avl_add(avl, box(691), box(936), NULL);
-  avl = gpr_avl_add(avl, box(820), box(937), NULL);
-  avl = gpr_avl_add(avl, box(202), box(938), NULL);
-  avl = gpr_avl_add(avl, box(308), box(939), NULL);
-  avl = gpr_avl_add(avl, box(20), box(940), NULL);
-  avl = remove_int(avl, 289);
-  avl = gpr_avl_add(avl, box(714), box(942), NULL);
-  avl = gpr_avl_add(avl, box(584), box(943), NULL);
-  avl = remove_int(avl, 294);
-  avl = gpr_avl_add(avl, box(496), box(945), NULL);
-  avl = gpr_avl_add(avl, box(394), box(946), NULL);
-  avl = gpr_avl_add(avl, box(860), box(947), NULL);
-  avl = gpr_avl_add(avl, box(58), box(948), NULL);
-  avl = remove_int(avl, 784);
-  avl = remove_int(avl, 584);
-  avl = remove_int(avl, 708);
-  avl = gpr_avl_add(avl, box(142), box(952), NULL);
-  avl = gpr_avl_add(avl, box(247), box(953), NULL);
-  avl = gpr_avl_add(avl, box(389), box(954), NULL);
-  avl = remove_int(avl, 390);
-  avl = gpr_avl_add(avl, box(465), box(956), NULL);
-  avl = gpr_avl_add(avl, box(936), box(957), NULL);
-  avl = gpr_avl_add(avl, box(309), box(958), NULL);
-  avl = remove_int(avl, 928);
-  avl = remove_int(avl, 128);
-  avl = remove_int(avl, 979);
-  avl = remove_int(avl, 670);
-  avl = remove_int(avl, 738);
-  avl = remove_int(avl, 271);
-  avl = remove_int(avl, 540);
-  avl = gpr_avl_add(avl, box(365), box(966), NULL);
-  avl = remove_int(avl, 82);
-  avl = gpr_avl_add(avl, box(728), box(968), NULL);
-  avl = remove_int(avl, 852);
-  avl = gpr_avl_add(avl, box(884), box(970), NULL);
-  avl = gpr_avl_add(avl, box(502), box(971), NULL);
-  avl = remove_int(avl, 898);
-  avl = remove_int(avl, 481);
-  avl = gpr_avl_add(avl, box(911), box(974), NULL);
-  avl = remove_int(avl, 787);
-  avl = remove_int(avl, 785);
-  avl = remove_int(avl, 537);
-  avl = remove_int(avl, 535);
-  avl = remove_int(avl, 136);
-  avl = remove_int(avl, 749);
-  avl = remove_int(avl, 637);
-  avl = remove_int(avl, 900);
-  avl = gpr_avl_add(avl, box(598), box(983), NULL);
-  avl = remove_int(avl, 25);
-  avl = remove_int(avl, 697);
-  avl = gpr_avl_add(avl, box(645), box(986), NULL);
-  avl = gpr_avl_add(avl, box(211), box(987), NULL);
-  avl = gpr_avl_add(avl, box(589), box(988), NULL);
-  avl = remove_int(avl, 702);
-  avl = gpr_avl_add(avl, box(53), box(990), NULL);
-  avl = remove_int(avl, 492);
-  avl = remove_int(avl, 185);
-  avl = remove_int(avl, 246);
-  avl = remove_int(avl, 257);
-  avl = remove_int(avl, 502);
-  avl = remove_int(avl, 34);
-  avl = gpr_avl_add(avl, box(74), box(997), NULL);
-  avl = gpr_avl_add(avl, box(834), box(998), NULL);
-  avl = gpr_avl_add(avl, box(514), box(999), NULL);
-  avl = gpr_avl_add(avl, box(75), box(1000), NULL);
-  avl = remove_int(avl, 745);
-  avl = gpr_avl_add(avl, box(362), box(1002), NULL);
-  avl = remove_int(avl, 215);
-  avl = gpr_avl_add(avl, box(624), box(1004), NULL);
-  avl = remove_int(avl, 404);
-  avl = remove_int(avl, 359);
-  avl = remove_int(avl, 491);
-  avl = gpr_avl_add(avl, box(903), box(1008), NULL);
-  avl = gpr_avl_add(avl, box(240), box(1009), NULL);
-  avl = remove_int(avl, 95);
-  avl = gpr_avl_add(avl, box(119), box(1011), NULL);
-  avl = gpr_avl_add(avl, box(857), box(1012), NULL);
-  avl = remove_int(avl, 39);
-  avl = remove_int(avl, 866);
-  avl = gpr_avl_add(avl, box(503), box(1015), NULL);
-  avl = gpr_avl_add(avl, box(740), box(1016), NULL);
-  avl = remove_int(avl, 637);
-  avl = remove_int(avl, 156);
-  avl = remove_int(avl, 6);
-  avl = remove_int(avl, 745);
-  avl = remove_int(avl, 433);
-  avl = remove_int(avl, 283);
-  avl = gpr_avl_add(avl, box(625), box(1023), NULL);
-  avl = remove_int(avl, 638);
-  avl = gpr_avl_add(avl, box(299), box(1025), NULL);
-  avl = gpr_avl_add(avl, box(584), box(1026), NULL);
-  avl = remove_int(avl, 863);
-  avl = gpr_avl_add(avl, box(612), box(1028), NULL);
-  avl = gpr_avl_add(avl, box(62), box(1029), NULL);
-  avl = gpr_avl_add(avl, box(432), box(1030), NULL);
-  avl = remove_int(avl, 371);
-  avl = remove_int(avl, 790);
-  avl = remove_int(avl, 227);
-  avl = remove_int(avl, 836);
-  avl = gpr_avl_add(avl, box(703), box(1035), NULL);
-  avl = gpr_avl_add(avl, box(644), box(1036), NULL);
-  avl = remove_int(avl, 638);
-  avl = gpr_avl_add(avl, box(13), box(1038), NULL);
-  avl = remove_int(avl, 66);
-  avl = remove_int(avl, 82);
-  avl = gpr_avl_add(avl, box(362), box(1041), NULL);
-  avl = gpr_avl_add(avl, box(783), box(1042), NULL);
-  avl = remove_int(avl, 60);
-  avl = gpr_avl_add(avl, box(80), box(1044), NULL);
-  avl = gpr_avl_add(avl, box(825), box(1045), NULL);
-  avl = gpr_avl_add(avl, box(688), box(1046), NULL);
-  avl = gpr_avl_add(avl, box(662), box(1047), NULL);
-  avl = remove_int(avl, 156);
-  avl = remove_int(avl, 376);
-  avl = remove_int(avl, 99);
-  avl = gpr_avl_add(avl, box(526), box(1051), NULL);
-  avl = gpr_avl_add(avl, box(168), box(1052), NULL);
-  avl = remove_int(avl, 646);
-  avl = remove_int(avl, 380);
-  avl = remove_int(avl, 833);
-  avl = gpr_avl_add(avl, box(53), box(1056), NULL);
-  avl = remove_int(avl, 105);
-  avl = gpr_avl_add(avl, box(373), box(1058), NULL);
-  avl = gpr_avl_add(avl, box(184), box(1059), NULL);
-  avl = remove_int(avl, 288);
-  avl = gpr_avl_add(avl, box(966), box(1061), NULL);
-  avl = remove_int(avl, 158);
-  avl = gpr_avl_add(avl, box(406), box(1063), NULL);
-  avl = remove_int(avl, 470);
-  avl = gpr_avl_add(avl, box(283), box(1065), NULL);
-  avl = gpr_avl_add(avl, box(838), box(1066), NULL);
-  avl = gpr_avl_add(avl, box(288), box(1067), NULL);
-  avl = gpr_avl_add(avl, box(950), box(1068), NULL);
-  avl = gpr_avl_add(avl, box(163), box(1069), NULL);
-  avl = remove_int(avl, 623);
-  avl = remove_int(avl, 769);
-  avl = gpr_avl_add(avl, box(144), box(1072), NULL);
-  avl = gpr_avl_add(avl, box(489), box(1073), NULL);
-  avl = remove_int(avl, 15);
-  avl = gpr_avl_add(avl, box(971), box(1075), NULL);
-  avl = remove_int(avl, 660);
-  avl = gpr_avl_add(avl, box(255), box(1077), NULL);
-  avl = remove_int(avl, 494);
-  avl = gpr_avl_add(avl, box(109), box(1079), NULL);
-  avl = gpr_avl_add(avl, box(420), box(1080), NULL);
-  avl = gpr_avl_add(avl, box(509), box(1081), NULL);
-  avl = remove_int(avl, 178);
-  avl = gpr_avl_add(avl, box(216), box(1083), NULL);
-  avl = gpr_avl_add(avl, box(707), box(1084), NULL);
-  avl = gpr_avl_add(avl, box(411), box(1085), NULL);
-  avl = gpr_avl_add(avl, box(352), box(1086), NULL);
-  avl = remove_int(avl, 983);
-  avl = gpr_avl_add(avl, box(6), box(1088), NULL);
-  avl = gpr_avl_add(avl, box(1014), box(1089), NULL);
-  avl = remove_int(avl, 98);
-  avl = remove_int(avl, 325);
-  avl = gpr_avl_add(avl, box(851), box(1092), NULL);
-  avl = remove_int(avl, 553);
-  avl = gpr_avl_add(avl, box(218), box(1094), NULL);
-  avl = gpr_avl_add(avl, box(261), box(1095), NULL);
-  avl = remove_int(avl, 31);
-  avl = gpr_avl_add(avl, box(872), box(1097), NULL);
-  avl = remove_int(avl, 543);
-  avl = remove_int(avl, 314);
-  avl = remove_int(avl, 443);
-  avl = gpr_avl_add(avl, box(533), box(1101), NULL);
-  avl = remove_int(avl, 881);
-  avl = remove_int(avl, 269);
-  avl = remove_int(avl, 940);
-  avl = remove_int(avl, 909);
-  avl = remove_int(avl, 197);
-  avl = remove_int(avl, 773);
-  avl = remove_int(avl, 790);
-  avl = remove_int(avl, 345);
-  avl = gpr_avl_add(avl, box(965), box(1110), NULL);
-  avl = remove_int(avl, 622);
-  avl = gpr_avl_add(avl, box(352), box(1112), NULL);
-  avl = remove_int(avl, 182);
-  avl = gpr_avl_add(avl, box(534), box(1114), NULL);
-  avl = gpr_avl_add(avl, box(97), box(1115), NULL);
-  avl = gpr_avl_add(avl, box(198), box(1116), NULL);
-  avl = remove_int(avl, 750);
-  avl = gpr_avl_add(avl, box(98), box(1118), NULL);
-  avl = remove_int(avl, 943);
-  avl = gpr_avl_add(avl, box(254), box(1120), NULL);
-  avl = gpr_avl_add(avl, box(30), box(1121), NULL);
-  avl = remove_int(avl, 14);
-  avl = remove_int(avl, 475);
-  avl = remove_int(avl, 82);
-  avl = gpr_avl_add(avl, box(789), box(1125), NULL);
-  avl = gpr_avl_add(avl, box(402), box(1126), NULL);
-  avl = remove_int(avl, 1019);
-  avl = gpr_avl_add(avl, box(858), box(1128), NULL);
-  avl = gpr_avl_add(avl, box(625), box(1129), NULL);
-  avl = remove_int(avl, 675);
-  avl = remove_int(avl, 323);
-  avl = gpr_avl_add(avl, box(329), box(1132), NULL);
-  avl = remove_int(avl, 929);
-  avl = remove_int(avl, 44);
-  avl = gpr_avl_add(avl, box(443), box(1135), NULL);
-  avl = gpr_avl_add(avl, box(653), box(1136), NULL);
-  avl = gpr_avl_add(avl, box(750), box(1137), NULL);
-  avl = gpr_avl_add(avl, box(252), box(1138), NULL);
-  avl = gpr_avl_add(avl, box(449), box(1139), NULL);
-  avl = remove_int(avl, 1022);
-  avl = remove_int(avl, 357);
-  avl = remove_int(avl, 602);
-  avl = remove_int(avl, 131);
-  avl = gpr_avl_add(avl, box(531), box(1144), NULL);
-  avl = remove_int(avl, 806);
-  avl = gpr_avl_add(avl, box(455), box(1146), NULL);
-  avl = remove_int(avl, 31);
-  avl = gpr_avl_add(avl, box(154), box(1148), NULL);
-  avl = gpr_avl_add(avl, box(189), box(1149), NULL);
-  avl = remove_int(avl, 786);
-  avl = gpr_avl_add(avl, box(496), box(1151), NULL);
-  avl = gpr_avl_add(avl, box(81), box(1152), NULL);
-  avl = gpr_avl_add(avl, box(59), box(1153), NULL);
-  avl = remove_int(avl, 424);
-  avl = remove_int(avl, 668);
-  avl = gpr_avl_add(avl, box(723), box(1156), NULL);
-  avl = gpr_avl_add(avl, box(822), box(1157), NULL);
-  avl = gpr_avl_add(avl, box(354), box(1158), NULL);
-  avl = remove_int(avl, 738);
-  avl = gpr_avl_add(avl, box(686), box(1160), NULL);
-  avl = gpr_avl_add(avl, box(43), box(1161), NULL);
-  avl = gpr_avl_add(avl, box(625), box(1162), NULL);
-  avl = gpr_avl_add(avl, box(902), box(1163), NULL);
-  avl = gpr_avl_add(avl, box(12), box(1164), NULL);
-  avl = gpr_avl_add(avl, box(977), box(1165), NULL);
-  avl = gpr_avl_add(avl, box(699), box(1166), NULL);
-  avl = gpr_avl_add(avl, box(189), box(1167), NULL);
-  avl = remove_int(avl, 672);
-  avl = remove_int(avl, 90);
-  avl = remove_int(avl, 757);
-  avl = remove_int(avl, 494);
-  avl = gpr_avl_add(avl, box(759), box(1172), NULL);
-  avl = remove_int(avl, 758);
-  avl = remove_int(avl, 222);
-  avl = gpr_avl_add(avl, box(975), box(1175), NULL);
-  avl = remove_int(avl, 993);
-  avl = gpr_avl_add(avl, box(2), box(1177), NULL);
-  avl = gpr_avl_add(avl, box(70), box(1178), NULL);
-  avl = remove_int(avl, 350);
-  avl = remove_int(avl, 972);
-  avl = remove_int(avl, 880);
-  avl = gpr_avl_add(avl, box(753), box(1182), NULL);
-  avl = remove_int(avl, 404);
-  avl = gpr_avl_add(avl, box(294), box(1184), NULL);
-  avl = remove_int(avl, 474);
-  avl = gpr_avl_add(avl, box(228), box(1186), NULL);
-  avl = gpr_avl_add(avl, box(484), box(1187), NULL);
-  avl = remove_int(avl, 238);
-  avl = remove_int(avl, 53);
-  avl = remove_int(avl, 691);
-  avl = gpr_avl_add(avl, box(345), box(1191), NULL);
-  avl = remove_int(avl, 0);
-  avl = gpr_avl_add(avl, box(230), box(1193), NULL);
-  avl = remove_int(avl, 227);
-  avl = remove_int(avl, 152);
-  avl = gpr_avl_add(avl, box(884), box(1196), NULL);
-  avl = remove_int(avl, 823);
-  avl = remove_int(avl, 53);
-  avl = gpr_avl_add(avl, box(1015), box(1199), NULL);
-  avl = gpr_avl_add(avl, box(697), box(1200), NULL);
-  avl = gpr_avl_add(avl, box(376), box(1201), NULL);
-  avl = remove_int(avl, 411);
-  avl = gpr_avl_add(avl, box(888), box(1203), NULL);
-  avl = remove_int(avl, 55);
-  avl = gpr_avl_add(avl, box(85), box(1205), NULL);
-  avl = remove_int(avl, 947);
-  avl = remove_int(avl, 382);
-  avl = remove_int(avl, 777);
-  avl = gpr_avl_add(avl, box(1017), box(1209), NULL);
-  avl = gpr_avl_add(avl, box(169), box(1210), NULL);
-  avl = gpr_avl_add(avl, box(156), box(1211), NULL);
-  avl = remove_int(avl, 153);
-  avl = remove_int(avl, 642);
-  avl = remove_int(avl, 158);
-  avl = gpr_avl_add(avl, box(554), box(1215), NULL);
-  avl = gpr_avl_add(avl, box(76), box(1216), NULL);
-  avl = gpr_avl_add(avl, box(756), box(1217), NULL);
-  avl = remove_int(avl, 767);
-  avl = remove_int(avl, 112);
-  avl = remove_int(avl, 539);
-  avl = remove_int(avl, 544);
-  avl = remove_int(avl, 628);
-  avl = remove_int(avl, 385);
-  avl = remove_int(avl, 514);
-  avl = remove_int(avl, 362);
-  avl = gpr_avl_add(avl, box(523), box(1226), NULL);
-  avl = gpr_avl_add(avl, box(712), box(1227), NULL);
-  avl = gpr_avl_add(avl, box(474), box(1228), NULL);
-  avl = gpr_avl_add(avl, box(882), box(1229), NULL);
-  avl = gpr_avl_add(avl, box(965), box(1230), NULL);
-  avl = remove_int(avl, 464);
-  avl = gpr_avl_add(avl, box(319), box(1232), NULL);
-  avl = gpr_avl_add(avl, box(504), box(1233), NULL);
-  avl = remove_int(avl, 818);
-  avl = gpr_avl_add(avl, box(884), box(1235), NULL);
-  avl = gpr_avl_add(avl, box(813), box(1236), NULL);
-  avl = gpr_avl_add(avl, box(795), box(1237), NULL);
-  avl = remove_int(avl, 306);
-  avl = gpr_avl_add(avl, box(799), box(1239), NULL);
-  avl = remove_int(avl, 534);
-  avl = gpr_avl_add(avl, box(480), box(1241), NULL);
-  avl = gpr_avl_add(avl, box(656), box(1242), NULL);
-  avl = gpr_avl_add(avl, box(709), box(1243), NULL);
-  avl = gpr_avl_add(avl, box(500), box(1244), NULL);
-  avl = remove_int(avl, 740);
-  avl = gpr_avl_add(avl, box(980), box(1246), NULL);
-  avl = gpr_avl_add(avl, box(458), box(1247), NULL);
-  avl = remove_int(avl, 377);
-  avl = remove_int(avl, 338);
-  avl = gpr_avl_add(avl, box(554), box(1250), NULL);
-  avl = gpr_avl_add(avl, box(504), box(1251), NULL);
-  avl = gpr_avl_add(avl, box(603), box(1252), NULL);
-  avl = gpr_avl_add(avl, box(761), box(1253), NULL);
-  avl = remove_int(avl, 431);
-  avl = gpr_avl_add(avl, box(707), box(1255), NULL);
-  avl = gpr_avl_add(avl, box(673), box(1256), NULL);
-  avl = remove_int(avl, 998);
-  avl = remove_int(avl, 332);
-  avl = remove_int(avl, 413);
-  avl = remove_int(avl, 227);
-  avl = remove_int(avl, 249);
-  avl = remove_int(avl, 309);
-  avl = remove_int(avl, 459);
-  avl = gpr_avl_add(avl, box(645), box(1264), NULL);
-  avl = remove_int(avl, 858);
-  avl = remove_int(avl, 997);
-  avl = gpr_avl_add(avl, box(519), box(1267), NULL);
-  avl = remove_int(avl, 614);
-  avl = remove_int(avl, 462);
-  avl = remove_int(avl, 792);
-  avl = gpr_avl_add(avl, box(987), box(1271), NULL);
-  avl = gpr_avl_add(avl, box(309), box(1272), NULL);
-  avl = remove_int(avl, 747);
-  avl = gpr_avl_add(avl, box(621), box(1274), NULL);
-  avl = gpr_avl_add(avl, box(450), box(1275), NULL);
-  avl = remove_int(avl, 265);
-  avl = remove_int(avl, 8);
-  avl = remove_int(avl, 383);
-  avl = gpr_avl_add(avl, box(238), box(1279), NULL);
-  avl = remove_int(avl, 241);
-  avl = gpr_avl_add(avl, box(180), box(1281), NULL);
-  avl = gpr_avl_add(avl, box(411), box(1282), NULL);
-  avl = gpr_avl_add(avl, box(791), box(1283), NULL);
-  avl = gpr_avl_add(avl, box(955), box(1284), NULL);
-  avl = remove_int(avl, 24);
-  avl = remove_int(avl, 375);
-  avl = gpr_avl_add(avl, box(140), box(1287), NULL);
-  avl = remove_int(avl, 949);
-  avl = gpr_avl_add(avl, box(301), box(1289), NULL);
-  avl = gpr_avl_add(avl, box(0), box(1290), NULL);
-  avl = remove_int(avl, 371);
-  avl = remove_int(avl, 427);
-  avl = remove_int(avl, 841);
-  avl = remove_int(avl, 847);
-  avl = gpr_avl_add(avl, box(814), box(1295), NULL);
-  avl = gpr_avl_add(avl, box(127), box(1296), NULL);
-  avl = gpr_avl_add(avl, box(279), box(1297), NULL);
-  avl = remove_int(avl, 669);
-  avl = remove_int(avl, 541);
-  avl = remove_int(avl, 275);
-  avl = remove_int(avl, 299);
-  avl = remove_int(avl, 552);
-  avl = gpr_avl_add(avl, box(310), box(1303), NULL);
-  avl = gpr_avl_add(avl, box(304), box(1304), NULL);
-  avl = gpr_avl_add(avl, box(1), box(1305), NULL);
-  avl = gpr_avl_add(avl, box(339), box(1306), NULL);
-  avl = remove_int(avl, 570);
-  avl = remove_int(avl, 752);
-  avl = remove_int(avl, 552);
-  avl = remove_int(avl, 442);
-  avl = remove_int(avl, 639);
-  avl = gpr_avl_add(avl, box(313), box(1312), NULL);
-  avl = remove_int(avl, 85);
-  avl = gpr_avl_add(avl, box(964), box(1314), NULL);
-  avl = gpr_avl_add(avl, box(559), box(1315), NULL);
-  avl = remove_int(avl, 167);
-  avl = gpr_avl_add(avl, box(866), box(1317), NULL);
-  avl = remove_int(avl, 275);
-  avl = gpr_avl_add(avl, box(173), box(1319), NULL);
-  avl = gpr_avl_add(avl, box(765), box(1320), NULL);
-  avl = remove_int(avl, 883);
-  avl = gpr_avl_add(avl, box(547), box(1322), NULL);
-  avl = gpr_avl_add(avl, box(847), box(1323), NULL);
-  avl = remove_int(avl, 817);
-  avl = remove_int(avl, 850);
-  avl = remove_int(avl, 718);
-  avl = gpr_avl_add(avl, box(806), box(1327), NULL);
-  avl = gpr_avl_add(avl, box(360), box(1328), NULL);
-  avl = remove_int(avl, 991);
-  avl = gpr_avl_add(avl, box(493), box(1330), NULL);
-  avl = remove_int(avl, 516);
-  avl = gpr_avl_add(avl, box(361), box(1332), NULL);
-  avl = remove_int(avl, 355);
-  avl = gpr_avl_add(avl, box(512), box(1334), NULL);
-  avl = gpr_avl_add(avl, box(191), box(1335), NULL);
-  avl = remove_int(avl, 703);
-  avl = gpr_avl_add(avl, box(333), box(1337), NULL);
-  avl = remove_int(avl, 481);
-  avl = gpr_avl_add(avl, box(501), box(1339), NULL);
-  avl = remove_int(avl, 532);
-  avl = remove_int(avl, 510);
-  avl = gpr_avl_add(avl, box(793), box(1342), NULL);
-  avl = gpr_avl_add(avl, box(234), box(1343), NULL);
-  avl = remove_int(avl, 159);
-  avl = remove_int(avl, 429);
-  avl = remove_int(avl, 728);
-  avl = remove_int(avl, 288);
-  avl = gpr_avl_add(avl, box(281), box(1348), NULL);
-  avl = gpr_avl_add(avl, box(702), box(1349), NULL);
-  avl = gpr_avl_add(avl, box(149), box(1350), NULL);
-  avl = remove_int(avl, 22);
-  avl = remove_int(avl, 944);
-  avl = remove_int(avl, 55);
-  avl = remove_int(avl, 512);
-  avl = remove_int(avl, 676);
-  avl = remove_int(avl, 884);
-  avl = gpr_avl_add(avl, box(246), box(1357), NULL);
-  avl = gpr_avl_add(avl, box(455), box(1358), NULL);
-  avl = remove_int(avl, 782);
-  avl = remove_int(avl, 682);
-  avl = gpr_avl_add(avl, box(243), box(1361), NULL);
-  avl = gpr_avl_add(avl, box(109), box(1362), NULL);
-  avl = gpr_avl_add(avl, box(452), box(1363), NULL);
-  avl = remove_int(avl, 151);
-  avl = gpr_avl_add(avl, box(159), box(1365), NULL);
-  avl = remove_int(avl, 1023);
-  avl = gpr_avl_add(avl, box(129), box(1367), NULL);
-  avl = gpr_avl_add(avl, box(537), box(1368), NULL);
-  avl = remove_int(avl, 321);
-  avl = gpr_avl_add(avl, box(740), box(1370), NULL);
-  avl = remove_int(avl, 45);
-  avl = remove_int(avl, 136);
-  avl = gpr_avl_add(avl, box(229), box(1373), NULL);
-  avl = remove_int(avl, 772);
-  avl = gpr_avl_add(avl, box(181), box(1375), NULL);
-  avl = remove_int(avl, 175);
-  avl = gpr_avl_add(avl, box(817), box(1377), NULL);
-  avl = remove_int(avl, 956);
-  avl = gpr_avl_add(avl, box(675), box(1379), NULL);
-  avl = gpr_avl_add(avl, box(375), box(1380), NULL);
-  avl = remove_int(avl, 384);
-  avl = gpr_avl_add(avl, box(1016), box(1382), NULL);
-  avl = remove_int(avl, 295);
-  avl = remove_int(avl, 697);
-  avl = remove_int(avl, 554);
-  avl = remove_int(avl, 590);
-  avl = remove_int(avl, 1014);
-  avl = gpr_avl_add(avl, box(890), box(1388), NULL);
-  avl = gpr_avl_add(avl, box(293), box(1389), NULL);
-  avl = remove_int(avl, 207);
-  avl = remove_int(avl, 46);
-  avl = gpr_avl_add(avl, box(899), box(1392), NULL);
-  avl = gpr_avl_add(avl, box(666), box(1393), NULL);
-  avl = gpr_avl_add(avl, box(85), box(1394), NULL);
-  avl = gpr_avl_add(avl, box(914), box(1395), NULL);
-  avl = gpr_avl_add(avl, box(128), box(1396), NULL);
-  avl = gpr_avl_add(avl, box(835), box(1397), NULL);
-  avl = gpr_avl_add(avl, box(787), box(1398), NULL);
-  avl = gpr_avl_add(avl, box(649), box(1399), NULL);
-  avl = gpr_avl_add(avl, box(723), box(1400), NULL);
-  avl = remove_int(avl, 874);
-  avl = gpr_avl_add(avl, box(778), box(1402), NULL);
-  avl = gpr_avl_add(avl, box(1015), box(1403), NULL);
-  avl = gpr_avl_add(avl, box(59), box(1404), NULL);
-  avl = gpr_avl_add(avl, box(259), box(1405), NULL);
-  avl = gpr_avl_add(avl, box(758), box(1406), NULL);
-  avl = remove_int(avl, 648);
-  avl = gpr_avl_add(avl, box(145), box(1408), NULL);
-  avl = gpr_avl_add(avl, box(440), box(1409), NULL);
-  avl = remove_int(avl, 608);
-  avl = remove_int(avl, 690);
-  avl = gpr_avl_add(avl, box(605), box(1412), NULL);
-  avl = remove_int(avl, 856);
-  avl = remove_int(avl, 608);
-  avl = gpr_avl_add(avl, box(829), box(1415), NULL);
-  avl = gpr_avl_add(avl, box(660), box(1416), NULL);
-  avl = remove_int(avl, 596);
-  avl = gpr_avl_add(avl, box(519), box(1418), NULL);
-  avl = gpr_avl_add(avl, box(35), box(1419), NULL);
-  avl = gpr_avl_add(avl, box(871), box(1420), NULL);
-  avl = remove_int(avl, 845);
-  avl = gpr_avl_add(avl, box(600), box(1422), NULL);
-  avl = gpr_avl_add(avl, box(215), box(1423), NULL);
-  avl = remove_int(avl, 761);
-  avl = gpr_avl_add(avl, box(975), box(1425), NULL);
-  avl = remove_int(avl, 987);
-  avl = gpr_avl_add(avl, box(58), box(1427), NULL);
-  avl = remove_int(avl, 119);
-  avl = gpr_avl_add(avl, box(937), box(1429), NULL);
-  avl = gpr_avl_add(avl, box(372), box(1430), NULL);
-  avl = gpr_avl_add(avl, box(11), box(1431), NULL);
-  avl = gpr_avl_add(avl, box(398), box(1432), NULL);
-  avl = gpr_avl_add(avl, box(423), box(1433), NULL);
-  avl = remove_int(avl, 171);
-  avl = gpr_avl_add(avl, box(473), box(1435), NULL);
-  avl = remove_int(avl, 752);
-  avl = remove_int(avl, 625);
-  avl = remove_int(avl, 764);
-  avl = remove_int(avl, 49);
-  avl = gpr_avl_add(avl, box(472), box(1440), NULL);
-  avl = remove_int(avl, 847);
-  avl = remove_int(avl, 642);
-  avl = remove_int(avl, 1004);
-  avl = remove_int(avl, 795);
-  avl = remove_int(avl, 465);
-  avl = gpr_avl_add(avl, box(636), box(1446), NULL);
-  avl = remove_int(avl, 152);
-  avl = gpr_avl_add(avl, box(61), box(1448), NULL);
-  avl = remove_int(avl, 929);
-  avl = remove_int(avl, 9);
-  avl = gpr_avl_add(avl, box(251), box(1451), NULL);
-  avl = gpr_avl_add(avl, box(672), box(1452), NULL);
-  avl = gpr_avl_add(avl, box(66), box(1453), NULL);
-  avl = remove_int(avl, 693);
-  avl = remove_int(avl, 914);
-  avl = remove_int(avl, 116);
-  avl = remove_int(avl, 577);
-  avl = gpr_avl_add(avl, box(618), box(1458), NULL);
-  avl = gpr_avl_add(avl, box(495), box(1459), NULL);
-  avl = remove_int(avl, 450);
-  avl = gpr_avl_add(avl, box(533), box(1461), NULL);
-  avl = gpr_avl_add(avl, box(414), box(1462), NULL);
-  avl = remove_int(avl, 74);
-  avl = remove_int(avl, 236);
-  avl = gpr_avl_add(avl, box(707), box(1465), NULL);
-  avl = gpr_avl_add(avl, box(357), box(1466), NULL);
-  avl = gpr_avl_add(avl, box(1007), box(1467), NULL);
-  avl = gpr_avl_add(avl, box(811), box(1468), NULL);
-  avl = gpr_avl_add(avl, box(418), box(1469), NULL);
-  avl = gpr_avl_add(avl, box(164), box(1470), NULL);
-  avl = gpr_avl_add(avl, box(622), box(1471), NULL);
-  avl = remove_int(avl, 22);
-  avl = remove_int(avl, 14);
-  avl = remove_int(avl, 732);
-  avl = remove_int(avl, 7);
-  avl = remove_int(avl, 447);
-  avl = gpr_avl_add(avl, box(221), box(1477), NULL);
-  avl = gpr_avl_add(avl, box(202), box(1478), NULL);
-  avl = gpr_avl_add(avl, box(312), box(1479), NULL);
-  avl = remove_int(avl, 274);
-  avl = gpr_avl_add(avl, box(684), box(1481), NULL);
-  avl = gpr_avl_add(avl, box(954), box(1482), NULL);
-  avl = gpr_avl_add(avl, box(637), box(1483), NULL);
-  avl = remove_int(avl, 716);
-  avl = gpr_avl_add(avl, box(198), box(1485), NULL);
-  avl = remove_int(avl, 340);
-  avl = remove_int(avl, 137);
-  avl = remove_int(avl, 995);
-  avl = remove_int(avl, 1004);
-  avl = gpr_avl_add(avl, box(661), box(1490), NULL);
-  avl = gpr_avl_add(avl, box(862), box(1491), NULL);
-  avl = remove_int(avl, 527);
-  avl = gpr_avl_add(avl, box(945), box(1493), NULL);
-  avl = remove_int(avl, 355);
-  avl = remove_int(avl, 144);
-  avl = gpr_avl_add(avl, box(229), box(1496), NULL);
-  avl = gpr_avl_add(avl, box(237), box(1497), NULL);
-  avl = remove_int(avl, 471);
-  avl = remove_int(avl, 901);
-  avl = gpr_avl_add(avl, box(905), box(1500), NULL);
-  avl = remove_int(avl, 19);
-  avl = remove_int(avl, 896);
-  avl = remove_int(avl, 585);
-  avl = remove_int(avl, 308);
-  avl = gpr_avl_add(avl, box(547), box(1505), NULL);
-  avl = gpr_avl_add(avl, box(552), box(1506), NULL);
-  avl = gpr_avl_add(avl, box(30), box(1507), NULL);
-  avl = gpr_avl_add(avl, box(445), box(1508), NULL);
-  avl = remove_int(avl, 785);
-  avl = remove_int(avl, 185);
-  avl = gpr_avl_add(avl, box(405), box(1511), NULL);
-  avl = gpr_avl_add(avl, box(733), box(1512), NULL);
-  avl = gpr_avl_add(avl, box(573), box(1513), NULL);
-  avl = gpr_avl_add(avl, box(492), box(1514), NULL);
-  avl = gpr_avl_add(avl, box(343), box(1515), NULL);
-  avl = gpr_avl_add(avl, box(527), box(1516), NULL);
-  avl = gpr_avl_add(avl, box(596), box(1517), NULL);
-  avl = gpr_avl_add(avl, box(519), box(1518), NULL);
-  avl = remove_int(avl, 243);
-  avl = remove_int(avl, 722);
-  avl = gpr_avl_add(avl, box(772), box(1521), NULL);
-  avl = remove_int(avl, 152);
-  avl = remove_int(avl, 305);
-  avl = gpr_avl_add(avl, box(754), box(1524), NULL);
-  avl = gpr_avl_add(avl, box(373), box(1525), NULL);
-  avl = remove_int(avl, 995);
-  avl = gpr_avl_add(avl, box(329), box(1527), NULL);
-  avl = remove_int(avl, 397);
-  avl = gpr_avl_add(avl, box(884), box(1529), NULL);
-  avl = remove_int(avl, 329);
-  avl = remove_int(avl, 240);
-  avl = gpr_avl_add(avl, box(566), box(1532), NULL);
-  avl = gpr_avl_add(avl, box(232), box(1533), NULL);
-  avl = remove_int(avl, 993);
-  avl = gpr_avl_add(avl, box(888), box(1535), NULL);
-  avl = remove_int(avl, 242);
-  avl = gpr_avl_add(avl, box(941), box(1537), NULL);
-  avl = remove_int(avl, 415);
-  avl = gpr_avl_add(avl, box(992), box(1539), NULL);
-  avl = remove_int(avl, 289);
-  avl = gpr_avl_add(avl, box(60), box(1541), NULL);
-  avl = gpr_avl_add(avl, box(97), box(1542), NULL);
-  avl = remove_int(avl, 965);
-  avl = remove_int(avl, 267);
-  avl = remove_int(avl, 360);
-  avl = gpr_avl_add(avl, box(5), box(1546), NULL);
-  avl = remove_int(avl, 429);
-  avl = gpr_avl_add(avl, box(412), box(1548), NULL);
-  avl = remove_int(avl, 632);
-  avl = remove_int(avl, 113);
-  avl = gpr_avl_add(avl, box(48), box(1551), NULL);
-  avl = gpr_avl_add(avl, box(108), box(1552), NULL);
-  avl = gpr_avl_add(avl, box(750), box(1553), NULL);
-  avl = remove_int(avl, 188);
-  avl = gpr_avl_add(avl, box(668), box(1555), NULL);
-  avl = remove_int(avl, 37);
-  avl = remove_int(avl, 737);
-  avl = gpr_avl_add(avl, box(93), box(1558), NULL);
-  avl = gpr_avl_add(avl, box(628), box(1559), NULL);
-  avl = gpr_avl_add(avl, box(480), box(1560), NULL);
-  avl = remove_int(avl, 958);
-  avl = remove_int(avl, 565);
-  avl = remove_int(avl, 32);
-  avl = remove_int(avl, 1);
-  avl = remove_int(avl, 335);
-  avl = gpr_avl_add(avl, box(136), box(1566), NULL);
-  avl = gpr_avl_add(avl, box(469), box(1567), NULL);
-  avl = remove_int(avl, 349);
-  avl = gpr_avl_add(avl, box(768), box(1569), NULL);
-  avl = gpr_avl_add(avl, box(915), box(1570), NULL);
-  avl = remove_int(avl, 1014);
-  avl = gpr_avl_add(avl, box(117), box(1572), NULL);
-  avl = remove_int(avl, 62);
-  avl = gpr_avl_add(avl, box(382), box(1574), NULL);
-  avl = remove_int(avl, 571);
-  avl = gpr_avl_add(avl, box(655), box(1576), NULL);
-  avl = gpr_avl_add(avl, box(323), box(1577), NULL);
-  avl = remove_int(avl, 869);
-  avl = remove_int(avl, 151);
-  avl = gpr_avl_add(avl, box(1019), box(1580), NULL);
-  avl = gpr_avl_add(avl, box(984), box(1581), NULL);
-  avl = gpr_avl_add(avl, box(870), box(1582), NULL);
-  avl = gpr_avl_add(avl, box(376), box(1583), NULL);
-  avl = remove_int(avl, 625);
-  avl = gpr_avl_add(avl, box(733), box(1585), NULL);
-  avl = remove_int(avl, 532);
-  avl = remove_int(avl, 444);
-  avl = gpr_avl_add(avl, box(428), box(1588), NULL);
-  avl = gpr_avl_add(avl, box(860), box(1589), NULL);
-  avl = gpr_avl_add(avl, box(173), box(1590), NULL);
-  avl = remove_int(avl, 649);
-  avl = remove_int(avl, 913);
-  avl = remove_int(avl, 1);
-  avl = remove_int(avl, 304);
-  avl = gpr_avl_add(avl, box(604), box(1595), NULL);
-  avl = gpr_avl_add(avl, box(639), box(1596), NULL);
-  avl = remove_int(avl, 431);
-  avl = gpr_avl_add(avl, box(993), box(1598), NULL);
-  avl = remove_int(avl, 681);
-  avl = remove_int(avl, 927);
-  avl = gpr_avl_add(avl, box(87), box(1601), NULL);
-  avl = gpr_avl_add(avl, box(91), box(1602), NULL);
-  avl = remove_int(avl, 61);
-  avl = remove_int(avl, 14);
-  avl = remove_int(avl, 305);
-  avl = remove_int(avl, 304);
-  avl = remove_int(avl, 1016);
-  avl = gpr_avl_add(avl, box(903), box(1608), NULL);
-  avl = gpr_avl_add(avl, box(951), box(1609), NULL);
-  avl = gpr_avl_add(avl, box(146), box(1610), NULL);
-  avl = gpr_avl_add(avl, box(482), box(1611), NULL);
-  avl = gpr_avl_add(avl, box(71), box(1612), NULL);
-  avl = remove_int(avl, 246);
-  avl = remove_int(avl, 696);
-  avl = gpr_avl_add(avl, box(636), box(1615), NULL);
-  avl = gpr_avl_add(avl, box(295), box(1616), NULL);
-  avl = remove_int(avl, 11);
-  avl = remove_int(avl, 231);
-  avl = gpr_avl_add(avl, box(905), box(1619), NULL);
-  avl = gpr_avl_add(avl, box(993), box(1620), NULL);
-  avl = gpr_avl_add(avl, box(433), box(1621), NULL);
-  avl = gpr_avl_add(avl, box(117), box(1622), NULL);
-  avl = gpr_avl_add(avl, box(467), box(1623), NULL);
-  avl = remove_int(avl, 419);
-  avl = gpr_avl_add(avl, box(179), box(1625), NULL);
-  avl = remove_int(avl, 926);
-  avl = remove_int(avl, 326);
-  avl = gpr_avl_add(avl, box(551), box(1628), NULL);
-  avl = remove_int(avl, 14);
-  avl = remove_int(avl, 476);
-  avl = remove_int(avl, 823);
-  avl = gpr_avl_add(avl, box(350), box(1632), NULL);
-  avl = gpr_avl_add(avl, box(133), box(1633), NULL);
-  avl = remove_int(avl, 906);
-  avl = gpr_avl_add(avl, box(827), box(1635), NULL);
-  avl = gpr_avl_add(avl, box(201), box(1636), NULL);
-  avl = remove_int(avl, 124);
-  avl = remove_int(avl, 662);
-  avl = gpr_avl_add(avl, box(314), box(1639), NULL);
-  avl = gpr_avl_add(avl, box(986), box(1640), NULL);
-  avl = gpr_avl_add(avl, box(622), box(1641), NULL);
-  avl = remove_int(avl, 130);
-  avl = gpr_avl_add(avl, box(861), box(1643), NULL);
-  avl = remove_int(avl, 497);
-  avl = remove_int(avl, 905);
-  avl = gpr_avl_add(avl, box(502), box(1646), NULL);
-  avl = remove_int(avl, 721);
-  avl = gpr_avl_add(avl, box(514), box(1648), NULL);
-  avl = gpr_avl_add(avl, box(410), box(1649), NULL);
-  avl = remove_int(avl, 869);
-  avl = remove_int(avl, 247);
-  avl = gpr_avl_add(avl, box(450), box(1652), NULL);
-  avl = remove_int(avl, 364);
-  avl = gpr_avl_add(avl, box(963), box(1654), NULL);
-  avl = gpr_avl_add(avl, box(146), box(1655), NULL);
-  avl = remove_int(avl, 147);
-  avl = remove_int(avl, 789);
-  avl = gpr_avl_add(avl, box(693), box(1658), NULL);
-  avl = gpr_avl_add(avl, box(959), box(1659), NULL);
-  avl = remove_int(avl, 478);
-  avl = gpr_avl_add(avl, box(116), box(1661), NULL);
-  avl = gpr_avl_add(avl, box(520), box(1662), NULL);
-  avl = gpr_avl_add(avl, box(809), box(1663), NULL);
-  avl = gpr_avl_add(avl, box(667), box(1664), NULL);
-  avl = gpr_avl_add(avl, box(406), box(1665), NULL);
-  avl = remove_int(avl, 409);
-  avl = gpr_avl_add(avl, box(558), box(1667), NULL);
-  avl = gpr_avl_add(avl, box(0), box(1668), NULL);
-  avl = gpr_avl_add(avl, box(948), box(1669), NULL);
-  avl = gpr_avl_add(avl, box(576), box(1670), NULL);
-  avl = remove_int(avl, 864);
-  avl = remove_int(avl, 840);
-  avl = remove_int(avl, 1001);
-  avl = gpr_avl_add(avl, box(232), box(1674), NULL);
-  avl = remove_int(avl, 676);
-  avl = remove_int(avl, 752);
-  avl = remove_int(avl, 667);
-  avl = remove_int(avl, 605);
-  avl = gpr_avl_add(avl, box(258), box(1679), NULL);
-  avl = gpr_avl_add(avl, box(648), box(1680), NULL);
-  avl = gpr_avl_add(avl, box(761), box(1681), NULL);
-  avl = remove_int(avl, 293);
-  avl = remove_int(avl, 893);
-  avl = gpr_avl_add(avl, box(194), box(1684), NULL);
-  avl = remove_int(avl, 233);
-  avl = gpr_avl_add(avl, box(888), box(1686), NULL);
-  avl = remove_int(avl, 470);
-  avl = remove_int(avl, 703);
-  avl = remove_int(avl, 190);
-  avl = remove_int(avl, 359);
-  avl = gpr_avl_add(avl, box(621), box(1691), NULL);
-  avl = remove_int(avl, 634);
-  avl = remove_int(avl, 335);
-  avl = gpr_avl_add(avl, box(718), box(1694), NULL);
-  avl = gpr_avl_add(avl, box(463), box(1695), NULL);
-  avl = gpr_avl_add(avl, box(233), box(1696), NULL);
-  avl = remove_int(avl, 376);
-  avl = remove_int(avl, 496);
-  avl = remove_int(avl, 819);
-  avl = remove_int(avl, 38);
-  avl = remove_int(avl, 436);
-  avl = remove_int(avl, 102);
-  avl = gpr_avl_add(avl, box(607), box(1703), NULL);
-  avl = remove_int(avl, 329);
-  avl = gpr_avl_add(avl, box(716), box(1705), NULL);
-  avl = remove_int(avl, 639);
-  avl = remove_int(avl, 775);
-  avl = remove_int(avl, 578);
-  avl = remove_int(avl, 464);
-  avl = remove_int(avl, 679);
-  avl = remove_int(avl, 615);
-  avl = remove_int(avl, 104);
-  avl = gpr_avl_add(avl, box(414), box(1713), NULL);
-  avl = gpr_avl_add(avl, box(212), box(1714), NULL);
-  avl = gpr_avl_add(avl, box(266), box(1715), NULL);
-  avl = gpr_avl_add(avl, box(238), box(1716), NULL);
-  avl = remove_int(avl, 153);
-  avl = gpr_avl_add(avl, box(585), box(1718), NULL);
-  avl = remove_int(avl, 121);
-  avl = gpr_avl_add(avl, box(534), box(1720), NULL);
-  avl = remove_int(avl, 579);
-  avl = gpr_avl_add(avl, box(127), box(1722), NULL);
-  avl = gpr_avl_add(avl, box(399), box(1723), NULL);
-  avl = remove_int(avl, 417);
-  avl = gpr_avl_add(avl, box(978), box(1725), NULL);
-  avl = gpr_avl_add(avl, box(768), box(1726), NULL);
-  avl = remove_int(avl, 985);
-  avl = gpr_avl_add(avl, box(536), box(1728), NULL);
-  avl = gpr_avl_add(avl, box(449), box(1729), NULL);
-  avl = gpr_avl_add(avl, box(586), box(1730), NULL);
-  avl = remove_int(avl, 998);
-  avl = remove_int(avl, 394);
-  avl = remove_int(avl, 141);
-  avl = gpr_avl_add(avl, box(889), box(1734), NULL);
-  avl = gpr_avl_add(avl, box(871), box(1735), NULL);
-  avl = gpr_avl_add(avl, box(76), box(1736), NULL);
-  avl = gpr_avl_add(avl, box(549), box(1737), NULL);
-  avl = gpr_avl_add(avl, box(757), box(1738), NULL);
-  avl = remove_int(avl, 908);
-  avl = gpr_avl_add(avl, box(789), box(1740), NULL);
-  avl = remove_int(avl, 224);
-  avl = gpr_avl_add(avl, box(407), box(1742), NULL);
-  avl = gpr_avl_add(avl, box(381), box(1743), NULL);
-  avl = gpr_avl_add(avl, box(561), box(1744), NULL);
-  avl = gpr_avl_add(avl, box(667), box(1745), NULL);
-  avl = gpr_avl_add(avl, box(522), box(1746), NULL);
-  avl = gpr_avl_add(avl, box(948), box(1747), NULL);
-  avl = remove_int(avl, 770);
-  avl = gpr_avl_add(avl, box(872), box(1749), NULL);
-  avl = gpr_avl_add(avl, box(327), box(1750), NULL);
-  avl = remove_int(avl, 10);
-  avl = gpr_avl_add(avl, box(122), box(1752), NULL);
-  avl = remove_int(avl, 606);
-  avl = gpr_avl_add(avl, box(485), box(1754), NULL);
-  avl = remove_int(avl, 6);
-  avl = gpr_avl_add(avl, box(329), box(1756), NULL);
-  avl = gpr_avl_add(avl, box(783), box(1757), NULL);
-  avl = remove_int(avl, 416);
-  avl = gpr_avl_add(avl, box(656), box(1759), NULL);
-  avl = gpr_avl_add(avl, box(971), box(1760), NULL);
-  avl = gpr_avl_add(avl, box(77), box(1761), NULL);
-  avl = gpr_avl_add(avl, box(942), box(1762), NULL);
-  avl = remove_int(avl, 361);
-  avl = gpr_avl_add(avl, box(66), box(1764), NULL);
-  avl = gpr_avl_add(avl, box(299), box(1765), NULL);
-  avl = gpr_avl_add(avl, box(929), box(1766), NULL);
-  avl = gpr_avl_add(avl, box(797), box(1767), NULL);
-  avl = remove_int(avl, 869);
-  avl = remove_int(avl, 907);
-  avl = gpr_avl_add(avl, box(870), box(1770), NULL);
-  avl = remove_int(avl, 580);
-  avl = remove_int(avl, 120);
-  avl = gpr_avl_add(avl, box(913), box(1773), NULL);
-  avl = remove_int(avl, 480);
-  avl = gpr_avl_add(avl, box(489), box(1775), NULL);
-  avl = remove_int(avl, 845);
-  avl = gpr_avl_add(avl, box(896), box(1777), NULL);
-  avl = remove_int(avl, 567);
-  avl = remove_int(avl, 427);
-  avl = gpr_avl_add(avl, box(443), box(1780), NULL);
-  avl = gpr_avl_add(avl, box(3), box(1781), NULL);
-  avl = remove_int(avl, 12);
-  avl = gpr_avl_add(avl, box(376), box(1783), NULL);
-  avl = gpr_avl_add(avl, box(155), box(1784), NULL);
-  avl = gpr_avl_add(avl, box(188), box(1785), NULL);
-  avl = gpr_avl_add(avl, box(149), box(1786), NULL);
-  avl = gpr_avl_add(avl, box(178), box(1787), NULL);
-  avl = remove_int(avl, 84);
-  avl = gpr_avl_add(avl, box(805), box(1789), NULL);
-  avl = gpr_avl_add(avl, box(612), box(1790), NULL);
-  avl = remove_int(avl, 991);
-  avl = gpr_avl_add(avl, box(837), box(1792), NULL);
-  avl = remove_int(avl, 173);
-  avl = remove_int(avl, 72);
-  avl = gpr_avl_add(avl, box(1014), box(1795), NULL);
-  avl = remove_int(avl, 303);
-  avl = gpr_avl_add(avl, box(865), box(1797), NULL);
-  avl = gpr_avl_add(avl, box(793), box(1798), NULL);
-  avl = remove_int(avl, 173);
-  avl = remove_int(avl, 477);
-  avl = gpr_avl_add(avl, box(950), box(1801), NULL);
-  avl = gpr_avl_add(avl, box(105), box(1802), NULL);
-  avl = gpr_avl_add(avl, box(895), box(1803), NULL);
-  avl = gpr_avl_add(avl, box(171), box(1804), NULL);
-  avl = gpr_avl_add(avl, box(753), box(1805), NULL);
-  avl = gpr_avl_add(avl, box(946), box(1806), NULL);
-  avl = remove_int(avl, 194);
-  avl = remove_int(avl, 559);
-  avl = remove_int(avl, 116);
-  avl = gpr_avl_add(avl, box(968), box(1810), NULL);
-  avl = remove_int(avl, 124);
-  avl = remove_int(avl, 99);
-  avl = gpr_avl_add(avl, box(563), box(1813), NULL);
-  avl = remove_int(avl, 182);
-  avl = gpr_avl_add(avl, box(816), box(1815), NULL);
-  avl = remove_int(avl, 73);
-  avl = remove_int(avl, 261);
-  avl = gpr_avl_add(avl, box(847), box(1818), NULL);
-  avl = gpr_avl_add(avl, box(368), box(1819), NULL);
-  avl = gpr_avl_add(avl, box(808), box(1820), NULL);
-  avl = gpr_avl_add(avl, box(779), box(1821), NULL);
-  avl = remove_int(avl, 818);
-  avl = gpr_avl_add(avl, box(466), box(1823), NULL);
-  avl = remove_int(avl, 316);
-  avl = gpr_avl_add(avl, box(986), box(1825), NULL);
-  avl = gpr_avl_add(avl, box(688), box(1826), NULL);
-  avl = gpr_avl_add(avl, box(509), box(1827), NULL);
-  avl = gpr_avl_add(avl, box(51), box(1828), NULL);
-  avl = remove_int(avl, 655);
-  avl = remove_int(avl, 785);
-  avl = remove_int(avl, 893);
-  avl = gpr_avl_add(avl, box(167), box(1832), NULL);
-  avl = remove_int(avl, 13);
-  avl = remove_int(avl, 263);
-  avl = gpr_avl_add(avl, box(1009), box(1835), NULL);
-  avl = remove_int(avl, 480);
-  avl = remove_int(avl, 778);
-  avl = remove_int(avl, 713);
-  avl = remove_int(avl, 628);
-  avl = gpr_avl_add(avl, box(803), box(1840), NULL);
-  avl = remove_int(avl, 267);
-  avl = gpr_avl_add(avl, box(676), box(1842), NULL);
-  avl = gpr_avl_add(avl, box(231), box(1843), NULL);
-  avl = gpr_avl_add(avl, box(824), box(1844), NULL);
-  avl = remove_int(avl, 961);
-  avl = gpr_avl_add(avl, box(311), box(1846), NULL);
-  avl = gpr_avl_add(avl, box(420), box(1847), NULL);
-  avl = gpr_avl_add(avl, box(960), box(1848), NULL);
-  avl = gpr_avl_add(avl, box(468), box(1849), NULL);
-  avl = gpr_avl_add(avl, box(815), box(1850), NULL);
-  avl = remove_int(avl, 247);
-  avl = remove_int(avl, 194);
-  avl = gpr_avl_add(avl, box(546), box(1853), NULL);
-  avl = remove_int(avl, 222);
-  avl = remove_int(avl, 914);
-  avl = remove_int(avl, 741);
-  avl = gpr_avl_add(avl, box(470), box(1857), NULL);
-  avl = gpr_avl_add(avl, box(933), box(1858), NULL);
-  avl = gpr_avl_add(avl, box(97), box(1859), NULL);
-  avl = remove_int(avl, 564);
-  avl = remove_int(avl, 295);
-  avl = gpr_avl_add(avl, box(864), box(1862), NULL);
-  avl = remove_int(avl, 329);
-  avl = gpr_avl_add(avl, box(124), box(1864), NULL);
-  avl = gpr_avl_add(avl, box(1000), box(1865), NULL);
-  avl = gpr_avl_add(avl, box(228), box(1866), NULL);
-  avl = gpr_avl_add(avl, box(187), box(1867), NULL);
-  avl = remove_int(avl, 224);
-  avl = remove_int(avl, 306);
-  avl = remove_int(avl, 884);
-  avl = gpr_avl_add(avl, box(449), box(1871), NULL);
-  avl = gpr_avl_add(avl, box(353), box(1872), NULL);
-  avl = gpr_avl_add(avl, box(994), box(1873), NULL);
-  avl = gpr_avl_add(avl, box(596), box(1874), NULL);
-  avl = gpr_avl_add(avl, box(996), box(1875), NULL);
-  avl = gpr_avl_add(avl, box(101), box(1876), NULL);
-  avl = gpr_avl_add(avl, box(1012), box(1877), NULL);
-  avl = gpr_avl_add(avl, box(982), box(1878), NULL);
-  avl = gpr_avl_add(avl, box(742), box(1879), NULL);
-  avl = remove_int(avl, 92);
-  avl = remove_int(avl, 1022);
-  avl = gpr_avl_add(avl, box(941), box(1882), NULL);
-  avl = remove_int(avl, 742);
-  avl = remove_int(avl, 919);
-  avl = gpr_avl_add(avl, box(588), box(1885), NULL);
-  avl = remove_int(avl, 221);
-  avl = gpr_avl_add(avl, box(356), box(1887), NULL);
-  avl = gpr_avl_add(avl, box(932), box(1888), NULL);
-  avl = remove_int(avl, 837);
-  avl = gpr_avl_add(avl, box(394), box(1890), NULL);
-  avl = gpr_avl_add(avl, box(642), box(1891), NULL);
-  avl = gpr_avl_add(avl, box(52), box(1892), NULL);
-  avl = gpr_avl_add(avl, box(437), box(1893), NULL);
-  avl = gpr_avl_add(avl, box(948), box(1894), NULL);
-  avl = gpr_avl_add(avl, box(93), box(1895), NULL);
-  avl = remove_int(avl, 873);
-  avl = remove_int(avl, 336);
-  avl = remove_int(avl, 277);
-  avl = remove_int(avl, 932);
-  avl = gpr_avl_add(avl, box(80), box(1900), NULL);
-  avl = gpr_avl_add(avl, box(952), box(1901), NULL);
-  avl = gpr_avl_add(avl, box(510), box(1902), NULL);
-  avl = remove_int(avl, 876);
-  avl = remove_int(avl, 612);
-  avl = gpr_avl_add(avl, box(923), box(1905), NULL);
-  avl = gpr_avl_add(avl, box(475), box(1906), NULL);
-  avl = remove_int(avl, 478);
-  avl = remove_int(avl, 148);
-  avl = gpr_avl_add(avl, box(538), box(1909), NULL);
-  avl = remove_int(avl, 47);
-  avl = gpr_avl_add(avl, box(89), box(1911), NULL);
-  avl = remove_int(avl, 723);
-  avl = gpr_avl_add(avl, box(687), box(1913), NULL);
-  avl = gpr_avl_add(avl, box(480), box(1914), NULL);
-  avl = gpr_avl_add(avl, box(149), box(1915), NULL);
-  avl = remove_int(avl, 68);
-  avl = remove_int(avl, 862);
-  avl = remove_int(avl, 363);
-  avl = gpr_avl_add(avl, box(996), box(1919), NULL);
-  avl = remove_int(avl, 380);
-  avl = gpr_avl_add(avl, box(957), box(1921), NULL);
-  avl = remove_int(avl, 413);
-  avl = gpr_avl_add(avl, box(360), box(1923), NULL);
-  avl = gpr_avl_add(avl, box(304), box(1924), NULL);
-  avl = gpr_avl_add(avl, box(634), box(1925), NULL);
-  avl = gpr_avl_add(avl, box(506), box(1926), NULL);
-  avl = remove_int(avl, 248);
-  avl = gpr_avl_add(avl, box(124), box(1928), NULL);
-  avl = gpr_avl_add(avl, box(181), box(1929), NULL);
-  avl = remove_int(avl, 507);
-  avl = gpr_avl_add(avl, box(141), box(1931), NULL);
-  avl = remove_int(avl, 409);
-  avl = remove_int(avl, 129);
-  avl = remove_int(avl, 694);
-  avl = remove_int(avl, 723);
-  avl = gpr_avl_add(avl, box(998), box(1936), NULL);
-  avl = gpr_avl_add(avl, box(906), box(1937), NULL);
-  avl = gpr_avl_add(avl, box(44), box(1938), NULL);
-  avl = remove_int(avl, 949);
-  avl = remove_int(avl, 117);
-  avl = gpr_avl_add(avl, box(700), box(1941), NULL);
-  avl = gpr_avl_add(avl, box(258), box(1942), NULL);
-  avl = remove_int(avl, 828);
-  avl = gpr_avl_add(avl, box(860), box(1944), NULL);
-  avl = gpr_avl_add(avl, box(987), box(1945), NULL);
-  avl = gpr_avl_add(avl, box(316), box(1946), NULL);
-  avl = gpr_avl_add(avl, box(919), box(1947), NULL);
-  avl = remove_int(avl, 84);
-  avl = gpr_avl_add(avl, box(473), box(1949), NULL);
-  avl = remove_int(avl, 127);
-  avl = remove_int(avl, 829);
-  avl = remove_int(avl, 829);
-  avl = gpr_avl_add(avl, box(488), box(1953), NULL);
-  avl = gpr_avl_add(avl, box(954), box(1954), NULL);
-  avl = remove_int(avl, 198);
-  avl = remove_int(avl, 972);
-  avl = remove_int(avl, 670);
-  avl = gpr_avl_add(avl, box(822), box(1958), NULL);
-  avl = remove_int(avl, 589);
-  avl = remove_int(avl, 459);
-  avl = gpr_avl_add(avl, box(1003), box(1961), NULL);
-  avl = gpr_avl_add(avl, box(657), box(1962), NULL);
-  avl = gpr_avl_add(avl, box(477), box(1963), NULL);
-  avl = gpr_avl_add(avl, box(923), box(1964), NULL);
-  avl = remove_int(avl, 496);
-  avl = remove_int(avl, 99);
-  avl = gpr_avl_add(avl, box(127), box(1967), NULL);
-  avl = gpr_avl_add(avl, box(1013), box(1968), NULL);
-  avl = gpr_avl_add(avl, box(778), box(1969), NULL);
-  avl = remove_int(avl, 5);
-  avl = remove_int(avl, 990);
-  avl = remove_int(avl, 850);
-  avl = remove_int(avl, 160);
-  avl = remove_int(avl, 86);
-  avl = gpr_avl_add(avl, box(283), box(1975), NULL);
-  avl = remove_int(avl, 278);
-  avl = remove_int(avl, 297);
-  avl = remove_int(avl, 137);
-  avl = remove_int(avl, 653);
-  avl = gpr_avl_add(avl, box(702), box(1980), NULL);
-  avl = remove_int(avl, 63);
-  avl = remove_int(avl, 427);
-  avl = remove_int(avl, 706);
-  avl = remove_int(avl, 806);
-  avl = gpr_avl_add(avl, box(335), box(1985), NULL);
-  avl = gpr_avl_add(avl, box(412), box(1986), NULL);
-  avl = remove_int(avl, 766);
-  avl = remove_int(avl, 937);
-  avl = remove_int(avl, 886);
-  avl = remove_int(avl, 652);
-  avl = gpr_avl_add(avl, box(545), box(1991), NULL);
-  avl = gpr_avl_add(avl, box(408), box(1992), NULL);
-  avl = gpr_avl_add(avl, box(841), box(1993), NULL);
-  avl = remove_int(avl, 593);
-  avl = gpr_avl_add(avl, box(582), box(1995), NULL);
-  avl = gpr_avl_add(avl, box(597), box(1996), NULL);
-  avl = remove_int(avl, 49);
-  avl = remove_int(avl, 835);
-  avl = gpr_avl_add(avl, box(417), box(1999), NULL);
-  avl = gpr_avl_add(avl, box(191), box(2000), NULL);
-  avl = remove_int(avl, 406);
-  avl = gpr_avl_add(avl, box(30), box(2002), NULL);
-  avl = remove_int(avl, 841);
-  avl = remove_int(avl, 50);
-  avl = gpr_avl_add(avl, box(967), box(2005), NULL);
-  avl = gpr_avl_add(avl, box(849), box(2006), NULL);
-  avl = remove_int(avl, 608);
-  avl = gpr_avl_add(avl, box(306), box(2008), NULL);
-  avl = remove_int(avl, 779);
-  avl = gpr_avl_add(avl, box(897), box(2010), NULL);
-  avl = gpr_avl_add(avl, box(147), box(2011), NULL);
-  avl = remove_int(avl, 982);
-  avl = gpr_avl_add(avl, box(470), box(2013), NULL);
-  avl = remove_int(avl, 951);
-  avl = gpr_avl_add(avl, box(388), box(2015), NULL);
-  avl = remove_int(avl, 616);
-  avl = remove_int(avl, 721);
-  avl = remove_int(avl, 942);
-  avl = remove_int(avl, 589);
-  avl = gpr_avl_add(avl, box(218), box(2020), NULL);
-  avl = remove_int(avl, 671);
-  avl = gpr_avl_add(avl, box(1020), box(2022), NULL);
-  avl = remove_int(avl, 277);
-  avl = gpr_avl_add(avl, box(681), box(2024), NULL);
-  avl = gpr_avl_add(avl, box(179), box(2025), NULL);
-  avl = gpr_avl_add(avl, box(370), box(2026), NULL);
-  avl = gpr_avl_add(avl, box(0), box(2027), NULL);
-  avl = remove_int(avl, 523);
-  avl = gpr_avl_add(avl, box(99), box(2029), NULL);
-  avl = gpr_avl_add(avl, box(334), box(2030), NULL);
-  avl = gpr_avl_add(avl, box(569), box(2031), NULL);
-  avl = gpr_avl_add(avl, box(257), box(2032), NULL);
-  avl = remove_int(avl, 572);
-  avl = gpr_avl_add(avl, box(805), box(2034), NULL);
-  avl = gpr_avl_add(avl, box(143), box(2035), NULL);
-  avl = gpr_avl_add(avl, box(670), box(2036), NULL);
-  avl = remove_int(avl, 42);
-  avl = gpr_avl_add(avl, box(46), box(2038), NULL);
-  avl = remove_int(avl, 970);
-  avl = gpr_avl_add(avl, box(353), box(2040), NULL);
-  avl = remove_int(avl, 258);
-  avl = gpr_avl_add(avl, box(451), box(2042), NULL);
-  avl = gpr_avl_add(avl, box(28), box(2043), NULL);
-  avl = gpr_avl_add(avl, box(729), box(2044), NULL);
-  avl = gpr_avl_add(avl, box(401), box(2045), NULL);
-  avl = gpr_avl_add(avl, box(614), box(2046), NULL);
-  avl = remove_int(avl, 990);
-  avl = remove_int(avl, 212);
-  avl = remove_int(avl, 22);
-  avl = remove_int(avl, 677);
-  avl = gpr_avl_add(avl, box(1016), box(2051), NULL);
-  avl = gpr_avl_add(avl, box(980), box(2052), NULL);
-  avl = gpr_avl_add(avl, box(990), box(2053), NULL);
-  avl = gpr_avl_add(avl, box(355), box(2054), NULL);
-  avl = remove_int(avl, 730);
-  avl = remove_int(avl, 37);
-  avl = gpr_avl_add(avl, box(407), box(2057), NULL);
-  avl = gpr_avl_add(avl, box(222), box(2058), NULL);
-  avl = gpr_avl_add(avl, box(439), box(2059), NULL);
-  avl = gpr_avl_add(avl, box(563), box(2060), NULL);
-  avl = remove_int(avl, 992);
-  avl = remove_int(avl, 786);
-  avl = gpr_avl_add(avl, box(1), box(2063), NULL);
-  avl = gpr_avl_add(avl, box(473), box(2064), NULL);
-  avl = gpr_avl_add(avl, box(992), box(2065), NULL);
-  avl = remove_int(avl, 190);
-  avl = remove_int(avl, 450);
-  avl = remove_int(avl, 1020);
-  avl = remove_int(avl, 149);
-  avl = gpr_avl_add(avl, box(329), box(2070), NULL);
-  avl = gpr_avl_add(avl, box(35), box(2071), NULL);
-  avl = remove_int(avl, 843);
-  avl = gpr_avl_add(avl, box(855), box(2073), NULL);
-  avl = remove_int(avl, 878);
-  avl = gpr_avl_add(avl, box(993), box(2075), NULL);
-  avl = gpr_avl_add(avl, box(87), box(2076), NULL);
-  avl = gpr_avl_add(avl, box(572), box(2077), NULL);
-  avl = remove_int(avl, 896);
-  avl = gpr_avl_add(avl, box(849), box(2079), NULL);
-  avl = remove_int(avl, 597);
-  avl = gpr_avl_add(avl, box(472), box(2081), NULL);
-  avl = remove_int(avl, 778);
-  avl = remove_int(avl, 934);
-  avl = remove_int(avl, 314);
-  avl = gpr_avl_add(avl, box(101), box(2085), NULL);
-  avl = remove_int(avl, 938);
-  avl = remove_int(avl, 1010);
-  avl = gpr_avl_add(avl, box(579), box(2088), NULL);
-  avl = remove_int(avl, 798);
-  avl = remove_int(avl, 88);
-  avl = gpr_avl_add(avl, box(851), box(2091), NULL);
-  avl = remove_int(avl, 705);
-  avl = gpr_avl_add(avl, box(26), box(2093), NULL);
-  avl = remove_int(avl, 973);
-  avl = gpr_avl_add(avl, box(923), box(2095), NULL);
-  avl = remove_int(avl, 668);
-  avl = gpr_avl_add(avl, box(310), box(2097), NULL);
-  avl = gpr_avl_add(avl, box(269), box(2098), NULL);
-  avl = remove_int(avl, 173);
-  avl = gpr_avl_add(avl, box(279), box(2100), NULL);
-  avl = remove_int(avl, 203);
-  avl = gpr_avl_add(avl, box(411), box(2102), NULL);
-  avl = remove_int(avl, 950);
-  avl = gpr_avl_add(avl, box(6), box(2104), NULL);
-  avl = remove_int(avl, 400);
-  avl = remove_int(avl, 468);
-  avl = remove_int(avl, 271);
-  avl = gpr_avl_add(avl, box(627), box(2108), NULL);
-  avl = remove_int(avl, 727);
-  avl = remove_int(avl, 148);
-  avl = remove_int(avl, 98);
-  avl = remove_int(avl, 997);
-  avl = remove_int(avl, 215);
-  avl = remove_int(avl, 628);
-  avl = remove_int(avl, 826);
-  avl = remove_int(avl, 664);
-  avl = gpr_avl_add(avl, box(76), box(2117), NULL);
-  avl = remove_int(avl, 194);
-  avl = remove_int(avl, 18);
-  avl = gpr_avl_add(avl, box(727), box(2120), NULL);
-  avl = remove_int(avl, 295);
-  avl = gpr_avl_add(avl, box(645), box(2122), NULL);
-  avl = remove_int(avl, 321);
-  avl = remove_int(avl, 863);
-  avl = gpr_avl_add(avl, box(824), box(2125), NULL);
-  avl = gpr_avl_add(avl, box(651), box(2126), NULL);
-  avl = gpr_avl_add(avl, box(804), box(2127), NULL);
-  avl = remove_int(avl, 307);
-  avl = gpr_avl_add(avl, box(867), box(2129), NULL);
-  avl = remove_int(avl, 384);
-  avl = gpr_avl_add(avl, box(819), box(2131), NULL);
-  avl = remove_int(avl, 674);
-  avl = gpr_avl_add(avl, box(76), box(2133), NULL);
-  avl = remove_int(avl, 898);
-  avl = gpr_avl_add(avl, box(45), box(2135), NULL);
-  avl = gpr_avl_add(avl, box(512), box(2136), NULL);
-  avl = remove_int(avl, 773);
-  avl = remove_int(avl, 907);
-  avl = remove_int(avl, 382);
-  avl = remove_int(avl, 95);
-  avl = remove_int(avl, 734);
-  avl = remove_int(avl, 81);
-  avl = gpr_avl_add(avl, box(348), box(2143), NULL);
-  avl = remove_int(avl, 509);
-  avl = remove_int(avl, 301);
-  avl = gpr_avl_add(avl, box(861), box(2146), NULL);
-  avl = gpr_avl_add(avl, box(918), box(2147), NULL);
-  avl = remove_int(avl, 992);
-  avl = gpr_avl_add(avl, box(356), box(2149), NULL);
-  avl = remove_int(avl, 64);
-  avl = remove_int(avl, 444);
-  avl = remove_int(avl, 741);
-  avl = gpr_avl_add(avl, box(710), box(2153), NULL);
-  avl = gpr_avl_add(avl, box(264), box(2154), NULL);
-  avl = remove_int(avl, 347);
-  avl = remove_int(avl, 250);
-  avl = gpr_avl_add(avl, box(82), box(2157), NULL);
-  avl = gpr_avl_add(avl, box(571), box(2158), NULL);
-  avl = remove_int(avl, 721);
-  avl = remove_int(avl, 622);
-  avl = gpr_avl_add(avl, box(950), box(2161), NULL);
-  avl = gpr_avl_add(avl, box(94), box(2162), NULL);
-  avl = remove_int(avl, 970);
-  avl = gpr_avl_add(avl, box(815), box(2164), NULL);
-  avl = remove_int(avl, 930);
-  avl = remove_int(avl, 703);
-  avl = gpr_avl_add(avl, box(432), box(2167), NULL);
-  avl = remove_int(avl, 544);
-  avl = gpr_avl_add(avl, box(21), box(2169), NULL);
-  avl = gpr_avl_add(avl, box(186), box(2170), NULL);
-  avl = remove_int(avl, 143);
-  avl = gpr_avl_add(avl, box(425), box(2172), NULL);
-  avl = remove_int(avl, 769);
-  avl = gpr_avl_add(avl, box(656), box(2174), NULL);
-  avl = remove_int(avl, 29);
-  avl = gpr_avl_add(avl, box(464), box(2176), NULL);
-  avl = remove_int(avl, 713);
-  avl = gpr_avl_add(avl, box(800), box(2178), NULL);
-  avl = remove_int(avl, 621);
-  avl = gpr_avl_add(avl, box(962), box(2180), NULL);
-  avl = remove_int(avl, 448);
-  avl = gpr_avl_add(avl, box(878), box(2182), NULL);
-  avl = remove_int(avl, 39);
-  avl = remove_int(avl, 999);
-  avl = gpr_avl_add(avl, box(182), box(2185), NULL);
-  avl = gpr_avl_add(avl, box(429), box(2186), NULL);
-  avl = gpr_avl_add(avl, box(598), box(2187), NULL);
-  avl = remove_int(avl, 551);
-  avl = gpr_avl_add(avl, box(827), box(2189), NULL);
-  avl = gpr_avl_add(avl, box(809), box(2190), NULL);
-  avl = remove_int(avl, 438);
-  avl = remove_int(avl, 811);
-  avl = gpr_avl_add(avl, box(808), box(2193), NULL);
-  avl = gpr_avl_add(avl, box(788), box(2194), NULL);
-  avl = remove_int(avl, 156);
-  avl = gpr_avl_add(avl, box(933), box(2196), NULL);
-  avl = gpr_avl_add(avl, box(344), box(2197), NULL);
-  avl = remove_int(avl, 460);
-  avl = gpr_avl_add(avl, box(161), box(2199), NULL);
-  avl = gpr_avl_add(avl, box(444), box(2200), NULL);
-  avl = remove_int(avl, 597);
-  avl = remove_int(avl, 668);
-  avl = gpr_avl_add(avl, box(703), box(2203), NULL);
-  avl = remove_int(avl, 515);
-  avl = gpr_avl_add(avl, box(380), box(2205), NULL);
-  avl = gpr_avl_add(avl, box(338), box(2206), NULL);
-  avl = remove_int(avl, 550);
-  avl = remove_int(avl, 946);
-  avl = remove_int(avl, 714);
-  avl = remove_int(avl, 739);
-  avl = gpr_avl_add(avl, box(413), box(2211), NULL);
-  avl = remove_int(avl, 450);
-  avl = gpr_avl_add(avl, box(411), box(2213), NULL);
-  avl = gpr_avl_add(avl, box(117), box(2214), NULL);
-  avl = gpr_avl_add(avl, box(322), box(2215), NULL);
-  avl = gpr_avl_add(avl, box(915), box(2216), NULL);
-  avl = gpr_avl_add(avl, box(410), box(2217), NULL);
-  avl = gpr_avl_add(avl, box(66), box(2218), NULL);
-  avl = remove_int(avl, 756);
-  avl = remove_int(avl, 596);
-  avl = gpr_avl_add(avl, box(882), box(2221), NULL);
-  avl = gpr_avl_add(avl, box(930), box(2222), NULL);
-  avl = gpr_avl_add(avl, box(36), box(2223), NULL);
-  avl = remove_int(avl, 742);
-  avl = gpr_avl_add(avl, box(539), box(2225), NULL);
-  avl = gpr_avl_add(avl, box(596), box(2226), NULL);
-  avl = remove_int(avl, 82);
-  avl = remove_int(avl, 686);
-  avl = remove_int(avl, 933);
-  avl = remove_int(avl, 42);
-  avl = remove_int(avl, 340);
-  avl = gpr_avl_add(avl, box(126), box(2232), NULL);
-  avl = gpr_avl_add(avl, box(493), box(2233), NULL);
-  avl = gpr_avl_add(avl, box(839), box(2234), NULL);
-  avl = remove_int(avl, 774);
-  avl = gpr_avl_add(avl, box(337), box(2236), NULL);
-  avl = remove_int(avl, 322);
-  avl = gpr_avl_add(avl, box(16), box(2238), NULL);
-  avl = remove_int(avl, 73);
-  avl = remove_int(avl, 85);
-  avl = remove_int(avl, 191);
-  avl = remove_int(avl, 541);
-  avl = gpr_avl_add(avl, box(704), box(2243), NULL);
-  avl = remove_int(avl, 767);
-  avl = remove_int(avl, 1006);
-  avl = remove_int(avl, 844);
-  avl = remove_int(avl, 742);
-  avl = gpr_avl_add(avl, box(48), box(2248), NULL);
-  avl = gpr_avl_add(avl, box(138), box(2249), NULL);
-  avl = gpr_avl_add(avl, box(437), box(2250), NULL);
-  avl = gpr_avl_add(avl, box(275), box(2251), NULL);
-  avl = remove_int(avl, 520);
-  avl = gpr_avl_add(avl, box(1019), box(2253), NULL);
-  avl = remove_int(avl, 955);
-  avl = gpr_avl_add(avl, box(270), box(2255), NULL);
-  avl = remove_int(avl, 680);
-  avl = remove_int(avl, 698);
-  avl = gpr_avl_add(avl, box(735), box(2258), NULL);
-  avl = gpr_avl_add(avl, box(400), box(2259), NULL);
-  avl = remove_int(avl, 991);
-  avl = gpr_avl_add(avl, box(263), box(2261), NULL);
-  avl = remove_int(avl, 704);
-  avl = gpr_avl_add(avl, box(757), box(2263), NULL);
-  avl = remove_int(avl, 194);
-  avl = remove_int(avl, 616);
-  avl = remove_int(avl, 784);
-  avl = gpr_avl_add(avl, box(382), box(2267), NULL);
-  avl = gpr_avl_add(avl, box(464), box(2268), NULL);
-  avl = gpr_avl_add(avl, box(817), box(2269), NULL);
-  avl = remove_int(avl, 445);
-  avl = gpr_avl_add(avl, box(412), box(2271), NULL);
-  avl = remove_int(avl, 525);
-  avl = gpr_avl_add(avl, box(299), box(2273), NULL);
-  avl = gpr_avl_add(avl, box(464), box(2274), NULL);
-  avl = gpr_avl_add(avl, box(715), box(2275), NULL);
-  avl = remove_int(avl, 58);
-  avl = remove_int(avl, 218);
-  avl = gpr_avl_add(avl, box(961), box(2278), NULL);
-  avl = gpr_avl_add(avl, box(491), box(2279), NULL);
-  avl = remove_int(avl, 846);
-  avl = gpr_avl_add(avl, box(762), box(2281), NULL);
-  avl = remove_int(avl, 974);
-  avl = remove_int(avl, 887);
-  avl = gpr_avl_add(avl, box(498), box(2284), NULL);
-  avl = remove_int(avl, 810);
-  avl = remove_int(avl, 743);
-  avl = remove_int(avl, 22);
-  avl = remove_int(avl, 284);
-  avl = gpr_avl_add(avl, box(482), box(2289), NULL);
-  avl = gpr_avl_add(avl, box(1021), box(2290), NULL);
-  avl = remove_int(avl, 155);
-  avl = remove_int(avl, 128);
-  avl = gpr_avl_add(avl, box(819), box(2293), NULL);
-  avl = gpr_avl_add(avl, box(324), box(2294), NULL);
-  avl = remove_int(avl, 196);
-  avl = remove_int(avl, 370);
-  avl = remove_int(avl, 753);
-  avl = remove_int(avl, 56);
-  avl = remove_int(avl, 735);
-  avl = gpr_avl_add(avl, box(272), box(2300), NULL);
-  avl = gpr_avl_add(avl, box(474), box(2301), NULL);
-  avl = gpr_avl_add(avl, box(719), box(2302), NULL);
-  avl = gpr_avl_add(avl, box(236), box(2303), NULL);
-  avl = remove_int(avl, 818);
-  avl = gpr_avl_add(avl, box(727), box(2305), NULL);
-  avl = remove_int(avl, 892);
-  avl = remove_int(avl, 871);
-  avl = remove_int(avl, 231);
-  avl = gpr_avl_add(avl, box(62), box(2309), NULL);
-  avl = gpr_avl_add(avl, box(953), box(2310), NULL);
-  avl = remove_int(avl, 701);
-  avl = gpr_avl_add(avl, box(193), box(2312), NULL);
-  avl = remove_int(avl, 619);
-  avl = remove_int(avl, 22);
-  avl = remove_int(avl, 804);
-  avl = remove_int(avl, 851);
-  avl = gpr_avl_add(avl, box(286), box(2317), NULL);
-  avl = gpr_avl_add(avl, box(751), box(2318), NULL);
-  avl = remove_int(avl, 525);
-  avl = gpr_avl_add(avl, box(217), box(2320), NULL);
-  avl = remove_int(avl, 336);
-  avl = gpr_avl_add(avl, box(86), box(2322), NULL);
-  avl = gpr_avl_add(avl, box(81), box(2323), NULL);
-  avl = gpr_avl_add(avl, box(850), box(2324), NULL);
-  avl = remove_int(avl, 872);
-  avl = gpr_avl_add(avl, box(402), box(2326), NULL);
-  avl = gpr_avl_add(avl, box(54), box(2327), NULL);
-  avl = gpr_avl_add(avl, box(980), box(2328), NULL);
-  avl = gpr_avl_add(avl, box(845), box(2329), NULL);
-  avl = remove_int(avl, 1004);
-  avl = remove_int(avl, 273);
-  avl = remove_int(avl, 879);
-  avl = gpr_avl_add(avl, box(354), box(2333), NULL);
-  avl = gpr_avl_add(avl, box(58), box(2334), NULL);
-  avl = gpr_avl_add(avl, box(127), box(2335), NULL);
-  avl = remove_int(avl, 84);
-  avl = gpr_avl_add(avl, box(360), box(2337), NULL);
-  avl = remove_int(avl, 648);
-  avl = remove_int(avl, 488);
-  avl = remove_int(avl, 585);
-  avl = remove_int(avl, 230);
-  avl = gpr_avl_add(avl, box(887), box(2342), NULL);
-  avl = remove_int(avl, 558);
-  avl = remove_int(avl, 958);
-  avl = gpr_avl_add(avl, box(822), box(2345), NULL);
-  avl = remove_int(avl, 1004);
-  avl = remove_int(avl, 747);
-  avl = gpr_avl_add(avl, box(631), box(2348), NULL);
-  avl = gpr_avl_add(avl, box(442), box(2349), NULL);
-  avl = remove_int(avl, 957);
-  avl = remove_int(avl, 964);
-  avl = gpr_avl_add(avl, box(10), box(2352), NULL);
-  avl = remove_int(avl, 189);
-  avl = gpr_avl_add(avl, box(742), box(2354), NULL);
-  avl = remove_int(avl, 108);
-  avl = gpr_avl_add(avl, box(1014), box(2356), NULL);
-  avl = remove_int(avl, 266);
-  avl = remove_int(avl, 623);
-  avl = remove_int(avl, 697);
-  avl = gpr_avl_add(avl, box(180), box(2360), NULL);
-  avl = remove_int(avl, 472);
-  avl = gpr_avl_add(avl, box(567), box(2362), NULL);
-  avl = remove_int(avl, 1020);
-  avl = remove_int(avl, 273);
-  avl = gpr_avl_add(avl, box(864), box(2365), NULL);
-  avl = gpr_avl_add(avl, box(1009), box(2366), NULL);
-  avl = remove_int(avl, 224);
-  avl = remove_int(avl, 81);
-  avl = gpr_avl_add(avl, box(653), box(2369), NULL);
-  avl = remove_int(avl, 67);
-  avl = remove_int(avl, 102);
-  avl = remove_int(avl, 76);
-  avl = remove_int(avl, 935);
-  avl = remove_int(avl, 169);
-  avl = remove_int(avl, 232);
-  avl = remove_int(avl, 79);
-  avl = gpr_avl_add(avl, box(509), box(2377), NULL);
-  avl = remove_int(avl, 900);
-  avl = remove_int(avl, 822);
-  avl = remove_int(avl, 945);
-  avl = remove_int(avl, 356);
-  avl = gpr_avl_add(avl, box(443), box(2382), NULL);
-  avl = gpr_avl_add(avl, box(925), box(2383), NULL);
-  avl = remove_int(avl, 994);
-  avl = remove_int(avl, 324);
-  avl = gpr_avl_add(avl, box(291), box(2386), NULL);
-  avl = remove_int(avl, 94);
-  avl = remove_int(avl, 795);
-  avl = remove_int(avl, 42);
-  avl = gpr_avl_add(avl, box(613), box(2390), NULL);
-  avl = remove_int(avl, 289);
-  avl = gpr_avl_add(avl, box(980), box(2392), NULL);
-  avl = remove_int(avl, 316);
-  avl = gpr_avl_add(avl, box(281), box(2394), NULL);
-  avl = gpr_avl_add(avl, box(1006), box(2395), NULL);
-  avl = remove_int(avl, 776);
-  avl = gpr_avl_add(avl, box(108), box(2397), NULL);
-  avl = gpr_avl_add(avl, box(918), box(2398), NULL);
-  avl = remove_int(avl, 721);
-  avl = remove_int(avl, 563);
-  avl = gpr_avl_add(avl, box(925), box(2401), NULL);
-  avl = remove_int(avl, 448);
-  avl = remove_int(avl, 198);
-  avl = remove_int(avl, 1);
-  avl = gpr_avl_add(avl, box(160), box(2405), NULL);
-  avl = remove_int(avl, 515);
-  avl = gpr_avl_add(avl, box(284), box(2407), NULL);
-  avl = gpr_avl_add(avl, box(225), box(2408), NULL);
-  avl = remove_int(avl, 304);
-  avl = gpr_avl_add(avl, box(714), box(2410), NULL);
-  avl = gpr_avl_add(avl, box(708), box(2411), NULL);
-  avl = gpr_avl_add(avl, box(624), box(2412), NULL);
-  avl = remove_int(avl, 662);
-  avl = remove_int(avl, 825);
-  avl = remove_int(avl, 383);
-  avl = remove_int(avl, 381);
-  avl = gpr_avl_add(avl, box(194), box(2417), NULL);
-  avl = remove_int(avl, 280);
-  avl = remove_int(avl, 25);
-  avl = remove_int(avl, 633);
-  avl = gpr_avl_add(avl, box(897), box(2421), NULL);
-  avl = remove_int(avl, 636);
-  avl = remove_int(avl, 596);
-  avl = remove_int(avl, 757);
-  avl = remove_int(avl, 343);
-  avl = remove_int(avl, 162);
-  avl = remove_int(avl, 913);
-  avl = remove_int(avl, 843);
-  avl = remove_int(avl, 280);
-  avl = remove_int(avl, 911);
-  avl = gpr_avl_add(avl, box(1008), box(2431), NULL);
-  avl = remove_int(avl, 948);
-  avl = remove_int(avl, 74);
-  avl = remove_int(avl, 571);
-  avl = gpr_avl_add(avl, box(486), box(2435), NULL);
-  avl = gpr_avl_add(avl, box(285), box(2436), NULL);
-  avl = remove_int(avl, 304);
-  avl = remove_int(avl, 516);
-  avl = gpr_avl_add(avl, box(758), box(2439), NULL);
-  avl = gpr_avl_add(avl, box(776), box(2440), NULL);
-  avl = remove_int(avl, 696);
-  avl = gpr_avl_add(avl, box(104), box(2442), NULL);
-  avl = gpr_avl_add(avl, box(700), box(2443), NULL);
-  avl = gpr_avl_add(avl, box(114), box(2444), NULL);
-  avl = gpr_avl_add(avl, box(567), box(2445), NULL);
-  avl = remove_int(avl, 620);
-  avl = gpr_avl_add(avl, box(270), box(2447), NULL);
-  avl = remove_int(avl, 730);
-  avl = gpr_avl_add(avl, box(749), box(2449), NULL);
-  avl = gpr_avl_add(avl, box(443), box(2450), NULL);
-  avl = remove_int(avl, 457);
-  avl = gpr_avl_add(avl, box(571), box(2452), NULL);
-  avl = gpr_avl_add(avl, box(626), box(2453), NULL);
-  avl = remove_int(avl, 638);
-  avl = remove_int(avl, 313);
-
-  gpr_avl_unref(avl, NULL);
-}
-
-static void test_stress(int amount_of_stress) {
-  int added[1024];
-  int i, j;
-  int deletions = 0;
-  gpr_avl avl;
-
-  unsigned seed = (unsigned)time(NULL);
-
-  gpr_log(GPR_DEBUG, "test_stress amount=%d seed=%u", amount_of_stress, seed);
-
-  srand((unsigned)time(NULL));
-  avl = gpr_avl_create(&int_int_vtable);
-
-  memset(added, 0, sizeof(added));
-
-  for (i = 1; deletions < amount_of_stress; i++) {
-    int idx = rand() % (int)GPR_ARRAY_SIZE(added);
-    GPR_ASSERT(i);
-    if (rand() < RAND_MAX / 2) {
-      added[idx] = i;
-      printf("avl = gpr_avl_add(avl, box(%d), box(%d), NULL); /* d=%d */\n",
-             idx, i, deletions);
-      avl = gpr_avl_add(avl, box(idx), box(i), NULL);
-    } else {
-      deletions += (added[idx] != 0);
-      added[idx] = 0;
-      printf("avl = remove_int(avl, %d); /* d=%d */\n", idx, deletions);
-      avl = remove_int(avl, idx);
-    }
-    for (j = 0; j < (int)GPR_ARRAY_SIZE(added); j++) {
-      if (added[j] != 0) {
-        check_get(avl, j, added[j]);
-      } else {
-        check_negget(avl, j);
-      }
-    }
-  }
-
-  gpr_avl_unref(avl, NULL);
-}
-
-int main(int argc, char *argv[]) {
-  grpc_test_init(argc, argv);
-
-  test_get();
-  test_ll();
-  test_lr();
-  test_rr();
-  test_rl();
-  test_unbalanced();
-  test_replace();
-  test_remove();
-  test_badcase1();
-  test_badcase2();
-  test_badcase3();
-  test_stress(10);
-
-  return 0;
-}
diff --git a/test/core/support/avl_test.cc b/test/core/support/avl_test.cc
new file mode 100644
index 0000000000..345db557b9
--- /dev/null
+++ b/test/core/support/avl_test.cc
@@ -0,0 +1,3659 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <grpc/support/avl.h>
+
+#include <stdio.h>
+#include <string.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/useful.h>
+
+#include "test/core/util/test_config.h"
+
+static int* box(int x) {
+  int* b = static_cast<int*>(gpr_malloc(sizeof(*b)));
+  *b = x;
+  return b;
+}
+
+static long int_compare(void* int1, void* int2, void* unused) {
+  return (*(int*)int1) - (*(int*)int2);
+}
+static void* int_copy(void* p, void* unused) { return box(*(int*)p); }
+
+static void destroy(void* p, void* unused) { gpr_free(p); }
+
+static const gpr_avl_vtable int_int_vtable = {destroy, int_copy, int_compare,
+                                              destroy, int_copy};
+
+static void check_get(gpr_avl avl, int key, int value) {
+  int* k = box(key);
+  GPR_ASSERT(*(int*)gpr_avl_get(avl, k, nullptr) == value);
+  gpr_free(k);
+}
+
+static void check_negget(gpr_avl avl, int key) {
+  int* k = box(key);
+  GPR_ASSERT(gpr_avl_get(avl, k, nullptr) == nullptr);
+  gpr_free(k);
+}
+
+static gpr_avl remove_int(gpr_avl avl, int key) {
+  int* k = box(key);
+  avl = gpr_avl_remove(avl, k, nullptr);
+  gpr_free(k);
+  return avl;
+}
+
+static void test_get(void) {
+  gpr_avl avl;
+  gpr_log(GPR_DEBUG, "test_get");
+  avl = gpr_avl_create(&int_int_vtable);
+  avl = gpr_avl_add(avl, box(1), box(11), nullptr);
+  avl = gpr_avl_add(avl, box(2), box(22), nullptr);
+  avl = gpr_avl_add(avl, box(3), box(33), nullptr);
+  check_get(avl, 1, 11);
+  check_get(avl, 2, 22);
+  check_get(avl, 3, 33);
+  check_negget(avl, 4);
+  gpr_avl_unref(avl, nullptr);
+}
+
+static void test_ll(void) {
+  gpr_avl avl;
+  gpr_log(GPR_DEBUG, "test_ll");
+  avl = gpr_avl_create(&int_int_vtable);
+  avl = gpr_avl_add(avl, box(5), box(1), nullptr);
+  avl = gpr_avl_add(avl, box(4), box(2), nullptr);
+  avl = gpr_avl_add(avl, box(3), box(3), nullptr);
+  GPR_ASSERT(*(int*)avl.root->key == 4);
+  GPR_ASSERT(*(int*)avl.root->left->key == 3);
+  GPR_ASSERT(*(int*)avl.root->right->key == 5);
+  gpr_avl_unref(avl, nullptr);
+}
+
+static void test_lr(void) {
+  gpr_avl avl;
+  gpr_log(GPR_DEBUG, "test_lr");
+  avl = gpr_avl_create(&int_int_vtable);
+  avl = gpr_avl_add(avl, box(5), box(1), nullptr);
+  avl = gpr_avl_add(avl, box(3), box(2), nullptr);
+  avl = gpr_avl_add(avl, box(4), box(3), nullptr);
+  GPR_ASSERT(*(int*)avl.root->key == 4);
+  GPR_ASSERT(*(int*)avl.root->left->key == 3);
+  GPR_ASSERT(*(int*)avl.root->right->key == 5);
+  gpr_avl_unref(avl, nullptr);
+}
+
+static void test_rr(void) {
+  gpr_avl avl;
+  gpr_log(GPR_DEBUG, "test_rr");
+  avl = gpr_avl_create(&int_int_vtable);
+  avl = gpr_avl_add(avl, box(3), box(1), nullptr);
+  avl = gpr_avl_add(avl, box(4), box(2), nullptr);
+  avl = gpr_avl_add(avl, box(5), box(3), nullptr);
+  GPR_ASSERT(*(int*)avl.root->key == 4);
+  GPR_ASSERT(*(int*)avl.root->left->key == 3);
+  GPR_ASSERT(*(int*)avl.root->right->key == 5);
+  gpr_avl_unref(avl, nullptr);
+}
+
+static void test_rl(void) {
+  gpr_avl avl;
+  gpr_log(GPR_DEBUG, "test_rl");
+  avl = gpr_avl_create(&int_int_vtable);
+  avl = gpr_avl_add(avl, box(3), box(1), nullptr);
+  avl = gpr_avl_add(avl, box(5), box(2), nullptr);
+  avl = gpr_avl_add(avl, box(4), box(3), nullptr);
+  GPR_ASSERT(*(int*)avl.root->key == 4);
+  GPR_ASSERT(*(int*)avl.root->left->key == 3);
+  GPR_ASSERT(*(int*)avl.root->right->key == 5);
+  gpr_avl_unref(avl, nullptr);
+}
+
+static void test_unbalanced(void) {
+  gpr_avl avl;
+  gpr_log(GPR_DEBUG, "test_unbalanced");
+  avl = gpr_avl_create(&int_int_vtable);
+  avl = gpr_avl_add(avl, box(5), box(1), nullptr);
+  avl = gpr_avl_add(avl, box(4), box(2), nullptr);
+  avl = gpr_avl_add(avl, box(3), box(3), nullptr);
+  avl = gpr_avl_add(avl, box(2), box(4), nullptr);
+  avl = gpr_avl_add(avl, box(1), box(5), nullptr);
+  GPR_ASSERT(*(int*)avl.root->key == 4);
+  GPR_ASSERT(*(int*)avl.root->left->key == 2);
+  GPR_ASSERT(*(int*)avl.root->left->left->key == 1);
+  GPR_ASSERT(*(int*)avl.root->left->right->key == 3);
+  GPR_ASSERT(*(int*)avl.root->right->key == 5);
+  gpr_avl_unref(avl, nullptr);
+}
+
+static void test_replace(void) {
+  gpr_avl avl;
+  gpr_log(GPR_DEBUG, "test_replace");
+  avl = gpr_avl_create(&int_int_vtable);
+  avl = gpr_avl_add(avl, box(1), box(1), nullptr);
+  avl = gpr_avl_add(avl, box(1), box(2), nullptr);
+  check_get(avl, 1, 2);
+  check_negget(avl, 2);
+  gpr_avl_unref(avl, nullptr);
+}
+
+static void test_remove(void) {
+  gpr_avl avl;
+  gpr_avl avl3, avl4, avl5, avln;
+  gpr_log(GPR_DEBUG, "test_remove");
+  avl = gpr_avl_create(&int_int_vtable);
+  avl = gpr_avl_add(avl, box(3), box(1), nullptr);
+  avl = gpr_avl_add(avl, box(4), box(2), nullptr);
+  avl = gpr_avl_add(avl, box(5), box(3), nullptr);
+
+  avl3 = remove_int(gpr_avl_ref(avl, nullptr), 3);
+  avl4 = remove_int(gpr_avl_ref(avl, nullptr), 4);
+  avl5 = remove_int(gpr_avl_ref(avl, nullptr), 5);
+  avln = remove_int(gpr_avl_ref(avl, nullptr), 1);
+
+  gpr_avl_unref(avl, nullptr);
+
+  check_negget(avl3, 3);
+  check_get(avl3, 4, 2);
+  check_get(avl3, 5, 3);
+  gpr_avl_unref(avl3, nullptr);
+
+  check_get(avl4, 3, 1);
+  check_negget(avl4, 4);
+  check_get(avl4, 5, 3);
+  gpr_avl_unref(avl4, nullptr);
+
+  check_get(avl5, 3, 1);
+  check_get(avl5, 4, 2);
+  check_negget(avl5, 5);
+  gpr_avl_unref(avl5, nullptr);
+
+  check_get(avln, 3, 1);
+  check_get(avln, 4, 2);
+  check_get(avln, 5, 3);
+  gpr_avl_unref(avln, nullptr);
+}
+
+static void test_badcase1(void) {
+  gpr_avl avl;
+
+  gpr_log(GPR_DEBUG, "test_badcase1");
+
+  avl = gpr_avl_create(&int_int_vtable);
+  avl = gpr_avl_add(avl, box(88), box(1), nullptr);
+  avl = remove_int(avl, 643);
+  avl = remove_int(avl, 983);
+  avl = gpr_avl_add(avl, box(985), box(4), nullptr);
+  avl = gpr_avl_add(avl, box(640), box(5), nullptr);
+  avl = gpr_avl_add(avl, box(41), box(6), nullptr);
+  avl = gpr_avl_add(avl, box(112), box(7), nullptr);
+  avl = gpr_avl_add(avl, box(342), box(8), nullptr);
+  avl = remove_int(avl, 1013);
+  avl = gpr_avl_add(avl, box(434), box(10), nullptr);
+  avl = gpr_avl_add(avl, box(520), box(11), nullptr);
+  avl = gpr_avl_add(avl, box(231), box(12), nullptr);
+  avl = gpr_avl_add(avl, box(852), box(13), nullptr);
+  avl = remove_int(avl, 461);
+  avl = gpr_avl_add(avl, box(108), box(15), nullptr);
+  avl = gpr_avl_add(avl, box(806), box(16), nullptr);
+  avl = gpr_avl_add(avl, box(827), box(17), nullptr);
+  avl = remove_int(avl, 796);
+  avl = gpr_avl_add(avl, box(340), box(19), nullptr);
+  avl = gpr_avl_add(avl, box(498), box(20), nullptr);
+  avl = gpr_avl_add(avl, box(203), box(21), nullptr);
+  avl = gpr_avl_add(avl, box(751), box(22), nullptr);
+  avl = gpr_avl_add(avl, box(150), box(23), nullptr);
+  avl = remove_int(avl, 237);
+  avl = gpr_avl_add(avl, box(830), box(25), nullptr);
+  avl = remove_int(avl, 1007);
+  avl = remove_int(avl, 394);
+  avl = gpr_avl_add(avl, box(65), box(28), nullptr);
+  avl = remove_int(avl, 904);
+  avl = remove_int(avl, 123);
+  avl = gpr_avl_add(avl, box(238), box(31), nullptr);
+  avl = gpr_avl_add(avl, box(184), box(32), nullptr);
+  avl = remove_int(avl, 331);
+  avl = gpr_avl_add(avl, box(827), box(34), nullptr);
+
+  check_get(avl, 830, 25);
+
+  gpr_avl_unref(avl, nullptr);
+}
+
+static void test_badcase2(void) {
+  gpr_avl avl;
+
+  gpr_log(GPR_DEBUG, "test_badcase2");
+
+  avl = gpr_avl_create(&int_int_vtable);
+  avl = gpr_avl_add(avl, box(288), box(1), nullptr);
+  avl = remove_int(avl, 415);
+  avl = gpr_avl_add(avl, box(953), box(3), nullptr);
+  avl = gpr_avl_add(avl, box(101), box(4), nullptr);
+  avl = gpr_avl_add(avl, box(516), box(5), nullptr);
+  avl = gpr_avl_add(avl, box(547), box(6), nullptr);
+  avl = gpr_avl_add(avl, box(467), box(7), nullptr);
+  avl = gpr_avl_add(avl, box(793), box(8), nullptr);
+  avl = remove_int(avl, 190);
+  avl = gpr_avl_add(avl, box(687), box(10), nullptr);
+  avl = gpr_avl_add(avl, box(242), box(11), nullptr);
+  avl = gpr_avl_add(avl, box(142), box(12), nullptr);
+  avl = remove_int(avl, 705);
+  avl = remove_int(avl, 578);
+  avl = remove_int(avl, 767);
+  avl = remove_int(avl, 183);
+  avl = gpr_avl_add(avl, box(950), box(17), nullptr);
+  avl = gpr_avl_add(avl, box(622), box(18), nullptr);
+  avl = remove_int(avl, 513);
+  avl = remove_int(avl, 429);
+  avl = gpr_avl_add(avl, box(205), box(21), nullptr);
+  avl = remove_int(avl, 663);
+  avl = remove_int(avl, 953);
+  avl = remove_int(avl, 892);
+  avl = gpr_avl_add(avl, box(236), box(25), nullptr);
+  avl = remove_int(avl, 982);
+  avl = remove_int(avl, 201);
+  avl = remove_int(avl, 684);
+  avl = gpr_avl_add(avl, box(572), box(29), nullptr);
+  avl = remove_int(avl, 817);
+  avl = gpr_avl_add(avl, box(970), box(31), nullptr);
+  avl = remove_int(avl, 347);
+  avl = remove_int(avl, 574);
+  avl = gpr_avl_add(avl, box(752), box(34), nullptr);
+  avl = gpr_avl_add(avl, box(670), box(35), nullptr);
+  avl = gpr_avl_add(avl, box(69), box(36), nullptr);
+  avl = remove_int(avl, 111);
+  avl = remove_int(avl, 523);
+  avl = gpr_avl_add(avl, box(141), box(39), nullptr);
+  avl = remove_int(avl, 159);
+  avl = gpr_avl_add(avl, box(947), box(41), nullptr);
+  avl = gpr_avl_add(avl, box(855), box(42), nullptr);
+  avl = remove_int(avl, 218);
+  avl = remove_int(avl, 6);
+  avl = gpr_avl_add(avl, box(753), box(45), nullptr);
+  avl = remove_int(avl, 82);
+  avl = remove_int(avl, 799);
+  avl = gpr_avl_add(avl, box(572), box(48), nullptr);
+  avl = remove_int(avl, 376);
+  avl = remove_int(avl, 413);
+  avl = gpr_avl_add(avl, box(458), box(51), nullptr);
+  avl = remove_int(avl, 897);
+  avl = gpr_avl_add(avl, box(191), box(53), nullptr);
+  avl = gpr_avl_add(avl, box(609), box(54), nullptr);
+  avl = remove_int(avl, 787);
+  avl = remove_int(avl, 710);
+  avl = remove_int(avl, 886);
+  avl = remove_int(avl, 835);
+  avl = remove_int(avl, 33);
+  avl = gpr_avl_add(avl, box(871), box(60), nullptr);
+  avl = remove_int(avl, 641);
+  avl = gpr_avl_add(avl, box(462), box(62), nullptr);
+  avl = remove_int(avl, 359);
+  avl = remove_int(avl, 767);
+  avl = gpr_avl_add(avl, box(310), box(65), nullptr);
+  avl = remove_int(avl, 757);
+  avl = remove_int(avl, 639);
+  avl = remove_int(avl, 314);
+  avl = gpr_avl_add(avl, box(2), box(69), nullptr);
+  avl = remove_int(avl, 138);
+  avl = gpr_avl_add(avl, box(669), box(71), nullptr);
+  avl = remove_int(avl, 477);
+  avl = gpr_avl_add(avl, box(366), box(73), nullptr);
+  avl = gpr_avl_add(avl, box(612), box(74), nullptr);
+  avl = gpr_avl_add(avl, box(106), box(75), nullptr);
+  avl = remove_int(avl, 161);
+  avl = gpr_avl_add(avl, box(388), box(77), nullptr);
+  avl = gpr_avl_add(avl, box(141), box(78), nullptr);
+  avl = remove_int(avl, 633);
+  avl = remove_int(avl, 459);
+  avl = gpr_avl_add(avl, box(40), box(81), nullptr);
+  avl = remove_int(avl, 689);
+  avl = gpr_avl_add(avl, box(823), box(83), nullptr);
+  avl = remove_int(avl, 485);
+  avl = gpr_avl_add(avl, box(903), box(85), nullptr);
+  avl = gpr_avl_add(avl, box(592), box(86), nullptr);
+  avl = remove_int(avl, 448);
+  avl = gpr_avl_add(avl, box(56), box(88), nullptr);
+  avl = remove_int(avl, 333);
+  avl = gpr_avl_add(avl, box(189), box(90), nullptr);
+  avl = gpr_avl_add(avl, box(103), box(91), nullptr);
+  avl = remove_int(avl, 164);
+  avl = remove_int(avl, 974);
+  avl = gpr_avl_add(avl, box(215), box(94), nullptr);
+  avl = remove_int(avl, 189);
+  avl = remove_int(avl, 504);
+  avl = gpr_avl_add(avl, box(868), box(97), nullptr);
+  avl = remove_int(avl, 909);
+  avl = remove_int(avl, 148);
+  avl = remove_int(avl, 469);
+  avl = gpr_avl_add(avl, box(994), box(101), nullptr);
+  avl = gpr_avl_add(avl, box(576), box(102), nullptr);
+  avl = remove_int(avl, 82);
+  avl = remove_int(avl, 209);
+  avl = gpr_avl_add(avl, box(276), box(105), nullptr);
+  avl = remove_int(avl, 856);
+  avl = gpr_avl_add(avl, box(750), box(107), nullptr);
+  avl = remove_int(avl, 871);
+  avl = gpr_avl_add(avl, box(301), box(109), nullptr);
+  avl = remove_int(avl, 260);
+  avl = remove_int(avl, 737);
+  avl = remove_int(avl, 719);
+  avl = gpr_avl_add(avl, box(933), box(113), nullptr);
+  avl = gpr_avl_add(avl, box(225), box(114), nullptr);
+  avl = gpr_avl_add(avl, box(975), box(115), nullptr);
+  avl = gpr_avl_add(avl, box(86), box(116), nullptr);
+  avl = remove_int(avl, 732);
+  avl = gpr_avl_add(avl, box(340), box(118), nullptr);
+  avl = gpr_avl_add(avl, box(271), box(119), nullptr);
+  avl = remove_int(avl, 206);
+  avl = gpr_avl_add(avl, box(949), box(121), nullptr);
+  avl = gpr_avl_add(avl, box(927), box(122), nullptr);
+  avl = gpr_avl_add(avl, box(34), box(123), nullptr);
+  avl = gpr_avl_add(avl, box(351), box(124), nullptr);
+  avl = remove_int(avl, 836);
+  avl = gpr_avl_add(avl, box(825), box(126), nullptr);
+  avl = gpr_avl_add(avl, box(352), box(127), nullptr);
+  avl = remove_int(avl, 107);
+  avl = remove_int(avl, 101);
+  avl = gpr_avl_add(avl, box(320), box(130), nullptr);
+  avl = gpr_avl_add(avl, box(3), box(131), nullptr);
+  avl = remove_int(avl, 998);
+  avl = remove_int(avl, 44);
+  avl = gpr_avl_add(avl, box(525), box(134), nullptr);
+  avl = gpr_avl_add(avl, box(864), box(135), nullptr);
+  avl = gpr_avl_add(avl, box(863), box(136), nullptr);
+  avl = remove_int(avl, 770);
+  avl = gpr_avl_add(avl, box(440), box(138), nullptr);
+  avl = remove_int(avl, 516);
+  avl = gpr_avl_add(avl, box(116), box(140), nullptr);
+  avl = remove_int(avl, 380);
+  avl = gpr_avl_add(avl, box(878), box(142), nullptr);
+  avl = remove_int(avl, 439);
+  avl = gpr_avl_add(avl, box(994), box(144), nullptr);
+  avl = remove_int(avl, 294);
+  avl = remove_int(avl, 593);
+  avl = gpr_avl_add(avl, box(696), box(147), nullptr);
+  avl = remove_int(avl, 8);
+  avl = gpr_avl_add(avl, box(881), box(149), nullptr);
+  avl = remove_int(avl, 32);
+  avl = remove_int(avl, 242);
+  avl = gpr_avl_add(avl, box(487), box(152), nullptr);
+  avl = gpr_avl_add(avl, box(637), box(153), nullptr);
+  avl = gpr_avl_add(avl, box(793), box(154), nullptr);
+  avl = gpr_avl_add(avl, box(696), box(155), nullptr);
+  avl = remove_int(avl, 458);
+  avl = gpr_avl_add(avl, box(828), box(157), nullptr);
+  avl = remove_int(avl, 784);
+  avl = remove_int(avl, 274);
+  avl = gpr_avl_add(avl, box(783), box(160), nullptr);
+  avl = remove_int(avl, 21);
+  avl = gpr_avl_add(avl, box(866), box(162), nullptr);
+  avl = remove_int(avl, 919);
+  avl = gpr_avl_add(avl, box(435), box(164), nullptr);
+  avl = remove_int(avl, 385);
+  avl = gpr_avl_add(avl, box(475), box(166), nullptr);
+  avl = remove_int(avl, 339);
+  avl = gpr_avl_add(avl, box(615), box(168), nullptr);
+  avl = remove_int(avl, 866);
+  avl = remove_int(avl, 82);
+  avl = remove_int(avl, 271);
+  avl = gpr_avl_add(avl, box(590), box(172), nullptr);
+  avl = gpr_avl_add(avl, box(852), box(173), nullptr);
+  avl = remove_int(avl, 318);
+  avl = remove_int(avl, 82);
+  avl = gpr_avl_add(avl, box(672), box(176), nullptr);
+  avl = remove_int(avl, 430);
+  avl = gpr_avl_add(avl, box(821), box(178), nullptr);
+  avl = gpr_avl_add(avl, box(365), box(179), nullptr);
+  avl = remove_int(avl, 78);
+  avl = gpr_avl_add(avl, box(700), box(181), nullptr);
+  avl = gpr_avl_add(avl, box(353), box(182), nullptr);
+  avl = remove_int(avl, 492);
+  avl = gpr_avl_add(avl, box(991), box(184), nullptr);
+  avl = remove_int(avl, 330);
+  avl = gpr_avl_add(avl, box(873), box(186), nullptr);
+  avl = remove_int(avl, 589);
+  avl = gpr_avl_add(avl, box(676), box(188), nullptr);
+  avl = gpr_avl_add(avl, box(790), box(189), nullptr);
+  avl = remove_int(avl, 521);
+  avl = remove_int(avl, 47);
+  avl = gpr_avl_add(avl, box(976), box(192), nullptr);
+  avl = gpr_avl_add(avl, box(683), box(193), nullptr);
+  avl = remove_int(avl, 803);
+  avl = remove_int(avl, 1006);
+  avl = gpr_avl_add(avl, box(775), box(196), nullptr);
+  avl = gpr_avl_add(avl, box(411), box(197), nullptr);
+  avl = gpr_avl_add(avl, box(697), box(198), nullptr);
+  avl = remove_int(avl, 50);
+  avl = gpr_avl_add(avl, box(213), box(200), nullptr);
+  avl = remove_int(avl, 714);
+  avl = gpr_avl_add(avl, box(981), box(202), nullptr);
+  avl = gpr_avl_add(avl, box(502), box(203), nullptr);
+  avl = gpr_avl_add(avl, box(697), box(204), nullptr);
+  avl = gpr_avl_add(avl, box(603), box(205), nullptr);
+  avl = gpr_avl_add(avl, box(117), box(206), nullptr);
+  avl = remove_int(avl, 363);
+  avl = gpr_avl_add(avl, box(104), box(208), nullptr);
+  avl = remove_int(avl, 842);
+  avl = gpr_avl_add(avl, box(48), box(210), nullptr);
+  avl = remove_int(avl, 764);
+  avl = gpr_avl_add(avl, box(482), box(212), nullptr);
+  avl = gpr_avl_add(avl, box(928), box(213), nullptr);
+  avl = gpr_avl_add(avl, box(30), box(214), nullptr);
+  avl = gpr_avl_add(avl, box(820), box(215), nullptr);
+  avl = gpr_avl_add(avl, box(334), box(216), nullptr);
+  avl = remove_int(avl, 306);
+  avl = gpr_avl_add(avl, box(789), box(218), nullptr);
+  avl = remove_int(avl, 924);
+  avl = gpr_avl_add(avl, box(53), box(220), nullptr);
+  avl = remove_int(avl, 657);
+  avl = gpr_avl_add(avl, box(130), box(222), nullptr);
+  avl = gpr_avl_add(avl, box(239), box(223), nullptr);
+  avl = remove_int(avl, 20);
+  avl = gpr_avl_add(avl, box(117), box(225), nullptr);
+  avl = remove_int(avl, 882);
+  avl = remove_int(avl, 891);
+  avl = gpr_avl_add(avl, box(9), box(228), nullptr);
+  avl = gpr_avl_add(avl, box(496), box(229), nullptr);
+  avl = gpr_avl_add(avl, box(750), box(230), nullptr);
+  avl = gpr_avl_add(avl, box(283), box(231), nullptr);
+  avl = gpr_avl_add(avl, box(802), box(232), nullptr);
+  avl = remove_int(avl, 352);
+  avl = gpr_avl_add(avl, box(374), box(234), nullptr);
+  avl = gpr_avl_add(avl, box(6), box(235), nullptr);
+  avl = gpr_avl_add(avl, box(756), box(236), nullptr);
+  avl = gpr_avl_add(avl, box(597), box(237), nullptr);
+  avl = gpr_avl_add(avl, box(661), box(238), nullptr);
+  avl = remove_int(avl, 96);
+  avl = gpr_avl_add(avl, box(894), box(240), nullptr);
+  avl = remove_int(avl, 749);
+  avl = gpr_avl_add(avl, box(71), box(242), nullptr);
+  avl = remove_int(avl, 68);
+  avl = gpr_avl_add(avl, box(388), box(244), nullptr);
+  avl = remove_int(avl, 119);
+  avl = remove_int(avl, 856);
+  avl = gpr_avl_add(avl, box(176), box(247), nullptr);
+  avl = gpr_avl_add(avl, box(993), box(248), nullptr);
+  avl = remove_int(avl, 178);
+  avl = remove_int(avl, 781);
+  avl = remove_int(avl, 771);
+  avl = remove_int(avl, 848);
+  avl = remove_int(avl, 376);
+  avl = remove_int(avl, 157);
+  avl = remove_int(avl, 142);
+  avl = remove_int(avl, 686);
+  avl = gpr_avl_add(avl, box(779), box(257), nullptr);
+  avl = gpr_avl_add(avl, box(484), box(258), nullptr);
+  avl = remove_int(avl, 837);
+  avl = gpr_avl_add(avl, box(388), box(260), nullptr);
+  avl = remove_int(avl, 987);
+  avl = gpr_avl_add(avl, box(336), box(262), nullptr);
+  avl = remove_int(avl, 855);
+  avl = gpr_avl_add(avl, box(668), box(264), nullptr);
+  avl = remove_int(avl, 648);
+  avl = gpr_avl_add(avl, box(193), box(266), nullptr);
+  avl = remove_int(avl, 939);
+  avl = gpr_avl_add(avl, box(740), box(268), nullptr);
+  avl = gpr_avl_add(avl, box(503), box(269), nullptr);
+  avl = gpr_avl_add(avl, box(765), box(270), nullptr);
+  avl = remove_int(avl, 924);
+  avl = remove_int(avl, 513);
+  avl = gpr_avl_add(avl, box(161), box(273), nullptr);
+  avl = gpr_avl_add(avl, box(502), box(274), nullptr);
+  avl = gpr_avl_add(avl, box(846), box(275), nullptr);
+  avl = remove_int(avl, 931);
+  avl = gpr_avl_add(avl, box(87), box(277), nullptr);
+  avl = gpr_avl_add(avl, box(949), box(278), nullptr);
+  avl = gpr_avl_add(avl, box(548), box(279), nullptr);
+  avl = gpr_avl_add(avl, box(951), box(280), nullptr);
+  avl = remove_int(avl, 1018);
+  avl = remove_int(avl, 568);
+  avl = gpr_avl_add(avl, box(138), box(283), nullptr);
+  avl = gpr_avl_add(avl, box(202), box(284), nullptr);
+  avl = gpr_avl_add(avl, box(157), box(285), nullptr);
+  avl = gpr_avl_add(avl, box(264), box(286), nullptr);
+  avl = gpr_avl_add(avl, box(370), box(287), nullptr);
+  avl = remove_int(avl, 736);
+  avl = remove_int(avl, 751);
+  avl = remove_int(avl, 506);
+  avl = remove_int(avl, 81);
+  avl = remove_int(avl, 358);
+  avl = remove_int(avl, 657);
+  avl = remove_int(avl, 86);
+  avl = gpr_avl_add(avl, box(876), box(295), nullptr);
+  avl = remove_int(avl, 354);
+  avl = gpr_avl_add(avl, box(134), box(297), nullptr);
+  avl = remove_int(avl, 781);
+  avl = remove_int(avl, 183);
+  avl = gpr_avl_add(avl, box(914), box(300), nullptr);
+  avl = remove_int(avl, 926);
+  avl = remove_int(avl, 398);
+  avl = remove_int(avl, 932);
+  avl = remove_int(avl, 804);
+  avl = remove_int(avl, 326);
+  avl = gpr_avl_add(avl, box(208), box(306), nullptr);
+  avl = gpr_avl_add(avl, box(699), box(307), nullptr);
+  avl = remove_int(avl, 576);
+  avl = remove_int(avl, 850);
+  avl = remove_int(avl, 514);
+  avl = remove_int(avl, 676);
+  avl = remove_int(avl, 549);
+  avl = remove_int(avl, 767);
+  avl = gpr_avl_add(avl, box(58), box(314), nullptr);
+  avl = gpr_avl_add(avl, box(265), box(315), nullptr);
+  avl = gpr_avl_add(avl, box(268), box(316), nullptr);
+  avl = gpr_avl_add(avl, box(103), box(317), nullptr);
+  avl = gpr_avl_add(avl, box(440), box(318), nullptr);
+  avl = remove_int(avl, 777);
+  avl = gpr_avl_add(avl, box(670), box(320), nullptr);
+  avl = remove_int(avl, 506);
+  avl = remove_int(avl, 487);
+  avl = gpr_avl_add(avl, box(421), box(323), nullptr);
+  avl = remove_int(avl, 514);
+  avl = gpr_avl_add(avl, box(701), box(325), nullptr);
+  avl = remove_int(avl, 949);
+  avl = remove_int(avl, 872);
+  avl = remove_int(avl, 139);
+  avl = gpr_avl_add(avl, box(781), box(329), nullptr);
+  avl = gpr_avl_add(avl, box(543), box(330), nullptr);
+  avl = gpr_avl_add(avl, box(147), box(331), nullptr);
+  avl = remove_int(avl, 190);
+  avl = gpr_avl_add(avl, box(453), box(333), nullptr);
+  avl = remove_int(avl, 262);
+  avl = remove_int(avl, 850);
+  avl = remove_int(avl, 286);
+  avl = remove_int(avl, 787);
+  avl = gpr_avl_add(avl, box(514), box(338), nullptr);
+  avl = remove_int(avl, 812);
+  avl = gpr_avl_add(avl, box(431), box(340), nullptr);
+  avl = gpr_avl_add(avl, box(8), box(341), nullptr);
+  avl = remove_int(avl, 843);
+  avl = gpr_avl_add(avl, box(831), box(343), nullptr);
+  avl = remove_int(avl, 472);
+  avl = remove_int(avl, 157);
+  avl = gpr_avl_add(avl, box(612), box(346), nullptr);
+  avl = gpr_avl_add(avl, box(802), box(347), nullptr);
+  avl = remove_int(avl, 554);
+  avl = gpr_avl_add(avl, box(409), box(349), nullptr);
+  avl = gpr_avl_add(avl, box(439), box(350), nullptr);
+  avl = gpr_avl_add(avl, box(725), box(351), nullptr);
+  avl = gpr_avl_add(avl, box(568), box(352), nullptr);
+  avl = remove_int(avl, 475);
+  avl = remove_int(avl, 672);
+  avl = remove_int(avl, 62);
+  avl = remove_int(avl, 753);
+  avl = gpr_avl_add(avl, box(435), box(357), nullptr);
+  avl = gpr_avl_add(avl, box(950), box(358), nullptr);
+  avl = gpr_avl_add(avl, box(532), box(359), nullptr);
+  avl = gpr_avl_add(avl, box(832), box(360), nullptr);
+  avl = remove_int(avl, 390);
+  avl = gpr_avl_add(avl, box(993), box(362), nullptr);
+  avl = remove_int(avl, 198);
+  avl = remove_int(avl, 401);
+  avl = gpr_avl_add(avl, box(316), box(365), nullptr);
+  avl = remove_int(avl, 843);
+  avl = gpr_avl_add(avl, box(541), box(367), nullptr);
+  avl = gpr_avl_add(avl, box(505), box(368), nullptr);
+  avl = remove_int(avl, 445);
+  avl = remove_int(avl, 256);
+  avl = gpr_avl_add(avl, box(232), box(371), nullptr);
+  avl = remove_int(avl, 577);
+  avl = remove_int(avl, 558);
+  avl = gpr_avl_add(avl, box(910), box(374), nullptr);
+  avl = remove_int(avl, 902);
+  avl = remove_int(avl, 755);
+  avl = remove_int(avl, 114);
+  avl = remove_int(avl, 438);
+  avl = remove_int(avl, 224);
+  avl = gpr_avl_add(avl, box(920), box(380), nullptr);
+  avl = gpr_avl_add(avl, box(655), box(381), nullptr);
+  avl = remove_int(avl, 557);
+  avl = remove_int(avl, 102);
+  avl = remove_int(avl, 165);
+  avl = gpr_avl_add(avl, box(191), box(385), nullptr);
+  avl = remove_int(avl, 30);
+  avl = gpr_avl_add(avl, box(406), box(387), nullptr);
+  avl = gpr_avl_add(avl, box(66), box(388), nullptr);
+  avl = gpr_avl_add(avl, box(87), box(389), nullptr);
+  avl = remove_int(avl, 7);
+  avl = remove_int(avl, 671);
+  avl = gpr_avl_add(avl, box(234), box(392), nullptr);
+  avl = remove_int(avl, 463);
+  avl = gpr_avl_add(avl, box(75), box(394), nullptr);
+  avl = gpr_avl_add(avl, box(487), box(395), nullptr);
+  avl = remove_int(avl, 203);
+  avl = gpr_avl_add(avl, box(711), box(397), nullptr);
+  avl = remove_int(avl, 291);
+  avl = remove_int(avl, 798);
+  avl = remove_int(avl, 337);
+  avl = gpr_avl_add(avl, box(877), box(401), nullptr);
+  avl = gpr_avl_add(avl, box(388), box(402), nullptr);
+  avl = remove_int(avl, 975);
+  avl = gpr_avl_add(avl, box(200), box(404), nullptr);
+  avl = gpr_avl_add(avl, box(408), box(405), nullptr);
+  avl = gpr_avl_add(avl, box(3), box(406), nullptr);
+  avl = gpr_avl_add(avl, box(971), box(407), nullptr);
+  avl = remove_int(avl, 841);
+  avl = remove_int(avl, 910);
+  avl = remove_int(avl, 74);
+  avl = remove_int(avl, 888);
+  avl = gpr_avl_add(avl, box(492), box(412), nullptr);
+  avl = remove_int(avl, 14);
+  avl = remove_int(avl, 364);
+  avl = gpr_avl_add(avl, box(215), box(415), nullptr);
+  avl = remove_int(avl, 778);
+  avl = remove_int(avl, 45);
+  avl = gpr_avl_add(avl, box(328), box(418), nullptr);
+  avl = gpr_avl_add(avl, box(597), box(419), nullptr);
+  avl = remove_int(avl, 34);
+  avl = gpr_avl_add(avl, box(736), box(421), nullptr);
+  avl = remove_int(avl, 37);
+  avl = gpr_avl_add(avl, box(275), box(423), nullptr);
+  avl = gpr_avl_add(avl, box(70), box(424), nullptr);
+  avl = gpr_avl_add(avl, box(771), box(425), nullptr);
+  avl = remove_int(avl, 536);
+  avl = remove_int(avl, 421);
+  avl = gpr_avl_add(avl, box(186), box(428), nullptr);
+  avl = gpr_avl_add(avl, box(788), box(429), nullptr);
+  avl = gpr_avl_add(avl, box(224), box(430), nullptr);
+  avl = remove_int(avl, 228);
+  avl = gpr_avl_add(avl, box(48), box(432), nullptr);
+  avl = gpr_avl_add(avl, box(120), box(433), nullptr);
+  avl = gpr_avl_add(avl, box(269), box(434), nullptr);
+  avl = gpr_avl_add(avl, box(904), box(435), nullptr);
+  avl = remove_int(avl, 699);
+  avl = gpr_avl_add(avl, box(340), box(437), nullptr);
+  avl = remove_int(avl, 276);
+  avl = gpr_avl_add(avl, box(591), box(439), nullptr);
+  avl = gpr_avl_add(avl, box(778), box(440), nullptr);
+  avl = remove_int(avl, 490);
+  avl = remove_int(avl, 973);
+  avl = gpr_avl_add(avl, box(294), box(443), nullptr);
+  avl = gpr_avl_add(avl, box(323), box(444), nullptr);
+  avl = remove_int(avl, 685);
+  avl = gpr_avl_add(avl, box(38), box(446), nullptr);
+  avl = gpr_avl_add(avl, box(525), box(447), nullptr);
+  avl = remove_int(avl, 162);
+  avl = gpr_avl_add(avl, box(462), box(449), nullptr);
+  avl = gpr_avl_add(avl, box(340), box(450), nullptr);
+  avl = remove_int(avl, 734);
+  avl = remove_int(avl, 959);
+  avl = gpr_avl_add(avl, box(752), box(453), nullptr);
+  avl = gpr_avl_add(avl, box(667), box(454), nullptr);
+  avl = remove_int(avl, 558);
+  avl = remove_int(avl, 657);
+  avl = gpr_avl_add(avl, box(711), box(457), nullptr);
+  avl = remove_int(avl, 937);
+  avl = gpr_avl_add(avl, box(741), box(459), nullptr);
+  avl = gpr_avl_add(avl, box(40), box(460), nullptr);
+  avl = remove_int(avl, 784);
+  avl = gpr_avl_add(avl, box(292), box(462), nullptr);
+  avl = remove_int(avl, 164);
+  avl = remove_int(avl, 931);
+  avl = remove_int(avl, 886);
+  avl = gpr_avl_add(avl, box(968), box(466), nullptr);
+  avl = remove_int(avl, 263);
+  avl = gpr_avl_add(avl, box(647), box(468), nullptr);
+  avl = gpr_avl_add(avl, box(92), box(469), nullptr);
+  avl = remove_int(avl, 310);
+  avl = gpr_avl_add(avl, box(711), box(471), nullptr);
+  avl = gpr_avl_add(avl, box(675), box(472), nullptr);
+  avl = remove_int(avl, 549);
+  avl = gpr_avl_add(avl, box(380), box(474), nullptr);
+  avl = remove_int(avl, 825);
+  avl = gpr_avl_add(avl, box(668), box(476), nullptr);
+  avl = remove_int(avl, 498);
+  avl = gpr_avl_add(avl, box(870), box(478), nullptr);
+  avl = gpr_avl_add(avl, box(391), box(479), nullptr);
+  avl = gpr_avl_add(avl, box(264), box(480), nullptr);
+  avl = remove_int(avl, 1);
+  avl = remove_int(avl, 849);
+  avl = remove_int(avl, 88);
+  avl = remove_int(avl, 255);
+  avl = remove_int(avl, 763);
+  avl = remove_int(avl, 831);
+  avl = gpr_avl_add(avl, box(508), box(487), nullptr);
+  avl = remove_int(avl, 849);
+  avl = remove_int(avl, 47);
+  avl = gpr_avl_add(avl, box(299), box(490), nullptr);
+  avl = remove_int(avl, 625);
+  avl = remove_int(avl, 433);
+  avl = remove_int(avl, 904);
+  avl = remove_int(avl, 761);
+  avl = gpr_avl_add(avl, box(33), box(495), nullptr);
+  avl = gpr_avl_add(avl, box(524), box(496), nullptr);
+  avl = remove_int(avl, 210);
+  avl = remove_int(avl, 299);
+  avl = gpr_avl_add(avl, box(823), box(499), nullptr);
+  avl = remove_int(avl, 479);
+  avl = remove_int(avl, 96);
+  avl = remove_int(avl, 1013);
+  avl = gpr_avl_add(avl, box(768), box(503), nullptr);
+  avl = remove_int(avl, 638);
+  avl = remove_int(avl, 20);
+  avl = gpr_avl_add(avl, box(663), box(506), nullptr);
+  avl = remove_int(avl, 882);
+  avl = gpr_avl_add(avl, box(745), box(508), nullptr);
+  avl = remove_int(avl, 352);
+  avl = gpr_avl_add(avl, box(10), box(510), nullptr);
+  avl = remove_int(avl, 484);
+  avl = gpr_avl_add(avl, box(420), box(512), nullptr);
+  avl = gpr_avl_add(avl, box(884), box(513), nullptr);
+  avl = gpr_avl_add(avl, box(993), box(514), nullptr);
+  avl = gpr_avl_add(avl, box(251), box(515), nullptr);
+  avl = remove_int(avl, 222);
+  avl = gpr_avl_add(avl, box(734), box(517), nullptr);
+  avl = gpr_avl_add(avl, box(952), box(518), nullptr);
+  avl = remove_int(avl, 26);
+  avl = remove_int(avl, 270);
+  avl = remove_int(avl, 481);
+  avl = remove_int(avl, 693);
+  avl = remove_int(avl, 1006);
+  avl = gpr_avl_add(avl, box(77), box(524), nullptr);
+  avl = remove_int(avl, 897);
+  avl = gpr_avl_add(avl, box(719), box(526), nullptr);
+  avl = gpr_avl_add(avl, box(622), box(527), nullptr);
+  avl = remove_int(avl, 28);
+  avl = remove_int(avl, 836);
+  avl = remove_int(avl, 142);
+  avl = gpr_avl_add(avl, box(445), box(531), nullptr);
+  avl = gpr_avl_add(avl, box(410), box(532), nullptr);
+  avl = remove_int(avl, 575);
+  avl = gpr_avl_add(avl, box(634), box(534), nullptr);
+  avl = gpr_avl_add(avl, box(906), box(535), nullptr);
+  avl = remove_int(avl, 649);
+  avl = gpr_avl_add(avl, box(813), box(537), nullptr);
+  avl = remove_int(avl, 702);
+  avl = remove_int(avl, 732);
+  avl = gpr_avl_add(avl, box(105), box(540), nullptr);
+  avl = gpr_avl_add(avl, box(867), box(541), nullptr);
+  avl = remove_int(avl, 964);
+  avl = remove_int(avl, 941);
+  avl = gpr_avl_add(avl, box(947), box(544), nullptr);
+  avl = remove_int(avl, 990);
+  avl = gpr_avl_add(avl, box(816), box(546), nullptr);
+  avl = remove_int(avl, 429);
+  avl = remove_int(avl, 567);
+  avl = remove_int(avl, 541);
+  avl = remove_int(avl, 583);
+  avl = gpr_avl_add(avl, box(57), box(551), nullptr);
+  avl = gpr_avl_add(avl, box(786), box(552), nullptr);
+  avl = gpr_avl_add(avl, box(526), box(553), nullptr);
+  avl = remove_int(avl, 642);
+  avl = remove_int(avl, 220);
+  avl = remove_int(avl, 840);
+  avl = remove_int(avl, 548);
+  avl = gpr_avl_add(avl, box(528), box(558), nullptr);
+  avl = gpr_avl_add(avl, box(749), box(559), nullptr);
+  avl = gpr_avl_add(avl, box(194), box(560), nullptr);
+  avl = remove_int(avl, 517);
+  avl = gpr_avl_add(avl, box(102), box(562), nullptr);
+  avl = remove_int(avl, 189);
+  avl = gpr_avl_add(avl, box(927), box(564), nullptr);
+  avl = remove_int(avl, 846);
+  avl = remove_int(avl, 130);
+  avl = gpr_avl_add(avl, box(694), box(567), nullptr);
+  avl = remove_int(avl, 750);
+  avl = gpr_avl_add(avl, box(357), box(569), nullptr);
+  avl = remove_int(avl, 431);
+  avl = remove_int(avl, 91);
+  avl = gpr_avl_add(avl, box(640), box(572), nullptr);
+  avl = remove_int(avl, 4);
+  avl = gpr_avl_add(avl, box(81), box(574), nullptr);
+  avl = gpr_avl_add(avl, box(595), box(575), nullptr);
+  avl = remove_int(avl, 444);
+  avl = remove_int(avl, 262);
+  avl = remove_int(avl, 11);
+  avl = gpr_avl_add(avl, box(192), box(579), nullptr);
+  avl = gpr_avl_add(avl, box(158), box(580), nullptr);
+  avl = remove_int(avl, 401);
+  avl = remove_int(avl, 918);
+  avl = gpr_avl_add(avl, box(180), box(583), nullptr);
+  avl = remove_int(avl, 268);
+  avl = gpr_avl_add(avl, box(1012), box(585), nullptr);
+  avl = gpr_avl_add(avl, box(90), box(586), nullptr);
+  avl = gpr_avl_add(avl, box(946), box(587), nullptr);
+  avl = remove_int(avl, 719);
+  avl = gpr_avl_add(avl, box(874), box(589), nullptr);
+  avl = gpr_avl_add(avl, box(679), box(590), nullptr);
+  avl = remove_int(avl, 53);
+  avl = remove_int(avl, 534);
+  avl = gpr_avl_add(avl, box(646), box(593), nullptr);
+  avl = gpr_avl_add(avl, box(767), box(594), nullptr);
+  avl = gpr_avl_add(avl, box(460), box(595), nullptr);
+  avl = gpr_avl_add(avl, box(852), box(596), nullptr);
+  avl = gpr_avl_add(avl, box(189), box(597), nullptr);
+  avl = remove_int(avl, 932);
+  avl = remove_int(avl, 366);
+  avl = remove_int(avl, 907);
+  avl = gpr_avl_add(avl, box(875), box(601), nullptr);
+  avl = gpr_avl_add(avl, box(434), box(602), nullptr);
+  avl = gpr_avl_add(avl, box(704), box(603), nullptr);
+  avl = gpr_avl_add(avl, box(724), box(604), nullptr);
+  avl = gpr_avl_add(avl, box(930), box(605), nullptr);
+  avl = gpr_avl_add(avl, box(1000), box(606), nullptr);
+  avl = remove_int(avl, 479);
+  avl = gpr_avl_add(avl, box(275), box(608), nullptr);
+  avl = remove_int(avl, 32);
+  avl = gpr_avl_add(avl, box(939), box(610), nullptr);
+  avl = remove_int(avl, 943);
+  avl = remove_int(avl, 329);
+  avl = gpr_avl_add(avl, box(490), box(613), nullptr);
+  avl = remove_int(avl, 477);
+  avl = remove_int(avl, 414);
+  avl = remove_int(avl, 187);
+  avl = remove_int(avl, 334);
+  avl = gpr_avl_add(avl, box(40), box(618), nullptr);
+  avl = remove_int(avl, 751);
+  avl = gpr_avl_add(avl, box(568), box(620), nullptr);
+  avl = gpr_avl_add(avl, box(120), box(621), nullptr);
+  avl = gpr_avl_add(avl, box(617), box(622), nullptr);
+  avl = gpr_avl_add(avl, box(32), box(623), nullptr);
+  avl = remove_int(avl, 701);
+  avl = gpr_avl_add(avl, box(910), box(625), nullptr);
+  avl = remove_int(avl, 557);
+  avl = remove_int(avl, 361);
+  avl = remove_int(avl, 937);
+  avl = remove_int(avl, 100);
+  avl = remove_int(avl, 684);
+  avl = gpr_avl_add(avl, box(751), box(631), nullptr);
+  avl = remove_int(avl, 781);
+  avl = remove_int(avl, 469);
+  avl = remove_int(avl, 75);
+  avl = remove_int(avl, 561);
+  avl = gpr_avl_add(avl, box(854), box(636), nullptr);
+  avl = remove_int(avl, 164);
+  avl = remove_int(avl, 258);
+  avl = remove_int(avl, 315);
+  avl = remove_int(avl, 261);
+  avl = gpr_avl_add(avl, box(552), box(641), nullptr);
+  avl = gpr_avl_add(avl, box(6), box(642), nullptr);
+  avl = gpr_avl_add(avl, box(680), box(643), nullptr);
+  avl = remove_int(avl, 741);
+  avl = remove_int(avl, 309);
+  avl = remove_int(avl, 272);
+  avl = gpr_avl_add(avl, box(249), box(647), nullptr);
+  avl = remove_int(avl, 97);
+  avl = remove_int(avl, 850);
+  avl = gpr_avl_add(avl, box(915), box(650), nullptr);
+  avl = gpr_avl_add(avl, box(816), box(651), nullptr);
+  avl = gpr_avl_add(avl, box(45), box(652), nullptr);
+  avl = gpr_avl_add(avl, box(168), box(653), nullptr);
+  avl = remove_int(avl, 153);
+  avl = remove_int(avl, 239);
+  avl = gpr_avl_add(avl, box(684), box(656), nullptr);
+  avl = gpr_avl_add(avl, box(208), box(657), nullptr);
+  avl = gpr_avl_add(avl, box(681), box(658), nullptr);
+  avl = gpr_avl_add(avl, box(609), box(659), nullptr);
+  avl = gpr_avl_add(avl, box(645), box(660), nullptr);
+  avl = remove_int(avl, 799);
+  avl = gpr_avl_add(avl, box(955), box(662), nullptr);
+  avl = gpr_avl_add(avl, box(946), box(663), nullptr);
+  avl = gpr_avl_add(avl, box(744), box(664), nullptr);
+  avl = gpr_avl_add(avl, box(201), box(665), nullptr);
+  avl = gpr_avl_add(avl, box(136), box(666), nullptr);
+  avl = remove_int(avl, 357);
+  avl = gpr_avl_add(avl, box(974), box(668), nullptr);
+  avl = remove_int(avl, 485);
+  avl = gpr_avl_add(avl, box(1009), box(670), nullptr);
+  avl = gpr_avl_add(avl, box(517), box(671), nullptr);
+  avl = remove_int(avl, 491);
+  avl = gpr_avl_add(avl, box(336), box(673), nullptr);
+  avl = gpr_avl_add(avl, box(589), box(674), nullptr);
+  avl = remove_int(avl, 546);
+  avl = remove_int(avl, 840);
+  avl = remove_int(avl, 104);
+  avl = remove_int(avl, 347);
+  avl = gpr_avl_add(avl, box(801), box(679), nullptr);
+  avl = remove_int(avl, 799);
+  avl = remove_int(avl, 702);
+  avl = remove_int(avl, 996);
+  avl = remove_int(avl, 93);
+  avl = gpr_avl_add(avl, box(561), box(684), nullptr);
+  avl = gpr_avl_add(avl, box(25), box(685), nullptr);
+  avl = remove_int(avl, 278);
+  avl = gpr_avl_add(avl, box(191), box(687), nullptr);
+  avl = remove_int(avl, 243);
+  avl = remove_int(avl, 918);
+  avl = remove_int(avl, 449);
+  avl = gpr_avl_add(avl, box(19), box(691), nullptr);
+  avl = gpr_avl_add(avl, box(762), box(692), nullptr);
+  avl = gpr_avl_add(avl, box(13), box(693), nullptr);
+  avl = gpr_avl_add(avl, box(151), box(694), nullptr);
+  avl = gpr_avl_add(avl, box(152), box(695), nullptr);
+  avl = gpr_avl_add(avl, box(793), box(696), nullptr);
+  avl = remove_int(avl, 862);
+  avl = remove_int(avl, 890);
+  avl = gpr_avl_add(avl, box(687), box(699), nullptr);
+  avl = gpr_avl_add(avl, box(509), box(700), nullptr);
+  avl = gpr_avl_add(avl, box(973), box(701), nullptr);
+  avl = remove_int(avl, 230);
+  avl = gpr_avl_add(avl, box(532), box(703), nullptr);
+  avl = remove_int(avl, 668);
+  avl = gpr_avl_add(avl, box(281), box(705), nullptr);
+  avl = gpr_avl_add(avl, box(867), box(706), nullptr);
+  avl = gpr_avl_add(avl, box(359), box(707), nullptr);
+  avl = remove_int(avl, 425);
+  avl = gpr_avl_add(avl, box(691), box(709), nullptr);
+  avl = gpr_avl_add(avl, box(163), box(710), nullptr);
+  avl = gpr_avl_add(avl, box(502), box(711), nullptr);
+  avl = remove_int(avl, 674);
+  avl = gpr_avl_add(avl, box(697), box(713), nullptr);
+  avl = remove_int(avl, 271);
+  avl = gpr_avl_add(avl, box(968), box(715), nullptr);
+  avl = gpr_avl_add(avl, box(48), box(716), nullptr);
+  avl = remove_int(avl, 543);
+  avl = gpr_avl_add(avl, box(35), box(718), nullptr);
+  avl = gpr_avl_add(avl, box(751), box(719), nullptr);
+  avl = gpr_avl_add(avl, box(478), box(720), nullptr);
+  avl = remove_int(avl, 797);
+  avl = remove_int(avl, 309);
+  avl = gpr_avl_add(avl, box(927), box(723), nullptr);
+  avl = remove_int(avl, 504);
+  avl = gpr_avl_add(avl, box(286), box(725), nullptr);
+  avl = gpr_avl_add(avl, box(413), box(726), nullptr);
+  avl = gpr_avl_add(avl, box(599), box(727), nullptr);
+  avl = remove_int(avl, 105);
+  avl = remove_int(avl, 605);
+  avl = gpr_avl_add(avl, box(632), box(730), nullptr);
+  avl = gpr_avl_add(avl, box(133), box(731), nullptr);
+  avl = remove_int(avl, 443);
+  avl = gpr_avl_add(avl, box(958), box(733), nullptr);
+  avl = gpr_avl_add(avl, box(729), box(734), nullptr);
+  avl = remove_int(avl, 158);
+  avl = gpr_avl_add(avl, box(694), box(736), nullptr);
+  avl = gpr_avl_add(avl, box(505), box(737), nullptr);
+  avl = remove_int(avl, 63);
+  avl = remove_int(avl, 714);
+  avl = gpr_avl_add(avl, box(1002), box(740), nullptr);
+  avl = remove_int(avl, 211);
+  avl = gpr_avl_add(avl, box(765), box(742), nullptr);
+  avl = gpr_avl_add(avl, box(455), box(743), nullptr);
+  avl = remove_int(avl, 59);
+  avl = remove_int(avl, 224);
+  avl = gpr_avl_add(avl, box(586), box(746), nullptr);
+  avl = gpr_avl_add(avl, box(348), box(747), nullptr);
+  avl = remove_int(avl, 10);
+  avl = remove_int(avl, 484);
+  avl = gpr_avl_add(avl, box(968), box(750), nullptr);
+  avl = gpr_avl_add(avl, box(923), box(751), nullptr);
+  avl = remove_int(avl, 573);
+  avl = remove_int(avl, 617);
+  avl = gpr_avl_add(avl, box(812), box(754), nullptr);
+  avl = gpr_avl_add(avl, box(179), box(755), nullptr);
+  avl = remove_int(avl, 284);
+  avl = remove_int(avl, 157);
+  avl = remove_int(avl, 177);
+  avl = remove_int(avl, 896);
+  avl = gpr_avl_add(avl, box(649), box(760), nullptr);
+  avl = gpr_avl_add(avl, box(927), box(761), nullptr);
+  avl = gpr_avl_add(avl, box(454), box(762), nullptr);
+  avl = gpr_avl_add(avl, box(217), box(763), nullptr);
+  avl = remove_int(avl, 534);
+  avl = gpr_avl_add(avl, box(180), box(765), nullptr);
+  avl = gpr_avl_add(avl, box(319), box(766), nullptr);
+  avl = remove_int(avl, 92);
+  avl = gpr_avl_add(avl, box(483), box(768), nullptr);
+  avl = remove_int(avl, 504);
+  avl = remove_int(avl, 1017);
+  avl = remove_int(avl, 37);
+  avl = remove_int(avl, 50);
+  avl = gpr_avl_add(avl, box(302), box(773), nullptr);
+  avl = remove_int(avl, 807);
+  avl = gpr_avl_add(avl, box(463), box(775), nullptr);
+  avl = gpr_avl_add(avl, box(271), box(776), nullptr);
+  avl = gpr_avl_add(avl, box(644), box(777), nullptr);
+  avl = remove_int(avl, 618);
+  avl = gpr_avl_add(avl, box(166), box(779), nullptr);
+  avl = gpr_avl_add(avl, box(538), box(780), nullptr);
+  avl = remove_int(avl, 606);
+  avl = gpr_avl_add(avl, box(425), box(782), nullptr);
+  avl = remove_int(avl, 725);
+  avl = remove_int(avl, 383);
+  avl = gpr_avl_add(avl, box(155), box(785), nullptr);
+  avl = remove_int(avl, 889);
+  avl = gpr_avl_add(avl, box(653), box(787), nullptr);
+  avl = remove_int(avl, 386);
+  avl = gpr_avl_add(avl, box(142), box(789), nullptr);
+  avl = remove_int(avl, 107);
+  avl = remove_int(avl, 603);
+  avl = remove_int(avl, 971);
+  avl = gpr_avl_add(avl, box(80), box(793), nullptr);
+  avl = gpr_avl_add(avl, box(61), box(794), nullptr);
+  avl = gpr_avl_add(avl, box(693), box(795), nullptr);
+  avl = gpr_avl_add(avl, box(592), box(796), nullptr);
+  avl = gpr_avl_add(avl, box(433), box(797), nullptr);
+  avl = gpr_avl_add(avl, box(973), box(798), nullptr);
+  avl = remove_int(avl, 901);
+  avl = remove_int(avl, 340);
+  avl = remove_int(avl, 709);
+  avl = gpr_avl_add(avl, box(224), box(802), nullptr);
+  avl = remove_int(avl, 120);
+  avl = remove_int(avl, 271);
+  avl = gpr_avl_add(avl, box(780), box(805), nullptr);
+  avl = gpr_avl_add(avl, box(867), box(806), nullptr);
+  avl = gpr_avl_add(avl, box(756), box(807), nullptr);
+  avl = gpr_avl_add(avl, box(583), box(808), nullptr);
+  avl = gpr_avl_add(avl, box(356), box(809), nullptr);
+  avl = gpr_avl_add(avl, box(58), box(810), nullptr);
+  avl = remove_int(avl, 219);
+  avl = gpr_avl_add(avl, box(301), box(812), nullptr);
+  avl = remove_int(avl, 643);
+  avl = remove_int(avl, 787);
+  avl = remove_int(avl, 583);
+  avl = remove_int(avl, 552);
+  avl = remove_int(avl, 308);
+  avl = remove_int(avl, 608);
+  avl = remove_int(avl, 363);
+  avl = remove_int(avl, 690);
+  avl = gpr_avl_add(avl, box(233), box(821), nullptr);
+  avl = gpr_avl_add(avl, box(479), box(822), nullptr);
+  avl = gpr_avl_add(avl, box(323), box(823), nullptr);
+  avl = gpr_avl_add(avl, box(802), box(824), nullptr);
+  avl = remove_int(avl, 682);
+  avl = remove_int(avl, 705);
+  avl = remove_int(avl, 487);
+  avl = gpr_avl_add(avl, box(530), box(828), nullptr);
+  avl = gpr_avl_add(avl, box(232), box(829), nullptr);
+  avl = remove_int(avl, 627);
+  avl = gpr_avl_add(avl, box(396), box(831), nullptr);
+  avl = gpr_avl_add(avl, box(61), box(832), nullptr);
+  avl = gpr_avl_add(avl, box(932), box(833), nullptr);
+  avl = gpr_avl_add(avl, box(108), box(834), nullptr);
+  avl = gpr_avl_add(avl, box(524), box(835), nullptr);
+  avl = remove_int(avl, 390);
+  avl = remove_int(avl, 307);
+  avl = gpr_avl_add(avl, box(722), box(838), nullptr);
+  avl = gpr_avl_add(avl, box(907), box(839), nullptr);
+  avl = remove_int(avl, 286);
+  avl = remove_int(avl, 337);
+  avl = remove_int(avl, 443);
+  avl = gpr_avl_add(avl, box(973), box(843), nullptr);
+  avl = remove_int(avl, 930);
+  avl = remove_int(avl, 242);
+  avl = gpr_avl_add(avl, box(997), box(846), nullptr);
+  avl = gpr_avl_add(avl, box(689), box(847), nullptr);
+  avl = remove_int(avl, 318);
+  avl = gpr_avl_add(avl, box(703), box(849), nullptr);
+  avl = gpr_avl_add(avl, box(868), box(850), nullptr);
+  avl = gpr_avl_add(avl, box(200), box(851), nullptr);
+  avl = gpr_avl_add(avl, box(960), box(852), nullptr);
+  avl = gpr_avl_add(avl, box(80), box(853), nullptr);
+  avl = remove_int(avl, 113);
+  avl = gpr_avl_add(avl, box(135), box(855), nullptr);
+  avl = remove_int(avl, 529);
+  avl = gpr_avl_add(avl, box(366), box(857), nullptr);
+  avl = remove_int(avl, 272);
+  avl = gpr_avl_add(avl, box(921), box(859), nullptr);
+  avl = remove_int(avl, 497);
+  avl = gpr_avl_add(avl, box(712), box(861), nullptr);
+  avl = remove_int(avl, 777);
+  avl = remove_int(avl, 505);
+  avl = remove_int(avl, 974);
+  avl = remove_int(avl, 497);
+  avl = gpr_avl_add(avl, box(388), box(866), nullptr);
+  avl = gpr_avl_add(avl, box(29), box(867), nullptr);
+  avl = gpr_avl_add(avl, box(180), box(868), nullptr);
+  avl = gpr_avl_add(avl, box(983), box(869), nullptr);
+  avl = gpr_avl_add(avl, box(72), box(870), nullptr);
+  avl = gpr_avl_add(avl, box(693), box(871), nullptr);
+  avl = gpr_avl_add(avl, box(567), box(872), nullptr);
+  avl = remove_int(avl, 549);
+  avl = remove_int(avl, 351);
+  avl = gpr_avl_add(avl, box(1019), box(875), nullptr);
+  avl = remove_int(avl, 585);
+  avl = remove_int(avl, 294);
+  avl = remove_int(avl, 61);
+  avl = gpr_avl_add(avl, box(409), box(879), nullptr);
+  avl = gpr_avl_add(avl, box(984), box(880), nullptr);
+  avl = gpr_avl_add(avl, box(830), box(881), nullptr);
+  avl = remove_int(avl, 579);
+  avl = gpr_avl_add(avl, box(672), box(883), nullptr);
+  avl = remove_int(avl, 968);
+
+  gpr_avl_unref(avl, nullptr);
+}
+
+static void test_badcase3(void) {
+  gpr_avl avl;
+
+  gpr_log(GPR_DEBUG, "test_badcase3");
+
+  avl = gpr_avl_create(&int_int_vtable);
+  avl = remove_int(avl, 624);
+  avl = gpr_avl_add(avl, box(59), box(2), nullptr);
+  avl = gpr_avl_add(avl, box(494), box(3), nullptr);
+  avl = gpr_avl_add(avl, box(226), box(4), nullptr);
+  avl = remove_int(avl, 524);
+  avl = gpr_avl_add(avl, box(540), box(6), nullptr);
+  avl = remove_int(avl, 1008);
+  avl = gpr_avl_add(avl, box(502), box(8), nullptr);
+  avl = remove_int(avl, 267);
+  avl = remove_int(avl, 764);
+  avl = remove_int(avl, 443);
+  avl = gpr_avl_add(avl, box(8), box(12), nullptr);
+  avl = remove_int(avl, 291);
+  avl = remove_int(avl, 796);
+  avl = remove_int(avl, 1002);
+  avl = gpr_avl_add(avl, box(778), box(16), nullptr);
+  avl = remove_int(avl, 621);
+  avl = remove_int(avl, 891);
+  avl = remove_int(avl, 880);
+  avl = gpr_avl_add(avl, box(197), box(20), nullptr);
+  avl = gpr_avl_add(avl, box(441), box(21), nullptr);
+  avl = gpr_avl_add(avl, box(719), box(22), nullptr);
+  avl = remove_int(avl, 109);
+  avl = gpr_avl_add(avl, box(458), box(24), nullptr);
+  avl = remove_int(avl, 86);
+  avl = gpr_avl_add(avl, box(897), box(26), nullptr);
+  avl = gpr_avl_add(avl, box(997), box(27), nullptr);
+  avl = remove_int(avl, 235);
+  avl = remove_int(avl, 425);
+  avl = remove_int(avl, 186);
+  avl = gpr_avl_add(avl, box(887), box(31), nullptr);
+  avl = gpr_avl_add(avl, box(1005), box(32), nullptr);
+  avl = gpr_avl_add(avl, box(778), box(33), nullptr);
+  avl = gpr_avl_add(avl, box(575), box(34), nullptr);
+  avl = remove_int(avl, 966);
+  avl = remove_int(avl, 1015);
+  avl = gpr_avl_add(avl, box(486), box(37), nullptr);
+  avl = gpr_avl_add(avl, box(809), box(38), nullptr);
+  avl = gpr_avl_add(avl, box(907), box(39), nullptr);
+  avl = gpr_avl_add(avl, box(971), box(40), nullptr);
+  avl = remove_int(avl, 441);
+  avl = remove_int(avl, 498);
+  avl = gpr_avl_add(avl, box(727), box(43), nullptr);
+  avl = remove_int(avl, 679);
+  avl = remove_int(avl, 740);
+  avl = remove_int(avl, 532);
+  avl = gpr_avl_add(avl, box(805), box(47), nullptr);
+  avl = remove_int(avl, 64);
+  avl = gpr_avl_add(avl, box(362), box(49), nullptr);
+  avl = gpr_avl_add(avl, box(170), box(50), nullptr);
+  avl = gpr_avl_add(avl, box(389), box(51), nullptr);
+  avl = gpr_avl_add(avl, box(689), box(52), nullptr);
+  avl = remove_int(avl, 871);
+  avl = gpr_avl_add(avl, box(447), box(54), nullptr);
+  avl = remove_int(avl, 718);
+  avl = gpr_avl_add(avl, box(724), box(56), nullptr);
+  avl = remove_int(avl, 215);
+  avl = gpr_avl_add(avl, box(550), box(58), nullptr);
+  avl = remove_int(avl, 932);
+  avl = gpr_avl_add(avl, box(47), box(60), nullptr);
+  avl = remove_int(avl, 46);
+  avl = remove_int(avl, 229);
+  avl = gpr_avl_add(avl, box(68), box(63), nullptr);
+  avl = gpr_avl_add(avl, box(387), box(64), nullptr);
+  avl = remove_int(avl, 933);
+  avl = remove_int(avl, 736);
+  avl = remove_int(avl, 719);
+  avl = gpr_avl_add(avl, box(150), box(68), nullptr);
+  avl = remove_int(avl, 875);
+  avl = remove_int(avl, 298);
+  avl = gpr_avl_add(avl, box(991), box(71), nullptr);
+  avl = remove_int(avl, 705);
+  avl = gpr_avl_add(avl, box(197), box(73), nullptr);
+  avl = gpr_avl_add(avl, box(101), box(74), nullptr);
+  avl = remove_int(avl, 436);
+  avl = gpr_avl_add(avl, box(755), box(76), nullptr);
+  avl = gpr_avl_add(avl, box(727), box(77), nullptr);
+  avl = remove_int(avl, 309);
+  avl = remove_int(avl, 253);
+  avl = gpr_avl_add(avl, box(203), box(80), nullptr);
+  avl = remove_int(avl, 231);
+  avl = gpr_avl_add(avl, box(461), box(82), nullptr);
+  avl = remove_int(avl, 316);
+  avl = remove_int(avl, 493);
+  avl = gpr_avl_add(avl, box(184), box(85), nullptr);
+  avl = remove_int(avl, 737);
+  avl = gpr_avl_add(avl, box(790), box(87), nullptr);
+  avl = gpr_avl_add(avl, box(335), box(88), nullptr);
+  avl = remove_int(avl, 649);
+  avl = gpr_avl_add(avl, box(69), box(90), nullptr);
+  avl = remove_int(avl, 585);
+  avl = remove_int(avl, 543);
+  avl = gpr_avl_add(avl, box(784), box(93), nullptr);
+  avl = gpr_avl_add(avl, box(60), box(94), nullptr);
+  avl = gpr_avl_add(avl, box(525), box(95), nullptr);
+  avl = gpr_avl_add(avl, box(177), box(96), nullptr);
+  avl = gpr_avl_add(avl, box(178), box(97), nullptr);
+  avl = gpr_avl_add(avl, box(683), box(98), nullptr);
+  avl = gpr_avl_add(avl, box(226), box(99), nullptr);
+  avl = gpr_avl_add(avl, box(662), box(100), nullptr);
+  avl = remove_int(avl, 944);
+  avl = gpr_avl_add(avl, box(562), box(102), nullptr);
+  avl = gpr_avl_add(avl, box(793), box(103), nullptr);
+  avl = remove_int(avl, 673);
+  avl = gpr_avl_add(avl, box(310), box(105), nullptr);
+  avl = remove_int(avl, 479);
+  avl = remove_int(avl, 543);
+  avl = remove_int(avl, 159);
+  avl = remove_int(avl, 850);
+  avl = gpr_avl_add(avl, box(318), box(110), nullptr);
+  avl = gpr_avl_add(avl, box(483), box(111), nullptr);
+  avl = gpr_avl_add(avl, box(84), box(112), nullptr);
+  avl = remove_int(avl, 109);
+  avl = gpr_avl_add(avl, box(132), box(114), nullptr);
+  avl = gpr_avl_add(avl, box(920), box(115), nullptr);
+  avl = remove_int(avl, 746);
+  avl = gpr_avl_add(avl, box(145), box(117), nullptr);
+  avl = gpr_avl_add(avl, box(526), box(118), nullptr);
+  avl = remove_int(avl, 158);
+  avl = gpr_avl_add(avl, box(332), box(120), nullptr);
+  avl = gpr_avl_add(avl, box(918), box(121), nullptr);
+  avl = remove_int(avl, 339);
+  avl = gpr_avl_add(avl, box(809), box(123), nullptr);
+  avl = gpr_avl_add(avl, box(742), box(124), nullptr);
+  avl = gpr_avl_add(avl, box(718), box(125), nullptr);
+  avl = remove_int(avl, 988);
+  avl = remove_int(avl, 531);
+  avl = remove_int(avl, 840);
+  avl = gpr_avl_add(avl, box(816), box(129), nullptr);
+  avl = gpr_avl_add(avl, box(976), box(130), nullptr);
+  avl = remove_int(avl, 743);
+  avl = remove_int(avl, 528);
+  avl = remove_int(avl, 982);
+  avl = gpr_avl_add(avl, box(803), box(134), nullptr);
+  avl = gpr_avl_add(avl, box(205), box(135), nullptr);
+  avl = gpr_avl_add(avl, box(584), box(136), nullptr);
+  avl = remove_int(avl, 923);
+  avl = remove_int(avl, 538);
+  avl = remove_int(avl, 398);
+  avl = remove_int(avl, 320);
+  avl = remove_int(avl, 292);
+  avl = gpr_avl_add(avl, box(270), box(142), nullptr);
+  avl = gpr_avl_add(avl, box(333), box(143), nullptr);
+  avl = remove_int(avl, 439);
+  avl = gpr_avl_add(avl, box(35), box(145), nullptr);
+  avl = gpr_avl_add(avl, box(837), box(146), nullptr);
+  avl = remove_int(avl, 65);
+  avl = remove_int(avl, 642);
+  avl = remove_int(avl, 371);
+  avl = remove_int(avl, 140);
+  avl = remove_int(avl, 533);
+  avl = remove_int(avl, 676);
+  avl = gpr_avl_add(avl, box(624), box(153), nullptr);
+  avl = gpr_avl_add(avl, box(116), box(154), nullptr);
+  avl = gpr_avl_add(avl, box(446), box(155), nullptr);
+  avl = remove_int(avl, 91);
+  avl = remove_int(avl, 721);
+  avl = remove_int(avl, 537);
+  avl = gpr_avl_add(avl, box(448), box(159), nullptr);
+  avl = remove_int(avl, 155);
+  avl = remove_int(avl, 344);
+  avl = remove_int(avl, 237);
+  avl = gpr_avl_add(avl, box(309), box(163), nullptr);
+  avl = gpr_avl_add(avl, box(434), box(164), nullptr);
+  avl = gpr_avl_add(avl, box(277), box(165), nullptr);
+  avl = remove_int(avl, 233);
+  avl = gpr_avl_add(avl, box(275), box(167), nullptr);
+  avl = gpr_avl_add(avl, box(218), box(168), nullptr);
+  avl = gpr_avl_add(avl, box(76), box(169), nullptr);
+  avl = gpr_avl_add(avl, box(898), box(170), nullptr);
+  avl = remove_int(avl, 771);
+  avl = gpr_avl_add(avl, box(237), box(172), nullptr);
+  avl = remove_int(avl, 327);
+  avl = gpr_avl_add(avl, box(499), box(174), nullptr);
+  avl = remove_int(avl, 727);
+  avl = remove_int(avl, 234);
+  avl = remove_int(avl, 623);
+  avl = remove_int(avl, 458);
+  avl = remove_int(avl, 326);
+  avl = remove_int(avl, 589);
+  avl = gpr_avl_add(avl, box(442), box(181), nullptr);
+  avl = remove_int(avl, 389);
+  avl = gpr_avl_add(avl, box(708), box(183), nullptr);
+  avl = gpr_avl_add(avl, box(594), box(184), nullptr);
+  avl = gpr_avl_add(avl, box(942), box(185), nullptr);
+  avl = gpr_avl_add(avl, box(282), box(186), nullptr);
+  avl = remove_int(avl, 434);
+  avl = remove_int(avl, 134);
+  avl = remove_int(avl, 270);
+  avl = remove_int(avl, 512);
+  avl = remove_int(avl, 265);
+  avl = remove_int(avl, 21);
+  avl = remove_int(avl, 193);
+  avl = remove_int(avl, 797);
+  avl = remove_int(avl, 347);
+  avl = gpr_avl_add(avl, box(99), box(196), nullptr);
+  avl = gpr_avl_add(avl, box(161), box(197), nullptr);
+  avl = remove_int(avl, 484);
+  avl = gpr_avl_add(avl, box(72), box(199), nullptr);
+  avl = remove_int(avl, 629);
+  avl = gpr_avl_add(avl, box(522), box(201), nullptr);
+  avl = remove_int(avl, 679);
+  avl = gpr_avl_add(avl, box(407), box(203), nullptr);
+  avl = remove_int(avl, 693);
+  avl = gpr_avl_add(avl, box(424), box(205), nullptr);
+  avl = gpr_avl_add(avl, box(651), box(206), nullptr);
+  avl = gpr_avl_add(avl, box(927), box(207), nullptr);
+  avl = remove_int(avl, 553);
+  avl = gpr_avl_add(avl, box(128), box(209), nullptr);
+  avl = gpr_avl_add(avl, box(616), box(210), nullptr);
+  avl = gpr_avl_add(avl, box(690), box(211), nullptr);
+  avl = remove_int(avl, 241);
+  avl = remove_int(avl, 179);
+  avl = gpr_avl_add(avl, box(697), box(214), nullptr);
+  avl = remove_int(avl, 779);
+  avl = gpr_avl_add(avl, box(241), box(216), nullptr);
+  avl = remove_int(avl, 190);
+  avl = remove_int(avl, 210);
+  avl = gpr_avl_add(avl, box(711), box(219), nullptr);
+  avl = remove_int(avl, 251);
+  avl = remove_int(avl, 61);
+  avl = gpr_avl_add(avl, box(800), box(222), nullptr);
+  avl = remove_int(avl, 551);
+  avl = gpr_avl_add(avl, box(61), box(224), nullptr);
+  avl = gpr_avl_add(avl, box(656), box(225), nullptr);
+  avl = remove_int(avl, 130);
+  avl = remove_int(avl, 368);
+  avl = remove_int(avl, 150);
+  avl = remove_int(avl, 73);
+  avl = gpr_avl_add(avl, box(799), box(230), nullptr);
+  avl = gpr_avl_add(avl, box(125), box(231), nullptr);
+  avl = remove_int(avl, 107);
+  avl = gpr_avl_add(avl, box(938), box(233), nullptr);
+  avl = gpr_avl_add(avl, box(914), box(234), nullptr);
+  avl = gpr_avl_add(avl, box(197), box(235), nullptr);
+  avl = remove_int(avl, 736);
+  avl = gpr_avl_add(avl, box(20), box(237), nullptr);
+  avl = remove_int(avl, 224);
+  avl = remove_int(avl, 841);
+  avl = gpr_avl_add(avl, box(226), box(240), nullptr);
+  avl = remove_int(avl, 963);
+  avl = remove_int(avl, 796);
+  avl = remove_int(avl, 728);
+  avl = gpr_avl_add(avl, box(855), box(244), nullptr);
+  avl = gpr_avl_add(avl, box(769), box(245), nullptr);
+  avl = gpr_avl_add(avl, box(631), box(246), nullptr);
+  avl = remove_int(avl, 648);
+  avl = gpr_avl_add(avl, box(187), box(248), nullptr);
+  avl = gpr_avl_add(avl, box(31), box(249), nullptr);
+  avl = remove_int(avl, 163);
+  avl = gpr_avl_add(avl, box(218), box(251), nullptr);
+  avl = gpr_avl_add(avl, box(488), box(252), nullptr);
+  avl = gpr_avl_add(avl, box(387), box(253), nullptr);
+  avl = gpr_avl_add(avl, box(809), box(254), nullptr);
+  avl = gpr_avl_add(avl, box(997), box(255), nullptr);
+  avl = remove_int(avl, 678);
+  avl = gpr_avl_add(avl, box(368), box(257), nullptr);
+  avl = gpr_avl_add(avl, box(220), box(258), nullptr);
+  avl = gpr_avl_add(avl, box(373), box(259), nullptr);
+  avl = remove_int(avl, 874);
+  avl = remove_int(avl, 682);
+  avl = remove_int(avl, 1014);
+  avl = remove_int(avl, 195);
+  avl = gpr_avl_add(avl, box(868), box(264), nullptr);
+  avl = remove_int(avl, 254);
+  avl = remove_int(avl, 456);
+  avl = gpr_avl_add(avl, box(906), box(267), nullptr);
+  avl = remove_int(avl, 711);
+  avl = gpr_avl_add(avl, box(632), box(269), nullptr);
+  avl = remove_int(avl, 474);
+  avl = gpr_avl_add(avl, box(508), box(271), nullptr);
+  avl = gpr_avl_add(avl, box(518), box(272), nullptr);
+  avl = remove_int(avl, 579);
+  avl = remove_int(avl, 948);
+  avl = gpr_avl_add(avl, box(789), box(275), nullptr);
+  avl = gpr_avl_add(avl, box(48), box(276), nullptr);
+  avl = gpr_avl_add(avl, box(256), box(277), nullptr);
+  avl = gpr_avl_add(avl, box(754), box(278), nullptr);
+  avl = remove_int(avl, 215);
+  avl = gpr_avl_add(avl, box(679), box(280), nullptr);
+  avl = gpr_avl_add(avl, box(606), box(281), nullptr);
+  avl = remove_int(avl, 941);
+  avl = remove_int(avl, 31);
+  avl = gpr_avl_add(avl, box(758), box(284), nullptr);
+  avl = remove_int(avl, 101);
+  avl = gpr_avl_add(avl, box(244), box(286), nullptr);
+  avl = gpr_avl_add(avl, box(337), box(287), nullptr);
+  avl = gpr_avl_add(avl, box(461), box(288), nullptr);
+  avl = remove_int(avl, 476);
+  avl = gpr_avl_add(avl, box(845), box(290), nullptr);
+  avl = remove_int(avl, 160);
+  avl = gpr_avl_add(avl, box(690), box(292), nullptr);
+  avl = remove_int(avl, 931);
+  avl = gpr_avl_add(avl, box(869), box(294), nullptr);
+  avl = gpr_avl_add(avl, box(1019), box(295), nullptr);
+  avl = remove_int(avl, 591);
+  avl = remove_int(avl, 635);
+  avl = remove_int(avl, 67);
+  avl = gpr_avl_add(avl, box(113), box(299), nullptr);
+  avl = remove_int(avl, 305);
+  avl = gpr_avl_add(avl, box(10), box(301), nullptr);
+  avl = remove_int(avl, 823);
+  avl = remove_int(avl, 288);
+  avl = remove_int(avl, 239);
+  avl = gpr_avl_add(avl, box(646), box(305), nullptr);
+  avl = gpr_avl_add(avl, box(1006), box(306), nullptr);
+  avl = gpr_avl_add(avl, box(954), box(307), nullptr);
+  avl = gpr_avl_add(avl, box(199), box(308), nullptr);
+  avl = gpr_avl_add(avl, box(69), box(309), nullptr);
+  avl = gpr_avl_add(avl, box(984), box(310), nullptr);
+  avl = remove_int(avl, 568);
+  avl = remove_int(avl, 666);
+  avl = remove_int(avl, 37);
+  avl = gpr_avl_add(avl, box(845), box(314), nullptr);
+  avl = remove_int(avl, 535);
+  avl = remove_int(avl, 365);
+  avl = remove_int(avl, 676);
+  avl = remove_int(avl, 892);
+  avl = remove_int(avl, 425);
+  avl = remove_int(avl, 704);
+  avl = remove_int(avl, 168);
+  avl = gpr_avl_add(avl, box(853), box(322), nullptr);
+  avl = gpr_avl_add(avl, box(335), box(323), nullptr);
+  avl = gpr_avl_add(avl, box(961), box(324), nullptr);
+  avl = gpr_avl_add(avl, box(73), box(325), nullptr);
+  avl = remove_int(avl, 469);
+  avl = gpr_avl_add(avl, box(449), box(327), nullptr);
+  avl = remove_int(avl, 821);
+  avl = gpr_avl_add(avl, box(845), box(329), nullptr);
+  avl = remove_int(avl, 637);
+  avl = gpr_avl_add(avl, box(769), box(331), nullptr);
+  avl = gpr_avl_add(avl, box(901), box(332), nullptr);
+  avl = remove_int(avl, 142);
+  avl = remove_int(avl, 361);
+  avl = remove_int(avl, 876);
+  avl = gpr_avl_add(avl, box(614), box(336), nullptr);
+  avl = gpr_avl_add(avl, box(729), box(337), nullptr);
+  avl = remove_int(avl, 120);
+  avl = remove_int(avl, 473);
+  avl = remove_int(avl, 445);
+  avl = gpr_avl_add(avl, box(978), box(341), nullptr);
+  avl = gpr_avl_add(avl, box(164), box(342), nullptr);
+  avl = gpr_avl_add(avl, box(1), box(343), nullptr);
+  avl = remove_int(avl, 890);
+  avl = gpr_avl_add(avl, box(605), box(345), nullptr);
+  avl = gpr_avl_add(avl, box(178), box(346), nullptr);
+  avl = gpr_avl_add(avl, box(481), box(347), nullptr);
+  avl = gpr_avl_add(avl, box(772), box(348), nullptr);
+  avl = remove_int(avl, 824);
+  avl = remove_int(avl, 167);
+  avl = remove_int(avl, 151);
+  avl = gpr_avl_add(avl, box(698), box(352), nullptr);
+  avl = gpr_avl_add(avl, box(202), box(353), nullptr);
+  avl = gpr_avl_add(avl, box(921), box(354), nullptr);
+  avl = gpr_avl_add(avl, box(875), box(355), nullptr);
+  avl = remove_int(avl, 197);
+  avl = remove_int(avl, 232);
+  avl = gpr_avl_add(avl, box(209), box(358), nullptr);
+  avl = remove_int(avl, 324);
+  avl = remove_int(avl, 56);
+  avl = remove_int(avl, 579);
+  avl = remove_int(avl, 255);
+  avl = remove_int(avl, 290);
+  avl = gpr_avl_add(avl, box(661), box(364), nullptr);
+  avl = gpr_avl_add(avl, box(113), box(365), nullptr);
+  avl = remove_int(avl, 767);
+  avl = gpr_avl_add(avl, box(586), box(367), nullptr);
+  avl = gpr_avl_add(avl, box(121), box(368), nullptr);
+  avl = remove_int(avl, 235);
+  avl = remove_int(avl, 439);
+  avl = remove_int(avl, 360);
+  avl = gpr_avl_add(avl, box(916), box(372), nullptr);
+  avl = remove_int(avl, 999);
+  avl = gpr_avl_add(avl, box(825), box(374), nullptr);
+  avl = gpr_avl_add(avl, box(177), box(375), nullptr);
+  avl = remove_int(avl, 204);
+  avl = remove_int(avl, 92);
+  avl = gpr_avl_add(avl, box(794), box(378), nullptr);
+  avl = gpr_avl_add(avl, box(463), box(379), nullptr);
+  avl = gpr_avl_add(avl, box(472), box(380), nullptr);
+  avl = remove_int(avl, 235);
+  avl = gpr_avl_add(avl, box(840), box(382), nullptr);
+  avl = remove_int(avl, 657);
+  avl = gpr_avl_add(avl, box(586), box(384), nullptr);
+  avl = gpr_avl_add(avl, box(979), box(385), nullptr);
+  avl = remove_int(avl, 979);
+  avl = gpr_avl_add(avl, box(639), box(387), nullptr);
+  avl = remove_int(avl, 907);
+  avl = remove_int(avl, 973);
+  avl = gpr_avl_add(avl, box(913), box(390), nullptr);
+  avl = gpr_avl_add(avl, box(566), box(391), nullptr);
+  avl = gpr_avl_add(avl, box(883), box(392), nullptr);
+  avl = gpr_avl_add(avl, box(552), box(393), nullptr);
+  avl = gpr_avl_add(avl, box(16), box(394), nullptr);
+  avl = remove_int(avl, 60);
+  avl = gpr_avl_add(avl, box(567), box(396), nullptr);
+  avl = gpr_avl_add(avl, box(705), box(397), nullptr);
+  avl = gpr_avl_add(avl, box(94), box(398), nullptr);
+  avl = remove_int(avl, 321);
+  avl = gpr_avl_add(avl, box(207), box(400), nullptr);
+  avl = gpr_avl_add(avl, box(682), box(401), nullptr);
+  avl = gpr_avl_add(avl, box(592), box(402), nullptr);
+  avl = gpr_avl_add(avl, box(10), box(403), nullptr);
+  avl = remove_int(avl, 911);
+  avl = remove_int(avl, 161);
+  avl = gpr_avl_add(avl, box(86), box(406), nullptr);
+  avl = remove_int(avl, 893);
+  avl = remove_int(avl, 362);
+  avl = gpr_avl_add(avl, box(599), box(409), nullptr);
+  avl = remove_int(avl, 413);
+  avl = gpr_avl_add(avl, box(867), box(411), nullptr);
+  avl = remove_int(avl, 955);
+  avl = gpr_avl_add(avl, box(341), box(413), nullptr);
+  avl = gpr_avl_add(avl, box(887), box(414), nullptr);
+  avl = remove_int(avl, 706);
+  avl = gpr_avl_add(avl, box(939), box(416), nullptr);
+  avl = remove_int(avl, 233);
+  avl = remove_int(avl, 662);
+  avl = remove_int(avl, 984);
+  avl = remove_int(avl, 203);
+  avl = gpr_avl_add(avl, box(326), box(421), nullptr);
+  avl = remove_int(avl, 848);
+  avl = gpr_avl_add(avl, box(235), box(423), nullptr);
+  avl = remove_int(avl, 617);
+  avl = gpr_avl_add(avl, box(565), box(425), nullptr);
+  avl = remove_int(avl, 469);
+  avl = gpr_avl_add(avl, box(988), box(427), nullptr);
+  avl = remove_int(avl, 957);
+  avl = gpr_avl_add(avl, box(426), box(429), nullptr);
+  avl = remove_int(avl, 967);
+  avl = gpr_avl_add(avl, box(890), box(431), nullptr);
+  avl = gpr_avl_add(avl, box(473), box(432), nullptr);
+  avl = remove_int(avl, 367);
+  avl = remove_int(avl, 344);
+  avl = remove_int(avl, 660);
+  avl = remove_int(avl, 448);
+  avl = remove_int(avl, 837);
+  avl = remove_int(avl, 158);
+  avl = gpr_avl_add(avl, box(459), box(439), nullptr);
+  avl = remove_int(avl, 882);
+  avl = remove_int(avl, 782);
+  avl = gpr_avl_add(avl, box(408), box(442), nullptr);
+  avl = gpr_avl_add(avl, box(728), box(443), nullptr);
+  avl = remove_int(avl, 27);
+  avl = gpr_avl_add(avl, box(137), box(445), nullptr);
+  avl = gpr_avl_add(avl, box(239), box(446), nullptr);
+  avl = remove_int(avl, 854);
+  avl = gpr_avl_add(avl, box(104), box(448), nullptr);
+  avl = gpr_avl_add(avl, box(823), box(449), nullptr);
+  avl = gpr_avl_add(avl, box(524), box(450), nullptr);
+  avl = gpr_avl_add(avl, box(995), box(451), nullptr);
+  avl = remove_int(avl, 422);
+  avl = remove_int(avl, 220);
+  avl = gpr_avl_add(avl, box(856), box(454), nullptr);
+  avl = remove_int(avl, 332);
+  avl = gpr_avl_add(avl, box(679), box(456), nullptr);
+  avl = remove_int(avl, 18);
+  avl = gpr_avl_add(avl, box(837), box(458), nullptr);
+  avl = remove_int(avl, 405);
+  avl = remove_int(avl, 877);
+  avl = remove_int(avl, 835);
+  avl = gpr_avl_add(avl, box(547), box(462), nullptr);
+  avl = remove_int(avl, 805);
+  avl = remove_int(avl, 862);
+  avl = gpr_avl_add(avl, box(75), box(465), nullptr);
+  avl = remove_int(avl, 41);
+  avl = gpr_avl_add(avl, box(310), box(467), nullptr);
+  avl = remove_int(avl, 855);
+  avl = gpr_avl_add(avl, box(20), box(469), nullptr);
+  avl = remove_int(avl, 186);
+  avl = remove_int(avl, 378);
+  avl = remove_int(avl, 442);
+  avl = remove_int(avl, 930);
+  avl = gpr_avl_add(avl, box(118), box(474), nullptr);
+  avl = gpr_avl_add(avl, box(96), box(475), nullptr);
+  avl = remove_int(avl, 854);
+  avl = gpr_avl_add(avl, box(65), box(477), nullptr);
+  avl = gpr_avl_add(avl, box(573), box(478), nullptr);
+  avl = gpr_avl_add(avl, box(4), box(479), nullptr);
+  avl = gpr_avl_add(avl, box(451), box(480), nullptr);
+  avl = gpr_avl_add(avl, box(774), box(481), nullptr);
+  avl = gpr_avl_add(avl, box(126), box(482), nullptr);
+  avl = remove_int(avl, 956);
+  avl = remove_int(avl, 591);
+  avl = remove_int(avl, 644);
+  avl = gpr_avl_add(avl, box(304), box(486), nullptr);
+  avl = remove_int(avl, 620);
+  avl = remove_int(avl, 394);
+  avl = gpr_avl_add(avl, box(1002), box(489), nullptr);
+  avl = gpr_avl_add(avl, box(837), box(490), nullptr);
+  avl = remove_int(avl, 485);
+  avl = gpr_avl_add(avl, box(1005), box(492), nullptr);
+  avl = remove_int(avl, 21);
+  avl = gpr_avl_add(avl, box(396), box(494), nullptr);
+  avl = remove_int(avl, 966);
+  avl = gpr_avl_add(avl, box(105), box(496), nullptr);
+  avl = gpr_avl_add(avl, box(316), box(497), nullptr);
+  avl = remove_int(avl, 776);
+  avl = gpr_avl_add(avl, box(188), box(499), nullptr);
+  avl = remove_int(avl, 200);
+  avl = gpr_avl_add(avl, box(98), box(501), nullptr);
+  avl = gpr_avl_add(avl, box(831), box(502), nullptr);
+  avl = gpr_avl_add(avl, box(227), box(503), nullptr);
+  avl = gpr_avl_add(avl, box(220), box(504), nullptr);
+  avl = remove_int(avl, 715);
+  avl = remove_int(avl, 279);
+  avl = gpr_avl_add(avl, box(701), box(507), nullptr);
+  avl = gpr_avl_add(avl, box(726), box(508), nullptr);
+  avl = gpr_avl_add(avl, box(815), box(509), nullptr);
+  avl = gpr_avl_add(avl, box(749), box(510), nullptr);
+  avl = remove_int(avl, 946);
+  avl = remove_int(avl, 449);
+  avl = remove_int(avl, 62);
+  avl = remove_int(avl, 487);
+  avl = gpr_avl_add(avl, box(545), box(515), nullptr);
+  avl = remove_int(avl, 59);
+  avl = gpr_avl_add(avl, box(168), box(517), nullptr);
+  avl = remove_int(avl, 337);
+  avl = gpr_avl_add(avl, box(69), box(519), nullptr);
+  avl = remove_int(avl, 600);
+  avl = gpr_avl_add(avl, box(591), box(521), nullptr);
+  avl = gpr_avl_add(avl, box(960), box(522), nullptr);
+  avl = gpr_avl_add(avl, box(116), box(523), nullptr);
+  avl = remove_int(avl, 991);
+  avl = gpr_avl_add(avl, box(760), box(525), nullptr);
+  avl = gpr_avl_add(avl, box(664), box(526), nullptr);
+  avl = gpr_avl_add(avl, box(547), box(527), nullptr);
+  avl = remove_int(avl, 922);
+  avl = gpr_avl_add(avl, box(290), box(529), nullptr);
+  avl = gpr_avl_add(avl, box(859), box(530), nullptr);
+  avl = gpr_avl_add(avl, box(49), box(531), nullptr);
+  avl = remove_int(avl, 455);
+  avl = remove_int(avl, 786);
+  avl = gpr_avl_add(avl, box(613), box(534), nullptr);
+  avl = gpr_avl_add(avl, box(326), box(535), nullptr);
+  avl = remove_int(avl, 615);
+  avl = gpr_avl_add(avl, box(45), box(537), nullptr);
+  avl = gpr_avl_add(avl, box(162), box(538), nullptr);
+  avl = gpr_avl_add(avl, box(189), box(539), nullptr);
+  avl = remove_int(avl, 68);
+  avl = remove_int(avl, 846);
+  avl = gpr_avl_add(avl, box(608), box(542), nullptr);
+  avl = remove_int(avl, 821);
+  avl = gpr_avl_add(avl, box(978), box(544), nullptr);
+  avl = gpr_avl_add(avl, box(892), box(545), nullptr);
+  avl = remove_int(avl, 924);
+  avl = gpr_avl_add(avl, box(708), box(547), nullptr);
+  avl = remove_int(avl, 135);
+  avl = remove_int(avl, 124);
+  avl = gpr_avl_add(avl, box(301), box(550), nullptr);
+  avl = gpr_avl_add(avl, box(939), box(551), nullptr);
+  avl = gpr_avl_add(avl, box(344), box(552), nullptr);
+  avl = remove_int(avl, 443);
+  avl = remove_int(avl, 122);
+  avl = gpr_avl_add(avl, box(636), box(555), nullptr);
+  avl = remove_int(avl, 558);
+  avl = gpr_avl_add(avl, box(923), box(557), nullptr);
+  avl = remove_int(avl, 827);
+  avl = gpr_avl_add(avl, box(649), box(559), nullptr);
+  avl = gpr_avl_add(avl, box(808), box(560), nullptr);
+  avl = remove_int(avl, 570);
+  avl = remove_int(avl, 434);
+  avl = gpr_avl_add(avl, box(40), box(563), nullptr);
+  avl = gpr_avl_add(avl, box(725), box(564), nullptr);
+  avl = remove_int(avl, 295);
+  avl = remove_int(avl, 615);
+  avl = remove_int(avl, 919);
+  avl = remove_int(avl, 170);
+  avl = remove_int(avl, 442);
+  avl = remove_int(avl, 971);
+  avl = gpr_avl_add(avl, box(483), box(571), nullptr);
+  avl = gpr_avl_add(avl, box(512), box(572), nullptr);
+  avl = remove_int(avl, 648);
+  avl = remove_int(avl, 78);
+  avl = remove_int(avl, 72);
+  avl = remove_int(avl, 790);
+  avl = remove_int(avl, 571);
+  avl = gpr_avl_add(avl, box(898), box(578), nullptr);
+  avl = remove_int(avl, 770);
+  avl = remove_int(avl, 776);
+  avl = gpr_avl_add(avl, box(602), box(581), nullptr);
+  avl = remove_int(avl, 251);
+  avl = gpr_avl_add(avl, box(303), box(583), nullptr);
+  avl = remove_int(avl, 837);
+  avl = gpr_avl_add(avl, box(714), box(585), nullptr);
+  avl = remove_int(avl, 800);
+  avl = gpr_avl_add(avl, box(266), box(587), nullptr);
+  avl = gpr_avl_add(avl, box(555), box(588), nullptr);
+  avl = remove_int(avl, 604);
+  avl = remove_int(avl, 163);
+  avl = remove_int(avl, 497);
+  avl = gpr_avl_add(avl, box(296), box(592), nullptr);
+  avl = remove_int(avl, 129);
+  avl = gpr_avl_add(avl, box(656), box(594), nullptr);
+  avl = remove_int(avl, 769);
+  avl = remove_int(avl, 941);
+  avl = gpr_avl_add(avl, box(775), box(597), nullptr);
+  avl = gpr_avl_add(avl, box(846), box(598), nullptr);
+  avl = remove_int(avl, 591);
+  avl = remove_int(avl, 801);
+  avl = remove_int(avl, 419);
+  avl = remove_int(avl, 455);
+  avl = gpr_avl_add(avl, box(866), box(603), nullptr);
+  avl = gpr_avl_add(avl, box(575), box(604), nullptr);
+  avl = gpr_avl_add(avl, box(620), box(605), nullptr);
+  avl = remove_int(avl, 100);
+  avl = remove_int(avl, 667);
+  avl = gpr_avl_add(avl, box(138), box(608), nullptr);
+  avl = gpr_avl_add(avl, box(566), box(609), nullptr);
+  avl = gpr_avl_add(avl, box(673), box(610), nullptr);
+  avl = gpr_avl_add(avl, box(178), box(611), nullptr);
+  avl = remove_int(avl, 659);
+  avl = gpr_avl_add(avl, box(759), box(613), nullptr);
+  avl = gpr_avl_add(avl, box(1008), box(614), nullptr);
+  avl = remove_int(avl, 116);
+  avl = gpr_avl_add(avl, box(608), box(616), nullptr);
+  avl = gpr_avl_add(avl, box(339), box(617), nullptr);
+  avl = gpr_avl_add(avl, box(197), box(618), nullptr);
+  avl = remove_int(avl, 25);
+  avl = remove_int(avl, 628);
+  avl = gpr_avl_add(avl, box(487), box(621), nullptr);
+  avl = remove_int(avl, 739);
+  avl = remove_int(avl, 100);
+  avl = remove_int(avl, 928);
+  avl = gpr_avl_add(avl, box(647), box(625), nullptr);
+  avl = remove_int(avl, 978);
+  avl = remove_int(avl, 143);
+  avl = remove_int(avl, 755);
+  avl = gpr_avl_add(avl, box(71), box(629), nullptr);
+  avl = remove_int(avl, 205);
+  avl = gpr_avl_add(avl, box(501), box(631), nullptr);
+  avl = remove_int(avl, 723);
+  avl = remove_int(avl, 852);
+  avl = remove_int(avl, 1021);
+  avl = remove_int(avl, 670);
+  avl = remove_int(avl, 500);
+  avl = gpr_avl_add(avl, box(330), box(637), nullptr);
+  avl = remove_int(avl, 264);
+  avl = gpr_avl_add(avl, box(69), box(639), nullptr);
+  avl = remove_int(avl, 73);
+  avl = gpr_avl_add(avl, box(745), box(641), nullptr);
+  avl = remove_int(avl, 518);
+  avl = remove_int(avl, 641);
+  avl = remove_int(avl, 768);
+  avl = gpr_avl_add(avl, box(988), box(645), nullptr);
+  avl = gpr_avl_add(avl, box(899), box(646), nullptr);
+  avl = remove_int(avl, 763);
+  avl = remove_int(avl, 281);
+  avl = remove_int(avl, 496);
+  avl = gpr_avl_add(avl, box(445), box(650), nullptr);
+  avl = remove_int(avl, 905);
+  avl = gpr_avl_add(avl, box(275), box(652), nullptr);
+  avl = gpr_avl_add(avl, box(137), box(653), nullptr);
+  avl = remove_int(avl, 642);
+  avl = gpr_avl_add(avl, box(708), box(655), nullptr);
+  avl = remove_int(avl, 922);
+  avl = gpr_avl_add(avl, box(743), box(657), nullptr);
+  avl = remove_int(avl, 295);
+  avl = remove_int(avl, 665);
+  avl = remove_int(avl, 48);
+  avl = gpr_avl_add(avl, box(1012), box(661), nullptr);
+  avl = remove_int(avl, 71);
+  avl = remove_int(avl, 523);
+  avl = gpr_avl_add(avl, box(319), box(664), nullptr);
+  avl = remove_int(avl, 632);
+  avl = gpr_avl_add(avl, box(137), box(666), nullptr);
+  avl = gpr_avl_add(avl, box(686), box(667), nullptr);
+  avl = gpr_avl_add(avl, box(724), box(668), nullptr);
+  avl = gpr_avl_add(avl, box(952), box(669), nullptr);
+  avl = gpr_avl_add(avl, box(5), box(670), nullptr);
+  avl = remove_int(avl, 35);
+  avl = gpr_avl_add(avl, box(43), box(672), nullptr);
+  avl = gpr_avl_add(avl, box(320), box(673), nullptr);
+  avl = gpr_avl_add(avl, box(115), box(674), nullptr);
+  avl = remove_int(avl, 377);
+  avl = remove_int(avl, 591);
+  avl = remove_int(avl, 87);
+  avl = remove_int(avl, 93);
+  avl = gpr_avl_add(avl, box(1016), box(679), nullptr);
+  avl = gpr_avl_add(avl, box(605), box(680), nullptr);
+  avl = gpr_avl_add(avl, box(152), box(681), nullptr);
+  avl = gpr_avl_add(avl, box(113), box(682), nullptr);
+  avl = remove_int(avl, 131);
+  avl = remove_int(avl, 637);
+  avl = gpr_avl_add(avl, box(156), box(685), nullptr);
+  avl = remove_int(avl, 696);
+  avl = gpr_avl_add(avl, box(546), box(687), nullptr);
+  avl = remove_int(avl, 970);
+  avl = remove_int(avl, 53);
+  avl = remove_int(avl, 827);
+  avl = remove_int(avl, 224);
+  avl = remove_int(avl, 796);
+  avl = remove_int(avl, 34);
+  avl = remove_int(avl, 922);
+  avl = remove_int(avl, 277);
+  avl = remove_int(avl, 650);
+  avl = remove_int(avl, 222);
+  avl = remove_int(avl, 244);
+  avl = remove_int(avl, 576);
+  avl = remove_int(avl, 413);
+  avl = gpr_avl_add(avl, box(500), box(701), nullptr);
+  avl = remove_int(avl, 924);
+  avl = gpr_avl_add(avl, box(825), box(703), nullptr);
+  avl = remove_int(avl, 888);
+  avl = remove_int(avl, 931);
+  avl = gpr_avl_add(avl, box(285), box(706), nullptr);
+  avl = remove_int(avl, 62);
+  avl = remove_int(avl, 444);
+  avl = remove_int(avl, 946);
+  avl = gpr_avl_add(avl, box(122), box(710), nullptr);
+  avl = gpr_avl_add(avl, box(846), box(711), nullptr);
+  avl = remove_int(avl, 628);
+  avl = gpr_avl_add(avl, box(511), box(713), nullptr);
+  avl = gpr_avl_add(avl, box(398), box(714), nullptr);
+  avl = remove_int(avl, 730);
+  avl = gpr_avl_add(avl, box(797), box(716), nullptr);
+  avl = remove_int(avl, 897);
+  avl = remove_int(avl, 228);
+  avl = remove_int(avl, 544);
+  avl = remove_int(avl, 552);
+  avl = remove_int(avl, 783);
+  avl = remove_int(avl, 583);
+  avl = remove_int(avl, 894);
+  avl = remove_int(avl, 942);
+  avl = gpr_avl_add(avl, box(346), box(725), nullptr);
+  avl = gpr_avl_add(avl, box(1015), box(726), nullptr);
+  avl = remove_int(avl, 813);
+  avl = gpr_avl_add(avl, box(213), box(728), nullptr);
+  avl = remove_int(avl, 468);
+  avl = remove_int(avl, 365);
+  avl = remove_int(avl, 399);
+  avl = gpr_avl_add(avl, box(380), box(732), nullptr);
+  avl = remove_int(avl, 835);
+  avl = remove_int(avl, 970);
+  avl = gpr_avl_add(avl, box(700), box(735), nullptr);
+  avl = gpr_avl_add(avl, box(807), box(736), nullptr);
+  avl = remove_int(avl, 312);
+  avl = remove_int(avl, 282);
+  avl = remove_int(avl, 370);
+  avl = remove_int(avl, 999);
+  avl = remove_int(avl, 241);
+  avl = remove_int(avl, 884);
+  avl = gpr_avl_add(avl, box(587), box(743), nullptr);
+  avl = gpr_avl_add(avl, box(332), box(744), nullptr);
+  avl = remove_int(avl, 686);
+  avl = remove_int(avl, 206);
+  avl = remove_int(avl, 835);
+  avl = gpr_avl_add(avl, box(334), box(748), nullptr);
+  avl = remove_int(avl, 171);
+  avl = gpr_avl_add(avl, box(1002), box(750), nullptr);
+  avl = gpr_avl_add(avl, box(779), box(751), nullptr);
+  avl = gpr_avl_add(avl, box(307), box(752), nullptr);
+  avl = gpr_avl_add(avl, box(127), box(753), nullptr);
+  avl = gpr_avl_add(avl, box(251), box(754), nullptr);
+  avl = remove_int(avl, 790);
+  avl = remove_int(avl, 189);
+  avl = remove_int(avl, 193);
+  avl = remove_int(avl, 38);
+  avl = remove_int(avl, 124);
+  avl = gpr_avl_add(avl, box(812), box(760), nullptr);
+  avl = remove_int(avl, 43);
+  avl = gpr_avl_add(avl, box(871), box(762), nullptr);
+  avl = gpr_avl_add(avl, box(580), box(763), nullptr);
+  avl = remove_int(avl, 501);
+  avl = remove_int(avl, 462);
+  avl = remove_int(avl, 599);
+  avl = gpr_avl_add(avl, box(240), box(767), nullptr);
+  avl = gpr_avl_add(avl, box(285), box(768), nullptr);
+  avl = gpr_avl_add(avl, box(472), box(769), nullptr);
+  avl = remove_int(avl, 865);
+  avl = remove_int(avl, 763);
+  avl = remove_int(avl, 245);
+  avl = remove_int(avl, 80);
+  avl = remove_int(avl, 713);
+  avl = remove_int(avl, 654);
+  avl = remove_int(avl, 1014);
+  avl = gpr_avl_add(avl, box(495), box(777), nullptr);
+  avl = gpr_avl_add(avl, box(552), box(778), nullptr);
+  avl = remove_int(avl, 19);
+  avl = remove_int(avl, 803);
+  avl = gpr_avl_add(avl, box(508), box(781), nullptr);
+  avl = remove_int(avl, 699);
+  avl = remove_int(avl, 260);
+  avl = remove_int(avl, 92);
+  avl = remove_int(avl, 497);
+  avl = gpr_avl_add(avl, box(970), box(786), nullptr);
+  avl = remove_int(avl, 987);
+  avl = remove_int(avl, 168);
+  avl = remove_int(avl, 476);
+  avl = remove_int(avl, 248);
+  avl = gpr_avl_add(avl, box(358), box(791), nullptr);
+  avl = remove_int(avl, 804);
+  avl = remove_int(avl, 77);
+  avl = remove_int(avl, 905);
+  avl = remove_int(avl, 362);
+  avl = gpr_avl_add(avl, box(578), box(796), nullptr);
+  avl = remove_int(avl, 38);
+  avl = remove_int(avl, 595);
+  avl = gpr_avl_add(avl, box(213), box(799), nullptr);
+  avl = remove_int(avl, 7);
+  avl = remove_int(avl, 620);
+  avl = gpr_avl_add(avl, box(946), box(802), nullptr);
+  avl = remove_int(avl, 145);
+  avl = gpr_avl_add(avl, box(628), box(804), nullptr);
+  avl = remove_int(avl, 972);
+  avl = gpr_avl_add(avl, box(728), box(806), nullptr);
+  avl = remove_int(avl, 91);
+  avl = gpr_avl_add(avl, box(136), box(808), nullptr);
+  avl = gpr_avl_add(avl, box(841), box(809), nullptr);
+  avl = gpr_avl_add(avl, box(265), box(810), nullptr);
+  avl = gpr_avl_add(avl, box(701), box(811), nullptr);
+  avl = gpr_avl_add(avl, box(27), box(812), nullptr);
+  avl = remove_int(avl, 72);
+  avl = remove_int(avl, 14);
+  avl = gpr_avl_add(avl, box(286), box(815), nullptr);
+  avl = remove_int(avl, 996);
+  avl = remove_int(avl, 998);
+  avl = gpr_avl_add(avl, box(466), box(818), nullptr);
+  avl = remove_int(avl, 1009);
+  avl = remove_int(avl, 741);
+  avl = remove_int(avl, 947);
+  avl = remove_int(avl, 241);
+  avl = remove_int(avl, 954);
+  avl = remove_int(avl, 183);
+  avl = remove_int(avl, 395);
+  avl = remove_int(avl, 951);
+  avl = gpr_avl_add(avl, box(267), box(827), nullptr);
+  avl = remove_int(avl, 812);
+  avl = gpr_avl_add(avl, box(577), box(829), nullptr);
+  avl = remove_int(avl, 624);
+  avl = remove_int(avl, 847);
+  avl = remove_int(avl, 745);
+  avl = gpr_avl_add(avl, box(491), box(833), nullptr);
+  avl = gpr_avl_add(avl, box(941), box(834), nullptr);
+  avl = remove_int(avl, 258);
+  avl = gpr_avl_add(avl, box(410), box(836), nullptr);
+  avl = gpr_avl_add(avl, box(80), box(837), nullptr);
+  avl = gpr_avl_add(avl, box(196), box(838), nullptr);
+  avl = gpr_avl_add(avl, box(5), box(839), nullptr);
+  avl = remove_int(avl, 782);
+  avl = gpr_avl_add(avl, box(827), box(841), nullptr);
+  avl = remove_int(avl, 472);
+  avl = remove_int(avl, 664);
+  avl = gpr_avl_add(avl, box(409), box(844), nullptr);
+  avl = gpr_avl_add(avl, box(62), box(845), nullptr);
+  avl = remove_int(avl, 56);
+  avl = remove_int(avl, 606);
+  avl = remove_int(avl, 707);
+  avl = remove_int(avl, 989);
+  avl = remove_int(avl, 549);
+  avl = remove_int(avl, 259);
+  avl = gpr_avl_add(avl, box(405), box(852), nullptr);
+  avl = remove_int(avl, 587);
+  avl = remove_int(avl, 350);
+  avl = gpr_avl_add(avl, box(980), box(855), nullptr);
+  avl = gpr_avl_add(avl, box(992), box(856), nullptr);
+  avl = gpr_avl_add(avl, box(818), box(857), nullptr);
+  avl = remove_int(avl, 853);
+  avl = remove_int(avl, 701);
+  avl = gpr_avl_add(avl, box(675), box(860), nullptr);
+  avl = remove_int(avl, 248);
+  avl = remove_int(avl, 649);
+  avl = gpr_avl_add(avl, box(508), box(863), nullptr);
+  avl = remove_int(avl, 927);
+  avl = gpr_avl_add(avl, box(957), box(865), nullptr);
+  avl = gpr_avl_add(avl, box(698), box(866), nullptr);
+  avl = gpr_avl_add(avl, box(388), box(867), nullptr);
+  avl = gpr_avl_add(avl, box(532), box(868), nullptr);
+  avl = gpr_avl_add(avl, box(681), box(869), nullptr);
+  avl = remove_int(avl, 544);
+  avl = remove_int(avl, 991);
+  avl = remove_int(avl, 397);
+  avl = gpr_avl_add(avl, box(954), box(873), nullptr);
+  avl = gpr_avl_add(avl, box(219), box(874), nullptr);
+  avl = gpr_avl_add(avl, box(465), box(875), nullptr);
+  avl = remove_int(avl, 371);
+  avl = gpr_avl_add(avl, box(601), box(877), nullptr);
+  avl = gpr_avl_add(avl, box(543), box(878), nullptr);
+  avl = remove_int(avl, 329);
+  avl = gpr_avl_add(avl, box(560), box(880), nullptr);
+  avl = remove_int(avl, 898);
+  avl = gpr_avl_add(avl, box(455), box(882), nullptr);
+  avl = remove_int(avl, 313);
+  avl = gpr_avl_add(avl, box(215), box(884), nullptr);
+  avl = remove_int(avl, 846);
+  avl = gpr_avl_add(avl, box(608), box(886), nullptr);
+  avl = remove_int(avl, 248);
+  avl = gpr_avl_add(avl, box(575), box(888), nullptr);
+  avl = remove_int(avl, 207);
+  avl = remove_int(avl, 810);
+  avl = remove_int(avl, 665);
+  avl = remove_int(avl, 361);
+  avl = gpr_avl_add(avl, box(154), box(893), nullptr);
+  avl = gpr_avl_add(avl, box(329), box(894), nullptr);
+  avl = gpr_avl_add(avl, box(326), box(895), nullptr);
+  avl = remove_int(avl, 746);
+  avl = remove_int(avl, 99);
+  avl = gpr_avl_add(avl, box(464), box(898), nullptr);
+  avl = gpr_avl_add(avl, box(141), box(899), nullptr);
+  avl = remove_int(avl, 383);
+  avl = gpr_avl_add(avl, box(414), box(901), nullptr);
+  avl = gpr_avl_add(avl, box(777), box(902), nullptr);
+  avl = remove_int(avl, 972);
+  avl = remove_int(avl, 841);
+  avl = remove_int(avl, 100);
+  avl = gpr_avl_add(avl, box(828), box(906), nullptr);
+  avl = remove_int(avl, 785);
+  avl = gpr_avl_add(avl, box(1008), box(908), nullptr);
+  avl = gpr_avl_add(avl, box(46), box(909), nullptr);
+  avl = remove_int(avl, 399);
+  avl = gpr_avl_add(avl, box(178), box(911), nullptr);
+  avl = gpr_avl_add(avl, box(573), box(912), nullptr);
+  avl = remove_int(avl, 299);
+  avl = gpr_avl_add(avl, box(690), box(914), nullptr);
+  avl = gpr_avl_add(avl, box(692), box(915), nullptr);
+  avl = remove_int(avl, 404);
+  avl = remove_int(avl, 16);
+  avl = remove_int(avl, 746);
+  avl = remove_int(avl, 486);
+  avl = remove_int(avl, 119);
+  avl = gpr_avl_add(avl, box(167), box(921), nullptr);
+  avl = remove_int(avl, 328);
+  avl = gpr_avl_add(avl, box(89), box(923), nullptr);
+  avl = remove_int(avl, 867);
+  avl = remove_int(avl, 626);
+  avl = remove_int(avl, 507);
+  avl = gpr_avl_add(avl, box(365), box(927), nullptr);
+  avl = gpr_avl_add(avl, box(58), box(928), nullptr);
+  avl = gpr_avl_add(avl, box(70), box(929), nullptr);
+  avl = remove_int(avl, 81);
+  avl = remove_int(avl, 797);
+  avl = gpr_avl_add(avl, box(846), box(932), nullptr);
+  avl = remove_int(avl, 642);
+  avl = gpr_avl_add(avl, box(777), box(934), nullptr);
+  avl = remove_int(avl, 107);
+  avl = gpr_avl_add(avl, box(691), box(936), nullptr);
+  avl = gpr_avl_add(avl, box(820), box(937), nullptr);
+  avl = gpr_avl_add(avl, box(202), box(938), nullptr);
+  avl = gpr_avl_add(avl, box(308), box(939), nullptr);
+  avl = gpr_avl_add(avl, box(20), box(940), nullptr);
+  avl = remove_int(avl, 289);
+  avl = gpr_avl_add(avl, box(714), box(942), nullptr);
+  avl = gpr_avl_add(avl, box(584), box(943), nullptr);
+  avl = remove_int(avl, 294);
+  avl = gpr_avl_add(avl, box(496), box(945), nullptr);
+  avl = gpr_avl_add(avl, box(394), box(946), nullptr);
+  avl = gpr_avl_add(avl, box(860), box(947), nullptr);
+  avl = gpr_avl_add(avl, box(58), box(948), nullptr);
+  avl = remove_int(avl, 784);
+  avl = remove_int(avl, 584);
+  avl = remove_int(avl, 708);
+  avl = gpr_avl_add(avl, box(142), box(952), nullptr);
+  avl = gpr_avl_add(avl, box(247), box(953), nullptr);
+  avl = gpr_avl_add(avl, box(389), box(954), nullptr);
+  avl = remove_int(avl, 390);
+  avl = gpr_avl_add(avl, box(465), box(956), nullptr);
+  avl = gpr_avl_add(avl, box(936), box(957), nullptr);
+  avl = gpr_avl_add(avl, box(309), box(958), nullptr);
+  avl = remove_int(avl, 928);
+  avl = remove_int(avl, 128);
+  avl = remove_int(avl, 979);
+  avl = remove_int(avl, 670);
+  avl = remove_int(avl, 738);
+  avl = remove_int(avl, 271);
+  avl = remove_int(avl, 540);
+  avl = gpr_avl_add(avl, box(365), box(966), nullptr);
+  avl = remove_int(avl, 82);
+  avl = gpr_avl_add(avl, box(728), box(968), nullptr);
+  avl = remove_int(avl, 852);
+  avl = gpr_avl_add(avl, box(884), box(970), nullptr);
+  avl = gpr_avl_add(avl, box(502), box(971), nullptr);
+  avl = remove_int(avl, 898);
+  avl = remove_int(avl, 481);
+  avl = gpr_avl_add(avl, box(911), box(974), nullptr);
+  avl = remove_int(avl, 787);
+  avl = remove_int(avl, 785);
+  avl = remove_int(avl, 537);
+  avl = remove_int(avl, 535);
+  avl = remove_int(avl, 136);
+  avl = remove_int(avl, 749);
+  avl = remove_int(avl, 637);
+  avl = remove_int(avl, 900);
+  avl = gpr_avl_add(avl, box(598), box(983), nullptr);
+  avl = remove_int(avl, 25);
+  avl = remove_int(avl, 697);
+  avl = gpr_avl_add(avl, box(645), box(986), nullptr);
+  avl = gpr_avl_add(avl, box(211), box(987), nullptr);
+  avl = gpr_avl_add(avl, box(589), box(988), nullptr);
+  avl = remove_int(avl, 702);
+  avl = gpr_avl_add(avl, box(53), box(990), nullptr);
+  avl = remove_int(avl, 492);
+  avl = remove_int(avl, 185);
+  avl = remove_int(avl, 246);
+  avl = remove_int(avl, 257);
+  avl = remove_int(avl, 502);
+  avl = remove_int(avl, 34);
+  avl = gpr_avl_add(avl, box(74), box(997), nullptr);
+  avl = gpr_avl_add(avl, box(834), box(998), nullptr);
+  avl = gpr_avl_add(avl, box(514), box(999), nullptr);
+  avl = gpr_avl_add(avl, box(75), box(1000), nullptr);
+  avl = remove_int(avl, 745);
+  avl = gpr_avl_add(avl, box(362), box(1002), nullptr);
+  avl = remove_int(avl, 215);
+  avl = gpr_avl_add(avl, box(624), box(1004), nullptr);
+  avl = remove_int(avl, 404);
+  avl = remove_int(avl, 359);
+  avl = remove_int(avl, 491);
+  avl = gpr_avl_add(avl, box(903), box(1008), nullptr);
+  avl = gpr_avl_add(avl, box(240), box(1009), nullptr);
+  avl = remove_int(avl, 95);
+  avl = gpr_avl_add(avl, box(119), box(1011), nullptr);
+  avl = gpr_avl_add(avl, box(857), box(1012), nullptr);
+  avl = remove_int(avl, 39);
+  avl = remove_int(avl, 866);
+  avl = gpr_avl_add(avl, box(503), box(1015), nullptr);
+  avl = gpr_avl_add(avl, box(740), box(1016), nullptr);
+  avl = remove_int(avl, 637);
+  avl = remove_int(avl, 156);
+  avl = remove_int(avl, 6);
+  avl = remove_int(avl, 745);
+  avl = remove_int(avl, 433);
+  avl = remove_int(avl, 283);
+  avl = gpr_avl_add(avl, box(625), box(1023), nullptr);
+  avl = remove_int(avl, 638);
+  avl = gpr_avl_add(avl, box(299), box(1025), nullptr);
+  avl = gpr_avl_add(avl, box(584), box(1026), nullptr);
+  avl = remove_int(avl, 863);
+  avl = gpr_avl_add(avl, box(612), box(1028), nullptr);
+  avl = gpr_avl_add(avl, box(62), box(1029), nullptr);
+  avl = gpr_avl_add(avl, box(432), box(1030), nullptr);
+  avl = remove_int(avl, 371);
+  avl = remove_int(avl, 790);
+  avl = remove_int(avl, 227);
+  avl = remove_int(avl, 836);
+  avl = gpr_avl_add(avl, box(703), box(1035), nullptr);
+  avl = gpr_avl_add(avl, box(644), box(1036), nullptr);
+  avl = remove_int(avl, 638);
+  avl = gpr_avl_add(avl, box(13), box(1038), nullptr);
+  avl = remove_int(avl, 66);
+  avl = remove_int(avl, 82);
+  avl = gpr_avl_add(avl, box(362), box(1041), nullptr);
+  avl = gpr_avl_add(avl, box(783), box(1042), nullptr);
+  avl = remove_int(avl, 60);
+  avl = gpr_avl_add(avl, box(80), box(1044), nullptr);
+  avl = gpr_avl_add(avl, box(825), box(1045), nullptr);
+  avl = gpr_avl_add(avl, box(688), box(1046), nullptr);
+  avl = gpr_avl_add(avl, box(662), box(1047), nullptr);
+  avl = remove_int(avl, 156);
+  avl = remove_int(avl, 376);
+  avl = remove_int(avl, 99);
+  avl = gpr_avl_add(avl, box(526), box(1051), nullptr);
+  avl = gpr_avl_add(avl, box(168), box(1052), nullptr);
+  avl = remove_int(avl, 646);
+  avl = remove_int(avl, 380);
+  avl = remove_int(avl, 833);
+  avl = gpr_avl_add(avl, box(53), box(1056), nullptr);
+  avl = remove_int(avl, 105);
+  avl = gpr_avl_add(avl, box(373), box(1058), nullptr);
+  avl = gpr_avl_add(avl, box(184), box(1059), nullptr);
+  avl = remove_int(avl, 288);
+  avl = gpr_avl_add(avl, box(966), box(1061), nullptr);
+  avl = remove_int(avl, 158);
+  avl = gpr_avl_add(avl, box(406), box(1063), nullptr);
+  avl = remove_int(avl, 470);
+  avl = gpr_avl_add(avl, box(283), box(1065), nullptr);
+  avl = gpr_avl_add(avl, box(838), box(1066), nullptr);
+  avl = gpr_avl_add(avl, box(288), box(1067), nullptr);
+  avl = gpr_avl_add(avl, box(950), box(1068), nullptr);
+  avl = gpr_avl_add(avl, box(163), box(1069), nullptr);
+  avl = remove_int(avl, 623);
+  avl = remove_int(avl, 769);
+  avl = gpr_avl_add(avl, box(144), box(1072), nullptr);
+  avl = gpr_avl_add(avl, box(489), box(1073), nullptr);
+  avl = remove_int(avl, 15);
+  avl = gpr_avl_add(avl, box(971), box(1075), nullptr);
+  avl = remove_int(avl, 660);
+  avl = gpr_avl_add(avl, box(255), box(1077), nullptr);
+  avl = remove_int(avl, 494);
+  avl = gpr_avl_add(avl, box(109), box(1079), nullptr);
+  avl = gpr_avl_add(avl, box(420), box(1080), nullptr);
+  avl = gpr_avl_add(avl, box(509), box(1081), nullptr);
+  avl = remove_int(avl, 178);
+  avl = gpr_avl_add(avl, box(216), box(1083), nullptr);
+  avl = gpr_avl_add(avl, box(707), box(1084), nullptr);
+  avl = gpr_avl_add(avl, box(411), box(1085), nullptr);
+  avl = gpr_avl_add(avl, box(352), box(1086), nullptr);
+  avl = remove_int(avl, 983);
+  avl = gpr_avl_add(avl, box(6), box(1088), nullptr);
+  avl = gpr_avl_add(avl, box(1014), box(1089), nullptr);
+  avl = remove_int(avl, 98);
+  avl = remove_int(avl, 325);
+  avl = gpr_avl_add(avl, box(851), box(1092), nullptr);
+  avl = remove_int(avl, 553);
+  avl = gpr_avl_add(avl, box(218), box(1094), nullptr);
+  avl = gpr_avl_add(avl, box(261), box(1095), nullptr);
+  avl = remove_int(avl, 31);
+  avl = gpr_avl_add(avl, box(872), box(1097), nullptr);
+  avl = remove_int(avl, 543);
+  avl = remove_int(avl, 314);
+  avl = remove_int(avl, 443);
+  avl = gpr_avl_add(avl, box(533), box(1101), nullptr);
+  avl = remove_int(avl, 881);
+  avl = remove_int(avl, 269);
+  avl = remove_int(avl, 940);
+  avl = remove_int(avl, 909);
+  avl = remove_int(avl, 197);
+  avl = remove_int(avl, 773);
+  avl = remove_int(avl, 790);
+  avl = remove_int(avl, 345);
+  avl = gpr_avl_add(avl, box(965), box(1110), nullptr);
+  avl = remove_int(avl, 622);
+  avl = gpr_avl_add(avl, box(352), box(1112), nullptr);
+  avl = remove_int(avl, 182);
+  avl = gpr_avl_add(avl, box(534), box(1114), nullptr);
+  avl = gpr_avl_add(avl, box(97), box(1115), nullptr);
+  avl = gpr_avl_add(avl, box(198), box(1116), nullptr);
+  avl = remove_int(avl, 750);
+  avl = gpr_avl_add(avl, box(98), box(1118), nullptr);
+  avl = remove_int(avl, 943);
+  avl = gpr_avl_add(avl, box(254), box(1120), nullptr);
+  avl = gpr_avl_add(avl, box(30), box(1121), nullptr);
+  avl = remove_int(avl, 14);
+  avl = remove_int(avl, 475);
+  avl = remove_int(avl, 82);
+  avl = gpr_avl_add(avl, box(789), box(1125), nullptr);
+  avl = gpr_avl_add(avl, box(402), box(1126), nullptr);
+  avl = remove_int(avl, 1019);
+  avl = gpr_avl_add(avl, box(858), box(1128), nullptr);
+  avl = gpr_avl_add(avl, box(625), box(1129), nullptr);
+  avl = remove_int(avl, 675);
+  avl = remove_int(avl, 323);
+  avl = gpr_avl_add(avl, box(329), box(1132), nullptr);
+  avl = remove_int(avl, 929);
+  avl = remove_int(avl, 44);
+  avl = gpr_avl_add(avl, box(443), box(1135), nullptr);
+  avl = gpr_avl_add(avl, box(653), box(1136), nullptr);
+  avl = gpr_avl_add(avl, box(750), box(1137), nullptr);
+  avl = gpr_avl_add(avl, box(252), box(1138), nullptr);
+  avl = gpr_avl_add(avl, box(449), box(1139), nullptr);
+  avl = remove_int(avl, 1022);
+  avl = remove_int(avl, 357);
+  avl = remove_int(avl, 602);
+  avl = remove_int(avl, 131);
+  avl = gpr_avl_add(avl, box(531), box(1144), nullptr);
+  avl = remove_int(avl, 806);
+  avl = gpr_avl_add(avl, box(455), box(1146), nullptr);
+  avl = remove_int(avl, 31);
+  avl = gpr_avl_add(avl, box(154), box(1148), nullptr);
+  avl = gpr_avl_add(avl, box(189), box(1149), nullptr);
+  avl = remove_int(avl, 786);
+  avl = gpr_avl_add(avl, box(496), box(1151), nullptr);
+  avl = gpr_avl_add(avl, box(81), box(1152), nullptr);
+  avl = gpr_avl_add(avl, box(59), box(1153), nullptr);
+  avl = remove_int(avl, 424);
+  avl = remove_int(avl, 668);
+  avl = gpr_avl_add(avl, box(723), box(1156), nullptr);
+  avl = gpr_avl_add(avl, box(822), box(1157), nullptr);
+  avl = gpr_avl_add(avl, box(354), box(1158), nullptr);
+  avl = remove_int(avl, 738);
+  avl = gpr_avl_add(avl, box(686), box(1160), nullptr);
+  avl = gpr_avl_add(avl, box(43), box(1161), nullptr);
+  avl = gpr_avl_add(avl, box(625), box(1162), nullptr);
+  avl = gpr_avl_add(avl, box(902), box(1163), nullptr);
+  avl = gpr_avl_add(avl, box(12), box(1164), nullptr);
+  avl = gpr_avl_add(avl, box(977), box(1165), nullptr);
+  avl = gpr_avl_add(avl, box(699), box(1166), nullptr);
+  avl = gpr_avl_add(avl, box(189), box(1167), nullptr);
+  avl = remove_int(avl, 672);
+  avl = remove_int(avl, 90);
+  avl = remove_int(avl, 757);
+  avl = remove_int(avl, 494);
+  avl = gpr_avl_add(avl, box(759), box(1172), nullptr);
+  avl = remove_int(avl, 758);
+  avl = remove_int(avl, 222);
+  avl = gpr_avl_add(avl, box(975), box(1175), nullptr);
+  avl = remove_int(avl, 993);
+  avl = gpr_avl_add(avl, box(2), box(1177), nullptr);
+  avl = gpr_avl_add(avl, box(70), box(1178), nullptr);
+  avl = remove_int(avl, 350);
+  avl = remove_int(avl, 972);
+  avl = remove_int(avl, 880);
+  avl = gpr_avl_add(avl, box(753), box(1182), nullptr);
+  avl = remove_int(avl, 404);
+  avl = gpr_avl_add(avl, box(294), box(1184), nullptr);
+  avl = remove_int(avl, 474);
+  avl = gpr_avl_add(avl, box(228), box(1186), nullptr);
+  avl = gpr_avl_add(avl, box(484), box(1187), nullptr);
+  avl = remove_int(avl, 238);
+  avl = remove_int(avl, 53);
+  avl = remove_int(avl, 691);
+  avl = gpr_avl_add(avl, box(345), box(1191), nullptr);
+  avl = remove_int(avl, 0);
+  avl = gpr_avl_add(avl, box(230), box(1193), nullptr);
+  avl = remove_int(avl, 227);
+  avl = remove_int(avl, 152);
+  avl = gpr_avl_add(avl, box(884), box(1196), nullptr);
+  avl = remove_int(avl, 823);
+  avl = remove_int(avl, 53);
+  avl = gpr_avl_add(avl, box(1015), box(1199), nullptr);
+  avl = gpr_avl_add(avl, box(697), box(1200), nullptr);
+  avl = gpr_avl_add(avl, box(376), box(1201), nullptr);
+  avl = remove_int(avl, 411);
+  avl = gpr_avl_add(avl, box(888), box(1203), nullptr);
+  avl = remove_int(avl, 55);
+  avl = gpr_avl_add(avl, box(85), box(1205), nullptr);
+  avl = remove_int(avl, 947);
+  avl = remove_int(avl, 382);
+  avl = remove_int(avl, 777);
+  avl = gpr_avl_add(avl, box(1017), box(1209), nullptr);
+  avl = gpr_avl_add(avl, box(169), box(1210), nullptr);
+  avl = gpr_avl_add(avl, box(156), box(1211), nullptr);
+  avl = remove_int(avl, 153);
+  avl = remove_int(avl, 642);
+  avl = remove_int(avl, 158);
+  avl = gpr_avl_add(avl, box(554), box(1215), nullptr);
+  avl = gpr_avl_add(avl, box(76), box(1216), nullptr);
+  avl = gpr_avl_add(avl, box(756), box(1217), nullptr);
+  avl = remove_int(avl, 767);
+  avl = remove_int(avl, 112);
+  avl = remove_int(avl, 539);
+  avl = remove_int(avl, 544);
+  avl = remove_int(avl, 628);
+  avl = remove_int(avl, 385);
+  avl = remove_int(avl, 514);
+  avl = remove_int(avl, 362);
+  avl = gpr_avl_add(avl, box(523), box(1226), nullptr);
+  avl = gpr_avl_add(avl, box(712), box(1227), nullptr);
+  avl = gpr_avl_add(avl, box(474), box(1228), nullptr);
+  avl = gpr_avl_add(avl, box(882), box(1229), nullptr);
+  avl = gpr_avl_add(avl, box(965), box(1230), nullptr);
+  avl = remove_int(avl, 464);
+  avl = gpr_avl_add(avl, box(319), box(1232), nullptr);
+  avl = gpr_avl_add(avl, box(504), box(1233), nullptr);
+  avl = remove_int(avl, 818);
+  avl = gpr_avl_add(avl, box(884), box(1235), nullptr);
+  avl = gpr_avl_add(avl, box(813), box(1236), nullptr);
+  avl = gpr_avl_add(avl, box(795), box(1237), nullptr);
+  avl = remove_int(avl, 306);
+  avl = gpr_avl_add(avl, box(799), box(1239), nullptr);
+  avl = remove_int(avl, 534);
+  avl = gpr_avl_add(avl, box(480), box(1241), nullptr);
+  avl = gpr_avl_add(avl, box(656), box(1242), nullptr);
+  avl = gpr_avl_add(avl, box(709), box(1243), nullptr);
+  avl = gpr_avl_add(avl, box(500), box(1244), nullptr);
+  avl = remove_int(avl, 740);
+  avl = gpr_avl_add(avl, box(980), box(1246), nullptr);
+  avl = gpr_avl_add(avl, box(458), box(1247), nullptr);
+  avl = remove_int(avl, 377);
+  avl = remove_int(avl, 338);
+  avl = gpr_avl_add(avl, box(554), box(1250), nullptr);
+  avl = gpr_avl_add(avl, box(504), box(1251), nullptr);
+  avl = gpr_avl_add(avl, box(603), box(1252), nullptr);
+  avl = gpr_avl_add(avl, box(761), box(1253), nullptr);
+  avl = remove_int(avl, 431);
+  avl = gpr_avl_add(avl, box(707), box(1255), nullptr);
+  avl = gpr_avl_add(avl, box(673), box(1256), nullptr);
+  avl = remove_int(avl, 998);
+  avl = remove_int(avl, 332);
+  avl = remove_int(avl, 413);
+  avl = remove_int(avl, 227);
+  avl = remove_int(avl, 249);
+  avl = remove_int(avl, 309);
+  avl = remove_int(avl, 459);
+  avl = gpr_avl_add(avl, box(645), box(1264), nullptr);
+  avl = remove_int(avl, 858);
+  avl = remove_int(avl, 997);
+  avl = gpr_avl_add(avl, box(519), box(1267), nullptr);
+  avl = remove_int(avl, 614);
+  avl = remove_int(avl, 462);
+  avl = remove_int(avl, 792);
+  avl = gpr_avl_add(avl, box(987), box(1271), nullptr);
+  avl = gpr_avl_add(avl, box(309), box(1272), nullptr);
+  avl = remove_int(avl, 747);
+  avl = gpr_avl_add(avl, box(621), box(1274), nullptr);
+  avl = gpr_avl_add(avl, box(450), box(1275), nullptr);
+  avl = remove_int(avl, 265);
+  avl = remove_int(avl, 8);
+  avl = remove_int(avl, 383);
+  avl = gpr_avl_add(avl, box(238), box(1279), nullptr);
+  avl = remove_int(avl, 241);
+  avl = gpr_avl_add(avl, box(180), box(1281), nullptr);
+  avl = gpr_avl_add(avl, box(411), box(1282), nullptr);
+  avl = gpr_avl_add(avl, box(791), box(1283), nullptr);
+  avl = gpr_avl_add(avl, box(955), box(1284), nullptr);
+  avl = remove_int(avl, 24);
+  avl = remove_int(avl, 375);
+  avl = gpr_avl_add(avl, box(140), box(1287), nullptr);
+  avl = remove_int(avl, 949);
+  avl = gpr_avl_add(avl, box(301), box(1289), nullptr);
+  avl = gpr_avl_add(avl, box(0), box(1290), nullptr);
+  avl = remove_int(avl, 371);
+  avl = remove_int(avl, 427);
+  avl = remove_int(avl, 841);
+  avl = remove_int(avl, 847);
+  avl = gpr_avl_add(avl, box(814), box(1295), nullptr);
+  avl = gpr_avl_add(avl, box(127), box(1296), nullptr);
+  avl = gpr_avl_add(avl, box(279), box(1297), nullptr);
+  avl = remove_int(avl, 669);
+  avl = remove_int(avl, 541);
+  avl = remove_int(avl, 275);
+  avl = remove_int(avl, 299);
+  avl = remove_int(avl, 552);
+  avl = gpr_avl_add(avl, box(310), box(1303), nullptr);
+  avl = gpr_avl_add(avl, box(304), box(1304), nullptr);
+  avl = gpr_avl_add(avl, box(1), box(1305), nullptr);
+  avl = gpr_avl_add(avl, box(339), box(1306), nullptr);
+  avl = remove_int(avl, 570);
+  avl = remove_int(avl, 752);
+  avl = remove_int(avl, 552);
+  avl = remove_int(avl, 442);
+  avl = remove_int(avl, 639);
+  avl = gpr_avl_add(avl, box(313), box(1312), nullptr);
+  avl = remove_int(avl, 85);
+  avl = gpr_avl_add(avl, box(964), box(1314), nullptr);
+  avl = gpr_avl_add(avl, box(559), box(1315), nullptr);
+  avl = remove_int(avl, 167);
+  avl = gpr_avl_add(avl, box(866), box(1317), nullptr);
+  avl = remove_int(avl, 275);
+  avl = gpr_avl_add(avl, box(173), box(1319), nullptr);
+  avl = gpr_avl_add(avl, box(765), box(1320), nullptr);
+  avl = remove_int(avl, 883);
+  avl = gpr_avl_add(avl, box(547), box(1322), nullptr);
+  avl = gpr_avl_add(avl, box(847), box(1323), nullptr);
+  avl = remove_int(avl, 817);
+  avl = remove_int(avl, 850);
+  avl = remove_int(avl, 718);
+  avl = gpr_avl_add(avl, box(806), box(1327), nullptr);
+  avl = gpr_avl_add(avl, box(360), box(1328), nullptr);
+  avl = remove_int(avl, 991);
+  avl = gpr_avl_add(avl, box(493), box(1330), nullptr);
+  avl = remove_int(avl, 516);
+  avl = gpr_avl_add(avl, box(361), box(1332), nullptr);
+  avl = remove_int(avl, 355);
+  avl = gpr_avl_add(avl, box(512), box(1334), nullptr);
+  avl = gpr_avl_add(avl, box(191), box(1335), nullptr);
+  avl = remove_int(avl, 703);
+  avl = gpr_avl_add(avl, box(333), box(1337), nullptr);
+  avl = remove_int(avl, 481);
+  avl = gpr_avl_add(avl, box(501), box(1339), nullptr);
+  avl = remove_int(avl, 532);
+  avl = remove_int(avl, 510);
+  avl = gpr_avl_add(avl, box(793), box(1342), nullptr);
+  avl = gpr_avl_add(avl, box(234), box(1343), nullptr);
+  avl = remove_int(avl, 159);
+  avl = remove_int(avl, 429);
+  avl = remove_int(avl, 728);
+  avl = remove_int(avl, 288);
+  avl = gpr_avl_add(avl, box(281), box(1348), nullptr);
+  avl = gpr_avl_add(avl, box(702), box(1349), nullptr);
+  avl = gpr_avl_add(avl, box(149), box(1350), nullptr);
+  avl = remove_int(avl, 22);
+  avl = remove_int(avl, 944);
+  avl = remove_int(avl, 55);
+  avl = remove_int(avl, 512);
+  avl = remove_int(avl, 676);
+  avl = remove_int(avl, 884);
+  avl = gpr_avl_add(avl, box(246), box(1357), nullptr);
+  avl = gpr_avl_add(avl, box(455), box(1358), nullptr);
+  avl = remove_int(avl, 782);
+  avl = remove_int(avl, 682);
+  avl = gpr_avl_add(avl, box(243), box(1361), nullptr);
+  avl = gpr_avl_add(avl, box(109), box(1362), nullptr);
+  avl = gpr_avl_add(avl, box(452), box(1363), nullptr);
+  avl = remove_int(avl, 151);
+  avl = gpr_avl_add(avl, box(159), box(1365), nullptr);
+  avl = remove_int(avl, 1023);
+  avl = gpr_avl_add(avl, box(129), box(1367), nullptr);
+  avl = gpr_avl_add(avl, box(537), box(1368), nullptr);
+  avl = remove_int(avl, 321);
+  avl = gpr_avl_add(avl, box(740), box(1370), nullptr);
+  avl = remove_int(avl, 45);
+  avl = remove_int(avl, 136);
+  avl = gpr_avl_add(avl, box(229), box(1373), nullptr);
+  avl = remove_int(avl, 772);
+  avl = gpr_avl_add(avl, box(181), box(1375), nullptr);
+  avl = remove_int(avl, 175);
+  avl = gpr_avl_add(avl, box(817), box(1377), nullptr);
+  avl = remove_int(avl, 956);
+  avl = gpr_avl_add(avl, box(675), box(1379), nullptr);
+  avl = gpr_avl_add(avl, box(375), box(1380), nullptr);
+  avl = remove_int(avl, 384);
+  avl = gpr_avl_add(avl, box(1016), box(1382), nullptr);
+  avl = remove_int(avl, 295);
+  avl = remove_int(avl, 697);
+  avl = remove_int(avl, 554);
+  avl = remove_int(avl, 590);
+  avl = remove_int(avl, 1014);
+  avl = gpr_avl_add(avl, box(890), box(1388), nullptr);
+  avl = gpr_avl_add(avl, box(293), box(1389), nullptr);
+  avl = remove_int(avl, 207);
+  avl = remove_int(avl, 46);
+  avl = gpr_avl_add(avl, box(899), box(1392), nullptr);
+  avl = gpr_avl_add(avl, box(666), box(1393), nullptr);
+  avl = gpr_avl_add(avl, box(85), box(1394), nullptr);
+  avl = gpr_avl_add(avl, box(914), box(1395), nullptr);
+  avl = gpr_avl_add(avl, box(128), box(1396), nullptr);
+  avl = gpr_avl_add(avl, box(835), box(1397), nullptr);
+  avl = gpr_avl_add(avl, box(787), box(1398), nullptr);
+  avl = gpr_avl_add(avl, box(649), box(1399), nullptr);
+  avl = gpr_avl_add(avl, box(723), box(1400), nullptr);
+  avl = remove_int(avl, 874);
+  avl = gpr_avl_add(avl, box(778), box(1402), nullptr);
+  avl = gpr_avl_add(avl, box(1015), box(1403), nullptr);
+  avl = gpr_avl_add(avl, box(59), box(1404), nullptr);
+  avl = gpr_avl_add(avl, box(259), box(1405), nullptr);
+  avl = gpr_avl_add(avl, box(758), box(1406), nullptr);
+  avl = remove_int(avl, 648);
+  avl = gpr_avl_add(avl, box(145), box(1408), nullptr);
+  avl = gpr_avl_add(avl, box(440), box(1409), nullptr);
+  avl = remove_int(avl, 608);
+  avl = remove_int(avl, 690);
+  avl = gpr_avl_add(avl, box(605), box(1412), nullptr);
+  avl = remove_int(avl, 856);
+  avl = remove_int(avl, 608);
+  avl = gpr_avl_add(avl, box(829), box(1415), nullptr);
+  avl = gpr_avl_add(avl, box(660), box(1416), nullptr);
+  avl = remove_int(avl, 596);
+  avl = gpr_avl_add(avl, box(519), box(1418), nullptr);
+  avl = gpr_avl_add(avl, box(35), box(1419), nullptr);
+  avl = gpr_avl_add(avl, box(871), box(1420), nullptr);
+  avl = remove_int(avl, 845);
+  avl = gpr_avl_add(avl, box(600), box(1422), nullptr);
+  avl = gpr_avl_add(avl, box(215), box(1423), nullptr);
+  avl = remove_int(avl, 761);
+  avl = gpr_avl_add(avl, box(975), box(1425), nullptr);
+  avl = remove_int(avl, 987);
+  avl = gpr_avl_add(avl, box(58), box(1427), nullptr);
+  avl = remove_int(avl, 119);
+  avl = gpr_avl_add(avl, box(937), box(1429), nullptr);
+  avl = gpr_avl_add(avl, box(372), box(1430), nullptr);
+  avl = gpr_avl_add(avl, box(11), box(1431), nullptr);
+  avl = gpr_avl_add(avl, box(398), box(1432), nullptr);
+  avl = gpr_avl_add(avl, box(423), box(1433), nullptr);
+  avl = remove_int(avl, 171);
+  avl = gpr_avl_add(avl, box(473), box(1435), nullptr);
+  avl = remove_int(avl, 752);
+  avl = remove_int(avl, 625);
+  avl = remove_int(avl, 764);
+  avl = remove_int(avl, 49);
+  avl = gpr_avl_add(avl, box(472), box(1440), nullptr);
+  avl = remove_int(avl, 847);
+  avl = remove_int(avl, 642);
+  avl = remove_int(avl, 1004);
+  avl = remove_int(avl, 795);
+  avl = remove_int(avl, 465);
+  avl = gpr_avl_add(avl, box(636), box(1446), nullptr);
+  avl = remove_int(avl, 152);
+  avl = gpr_avl_add(avl, box(61), box(1448), nullptr);
+  avl = remove_int(avl, 929);
+  avl = remove_int(avl, 9);
+  avl = gpr_avl_add(avl, box(251), box(1451), nullptr);
+  avl = gpr_avl_add(avl, box(672), box(1452), nullptr);
+  avl = gpr_avl_add(avl, box(66), box(1453), nullptr);
+  avl = remove_int(avl, 693);
+  avl = remove_int(avl, 914);
+  avl = remove_int(avl, 116);
+  avl = remove_int(avl, 577);
+  avl = gpr_avl_add(avl, box(618), box(1458), nullptr);
+  avl = gpr_avl_add(avl, box(495), box(1459), nullptr);
+  avl = remove_int(avl, 450);
+  avl = gpr_avl_add(avl, box(533), box(1461), nullptr);
+  avl = gpr_avl_add(avl, box(414), box(1462), nullptr);
+  avl = remove_int(avl, 74);
+  avl = remove_int(avl, 236);
+  avl = gpr_avl_add(avl, box(707), box(1465), nullptr);
+  avl = gpr_avl_add(avl, box(357), box(1466), nullptr);
+  avl = gpr_avl_add(avl, box(1007), box(1467), nullptr);
+  avl = gpr_avl_add(avl, box(811), box(1468), nullptr);
+  avl = gpr_avl_add(avl, box(418), box(1469), nullptr);
+  avl = gpr_avl_add(avl, box(164), box(1470), nullptr);
+  avl = gpr_avl_add(avl, box(622), box(1471), nullptr);
+  avl = remove_int(avl, 22);
+  avl = remove_int(avl, 14);
+  avl = remove_int(avl, 732);
+  avl = remove_int(avl, 7);
+  avl = remove_int(avl, 447);
+  avl = gpr_avl_add(avl, box(221), box(1477), nullptr);
+  avl = gpr_avl_add(avl, box(202), box(1478), nullptr);
+  avl = gpr_avl_add(avl, box(312), box(1479), nullptr);
+  avl = remove_int(avl, 274);
+  avl = gpr_avl_add(avl, box(684), box(1481), nullptr);
+  avl = gpr_avl_add(avl, box(954), box(1482), nullptr);
+  avl = gpr_avl_add(avl, box(637), box(1483), nullptr);
+  avl = remove_int(avl, 716);
+  avl = gpr_avl_add(avl, box(198), box(1485), nullptr);
+  avl = remove_int(avl, 340);
+  avl = remove_int(avl, 137);
+  avl = remove_int(avl, 995);
+  avl = remove_int(avl, 1004);
+  avl = gpr_avl_add(avl, box(661), box(1490), nullptr);
+  avl = gpr_avl_add(avl, box(862), box(1491), nullptr);
+  avl = remove_int(avl, 527);
+  avl = gpr_avl_add(avl, box(945), box(1493), nullptr);
+  avl = remove_int(avl, 355);
+  avl = remove_int(avl, 144);
+  avl = gpr_avl_add(avl, box(229), box(1496), nullptr);
+  avl = gpr_avl_add(avl, box(237), box(1497), nullptr);
+  avl = remove_int(avl, 471);
+  avl = remove_int(avl, 901);
+  avl = gpr_avl_add(avl, box(905), box(1500), nullptr);
+  avl = remove_int(avl, 19);
+  avl = remove_int(avl, 896);
+  avl = remove_int(avl, 585);
+  avl = remove_int(avl, 308);
+  avl = gpr_avl_add(avl, box(547), box(1505), nullptr);
+  avl = gpr_avl_add(avl, box(552), box(1506), nullptr);
+  avl = gpr_avl_add(avl, box(30), box(1507), nullptr);
+  avl = gpr_avl_add(avl, box(445), box(1508), nullptr);
+  avl = remove_int(avl, 785);
+  avl = remove_int(avl, 185);
+  avl = gpr_avl_add(avl, box(405), box(1511), nullptr);
+  avl = gpr_avl_add(avl, box(733), box(1512), nullptr);
+  avl = gpr_avl_add(avl, box(573), box(1513), nullptr);
+  avl = gpr_avl_add(avl, box(492), box(1514), nullptr);
+  avl = gpr_avl_add(avl, box(343), box(1515), nullptr);
+  avl = gpr_avl_add(avl, box(527), box(1516), nullptr);
+  avl = gpr_avl_add(avl, box(596), box(1517), nullptr);
+  avl = gpr_avl_add(avl, box(519), box(1518), nullptr);
+  avl = remove_int(avl, 243);
+  avl = remove_int(avl, 722);
+  avl = gpr_avl_add(avl, box(772), box(1521), nullptr);
+  avl = remove_int(avl, 152);
+  avl = remove_int(avl, 305);
+  avl = gpr_avl_add(avl, box(754), box(1524), nullptr);
+  avl = gpr_avl_add(avl, box(373), box(1525), nullptr);
+  avl = remove_int(avl, 995);
+  avl = gpr_avl_add(avl, box(329), box(1527), nullptr);
+  avl = remove_int(avl, 397);
+  avl = gpr_avl_add(avl, box(884), box(1529), nullptr);
+  avl = remove_int(avl, 329);
+  avl = remove_int(avl, 240);
+  avl = gpr_avl_add(avl, box(566), box(1532), nullptr);
+  avl = gpr_avl_add(avl, box(232), box(1533), nullptr);
+  avl = remove_int(avl, 993);
+  avl = gpr_avl_add(avl, box(888), box(1535), nullptr);
+  avl = remove_int(avl, 242);
+  avl = gpr_avl_add(avl, box(941), box(1537), nullptr);
+  avl = remove_int(avl, 415);
+  avl = gpr_avl_add(avl, box(992), box(1539), nullptr);
+  avl = remove_int(avl, 289);
+  avl = gpr_avl_add(avl, box(60), box(1541), nullptr);
+  avl = gpr_avl_add(avl, box(97), box(1542), nullptr);
+  avl = remove_int(avl, 965);
+  avl = remove_int(avl, 267);
+  avl = remove_int(avl, 360);
+  avl = gpr_avl_add(avl, box(5), box(1546), nullptr);
+  avl = remove_int(avl, 429);
+  avl = gpr_avl_add(avl, box(412), box(1548), nullptr);
+  avl = remove_int(avl, 632);
+  avl = remove_int(avl, 113);
+  avl = gpr_avl_add(avl, box(48), box(1551), nullptr);
+  avl = gpr_avl_add(avl, box(108), box(1552), nullptr);
+  avl = gpr_avl_add(avl, box(750), box(1553), nullptr);
+  avl = remove_int(avl, 188);
+  avl = gpr_avl_add(avl, box(668), box(1555), nullptr);
+  avl = remove_int(avl, 37);
+  avl = remove_int(avl, 737);
+  avl = gpr_avl_add(avl, box(93), box(1558), nullptr);
+  avl = gpr_avl_add(avl, box(628), box(1559), nullptr);
+  avl = gpr_avl_add(avl, box(480), box(1560), nullptr);
+  avl = remove_int(avl, 958);
+  avl = remove_int(avl, 565);
+  avl = remove_int(avl, 32);
+  avl = remove_int(avl, 1);
+  avl = remove_int(avl, 335);
+  avl = gpr_avl_add(avl, box(136), box(1566), nullptr);
+  avl = gpr_avl_add(avl, box(469), box(1567), nullptr);
+  avl = remove_int(avl, 349);
+  avl = gpr_avl_add(avl, box(768), box(1569), nullptr);
+  avl = gpr_avl_add(avl, box(915), box(1570), nullptr);
+  avl = remove_int(avl, 1014);
+  avl = gpr_avl_add(avl, box(117), box(1572), nullptr);
+  avl = remove_int(avl, 62);
+  avl = gpr_avl_add(avl, box(382), box(1574), nullptr);
+  avl = remove_int(avl, 571);
+  avl = gpr_avl_add(avl, box(655), box(1576), nullptr);
+  avl = gpr_avl_add(avl, box(323), box(1577), nullptr);
+  avl = remove_int(avl, 869);
+  avl = remove_int(avl, 151);
+  avl = gpr_avl_add(avl, box(1019), box(1580), nullptr);
+  avl = gpr_avl_add(avl, box(984), box(1581), nullptr);
+  avl = gpr_avl_add(avl, box(870), box(1582), nullptr);
+  avl = gpr_avl_add(avl, box(376), box(1583), nullptr);
+  avl = remove_int(avl, 625);
+  avl = gpr_avl_add(avl, box(733), box(1585), nullptr);
+  avl = remove_int(avl, 532);
+  avl = remove_int(avl, 444);
+  avl = gpr_avl_add(avl, box(428), box(1588), nullptr);
+  avl = gpr_avl_add(avl, box(860), box(1589), nullptr);
+  avl = gpr_avl_add(avl, box(173), box(1590), nullptr);
+  avl = remove_int(avl, 649);
+  avl = remove_int(avl, 913);
+  avl = remove_int(avl, 1);
+  avl = remove_int(avl, 304);
+  avl = gpr_avl_add(avl, box(604), box(1595), nullptr);
+  avl = gpr_avl_add(avl, box(639), box(1596), nullptr);
+  avl = remove_int(avl, 431);
+  avl = gpr_avl_add(avl, box(993), box(1598), nullptr);
+  avl = remove_int(avl, 681);
+  avl = remove_int(avl, 927);
+  avl = gpr_avl_add(avl, box(87), box(1601), nullptr);
+  avl = gpr_avl_add(avl, box(91), box(1602), nullptr);
+  avl = remove_int(avl, 61);
+  avl = remove_int(avl, 14);
+  avl = remove_int(avl, 305);
+  avl = remove_int(avl, 304);
+  avl = remove_int(avl, 1016);
+  avl = gpr_avl_add(avl, box(903), box(1608), nullptr);
+  avl = gpr_avl_add(avl, box(951), box(1609), nullptr);
+  avl = gpr_avl_add(avl, box(146), box(1610), nullptr);
+  avl = gpr_avl_add(avl, box(482), box(1611), nullptr);
+  avl = gpr_avl_add(avl, box(71), box(1612), nullptr);
+  avl = remove_int(avl, 246);
+  avl = remove_int(avl, 696);
+  avl = gpr_avl_add(avl, box(636), box(1615), nullptr);
+  avl = gpr_avl_add(avl, box(295), box(1616), nullptr);
+  avl = remove_int(avl, 11);
+  avl = remove_int(avl, 231);
+  avl = gpr_avl_add(avl, box(905), box(1619), nullptr);
+  avl = gpr_avl_add(avl, box(993), box(1620), nullptr);
+  avl = gpr_avl_add(avl, box(433), box(1621), nullptr);
+  avl = gpr_avl_add(avl, box(117), box(1622), nullptr);
+  avl = gpr_avl_add(avl, box(467), box(1623), nullptr);
+  avl = remove_int(avl, 419);
+  avl = gpr_avl_add(avl, box(179), box(1625), nullptr);
+  avl = remove_int(avl, 926);
+  avl = remove_int(avl, 326);
+  avl = gpr_avl_add(avl, box(551), box(1628), nullptr);
+  avl = remove_int(avl, 14);
+  avl = remove_int(avl, 476);
+  avl = remove_int(avl, 823);
+  avl = gpr_avl_add(avl, box(350), box(1632), nullptr);
+  avl = gpr_avl_add(avl, box(133), box(1633), nullptr);
+  avl = remove_int(avl, 906);
+  avl = gpr_avl_add(avl, box(827), box(1635), nullptr);
+  avl = gpr_avl_add(avl, box(201), box(1636), nullptr);
+  avl = remove_int(avl, 124);
+  avl = remove_int(avl, 662);
+  avl = gpr_avl_add(avl, box(314), box(1639), nullptr);
+  avl = gpr_avl_add(avl, box(986), box(1640), nullptr);
+  avl = gpr_avl_add(avl, box(622), box(1641), nullptr);
+  avl = remove_int(avl, 130);
+  avl = gpr_avl_add(avl, box(861), box(1643), nullptr);
+  avl = remove_int(avl, 497);
+  avl = remove_int(avl, 905);
+  avl = gpr_avl_add(avl, box(502), box(1646), nullptr);
+  avl = remove_int(avl, 721);
+  avl = gpr_avl_add(avl, box(514), box(1648), nullptr);
+  avl = gpr_avl_add(avl, box(410), box(1649), nullptr);
+  avl = remove_int(avl, 869);
+  avl = remove_int(avl, 247);
+  avl = gpr_avl_add(avl, box(450), box(1652), nullptr);
+  avl = remove_int(avl, 364);
+  avl = gpr_avl_add(avl, box(963), box(1654), nullptr);
+  avl = gpr_avl_add(avl, box(146), box(1655), nullptr);
+  avl = remove_int(avl, 147);
+  avl = remove_int(avl, 789);
+  avl = gpr_avl_add(avl, box(693), box(1658), nullptr);
+  avl = gpr_avl_add(avl, box(959), box(1659), nullptr);
+  avl = remove_int(avl, 478);
+  avl = gpr_avl_add(avl, box(116), box(1661), nullptr);
+  avl = gpr_avl_add(avl, box(520), box(1662), nullptr);
+  avl = gpr_avl_add(avl, box(809), box(1663), nullptr);
+  avl = gpr_avl_add(avl, box(667), box(1664), nullptr);
+  avl = gpr_avl_add(avl, box(406), box(1665), nullptr);
+  avl = remove_int(avl, 409);
+  avl = gpr_avl_add(avl, box(558), box(1667), nullptr);
+  avl = gpr_avl_add(avl, box(0), box(1668), nullptr);
+  avl = gpr_avl_add(avl, box(948), box(1669), nullptr);
+  avl = gpr_avl_add(avl, box(576), box(1670), nullptr);
+  avl = remove_int(avl, 864);
+  avl = remove_int(avl, 840);
+  avl = remove_int(avl, 1001);
+  avl = gpr_avl_add(avl, box(232), box(1674), nullptr);
+  avl = remove_int(avl, 676);
+  avl = remove_int(avl, 752);
+  avl = remove_int(avl, 667);
+  avl = remove_int(avl, 605);
+  avl = gpr_avl_add(avl, box(258), box(1679), nullptr);
+  avl = gpr_avl_add(avl, box(648), box(1680), nullptr);
+  avl = gpr_avl_add(avl, box(761), box(1681), nullptr);
+  avl = remove_int(avl, 293);
+  avl = remove_int(avl, 893);
+  avl = gpr_avl_add(avl, box(194), box(1684), nullptr);
+  avl = remove_int(avl, 233);
+  avl = gpr_avl_add(avl, box(888), box(1686), nullptr);
+  avl = remove_int(avl, 470);
+  avl = remove_int(avl, 703);
+  avl = remove_int(avl, 190);
+  avl = remove_int(avl, 359);
+  avl = gpr_avl_add(avl, box(621), box(1691), nullptr);
+  avl = remove_int(avl, 634);
+  avl = remove_int(avl, 335);
+  avl = gpr_avl_add(avl, box(718), box(1694), nullptr);
+  avl = gpr_avl_add(avl, box(463), box(1695), nullptr);
+  avl = gpr_avl_add(avl, box(233), box(1696), nullptr);
+  avl = remove_int(avl, 376);
+  avl = remove_int(avl, 496);
+  avl = remove_int(avl, 819);
+  avl = remove_int(avl, 38);
+  avl = remove_int(avl, 436);
+  avl = remove_int(avl, 102);
+  avl = gpr_avl_add(avl, box(607), box(1703), nullptr);
+  avl = remove_int(avl, 329);
+  avl = gpr_avl_add(avl, box(716), box(1705), nullptr);
+  avl = remove_int(avl, 639);
+  avl = remove_int(avl, 775);
+  avl = remove_int(avl, 578);
+  avl = remove_int(avl, 464);
+  avl = remove_int(avl, 679);
+  avl = remove_int(avl, 615);
+  avl = remove_int(avl, 104);
+  avl = gpr_avl_add(avl, box(414), box(1713), nullptr);
+  avl = gpr_avl_add(avl, box(212), box(1714), nullptr);
+  avl = gpr_avl_add(avl, box(266), box(1715), nullptr);
+  avl = gpr_avl_add(avl, box(238), box(1716), nullptr);
+  avl = remove_int(avl, 153);
+  avl = gpr_avl_add(avl, box(585), box(1718), nullptr);
+  avl = remove_int(avl, 121);
+  avl = gpr_avl_add(avl, box(534), box(1720), nullptr);
+  avl = remove_int(avl, 579);
+  avl = gpr_avl_add(avl, box(127), box(1722), nullptr);
+  avl = gpr_avl_add(avl, box(399), box(1723), nullptr);
+  avl = remove_int(avl, 417);
+  avl = gpr_avl_add(avl, box(978), box(1725), nullptr);
+  avl = gpr_avl_add(avl, box(768), box(1726), nullptr);
+  avl = remove_int(avl, 985);
+  avl = gpr_avl_add(avl, box(536), box(1728), nullptr);
+  avl = gpr_avl_add(avl, box(449), box(1729), nullptr);
+  avl = gpr_avl_add(avl, box(586), box(1730), nullptr);
+  avl = remove_int(avl, 998);
+  avl = remove_int(avl, 394);
+  avl = remove_int(avl, 141);
+  avl = gpr_avl_add(avl, box(889), box(1734), nullptr);
+  avl = gpr_avl_add(avl, box(871), box(1735), nullptr);
+  avl = gpr_avl_add(avl, box(76), box(1736), nullptr);
+  avl = gpr_avl_add(avl, box(549), box(1737), nullptr);
+  avl = gpr_avl_add(avl, box(757), box(1738), nullptr);
+  avl = remove_int(avl, 908);
+  avl = gpr_avl_add(avl, box(789), box(1740), nullptr);
+  avl = remove_int(avl, 224);
+  avl = gpr_avl_add(avl, box(407), box(1742), nullptr);
+  avl = gpr_avl_add(avl, box(381), box(1743), nullptr);
+  avl = gpr_avl_add(avl, box(561), box(1744), nullptr);
+  avl = gpr_avl_add(avl, box(667), box(1745), nullptr);
+  avl = gpr_avl_add(avl, box(522), box(1746), nullptr);
+  avl = gpr_avl_add(avl, box(948), box(1747), nullptr);
+  avl = remove_int(avl, 770);
+  avl = gpr_avl_add(avl, box(872), box(1749), nullptr);
+  avl = gpr_avl_add(avl, box(327), box(1750), nullptr);
+  avl = remove_int(avl, 10);
+  avl = gpr_avl_add(avl, box(122), box(1752), nullptr);
+  avl = remove_int(avl, 606);
+  avl = gpr_avl_add(avl, box(485), box(1754), nullptr);
+  avl = remove_int(avl, 6);
+  avl = gpr_avl_add(avl, box(329), box(1756), nullptr);
+  avl = gpr_avl_add(avl, box(783), box(1757), nullptr);
+  avl = remove_int(avl, 416);
+  avl = gpr_avl_add(avl, box(656), box(1759), nullptr);
+  avl = gpr_avl_add(avl, box(971), box(1760), nullptr);
+  avl = gpr_avl_add(avl, box(77), box(1761), nullptr);
+  avl = gpr_avl_add(avl, box(942), box(1762), nullptr);
+  avl = remove_int(avl, 361);
+  avl = gpr_avl_add(avl, box(66), box(1764), nullptr);
+  avl = gpr_avl_add(avl, box(299), box(1765), nullptr);
+  avl = gpr_avl_add(avl, box(929), box(1766), nullptr);
+  avl = gpr_avl_add(avl, box(797), box(1767), nullptr);
+  avl = remove_int(avl, 869);
+  avl = remove_int(avl, 907);
+  avl = gpr_avl_add(avl, box(870), box(1770), nullptr);
+  avl = remove_int(avl, 580);
+  avl = remove_int(avl, 120);
+  avl = gpr_avl_add(avl, box(913), box(1773), nullptr);
+  avl = remove_int(avl, 480);
+  avl = gpr_avl_add(avl, box(489), box(1775), nullptr);
+  avl = remove_int(avl, 845);
+  avl = gpr_avl_add(avl, box(896), box(1777), nullptr);
+  avl = remove_int(avl, 567);
+  avl = remove_int(avl, 427);
+  avl = gpr_avl_add(avl, box(443), box(1780), nullptr);
+  avl = gpr_avl_add(avl, box(3), box(1781), nullptr);
+  avl = remove_int(avl, 12);
+  avl = gpr_avl_add(avl, box(376), box(1783), nullptr);
+  avl = gpr_avl_add(avl, box(155), box(1784), nullptr);
+  avl = gpr_avl_add(avl, box(188), box(1785), nullptr);
+  avl = gpr_avl_add(avl, box(149), box(1786), nullptr);
+  avl = gpr_avl_add(avl, box(178), box(1787), nullptr);
+  avl = remove_int(avl, 84);
+  avl = gpr_avl_add(avl, box(805), box(1789), nullptr);
+  avl = gpr_avl_add(avl, box(612), box(1790), nullptr);
+  avl = remove_int(avl, 991);
+  avl = gpr_avl_add(avl, box(837), box(1792), nullptr);
+  avl = remove_int(avl, 173);
+  avl = remove_int(avl, 72);
+  avl = gpr_avl_add(avl, box(1014), box(1795), nullptr);
+  avl = remove_int(avl, 303);
+  avl = gpr_avl_add(avl, box(865), box(1797), nullptr);
+  avl = gpr_avl_add(avl, box(793), box(1798), nullptr);
+  avl = remove_int(avl, 173);
+  avl = remove_int(avl, 477);
+  avl = gpr_avl_add(avl, box(950), box(1801), nullptr);
+  avl = gpr_avl_add(avl, box(105), box(1802), nullptr);
+  avl = gpr_avl_add(avl, box(895), box(1803), nullptr);
+  avl = gpr_avl_add(avl, box(171), box(1804), nullptr);
+  avl = gpr_avl_add(avl, box(753), box(1805), nullptr);
+  avl = gpr_avl_add(avl, box(946), box(1806), nullptr);
+  avl = remove_int(avl, 194);
+  avl = remove_int(avl, 559);
+  avl = remove_int(avl, 116);
+  avl = gpr_avl_add(avl, box(968), box(1810), nullptr);
+  avl = remove_int(avl, 124);
+  avl = remove_int(avl, 99);
+  avl = gpr_avl_add(avl, box(563), box(1813), nullptr);
+  avl = remove_int(avl, 182);
+  avl = gpr_avl_add(avl, box(816), box(1815), nullptr);
+  avl = remove_int(avl, 73);
+  avl = remove_int(avl, 261);
+  avl = gpr_avl_add(avl, box(847), box(1818), nullptr);
+  avl = gpr_avl_add(avl, box(368), box(1819), nullptr);
+  avl = gpr_avl_add(avl, box(808), box(1820), nullptr);
+  avl = gpr_avl_add(avl, box(779), box(1821), nullptr);
+  avl = remove_int(avl, 818);
+  avl = gpr_avl_add(avl, box(466), box(1823), nullptr);
+  avl = remove_int(avl, 316);
+  avl = gpr_avl_add(avl, box(986), box(1825), nullptr);
+  avl = gpr_avl_add(avl, box(688), box(1826), nullptr);
+  avl = gpr_avl_add(avl, box(509), box(1827), nullptr);
+  avl = gpr_avl_add(avl, box(51), box(1828), nullptr);
+  avl = remove_int(avl, 655);
+  avl = remove_int(avl, 785);
+  avl = remove_int(avl, 893);
+  avl = gpr_avl_add(avl, box(167), box(1832), nullptr);
+  avl = remove_int(avl, 13);
+  avl = remove_int(avl, 263);
+  avl = gpr_avl_add(avl, box(1009), box(1835), nullptr);
+  avl = remove_int(avl, 480);
+  avl = remove_int(avl, 778);
+  avl = remove_int(avl, 713);
+  avl = remove_int(avl, 628);
+  avl = gpr_avl_add(avl, box(803), box(1840), nullptr);
+  avl = remove_int(avl, 267);
+  avl = gpr_avl_add(avl, box(676), box(1842), nullptr);
+  avl = gpr_avl_add(avl, box(231), box(1843), nullptr);
+  avl = gpr_avl_add(avl, box(824), box(1844), nullptr);
+  avl = remove_int(avl, 961);
+  avl = gpr_avl_add(avl, box(311), box(1846), nullptr);
+  avl = gpr_avl_add(avl, box(420), box(1847), nullptr);
+  avl = gpr_avl_add(avl, box(960), box(1848), nullptr);
+  avl = gpr_avl_add(avl, box(468), box(1849), nullptr);
+  avl = gpr_avl_add(avl, box(815), box(1850), nullptr);
+  avl = remove_int(avl, 247);
+  avl = remove_int(avl, 194);
+  avl = gpr_avl_add(avl, box(546), box(1853), nullptr);
+  avl = remove_int(avl, 222);
+  avl = remove_int(avl, 914);
+  avl = remove_int(avl, 741);
+  avl = gpr_avl_add(avl, box(470), box(1857), nullptr);
+  avl = gpr_avl_add(avl, box(933), box(1858), nullptr);
+  avl = gpr_avl_add(avl, box(97), box(1859), nullptr);
+  avl = remove_int(avl, 564);
+  avl = remove_int(avl, 295);
+  avl = gpr_avl_add(avl, box(864), box(1862), nullptr);
+  avl = remove_int(avl, 329);
+  avl = gpr_avl_add(avl, box(124), box(1864), nullptr);
+  avl = gpr_avl_add(avl, box(1000), box(1865), nullptr);
+  avl = gpr_avl_add(avl, box(228), box(1866), nullptr);
+  avl = gpr_avl_add(avl, box(187), box(1867), nullptr);
+  avl = remove_int(avl, 224);
+  avl = remove_int(avl, 306);
+  avl = remove_int(avl, 884);
+  avl = gpr_avl_add(avl, box(449), box(1871), nullptr);
+  avl = gpr_avl_add(avl, box(353), box(1872), nullptr);
+  avl = gpr_avl_add(avl, box(994), box(1873), nullptr);
+  avl = gpr_avl_add(avl, box(596), box(1874), nullptr);
+  avl = gpr_avl_add(avl, box(996), box(1875), nullptr);
+  avl = gpr_avl_add(avl, box(101), box(1876), nullptr);
+  avl = gpr_avl_add(avl, box(1012), box(1877), nullptr);
+  avl = gpr_avl_add(avl, box(982), box(1878), nullptr);
+  avl = gpr_avl_add(avl, box(742), box(1879), nullptr);
+  avl = remove_int(avl, 92);
+  avl = remove_int(avl, 1022);
+  avl = gpr_avl_add(avl, box(941), box(1882), nullptr);
+  avl = remove_int(avl, 742);
+  avl = remove_int(avl, 919);
+  avl = gpr_avl_add(avl, box(588), box(1885), nullptr);
+  avl = remove_int(avl, 221);
+  avl = gpr_avl_add(avl, box(356), box(1887), nullptr);
+  avl = gpr_avl_add(avl, box(932), box(1888), nullptr);
+  avl = remove_int(avl, 837);
+  avl = gpr_avl_add(avl, box(394), box(1890), nullptr);
+  avl = gpr_avl_add(avl, box(642), box(1891), nullptr);
+  avl = gpr_avl_add(avl, box(52), box(1892), nullptr);
+  avl = gpr_avl_add(avl, box(437), box(1893), nullptr);
+  avl = gpr_avl_add(avl, box(948), box(1894), nullptr);
+  avl = gpr_avl_add(avl, box(93), box(1895), nullptr);
+  avl = remove_int(avl, 873);
+  avl = remove_int(avl, 336);
+  avl = remove_int(avl, 277);
+  avl = remove_int(avl, 932);
+  avl = gpr_avl_add(avl, box(80), box(1900), nullptr);
+  avl = gpr_avl_add(avl, box(952), box(1901), nullptr);
+  avl = gpr_avl_add(avl, box(510), box(1902), nullptr);
+  avl = remove_int(avl, 876);
+  avl = remove_int(avl, 612);
+  avl = gpr_avl_add(avl, box(923), box(1905), nullptr);
+  avl = gpr_avl_add(avl, box(475), box(1906), nullptr);
+  avl = remove_int(avl, 478);
+  avl = remove_int(avl, 148);
+  avl = gpr_avl_add(avl, box(538), box(1909), nullptr);
+  avl = remove_int(avl, 47);
+  avl = gpr_avl_add(avl, box(89), box(1911), nullptr);
+  avl = remove_int(avl, 723);
+  avl = gpr_avl_add(avl, box(687), box(1913), nullptr);
+  avl = gpr_avl_add(avl, box(480), box(1914), nullptr);
+  avl = gpr_avl_add(avl, box(149), box(1915), nullptr);
+  avl = remove_int(avl, 68);
+  avl = remove_int(avl, 862);
+  avl = remove_int(avl, 363);
+  avl = gpr_avl_add(avl, box(996), box(1919), nullptr);
+  avl = remove_int(avl, 380);
+  avl = gpr_avl_add(avl, box(957), box(1921), nullptr);
+  avl = remove_int(avl, 413);
+  avl = gpr_avl_add(avl, box(360), box(1923), nullptr);
+  avl = gpr_avl_add(avl, box(304), box(1924), nullptr);
+  avl = gpr_avl_add(avl, box(634), box(1925), nullptr);
+  avl = gpr_avl_add(avl, box(506), box(1926), nullptr);
+  avl = remove_int(avl, 248);
+  avl = gpr_avl_add(avl, box(124), box(1928), nullptr);
+  avl = gpr_avl_add(avl, box(181), box(1929), nullptr);
+  avl = remove_int(avl, 507);
+  avl = gpr_avl_add(avl, box(141), box(1931), nullptr);
+  avl = remove_int(avl, 409);
+  avl = remove_int(avl, 129);
+  avl = remove_int(avl, 694);
+  avl = remove_int(avl, 723);
+  avl = gpr_avl_add(avl, box(998), box(1936), nullptr);
+  avl = gpr_avl_add(avl, box(906), box(1937), nullptr);
+  avl = gpr_avl_add(avl, box(44), box(1938), nullptr);
+  avl = remove_int(avl, 949);
+  avl = remove_int(avl, 117);
+  avl = gpr_avl_add(avl, box(700), box(1941), nullptr);
+  avl = gpr_avl_add(avl, box(258), box(1942), nullptr);
+  avl = remove_int(avl, 828);
+  avl = gpr_avl_add(avl, box(860), box(1944), nullptr);
+  avl = gpr_avl_add(avl, box(987), box(1945), nullptr);
+  avl = gpr_avl_add(avl, box(316), box(1946), nullptr);
+  avl = gpr_avl_add(avl, box(919), box(1947), nullptr);
+  avl = remove_int(avl, 84);
+  avl = gpr_avl_add(avl, box(473), box(1949), nullptr);
+  avl = remove_int(avl, 127);
+  avl = remove_int(avl, 829);
+  avl = remove_int(avl, 829);
+  avl = gpr_avl_add(avl, box(488), box(1953), nullptr);
+  avl = gpr_avl_add(avl, box(954), box(1954), nullptr);
+  avl = remove_int(avl, 198);
+  avl = remove_int(avl, 972);
+  avl = remove_int(avl, 670);
+  avl = gpr_avl_add(avl, box(822), box(1958), nullptr);
+  avl = remove_int(avl, 589);
+  avl = remove_int(avl, 459);
+  avl = gpr_avl_add(avl, box(1003), box(1961), nullptr);
+  avl = gpr_avl_add(avl, box(657), box(1962), nullptr);
+  avl = gpr_avl_add(avl, box(477), box(1963), nullptr);
+  avl = gpr_avl_add(avl, box(923), box(1964), nullptr);
+  avl = remove_int(avl, 496);
+  avl = remove_int(avl, 99);
+  avl = gpr_avl_add(avl, box(127), box(1967), nullptr);
+  avl = gpr_avl_add(avl, box(1013), box(1968), nullptr);
+  avl = gpr_avl_add(avl, box(778), box(1969), nullptr);
+  avl = remove_int(avl, 5);
+  avl = remove_int(avl, 990);
+  avl = remove_int(avl, 850);
+  avl = remove_int(avl, 160);
+  avl = remove_int(avl, 86);
+  avl = gpr_avl_add(avl, box(283), box(1975), nullptr);
+  avl = remove_int(avl, 278);
+  avl = remove_int(avl, 297);
+  avl = remove_int(avl, 137);
+  avl = remove_int(avl, 653);
+  avl = gpr_avl_add(avl, box(702), box(1980), nullptr);
+  avl = remove_int(avl, 63);
+  avl = remove_int(avl, 427);
+  avl = remove_int(avl, 706);
+  avl = remove_int(avl, 806);
+  avl = gpr_avl_add(avl, box(335), box(1985), nullptr);
+  avl = gpr_avl_add(avl, box(412), box(1986), nullptr);
+  avl = remove_int(avl, 766);
+  avl = remove_int(avl, 937);
+  avl = remove_int(avl, 886);
+  avl = remove_int(avl, 652);
+  avl = gpr_avl_add(avl, box(545), box(1991), nullptr);
+  avl = gpr_avl_add(avl, box(408), box(1992), nullptr);
+  avl = gpr_avl_add(avl, box(841), box(1993), nullptr);
+  avl = remove_int(avl, 593);
+  avl = gpr_avl_add(avl, box(582), box(1995), nullptr);
+  avl = gpr_avl_add(avl, box(597), box(1996), nullptr);
+  avl = remove_int(avl, 49);
+  avl = remove_int(avl, 835);
+  avl = gpr_avl_add(avl, box(417), box(1999), nullptr);
+  avl = gpr_avl_add(avl, box(191), box(2000), nullptr);
+  avl = remove_int(avl, 406);
+  avl = gpr_avl_add(avl, box(30), box(2002), nullptr);
+  avl = remove_int(avl, 841);
+  avl = remove_int(avl, 50);
+  avl = gpr_avl_add(avl, box(967), box(2005), nullptr);
+  avl = gpr_avl_add(avl, box(849), box(2006), nullptr);
+  avl = remove_int(avl, 608);
+  avl = gpr_avl_add(avl, box(306), box(2008), nullptr);
+  avl = remove_int(avl, 779);
+  avl = gpr_avl_add(avl, box(897), box(2010), nullptr);
+  avl = gpr_avl_add(avl, box(147), box(2011), nullptr);
+  avl = remove_int(avl, 982);
+  avl = gpr_avl_add(avl, box(470), box(2013), nullptr);
+  avl = remove_int(avl, 951);
+  avl = gpr_avl_add(avl, box(388), box(2015), nullptr);
+  avl = remove_int(avl, 616);
+  avl = remove_int(avl, 721);
+  avl = remove_int(avl, 942);
+  avl = remove_int(avl, 589);
+  avl = gpr_avl_add(avl, box(218), box(2020), nullptr);
+  avl = remove_int(avl, 671);
+  avl = gpr_avl_add(avl, box(1020), box(2022), nullptr);
+  avl = remove_int(avl, 277);
+  avl = gpr_avl_add(avl, box(681), box(2024), nullptr);
+  avl = gpr_avl_add(avl, box(179), box(2025), nullptr);
+  avl = gpr_avl_add(avl, box(370), box(2026), nullptr);
+  avl = gpr_avl_add(avl, box(0), box(2027), nullptr);
+  avl = remove_int(avl, 523);
+  avl = gpr_avl_add(avl, box(99), box(2029), nullptr);
+  avl = gpr_avl_add(avl, box(334), box(2030), nullptr);
+  avl = gpr_avl_add(avl, box(569), box(2031), nullptr);
+  avl = gpr_avl_add(avl, box(257), box(2032), nullptr);
+  avl = remove_int(avl, 572);
+  avl = gpr_avl_add(avl, box(805), box(2034), nullptr);
+  avl = gpr_avl_add(avl, box(143), box(2035), nullptr);
+  avl = gpr_avl_add(avl, box(670), box(2036), nullptr);
+  avl = remove_int(avl, 42);
+  avl = gpr_avl_add(avl, box(46), box(2038), nullptr);
+  avl = remove_int(avl, 970);
+  avl = gpr_avl_add(avl, box(353), box(2040), nullptr);
+  avl = remove_int(avl, 258);
+  avl = gpr_avl_add(avl, box(451), box(2042), nullptr);
+  avl = gpr_avl_add(avl, box(28), box(2043), nullptr);
+  avl = gpr_avl_add(avl, box(729), box(2044), nullptr);
+  avl = gpr_avl_add(avl, box(401), box(2045), nullptr);
+  avl = gpr_avl_add(avl, box(614), box(2046), nullptr);
+  avl = remove_int(avl, 990);
+  avl = remove_int(avl, 212);
+  avl = remove_int(avl, 22);
+  avl = remove_int(avl, 677);
+  avl = gpr_avl_add(avl, box(1016), box(2051), nullptr);
+  avl = gpr_avl_add(avl, box(980), box(2052), nullptr);
+  avl = gpr_avl_add(avl, box(990), box(2053), nullptr);
+  avl = gpr_avl_add(avl, box(355), box(2054), nullptr);
+  avl = remove_int(avl, 730);
+  avl = remove_int(avl, 37);
+  avl = gpr_avl_add(avl, box(407), box(2057), nullptr);
+  avl = gpr_avl_add(avl, box(222), box(2058), nullptr);
+  avl = gpr_avl_add(avl, box(439), box(2059), nullptr);
+  avl = gpr_avl_add(avl, box(563), box(2060), nullptr);
+  avl = remove_int(avl, 992);
+  avl = remove_int(avl, 786);
+  avl = gpr_avl_add(avl, box(1), box(2063), nullptr);
+  avl = gpr_avl_add(avl, box(473), box(2064), nullptr);
+  avl = gpr_avl_add(avl, box(992), box(2065), nullptr);
+  avl = remove_int(avl, 190);
+  avl = remove_int(avl, 450);
+  avl = remove_int(avl, 1020);
+  avl = remove_int(avl, 149);
+  avl = gpr_avl_add(avl, box(329), box(2070), nullptr);
+  avl = gpr_avl_add(avl, box(35), box(2071), nullptr);
+  avl = remove_int(avl, 843);
+  avl = gpr_avl_add(avl, box(855), box(2073), nullptr);
+  avl = remove_int(avl, 878);
+  avl = gpr_avl_add(avl, box(993), box(2075), nullptr);
+  avl = gpr_avl_add(avl, box(87), box(2076), nullptr);
+  avl = gpr_avl_add(avl, box(572), box(2077), nullptr);
+  avl = remove_int(avl, 896);
+  avl = gpr_avl_add(avl, box(849), box(2079), nullptr);
+  avl = remove_int(avl, 597);
+  avl = gpr_avl_add(avl, box(472), box(2081), nullptr);
+  avl = remove_int(avl, 778);
+  avl = remove_int(avl, 934);
+  avl = remove_int(avl, 314);
+  avl = gpr_avl_add(avl, box(101), box(2085), nullptr);
+  avl = remove_int(avl, 938);
+  avl = remove_int(avl, 1010);
+  avl = gpr_avl_add(avl, box(579), box(2088), nullptr);
+  avl = remove_int(avl, 798);
+  avl = remove_int(avl, 88);
+  avl = gpr_avl_add(avl, box(851), box(2091), nullptr);
+  avl = remove_int(avl, 705);
+  avl = gpr_avl_add(avl, box(26), box(2093), nullptr);
+  avl = remove_int(avl, 973);
+  avl = gpr_avl_add(avl, box(923), box(2095), nullptr);
+  avl = remove_int(avl, 668);
+  avl = gpr_avl_add(avl, box(310), box(2097), nullptr);
+  avl = gpr_avl_add(avl, box(269), box(2098), nullptr);
+  avl = remove_int(avl, 173);
+  avl = gpr_avl_add(avl, box(279), box(2100), nullptr);
+  avl = remove_int(avl, 203);
+  avl = gpr_avl_add(avl, box(411), box(2102), nullptr);
+  avl = remove_int(avl, 950);
+  avl = gpr_avl_add(avl, box(6), box(2104), nullptr);
+  avl = remove_int(avl, 400);
+  avl = remove_int(avl, 468);
+  avl = remove_int(avl, 271);
+  avl = gpr_avl_add(avl, box(627), box(2108), nullptr);
+  avl = remove_int(avl, 727);
+  avl = remove_int(avl, 148);
+  avl = remove_int(avl, 98);
+  avl = remove_int(avl, 997);
+  avl = remove_int(avl, 215);
+  avl = remove_int(avl, 628);
+  avl = remove_int(avl, 826);
+  avl = remove_int(avl, 664);
+  avl = gpr_avl_add(avl, box(76), box(2117), nullptr);
+  avl = remove_int(avl, 194);
+  avl = remove_int(avl, 18);
+  avl = gpr_avl_add(avl, box(727), box(2120), nullptr);
+  avl = remove_int(avl, 295);
+  avl = gpr_avl_add(avl, box(645), box(2122), nullptr);
+  avl = remove_int(avl, 321);
+  avl = remove_int(avl, 863);
+  avl = gpr_avl_add(avl, box(824), box(2125), nullptr);
+  avl = gpr_avl_add(avl, box(651), box(2126), nullptr);
+  avl = gpr_avl_add(avl, box(804), box(2127), nullptr);
+  avl = remove_int(avl, 307);
+  avl = gpr_avl_add(avl, box(867), box(2129), nullptr);
+  avl = remove_int(avl, 384);
+  avl = gpr_avl_add(avl, box(819), box(2131), nullptr);
+  avl = remove_int(avl, 674);
+  avl = gpr_avl_add(avl, box(76), box(2133), nullptr);
+  avl = remove_int(avl, 898);
+  avl = gpr_avl_add(avl, box(45), box(2135), nullptr);
+  avl = gpr_avl_add(avl, box(512), box(2136), nullptr);
+  avl = remove_int(avl, 773);
+  avl = remove_int(avl, 907);
+  avl = remove_int(avl, 382);
+  avl = remove_int(avl, 95);
+  avl = remove_int(avl, 734);
+  avl = remove_int(avl, 81);
+  avl = gpr_avl_add(avl, box(348), box(2143), nullptr);
+  avl = remove_int(avl, 509);
+  avl = remove_int(avl, 301);
+  avl = gpr_avl_add(avl, box(861), box(2146), nullptr);
+  avl = gpr_avl_add(avl, box(918), box(2147), nullptr);
+  avl = remove_int(avl, 992);
+  avl = gpr_avl_add(avl, box(356), box(2149), nullptr);
+  avl = remove_int(avl, 64);
+  avl = remove_int(avl, 444);
+  avl = remove_int(avl, 741);
+  avl = gpr_avl_add(avl, box(710), box(2153), nullptr);
+  avl = gpr_avl_add(avl, box(264), box(2154), nullptr);
+  avl = remove_int(avl, 347);
+  avl = remove_int(avl, 250);
+  avl = gpr_avl_add(avl, box(82), box(2157), nullptr);
+  avl = gpr_avl_add(avl, box(571), box(2158), nullptr);
+  avl = remove_int(avl, 721);
+  avl = remove_int(avl, 622);
+  avl = gpr_avl_add(avl, box(950), box(2161), nullptr);
+  avl = gpr_avl_add(avl, box(94), box(2162), nullptr);
+  avl = remove_int(avl, 970);
+  avl = gpr_avl_add(avl, box(815), box(2164), nullptr);
+  avl = remove_int(avl, 930);
+  avl = remove_int(avl, 703);
+  avl = gpr_avl_add(avl, box(432), box(2167), nullptr);
+  avl = remove_int(avl, 544);
+  avl = gpr_avl_add(avl, box(21), box(2169), nullptr);
+  avl = gpr_avl_add(avl, box(186), box(2170), nullptr);
+  avl = remove_int(avl, 143);
+  avl = gpr_avl_add(avl, box(425), box(2172), nullptr);
+  avl = remove_int(avl, 769);
+  avl = gpr_avl_add(avl, box(656), box(2174), nullptr);
+  avl = remove_int(avl, 29);
+  avl = gpr_avl_add(avl, box(464), box(2176), nullptr);
+  avl = remove_int(avl, 713);
+  avl = gpr_avl_add(avl, box(800), box(2178), nullptr);
+  avl = remove_int(avl, 621);
+  avl = gpr_avl_add(avl, box(962), box(2180), nullptr);
+  avl = remove_int(avl, 448);
+  avl = gpr_avl_add(avl, box(878), box(2182), nullptr);
+  avl = remove_int(avl, 39);
+  avl = remove_int(avl, 999);
+  avl = gpr_avl_add(avl, box(182), box(2185), nullptr);
+  avl = gpr_avl_add(avl, box(429), box(2186), nullptr);
+  avl = gpr_avl_add(avl, box(598), box(2187), nullptr);
+  avl = remove_int(avl, 551);
+  avl = gpr_avl_add(avl, box(827), box(2189), nullptr);
+  avl = gpr_avl_add(avl, box(809), box(2190), nullptr);
+  avl = remove_int(avl, 438);
+  avl = remove_int(avl, 811);
+  avl = gpr_avl_add(avl, box(808), box(2193), nullptr);
+  avl = gpr_avl_add(avl, box(788), box(2194), nullptr);
+  avl = remove_int(avl, 156);
+  avl = gpr_avl_add(avl, box(933), box(2196), nullptr);
+  avl = gpr_avl_add(avl, box(344), box(2197), nullptr);
+  avl = remove_int(avl, 460);
+  avl = gpr_avl_add(avl, box(161), box(2199), nullptr);
+  avl = gpr_avl_add(avl, box(444), box(2200), nullptr);
+  avl = remove_int(avl, 597);
+  avl = remove_int(avl, 668);
+  avl = gpr_avl_add(avl, box(703), box(2203), nullptr);
+  avl = remove_int(avl, 515);
+  avl = gpr_avl_add(avl, box(380), box(2205), nullptr);
+  avl = gpr_avl_add(avl, box(338), box(2206), nullptr);
+  avl = remove_int(avl, 550);
+  avl = remove_int(avl, 946);
+  avl = remove_int(avl, 714);
+  avl = remove_int(avl, 739);
+  avl = gpr_avl_add(avl, box(413), box(2211), nullptr);
+  avl = remove_int(avl, 450);
+  avl = gpr_avl_add(avl, box(411), box(2213), nullptr);
+  avl = gpr_avl_add(avl, box(117), box(2214), nullptr);
+  avl = gpr_avl_add(avl, box(322), box(2215), nullptr);
+  avl = gpr_avl_add(avl, box(915), box(2216), nullptr);
+  avl = gpr_avl_add(avl, box(410), box(2217), nullptr);
+  avl = gpr_avl_add(avl, box(66), box(2218), nullptr);
+  avl = remove_int(avl, 756);
+  avl = remove_int(avl, 596);
+  avl = gpr_avl_add(avl, box(882), box(2221), nullptr);
+  avl = gpr_avl_add(avl, box(930), box(2222), nullptr);
+  avl = gpr_avl_add(avl, box(36), box(2223), nullptr);
+  avl = remove_int(avl, 742);
+  avl = gpr_avl_add(avl, box(539), box(2225), nullptr);
+  avl = gpr_avl_add(avl, box(596), box(2226), nullptr);
+  avl = remove_int(avl, 82);
+  avl = remove_int(avl, 686);
+  avl = remove_int(avl, 933);
+  avl = remove_int(avl, 42);
+  avl = remove_int(avl, 340);
+  avl = gpr_avl_add(avl, box(126), box(2232), nullptr);
+  avl = gpr_avl_add(avl, box(493), box(2233), nullptr);
+  avl = gpr_avl_add(avl, box(839), box(2234), nullptr);
+  avl = remove_int(avl, 774);
+  avl = gpr_avl_add(avl, box(337), box(2236), nullptr);
+  avl = remove_int(avl, 322);
+  avl = gpr_avl_add(avl, box(16), box(2238), nullptr);
+  avl = remove_int(avl, 73);
+  avl = remove_int(avl, 85);
+  avl = remove_int(avl, 191);
+  avl = remove_int(avl, 541);
+  avl = gpr_avl_add(avl, box(704), box(2243), nullptr);
+  avl = remove_int(avl, 767);
+  avl = remove_int(avl, 1006);
+  avl = remove_int(avl, 844);
+  avl = remove_int(avl, 742);
+  avl = gpr_avl_add(avl, box(48), box(2248), nullptr);
+  avl = gpr_avl_add(avl, box(138), box(2249), nullptr);
+  avl = gpr_avl_add(avl, box(437), box(2250), nullptr);
+  avl = gpr_avl_add(avl, box(275), box(2251), nullptr);
+  avl = remove_int(avl, 520);
+  avl = gpr_avl_add(avl, box(1019), box(2253), nullptr);
+  avl = remove_int(avl, 955);
+  avl = gpr_avl_add(avl, box(270), box(2255), nullptr);
+  avl = remove_int(avl, 680);
+  avl = remove_int(avl, 698);
+  avl = gpr_avl_add(avl, box(735), box(2258), nullptr);
+  avl = gpr_avl_add(avl, box(400), box(2259), nullptr);
+  avl = remove_int(avl, 991);
+  avl = gpr_avl_add(avl, box(263), box(2261), nullptr);
+  avl = remove_int(avl, 704);
+  avl = gpr_avl_add(avl, box(757), box(2263), nullptr);
+  avl = remove_int(avl, 194);
+  avl = remove_int(avl, 616);
+  avl = remove_int(avl, 784);
+  avl = gpr_avl_add(avl, box(382), box(2267), nullptr);
+  avl = gpr_avl_add(avl, box(464), box(2268), nullptr);
+  avl = gpr_avl_add(avl, box(817), box(2269), nullptr);
+  avl = remove_int(avl, 445);
+  avl = gpr_avl_add(avl, box(412), box(2271), nullptr);
+  avl = remove_int(avl, 525);
+  avl = gpr_avl_add(avl, box(299), box(2273), nullptr);
+  avl = gpr_avl_add(avl, box(464), box(2274), nullptr);
+  avl = gpr_avl_add(avl, box(715), box(2275), nullptr);
+  avl = remove_int(avl, 58);
+  avl = remove_int(avl, 218);
+  avl = gpr_avl_add(avl, box(961), box(2278), nullptr);
+  avl = gpr_avl_add(avl, box(491), box(2279), nullptr);
+  avl = remove_int(avl, 846);
+  avl = gpr_avl_add(avl, box(762), box(2281), nullptr);
+  avl = remove_int(avl, 974);
+  avl = remove_int(avl, 887);
+  avl = gpr_avl_add(avl, box(498), box(2284), nullptr);
+  avl = remove_int(avl, 810);
+  avl = remove_int(avl, 743);
+  avl = remove_int(avl, 22);
+  avl = remove_int(avl, 284);
+  avl = gpr_avl_add(avl, box(482), box(2289), nullptr);
+  avl = gpr_avl_add(avl, box(1021), box(2290), nullptr);
+  avl = remove_int(avl, 155);
+  avl = remove_int(avl, 128);
+  avl = gpr_avl_add(avl, box(819), box(2293), nullptr);
+  avl = gpr_avl_add(avl, box(324), box(2294), nullptr);
+  avl = remove_int(avl, 196);
+  avl = remove_int(avl, 370);
+  avl = remove_int(avl, 753);
+  avl = remove_int(avl, 56);
+  avl = remove_int(avl, 735);
+  avl = gpr_avl_add(avl, box(272), box(2300), nullptr);
+  avl = gpr_avl_add(avl, box(474), box(2301), nullptr);
+  avl = gpr_avl_add(avl, box(719), box(2302), nullptr);
+  avl = gpr_avl_add(avl, box(236), box(2303), nullptr);
+  avl = remove_int(avl, 818);
+  avl = gpr_avl_add(avl, box(727), box(2305), nullptr);
+  avl = remove_int(avl, 892);
+  avl = remove_int(avl, 871);
+  avl = remove_int(avl, 231);
+  avl = gpr_avl_add(avl, box(62), box(2309), nullptr);
+  avl = gpr_avl_add(avl, box(953), box(2310), nullptr);
+  avl = remove_int(avl, 701);
+  avl = gpr_avl_add(avl, box(193), box(2312), nullptr);
+  avl = remove_int(avl, 619);
+  avl = remove_int(avl, 22);
+  avl = remove_int(avl, 804);
+  avl = remove_int(avl, 851);
+  avl = gpr_avl_add(avl, box(286), box(2317), nullptr);
+  avl = gpr_avl_add(avl, box(751), box(2318), nullptr);
+  avl = remove_int(avl, 525);
+  avl = gpr_avl_add(avl, box(217), box(2320), nullptr);
+  avl = remove_int(avl, 336);
+  avl = gpr_avl_add(avl, box(86), box(2322), nullptr);
+  avl = gpr_avl_add(avl, box(81), box(2323), nullptr);
+  avl = gpr_avl_add(avl, box(850), box(2324), nullptr);
+  avl = remove_int(avl, 872);
+  avl = gpr_avl_add(avl, box(402), box(2326), nullptr);
+  avl = gpr_avl_add(avl, box(54), box(2327), nullptr);
+  avl = gpr_avl_add(avl, box(980), box(2328), nullptr);
+  avl = gpr_avl_add(avl, box(845), box(2329), nullptr);
+  avl = remove_int(avl, 1004);
+  avl = remove_int(avl, 273);
+  avl = remove_int(avl, 879);
+  avl = gpr_avl_add(avl, box(354), box(2333), nullptr);
+  avl = gpr_avl_add(avl, box(58), box(2334), nullptr);
+  avl = gpr_avl_add(avl, box(127), box(2335), nullptr);
+  avl = remove_int(avl, 84);
+  avl = gpr_avl_add(avl, box(360), box(2337), nullptr);
+  avl = remove_int(avl, 648);
+  avl = remove_int(avl, 488);
+  avl = remove_int(avl, 585);
+  avl = remove_int(avl, 230);
+  avl = gpr_avl_add(avl, box(887), box(2342), nullptr);
+  avl = remove_int(avl, 558);
+  avl = remove_int(avl, 958);
+  avl = gpr_avl_add(avl, box(822), box(2345), nullptr);
+  avl = remove_int(avl, 1004);
+  avl = remove_int(avl, 747);
+  avl = gpr_avl_add(avl, box(631), box(2348), nullptr);
+  avl = gpr_avl_add(avl, box(442), box(2349), nullptr);
+  avl = remove_int(avl, 957);
+  avl = remove_int(avl, 964);
+  avl = gpr_avl_add(avl, box(10), box(2352), nullptr);
+  avl = remove_int(avl, 189);
+  avl = gpr_avl_add(avl, box(742), box(2354), nullptr);
+  avl = remove_int(avl, 108);
+  avl = gpr_avl_add(avl, box(1014), box(2356), nullptr);
+  avl = remove_int(avl, 266);
+  avl = remove_int(avl, 623);
+  avl = remove_int(avl, 697);
+  avl = gpr_avl_add(avl, box(180), box(2360), nullptr);
+  avl = remove_int(avl, 472);
+  avl = gpr_avl_add(avl, box(567), box(2362), nullptr);
+  avl = remove_int(avl, 1020);
+  avl = remove_int(avl, 273);
+  avl = gpr_avl_add(avl, box(864), box(2365), nullptr);
+  avl = gpr_avl_add(avl, box(1009), box(2366), nullptr);
+  avl = remove_int(avl, 224);
+  avl = remove_int(avl, 81);
+  avl = gpr_avl_add(avl, box(653), box(2369), nullptr);
+  avl = remove_int(avl, 67);
+  avl = remove_int(avl, 102);
+  avl = remove_int(avl, 76);
+  avl = remove_int(avl, 935);
+  avl = remove_int(avl, 169);
+  avl = remove_int(avl, 232);
+  avl = remove_int(avl, 79);
+  avl = gpr_avl_add(avl, box(509), box(2377), nullptr);
+  avl = remove_int(avl, 900);
+  avl = remove_int(avl, 822);
+  avl = remove_int(avl, 945);
+  avl = remove_int(avl, 356);
+  avl = gpr_avl_add(avl, box(443), box(2382), nullptr);
+  avl = gpr_avl_add(avl, box(925), box(2383), nullptr);
+  avl = remove_int(avl, 994);
+  avl = remove_int(avl, 324);
+  avl = gpr_avl_add(avl, box(291), box(2386), nullptr);
+  avl = remove_int(avl, 94);
+  avl = remove_int(avl, 795);
+  avl = remove_int(avl, 42);
+  avl = gpr_avl_add(avl, box(613), box(2390), nullptr);
+  avl = remove_int(avl, 289);
+  avl = gpr_avl_add(avl, box(980), box(2392), nullptr);
+  avl = remove_int(avl, 316);
+  avl = gpr_avl_add(avl, box(281), box(2394), nullptr);
+  avl = gpr_avl_add(avl, box(1006), box(2395), nullptr);
+  avl = remove_int(avl, 776);
+  avl = gpr_avl_add(avl, box(108), box(2397), nullptr);
+  avl = gpr_avl_add(avl, box(918), box(2398), nullptr);
+  avl = remove_int(avl, 721);
+  avl = remove_int(avl, 563);
+  avl = gpr_avl_add(avl, box(925), box(2401), nullptr);
+  avl = remove_int(avl, 448);
+  avl = remove_int(avl, 198);
+  avl = remove_int(avl, 1);
+  avl = gpr_avl_add(avl, box(160), box(2405), nullptr);
+  avl = remove_int(avl, 515);
+  avl = gpr_avl_add(avl, box(284), box(2407), nullptr);
+  avl = gpr_avl_add(avl, box(225), box(2408), nullptr);
+  avl = remove_int(avl, 304);
+  avl = gpr_avl_add(avl, box(714), box(2410), nullptr);
+  avl = gpr_avl_add(avl, box(708), box(2411), nullptr);
+  avl = gpr_avl_add(avl, box(624), box(2412), nullptr);
+  avl = remove_int(avl, 662);
+  avl = remove_int(avl, 825);
+  avl = remove_int(avl, 383);
+  avl = remove_int(avl, 381);
+  avl = gpr_avl_add(avl, box(194), box(2417), nullptr);
+  avl = remove_int(avl, 280);
+  avl = remove_int(avl, 25);
+  avl = remove_int(avl, 633);
+  avl = gpr_avl_add(avl, box(897), box(2421), nullptr);
+  avl = remove_int(avl, 636);
+  avl = remove_int(avl, 596);
+  avl = remove_int(avl, 757);
+  avl = remove_int(avl, 343);
+  avl = remove_int(avl, 162);
+  avl = remove_int(avl, 913);
+  avl = remove_int(avl, 843);
+  avl = remove_int(avl, 280);
+  avl = remove_int(avl, 911);
+  avl = gpr_avl_add(avl, box(1008), box(2431), nullptr);
+  avl = remove_int(avl, 948);
+  avl = remove_int(avl, 74);
+  avl = remove_int(avl, 571);
+  avl = gpr_avl_add(avl, box(486), box(2435), nullptr);
+  avl = gpr_avl_add(avl, box(285), box(2436), nullptr);
+  avl = remove_int(avl, 304);
+  avl = remove_int(avl, 516);
+  avl = gpr_avl_add(avl, box(758), box(2439), nullptr);
+  avl = gpr_avl_add(avl, box(776), box(2440), nullptr);
+  avl = remove_int(avl, 696);
+  avl = gpr_avl_add(avl, box(104), box(2442), nullptr);
+  avl = gpr_avl_add(avl, box(700), box(2443), nullptr);
+  avl = gpr_avl_add(avl, box(114), box(2444), nullptr);
+  avl = gpr_avl_add(avl, box(567), box(2445), nullptr);
+  avl = remove_int(avl, 620);
+  avl = gpr_avl_add(avl, box(270), box(2447), nullptr);
+  avl = remove_int(avl, 730);
+  avl = gpr_avl_add(avl, box(749), box(2449), nullptr);
+  avl = gpr_avl_add(avl, box(443), box(2450), nullptr);
+  avl = remove_int(avl, 457);
+  avl = gpr_avl_add(avl, box(571), box(2452), nullptr);
+  avl = gpr_avl_add(avl, box(626), box(2453), nullptr);
+  avl = remove_int(avl, 638);
+  avl = remove_int(avl, 313);
+
+  gpr_avl_unref(avl, nullptr);
+}
+
+static void test_stress(int amount_of_stress) {
+  int added[1024];
+  int i, j;
+  int deletions = 0;
+  gpr_avl avl;
+
+  unsigned seed = (unsigned)time(nullptr);
+
+  gpr_log(GPR_DEBUG, "test_stress amount=%d seed=%u", amount_of_stress, seed);
+
+  srand((unsigned)time(nullptr));
+  avl = gpr_avl_create(&int_int_vtable);
+
+  memset(added, 0, sizeof(added));
+
+  for (i = 1; deletions < amount_of_stress; i++) {
+    int idx = rand() % (int)GPR_ARRAY_SIZE(added);
+    GPR_ASSERT(i);
+    if (rand() < RAND_MAX / 2) {
+      added[idx] = i;
+      printf("avl = gpr_avl_add(avl, box(%d), box(%d), NULL); /* d=%d */\n",
+             idx, i, deletions);
+      avl = gpr_avl_add(avl, box(idx), box(i), nullptr);
+    } else {
+      deletions += (added[idx] != 0);
+      added[idx] = 0;
+      printf("avl = remove_int(avl, %d); /* d=%d */\n", idx, deletions);
+      avl = remove_int(avl, idx);
+    }
+    for (j = 0; j < (int)GPR_ARRAY_SIZE(added); j++) {
+      if (added[j] != 0) {
+        check_get(avl, j, added[j]);
+      } else {
+        check_negget(avl, j);
+      }
+    }
+  }
+
+  gpr_avl_unref(avl, nullptr);
+}
+
+int main(int argc, char* argv[]) {
+  grpc_test_init(argc, argv);
+
+  test_get();
+  test_ll();
+  test_lr();
+  test_rr();
+  test_rl();
+  test_unbalanced();
+  test_replace();
+  test_remove();
+  test_badcase1();
+  test_badcase2();
+  test_badcase3();
+  test_stress(10);
+
+  return 0;
+}
diff --git a/test/core/support/cmdline_test.c b/test/core/support/cmdline_test.cc
index 72e7c7f9fc..172efda8a0 100644
--- a/test/core/support/cmdline_test.c
+++ b/test/core/support/cmdline_test.cc
@@ -29,13 +29,14 @@
 
 static void test_simple_int(void) {
   int x = 1;
-  gpr_cmdline *cl;
-  char *args[] = {(char *)__FILE__, "-foo", "3"};
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("-foo"),
+                  const_cast<char*>("3")};
 
   LOG_TEST();
 
-  cl = gpr_cmdline_create(NULL);
-  gpr_cmdline_add_int(cl, "foo", NULL, &x);
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_int(cl, "foo", nullptr, &x);
   GPR_ASSERT(x == 1);
   gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
   GPR_ASSERT(x == 3);
@@ -44,13 +45,13 @@ static void test_simple_int(void) {
 
 static void test_eq_int(void) {
   int x = 1;
-  gpr_cmdline *cl;
-  char *args[] = {(char *)__FILE__, "-foo=3"};
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("-foo=3")};
 
   LOG_TEST();
 
-  cl = gpr_cmdline_create(NULL);
-  gpr_cmdline_add_int(cl, "foo", NULL, &x);
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_int(cl, "foo", nullptr, &x);
   GPR_ASSERT(x == 1);
   gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
   GPR_ASSERT(x == 3);
@@ -59,13 +60,14 @@ static void test_eq_int(void) {
 
 static void test_2dash_int(void) {
   int x = 1;
-  gpr_cmdline *cl;
-  char *args[] = {(char *)__FILE__, "--foo", "3"};
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("--foo"),
+                  const_cast<char*>("3")};
 
   LOG_TEST();
 
-  cl = gpr_cmdline_create(NULL);
-  gpr_cmdline_add_int(cl, "foo", NULL, &x);
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_int(cl, "foo", nullptr, &x);
   GPR_ASSERT(x == 1);
   gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
   GPR_ASSERT(x == 3);
@@ -74,13 +76,13 @@ static void test_2dash_int(void) {
 
 static void test_2dash_eq_int(void) {
   int x = 1;
-  gpr_cmdline *cl;
-  char *args[] = {(char *)__FILE__, "--foo=3"};
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("--foo=3")};
 
   LOG_TEST();
 
-  cl = gpr_cmdline_create(NULL);
-  gpr_cmdline_add_int(cl, "foo", NULL, &x);
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_int(cl, "foo", nullptr, &x);
   GPR_ASSERT(x == 1);
   gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
   GPR_ASSERT(x == 3);
@@ -88,60 +90,62 @@ static void test_2dash_eq_int(void) {
 }
 
 static void test_simple_string(void) {
-  char *x = NULL;
-  gpr_cmdline *cl;
-  char *args[] = {(char *)__FILE__, "-foo", "3"};
+  const char* x = nullptr;
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("-foo"),
+                  const_cast<char*>("3")};
 
   LOG_TEST();
 
-  cl = gpr_cmdline_create(NULL);
-  gpr_cmdline_add_string(cl, "foo", NULL, &x);
-  GPR_ASSERT(x == NULL);
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_string(cl, "foo", nullptr, &x);
+  GPR_ASSERT(x == nullptr);
   gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
   GPR_ASSERT(0 == strcmp(x, "3"));
   gpr_cmdline_destroy(cl);
 }
 
 static void test_eq_string(void) {
-  char *x = NULL;
-  gpr_cmdline *cl;
-  char *args[] = {(char *)__FILE__, "-foo=3"};
+  const char* x = nullptr;
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("-foo=3")};
 
   LOG_TEST();
 
-  cl = gpr_cmdline_create(NULL);
-  gpr_cmdline_add_string(cl, "foo", NULL, &x);
-  GPR_ASSERT(x == NULL);
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_string(cl, "foo", nullptr, &x);
+  GPR_ASSERT(x == nullptr);
   gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
   GPR_ASSERT(0 == strcmp(x, "3"));
   gpr_cmdline_destroy(cl);
 }
 
 static void test_2dash_string(void) {
-  char *x = NULL;
-  gpr_cmdline *cl;
-  char *args[] = {(char *)__FILE__, "--foo", "3"};
+  const char* x = nullptr;
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("--foo"),
+                  const_cast<char*>("3")};
 
   LOG_TEST();
 
-  cl = gpr_cmdline_create(NULL);
-  gpr_cmdline_add_string(cl, "foo", NULL, &x);
-  GPR_ASSERT(x == NULL);
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_string(cl, "foo", nullptr, &x);
+  GPR_ASSERT(x == nullptr);
   gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
   GPR_ASSERT(0 == strcmp(x, "3"));
   gpr_cmdline_destroy(cl);
 }
 
 static void test_2dash_eq_string(void) {
-  char *x = NULL;
-  gpr_cmdline *cl;
-  char *args[] = {(char *)__FILE__, "--foo=3"};
+  const char* x = nullptr;
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("--foo=3")};
 
   LOG_TEST();
 
-  cl = gpr_cmdline_create(NULL);
-  gpr_cmdline_add_string(cl, "foo", NULL, &x);
-  GPR_ASSERT(x == NULL);
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_string(cl, "foo", nullptr, &x);
+  GPR_ASSERT(x == nullptr);
   gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
   GPR_ASSERT(0 == strcmp(x, "3"));
   gpr_cmdline_destroy(cl);
@@ -149,13 +153,13 @@ static void test_2dash_eq_string(void) {
 
 static void test_flag_on(void) {
   int x = 2;
-  gpr_cmdline *cl;
-  char *args[] = {(char *)__FILE__, "--foo"};
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("--foo")};
 
   LOG_TEST();
 
-  cl = gpr_cmdline_create(NULL);
-  gpr_cmdline_add_flag(cl, "foo", NULL, &x);
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_flag(cl, "foo", nullptr, &x);
   GPR_ASSERT(x == 2);
   gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
   GPR_ASSERT(x == 1);
@@ -164,13 +168,13 @@ static void test_flag_on(void) {
 
 static void test_flag_no(void) {
   int x = 2;
-  gpr_cmdline *cl;
-  char *args[] = {(char *)__FILE__, "--no-foo"};
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("--no-foo")};
 
   LOG_TEST();
 
-  cl = gpr_cmdline_create(NULL);
-  gpr_cmdline_add_flag(cl, "foo", NULL, &x);
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_flag(cl, "foo", nullptr, &x);
   GPR_ASSERT(x == 2);
   gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
   GPR_ASSERT(x == 0);
@@ -179,13 +183,13 @@ static void test_flag_no(void) {
 
 static void test_flag_val_1(void) {
   int x = 2;
-  gpr_cmdline *cl;
-  char *args[] = {(char *)__FILE__, "--foo=1"};
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("--foo=1")};
 
   LOG_TEST();
 
-  cl = gpr_cmdline_create(NULL);
-  gpr_cmdline_add_flag(cl, "foo", NULL, &x);
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_flag(cl, "foo", nullptr, &x);
   GPR_ASSERT(x == 2);
   gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
   GPR_ASSERT(x == 1);
@@ -194,13 +198,13 @@ static void test_flag_val_1(void) {
 
 static void test_flag_val_0(void) {
   int x = 2;
-  gpr_cmdline *cl;
-  char *args[] = {(char *)__FILE__, "--foo=0"};
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("--foo=0")};
 
   LOG_TEST();
 
-  cl = gpr_cmdline_create(NULL);
-  gpr_cmdline_add_flag(cl, "foo", NULL, &x);
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_flag(cl, "foo", nullptr, &x);
   GPR_ASSERT(x == 2);
   gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
   GPR_ASSERT(x == 0);
@@ -209,13 +213,13 @@ static void test_flag_val_0(void) {
 
 static void test_flag_val_true(void) {
   int x = 2;
-  gpr_cmdline *cl;
-  char *args[] = {(char *)__FILE__, "--foo=true"};
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("--foo=true")};
 
   LOG_TEST();
 
-  cl = gpr_cmdline_create(NULL);
-  gpr_cmdline_add_flag(cl, "foo", NULL, &x);
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_flag(cl, "foo", nullptr, &x);
   GPR_ASSERT(x == 2);
   gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
   GPR_ASSERT(x == 1);
@@ -224,13 +228,13 @@ static void test_flag_val_true(void) {
 
 static void test_flag_val_false(void) {
   int x = 2;
-  gpr_cmdline *cl;
-  char *args[] = {(char *)__FILE__, "--foo=false"};
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("--foo=false")};
 
   LOG_TEST();
 
-  cl = gpr_cmdline_create(NULL);
-  gpr_cmdline_add_flag(cl, "foo", NULL, &x);
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_flag(cl, "foo", nullptr, &x);
   GPR_ASSERT(x == 2);
   gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
   GPR_ASSERT(x == 0);
@@ -238,19 +242,21 @@ static void test_flag_val_false(void) {
 }
 
 static void test_many(void) {
-  char *str = NULL;
+  const char* str = nullptr;
   int x = 0;
   int flag = 2;
-  gpr_cmdline *cl;
+  gpr_cmdline* cl;
 
-  char *args[] = {(char *)__FILE__, "--str", "hello", "-x=4", "-no-flag"};
+  char* args[] = {(char*)__FILE__, const_cast<char*>("--str"),
+                  const_cast<char*>("hello"), const_cast<char*>("-x=4"),
+                  const_cast<char*>("-no-flag")};
 
   LOG_TEST();
 
-  cl = gpr_cmdline_create(NULL);
-  gpr_cmdline_add_string(cl, "str", NULL, &str);
-  gpr_cmdline_add_int(cl, "x", NULL, &x);
-  gpr_cmdline_add_flag(cl, "flag", NULL, &flag);
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_string(cl, "str", nullptr, &str);
+  gpr_cmdline_add_int(cl, "x", nullptr, &x);
+  gpr_cmdline_add_flag(cl, "flag", nullptr, &flag);
   gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
   GPR_ASSERT(x == 4);
   GPR_ASSERT(0 == strcmp(str, "hello"));
@@ -258,22 +264,23 @@ static void test_many(void) {
   gpr_cmdline_destroy(cl);
 }
 
-static void extra_arg_cb(void *user_data, const char *arg) {
-  int *count = user_data;
-  GPR_ASSERT(arg != NULL);
+static void extra_arg_cb(void* user_data, const char* arg) {
+  int* count = static_cast<int*>(user_data);
+  GPR_ASSERT(arg != nullptr);
   GPR_ASSERT(strlen(arg) == 1);
   GPR_ASSERT(arg[0] == 'a' + *count);
   ++*count;
 }
 
 static void test_extra(void) {
-  gpr_cmdline *cl;
+  gpr_cmdline* cl;
   int count = 0;
-  char *args[] = {(char *)__FILE__, "a", "b", "c"};
+  char* args[] = {(char*)__FILE__, const_cast<char*>("a"),
+                  const_cast<char*>("b"), const_cast<char*>("c")};
 
   LOG_TEST();
 
-  cl = gpr_cmdline_create(NULL);
+  cl = gpr_cmdline_create(nullptr);
   gpr_cmdline_on_extra_arg(cl, "file", "filenames to process", extra_arg_cb,
                            &count);
   gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
@@ -282,13 +289,15 @@ static void test_extra(void) {
 }
 
 static void test_extra_dashdash(void) {
-  gpr_cmdline *cl;
+  gpr_cmdline* cl;
   int count = 0;
-  char *args[] = {(char *)__FILE__, "--", "a", "b", "c"};
+  char* args[] = {(char*)__FILE__, const_cast<char*>("--"),
+                  const_cast<char*>("a"), const_cast<char*>("b"),
+                  const_cast<char*>("c")};
 
   LOG_TEST();
 
-  cl = gpr_cmdline_create(NULL);
+  cl = gpr_cmdline_create(nullptr);
   gpr_cmdline_on_extra_arg(cl, "file", "filenames to process", extra_arg_cb,
                            &count);
   gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
@@ -297,21 +306,21 @@ static void test_extra_dashdash(void) {
 }
 
 static void test_usage(void) {
-  gpr_cmdline *cl;
-  char *usage;
+  gpr_cmdline* cl;
+  char* usage;
 
-  char *str = NULL;
+  const char* str = nullptr;
   int x = 0;
   int flag = 2;
 
   LOG_TEST();
 
-  cl = gpr_cmdline_create(NULL);
-  gpr_cmdline_add_string(cl, "str", NULL, &str);
-  gpr_cmdline_add_int(cl, "x", NULL, &x);
-  gpr_cmdline_add_flag(cl, "flag", NULL, &flag);
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_string(cl, "str", nullptr, &str);
+  gpr_cmdline_add_int(cl, "x", nullptr, &x);
+  gpr_cmdline_add_flag(cl, "flag", nullptr, &flag);
   gpr_cmdline_on_extra_arg(cl, "file", "filenames to process", extra_arg_cb,
-                           NULL);
+                           nullptr);
 
   usage = gpr_cmdline_usage_string(cl, "test");
   GPR_ASSERT(0 == strcmp(usage,
@@ -329,23 +338,23 @@ static void test_usage(void) {
 }
 
 static void test_help(void) {
-  gpr_cmdline *cl;
+  gpr_cmdline* cl;
 
-  char *str = NULL;
+  const char* str = nullptr;
   int x = 0;
   int flag = 2;
 
-  char *help[] = {(char *)__FILE__, "-h"};
+  char* help[] = {(char*)__FILE__, const_cast<char*>("-h")};
 
   LOG_TEST();
 
-  cl = gpr_cmdline_create(NULL);
+  cl = gpr_cmdline_create(nullptr);
   gpr_cmdline_set_survive_failure(cl);
-  gpr_cmdline_add_string(cl, "str", NULL, &str);
-  gpr_cmdline_add_int(cl, "x", NULL, &x);
-  gpr_cmdline_add_flag(cl, "flag", NULL, &flag);
+  gpr_cmdline_add_string(cl, "str", nullptr, &str);
+  gpr_cmdline_add_int(cl, "x", nullptr, &x);
+  gpr_cmdline_add_flag(cl, "flag", nullptr, &flag);
   gpr_cmdline_on_extra_arg(cl, "file", "filenames to process", extra_arg_cb,
-                           NULL);
+                           nullptr);
 
   GPR_ASSERT(0 == gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(help), help));
 
@@ -353,23 +362,23 @@ static void test_help(void) {
 }
 
 static void test_badargs1(void) {
-  gpr_cmdline *cl;
+  gpr_cmdline* cl;
 
-  char *str = NULL;
+  const char* str = nullptr;
   int x = 0;
   int flag = 2;
 
-  char *bad_arg_name[] = {(char *)__FILE__, "--y"};
+  char* bad_arg_name[] = {(char*)__FILE__, const_cast<char*>("--y")};
 
   LOG_TEST();
 
-  cl = gpr_cmdline_create(NULL);
+  cl = gpr_cmdline_create(nullptr);
   gpr_cmdline_set_survive_failure(cl);
-  gpr_cmdline_add_string(cl, "str", NULL, &str);
-  gpr_cmdline_add_int(cl, "x", NULL, &x);
-  gpr_cmdline_add_flag(cl, "flag", NULL, &flag);
+  gpr_cmdline_add_string(cl, "str", nullptr, &str);
+  gpr_cmdline_add_int(cl, "x", nullptr, &x);
+  gpr_cmdline_add_flag(cl, "flag", nullptr, &flag);
   gpr_cmdline_on_extra_arg(cl, "file", "filenames to process", extra_arg_cb,
-                           NULL);
+                           nullptr);
 
   GPR_ASSERT(0 ==
              gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(bad_arg_name), bad_arg_name));
@@ -378,23 +387,24 @@ static void test_badargs1(void) {
 }
 
 static void test_badargs2(void) {
-  gpr_cmdline *cl;
+  gpr_cmdline* cl;
 
-  char *str = NULL;
+  const char* str = nullptr;
   int x = 0;
   int flag = 2;
 
-  char *bad_int_value[] = {(char *)__FILE__, "--x", "henry"};
+  char* bad_int_value[] = {(char*)__FILE__, const_cast<char*>("--x"),
+                           const_cast<char*>("henry")};
 
   LOG_TEST();
 
-  cl = gpr_cmdline_create(NULL);
+  cl = gpr_cmdline_create(nullptr);
   gpr_cmdline_set_survive_failure(cl);
-  gpr_cmdline_add_string(cl, "str", NULL, &str);
-  gpr_cmdline_add_int(cl, "x", NULL, &x);
-  gpr_cmdline_add_flag(cl, "flag", NULL, &flag);
+  gpr_cmdline_add_string(cl, "str", nullptr, &str);
+  gpr_cmdline_add_int(cl, "x", nullptr, &x);
+  gpr_cmdline_add_flag(cl, "flag", nullptr, &flag);
   gpr_cmdline_on_extra_arg(cl, "file", "filenames to process", extra_arg_cb,
-                           NULL);
+                           nullptr);
 
   GPR_ASSERT(
       0 == gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(bad_int_value), bad_int_value));
@@ -403,23 +413,23 @@ static void test_badargs2(void) {
 }
 
 static void test_badargs3(void) {
-  gpr_cmdline *cl;
+  gpr_cmdline* cl;
 
-  char *str = NULL;
+  const char* str = nullptr;
   int x = 0;
   int flag = 2;
 
-  char *bad_bool_value[] = {(char *)__FILE__, "--flag=henry"};
+  char* bad_bool_value[] = {(char*)__FILE__, const_cast<char*>("--flag=henry")};
 
   LOG_TEST();
 
-  cl = gpr_cmdline_create(NULL);
+  cl = gpr_cmdline_create(nullptr);
   gpr_cmdline_set_survive_failure(cl);
-  gpr_cmdline_add_string(cl, "str", NULL, &str);
-  gpr_cmdline_add_int(cl, "x", NULL, &x);
-  gpr_cmdline_add_flag(cl, "flag", NULL, &flag);
+  gpr_cmdline_add_string(cl, "str", nullptr, &str);
+  gpr_cmdline_add_int(cl, "x", nullptr, &x);
+  gpr_cmdline_add_flag(cl, "flag", nullptr, &flag);
   gpr_cmdline_on_extra_arg(cl, "file", "filenames to process", extra_arg_cb,
-                           NULL);
+                           nullptr);
 
   GPR_ASSERT(0 == gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(bad_bool_value),
                                     bad_bool_value));
@@ -428,23 +438,23 @@ static void test_badargs3(void) {
 }
 
 static void test_badargs4(void) {
-  gpr_cmdline *cl;
+  gpr_cmdline* cl;
 
-  char *str = NULL;
+  const char* str = nullptr;
   int x = 0;
   int flag = 2;
 
-  char *bad_bool_value[] = {(char *)__FILE__, "--no-str"};
+  char* bad_bool_value[] = {(char*)__FILE__, const_cast<char*>("--no-str")};
 
   LOG_TEST();
 
-  cl = gpr_cmdline_create(NULL);
+  cl = gpr_cmdline_create(nullptr);
   gpr_cmdline_set_survive_failure(cl);
-  gpr_cmdline_add_string(cl, "str", NULL, &str);
-  gpr_cmdline_add_int(cl, "x", NULL, &x);
-  gpr_cmdline_add_flag(cl, "flag", NULL, &flag);
+  gpr_cmdline_add_string(cl, "str", nullptr, &str);
+  gpr_cmdline_add_int(cl, "x", nullptr, &x);
+  gpr_cmdline_add_flag(cl, "flag", nullptr, &flag);
   gpr_cmdline_on_extra_arg(cl, "file", "filenames to process", extra_arg_cb,
-                           NULL);
+                           nullptr);
 
   GPR_ASSERT(0 == gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(bad_bool_value),
                                     bad_bool_value));
@@ -452,7 +462,7 @@ static void test_badargs4(void) {
   gpr_cmdline_destroy(cl);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_simple_int();
   test_eq_int();
diff --git a/test/core/support/cpu_test.c b/test/core/support/cpu_test.cc
index 72db53fa49..1783ec3c60 100644
--- a/test/core/support/cpu_test.c
+++ b/test/core/support/cpu_test.cc
@@ -57,18 +57,18 @@ struct cpu_test {
   uint32_t ncores;
   int is_done;
   gpr_cv done_cv;
-  int *used;  /* is this core used? */
+  int* used;  /* is this core used? */
   unsigned r; /* random number */
 };
 
-static void worker_thread(void *arg) {
-  struct cpu_test *ct = (struct cpu_test *)arg;
+static void worker_thread(void* arg) {
+  struct cpu_test* ct = (struct cpu_test*)arg;
   uint32_t cpu;
   unsigned r = 12345678;
   unsigned i, j;
   /* Avoid repetitive division calculations */
   int64_t max_i = 1000 / grpc_test_slowdown_factor();
-  int64_t max_j = 1000000 / grpc_test_slowdown_factor();
+  int64_t max_j = 1000 / grpc_test_slowdown_factor();
   for (i = 0; i < max_i; i++) {
     /* run for a bit - just calculate something random. */
     for (j = 0; j < max_j; j++) {
@@ -104,13 +104,13 @@ static void cpu_test(void) {
   ct.ncores = gpr_cpu_num_cores();
   GPR_ASSERT(ct.ncores > 0);
   ct.nthreads = (int)ct.ncores * 3;
-  ct.used = gpr_malloc(ct.ncores * sizeof(int));
+  ct.used = static_cast<int*>(gpr_malloc(ct.ncores * sizeof(int)));
   memset(ct.used, 0, ct.ncores * sizeof(int));
   gpr_mu_init(&ct.mu);
   gpr_cv_init(&ct.done_cv);
   ct.is_done = 0;
   for (i = 0; i < ct.ncores * 3; i++) {
-    GPR_ASSERT(gpr_thd_new(&thd, &worker_thread, &ct, NULL));
+    GPR_ASSERT(gpr_thd_new(&thd, &worker_thread, &ct, nullptr));
   }
   gpr_mu_lock(&ct.mu);
   while (!ct.is_done) {
@@ -128,7 +128,7 @@ static void cpu_test(void) {
   gpr_free(ct.used);
 }
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
   grpc_test_init(argc, argv);
   cpu_test();
   return 0;
diff --git a/test/core/support/env_test.c b/test/core/support/env_test.cc
index 661a546720..b12c04d06f 100644
--- a/test/core/support/env_test.c
+++ b/test/core/support/env_test.cc
@@ -29,20 +29,20 @@
 #define LOG_TEST_NAME(x) gpr_log(GPR_INFO, "%s", x)
 
 static void test_setenv_getenv(void) {
-  const char *name = "FOO";
-  const char *value = "BAR";
-  char *retrieved_value;
+  const char* name = "FOO";
+  const char* value = "BAR";
+  char* retrieved_value;
 
   LOG_TEST_NAME("test_setenv_getenv");
 
   gpr_setenv(name, value);
   retrieved_value = gpr_getenv(name);
-  GPR_ASSERT(retrieved_value != NULL);
+  GPR_ASSERT(retrieved_value != nullptr);
   GPR_ASSERT(strcmp(value, retrieved_value) == 0);
   gpr_free(retrieved_value);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_setenv_getenv();
   return 0;
diff --git a/test/core/support/histogram_test.c b/test/core/support/histogram_test.cc
index 0ee5d5cdd1..86b7d599e6 100644
--- a/test/core/support/histogram_test.c
+++ b/test/core/support/histogram_test.cc
@@ -25,7 +25,7 @@ static void test_no_op(void) {
   gpr_histogram_destroy(gpr_histogram_create(0.01, 60e9));
 }
 
-static void expect_percentile(gpr_histogram *h, double percentile,
+static void expect_percentile(gpr_histogram* h, double percentile,
                               double min_expect, double max_expect) {
   double got = gpr_histogram_percentile(h, percentile);
   gpr_log(GPR_INFO, "@%f%%, expect %f <= %f <= %f", percentile, min_expect, got,
@@ -35,7 +35,7 @@ static void expect_percentile(gpr_histogram *h, double percentile,
 }
 
 static void test_simple(void) {
-  gpr_histogram *h;
+  gpr_histogram* h;
 
   LOG_TEST("test_simple");
 
@@ -52,7 +52,7 @@ static void test_simple(void) {
 }
 
 static void test_percentile(void) {
-  gpr_histogram *h;
+  gpr_histogram* h;
   double last;
   double i;
   double cur;
diff --git a/test/core/support/host_port_test.c b/test/core/support/host_port_test.cc
index 2ff3bcf68e..42dd56524f 100644
--- a/test/core/support/host_port_test.c
+++ b/test/core/support/host_port_test.cc
@@ -23,9 +23,9 @@
 #include <grpc/support/log.h>
 #include "test/core/util/test_config.h"
 
-static void join_host_port_expect(const char *host, int port,
-                                  const char *expected) {
-  char *buf;
+static void join_host_port_expect(const char* host, int port,
+                                  const char* expected) {
+  char* buf;
   int len;
   len = gpr_join_host_port(&buf, host, port);
   GPR_ASSERT(len >= 0);
@@ -48,7 +48,7 @@ static void test_join_host_port_garbage(void) {
   join_host_port_expect("::]", 107, "[::]]:107");
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
 
   test_join_host_port();
diff --git a/test/core/support/log_test.c b/test/core/support/log_test.cc
index c221ff6783..7dba35c13e 100644
--- a/test/core/support/log_test.c
+++ b/test/core/support/log_test.cc
@@ -26,17 +26,17 @@
 
 static bool log_func_reached = false;
 
-static void test_callback(gpr_log_func_args *args) {
+static void test_callback(gpr_log_func_args* args) {
   GPR_ASSERT(0 == strcmp(__FILE__, args->file));
   GPR_ASSERT(args->severity == GPR_LOG_SEVERITY_INFO);
   GPR_ASSERT(0 == strcmp(args->message, "hello 1 2 3"));
 }
 
-static void test_should_log(gpr_log_func_args *args) {
+static void test_should_log(gpr_log_func_args* args) {
   log_func_reached = true;
 }
 
-static void test_should_not_log(gpr_log_func_args *args) { GPR_ASSERT(false); }
+static void test_should_not_log(gpr_log_func_args* args) { GPR_ASSERT(false); }
 
 #define test_log_function_reached(SEVERITY)     \
   gpr_set_log_function(test_should_log);        \
@@ -52,7 +52,7 @@ static void test_should_not_log(gpr_log_func_args *args) { GPR_ASSERT(false); }
   gpr_log_message(SEVERITY, "hello 1 2 3");   \
   gpr_log(SEVERITY, "hello %d %d %d", 1, 2, 3);
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   /* test logging at various verbosity levels */
   gpr_log(GPR_DEBUG, "%s", "hello world");
@@ -63,7 +63,7 @@ int main(int argc, char **argv) {
   gpr_set_log_function(test_callback);
   gpr_log_message(GPR_INFO, "hello 1 2 3");
   gpr_log(GPR_INFO, "hello %d %d %d", 1, 2, 3);
-  gpr_set_log_function(NULL);
+  gpr_set_log_function(nullptr);
 
   /* gpr_log_verbosity_init() will be effective only once, and only before
    * gpr_set_log_verbosity() is called */
diff --git a/test/core/support/manual_constructor_test.cc b/test/core/support/manual_constructor_test.cc
new file mode 100644
index 0000000000..714f8b21a0
--- /dev/null
+++ b/test/core/support/manual_constructor_test.cc
@@ -0,0 +1,99 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/* Test of gpr synchronization support. */
+
+#include "src/core/lib/support/manual_constructor.h"
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/thd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <cstring>
+#include "src/core/lib/support/abstract.h"
+#include "test/core/util/test_config.h"
+
+class A {
+ public:
+  A() {}
+  virtual ~A() {}
+  virtual const char* foo() { return "A_foo"; }
+  virtual const char* bar() { return "A_bar"; }
+  GRPC_ABSTRACT_BASE_CLASS
+};
+
+class B : public A {
+ public:
+  B() {}
+  ~B() {}
+  const char* foo() override { return "B_foo"; }
+  char get_junk() { return junk[0]; }
+
+ private:
+  char junk[1000];
+};
+
+class C : public B {
+ public:
+  C() {}
+  ~C() {}
+  virtual const char* bar() { return "C_bar"; }
+  char get_more_junk() { return more_junk[0]; }
+
+ private:
+  char more_junk[1000];
+};
+
+class D : public A {
+ public:
+  virtual const char* bar() { return "D_bar"; }
+};
+
+static void basic_test() {
+  grpc_core::PolymorphicManualConstructor<A, B> poly;
+  poly.Init<B>();
+  GPR_ASSERT(!strcmp(poly->foo(), "B_foo"));
+  GPR_ASSERT(!strcmp(poly->bar(), "A_bar"));
+}
+
+static void complex_test() {
+  grpc_core::PolymorphicManualConstructor<A, B, C, D> polyB;
+  polyB.Init<B>();
+  GPR_ASSERT(!strcmp(polyB->foo(), "B_foo"));
+  GPR_ASSERT(!strcmp(polyB->bar(), "A_bar"));
+
+  grpc_core::PolymorphicManualConstructor<A, B, C, D> polyC;
+  polyC.Init<C>();
+  GPR_ASSERT(!strcmp(polyC->foo(), "B_foo"));
+  GPR_ASSERT(!strcmp(polyC->bar(), "C_bar"));
+
+  grpc_core::PolymorphicManualConstructor<A, B, C, D> polyD;
+  polyD.Init<D>();
+  GPR_ASSERT(!strcmp(polyD->foo(), "A_foo"));
+  GPR_ASSERT(!strcmp(polyD->bar(), "D_bar"));
+}
+
+/* ------------------------------------------------- */
+
+int main(int argc, char* argv[]) {
+  grpc_test_init(argc, argv);
+  basic_test();
+  complex_test();
+  return 0;
+}
diff --git a/test/core/support/mpscq_test.c b/test/core/support/mpscq_test.cc
index 5e7dc9fca5..50ff8174f6 100644
--- a/test/core/support/mpscq_test.c
+++ b/test/core/support/mpscq_test.cc
@@ -30,11 +30,11 @@
 typedef struct test_node {
   gpr_mpscq_node node;
   size_t i;
-  size_t *ctr;
+  size_t* ctr;
 } test_node;
 
-static test_node *new_node(size_t i, size_t *ctr) {
-  test_node *n = gpr_malloc(sizeof(test_node));
+static test_node* new_node(size_t i, size_t* ctr) {
+  test_node* n = static_cast<test_node*>(gpr_malloc(sizeof(test_node)));
   n->i = i;
   n->ctr = ctr;
   return n;
@@ -45,10 +45,10 @@ static void test_serial(void) {
   gpr_mpscq q;
   gpr_mpscq_init(&q);
   for (size_t i = 0; i < 10000000; i++) {
-    gpr_mpscq_push(&q, &new_node(i, NULL)->node);
+    gpr_mpscq_push(&q, &new_node(i, nullptr)->node);
   }
   for (size_t i = 0; i < 10000000; i++) {
-    test_node *n = (test_node *)gpr_mpscq_pop(&q);
+    test_node* n = (test_node*)gpr_mpscq_pop(&q);
     GPR_ASSERT(n);
     GPR_ASSERT(n->i == i);
     gpr_free(n);
@@ -57,14 +57,14 @@ static void test_serial(void) {
 
 typedef struct {
   size_t ctr;
-  gpr_mpscq *q;
-  gpr_event *start;
+  gpr_mpscq* q;
+  gpr_event* start;
 } thd_args;
 
 #define THREAD_ITERATIONS 10000
 
-static void test_thread(void *args) {
-  thd_args *a = args;
+static void test_thread(void* args) {
+  thd_args* a = static_cast<thd_args*>(args);
   gpr_event_wait(a->start, gpr_inf_future(GPR_CLOCK_REALTIME));
   for (size_t i = 1; i <= THREAD_ITERATIONS; i++) {
     gpr_mpscq_push(a->q, &new_node(i, &a->ctr)->node);
@@ -89,13 +89,13 @@ static void test_mt(void) {
   }
   size_t num_done = 0;
   size_t spins = 0;
-  gpr_event_set(&start, (void *)1);
+  gpr_event_set(&start, (void*)1);
   while (num_done != GPR_ARRAY_SIZE(thds)) {
-    gpr_mpscq_node *n;
-    while ((n = gpr_mpscq_pop(&q)) == NULL) {
+    gpr_mpscq_node* n;
+    while ((n = gpr_mpscq_pop(&q)) == nullptr) {
       spins++;
     }
-    test_node *tn = (test_node *)n;
+    test_node* tn = (test_node*)n;
     GPR_ASSERT(*tn->ctr == tn->i - 1);
     *tn->ctr = tn->i;
     if (tn->i == THREAD_ITERATIONS) num_done++;
@@ -109,17 +109,17 @@ static void test_mt(void) {
 }
 
 typedef struct {
-  thd_args *ta;
+  thd_args* ta;
   size_t num_thds;
   gpr_mu mu;
   size_t num_done;
   size_t spins;
-  gpr_mpscq *q;
-  gpr_event *start;
+  gpr_mpscq* q;
+  gpr_event* start;
 } pull_args;
 
-static void pull_thread(void *arg) {
-  pull_args *pa = arg;
+static void pull_thread(void* arg) {
+  pull_args* pa = static_cast<pull_args*>(arg);
   gpr_event_wait(pa->start, gpr_inf_future(GPR_CLOCK_REALTIME));
 
   for (;;) {
@@ -128,11 +128,11 @@ static void pull_thread(void *arg) {
       gpr_mu_unlock(&pa->mu);
       return;
     }
-    gpr_mpscq_node *n;
-    while ((n = gpr_mpscq_pop(pa->q)) == NULL) {
+    gpr_mpscq_node* n;
+    while ((n = gpr_mpscq_pop(pa->q)) == nullptr) {
       pa->spins++;
     }
-    test_node *tn = (test_node *)n;
+    test_node* tn = (test_node*)n;
     GPR_ASSERT(*tn->ctr == tn->i - 1);
     *tn->ctr = tn->i;
     if (tn->i == THREAD_ITERATIONS) pa->num_done++;
@@ -171,7 +171,7 @@ static void test_mt_multipop(void) {
     gpr_thd_options_set_joinable(&options);
     GPR_ASSERT(gpr_thd_new(&pull_thds[i], pull_thread, &pa, &options));
   }
-  gpr_event_set(&start, (void *)1);
+  gpr_event_set(&start, (void*)1);
   for (size_t i = 0; i < GPR_ARRAY_SIZE(pull_thds); i++) {
     gpr_thd_join(pull_thds[i]);
   }
@@ -182,7 +182,7 @@ static void test_mt_multipop(void) {
   gpr_mpscq_destroy(&q);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_serial();
   test_mt();
diff --git a/test/core/support/murmur_hash_test.c b/test/core/support/murmur_hash_test.cc
index 5677515d04..461c728951 100644
--- a/test/core/support/murmur_hash_test.c
+++ b/test/core/support/murmur_hash_test.cc
@@ -23,7 +23,7 @@
 
 #include <string.h>
 
-typedef uint32_t (*hash_func)(const void *key, size_t len, uint32_t seed);
+typedef uint32_t (*hash_func)(const void* key, size_t len, uint32_t seed);
 
 /* From smhasher:
    This should hopefully be a thorough and uambiguous test of whether a hash
@@ -63,7 +63,7 @@ static void verification_test(hash_func hash, uint32_t expected) {
   }
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   /* basic tests to verify that things don't crash */
   gpr_murmur_hash3("", 0, 0);
diff --git a/test/core/support/spinlock_test.c b/test/core/support/spinlock_test.cc
index b236a88ab7..3639802cd7 100644
--- a/test/core/support/spinlock_test.c
+++ b/test/core/support/spinlock_test.cc
@@ -32,7 +32,7 @@
 /* Tests for gpr_spinlock. */
 struct test {
   int thread_count; /* number of threads */
-  gpr_thd_id *threads;
+  gpr_thd_id* threads;
 
   int64_t iterations; /* number of iterations per thread */
   int64_t counter;
@@ -42,10 +42,11 @@ struct test {
 };
 
 /* Return pointer to a new struct test. */
-static struct test *test_new(int threads, int64_t iterations, int incr_step) {
-  struct test *m = gpr_malloc(sizeof(*m));
+static struct test* test_new(int threads, int64_t iterations, int incr_step) {
+  struct test* m = static_cast<struct test*>(gpr_malloc(sizeof(*m)));
   m->thread_count = threads;
-  m->threads = gpr_malloc(sizeof(*m->threads) * (size_t)threads);
+  m->threads = static_cast<gpr_thd_id*>(
+      gpr_malloc(sizeof(*m->threads) * (size_t)threads));
   m->iterations = iterations;
   m->counter = 0;
   m->thread_count = 0;
@@ -55,13 +56,13 @@ static struct test *test_new(int threads, int64_t iterations, int incr_step) {
 }
 
 /* Return pointer to a new struct test. */
-static void test_destroy(struct test *m) {
+static void test_destroy(struct test* m) {
   gpr_free(m->threads);
   gpr_free(m);
 }
 
 /* Create m->threads threads, each running (*body)(m) */
-static void test_create_threads(struct test *m, void (*body)(void *arg)) {
+static void test_create_threads(struct test* m, void (*body)(void* arg)) {
   int i;
   for (i = 0; i != m->thread_count; i++) {
     gpr_thd_options opt = gpr_thd_options_default();
@@ -71,7 +72,7 @@ static void test_create_threads(struct test *m, void (*body)(void *arg)) {
 }
 
 /* Wait until all threads report done. */
-static void test_wait(struct test *m) {
+static void test_wait(struct test* m) {
   int i;
   for (i = 0; i != m->thread_count; i++) {
     gpr_thd_join(m->threads[i]);
@@ -84,10 +85,10 @@ static void test_wait(struct test *m) {
    incr_step controls by how much m->refcount should be incremented/decremented
    (if at all) each time in the tests.
    */
-static void test(const char *name, void (*body)(void *m), int timeout_s,
+static void test(const char* name, void (*body)(void* m), int timeout_s,
                  int incr_step) {
   int64_t iterations = 1024;
-  struct test *m;
+  struct test* m;
   gpr_timespec start = gpr_now(GPR_CLOCK_REALTIME);
   gpr_timespec time_taken;
   gpr_timespec deadline = gpr_time_add(
@@ -112,8 +113,8 @@ static void test(const char *name, void (*body)(void *m), int timeout_s,
 }
 
 /* Increment m->counter on each iteration; then mark thread as done.  */
-static void inc(void *v /*=m*/) {
-  struct test *m = v;
+static void inc(void* v /*=m*/) {
+  struct test* m = static_cast<struct test*>(v);
   int64_t i;
   for (i = 0; i != m->iterations; i++) {
     gpr_spinlock_lock(&m->mu);
@@ -124,8 +125,8 @@ static void inc(void *v /*=m*/) {
 
 /* Increment m->counter under lock acquired with trylock, m->iterations times;
    then mark thread as done.  */
-static void inctry(void *v /*=m*/) {
-  struct test *m = v;
+static void inctry(void* v /*=m*/) {
+  struct test* m = static_cast<struct test*>(v);
   int64_t i;
   for (i = 0; i != m->iterations;) {
     if (gpr_spinlock_trylock(&m->mu)) {
@@ -138,7 +139,7 @@ static void inctry(void *v /*=m*/) {
 
 /* ------------------------------------------------- */
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
   grpc_test_init(argc, argv);
   test("spinlock", &inc, 1, 1);
   test("spinlock try", &inctry, 1, 1);
diff --git a/test/core/support/stack_lockfree_test.c b/test/core/support/stack_lockfree_test.cc
index 4b1f60ce01..e6d0c9b795 100644
--- a/test/core/support/stack_lockfree_test.c
+++ b/test/core/support/stack_lockfree_test.cc
@@ -32,7 +32,7 @@
 #define MAX_THREADS 32
 
 static void test_serial_sized(size_t size) {
-  gpr_stack_lockfree *stack = gpr_stack_lockfree_create(size);
+  gpr_stack_lockfree* stack = gpr_stack_lockfree_create(size);
   size_t i;
   size_t j;
 
@@ -67,15 +67,15 @@ static void test_serial() {
 }
 
 struct test_arg {
-  gpr_stack_lockfree *stack;
+  gpr_stack_lockfree* stack;
   int stack_size;
   int nthreads;
   int rank;
   int sum;
 };
 
-static void test_mt_body(void *v) {
-  struct test_arg *arg = (struct test_arg *)v;
+static void test_mt_body(void* v) {
+  struct test_arg* arg = (struct test_arg*)v;
   int lo, hi;
   int i;
   int res;
@@ -93,7 +93,7 @@ static void test_mt_body(void *v) {
 }
 
 static void test_mt_sized(size_t size, int nth) {
-  gpr_stack_lockfree *stack;
+  gpr_stack_lockfree* stack;
   struct test_arg args[MAX_THREADS];
   gpr_thd_id thds[MAX_THREADS];
   int sum;
@@ -132,7 +132,7 @@ static void test_mt() {
   }
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_serial();
   test_mt();
diff --git a/test/core/support/string_test.c b/test/core/support/string_test.cc
index bee2139477..fd7f7cde59 100644
--- a/test/core/support/string_test.c
+++ b/test/core/support/string_test.cc
@@ -32,8 +32,8 @@
 #define LOG_TEST_NAME(x) gpr_log(GPR_INFO, "%s", x)
 
 static void test_strdup(void) {
-  static const char *src1 = "hello world";
-  char *dst1;
+  static const char* src1 = "hello world";
+  char* dst1;
 
   LOG_TEST_NAME("test_strdup");
 
@@ -41,12 +41,12 @@ static void test_strdup(void) {
   GPR_ASSERT(0 == strcmp(src1, dst1));
   gpr_free(dst1);
 
-  GPR_ASSERT(NULL == gpr_strdup(NULL));
+  GPR_ASSERT(nullptr == gpr_strdup(nullptr));
 }
 
-static void expect_dump(const char *buf, size_t len, uint32_t flags,
-                        const char *result) {
-  char *got = gpr_dump(buf, len, flags);
+static void expect_dump(const char* buf, size_t len, uint32_t flags,
+                        const char* result) {
+  char* got = gpr_dump(buf, len, flags);
   GPR_ASSERT(0 == strcmp(got, result));
   gpr_free(got);
 }
@@ -61,12 +61,12 @@ static void test_dump(void) {
   expect_dump("ab", 2, GPR_DUMP_HEX | GPR_DUMP_ASCII, "61 62 'ab'");
 }
 
-static void test_pu32_fail(const char *s) {
+static void test_pu32_fail(const char* s) {
   uint32_t out;
   GPR_ASSERT(!gpr_parse_bytes_to_uint32(s, strlen(s), &out));
 }
 
-static void test_pu32_succeed(const char *s, uint32_t want) {
+static void test_pu32_succeed(const char* s, uint32_t want) {
   uint32_t out;
   GPR_ASSERT(gpr_parse_bytes_to_uint32(s, strlen(s), &out));
   GPR_ASSERT(out == want);
@@ -107,7 +107,7 @@ static void test_parse_uint32(void) {
 }
 
 static void test_asprintf(void) {
-  char *buf;
+  char* buf;
   int i, j;
 
   LOG_TEST_NAME("test_asprintf");
@@ -132,9 +132,9 @@ static void test_asprintf(void) {
 }
 
 static void test_strjoin(void) {
-  const char *parts[4] = {"one", "two", "three", "four"};
+  const char* parts[4] = {"one", "two", "three", "four"};
   size_t joined_len;
-  char *joined;
+  char* joined;
 
   LOG_TEST_NAME("test_strjoin");
 
@@ -152,9 +152,9 @@ static void test_strjoin(void) {
 }
 
 static void test_strjoin_sep(void) {
-  const char *parts[4] = {"one", "two", "three", "four"};
+  const char* parts[4] = {"one", "two", "three", "four"};
   size_t joined_len;
-  char *joined;
+  char* joined;
 
   LOG_TEST_NAME("test_strjoin_sep");
 
@@ -179,7 +179,7 @@ static void test_strjoin_sep(void) {
 }
 
 static void test_ltoa() {
-  char *str;
+  char* str;
   char buf[GPR_LTOA_MIN_BUFSIZE];
 
   LOG_TEST_NAME("test_ltoa");
@@ -226,7 +226,7 @@ static void test_int64toa() {
 }
 
 static void test_leftpad() {
-  char *padded;
+  char* padded;
 
   LOG_TEST_NAME("test_leftpad");
 
@@ -271,12 +271,12 @@ static void test_stricmp(void) {
 static void test_memrchr(void) {
   LOG_TEST_NAME("test_memrchr");
 
-  GPR_ASSERT(NULL == gpr_memrchr(NULL, 'a', 0));
-  GPR_ASSERT(NULL == gpr_memrchr("", 'a', 0));
-  GPR_ASSERT(NULL == gpr_memrchr("hello", 'b', 5));
-  GPR_ASSERT(0 == strcmp((const char *)gpr_memrchr("hello", 'h', 5), "hello"));
-  GPR_ASSERT(0 == strcmp((const char *)gpr_memrchr("hello", 'o', 5), "o"));
-  GPR_ASSERT(0 == strcmp((const char *)gpr_memrchr("hello", 'l', 5), "lo"));
+  GPR_ASSERT(nullptr == gpr_memrchr(nullptr, 'a', 0));
+  GPR_ASSERT(nullptr == gpr_memrchr("", 'a', 0));
+  GPR_ASSERT(nullptr == gpr_memrchr("hello", 'b', 5));
+  GPR_ASSERT(0 == strcmp((const char*)gpr_memrchr("hello", 'h', 5), "hello"));
+  GPR_ASSERT(0 == strcmp((const char*)gpr_memrchr("hello", 'o', 5), "o"));
+  GPR_ASSERT(0 == strcmp((const char*)gpr_memrchr("hello", 'l', 5), "lo"));
 }
 
 static void test_is_true(void) {
@@ -289,12 +289,12 @@ static void test_is_true(void) {
   GPR_ASSERT(true == gpr_is_true("yes"));
   GPR_ASSERT(true == gpr_is_true("YES"));
   GPR_ASSERT(true == gpr_is_true("1"));
-  GPR_ASSERT(false == gpr_is_true(NULL));
+  GPR_ASSERT(false == gpr_is_true(nullptr));
   GPR_ASSERT(false == gpr_is_true(""));
   GPR_ASSERT(false == gpr_is_true("0"));
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_strdup();
   test_dump();
diff --git a/test/core/support/sync_test.c b/test/core/support/sync_test.cc
index 178d77edcd..86e78ce0b5 100644
--- a/test/core/support/sync_test.c
+++ b/test/core/support/sync_test.cc
@@ -47,7 +47,7 @@ typedef struct queue {
 } queue;
 
 /* Initialize *q. */
-void queue_init(queue *q) {
+void queue_init(queue* q) {
   gpr_mu_init(&q->mu);
   gpr_cv_init(&q->non_empty);
   gpr_cv_init(&q->non_full);
@@ -56,14 +56,14 @@ void queue_init(queue *q) {
 }
 
 /* Free storage associated with *q. */
-void queue_destroy(queue *q) {
+void queue_destroy(queue* q) {
   gpr_mu_destroy(&q->mu);
   gpr_cv_destroy(&q->non_empty);
   gpr_cv_destroy(&q->non_full);
 }
 
 /* Wait until there is room in *q, then append x to *q. */
-void queue_append(queue *q, int x) {
+void queue_append(queue* q, int x) {
   gpr_mu_lock(&q->mu);
   /* To wait for a predicate without a deadline, loop on the negation of the
      predicate, and use gpr_cv_wait(..., gpr_inf_future(GPR_CLOCK_REALTIME))
@@ -87,7 +87,7 @@ void queue_append(queue *q, int x) {
 
 /* If it can be done without blocking, append x to *q and return non-zero.
    Otherwise return 0. */
-int queue_try_append(queue *q, int x) {
+int queue_try_append(queue* q, int x) {
   int result = 0;
   if (gpr_mu_trylock(&q->mu)) {
     if (q->length != N) {
@@ -106,7 +106,7 @@ int queue_try_append(queue *q, int x) {
 /* Wait until the *q is non-empty or deadline abs_deadline passes.  If the
    queue is non-empty, remove its head entry, place it in *head, and return
    non-zero.  Otherwise return 0.  */
-int queue_remove(queue *q, int *head, gpr_timespec abs_deadline) {
+int queue_remove(queue* q, int* head, gpr_timespec abs_deadline) {
   int result = 0;
   gpr_mu_lock(&q->mu);
   /* To wait for a predicate with a deadline, loop on the negation of the
@@ -156,8 +156,8 @@ struct test {
 };
 
 /* Return pointer to a new struct test. */
-static struct test *test_new(int threads, int64_t iterations, int incr_step) {
-  struct test *m = gpr_malloc(sizeof(*m));
+static struct test* test_new(int threads, int64_t iterations, int incr_step) {
+  struct test* m = static_cast<struct test*>(gpr_malloc(sizeof(*m)));
   m->threads = threads;
   m->iterations = iterations;
   m->counter = 0;
@@ -176,7 +176,7 @@ static struct test *test_new(int threads, int64_t iterations, int incr_step) {
 }
 
 /* Return pointer to a new struct test. */
-static void test_destroy(struct test *m) {
+static void test_destroy(struct test* m) {
   gpr_mu_destroy(&m->mu);
   gpr_cv_destroy(&m->cv);
   gpr_cv_destroy(&m->done_cv);
@@ -185,16 +185,16 @@ static void test_destroy(struct test *m) {
 }
 
 /* Create m->threads threads, each running (*body)(m) */
-static void test_create_threads(struct test *m, void (*body)(void *arg)) {
+static void test_create_threads(struct test* m, void (*body)(void* arg)) {
   gpr_thd_id id;
   int i;
   for (i = 0; i != m->threads; i++) {
-    GPR_ASSERT(gpr_thd_new(&id, body, m, NULL));
+    GPR_ASSERT(gpr_thd_new(&id, body, m, nullptr));
   }
 }
 
 /* Wait until all threads report done. */
-static void test_wait(struct test *m) {
+static void test_wait(struct test* m) {
   gpr_mu_lock(&m->mu);
   while (m->done != 0) {
     gpr_cv_wait(&m->done_cv, &m->mu, gpr_inf_future(GPR_CLOCK_REALTIME));
@@ -203,7 +203,7 @@ static void test_wait(struct test *m) {
 }
 
 /* Get an integer thread id in the raneg 0..threads-1 */
-static int thread_id(struct test *m) {
+static int thread_id(struct test* m) {
   int id;
   gpr_mu_lock(&m->mu);
   id = m->thread_count++;
@@ -213,7 +213,7 @@ static int thread_id(struct test *m) {
 
 /* Indicate that a thread is done, by decrementing m->done
    and signalling done_cv if m->done==0. */
-static void mark_thread_done(struct test *m) {
+static void mark_thread_done(struct test* m) {
   gpr_mu_lock(&m->mu);
   GPR_ASSERT(m->done != 0);
   m->done--;
@@ -229,10 +229,10 @@ static void mark_thread_done(struct test *m) {
    incr_step controls by how much m->refcount should be incremented/decremented
    (if at all) each time in the tests.
    */
-static void test(const char *name, void (*body)(void *m),
-                 void (*extra)(void *m), int timeout_s, int incr_step) {
+static void test(const char* name, void (*body)(void* m),
+                 void (*extra)(void* m), int timeout_s, int incr_step) {
   int64_t iterations = 1024;
-  struct test *m;
+  struct test* m;
   gpr_timespec start = gpr_now(GPR_CLOCK_REALTIME);
   gpr_timespec time_taken;
   gpr_timespec deadline = gpr_time_add(
@@ -242,9 +242,9 @@ static void test(const char *name, void (*body)(void *m),
     iterations <<= 1;
     fprintf(stderr, " %ld", (long)iterations);
     m = test_new(10, iterations, incr_step);
-    if (extra != NULL) {
+    if (extra != nullptr) {
       gpr_thd_id id;
-      GPR_ASSERT(gpr_thd_new(&id, extra, m, NULL));
+      GPR_ASSERT(gpr_thd_new(&id, extra, m, nullptr));
       m->done++; /* one more thread to wait for */
     }
     test_create_threads(m, body);
@@ -262,8 +262,8 @@ static void test(const char *name, void (*body)(void *m),
 }
 
 /* Increment m->counter on each iteration; then mark thread as done.  */
-static void inc(void *v /*=m*/) {
-  struct test *m = v;
+static void inc(void* v /*=m*/) {
+  struct test* m = static_cast<struct test*>(v);
   int64_t i;
   for (i = 0; i != m->iterations; i++) {
     gpr_mu_lock(&m->mu);
@@ -275,8 +275,8 @@ static void inc(void *v /*=m*/) {
 
 /* Increment m->counter under lock acquired with trylock, m->iterations times;
    then mark thread as done.  */
-static void inctry(void *v /*=m*/) {
-  struct test *m = v;
+static void inctry(void* v /*=m*/) {
+  struct test* m = static_cast<struct test*>(v);
   int64_t i;
   for (i = 0; i != m->iterations;) {
     if (gpr_mu_trylock(&m->mu)) {
@@ -290,8 +290,8 @@ static void inctry(void *v /*=m*/) {
 
 /* Increment counter only when (m->counter%m->threads)==m->thread_id; then mark
    thread as done.  */
-static void inc_by_turns(void *v /*=m*/) {
-  struct test *m = v;
+static void inc_by_turns(void* v /*=m*/) {
+  struct test* m = static_cast<struct test*>(v);
   int64_t i;
   int id = thread_id(m);
   for (i = 0; i != m->iterations; i++) {
@@ -308,8 +308,8 @@ static void inc_by_turns(void *v /*=m*/) {
 
 /* Wait a millisecond and increment counter on each iteration;
    then mark thread as done. */
-static void inc_with_1ms_delay(void *v /*=m*/) {
-  struct test *m = v;
+static void inc_with_1ms_delay(void* v /*=m*/) {
+  struct test* m = static_cast<struct test*>(v);
   int64_t i;
   for (i = 0; i != m->iterations; i++) {
     gpr_timespec deadline;
@@ -326,14 +326,14 @@ static void inc_with_1ms_delay(void *v /*=m*/) {
 
 /* Wait a millisecond and increment counter on each iteration, using an event
    for timing; then mark thread as done. */
-static void inc_with_1ms_delay_event(void *v /*=m*/) {
-  struct test *m = v;
+static void inc_with_1ms_delay_event(void* v /*=m*/) {
+  struct test* m = static_cast<struct test*>(v);
   int64_t i;
   for (i = 0; i != m->iterations; i++) {
     gpr_timespec deadline;
     deadline = gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
                             gpr_time_from_micros(1000, GPR_TIMESPAN));
-    GPR_ASSERT(gpr_event_wait(&m->event, deadline) == NULL);
+    GPR_ASSERT(gpr_event_wait(&m->event, deadline) == nullptr);
     gpr_mu_lock(&m->mu);
     m->counter++;
     gpr_mu_unlock(&m->mu);
@@ -344,8 +344,8 @@ static void inc_with_1ms_delay_event(void *v /*=m*/) {
 /* Produce m->iterations elements on queue m->q, then mark thread as done.
    Even threads use queue_append(), and odd threads use queue_try_append()
    until it succeeds. */
-static void many_producers(void *v /*=m*/) {
-  struct test *m = v;
+static void many_producers(void* v /*=m*/) {
+  struct test* m = static_cast<struct test*>(v);
   int64_t i;
   int x = thread_id(m);
   if ((x & 1) == 0) {
@@ -364,8 +364,8 @@ static void many_producers(void *v /*=m*/) {
 /* Consume elements from m->q until m->threads*m->iterations are seen,
    wait an extra second to confirm that no more elements are arriving,
    then mark thread as done. */
-static void consumer(void *v /*=m*/) {
-  struct test *m = v;
+static void consumer(void* v /*=m*/) {
+  struct test* m = static_cast<struct test*>(v);
   int64_t n = m->iterations * m->threads;
   int64_t i;
   int value;
@@ -384,8 +384,8 @@ static void consumer(void *v /*=m*/) {
 
 /* Increment m->stats_counter m->iterations times, transfer counter value to
    m->counter, then mark thread as done.  */
-static void statsinc(void *v /*=m*/) {
-  struct test *m = v;
+static void statsinc(void* v /*=m*/) {
+  struct test* m = static_cast<struct test*>(v);
   int64_t i;
   for (i = 0; i != m->iterations; i++) {
     gpr_stats_inc(&m->stats_counter, 1);
@@ -399,8 +399,8 @@ static void statsinc(void *v /*=m*/) {
 /* Increment m->refcount by m->incr_step for m->iterations times. Decrement
    m->thread_refcount once, and if it reaches zero, set m->event to (void*)1;
    then mark thread as done.  */
-static void refinc(void *v /*=m*/) {
-  struct test *m = v;
+static void refinc(void* v /*=m*/) {
+  struct test* m = static_cast<struct test*>(v);
   int64_t i;
   for (i = 0; i != m->iterations; i++) {
     if (m->incr_step == 1) {
@@ -410,7 +410,7 @@ static void refinc(void *v /*=m*/) {
     }
   }
   if (gpr_unref(&m->thread_refcount)) {
-    gpr_event_set(&m->event, (void *)1);
+    gpr_event_set(&m->event, (void*)1);
   }
   mark_thread_done(m);
 }
@@ -418,13 +418,13 @@ static void refinc(void *v /*=m*/) {
 /* Wait until m->event is set to (void *)1, then decrement m->refcount by 1
    (m->threads * m->iterations * m->incr_step) times, and ensure that the last
    decrement caused the counter to reach zero, then mark thread as done.  */
-static void refcheck(void *v /*=m*/) {
-  struct test *m = v;
+static void refcheck(void* v /*=m*/) {
+  struct test* m = static_cast<struct test*>(v);
   int64_t n = m->iterations * m->threads * m->incr_step;
   int64_t i;
   GPR_ASSERT(gpr_event_wait(&m->event, gpr_inf_future(GPR_CLOCK_REALTIME)) ==
-             (void *)1);
-  GPR_ASSERT(gpr_event_get(&m->event) == (void *)1);
+             (void*)1);
+  GPR_ASSERT(gpr_event_get(&m->event) == (void*)1);
   for (i = 1; i != n; i++) {
     GPR_ASSERT(!gpr_unref(&m->refcount));
     m->counter++;
@@ -436,18 +436,18 @@ static void refcheck(void *v /*=m*/) {
 
 /* ------------------------------------------------- */
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
   grpc_test_init(argc, argv);
-  test("mutex", &inc, NULL, 1, 1);
-  test("mutex try", &inctry, NULL, 1, 1);
-  test("cv", &inc_by_turns, NULL, 1, 1);
-  test("timedcv", &inc_with_1ms_delay, NULL, 1, 1);
+  test("mutex", &inc, nullptr, 1, 1);
+  test("mutex try", &inctry, nullptr, 1, 1);
+  test("cv", &inc_by_turns, nullptr, 1, 1);
+  test("timedcv", &inc_with_1ms_delay, nullptr, 1, 1);
   test("queue", &many_producers, &consumer, 10, 1);
-  test("stats_counter", &statsinc, NULL, 1, 1);
+  test("stats_counter", &statsinc, nullptr, 1, 1);
   test("refcount by 1", &refinc, &refcheck, 1, 1);
   test("refcount by 3", &refinc, &refcheck, 1, 3); /* incr_step of 3 is an
                                                       arbitrary choice. Any
                                                       number > 1 is okay here */
-  test("timedevent", &inc_with_1ms_delay_event, NULL, 1, 1);
+  test("timedevent", &inc_with_1ms_delay_event, nullptr, 1, 1);
   return 0;
 }
diff --git a/test/core/support/thd_test.c b/test/core/support/thd_test.cc
index 2c578a242c..34befd80d1 100644
--- a/test/core/support/thd_test.c
+++ b/test/core/support/thd_test.cc
@@ -36,8 +36,8 @@ struct test {
 };
 
 /* A Thread body.   Decrement t->n, and if is becomes zero, set t->done. */
-static void thd_body(void *v) {
-  struct test *t = v;
+static void thd_body(void* v) {
+  struct test* t = static_cast<struct test*>(v);
   gpr_mu_lock(&t->mu);
   t->n--;
   if (t->n == 0) {
@@ -47,7 +47,7 @@ static void thd_body(void *v) {
   gpr_mu_unlock(&t->mu);
 }
 
-static void thd_body_joinable(void *v) {}
+static void thd_body_joinable(void* v) {}
 
 /* Test thread options work as expected */
 static void test_options(void) {
@@ -74,7 +74,7 @@ static void test(void) {
   t.n = NUM_THREADS;
   t.is_done = 0;
   for (i = 0; i < NUM_THREADS; i++) {
-    GPR_ASSERT(gpr_thd_new(&thd, &thd_body, &t, NULL));
+    GPR_ASSERT(gpr_thd_new(&thd, &thd_body, &t, nullptr));
   }
   gpr_mu_lock(&t.mu);
   while (!t.is_done) {
@@ -84,7 +84,7 @@ static void test(void) {
   GPR_ASSERT(t.n == 0);
   gpr_thd_options_set_joinable(&options);
   for (i = 0; i < NUM_THREADS; i++) {
-    GPR_ASSERT(gpr_thd_new(&thds[i], &thd_body_joinable, NULL, &options));
+    GPR_ASSERT(gpr_thd_new(&thds[i], &thd_body_joinable, nullptr, &options));
   }
   for (i = 0; i < NUM_THREADS; i++) {
     gpr_thd_join(thds[i]);
@@ -93,7 +93,7 @@ static void test(void) {
 
 /* ------------------------------------------------- */
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
   grpc_test_init(argc, argv);
   test_options();
   test();
diff --git a/test/core/support/time_test.c b/test/core/support/time_test.cc
index 74b5ef6114..608169274f 100644
--- a/test/core/support/time_test.c
+++ b/test/core/support/time_test.cc
@@ -28,15 +28,15 @@
 #include <string.h>
 #include "test/core/util/test_config.h"
 
-static void to_fp(void *arg, const char *buf, size_t len) {
-  fwrite(buf, 1, len, (FILE *)arg);
+static void to_fp(void* arg, const char* buf, size_t len) {
+  fwrite(buf, 1, len, (FILE*)arg);
 }
 
 /* Convert gpr_intmax x to ascii base b (2..16), and write with
    (*writer)(arg, ...), zero padding to "chars" digits).  */
 static void i_to_s(intmax_t x, int base, int chars,
-                   void (*writer)(void *arg, const char *buf, size_t len),
-                   void *arg) {
+                   void (*writer)(void* arg, const char* buf, size_t len),
+                   void* arg) {
   char buf[64];
   char fmt[32];
   GPR_ASSERT(base == 16 || base == 10);
@@ -47,8 +47,8 @@ static void i_to_s(intmax_t x, int base, int chars,
 
 /* Convert ts to ascii, and write with (*writer)(arg, ...).  */
 static void ts_to_s(gpr_timespec t,
-                    void (*writer)(void *arg, const char *buf, size_t len),
-                    void *arg) {
+                    void (*writer)(void* arg, const char* buf, size_t len),
+                    void* arg) {
   if (t.tv_sec < 0 && t.tv_nsec != 0) {
     t.tv_sec++;
     t.tv_nsec = GPR_NS_PER_SEC - t.tv_nsec;
@@ -241,7 +241,7 @@ static void test_cmp_extreme(void) {
   GPR_ASSERT(gpr_time_cmp(t1, t2) == 0);
 }
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
   grpc_test_init(argc, argv);
 
   test_values();
diff --git a/test/core/support/tls_test.c b/test/core/support/tls_test.cc
index 5529d5cf59..0f64d2ee7c 100644
--- a/test/core/support/tls_test.c
+++ b/test/core/support/tls_test.cc
@@ -30,7 +30,7 @@
 
 GPR_TLS_DECL(test_var);
 
-static void thd_body(void *arg) {
+static void thd_body(void* arg) {
   intptr_t i;
 
   GPR_ASSERT(gpr_tls_get(&test_var) == 0);
@@ -44,7 +44,7 @@ static void thd_body(void *arg) {
 
 /* ------------------------------------------------- */
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
   gpr_thd_options opt = gpr_thd_options_default();
   int i;
   gpr_thd_id threads[NUM_THREADS];
@@ -56,7 +56,7 @@ int main(int argc, char *argv[]) {
   gpr_thd_options_set_joinable(&opt);
 
   for (i = 0; i < NUM_THREADS; i++) {
-    gpr_thd_new(&threads[i], thd_body, NULL, &opt);
+    gpr_thd_new(&threads[i], thd_body, nullptr, &opt);
   }
   for (i = 0; i < NUM_THREADS; i++) {
     gpr_thd_join(threads[i]);
diff --git a/test/core/support/useful_test.c b/test/core/support/useful_test.cc
index 2f84f485fc..2f86010d77 100644
--- a/test/core/support/useful_test.c
+++ b/test/core/support/useful_test.cc
@@ -21,7 +21,7 @@
 #include <grpc/support/useful.h>
 #include "test/core/util/test_config.h"
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   int four[4];
   int five[5];
   uint32_t bitset = 0;
diff --git a/test/core/surface/BUILD b/test/core/surface/BUILD
index 17db7737f7..6cec7feabc 100644
--- a/test/core/surface/BUILD
+++ b/test/core/surface/BUILD
@@ -20,8 +20,8 @@ grpc_package(name = "test/core/surface")
 
 grpc_cc_test(
     name = "alarm_test",
-    srcs = ["alarm_test.c"],
-    language = "C",
+    srcs = ["alarm_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -32,8 +32,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "grpc_byte_buffer_reader_test",
-    srcs = ["byte_buffer_reader_test.c"],
-    language = "C",
+    srcs = ["byte_buffer_reader_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -44,8 +44,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "channel_create_test",
-    srcs = ["channel_create_test.c"],
-    language = "C",
+    srcs = ["channel_create_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -56,8 +56,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "grpc_completion_queue_test",
-    srcs = ["completion_queue_test.c"],
-    language = "C",
+    srcs = ["completion_queue_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -68,8 +68,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "concurrent_connectivity_test",
-    srcs = ["concurrent_connectivity_test.c"],
-    language = "C",
+    srcs = ["concurrent_connectivity_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -80,8 +80,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "init_test",
-    srcs = ["init_test.c"],
-    language = "C",
+    srcs = ["init_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -92,8 +92,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "grpc_invalid_channel_args_test",
-    srcs = ["invalid_channel_args_test.c"],
-    language = "C",
+    srcs = ["invalid_channel_args_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -104,8 +104,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "lame_client_test",
-    srcs = ["lame_client_test.c"],
-    language = "C",
+    srcs = ["lame_client_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -129,8 +129,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "secure_channel_create_test",
-    srcs = ["secure_channel_create_test.c"],
-    language = "C",
+    srcs = ["secure_channel_create_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -141,8 +141,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "sequential_connectivity_test",
-    srcs = ["sequential_connectivity_test.c"],
-    language = "C",
+    srcs = ["sequential_connectivity_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -154,8 +154,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "server_chttp2_test",
-    srcs = ["server_chttp2_test.c"],
-    language = "C",
+    srcs = ["server_chttp2_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -166,8 +166,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "server_test",
-    srcs = ["server_test.c"],
-    language = "C",
+    srcs = ["server_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
diff --git a/test/core/surface/alarm_test.c b/test/core/surface/alarm_test.cc
index 4fd7cb93c6..8950603b41 100644
--- a/test/core/surface/alarm_test.c
+++ b/test/core/surface/alarm_test.cc
@@ -25,78 +25,82 @@
 
 #define LOG_TEST(x) gpr_log(GPR_INFO, "%s", x)
 
-static void *create_test_tag(void) {
+static void* create_test_tag(void) {
   static intptr_t i = 0;
-  return (void *)(++i);
+  return (void*)(++i);
 }
 
 /* helper for tests to shutdown correctly and tersely */
-static void shutdown_and_destroy(grpc_completion_queue *cc) {
+static void shutdown_and_destroy(grpc_completion_queue* cc) {
   grpc_event ev;
   grpc_completion_queue_shutdown(cc);
-  ev = grpc_completion_queue_next(cc, gpr_inf_past(GPR_CLOCK_REALTIME), NULL);
+  ev =
+      grpc_completion_queue_next(cc, gpr_inf_past(GPR_CLOCK_REALTIME), nullptr);
   GPR_ASSERT(ev.type == GRPC_QUEUE_SHUTDOWN);
   grpc_completion_queue_destroy(cc);
 }
 
 static void test_alarm(void) {
-  grpc_completion_queue *cc;
+  grpc_completion_queue* cc;
 
   LOG_TEST("test_alarm");
-  cc = grpc_completion_queue_create_for_next(NULL);
+  cc = grpc_completion_queue_create_for_next(nullptr);
   {
     /* regular expiry */
     grpc_event ev;
-    void *tag = create_test_tag();
-    grpc_alarm *alarm = grpc_alarm_create(NULL);
-    grpc_alarm_set(alarm, cc, grpc_timeout_seconds_to_deadline(1), tag, NULL);
+    void* tag = create_test_tag();
+    grpc_alarm* alarm = grpc_alarm_create(nullptr);
+    grpc_alarm_set(alarm, cc, grpc_timeout_seconds_to_deadline(1), tag,
+                   nullptr);
 
     ev = grpc_completion_queue_next(cc, grpc_timeout_seconds_to_deadline(2),
-                                    NULL);
+                                    nullptr);
     GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
     GPR_ASSERT(ev.tag == tag);
     GPR_ASSERT(ev.success);
-    grpc_alarm_destroy(alarm, NULL);
+    grpc_alarm_destroy(alarm, nullptr);
   }
   {
     /* cancellation */
     grpc_event ev;
-    void *tag = create_test_tag();
-    grpc_alarm *alarm = grpc_alarm_create(NULL);
-    grpc_alarm_set(alarm, cc, grpc_timeout_seconds_to_deadline(2), tag, NULL);
+    void* tag = create_test_tag();
+    grpc_alarm* alarm = grpc_alarm_create(nullptr);
+    grpc_alarm_set(alarm, cc, grpc_timeout_seconds_to_deadline(2), tag,
+                   nullptr);
 
-    grpc_alarm_cancel(alarm, NULL);
+    grpc_alarm_cancel(alarm, nullptr);
     ev = grpc_completion_queue_next(cc, grpc_timeout_seconds_to_deadline(1),
-                                    NULL);
+                                    nullptr);
     GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
     GPR_ASSERT(ev.tag == tag);
     GPR_ASSERT(ev.success == 0);
-    grpc_alarm_destroy(alarm, NULL);
+    grpc_alarm_destroy(alarm, nullptr);
   }
   {
     /* alarm_destroy before cq_next */
     grpc_event ev;
-    void *tag = create_test_tag();
-    grpc_alarm *alarm = grpc_alarm_create(NULL);
-    grpc_alarm_set(alarm, cc, grpc_timeout_seconds_to_deadline(2), tag, NULL);
+    void* tag = create_test_tag();
+    grpc_alarm* alarm = grpc_alarm_create(nullptr);
+    grpc_alarm_set(alarm, cc, grpc_timeout_seconds_to_deadline(2), tag,
+                   nullptr);
 
-    grpc_alarm_destroy(alarm, NULL);
+    grpc_alarm_destroy(alarm, nullptr);
     ev = grpc_completion_queue_next(cc, grpc_timeout_seconds_to_deadline(1),
-                                    NULL);
+                                    nullptr);
     GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
     GPR_ASSERT(ev.tag == tag);
     GPR_ASSERT(ev.success == 0);
   }
   {
     /* alarm_destroy before set */
-    grpc_alarm *alarm = grpc_alarm_create(NULL);
-    grpc_alarm_destroy(alarm, NULL);
+    grpc_alarm* alarm = grpc_alarm_create(nullptr);
+    grpc_alarm_destroy(alarm, nullptr);
   }
 
   shutdown_and_destroy(cc);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   test_alarm();
diff --git a/test/core/surface/byte_buffer_reader_test.c b/test/core/surface/byte_buffer_reader_test.cc
index a6b4c86abc..e5d2d7c78d 100644
--- a/test/core/surface/byte_buffer_reader_test.c
+++ b/test/core/surface/byte_buffer_reader_test.cc
@@ -36,7 +36,7 @@
 
 static void test_read_one_slice(void) {
   grpc_slice slice;
-  grpc_byte_buffer *buffer;
+  grpc_byte_buffer* buffer;
   grpc_byte_buffer_reader reader;
   grpc_slice first_slice, second_slice;
   int first_code, second_code;
@@ -58,7 +58,7 @@ static void test_read_one_slice(void) {
 
 static void test_read_one_slice_malloc(void) {
   grpc_slice slice;
-  grpc_byte_buffer *buffer;
+  grpc_byte_buffer* buffer;
   grpc_byte_buffer_reader reader;
   grpc_slice first_slice, second_slice;
   int first_code, second_code;
@@ -81,7 +81,7 @@ static void test_read_one_slice_malloc(void) {
 
 static void test_read_none_compressed_slice(void) {
   grpc_slice slice;
-  grpc_byte_buffer *buffer;
+  grpc_byte_buffer* buffer;
   grpc_byte_buffer_reader reader;
   grpc_slice first_slice, second_slice;
   int first_code, second_code;
@@ -103,7 +103,7 @@ static void test_read_none_compressed_slice(void) {
 
 static void test_read_corrupted_slice(void) {
   grpc_slice slice;
-  grpc_byte_buffer *buffer;
+  grpc_byte_buffer* buffer;
   grpc_byte_buffer_reader reader;
 
   LOG_TEST("test_read_corrupted_slice");
@@ -120,7 +120,7 @@ static void read_compressed_slice(grpc_compression_algorithm algorithm,
   grpc_slice input_slice;
   grpc_slice_buffer sliceb_in;
   grpc_slice_buffer sliceb_out;
-  grpc_byte_buffer *buffer;
+  grpc_byte_buffer* buffer;
   grpc_byte_buffer_reader reader;
   grpc_slice read_slice;
   size_t read_count = 0;
@@ -195,10 +195,10 @@ static void test_byte_buffer_from_reader(void) {
 }
 
 static void test_readall(void) {
-  char *lotsa_as[512];
-  char *lotsa_bs[1024];
+  char* lotsa_as[512];
+  char* lotsa_bs[1024];
   grpc_slice slices[2];
-  grpc_byte_buffer *buffer;
+  grpc_byte_buffer* buffer;
   grpc_byte_buffer_reader reader;
   grpc_slice slice_out;
 
@@ -229,11 +229,11 @@ static void test_readall(void) {
 }
 
 static void test_byte_buffer_copy(void) {
-  char *lotsa_as[512];
-  char *lotsa_bs[1024];
+  char* lotsa_as[512];
+  char* lotsa_bs[1024];
   grpc_slice slices[2];
-  grpc_byte_buffer *buffer;
-  grpc_byte_buffer *copied_buffer;
+  grpc_byte_buffer* buffer;
+  grpc_byte_buffer* copied_buffer;
   grpc_byte_buffer_reader reader;
   grpc_slice slice_out;
 
@@ -265,7 +265,7 @@ static void test_byte_buffer_copy(void) {
   grpc_byte_buffer_destroy(copied_buffer);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_read_one_slice();
   test_read_one_slice_malloc();
diff --git a/test/core/surface/channel_create_test.c b/test/core/surface/channel_create_test.cc
index a6884750e7..f358b0fc8d 100644
--- a/test/core/surface/channel_create_test.c
+++ b/test/core/surface/channel_create_test.cc
@@ -27,16 +27,16 @@
 #include "test/core/util/test_config.h"
 
 void test_unknown_scheme_target(void) {
-  grpc_channel *chan;
+  grpc_channel* chan;
   /* avoid default prefix */
   grpc_resolver_registry_shutdown();
   grpc_resolver_registry_init();
 
-  chan = grpc_insecure_channel_create("blah://blah", NULL, NULL);
-  GPR_ASSERT(chan != NULL);
+  chan = grpc_insecure_channel_create("blah://blah", nullptr, nullptr);
+  GPR_ASSERT(chan != nullptr);
 
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_channel_element *elem =
+  grpc_channel_element* elem =
       grpc_channel_stack_element(grpc_channel_get_channel_stack(chan), 0);
   GPR_ASSERT(0 == strcmp(elem->filter->name, "lame-client"));
   grpc_exec_ctx_finish(&exec_ctx);
@@ -44,7 +44,7 @@ void test_unknown_scheme_target(void) {
   grpc_channel_destroy(chan);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   test_unknown_scheme_target();
diff --git a/test/core/surface/completion_queue_test.c b/test/core/surface/completion_queue_test.cc
index e6372a379c..c6e13d2386 100644
--- a/test/core/surface/completion_queue_test.c
+++ b/test/core/surface/completion_queue_test.cc
@@ -27,25 +27,25 @@
 
 #define LOG_TEST(x) gpr_log(GPR_INFO, "%s", x)
 
-static void *create_test_tag(void) {
+static void* create_test_tag(void) {
   static intptr_t i = 0;
-  return (void *)(++i);
+  return (void*)(++i);
 }
 
 /* helper for tests to shutdown correctly and tersely */
-static void shutdown_and_destroy(grpc_completion_queue *cc) {
+static void shutdown_and_destroy(grpc_completion_queue* cc) {
   grpc_event ev;
   grpc_completion_queue_shutdown(cc);
 
   switch (grpc_get_cq_completion_type(cc)) {
     case GRPC_CQ_NEXT: {
       ev = grpc_completion_queue_next(cc, gpr_inf_past(GPR_CLOCK_REALTIME),
-                                      NULL);
+                                      nullptr);
       break;
     }
     case GRPC_CQ_PLUCK: {
-      ev = grpc_completion_queue_pluck(cc, create_test_tag(),
-                                       gpr_inf_past(GPR_CLOCK_REALTIME), NULL);
+      ev = grpc_completion_queue_pluck(
+          cc, create_test_tag(), gpr_inf_past(GPR_CLOCK_REALTIME), nullptr);
       break;
     }
     default: {
@@ -72,7 +72,7 @@ static void test_no_op(void) {
       attr.cq_completion_type = completion_types[i];
       attr.cq_polling_type = polling_types[j];
       shutdown_and_destroy(grpc_completion_queue_create(
-          grpc_completion_queue_factory_lookup(&attr), &attr, NULL));
+          grpc_completion_queue_factory_lookup(&attr), &attr, nullptr));
     }
   }
 }
@@ -81,7 +81,7 @@ static void test_pollset_conversion(void) {
   grpc_cq_completion_type completion_types[] = {GRPC_CQ_NEXT, GRPC_CQ_PLUCK};
   grpc_cq_polling_type polling_types[] = {GRPC_CQ_DEFAULT_POLLING,
                                           GRPC_CQ_NON_LISTENING};
-  grpc_completion_queue *cq;
+  grpc_completion_queue* cq;
   grpc_completion_queue_attributes attr;
 
   LOG_TEST("test_pollset_conversion");
@@ -92,8 +92,8 @@ static void test_pollset_conversion(void) {
       attr.cq_completion_type = completion_types[i];
       attr.cq_polling_type = polling_types[j];
       cq = grpc_completion_queue_create(
-          grpc_completion_queue_factory_lookup(&attr), &attr, NULL);
-      GPR_ASSERT(grpc_cq_pollset(cq) != NULL);
+          grpc_completion_queue_factory_lookup(&attr), &attr, nullptr);
+      GPR_ASSERT(grpc_cq_pollset(cq) != nullptr);
       shutdown_and_destroy(cq);
     }
   }
@@ -102,7 +102,7 @@ static void test_pollset_conversion(void) {
 static void test_wait_empty(void) {
   grpc_cq_polling_type polling_types[] = {
       GRPC_CQ_DEFAULT_POLLING, GRPC_CQ_NON_LISTENING, GRPC_CQ_NON_POLLING};
-  grpc_completion_queue *cc;
+  grpc_completion_queue* cc;
   grpc_completion_queue_attributes attr;
   grpc_event event;
 
@@ -113,26 +113,27 @@ static void test_wait_empty(void) {
   for (size_t i = 0; i < GPR_ARRAY_SIZE(polling_types); i++) {
     attr.cq_polling_type = polling_types[i];
     cc = grpc_completion_queue_create(
-        grpc_completion_queue_factory_lookup(&attr), &attr, NULL);
-    event = grpc_completion_queue_next(cc, gpr_now(GPR_CLOCK_REALTIME), NULL);
+        grpc_completion_queue_factory_lookup(&attr), &attr, nullptr);
+    event =
+        grpc_completion_queue_next(cc, gpr_now(GPR_CLOCK_REALTIME), nullptr);
     GPR_ASSERT(event.type == GRPC_QUEUE_TIMEOUT);
     shutdown_and_destroy(cc);
   }
 }
 
-static void do_nothing_end_completion(grpc_exec_ctx *exec_ctx, void *arg,
-                                      grpc_cq_completion *c) {}
+static void do_nothing_end_completion(grpc_exec_ctx* exec_ctx, void* arg,
+                                      grpc_cq_completion* c) {}
 
 static void test_cq_end_op(void) {
   grpc_event ev;
-  grpc_completion_queue *cc;
+  grpc_completion_queue* cc;
   grpc_cq_completion completion;
   grpc_cq_polling_type polling_types[] = {
       GRPC_CQ_DEFAULT_POLLING, GRPC_CQ_NON_LISTENING, GRPC_CQ_NON_POLLING};
   grpc_completion_queue_attributes attr;
   grpc_exec_ctx init_exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_exec_ctx exec_ctx;
-  void *tag = create_test_tag();
+  void* tag = create_test_tag();
 
   LOG_TEST("test_cq_end_op");
 
@@ -142,13 +143,14 @@ static void test_cq_end_op(void) {
     exec_ctx = init_exec_ctx;  // Reset exec_ctx
     attr.cq_polling_type = polling_types[i];
     cc = grpc_completion_queue_create(
-        grpc_completion_queue_factory_lookup(&attr), &attr, NULL);
+        grpc_completion_queue_factory_lookup(&attr), &attr, nullptr);
 
     GPR_ASSERT(grpc_cq_begin_op(cc, tag));
     grpc_cq_end_op(&exec_ctx, cc, tag, GRPC_ERROR_NONE,
-                   do_nothing_end_completion, NULL, &completion);
+                   do_nothing_end_completion, nullptr, &completion);
 
-    ev = grpc_completion_queue_next(cc, gpr_inf_past(GPR_CLOCK_REALTIME), NULL);
+    ev = grpc_completion_queue_next(cc, gpr_inf_past(GPR_CLOCK_REALTIME),
+                                    nullptr);
     GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
     GPR_ASSERT(ev.tag == tag);
     GPR_ASSERT(ev.success);
@@ -158,10 +160,86 @@ static void test_cq_end_op(void) {
   }
 }
 
+static void test_cq_tls_cache_full(void) {
+  grpc_event ev;
+  grpc_completion_queue* cc;
+  grpc_cq_completion completion;
+  grpc_cq_polling_type polling_types[] = {
+      GRPC_CQ_DEFAULT_POLLING, GRPC_CQ_NON_LISTENING, GRPC_CQ_NON_POLLING};
+  grpc_completion_queue_attributes attr;
+  grpc_exec_ctx init_exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_exec_ctx exec_ctx;
+  void* tag = create_test_tag();
+  void* res_tag;
+  int ok;
+
+  LOG_TEST("test_cq_tls_cache_full");
+
+  attr.version = 1;
+  attr.cq_completion_type = GRPC_CQ_NEXT;
+  for (size_t i = 0; i < GPR_ARRAY_SIZE(polling_types); i++) {
+    exec_ctx = init_exec_ctx;  // Reset exec_ctx
+    attr.cq_polling_type = polling_types[i];
+    cc = grpc_completion_queue_create(
+        grpc_completion_queue_factory_lookup(&attr), &attr, nullptr);
+
+    grpc_completion_queue_thread_local_cache_init(cc);
+    GPR_ASSERT(grpc_cq_begin_op(cc, tag));
+    grpc_cq_end_op(&exec_ctx, cc, tag, GRPC_ERROR_NONE,
+                   do_nothing_end_completion, nullptr, &completion);
+
+    ev = grpc_completion_queue_next(cc, gpr_inf_past(GPR_CLOCK_REALTIME),
+                                    nullptr);
+    GPR_ASSERT(ev.type == GRPC_QUEUE_TIMEOUT);
+
+    GPR_ASSERT(
+        grpc_completion_queue_thread_local_cache_flush(cc, &res_tag, &ok) == 1);
+    GPR_ASSERT(res_tag == tag);
+    GPR_ASSERT(ok);
+
+    ev = grpc_completion_queue_next(cc, gpr_inf_past(GPR_CLOCK_REALTIME),
+                                    nullptr);
+    GPR_ASSERT(ev.type == GRPC_QUEUE_TIMEOUT);
+
+    shutdown_and_destroy(cc);
+    grpc_exec_ctx_finish(&exec_ctx);
+  }
+}
+
+static void test_cq_tls_cache_empty(void) {
+  grpc_completion_queue* cc;
+  grpc_cq_polling_type polling_types[] = {
+      GRPC_CQ_DEFAULT_POLLING, GRPC_CQ_NON_LISTENING, GRPC_CQ_NON_POLLING};
+  grpc_completion_queue_attributes attr;
+  grpc_exec_ctx init_exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_exec_ctx exec_ctx;
+  void* res_tag;
+  int ok;
+
+  LOG_TEST("test_cq_tls_cache_empty");
+
+  attr.version = 1;
+  attr.cq_completion_type = GRPC_CQ_NEXT;
+  for (size_t i = 0; i < GPR_ARRAY_SIZE(polling_types); i++) {
+    exec_ctx = init_exec_ctx;  // Reset exec_ctx
+    attr.cq_polling_type = polling_types[i];
+    cc = grpc_completion_queue_create(
+        grpc_completion_queue_factory_lookup(&attr), &attr, nullptr);
+
+    GPR_ASSERT(
+        grpc_completion_queue_thread_local_cache_flush(cc, &res_tag, &ok) == 0);
+    grpc_completion_queue_thread_local_cache_init(cc);
+    GPR_ASSERT(
+        grpc_completion_queue_thread_local_cache_flush(cc, &res_tag, &ok) == 0);
+    shutdown_and_destroy(cc);
+    grpc_exec_ctx_finish(&exec_ctx);
+  }
+}
+
 static void test_shutdown_then_next_polling(void) {
   grpc_cq_polling_type polling_types[] = {
       GRPC_CQ_DEFAULT_POLLING, GRPC_CQ_NON_LISTENING, GRPC_CQ_NON_POLLING};
-  grpc_completion_queue *cc;
+  grpc_completion_queue* cc;
   grpc_completion_queue_attributes attr;
   grpc_event event;
   LOG_TEST("test_shutdown_then_next_polling");
@@ -171,10 +249,10 @@ static void test_shutdown_then_next_polling(void) {
   for (size_t i = 0; i < GPR_ARRAY_SIZE(polling_types); i++) {
     attr.cq_polling_type = polling_types[i];
     cc = grpc_completion_queue_create(
-        grpc_completion_queue_factory_lookup(&attr), &attr, NULL);
+        grpc_completion_queue_factory_lookup(&attr), &attr, nullptr);
     grpc_completion_queue_shutdown(cc);
-    event =
-        grpc_completion_queue_next(cc, gpr_inf_past(GPR_CLOCK_REALTIME), NULL);
+    event = grpc_completion_queue_next(cc, gpr_inf_past(GPR_CLOCK_REALTIME),
+                                       nullptr);
     GPR_ASSERT(event.type == GRPC_QUEUE_SHUTDOWN);
     grpc_completion_queue_destroy(cc);
   }
@@ -183,7 +261,7 @@ static void test_shutdown_then_next_polling(void) {
 static void test_shutdown_then_next_with_timeout(void) {
   grpc_cq_polling_type polling_types[] = {
       GRPC_CQ_DEFAULT_POLLING, GRPC_CQ_NON_LISTENING, GRPC_CQ_NON_POLLING};
-  grpc_completion_queue *cc;
+  grpc_completion_queue* cc;
   grpc_completion_queue_attributes attr;
   grpc_event event;
   LOG_TEST("test_shutdown_then_next_with_timeout");
@@ -193,11 +271,11 @@ static void test_shutdown_then_next_with_timeout(void) {
   for (size_t i = 0; i < GPR_ARRAY_SIZE(polling_types); i++) {
     attr.cq_polling_type = polling_types[i];
     cc = grpc_completion_queue_create(
-        grpc_completion_queue_factory_lookup(&attr), &attr, NULL);
+        grpc_completion_queue_factory_lookup(&attr), &attr, nullptr);
 
     grpc_completion_queue_shutdown(cc);
     event = grpc_completion_queue_next(cc, gpr_inf_future(GPR_CLOCK_REALTIME),
-                                       NULL);
+                                       nullptr);
     GPR_ASSERT(event.type == GRPC_QUEUE_SHUTDOWN);
     grpc_completion_queue_destroy(cc);
   }
@@ -205,8 +283,8 @@ static void test_shutdown_then_next_with_timeout(void) {
 
 static void test_pluck(void) {
   grpc_event ev;
-  grpc_completion_queue *cc;
-  void *tags[128];
+  grpc_completion_queue* cc;
+  void* tags[128];
   grpc_cq_completion completions[GPR_ARRAY_SIZE(tags)];
   grpc_cq_polling_type polling_types[] = {
       GRPC_CQ_DEFAULT_POLLING, GRPC_CQ_NON_LISTENING, GRPC_CQ_NON_POLLING};
@@ -230,29 +308,30 @@ static void test_pluck(void) {
     exec_ctx = init_exec_ctx;  // reset exec_ctx
     attr.cq_polling_type = polling_types[pidx];
     cc = grpc_completion_queue_create(
-        grpc_completion_queue_factory_lookup(&attr), &attr, NULL);
+        grpc_completion_queue_factory_lookup(&attr), &attr, nullptr);
 
     for (i = 0; i < GPR_ARRAY_SIZE(tags); i++) {
       GPR_ASSERT(grpc_cq_begin_op(cc, tags[i]));
       grpc_cq_end_op(&exec_ctx, cc, tags[i], GRPC_ERROR_NONE,
-                     do_nothing_end_completion, NULL, &completions[i]);
+                     do_nothing_end_completion, nullptr, &completions[i]);
     }
 
     for (i = 0; i < GPR_ARRAY_SIZE(tags); i++) {
-      ev = grpc_completion_queue_pluck(cc, tags[i],
-                                       gpr_inf_past(GPR_CLOCK_REALTIME), NULL);
+      ev = grpc_completion_queue_pluck(
+          cc, tags[i], gpr_inf_past(GPR_CLOCK_REALTIME), nullptr);
       GPR_ASSERT(ev.tag == tags[i]);
     }
 
     for (i = 0; i < GPR_ARRAY_SIZE(tags); i++) {
       GPR_ASSERT(grpc_cq_begin_op(cc, tags[i]));
       grpc_cq_end_op(&exec_ctx, cc, tags[i], GRPC_ERROR_NONE,
-                     do_nothing_end_completion, NULL, &completions[i]);
+                     do_nothing_end_completion, nullptr, &completions[i]);
     }
 
     for (i = 0; i < GPR_ARRAY_SIZE(tags); i++) {
       ev = grpc_completion_queue_pluck(cc, tags[GPR_ARRAY_SIZE(tags) - i - 1],
-                                       gpr_inf_past(GPR_CLOCK_REALTIME), NULL);
+                                       gpr_inf_past(GPR_CLOCK_REALTIME),
+                                       nullptr);
       GPR_ASSERT(ev.tag == tags[GPR_ARRAY_SIZE(tags) - i - 1]);
     }
 
@@ -265,7 +344,7 @@ static void test_pluck_after_shutdown(void) {
   grpc_cq_polling_type polling_types[] = {
       GRPC_CQ_DEFAULT_POLLING, GRPC_CQ_NON_LISTENING, GRPC_CQ_NON_POLLING};
   grpc_event ev;
-  grpc_completion_queue *cc;
+  grpc_completion_queue* cc;
   grpc_completion_queue_attributes attr;
 
   LOG_TEST("test_pluck_after_shutdown");
@@ -275,21 +354,21 @@ static void test_pluck_after_shutdown(void) {
   for (size_t i = 0; i < GPR_ARRAY_SIZE(polling_types); i++) {
     attr.cq_polling_type = polling_types[i];
     cc = grpc_completion_queue_create(
-        grpc_completion_queue_factory_lookup(&attr), &attr, NULL);
+        grpc_completion_queue_factory_lookup(&attr), &attr, nullptr);
     grpc_completion_queue_shutdown(cc);
-    ev = grpc_completion_queue_pluck(cc, NULL,
-                                     gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+    ev = grpc_completion_queue_pluck(
+        cc, nullptr, gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
     GPR_ASSERT(ev.type == GRPC_QUEUE_SHUTDOWN);
     grpc_completion_queue_destroy(cc);
   }
 }
 
 struct thread_state {
-  grpc_completion_queue *cc;
-  void *tag;
+  grpc_completion_queue* cc;
+  void* tag;
 };
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   test_no_op();
@@ -300,6 +379,8 @@ int main(int argc, char **argv) {
   test_cq_end_op();
   test_pluck();
   test_pluck_after_shutdown();
+  test_cq_tls_cache_full();
+  test_cq_tls_cache_empty();
   grpc_shutdown();
   return 0;
 }
diff --git a/test/core/surface/completion_queue_threading_test.c b/test/core/surface/completion_queue_threading_test.cc
index 9996b6b840..af54e00c4a 100644
--- a/test/core/surface/completion_queue_threading_test.c
+++ b/test/core/surface/completion_queue_threading_test.cc
@@ -28,25 +28,25 @@
 
 #define LOG_TEST(x) gpr_log(GPR_INFO, "%s", x)
 
-static void *create_test_tag(void) {
+static void* create_test_tag(void) {
   static intptr_t i = 0;
-  return (void *)(++i);
+  return (void*)(++i);
 }
 
 /* helper for tests to shutdown correctly and tersely */
-static void shutdown_and_destroy(grpc_completion_queue *cc) {
+static void shutdown_and_destroy(grpc_completion_queue* cc) {
   grpc_event ev;
   grpc_completion_queue_shutdown(cc);
 
   switch (grpc_get_cq_completion_type(cc)) {
     case GRPC_CQ_NEXT: {
       ev = grpc_completion_queue_next(cc, gpr_inf_past(GPR_CLOCK_REALTIME),
-                                      NULL);
+                                      nullptr);
       break;
     }
     case GRPC_CQ_PLUCK: {
-      ev = grpc_completion_queue_pluck(cc, create_test_tag(),
-                                       gpr_inf_past(GPR_CLOCK_REALTIME), NULL);
+      ev = grpc_completion_queue_pluck(
+          cc, create_test_tag(), gpr_inf_past(GPR_CLOCK_REALTIME), nullptr);
       break;
     }
     default: {
@@ -59,24 +59,24 @@ static void shutdown_and_destroy(grpc_completion_queue *cc) {
   grpc_completion_queue_destroy(cc);
 }
 
-static void do_nothing_end_completion(grpc_exec_ctx *exec_ctx, void *arg,
-                                      grpc_cq_completion *c) {}
+static void do_nothing_end_completion(grpc_exec_ctx* exec_ctx, void* arg,
+                                      grpc_cq_completion* c) {}
 
 struct thread_state {
-  grpc_completion_queue *cc;
-  void *tag;
+  grpc_completion_queue* cc;
+  void* tag;
 };
 
-static void pluck_one(void *arg) {
-  struct thread_state *state = arg;
+static void pluck_one(void* arg) {
+  struct thread_state* state = static_cast<struct thread_state*>(arg);
   grpc_completion_queue_pluck(state->cc, state->tag,
-                              gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+                              gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
 }
 
 static void test_too_many_plucks(void) {
   grpc_event ev;
-  grpc_completion_queue *cc;
-  void *tags[GRPC_MAX_COMPLETION_QUEUE_PLUCKERS];
+  grpc_completion_queue* cc;
+  void* tags[GRPC_MAX_COMPLETION_QUEUE_PLUCKERS];
   grpc_cq_completion completions[GPR_ARRAY_SIZE(tags)];
   gpr_thd_id thread_ids[GPR_ARRAY_SIZE(tags)];
   struct thread_state thread_states[GPR_ARRAY_SIZE(tags)];
@@ -86,7 +86,7 @@ static void test_too_many_plucks(void) {
 
   LOG_TEST("test_too_many_plucks");
 
-  cc = grpc_completion_queue_create_for_pluck(NULL);
+  cc = grpc_completion_queue_create_for_pluck(nullptr);
   gpr_thd_options_set_joinable(&thread_options);
 
   for (i = 0; i < GPR_ARRAY_SIZE(tags); i++) {
@@ -103,13 +103,13 @@ static void test_too_many_plucks(void) {
   gpr_sleep_until(grpc_timeout_milliseconds_to_deadline(1000));
 
   ev = grpc_completion_queue_pluck(cc, create_test_tag(),
-                                   gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+                                   gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
   GPR_ASSERT(ev.type == GRPC_QUEUE_TIMEOUT);
 
   for (i = 0; i < GPR_ARRAY_SIZE(tags); i++) {
     GPR_ASSERT(grpc_cq_begin_op(cc, tags[i]));
     grpc_cq_end_op(&exec_ctx, cc, tags[i], GRPC_ERROR_NONE,
-                   do_nothing_end_completion, NULL, &completions[i]);
+                   do_nothing_end_completion, nullptr, &completions[i]);
   }
 
   for (i = 0; i < GPR_ARRAY_SIZE(tags); i++) {
@@ -124,74 +124,75 @@ static void test_too_many_plucks(void) {
 
 typedef struct test_thread_options {
   gpr_event on_started;
-  gpr_event *phase1;
+  gpr_event* phase1;
   gpr_event on_phase1_done;
-  gpr_event *phase2;
+  gpr_event* phase2;
   gpr_event on_finished;
   size_t events_triggered;
   int id;
-  grpc_completion_queue *cc;
+  grpc_completion_queue* cc;
 } test_thread_options;
 
 gpr_timespec ten_seconds_time(void) {
   return grpc_timeout_seconds_to_deadline(10);
 }
 
-static void free_completion(grpc_exec_ctx *exec_ctx, void *arg,
-                            grpc_cq_completion *completion) {
+static void free_completion(grpc_exec_ctx* exec_ctx, void* arg,
+                            grpc_cq_completion* completion) {
   gpr_free(completion);
 }
 
-static void producer_thread(void *arg) {
-  test_thread_options *opt = arg;
+static void producer_thread(void* arg) {
+  test_thread_options* opt = static_cast<test_thread_options*>(arg);
   int i;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
   gpr_log(GPR_INFO, "producer %d started", opt->id);
-  gpr_event_set(&opt->on_started, (void *)(intptr_t)1);
+  gpr_event_set(&opt->on_started, (void*)(intptr_t)1);
   GPR_ASSERT(gpr_event_wait(opt->phase1, ten_seconds_time()));
 
   gpr_log(GPR_INFO, "producer %d phase 1", opt->id);
   for (i = 0; i < TEST_THREAD_EVENTS; i++) {
-    GPR_ASSERT(grpc_cq_begin_op(opt->cc, (void *)(intptr_t)1));
+    GPR_ASSERT(grpc_cq_begin_op(opt->cc, (void*)(intptr_t)1));
   }
 
   gpr_log(GPR_INFO, "producer %d phase 1 done", opt->id);
-  gpr_event_set(&opt->on_phase1_done, (void *)(intptr_t)1);
+  gpr_event_set(&opt->on_phase1_done, (void*)(intptr_t)1);
   GPR_ASSERT(gpr_event_wait(opt->phase2, ten_seconds_time()));
 
   gpr_log(GPR_INFO, "producer %d phase 2", opt->id);
   for (i = 0; i < TEST_THREAD_EVENTS; i++) {
-    grpc_cq_end_op(&exec_ctx, opt->cc, (void *)(intptr_t)1, GRPC_ERROR_NONE,
-                   free_completion, NULL,
-                   gpr_malloc(sizeof(grpc_cq_completion)));
+    grpc_cq_end_op(&exec_ctx, opt->cc, (void*)(intptr_t)1, GRPC_ERROR_NONE,
+                   free_completion, nullptr,
+                   static_cast<grpc_cq_completion*>(
+                       gpr_malloc(sizeof(grpc_cq_completion))));
     opt->events_triggered++;
     grpc_exec_ctx_finish(&exec_ctx);
   }
 
   gpr_log(GPR_INFO, "producer %d phase 2 done", opt->id);
-  gpr_event_set(&opt->on_finished, (void *)(intptr_t)1);
+  gpr_event_set(&opt->on_finished, (void*)(intptr_t)1);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void consumer_thread(void *arg) {
-  test_thread_options *opt = arg;
+static void consumer_thread(void* arg) {
+  test_thread_options* opt = static_cast<test_thread_options*>(arg);
   grpc_event ev;
 
   gpr_log(GPR_INFO, "consumer %d started", opt->id);
-  gpr_event_set(&opt->on_started, (void *)(intptr_t)1);
+  gpr_event_set(&opt->on_started, (void*)(intptr_t)1);
   GPR_ASSERT(gpr_event_wait(opt->phase1, ten_seconds_time()));
 
   gpr_log(GPR_INFO, "consumer %d phase 1", opt->id);
 
   gpr_log(GPR_INFO, "consumer %d phase 1 done", opt->id);
-  gpr_event_set(&opt->on_phase1_done, (void *)(intptr_t)1);
+  gpr_event_set(&opt->on_phase1_done, (void*)(intptr_t)1);
   GPR_ASSERT(gpr_event_wait(opt->phase2, ten_seconds_time()));
 
   gpr_log(GPR_INFO, "consumer %d phase 2", opt->id);
   for (;;) {
-    ev = grpc_completion_queue_next(opt->cc,
-                                    gpr_inf_future(GPR_CLOCK_MONOTONIC), NULL);
+    ev = grpc_completion_queue_next(
+        opt->cc, gpr_inf_future(GPR_CLOCK_MONOTONIC), nullptr);
     switch (ev.type) {
       case GRPC_OP_COMPLETE:
         GPR_ASSERT(ev.success);
@@ -199,7 +200,7 @@ static void consumer_thread(void *arg) {
         break;
       case GRPC_QUEUE_SHUTDOWN:
         gpr_log(GPR_INFO, "consumer %d phase 2 done", opt->id);
-        gpr_event_set(&opt->on_finished, (void *)(intptr_t)1);
+        gpr_event_set(&opt->on_finished, (void*)(intptr_t)1);
         return;
       case GRPC_QUEUE_TIMEOUT:
         gpr_log(GPR_ERROR, "Invalid timeout received");
@@ -209,11 +210,11 @@ static void consumer_thread(void *arg) {
 }
 
 static void test_threading(size_t producers, size_t consumers) {
-  test_thread_options *options =
-      gpr_malloc((producers + consumers) * sizeof(test_thread_options));
+  test_thread_options* options = static_cast<test_thread_options*>(
+      gpr_malloc((producers + consumers) * sizeof(test_thread_options)));
   gpr_event phase1 = GPR_EVENT_INIT;
   gpr_event phase2 = GPR_EVENT_INIT;
-  grpc_completion_queue *cc = grpc_completion_queue_create_for_next(NULL);
+  grpc_completion_queue* cc = grpc_completion_queue_create_for_next(nullptr);
   size_t i;
   size_t total_consumed = 0;
   static int optid = 101;
@@ -234,14 +235,14 @@ static void test_threading(size_t producers, size_t consumers) {
     options[i].id = optid++;
     GPR_ASSERT(gpr_thd_new(&id,
                            i < producers ? producer_thread : consumer_thread,
-                           options + i, NULL));
+                           options + i, nullptr));
     gpr_event_wait(&options[i].on_started, ten_seconds_time());
   }
 
   /* start phase1: producers will pre-declare all operations they will
      complete */
   gpr_log(GPR_INFO, "start phase 1");
-  gpr_event_set(&phase1, (void *)(intptr_t)1);
+  gpr_event_set(&phase1, (void*)(intptr_t)1);
 
   gpr_log(GPR_INFO, "wait phase 1");
   for (i = 0; i < producers + consumers; i++) {
@@ -251,7 +252,7 @@ static void test_threading(size_t producers, size_t consumers) {
 
   /* start phase2: operations will complete, and consumers will consume them */
   gpr_log(GPR_INFO, "start phase 2");
-  gpr_event_set(&phase2, (void *)(intptr_t)1);
+  gpr_event_set(&phase2, (void*)(intptr_t)1);
 
   /* in parallel, we shutdown the completion channel - all events should still
      be consumed */
@@ -280,7 +281,7 @@ static void test_threading(size_t producers, size_t consumers) {
   gpr_free(options);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   test_too_many_plucks();
diff --git a/test/core/surface/concurrent_connectivity_test.c b/test/core/surface/concurrent_connectivity_test.cc
index 3595885ff6..8fa15ab331 100644
--- a/test/core/surface/concurrent_connectivity_test.c
+++ b/test/core/surface/concurrent_connectivity_test.cc
@@ -54,23 +54,25 @@
 // end after the shorter delay_millis
 #define POLL_MILLIS_SHORT_TIMEOUTS 30000
 
-static void *tag(int n) { return (void *)(uintptr_t)n; }
-static int detag(void *p) { return (int)(uintptr_t)p; }
+static void* tag(int n) { return (void*)(uintptr_t)n; }
+static int detag(void* p) { return (int)(uintptr_t)p; }
 
-void create_loop_destroy(void *addr) {
+void create_loop_destroy(void* addr) {
   for (int i = 0; i < NUM_OUTER_LOOPS; ++i) {
-    grpc_completion_queue *cq = grpc_completion_queue_create_for_next(NULL);
-    grpc_channel *chan = grpc_insecure_channel_create((char *)addr, NULL, NULL);
+    grpc_completion_queue* cq = grpc_completion_queue_create_for_next(nullptr);
+    grpc_channel* chan =
+        grpc_insecure_channel_create((char*)addr, nullptr, nullptr);
 
     for (int j = 0; j < NUM_INNER_LOOPS; ++j) {
       gpr_timespec later_time =
           grpc_timeout_milliseconds_to_deadline(DELAY_MILLIS);
       grpc_connectivity_state state =
           grpc_channel_check_connectivity_state(chan, 1);
-      grpc_channel_watch_connectivity_state(chan, state, later_time, cq, NULL);
+      grpc_channel_watch_connectivity_state(chan, state, later_time, cq,
+                                            nullptr);
       gpr_timespec poll_time =
           grpc_timeout_milliseconds_to_deadline(POLL_MILLIS);
-      GPR_ASSERT(grpc_completion_queue_next(cq, poll_time, NULL).type ==
+      GPR_ASSERT(grpc_completion_queue_next(cq, poll_time, nullptr).type ==
                  GRPC_OP_COMPLETE);
       /* check that the watcher from "watch state" was free'd */
       GPR_ASSERT(grpc_channel_num_external_connectivity_watchers(chan) == 0);
@@ -81,47 +83,47 @@ void create_loop_destroy(void *addr) {
 }
 
 struct server_thread_args {
-  char *addr;
-  grpc_server *server;
-  grpc_completion_queue *cq;
-  grpc_pollset *pollset;
-  gpr_mu *mu;
+  char* addr;
+  grpc_server* server;
+  grpc_completion_queue* cq;
+  grpc_pollset* pollset;
+  gpr_mu* mu;
   gpr_event ready;
   gpr_atm stop;
 };
 
-void server_thread(void *vargs) {
-  struct server_thread_args *args = (struct server_thread_args *)vargs;
+void server_thread(void* vargs) {
+  struct server_thread_args* args = (struct server_thread_args*)vargs;
   grpc_event ev;
   gpr_timespec deadline = gpr_inf_future(GPR_CLOCK_MONOTONIC);
-  ev = grpc_completion_queue_next(args->cq, deadline, NULL);
+  ev = grpc_completion_queue_next(args->cq, deadline, nullptr);
   GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
   GPR_ASSERT(detag(ev.tag) == 0xd1e);
 }
 
-static void on_connect(grpc_exec_ctx *exec_ctx, void *vargs, grpc_endpoint *tcp,
-                       grpc_pollset *accepting_pollset,
-                       grpc_tcp_server_acceptor *acceptor) {
+static void on_connect(grpc_exec_ctx* exec_ctx, void* vargs, grpc_endpoint* tcp,
+                       grpc_pollset* accepting_pollset,
+                       grpc_tcp_server_acceptor* acceptor) {
   gpr_free(acceptor);
-  struct server_thread_args *args = (struct server_thread_args *)vargs;
+  struct server_thread_args* args = (struct server_thread_args*)vargs;
   grpc_endpoint_shutdown(exec_ctx, tcp,
                          GRPC_ERROR_CREATE_FROM_STATIC_STRING("Connected"));
   grpc_endpoint_destroy(exec_ctx, tcp);
   gpr_mu_lock(args->mu);
   GRPC_LOG_IF_ERROR("pollset_kick",
-                    grpc_pollset_kick(exec_ctx, args->pollset, NULL));
+                    grpc_pollset_kick(exec_ctx, args->pollset, nullptr));
   gpr_mu_unlock(args->mu);
 }
 
-void bad_server_thread(void *vargs) {
-  struct server_thread_args *args = (struct server_thread_args *)vargs;
+void bad_server_thread(void* vargs) {
+  struct server_thread_args* args = (struct server_thread_args*)vargs;
 
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_resolved_address resolved_addr;
-  struct sockaddr_storage *addr = (struct sockaddr_storage *)resolved_addr.addr;
+  struct sockaddr_storage* addr = (struct sockaddr_storage*)resolved_addr.addr;
   int port;
-  grpc_tcp_server *s;
-  grpc_error *error = grpc_tcp_server_create(&exec_ctx, NULL, NULL, &s);
+  grpc_tcp_server* s;
+  grpc_error* error = grpc_tcp_server_create(&exec_ctx, nullptr, nullptr, &s);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   memset(&resolved_addr, 0, sizeof(resolved_addr));
   addr->ss_family = AF_INET;
@@ -131,13 +133,13 @@ void bad_server_thread(void *vargs) {
   gpr_asprintf(&args->addr, "localhost:%d", port);
 
   grpc_tcp_server_start(&exec_ctx, s, &args->pollset, 1, on_connect, args);
-  gpr_event_set(&args->ready, (void *)1);
+  gpr_event_set(&args->ready, (void*)1);
 
   gpr_mu_lock(args->mu);
   while (gpr_atm_acq_load(&args->stop) == 0) {
     grpc_millis deadline = grpc_exec_ctx_now(&exec_ctx) + 100;
 
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     if (!GRPC_LOG_IF_ERROR(
             "pollset_work",
             grpc_pollset_work(&exec_ctx, args->pollset, &worker, deadline))) {
@@ -156,9 +158,9 @@ void bad_server_thread(void *vargs) {
   gpr_free(args->addr);
 }
 
-static void done_pollset_shutdown(grpc_exec_ctx *exec_ctx, void *pollset,
-                                  grpc_error *error) {
-  grpc_pollset_destroy(exec_ctx, pollset);
+static void done_pollset_shutdown(grpc_exec_ctx* exec_ctx, void* pollset,
+                                  grpc_error* error) {
+  grpc_pollset_destroy(exec_ctx, static_cast<grpc_pollset*>(pollset));
   gpr_free(pollset);
 }
 
@@ -171,7 +173,7 @@ int run_concurrent_connectivity_test() {
   gpr_thd_id threads[NUM_THREADS];
   gpr_thd_id server;
 
-  char *localhost = gpr_strdup("localhost:54321");
+  char* localhost = gpr_strdup("localhost:54321");
   gpr_thd_options options = gpr_thd_options_default();
   gpr_thd_options_set_joinable(&options);
 
@@ -189,10 +191,10 @@ int run_concurrent_connectivity_test() {
   gpr_log(GPR_DEBUG, "Wave 2");
   int port = grpc_pick_unused_port_or_die();
   gpr_asprintf(&args.addr, "localhost:%d", port);
-  args.server = grpc_server_create(NULL, NULL);
+  args.server = grpc_server_create(nullptr, nullptr);
   grpc_server_add_insecure_http2_port(args.server, args.addr);
-  args.cq = grpc_completion_queue_create_for_next(NULL);
-  grpc_server_register_completion_queue(args.server, args.cq, NULL);
+  args.cq = grpc_completion_queue_create_for_next(nullptr);
+  grpc_server_register_completion_queue(args.server, args.cq, nullptr);
   grpc_server_start(args.server);
   gpr_thd_new(&server, server_thread, &args, &options);
 
@@ -211,7 +213,7 @@ int run_concurrent_connectivity_test() {
 
   /* Third round, bogus tcp server */
   gpr_log(GPR_DEBUG, "Wave 3");
-  args.pollset = gpr_zalloc(grpc_pollset_size());
+  args.pollset = static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
   grpc_pollset_init(args.pollset, &args.mu);
   gpr_event_init(&args.ready);
   gpr_thd_new(&server, bad_server_thread, &args, &options);
@@ -236,10 +238,11 @@ int run_concurrent_connectivity_test() {
   return 0;
 }
 
-void watches_with_short_timeouts(void *addr) {
+void watches_with_short_timeouts(void* addr) {
   for (int i = 0; i < NUM_OUTER_LOOPS_SHORT_TIMEOUTS; ++i) {
-    grpc_completion_queue *cq = grpc_completion_queue_create_for_next(NULL);
-    grpc_channel *chan = grpc_insecure_channel_create((char *)addr, NULL, NULL);
+    grpc_completion_queue* cq = grpc_completion_queue_create_for_next(nullptr);
+    grpc_channel* chan =
+        grpc_insecure_channel_create((char*)addr, nullptr, nullptr);
 
     for (int j = 0; j < NUM_INNER_LOOPS_SHORT_TIMEOUTS; ++j) {
       gpr_timespec later_time =
@@ -247,10 +250,11 @@ void watches_with_short_timeouts(void *addr) {
       grpc_connectivity_state state =
           grpc_channel_check_connectivity_state(chan, 0);
       GPR_ASSERT(state == GRPC_CHANNEL_IDLE);
-      grpc_channel_watch_connectivity_state(chan, state, later_time, cq, NULL);
+      grpc_channel_watch_connectivity_state(chan, state, later_time, cq,
+                                            nullptr);
       gpr_timespec poll_time =
           grpc_timeout_milliseconds_to_deadline(POLL_MILLIS_SHORT_TIMEOUTS);
-      grpc_event ev = grpc_completion_queue_next(cq, poll_time, NULL);
+      grpc_event ev = grpc_completion_queue_next(cq, poll_time, nullptr);
       GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
       GPR_ASSERT(ev.success == false);
       /* check that the watcher from "watch state" was free'd */
@@ -269,7 +273,7 @@ int run_concurrent_watches_with_short_timeouts_test() {
 
   gpr_thd_id threads[NUM_THREADS];
 
-  char *localhost = gpr_strdup("localhost:54321");
+  char* localhost = gpr_strdup("localhost:54321");
   gpr_thd_options options = gpr_thd_options_default();
   gpr_thd_options_set_joinable(&options);
 
@@ -285,7 +289,7 @@ int run_concurrent_watches_with_short_timeouts_test() {
   return 0;
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
 
   run_concurrent_connectivity_test();
diff --git a/test/core/surface/init_test.c b/test/core/surface/init_test.cc
index b835a2a884..5749bc8b36 100644
--- a/test/core/surface/init_test.c
+++ b/test/core/surface/init_test.cc
@@ -59,7 +59,7 @@ static void test_repeatedly() {
   }
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test(1);
   test(2);
diff --git a/test/core/surface/invalid_channel_args_test.c b/test/core/surface/invalid_channel_args_test.cc
index 9c84c30f03..7c5f1f0352 100644
--- a/test/core/surface/invalid_channel_args_test.c
+++ b/test/core/surface/invalid_channel_args_test.cc
@@ -24,10 +24,10 @@
 #include <grpc/support/string_util.h>
 #include "test/core/util/test_config.h"
 
-static char *g_last_log_error_message = NULL;
-static const char *g_file_name = "channel.cc";
+static char* g_last_log_error_message = nullptr;
+static const char* g_file_name = "channel.cc";
 
-static int ends_with(const char *src, const char *suffix) {
+static int ends_with(const char* src, const char* suffix) {
   size_t src_len = strlen(src);
   size_t suffix_len = strlen(suffix);
   if (src_len < suffix_len) {
@@ -36,46 +36,46 @@ static int ends_with(const char *src, const char *suffix) {
   return strcmp(src + src_len - suffix_len, suffix) == 0;
 }
 
-static void log_error_sink(gpr_log_func_args *args) {
+static void log_error_sink(gpr_log_func_args* args) {
   if (args->severity == GPR_LOG_SEVERITY_ERROR &&
       ends_with(args->file, g_file_name)) {
     g_last_log_error_message = gpr_strdup(args->message);
   }
 }
 
-static void verify_last_error(const char *message) {
-  if (message == NULL) {
-    GPR_ASSERT(g_last_log_error_message == NULL);
+static void verify_last_error(const char* message) {
+  if (message == nullptr) {
+    GPR_ASSERT(g_last_log_error_message == nullptr);
     return;
   }
   GPR_ASSERT(strcmp(message, g_last_log_error_message) == 0);
   gpr_free(g_last_log_error_message);
-  g_last_log_error_message = NULL;
+  g_last_log_error_message = nullptr;
 }
 
-static char *compose_error_string(const char *key, const char *message) {
-  char *ret;
+static char* compose_error_string(const char* key, const char* message) {
+  char* ret;
   gpr_asprintf(&ret, "%s%s", key, message);
   return ret;
 }
 
-static void one_test(grpc_channel_args *args, char *expected_error_message) {
-  grpc_channel *chan =
-      grpc_insecure_channel_create("nonexistant:54321", args, NULL);
+static void one_test(grpc_channel_args* args, char* expected_error_message) {
+  grpc_channel* chan =
+      grpc_insecure_channel_create("nonexistant:54321", args, nullptr);
   verify_last_error(expected_error_message);
   gpr_free(expected_error_message);
   grpc_channel_destroy(chan);
 }
 
-static void test_no_error_message(void) { one_test(NULL, NULL); }
+static void test_no_error_message(void) { one_test(nullptr, nullptr); }
 
 static void test_default_authority_type(void) {
   grpc_arg client_arg;
   grpc_channel_args client_args;
-  char *expected_error_message;
+  char* expected_error_message;
 
   client_arg.type = GRPC_ARG_INTEGER;
-  client_arg.key = GRPC_ARG_DEFAULT_AUTHORITY;
+  client_arg.key = const_cast<char*>(GRPC_ARG_DEFAULT_AUTHORITY);
   client_arg.value.integer = 0;
 
   client_args.num_args = 1;
@@ -88,10 +88,10 @@ static void test_default_authority_type(void) {
 static void test_ssl_name_override_type(void) {
   grpc_arg client_arg;
   grpc_channel_args client_args;
-  char *expected_error_message;
+  char* expected_error_message;
 
   client_arg.type = GRPC_ARG_INTEGER;
-  client_arg.key = GRPC_SSL_TARGET_NAME_OVERRIDE_ARG;
+  client_arg.key = const_cast<char*>(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG);
   client_arg.value.integer = 0;
 
   client_args.num_args = 1;
@@ -104,14 +104,14 @@ static void test_ssl_name_override_type(void) {
 static void test_ssl_name_override_failed(void) {
   grpc_arg client_arg[2];
   grpc_channel_args client_args;
-  char *expected_error_message;
+  char* expected_error_message;
 
   client_arg[0].type = GRPC_ARG_STRING;
-  client_arg[0].key = GRPC_ARG_DEFAULT_AUTHORITY;
-  client_arg[0].value.string = "default";
+  client_arg[0].key = const_cast<char*>(GRPC_ARG_DEFAULT_AUTHORITY);
+  client_arg[0].value.string = const_cast<char*>("default");
   client_arg[1].type = GRPC_ARG_STRING;
-  client_arg[1].key = GRPC_SSL_TARGET_NAME_OVERRIDE_ARG;
-  client_arg[1].value.string = "ssl";
+  client_arg[1].key = const_cast<char*>(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG);
+  client_arg[1].value.string = const_cast<char*>("ssl");
 
   client_args.num_args = 2;
   client_args.args = client_arg;
@@ -121,7 +121,7 @@ static void test_ssl_name_override_failed(void) {
   one_test(&client_args, expected_error_message);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   gpr_set_log_function(log_error_sink);
diff --git a/test/core/surface/lame_client_test.c b/test/core/surface/lame_client_test.cc
index f623e1a743..f3df7f35a7 100644
--- a/test/core/surface/lame_client_test.c
+++ b/test/core/surface/lame_client_test.cc
@@ -30,53 +30,53 @@
 
 grpc_closure transport_op_cb;
 
-static void *tag(intptr_t x) { return (void *)x; }
+static void* tag(intptr_t x) { return (void*)x; }
 
-void verify_connectivity(grpc_exec_ctx *exec_ctx, void *arg,
-                         grpc_error *error) {
-  grpc_connectivity_state *state = arg;
+void verify_connectivity(grpc_exec_ctx* exec_ctx, void* arg,
+                         grpc_error* error) {
+  grpc_connectivity_state* state = static_cast<grpc_connectivity_state*>(arg);
   GPR_ASSERT(GRPC_CHANNEL_SHUTDOWN == *state);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
 }
 
-void do_nothing(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {}
+void do_nothing(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {}
 
-void test_transport_op(grpc_channel *channel) {
-  grpc_transport_op *op;
-  grpc_channel_element *elem;
+void test_transport_op(grpc_channel* channel) {
+  grpc_transport_op* op;
+  grpc_channel_element* elem;
   grpc_connectivity_state state = GRPC_CHANNEL_IDLE;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
   GRPC_CLOSURE_INIT(&transport_op_cb, verify_connectivity, &state,
                     grpc_schedule_on_exec_ctx);
 
-  op = grpc_make_transport_op(NULL);
+  op = grpc_make_transport_op(nullptr);
   op->on_connectivity_state_change = &transport_op_cb;
   op->connectivity_state = &state;
   elem = grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0);
   elem->filter->start_transport_op(&exec_ctx, elem, op);
   grpc_exec_ctx_finish(&exec_ctx);
 
-  GRPC_CLOSURE_INIT(&transport_op_cb, do_nothing, NULL,
+  GRPC_CLOSURE_INIT(&transport_op_cb, do_nothing, nullptr,
                     grpc_schedule_on_exec_ctx);
   op = grpc_make_transport_op(&transport_op_cb);
   elem->filter->start_transport_op(&exec_ctx, elem, op);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-int main(int argc, char **argv) {
-  grpc_channel *chan;
-  grpc_call *call;
-  grpc_completion_queue *cq;
-  cq_verifier *cqv;
+int main(int argc, char** argv) {
+  grpc_channel* chan;
+  grpc_call* call;
+  grpc_completion_queue* cq;
+  cq_verifier* cqv;
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_status_code status;
   grpc_call_error error;
   grpc_slice details;
-  char *peer;
+  char* peer;
 
   grpc_test_init(argc, argv);
   grpc_init();
@@ -93,12 +93,13 @@ int main(int argc, char **argv) {
   GPR_ASSERT(GRPC_CHANNEL_SHUTDOWN ==
              grpc_channel_check_connectivity_state(chan, 0));
 
-  cq = grpc_completion_queue_create_for_next(NULL);
+  cq = grpc_completion_queue_create_for_next(nullptr);
 
   grpc_slice host = grpc_slice_from_static_string("anywhere");
-  call = grpc_channel_create_call(chan, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
-                                  grpc_slice_from_static_string("/Foo"), &host,
-                                  grpc_timeout_seconds_to_deadline(100), NULL);
+  call =
+      grpc_channel_create_call(chan, nullptr, GRPC_PROPAGATE_DEFAULTS, cq,
+                               grpc_slice_from_static_string("/Foo"), &host,
+                               grpc_timeout_seconds_to_deadline(100), nullptr);
   GPR_ASSERT(call);
   cqv = cq_verifier_create(cq);
 
@@ -107,14 +108,14 @@ int main(int argc, char **argv) {
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(call, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(call, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   /* the call should immediately fail */
@@ -128,9 +129,9 @@ int main(int argc, char **argv) {
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(call, ops, (size_t)(op - ops), tag(2), NULL);
+  error = grpc_call_start_batch(call, ops, (size_t)(op - ops), tag(2), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   /* the call should immediately fail */
diff --git a/test/core/surface/num_external_connectivity_watchers_test.c b/test/core/surface/num_external_connectivity_watchers_test.cc
index 16401bb7ac..f78d333673 100644
--- a/test/core/surface/num_external_connectivity_watchers_test.c
+++ b/test/core/surface/num_external_connectivity_watchers_test.cc
@@ -30,28 +30,28 @@
 #include "test/core/util/test_config.h"
 
 typedef struct test_fixture {
-  const char *name;
-  grpc_channel *(*create_channel)(const char *addr);
+  const char* name;
+  grpc_channel* (*create_channel)(const char* addr);
 } test_fixture;
 
 static size_t next_tag = 1;
 
-static void channel_idle_start_watch(grpc_channel *channel,
-                                     grpc_completion_queue *cq) {
+static void channel_idle_start_watch(grpc_channel* channel,
+                                     grpc_completion_queue* cq) {
   gpr_timespec connect_deadline = grpc_timeout_milliseconds_to_deadline(1);
   GPR_ASSERT(grpc_channel_check_connectivity_state(channel, 0) ==
              GRPC_CHANNEL_IDLE);
 
   grpc_channel_watch_connectivity_state(
-      channel, GRPC_CHANNEL_IDLE, connect_deadline, cq, (void *)(next_tag++));
+      channel, GRPC_CHANNEL_IDLE, connect_deadline, cq, (void*)(next_tag++));
   gpr_log(GPR_DEBUG, "number of active connect watchers: %d",
           grpc_channel_num_external_connectivity_watchers(channel));
 }
 
-static void channel_idle_poll_for_timeout(grpc_channel *channel,
-                                          grpc_completion_queue *cq) {
-  grpc_event ev =
-      grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+static void channel_idle_poll_for_timeout(grpc_channel* channel,
+                                          grpc_completion_queue* cq) {
+  grpc_event ev = grpc_completion_queue_next(
+      cq, gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
 
   /* expect watch_connectivity_state to end with a timeout */
   GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
@@ -63,17 +63,17 @@ static void channel_idle_poll_for_timeout(grpc_channel *channel,
 /* Test and use the "num_external_watchers" call to make sure
  * that "connectivity watcher" structs are free'd just after, if
  * their corresponding timeouts occur. */
-static void run_timeouts_test(const test_fixture *fixture) {
+static void run_timeouts_test(const test_fixture* fixture) {
   gpr_log(GPR_INFO, "TEST: %s", fixture->name);
 
-  char *addr;
+  char* addr;
 
   grpc_init();
 
   gpr_join_host_port(&addr, "localhost", grpc_pick_unused_port_or_die());
 
-  grpc_channel *channel = fixture->create_channel(addr);
-  grpc_completion_queue *cq = grpc_completion_queue_create_for_next(NULL);
+  grpc_channel* channel = fixture->create_channel(addr);
+  grpc_completion_queue* cq = grpc_completion_queue_create_for_next(nullptr);
 
   /* start 1 watcher and then let it time out */
   channel_idle_start_watch(channel, cq);
@@ -105,9 +105,9 @@ static void run_timeouts_test(const test_fixture *fixture) {
 
   grpc_channel_destroy(channel);
   grpc_completion_queue_shutdown(cq);
-  GPR_ASSERT(
-      grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL)
-          .type == GRPC_QUEUE_SHUTDOWN);
+  GPR_ASSERT(grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME),
+                                        nullptr)
+                 .type == GRPC_QUEUE_SHUTDOWN);
   grpc_completion_queue_destroy(cq);
 
   grpc_shutdown();
@@ -117,17 +117,17 @@ static void run_timeouts_test(const test_fixture *fixture) {
 /* An edge scenario; sets channel state to explicitly, and outside
  * of a polling call. */
 static void run_channel_shutdown_before_timeout_test(
-    const test_fixture *fixture) {
+    const test_fixture* fixture) {
   gpr_log(GPR_INFO, "TEST: %s", fixture->name);
 
-  char *addr;
+  char* addr;
 
   grpc_init();
 
   gpr_join_host_port(&addr, "localhost", grpc_pick_unused_port_or_die());
 
-  grpc_channel *channel = fixture->create_channel(addr);
-  grpc_completion_queue *cq = grpc_completion_queue_create_for_next(NULL);
+  grpc_channel* channel = fixture->create_channel(addr);
+  grpc_completion_queue* cq = grpc_completion_queue_create_for_next(nullptr);
 
   /* start 1 watcher and then shut down the channel before the timer goes off */
   GPR_ASSERT(grpc_channel_num_external_connectivity_watchers(channel) == 0);
@@ -138,43 +138,45 @@ static void run_channel_shutdown_before_timeout_test(
              GRPC_CHANNEL_IDLE);
 
   grpc_channel_watch_connectivity_state(channel, GRPC_CHANNEL_IDLE,
-                                        connect_deadline, cq, (void *)1);
+                                        connect_deadline, cq, (void*)1);
   grpc_channel_destroy(channel);
 
-  grpc_event ev =
-      grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+  grpc_event ev = grpc_completion_queue_next(
+      cq, gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
   GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
   /* expect success with a state transition to CHANNEL_SHUTDOWN */
   GPR_ASSERT(ev.success == true);
 
   grpc_completion_queue_shutdown(cq);
-  GPR_ASSERT(
-      grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL)
-          .type == GRPC_QUEUE_SHUTDOWN);
+  GPR_ASSERT(grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME),
+                                        nullptr)
+                 .type == GRPC_QUEUE_SHUTDOWN);
   grpc_completion_queue_destroy(cq);
 
   grpc_shutdown();
   gpr_free(addr);
 }
 
-static grpc_channel *insecure_test_create_channel(const char *addr) {
-  return grpc_insecure_channel_create(addr, NULL, NULL);
+static grpc_channel* insecure_test_create_channel(const char* addr) {
+  return grpc_insecure_channel_create(addr, nullptr, nullptr);
 }
 
 static const test_fixture insecure_test = {
-    "insecure", insecure_test_create_channel,
+    "insecure",
+    insecure_test_create_channel,
 };
 
-static grpc_channel *secure_test_create_channel(const char *addr) {
-  grpc_channel_credentials *ssl_creds =
-      grpc_ssl_credentials_create(test_root_cert, NULL, NULL);
-  grpc_arg ssl_name_override = {GRPC_ARG_STRING,
-                                GRPC_SSL_TARGET_NAME_OVERRIDE_ARG,
-                                {"foo.test.google.fr"}};
-  grpc_channel_args *new_client_args =
-      grpc_channel_args_copy_and_add(NULL, &ssl_name_override, 1);
-  grpc_channel *channel =
-      grpc_secure_channel_create(ssl_creds, addr, new_client_args, NULL);
+static grpc_channel* secure_test_create_channel(const char* addr) {
+  grpc_channel_credentials* ssl_creds =
+      grpc_ssl_credentials_create(test_root_cert, nullptr, nullptr);
+  grpc_arg ssl_name_override = {
+      GRPC_ARG_STRING,
+      const_cast<char*>(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG),
+      {const_cast<char*>("foo.test.google.fr")}};
+  grpc_channel_args* new_client_args =
+      grpc_channel_args_copy_and_add(nullptr, &ssl_name_override, 1);
+  grpc_channel* channel =
+      grpc_secure_channel_create(ssl_creds, addr, new_client_args, nullptr);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_channel_args_destroy(&exec_ctx, new_client_args);
@@ -185,10 +187,11 @@ static grpc_channel *secure_test_create_channel(const char *addr) {
 }
 
 static const test_fixture secure_test = {
-    "secure", secure_test_create_channel,
+    "secure",
+    secure_test_create_channel,
 };
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
 
   run_timeouts_test(&insecure_test);
diff --git a/test/core/surface/public_headers_must_be_c89.c b/test/core/surface/public_headers_must_be_c89.c
index d36d116afb..b5a83c8eed 100644
--- a/test/core/surface/public_headers_must_be_c89.c
+++ b/test/core/surface/public_headers_must_be_c89.c
@@ -63,4 +63,289 @@
 #include <grpc/support/useful.h>
 #include <grpc/support/workaround_list.h>
 
-int main(int argc, char **argv) { return 0; }
+#include <stdio.h>
+
+int main(int argc, char **argv) {
+  printf("%lx", (unsigned long) grpc_compression_algorithm_parse);
+  printf("%lx", (unsigned long) grpc_compression_algorithm_name);
+  printf("%lx", (unsigned long) grpc_stream_compression_algorithm_name);
+  printf("%lx", (unsigned long) grpc_compression_algorithm_for_level);
+  printf("%lx", (unsigned long) grpc_stream_compression_algorithm_for_level);
+  printf("%lx", (unsigned long) grpc_compression_options_init);
+  printf("%lx", (unsigned long) grpc_compression_options_enable_algorithm);
+  printf("%lx", (unsigned long) grpc_compression_options_disable_algorithm);
+  printf("%lx", (unsigned long) grpc_compression_options_is_algorithm_enabled);
+  printf("%lx", (unsigned long) grpc_compression_options_is_stream_compression_algorithm_enabled);
+  printf("%lx", (unsigned long) grpc_metadata_array_init);
+  printf("%lx", (unsigned long) grpc_metadata_array_destroy);
+  printf("%lx", (unsigned long) grpc_call_details_init);
+  printf("%lx", (unsigned long) grpc_call_details_destroy);
+  printf("%lx", (unsigned long) grpc_register_plugin);
+  printf("%lx", (unsigned long) grpc_init);
+  printf("%lx", (unsigned long) grpc_shutdown);
+  printf("%lx", (unsigned long) grpc_version_string);
+  printf("%lx", (unsigned long) grpc_g_stands_for);
+  printf("%lx", (unsigned long) grpc_completion_queue_factory_lookup);
+  printf("%lx", (unsigned long) grpc_completion_queue_create_for_next);
+  printf("%lx", (unsigned long) grpc_completion_queue_create_for_pluck);
+  printf("%lx", (unsigned long) grpc_completion_queue_create);
+  printf("%lx", (unsigned long) grpc_completion_queue_next);
+  printf("%lx", (unsigned long) grpc_completion_queue_pluck);
+  printf("%lx", (unsigned long) grpc_completion_queue_shutdown);
+  printf("%lx", (unsigned long) grpc_completion_queue_destroy);
+  printf("%lx", (unsigned long) grpc_completion_queue_thread_local_cache_init);
+  printf("%lx", (unsigned long) grpc_completion_queue_thread_local_cache_flush);
+  printf("%lx", (unsigned long) grpc_alarm_create);
+  printf("%lx", (unsigned long) grpc_alarm_set);
+  printf("%lx", (unsigned long) grpc_alarm_cancel);
+  printf("%lx", (unsigned long) grpc_alarm_destroy);
+  printf("%lx", (unsigned long) grpc_channel_check_connectivity_state);
+  printf("%lx", (unsigned long) grpc_channel_num_external_connectivity_watchers);
+  printf("%lx", (unsigned long) grpc_channel_watch_connectivity_state);
+  printf("%lx", (unsigned long) grpc_channel_support_connectivity_watcher);
+  printf("%lx", (unsigned long) grpc_channel_create_call);
+  printf("%lx", (unsigned long) grpc_channel_ping);
+  printf("%lx", (unsigned long) grpc_channel_register_call);
+  printf("%lx", (unsigned long) grpc_channel_create_registered_call);
+  printf("%lx", (unsigned long) grpc_call_arena_alloc);
+  printf("%lx", (unsigned long) grpc_call_start_batch);
+  printf("%lx", (unsigned long) grpc_call_get_peer);
+  printf("%lx", (unsigned long) grpc_census_call_set_context);
+  printf("%lx", (unsigned long) grpc_census_call_get_context);
+  printf("%lx", (unsigned long) grpc_channel_get_target);
+  printf("%lx", (unsigned long) grpc_channel_get_info);
+  printf("%lx", (unsigned long) grpc_insecure_channel_create);
+  printf("%lx", (unsigned long) grpc_lame_client_channel_create);
+  printf("%lx", (unsigned long) grpc_channel_destroy);
+  printf("%lx", (unsigned long) grpc_call_cancel);
+  printf("%lx", (unsigned long) grpc_call_cancel_with_status);
+  printf("%lx", (unsigned long) grpc_call_ref);
+  printf("%lx", (unsigned long) grpc_call_unref);
+  printf("%lx", (unsigned long) grpc_server_request_call);
+  printf("%lx", (unsigned long) grpc_server_register_method);
+  printf("%lx", (unsigned long) grpc_server_request_registered_call);
+  printf("%lx", (unsigned long) grpc_server_create);
+  printf("%lx", (unsigned long) grpc_server_register_completion_queue);
+  printf("%lx", (unsigned long) grpc_server_add_insecure_http2_port);
+  printf("%lx", (unsigned long) grpc_server_start);
+  printf("%lx", (unsigned long) grpc_server_shutdown_and_notify);
+  printf("%lx", (unsigned long) grpc_server_cancel_all_calls);
+  printf("%lx", (unsigned long) grpc_server_destroy);
+  printf("%lx", (unsigned long) grpc_tracer_set_enabled);
+  printf("%lx", (unsigned long) grpc_header_key_is_legal);
+  printf("%lx", (unsigned long) grpc_header_nonbin_value_is_legal);
+  printf("%lx", (unsigned long) grpc_is_binary_header);
+  printf("%lx", (unsigned long) grpc_call_error_to_string);
+  printf("%lx", (unsigned long) grpc_resource_quota_create);
+  printf("%lx", (unsigned long) grpc_resource_quota_ref);
+  printf("%lx", (unsigned long) grpc_resource_quota_unref);
+  printf("%lx", (unsigned long) grpc_resource_quota_resize);
+  printf("%lx", (unsigned long) grpc_resource_quota_arg_vtable);
+  printf("%lx", (unsigned long) grpc_auth_property_iterator_next);
+  printf("%lx", (unsigned long) grpc_auth_context_property_iterator);
+  printf("%lx", (unsigned long) grpc_auth_context_peer_identity);
+  printf("%lx", (unsigned long) grpc_auth_context_find_properties_by_name);
+  printf("%lx", (unsigned long) grpc_auth_context_peer_identity_property_name);
+  printf("%lx", (unsigned long) grpc_auth_context_peer_is_authenticated);
+  printf("%lx", (unsigned long) grpc_call_auth_context);
+  printf("%lx", (unsigned long) grpc_auth_context_release);
+  printf("%lx", (unsigned long) grpc_auth_context_add_property);
+  printf("%lx", (unsigned long) grpc_auth_context_add_cstring_property);
+  printf("%lx", (unsigned long) grpc_auth_context_set_peer_identity_property_name);
+  printf("%lx", (unsigned long) grpc_channel_credentials_release);
+  printf("%lx", (unsigned long) grpc_google_default_credentials_create);
+  printf("%lx", (unsigned long) grpc_set_ssl_roots_override_callback);
+  printf("%lx", (unsigned long) grpc_ssl_credentials_create);
+  printf("%lx", (unsigned long) grpc_call_credentials_release);
+  printf("%lx", (unsigned long) grpc_composite_channel_credentials_create);
+  printf("%lx", (unsigned long) grpc_composite_call_credentials_create);
+  printf("%lx", (unsigned long) grpc_google_compute_engine_credentials_create);
+  printf("%lx", (unsigned long) grpc_max_auth_token_lifetime);
+  printf("%lx", (unsigned long) grpc_service_account_jwt_access_credentials_create);
+  printf("%lx", (unsigned long) grpc_google_refresh_token_credentials_create);
+  printf("%lx", (unsigned long) grpc_access_token_credentials_create);
+  printf("%lx", (unsigned long) grpc_google_iam_credentials_create);
+  printf("%lx", (unsigned long) grpc_metadata_credentials_create_from_plugin);
+  printf("%lx", (unsigned long) grpc_secure_channel_create);
+  printf("%lx", (unsigned long) grpc_server_credentials_release);
+  printf("%lx", (unsigned long) grpc_ssl_server_certificate_config_create);
+  printf("%lx", (unsigned long) grpc_ssl_server_certificate_config_destroy);
+  printf("%lx", (unsigned long) grpc_ssl_server_credentials_create);
+  printf("%lx", (unsigned long) grpc_ssl_server_credentials_create_ex);
+  printf("%lx", (unsigned long) grpc_ssl_server_credentials_create_options_using_config);
+  printf("%lx", (unsigned long) grpc_ssl_server_credentials_create_options_using_config_fetcher);
+  printf("%lx", (unsigned long) grpc_ssl_server_credentials_options_destroy);
+  printf("%lx", (unsigned long) grpc_ssl_server_credentials_create_with_options);
+  printf("%lx", (unsigned long) grpc_server_add_secure_http2_port);
+  printf("%lx", (unsigned long) grpc_call_set_credentials);
+  printf("%lx", (unsigned long) grpc_server_credentials_set_auth_metadata_processor);
+  printf("%lx", (unsigned long) grpc_raw_byte_buffer_create);
+  printf("%lx", (unsigned long) grpc_raw_compressed_byte_buffer_create);
+  printf("%lx", (unsigned long) grpc_byte_buffer_copy);
+  printf("%lx", (unsigned long) grpc_byte_buffer_length);
+  printf("%lx", (unsigned long) grpc_byte_buffer_destroy);
+  printf("%lx", (unsigned long) grpc_byte_buffer_reader_init);
+  printf("%lx", (unsigned long) grpc_byte_buffer_reader_destroy);
+  printf("%lx", (unsigned long) grpc_byte_buffer_reader_next);
+  printf("%lx", (unsigned long) grpc_byte_buffer_reader_readall);
+  printf("%lx", (unsigned long) grpc_raw_byte_buffer_from_reader);
+  printf("%lx", (unsigned long) grpc_slice_ref);
+  printf("%lx", (unsigned long) grpc_slice_unref);
+  printf("%lx", (unsigned long) grpc_slice_copy);
+  printf("%lx", (unsigned long) grpc_slice_new);
+  printf("%lx", (unsigned long) grpc_slice_new_with_user_data);
+  printf("%lx", (unsigned long) grpc_slice_new_with_len);
+  printf("%lx", (unsigned long) grpc_slice_malloc);
+  printf("%lx", (unsigned long) grpc_slice_malloc_large);
+  printf("%lx", (unsigned long) grpc_slice_intern);
+  printf("%lx", (unsigned long) grpc_slice_from_copied_string);
+  printf("%lx", (unsigned long) grpc_slice_from_copied_buffer);
+  printf("%lx", (unsigned long) grpc_slice_from_static_string);
+  printf("%lx", (unsigned long) grpc_slice_from_static_buffer);
+  printf("%lx", (unsigned long) grpc_slice_sub);
+  printf("%lx", (unsigned long) grpc_slice_sub_no_ref);
+  printf("%lx", (unsigned long) grpc_slice_split_tail);
+  printf("%lx", (unsigned long) grpc_slice_split_tail_maybe_ref);
+  printf("%lx", (unsigned long) grpc_slice_split_head);
+  printf("%lx", (unsigned long) grpc_empty_slice);
+  printf("%lx", (unsigned long) grpc_slice_default_hash_impl);
+  printf("%lx", (unsigned long) grpc_slice_default_eq_impl);
+  printf("%lx", (unsigned long) grpc_slice_eq);
+  printf("%lx", (unsigned long) grpc_slice_cmp);
+  printf("%lx", (unsigned long) grpc_slice_str_cmp);
+  printf("%lx", (unsigned long) grpc_slice_buf_start_eq);
+  printf("%lx", (unsigned long) grpc_slice_rchr);
+  printf("%lx", (unsigned long) grpc_slice_chr);
+  printf("%lx", (unsigned long) grpc_slice_slice);
+  printf("%lx", (unsigned long) grpc_slice_hash);
+  printf("%lx", (unsigned long) grpc_slice_is_equivalent);
+  printf("%lx", (unsigned long) grpc_slice_dup);
+  printf("%lx", (unsigned long) grpc_slice_to_c_string);
+  printf("%lx", (unsigned long) grpc_slice_buffer_init);
+  printf("%lx", (unsigned long) grpc_slice_buffer_destroy);
+  printf("%lx", (unsigned long) grpc_slice_buffer_add);
+  printf("%lx", (unsigned long) grpc_slice_buffer_add_indexed);
+  printf("%lx", (unsigned long) grpc_slice_buffer_addn);
+  printf("%lx", (unsigned long) grpc_slice_buffer_tiny_add);
+  printf("%lx", (unsigned long) grpc_slice_buffer_pop);
+  printf("%lx", (unsigned long) grpc_slice_buffer_reset_and_unref);
+  printf("%lx", (unsigned long) grpc_slice_buffer_swap);
+  printf("%lx", (unsigned long) grpc_slice_buffer_move_into);
+  printf("%lx", (unsigned long) grpc_slice_buffer_trim_end);
+  printf("%lx", (unsigned long) grpc_slice_buffer_move_first);
+  printf("%lx", (unsigned long) grpc_slice_buffer_move_first_no_ref);
+  printf("%lx", (unsigned long) grpc_slice_buffer_move_first_into_buffer);
+  printf("%lx", (unsigned long) grpc_slice_buffer_take_first);
+  printf("%lx", (unsigned long) grpc_slice_buffer_undo_take_first);
+  printf("%lx", (unsigned long) gpr_malloc);
+  printf("%lx", (unsigned long) gpr_zalloc);
+  printf("%lx", (unsigned long) gpr_free);
+  printf("%lx", (unsigned long) gpr_realloc);
+  printf("%lx", (unsigned long) gpr_malloc_aligned);
+  printf("%lx", (unsigned long) gpr_free_aligned);
+  printf("%lx", (unsigned long) gpr_set_allocation_functions);
+  printf("%lx", (unsigned long) gpr_get_allocation_functions);
+  printf("%lx", (unsigned long) gpr_avl_create);
+  printf("%lx", (unsigned long) gpr_avl_ref);
+  printf("%lx", (unsigned long) gpr_avl_unref);
+  printf("%lx", (unsigned long) gpr_avl_add);
+  printf("%lx", (unsigned long) gpr_avl_remove);
+  printf("%lx", (unsigned long) gpr_avl_get);
+  printf("%lx", (unsigned long) gpr_avl_maybe_get);
+  printf("%lx", (unsigned long) gpr_avl_is_empty);
+  printf("%lx", (unsigned long) gpr_cmdline_create);
+  printf("%lx", (unsigned long) gpr_cmdline_add_int);
+  printf("%lx", (unsigned long) gpr_cmdline_add_flag);
+  printf("%lx", (unsigned long) gpr_cmdline_add_string);
+  printf("%lx", (unsigned long) gpr_cmdline_on_extra_arg);
+  printf("%lx", (unsigned long) gpr_cmdline_set_survive_failure);
+  printf("%lx", (unsigned long) gpr_cmdline_parse);
+  printf("%lx", (unsigned long) gpr_cmdline_destroy);
+  printf("%lx", (unsigned long) gpr_cmdline_usage_string);
+  printf("%lx", (unsigned long) gpr_cpu_num_cores);
+  printf("%lx", (unsigned long) gpr_cpu_current_cpu);
+  printf("%lx", (unsigned long) gpr_histogram_create);
+  printf("%lx", (unsigned long) gpr_histogram_destroy);
+  printf("%lx", (unsigned long) gpr_histogram_add);
+  printf("%lx", (unsigned long) gpr_histogram_merge);
+  printf("%lx", (unsigned long) gpr_histogram_percentile);
+  printf("%lx", (unsigned long) gpr_histogram_mean);
+  printf("%lx", (unsigned long) gpr_histogram_stddev);
+  printf("%lx", (unsigned long) gpr_histogram_variance);
+  printf("%lx", (unsigned long) gpr_histogram_maximum);
+  printf("%lx", (unsigned long) gpr_histogram_minimum);
+  printf("%lx", (unsigned long) gpr_histogram_count);
+  printf("%lx", (unsigned long) gpr_histogram_sum);
+  printf("%lx", (unsigned long) gpr_histogram_sum_of_squares);
+  printf("%lx", (unsigned long) gpr_histogram_get_contents);
+  printf("%lx", (unsigned long) gpr_histogram_merge_contents);
+  printf("%lx", (unsigned long) gpr_join_host_port);
+  printf("%lx", (unsigned long) gpr_split_host_port);
+  printf("%lx", (unsigned long) gpr_log_severity_string);
+  printf("%lx", (unsigned long) gpr_log);
+  printf("%lx", (unsigned long) gpr_log_message);
+  printf("%lx", (unsigned long) gpr_set_log_verbosity);
+  printf("%lx", (unsigned long) gpr_log_verbosity_init);
+  printf("%lx", (unsigned long) gpr_set_log_function);
+  printf("%lx", (unsigned long) gpr_strdup);
+  printf("%lx", (unsigned long) gpr_asprintf);
+  printf("%lx", (unsigned long) gpr_subprocess_binary_extension);
+  printf("%lx", (unsigned long) gpr_subprocess_create);
+  printf("%lx", (unsigned long) gpr_subprocess_destroy);
+  printf("%lx", (unsigned long) gpr_subprocess_join);
+  printf("%lx", (unsigned long) gpr_subprocess_interrupt);
+  printf("%lx", (unsigned long) gpr_mu_init);
+  printf("%lx", (unsigned long) gpr_mu_destroy);
+  printf("%lx", (unsigned long) gpr_mu_lock);
+  printf("%lx", (unsigned long) gpr_mu_unlock);
+  printf("%lx", (unsigned long) gpr_mu_trylock);
+  printf("%lx", (unsigned long) gpr_cv_init);
+  printf("%lx", (unsigned long) gpr_cv_destroy);
+  printf("%lx", (unsigned long) gpr_cv_wait);
+  printf("%lx", (unsigned long) gpr_cv_signal);
+  printf("%lx", (unsigned long) gpr_cv_broadcast);
+  printf("%lx", (unsigned long) gpr_once_init);
+  printf("%lx", (unsigned long) gpr_event_init);
+  printf("%lx", (unsigned long) gpr_event_set);
+  printf("%lx", (unsigned long) gpr_event_get);
+  printf("%lx", (unsigned long) gpr_event_wait);
+  printf("%lx", (unsigned long) gpr_ref_init);
+  printf("%lx", (unsigned long) gpr_ref);
+  printf("%lx", (unsigned long) gpr_ref_non_zero);
+  printf("%lx", (unsigned long) gpr_refn);
+  printf("%lx", (unsigned long) gpr_unref);
+  printf("%lx", (unsigned long) gpr_ref_is_unique);
+  printf("%lx", (unsigned long) gpr_stats_init);
+  printf("%lx", (unsigned long) gpr_stats_inc);
+  printf("%lx", (unsigned long) gpr_stats_read);
+  printf("%lx", (unsigned long) gpr_thd_new);
+  printf("%lx", (unsigned long) gpr_thd_options_default);
+  printf("%lx", (unsigned long) gpr_thd_options_set_detached);
+  printf("%lx", (unsigned long) gpr_thd_options_set_joinable);
+  printf("%lx", (unsigned long) gpr_thd_options_is_detached);
+  printf("%lx", (unsigned long) gpr_thd_options_is_joinable);
+  printf("%lx", (unsigned long) gpr_thd_currentid);
+  printf("%lx", (unsigned long) gpr_thd_join);
+  printf("%lx", (unsigned long) gpr_time_0);
+  printf("%lx", (unsigned long) gpr_inf_future);
+  printf("%lx", (unsigned long) gpr_inf_past);
+  printf("%lx", (unsigned long) gpr_time_init);
+  printf("%lx", (unsigned long) gpr_now);
+  printf("%lx", (unsigned long) gpr_convert_clock_type);
+  printf("%lx", (unsigned long) gpr_time_cmp);
+  printf("%lx", (unsigned long) gpr_time_max);
+  printf("%lx", (unsigned long) gpr_time_min);
+  printf("%lx", (unsigned long) gpr_time_add);
+  printf("%lx", (unsigned long) gpr_time_sub);
+  printf("%lx", (unsigned long) gpr_time_from_micros);
+  printf("%lx", (unsigned long) gpr_time_from_nanos);
+  printf("%lx", (unsigned long) gpr_time_from_millis);
+  printf("%lx", (unsigned long) gpr_time_from_seconds);
+  printf("%lx", (unsigned long) gpr_time_from_minutes);
+  printf("%lx", (unsigned long) gpr_time_from_hours);
+  printf("%lx", (unsigned long) gpr_time_to_millis);
+  printf("%lx", (unsigned long) gpr_time_similar);
+  printf("%lx", (unsigned long) gpr_sleep_until);
+  printf("%lx", (unsigned long) gpr_timespec_to_micros);
+  return 0;
+}
diff --git a/test/core/surface/secure_channel_create_test.c b/test/core/surface/secure_channel_create_test.cc
index 0c45135501..c31c61430c 100644
--- a/test/core/surface/secure_channel_create_test.c
+++ b/test/core/surface/secure_channel_create_test.cc
@@ -30,11 +30,11 @@
 void test_unknown_scheme_target(void) {
   grpc_resolver_registry_shutdown();
   grpc_resolver_registry_init();
-  grpc_channel_credentials *creds =
+  grpc_channel_credentials* creds =
       grpc_fake_transport_security_credentials_create();
-  grpc_channel *chan =
-      grpc_secure_channel_create(creds, "blah://blah", NULL, NULL);
-  grpc_channel_element *elem =
+  grpc_channel* chan =
+      grpc_secure_channel_create(creds, "blah://blah", nullptr, nullptr);
+  grpc_channel_element* elem =
       grpc_channel_stack_element(grpc_channel_get_channel_stack(chan), 0);
   GPR_ASSERT(0 == strcmp(elem->filter->name, "lame-client"));
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -46,13 +46,14 @@ void test_unknown_scheme_target(void) {
 void test_security_connector_already_in_arg(void) {
   grpc_arg arg;
   arg.type = GRPC_ARG_POINTER;
-  arg.value.pointer.p = NULL;
-  arg.key = GRPC_ARG_SECURITY_CONNECTOR;
+  arg.value.pointer.p = nullptr;
+  arg.key = const_cast<char*>(GRPC_ARG_SECURITY_CONNECTOR);
   grpc_channel_args args;
   args.num_args = 1;
   args.args = &arg;
-  grpc_channel *chan = grpc_secure_channel_create(NULL, NULL, &args, NULL);
-  grpc_channel_element *elem =
+  grpc_channel* chan =
+      grpc_secure_channel_create(nullptr, nullptr, &args, nullptr);
+  grpc_channel_element* elem =
       grpc_channel_stack_element(grpc_channel_get_channel_stack(chan), 0);
   GPR_ASSERT(0 == strcmp(elem->filter->name, "lame-client"));
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -61,8 +62,9 @@ void test_security_connector_already_in_arg(void) {
 }
 
 void test_null_creds(void) {
-  grpc_channel *chan = grpc_secure_channel_create(NULL, NULL, NULL, NULL);
-  grpc_channel_element *elem =
+  grpc_channel* chan =
+      grpc_secure_channel_create(nullptr, nullptr, nullptr, nullptr);
+  grpc_channel_element* elem =
       grpc_channel_stack_element(grpc_channel_get_channel_stack(chan), 0);
   GPR_ASSERT(0 == strcmp(elem->filter->name, "lame-client"));
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -70,7 +72,7 @@ void test_null_creds(void) {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   test_security_connector_already_in_arg();
diff --git a/test/core/surface/sequential_connectivity_test.c b/test/core/surface/sequential_connectivity_test.cc
index d5fd2db81b..015db92cb0 100644
--- a/test/core/surface/sequential_connectivity_test.c
+++ b/test/core/surface/sequential_connectivity_test.cc
@@ -30,40 +30,40 @@
 #include "test/core/util/test_config.h"
 
 typedef struct test_fixture {
-  const char *name;
-  void (*add_server_port)(grpc_server *server, const char *addr);
-  grpc_channel *(*create_channel)(const char *addr);
+  const char* name;
+  void (*add_server_port)(grpc_server* server, const char* addr);
+  grpc_channel* (*create_channel)(const char* addr);
 } test_fixture;
 
 #define NUM_CONNECTIONS 1000
 
 typedef struct {
-  grpc_server *server;
-  grpc_completion_queue *cq;
+  grpc_server* server;
+  grpc_completion_queue* cq;
 } server_thread_args;
 
-static void server_thread_func(void *args) {
-  server_thread_args *a = args;
+static void server_thread_func(void* args) {
+  server_thread_args* a = static_cast<server_thread_args*>(args);
   grpc_event ev = grpc_completion_queue_next(
-      a->cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+      a->cq, gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
   GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
-  GPR_ASSERT(ev.tag == NULL);
+  GPR_ASSERT(ev.tag == nullptr);
   GPR_ASSERT(ev.success == true);
 }
 
-static void run_test(const test_fixture *fixture) {
+static void run_test(const test_fixture* fixture) {
   gpr_log(GPR_INFO, "TEST: %s", fixture->name);
 
   grpc_init();
 
-  char *addr;
+  char* addr;
   gpr_join_host_port(&addr, "localhost", grpc_pick_unused_port_or_die());
 
-  grpc_server *server = grpc_server_create(NULL, NULL);
+  grpc_server* server = grpc_server_create(nullptr, nullptr);
   fixture->add_server_port(server, addr);
-  grpc_completion_queue *server_cq =
-      grpc_completion_queue_create_for_next(NULL);
-  grpc_server_register_completion_queue(server, server_cq, NULL);
+  grpc_completion_queue* server_cq =
+      grpc_completion_queue_create_for_next(nullptr);
+  grpc_server_register_completion_queue(server, server_cq, nullptr);
   grpc_server_start(server);
 
   server_thread_args sta = {server, server_cq};
@@ -72,8 +72,8 @@ static void run_test(const test_fixture *fixture) {
   gpr_thd_options_set_joinable(&thdopt);
   gpr_thd_new(&server_thread, server_thread_func, &sta, &thdopt);
 
-  grpc_completion_queue *cq = grpc_completion_queue_create_for_next(NULL);
-  grpc_channel *channels[NUM_CONNECTIONS];
+  grpc_completion_queue* cq = grpc_completion_queue_create_for_next(nullptr);
+  grpc_channel* channels[NUM_CONNECTIONS];
   for (size_t i = 0; i < NUM_CONNECTIONS; i++) {
     channels[i] = fixture->create_channel(addr);
 
@@ -82,31 +82,31 @@ static void run_test(const test_fixture *fixture) {
     while ((state = grpc_channel_check_connectivity_state(channels[i], 1)) !=
            GRPC_CHANNEL_READY) {
       grpc_channel_watch_connectivity_state(channels[i], state,
-                                            connect_deadline, cq, NULL);
+                                            connect_deadline, cq, nullptr);
       grpc_event ev = grpc_completion_queue_next(
-          cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+          cq, gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
       /* check that the watcher from "watch state" was free'd */
       GPR_ASSERT(grpc_channel_num_external_connectivity_watchers(channels[i]) ==
                  0);
       GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
-      GPR_ASSERT(ev.tag == NULL);
+      GPR_ASSERT(ev.tag == nullptr);
       GPR_ASSERT(ev.success == true);
     }
   }
 
-  grpc_server_shutdown_and_notify(server, server_cq, NULL);
+  grpc_server_shutdown_and_notify(server, server_cq, nullptr);
   gpr_thd_join(server_thread);
 
   grpc_completion_queue_shutdown(server_cq);
   grpc_completion_queue_shutdown(cq);
 
   while (grpc_completion_queue_next(server_cq,
-                                    gpr_inf_future(GPR_CLOCK_REALTIME), NULL)
+                                    gpr_inf_future(GPR_CLOCK_REALTIME), nullptr)
              .type != GRPC_QUEUE_SHUTDOWN)
     ;
-  while (
-      grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL)
-          .type != GRPC_QUEUE_SHUTDOWN)
+  while (grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME),
+                                    nullptr)
+             .type != GRPC_QUEUE_SHUTDOWN)
     ;
 
   for (size_t i = 0; i < NUM_CONNECTIONS; i++) {
@@ -121,37 +121,40 @@ static void run_test(const test_fixture *fixture) {
   gpr_free(addr);
 }
 
-static void insecure_test_add_port(grpc_server *server, const char *addr) {
+static void insecure_test_add_port(grpc_server* server, const char* addr) {
   grpc_server_add_insecure_http2_port(server, addr);
 }
 
-static grpc_channel *insecure_test_create_channel(const char *addr) {
-  return grpc_insecure_channel_create(addr, NULL, NULL);
+static grpc_channel* insecure_test_create_channel(const char* addr) {
+  return grpc_insecure_channel_create(addr, nullptr, nullptr);
 }
 
 static const test_fixture insecure_test = {
-    "insecure", insecure_test_add_port, insecure_test_create_channel,
+    "insecure",
+    insecure_test_add_port,
+    insecure_test_create_channel,
 };
 
-static void secure_test_add_port(grpc_server *server, const char *addr) {
+static void secure_test_add_port(grpc_server* server, const char* addr) {
   grpc_ssl_pem_key_cert_pair pem_cert_key_pair = {test_server1_key,
                                                   test_server1_cert};
-  grpc_server_credentials *ssl_creds =
-      grpc_ssl_server_credentials_create(NULL, &pem_cert_key_pair, 1, 0, NULL);
+  grpc_server_credentials* ssl_creds = grpc_ssl_server_credentials_create(
+      nullptr, &pem_cert_key_pair, 1, 0, nullptr);
   grpc_server_add_secure_http2_port(server, addr, ssl_creds);
   grpc_server_credentials_release(ssl_creds);
 }
 
-static grpc_channel *secure_test_create_channel(const char *addr) {
-  grpc_channel_credentials *ssl_creds =
-      grpc_ssl_credentials_create(test_root_cert, NULL, NULL);
-  grpc_arg ssl_name_override = {GRPC_ARG_STRING,
-                                GRPC_SSL_TARGET_NAME_OVERRIDE_ARG,
-                                {"foo.test.google.fr"}};
-  grpc_channel_args *new_client_args =
-      grpc_channel_args_copy_and_add(NULL, &ssl_name_override, 1);
-  grpc_channel *channel =
-      grpc_secure_channel_create(ssl_creds, addr, new_client_args, NULL);
+static grpc_channel* secure_test_create_channel(const char* addr) {
+  grpc_channel_credentials* ssl_creds =
+      grpc_ssl_credentials_create(test_root_cert, nullptr, nullptr);
+  grpc_arg ssl_name_override = {
+      GRPC_ARG_STRING,
+      const_cast<char*>(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG),
+      {const_cast<char*>("foo.test.google.fr")}};
+  grpc_channel_args* new_client_args =
+      grpc_channel_args_copy_and_add(nullptr, &ssl_name_override, 1);
+  grpc_channel* channel =
+      grpc_secure_channel_create(ssl_creds, addr, new_client_args, nullptr);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_channel_args_destroy(&exec_ctx, new_client_args);
@@ -162,10 +165,12 @@ static grpc_channel *secure_test_create_channel(const char *addr) {
 }
 
 static const test_fixture secure_test = {
-    "secure", secure_test_add_port, secure_test_create_channel,
+    "secure",
+    secure_test_add_port,
+    secure_test_create_channel,
 };
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
 
   run_test(&insecure_test);
diff --git a/test/core/surface/server_chttp2_test.c b/test/core/surface/server_chttp2_test.cc
index cd8931e0d7..96eaa6a7a9 100644
--- a/test/core/surface/server_chttp2_test.c
+++ b/test/core/surface/server_chttp2_test.cc
@@ -29,8 +29,8 @@
 #include "test/core/util/test_config.h"
 
 void test_unparsable_target(void) {
-  grpc_channel_args args = {0, NULL};
-  grpc_server *server = grpc_server_create(&args, NULL);
+  grpc_channel_args args = {0, nullptr};
+  grpc_server* server = grpc_server_create(&args, nullptr);
   int port = grpc_server_add_insecure_http2_port(server, "[");
   GPR_ASSERT(port == 0);
   grpc_server_destroy(server);
@@ -39,15 +39,15 @@ void test_unparsable_target(void) {
 void test_add_same_port_twice() {
   grpc_arg a;
   a.type = GRPC_ARG_INTEGER;
-  a.key = GRPC_ARG_ALLOW_REUSEPORT;
+  a.key = const_cast<char*>(GRPC_ARG_ALLOW_REUSEPORT);
   a.value.integer = 0;
   grpc_channel_args args = {1, &a};
 
   int port = grpc_pick_unused_port_or_die();
-  char *addr = NULL;
-  grpc_completion_queue *cq = grpc_completion_queue_create_for_pluck(NULL);
-  grpc_server *server = grpc_server_create(&args, NULL);
-  grpc_server_credentials *fake_creds =
+  char* addr = nullptr;
+  grpc_completion_queue* cq = grpc_completion_queue_create_for_pluck(nullptr);
+  grpc_server* server = grpc_server_create(&args, nullptr);
+  grpc_server_credentials* fake_creds =
       grpc_fake_transport_security_server_credentials_create();
   gpr_join_host_port(&addr, "localhost", port);
   GPR_ASSERT(grpc_server_add_secure_http2_port(server, addr, fake_creds));
@@ -55,14 +55,14 @@ void test_add_same_port_twice() {
 
   grpc_server_credentials_release(fake_creds);
   gpr_free(addr);
-  grpc_server_shutdown_and_notify(server, cq, NULL);
-  grpc_completion_queue_pluck(cq, NULL, gpr_inf_future(GPR_CLOCK_REALTIME),
-                              NULL);
+  grpc_server_shutdown_and_notify(server, cq, nullptr);
+  grpc_completion_queue_pluck(cq, nullptr, gpr_inf_future(GPR_CLOCK_REALTIME),
+                              nullptr);
   grpc_server_destroy(server);
   grpc_completion_queue_destroy(cq);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   test_unparsable_target();
diff --git a/test/core/surface/server_test.c b/test/core/surface/server_test.cc
index 4c185cd8ea..969b8cb11b 100644
--- a/test/core/surface/server_test.c
+++ b/test/core/surface/server_test.cc
@@ -28,40 +28,42 @@
 #include "test/core/util/test_config.h"
 
 void test_register_method_fail(void) {
-  grpc_server *server = grpc_server_create(NULL, NULL);
-  void *method;
-  void *method_old;
-  method =
-      grpc_server_register_method(server, NULL, NULL, GRPC_SRM_PAYLOAD_NONE, 0);
-  GPR_ASSERT(method == NULL);
+  grpc_server* server = grpc_server_create(nullptr, nullptr);
+  void* method;
+  void* method_old;
+  method = grpc_server_register_method(server, nullptr, nullptr,
+                                       GRPC_SRM_PAYLOAD_NONE, 0);
+  GPR_ASSERT(method == nullptr);
   method_old =
       grpc_server_register_method(server, "m", "h", GRPC_SRM_PAYLOAD_NONE, 0);
-  GPR_ASSERT(method_old != NULL);
+  GPR_ASSERT(method_old != nullptr);
   method = grpc_server_register_method(
       server, "m", "h", GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER, 0);
-  GPR_ASSERT(method == NULL);
+  GPR_ASSERT(method == nullptr);
   method_old =
       grpc_server_register_method(server, "m2", "h2", GRPC_SRM_PAYLOAD_NONE,
                                   GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST);
-  GPR_ASSERT(method_old != NULL);
+  GPR_ASSERT(method_old != nullptr);
   method =
       grpc_server_register_method(server, "m2", "h2", GRPC_SRM_PAYLOAD_NONE, 0);
-  GPR_ASSERT(method == NULL);
+  GPR_ASSERT(method == nullptr);
   method = grpc_server_register_method(
       server, "m2", "h2", GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER,
       GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST);
-  GPR_ASSERT(method == NULL);
+  GPR_ASSERT(method == nullptr);
   grpc_server_destroy(server);
 }
 
 void test_request_call_on_no_server_cq(void) {
-  grpc_completion_queue *cc = grpc_completion_queue_create_for_next(NULL);
-  grpc_server *server = grpc_server_create(NULL, NULL);
+  grpc_completion_queue* cc = grpc_completion_queue_create_for_next(nullptr);
+  grpc_server* server = grpc_server_create(nullptr, nullptr);
   GPR_ASSERT(GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE ==
-             grpc_server_request_call(server, NULL, NULL, NULL, cc, cc, NULL));
+             grpc_server_request_call(server, nullptr, nullptr, nullptr, cc, cc,
+                                      nullptr));
   GPR_ASSERT(GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE ==
-             grpc_server_request_registered_call(server, NULL, NULL, NULL, NULL,
-                                                 NULL, cc, cc, NULL));
+             grpc_server_request_registered_call(server, nullptr, nullptr,
+                                                 nullptr, nullptr, nullptr, cc,
+                                                 cc, nullptr));
   grpc_completion_queue_destroy(cc);
   grpc_server_destroy(server);
 }
@@ -69,93 +71,94 @@ void test_request_call_on_no_server_cq(void) {
 void test_bind_server_twice(void) {
   grpc_arg a;
   a.type = GRPC_ARG_INTEGER;
-  a.key = GRPC_ARG_ALLOW_REUSEPORT;
+  a.key = const_cast<char*>(GRPC_ARG_ALLOW_REUSEPORT);
   a.value.integer = 0;
   grpc_channel_args args = {1, &a};
 
-  char *addr;
-  grpc_server *server1 = grpc_server_create(&args, NULL);
-  grpc_server *server2 = grpc_server_create(&args, NULL);
-  grpc_completion_queue *cq = grpc_completion_queue_create_for_next(NULL);
+  char* addr;
+  grpc_server* server1 = grpc_server_create(&args, nullptr);
+  grpc_server* server2 = grpc_server_create(&args, nullptr);
+  grpc_completion_queue* cq = grpc_completion_queue_create_for_next(nullptr);
   int port = grpc_pick_unused_port_or_die();
   gpr_asprintf(&addr, "[::]:%d", port);
-  grpc_server_register_completion_queue(server1, cq, NULL);
-  grpc_server_register_completion_queue(server2, cq, NULL);
-  GPR_ASSERT(0 == grpc_server_add_secure_http2_port(server2, addr, NULL));
+  grpc_server_register_completion_queue(server1, cq, nullptr);
+  grpc_server_register_completion_queue(server2, cq, nullptr);
+  GPR_ASSERT(0 == grpc_server_add_secure_http2_port(server2, addr, nullptr));
   GPR_ASSERT(port == grpc_server_add_insecure_http2_port(server1, addr));
   GPR_ASSERT(0 == grpc_server_add_insecure_http2_port(server2, addr));
-  grpc_server_credentials *fake_creds =
+  grpc_server_credentials* fake_creds =
       grpc_fake_transport_security_server_credentials_create();
   GPR_ASSERT(0 == grpc_server_add_secure_http2_port(server2, addr, fake_creds));
   grpc_server_credentials_release(fake_creds);
-  grpc_server_shutdown_and_notify(server1, cq, NULL);
-  grpc_server_shutdown_and_notify(server2, cq, NULL);
-  grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_MONOTONIC), NULL);
-  grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_MONOTONIC), NULL);
+  grpc_server_shutdown_and_notify(server1, cq, nullptr);
+  grpc_server_shutdown_and_notify(server2, cq, nullptr);
+  grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_MONOTONIC), nullptr);
+  grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_MONOTONIC), nullptr);
   grpc_server_destroy(server1);
   grpc_server_destroy(server2);
   grpc_completion_queue_destroy(cq);
   gpr_free(addr);
 }
 
-void test_bind_server_to_addr(const char *host, bool secure) {
+void test_bind_server_to_addr(const char* host, bool secure) {
   int port = grpc_pick_unused_port_or_die();
-  char *addr;
+  char* addr;
   gpr_join_host_port(&addr, host, port);
   gpr_log(GPR_INFO, "Test bind to %s", addr);
 
-  grpc_server *server = grpc_server_create(NULL, NULL);
+  grpc_server* server = grpc_server_create(nullptr, nullptr);
   if (secure) {
-    grpc_server_credentials *fake_creds =
+    grpc_server_credentials* fake_creds =
         grpc_fake_transport_security_server_credentials_create();
     GPR_ASSERT(grpc_server_add_secure_http2_port(server, addr, fake_creds));
     grpc_server_credentials_release(fake_creds);
   } else {
     GPR_ASSERT(grpc_server_add_insecure_http2_port(server, addr));
   }
-  grpc_completion_queue *cq = grpc_completion_queue_create_for_next(NULL);
-  grpc_server_register_completion_queue(server, cq, NULL);
+  grpc_completion_queue* cq = grpc_completion_queue_create_for_next(nullptr);
+  grpc_server_register_completion_queue(server, cq, nullptr);
   grpc_server_start(server);
-  grpc_server_shutdown_and_notify(server, cq, NULL);
-  grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_MONOTONIC), NULL);
+  grpc_server_shutdown_and_notify(server, cq, nullptr);
+  grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_MONOTONIC), nullptr);
   grpc_server_destroy(server);
   grpc_completion_queue_destroy(cq);
   gpr_free(addr);
 }
 
-static int external_dns_works(const char *host) {
-  grpc_resolved_addresses *res = NULL;
-  grpc_error *error = grpc_blocking_resolve_address(host, "80", &res);
+static int external_dns_works(const char* host) {
+  grpc_resolved_addresses* res = nullptr;
+  grpc_error* error = grpc_blocking_resolve_address(host, "80", &res);
   GRPC_ERROR_UNREF(error);
-  if (res != NULL) {
+  if (res != nullptr) {
     grpc_resolved_addresses_destroy(res);
     return 1;
   }
   return 0;
 }
 
-static void test_bind_server_to_addrs(const char **addrs, size_t n) {
+static void test_bind_server_to_addrs(const char** addrs, size_t n) {
   for (size_t i = 0; i < n; i++) {
     test_bind_server_to_addr(addrs[i], false);
     test_bind_server_to_addr(addrs[i], true);
   }
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   test_register_method_fail();
   test_request_call_on_no_server_cq();
   test_bind_server_twice();
 
-  static const char *addrs[] = {
+  static const char* addrs[] = {
       "::1", "127.0.0.1", "::ffff:127.0.0.1", "localhost", "0.0.0.0", "::",
   };
   test_bind_server_to_addrs(addrs, GPR_ARRAY_SIZE(addrs));
 
   if (external_dns_works("loopback46.unittest.grpc.io")) {
-    static const char *dns_addrs[] = {
-        "loopback46.unittest.grpc.io", "loopback4.unittest.grpc.io",
+    static const char* dns_addrs[] = {
+        "loopback46.unittest.grpc.io",
+        "loopback4.unittest.grpc.io",
     };
     test_bind_server_to_addrs(dns_addrs, GPR_ARRAY_SIZE(dns_addrs));
   }
diff --git a/test/core/transport/BUILD b/test/core/transport/BUILD
index edd27b8a5f..b31d4ff899 100644
--- a/test/core/transport/BUILD
+++ b/test/core/transport/BUILD
@@ -35,8 +35,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "byte_stream_test",
-    srcs = ["byte_stream_test.c"],
-    language = "C",
+    srcs = ["byte_stream_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -47,8 +47,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "connectivity_state_test",
-    srcs = ["connectivity_state_test.c"],
-    language = "C",
+    srcs = ["connectivity_state_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -59,8 +59,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "metadata_test",
-    srcs = ["metadata_test.c"],
-    language = "C",
+    srcs = ["metadata_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -86,8 +86,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "status_conversion_test",
-    srcs = ["status_conversion_test.c"],
-    language = "C",
+    srcs = ["status_conversion_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -98,8 +98,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "stream_owned_slice_test",
-    srcs = ["stream_owned_slice_test.c"],
-    language = "C",
+    srcs = ["stream_owned_slice_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -110,8 +110,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "timeout_encoding_test",
-    srcs = ["timeout_encoding_test.c"],
-    language = "C",
+    srcs = ["timeout_encoding_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
diff --git a/test/core/transport/bdp_estimator_test.cc b/test/core/transport/bdp_estimator_test.cc
index 2c4fc4588b..2a6fa95162 100644
--- a/test/core/transport/bdp_estimator_test.cc
+++ b/test/core/transport/bdp_estimator_test.cc
@@ -55,7 +55,7 @@ TEST(BdpEstimatorTest, EstimateBdpNoSamples) {
 }
 
 namespace {
-void AddSamples(BdpEstimator *estimator, int64_t *samples, size_t n) {
+void AddSamples(BdpEstimator* estimator, int64_t* samples, size_t n) {
   estimator->AddIncomingBytes(1234567);
   inc_time();
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -71,7 +71,7 @@ void AddSamples(BdpEstimator *estimator, int64_t *samples, size_t n) {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-void AddSample(BdpEstimator *estimator, int64_t sample) {
+void AddSample(BdpEstimator* estimator, int64_t sample) {
   AddSamples(estimator, &sample, 1);
 }
 }  // namespace
@@ -137,7 +137,7 @@ INSTANTIATE_TEST_CASE_P(TooManyNames, BdpEstimatorRandomTest,
 }  // namespace testing
 }  // namespace grpc_core
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   gpr_now_impl = grpc_core::testing::fake_gpr_now;
   grpc_init();
diff --git a/test/core/transport/byte_stream_test.c b/test/core/transport/byte_stream_test.cc
index a0c5f961cf..0e34fd7651 100644
--- a/test/core/transport/byte_stream_test.c
+++ b/test/core/transport/byte_stream_test.cc
@@ -30,8 +30,8 @@
 // grpc_slice_buffer_stream tests
 //
 
-static void not_called_closure(grpc_exec_ctx *exec_ctx, void *arg,
-                               grpc_error *error) {
+static void not_called_closure(grpc_exec_ctx* exec_ctx, void* arg,
+                               grpc_error* error) {
   GPR_ASSERT(false);
 }
 
@@ -53,14 +53,14 @@ static void test_slice_buffer_stream_basic(void) {
   grpc_slice_buffer_stream_init(&stream, &buffer, 0);
   GPR_ASSERT(stream.base.length == 6);
   grpc_closure closure;
-  GRPC_CLOSURE_INIT(&closure, not_called_closure, NULL,
+  GRPC_CLOSURE_INIT(&closure, not_called_closure, nullptr,
                     grpc_schedule_on_exec_ctx);
   // Read each slice.  Note that next() always returns synchronously.
   for (size_t i = 0; i < GPR_ARRAY_SIZE(input); ++i) {
     GPR_ASSERT(
         grpc_byte_stream_next(&exec_ctx, &stream.base, ~(size_t)0, &closure));
     grpc_slice output;
-    grpc_error *error = grpc_byte_stream_pull(&exec_ctx, &stream.base, &output);
+    grpc_error* error = grpc_byte_stream_pull(&exec_ctx, &stream.base, &output);
     GPR_ASSERT(error == GRPC_ERROR_NONE);
     GPR_ASSERT(grpc_slice_eq(input[i], output));
     grpc_slice_unref_internal(&exec_ctx, output);
@@ -89,18 +89,18 @@ static void test_slice_buffer_stream_shutdown(void) {
   grpc_slice_buffer_stream_init(&stream, &buffer, 0);
   GPR_ASSERT(stream.base.length == 6);
   grpc_closure closure;
-  GRPC_CLOSURE_INIT(&closure, not_called_closure, NULL,
+  GRPC_CLOSURE_INIT(&closure, not_called_closure, nullptr,
                     grpc_schedule_on_exec_ctx);
   // Read the first slice.
   GPR_ASSERT(
       grpc_byte_stream_next(&exec_ctx, &stream.base, ~(size_t)0, &closure));
   grpc_slice output;
-  grpc_error *error = grpc_byte_stream_pull(&exec_ctx, &stream.base, &output);
+  grpc_error* error = grpc_byte_stream_pull(&exec_ctx, &stream.base, &output);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   GPR_ASSERT(grpc_slice_eq(input[0], output));
   grpc_slice_unref_internal(&exec_ctx, output);
   // Now shutdown.
-  grpc_error *shutdown_error =
+  grpc_error* shutdown_error =
       GRPC_ERROR_CREATE_FROM_STATIC_STRING("shutdown error");
   grpc_byte_stream_shutdown(&exec_ctx, &stream.base,
                             GRPC_ERROR_REF(shutdown_error));
@@ -142,7 +142,7 @@ static void test_caching_byte_stream_basic(void) {
   grpc_caching_byte_stream stream;
   grpc_caching_byte_stream_init(&stream, &cache);
   grpc_closure closure;
-  GRPC_CLOSURE_INIT(&closure, not_called_closure, NULL,
+  GRPC_CLOSURE_INIT(&closure, not_called_closure, nullptr,
                     grpc_schedule_on_exec_ctx);
   // Read each slice.  Note that next() always returns synchronously,
   // because the underlying byte stream always does.
@@ -150,7 +150,7 @@ static void test_caching_byte_stream_basic(void) {
     GPR_ASSERT(
         grpc_byte_stream_next(&exec_ctx, &stream.base, ~(size_t)0, &closure));
     grpc_slice output;
-    grpc_error *error = grpc_byte_stream_pull(&exec_ctx, &stream.base, &output);
+    grpc_error* error = grpc_byte_stream_pull(&exec_ctx, &stream.base, &output);
     GPR_ASSERT(error == GRPC_ERROR_NONE);
     GPR_ASSERT(grpc_slice_eq(input[i], output));
     grpc_slice_unref_internal(&exec_ctx, output);
@@ -183,13 +183,13 @@ static void test_caching_byte_stream_reset(void) {
   grpc_caching_byte_stream stream;
   grpc_caching_byte_stream_init(&stream, &cache);
   grpc_closure closure;
-  GRPC_CLOSURE_INIT(&closure, not_called_closure, NULL,
+  GRPC_CLOSURE_INIT(&closure, not_called_closure, nullptr,
                     grpc_schedule_on_exec_ctx);
   // Read one slice.
   GPR_ASSERT(
       grpc_byte_stream_next(&exec_ctx, &stream.base, ~(size_t)0, &closure));
   grpc_slice output;
-  grpc_error *error = grpc_byte_stream_pull(&exec_ctx, &stream.base, &output);
+  grpc_error* error = grpc_byte_stream_pull(&exec_ctx, &stream.base, &output);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   GPR_ASSERT(grpc_slice_eq(input[0], output));
   grpc_slice_unref_internal(&exec_ctx, output);
@@ -234,13 +234,13 @@ static void test_caching_byte_stream_shared_cache(void) {
   grpc_caching_byte_stream stream2;
   grpc_caching_byte_stream_init(&stream2, &cache);
   grpc_closure closure;
-  GRPC_CLOSURE_INIT(&closure, not_called_closure, NULL,
+  GRPC_CLOSURE_INIT(&closure, not_called_closure, nullptr,
                     grpc_schedule_on_exec_ctx);
   // Read one slice from stream1.
   GPR_ASSERT(
       grpc_byte_stream_next(&exec_ctx, &stream1.base, ~(size_t)0, &closure));
   grpc_slice output;
-  grpc_error *error = grpc_byte_stream_pull(&exec_ctx, &stream1.base, &output);
+  grpc_error* error = grpc_byte_stream_pull(&exec_ctx, &stream1.base, &output);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   GPR_ASSERT(grpc_slice_eq(input[0], output));
   grpc_slice_unref_internal(&exec_ctx, output);
@@ -268,7 +268,7 @@ static void test_caching_byte_stream_shared_cache(void) {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_slice_buffer_stream_basic();
   test_slice_buffer_stream_shutdown();
diff --git a/test/core/transport/chttp2/BUILD b/test/core/transport/chttp2/BUILD
index 6081940243..1ea7d0341d 100644
--- a/test/core/transport/chttp2/BUILD
+++ b/test/core/transport/chttp2/BUILD
@@ -22,7 +22,7 @@ load("//test/core/util:grpc_fuzzer.bzl", "grpc_fuzzer")
 
 grpc_fuzzer(
     name = "hpack_parser_fuzzer",
-    srcs = ["hpack_parser_fuzzer_test.c"],
+    srcs = ["hpack_parser_fuzzer_test.cc"],
     corpus = "hpack_parser_corpus",
     deps = [
         "//:grpc",
@@ -32,8 +32,8 @@ grpc_fuzzer(
 
 grpc_cc_test(
     name = "alpn_test",
-    srcs = ["alpn_test.c"],
-    language = "C",
+    srcs = ["alpn_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -44,8 +44,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "bin_decoder_test",
-    srcs = ["bin_decoder_test.c"],
-    language = "C",
+    srcs = ["bin_decoder_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -56,8 +56,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "bin_encoder_test",
-    srcs = ["bin_encoder_test.c"],
-    language = "C",
+    srcs = ["bin_encoder_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -68,8 +68,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "hpack_encoder_test",
-    srcs = ["hpack_encoder_test.c"],
-    language = "C",
+    srcs = ["hpack_encoder_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -80,8 +80,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "hpack_parser_test",
-    srcs = ["hpack_parser_test.c"],
-    language = "C",
+    srcs = ["hpack_parser_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -92,8 +92,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "hpack_table_test",
-    srcs = ["hpack_table_test.c"],
-    language = "C",
+    srcs = ["hpack_table_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -104,8 +104,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "stream_map_test",
-    srcs = ["stream_map_test.c"],
-    language = "C",
+    srcs = ["stream_map_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -116,8 +116,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "varint_test",
-    srcs = ["varint_test.c"],
-    language = "C",
+    srcs = ["varint_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
diff --git a/test/core/transport/chttp2/alpn_test.c b/test/core/transport/chttp2/alpn_test.cc
index 72c30c40eb..a43377393e 100644
--- a/test/core/transport/chttp2/alpn_test.c
+++ b/test/core/transport/chttp2/alpn_test.cc
@@ -33,7 +33,7 @@ static void test_alpn_failure(void) {
 
 // First index in ALPN supported version list of a given protocol. Returns a
 // value one beyond the last valid element index if not found.
-static size_t alpn_version_index(const char *version, size_t size) {
+static size_t alpn_version_index(const char* version, size_t size) {
   size_t i;
   for (i = 0; i < grpc_chttp2_num_alpn_versions(); ++i) {
     if (!strncmp(version, grpc_chttp2_get_alpn_version_index(i), size)) {
@@ -48,7 +48,7 @@ static void test_alpn_grpc_before_h2(void) {
   GPR_ASSERT(alpn_version_index("grpc-exp", 8) < alpn_version_index("h2", 2));
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_alpn_success();
   test_alpn_failure();
diff --git a/test/core/transport/chttp2/bin_decoder_test.c b/test/core/transport/chttp2/bin_decoder_test.cc
index 775161ec91..a29ec8a13f 100644
--- a/test/core/transport/chttp2/bin_decoder_test.c
+++ b/test/core/transport/chttp2/bin_decoder_test.cc
@@ -29,11 +29,11 @@
 
 static int all_ok = 1;
 
-static void expect_slice_eq(grpc_exec_ctx *exec_ctx, grpc_slice expected,
-                            grpc_slice slice, char *debug, int line) {
+static void expect_slice_eq(grpc_exec_ctx* exec_ctx, grpc_slice expected,
+                            grpc_slice slice, const char* debug, int line) {
   if (!grpc_slice_eq(slice, expected)) {
-    char *hs = grpc_dump_slice(slice, GPR_DUMP_HEX | GPR_DUMP_ASCII);
-    char *he = grpc_dump_slice(expected, GPR_DUMP_HEX | GPR_DUMP_ASCII);
+    char* hs = grpc_dump_slice(slice, GPR_DUMP_HEX | GPR_DUMP_ASCII);
+    char* he = grpc_dump_slice(expected, GPR_DUMP_HEX | GPR_DUMP_ASCII);
     gpr_log(GPR_ERROR, "FAILED:%d: %s\ngot:  %s\nwant: %s", line, debug, hs,
             he);
     gpr_free(hs);
@@ -44,22 +44,22 @@ static void expect_slice_eq(grpc_exec_ctx *exec_ctx, grpc_slice expected,
   grpc_slice_unref_internal(exec_ctx, slice);
 }
 
-static grpc_slice base64_encode(grpc_exec_ctx *exec_ctx, const char *s) {
+static grpc_slice base64_encode(grpc_exec_ctx* exec_ctx, const char* s) {
   grpc_slice ss = grpc_slice_from_copied_string(s);
   grpc_slice out = grpc_chttp2_base64_encode(ss);
   grpc_slice_unref_internal(exec_ctx, ss);
   return out;
 }
 
-static grpc_slice base64_decode(grpc_exec_ctx *exec_ctx, const char *s) {
+static grpc_slice base64_decode(grpc_exec_ctx* exec_ctx, const char* s) {
   grpc_slice ss = grpc_slice_from_copied_string(s);
   grpc_slice out = grpc_chttp2_base64_decode(exec_ctx, ss);
   grpc_slice_unref_internal(exec_ctx, ss);
   return out;
 }
 
-static grpc_slice base64_decode_with_length(grpc_exec_ctx *exec_ctx,
-                                            const char *s,
+static grpc_slice base64_decode_with_length(grpc_exec_ctx* exec_ctx,
+                                            const char* s,
                                             size_t output_length) {
   grpc_slice ss = grpc_slice_from_copied_string(s);
   grpc_slice out =
@@ -78,7 +78,7 @@ static grpc_slice base64_decode_with_length(grpc_exec_ctx *exec_ctx,
                   grpc_chttp2_base64_decode_with_length( \
                       exec_ctx, base64_encode(exec_ctx, s), strlen(s)));
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
   /* ENCODE_AND_DECODE tests grpc_chttp2_base64_decode_with_length(), which
diff --git a/test/core/transport/chttp2/bin_encoder_test.c b/test/core/transport/chttp2/bin_encoder_test.cc
index acadcf6c89..78b8808c41 100644
--- a/test/core/transport/chttp2/bin_encoder_test.c
+++ b/test/core/transport/chttp2/bin_encoder_test.cc
@@ -31,11 +31,11 @@
 
 static int all_ok = 1;
 
-static void expect_slice_eq(grpc_slice expected, grpc_slice slice, char *debug,
-                            int line) {
+static void expect_slice_eq(grpc_slice expected, grpc_slice slice,
+                            const char* debug, int line) {
   if (!grpc_slice_eq(slice, expected)) {
-    char *hs = grpc_dump_slice(slice, GPR_DUMP_HEX | GPR_DUMP_ASCII);
-    char *he = grpc_dump_slice(expected, GPR_DUMP_HEX | GPR_DUMP_ASCII);
+    char* hs = grpc_dump_slice(slice, GPR_DUMP_HEX | GPR_DUMP_ASCII);
+    char* he = grpc_dump_slice(expected, GPR_DUMP_HEX | GPR_DUMP_ASCII);
     gpr_log(GPR_ERROR, "FAILED:%d: %s\ngot:  %s\nwant: %s", line, debug, hs,
             he);
     gpr_free(hs);
@@ -46,14 +46,14 @@ static void expect_slice_eq(grpc_slice expected, grpc_slice slice, char *debug,
   grpc_slice_unref(slice);
 }
 
-static grpc_slice B64(const char *s) {
+static grpc_slice B64(const char* s) {
   grpc_slice ss = grpc_slice_from_copied_string(s);
   grpc_slice out = grpc_chttp2_base64_encode(ss);
   grpc_slice_unref(ss);
   return out;
 }
 
-static grpc_slice HUFF(const char *s) {
+static grpc_slice HUFF(const char* s) {
   grpc_slice ss = grpc_slice_from_copied_string(s);
   grpc_slice out = grpc_chttp2_huffman_compress(ss);
   grpc_slice_unref(ss);
@@ -65,15 +65,15 @@ static grpc_slice HUFF(const char *s) {
       grpc_slice_from_copied_buffer(expected, sizeof(expected) - 1), slice, \
       #slice, __LINE__);
 
-static void expect_combined_equiv(const char *s, size_t len, int line) {
+static void expect_combined_equiv(const char* s, size_t len, int line) {
   grpc_slice input = grpc_slice_from_copied_buffer(s, len);
   grpc_slice base64 = grpc_chttp2_base64_encode(input);
   grpc_slice expect = grpc_chttp2_huffman_compress(base64);
   grpc_slice got = grpc_chttp2_base64_encode_and_huffman_compress(input);
   if (!grpc_slice_eq(expect, got)) {
-    char *t = grpc_dump_slice(input, GPR_DUMP_HEX | GPR_DUMP_ASCII);
-    char *e = grpc_dump_slice(expect, GPR_DUMP_HEX | GPR_DUMP_ASCII);
-    char *g = grpc_dump_slice(got, GPR_DUMP_HEX | GPR_DUMP_ASCII);
+    char* t = grpc_dump_slice(input, GPR_DUMP_HEX | GPR_DUMP_ASCII);
+    char* e = grpc_dump_slice(expect, GPR_DUMP_HEX | GPR_DUMP_ASCII);
+    char* g = grpc_dump_slice(got, GPR_DUMP_HEX | GPR_DUMP_ASCII);
     gpr_log(GPR_ERROR, "FAILED:%d:\ntest: %s\ngot:  %s\nwant: %s", line, t, g,
             e);
     gpr_free(t);
@@ -90,7 +90,7 @@ static void expect_combined_equiv(const char *s, size_t len, int line) {
 #define EXPECT_COMBINED_EQUIV(x) \
   expect_combined_equiv(x, sizeof(x) - 1, __LINE__)
 
-static void expect_binary_header(const char *hdr, int binary) {
+static void expect_binary_header(const char* hdr, int binary) {
   if (grpc_is_binary_header(grpc_slice_from_static_string(hdr)) != binary) {
     gpr_log(GPR_ERROR, "FAILED: expected header '%s' to be %s", hdr,
             binary ? "binary" : "not binary");
@@ -98,7 +98,7 @@ static void expect_binary_header(const char *hdr, int binary) {
   }
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   /* Base64 test vectors from RFC 4648, with padding removed */
   /* BASE64("") = "" */
   EXPECT_SLICE_EQ("", B64(""));
diff --git a/test/core/transport/chttp2/hpack_encoder_test.c b/test/core/transport/chttp2/hpack_encoder_test.cc
index a2af83b6cb..2d18b72504 100644
--- a/test/core/transport/chttp2/hpack_encoder_test.c
+++ b/test/core/transport/chttp2/hpack_encoder_test.cc
@@ -39,7 +39,7 @@
 grpc_chttp2_hpack_compressor g_compressor;
 int g_failure = 0;
 
-void **to_delete = NULL;
+void** to_delete = nullptr;
 size_t num_to_delete = 0;
 size_t cap_to_delete = 0;
 
@@ -51,22 +51,23 @@ typedef struct {
 
 /* verify that the output generated by encoding the stream matches the
    hexstring passed in */
-static void verify(grpc_exec_ctx *exec_ctx, const verify_params params,
-                   const char *expected, size_t nheaders, ...) {
+static void verify(grpc_exec_ctx* exec_ctx, const verify_params params,
+                   const char* expected, size_t nheaders, ...) {
   grpc_slice_buffer output;
   grpc_slice merged;
   grpc_slice expect = parse_hexstring(expected);
   size_t i;
   va_list l;
-  grpc_linked_mdelem *e = gpr_malloc(sizeof(*e) * nheaders);
+  grpc_linked_mdelem* e =
+      static_cast<grpc_linked_mdelem*>(gpr_malloc(sizeof(*e) * nheaders));
   grpc_metadata_batch b;
 
   grpc_metadata_batch_init(&b);
 
   va_start(l, nheaders);
   for (i = 0; i < nheaders; i++) {
-    char *key = va_arg(l, char *);
-    char *value = va_arg(l, char *);
+    char* key = va_arg(l, char*);
+    char* value = va_arg(l, char*);
     if (i) {
       e[i - 1].next = &e[i];
       e[i].prev = &e[i - 1];
@@ -79,8 +80,8 @@ static void verify(grpc_exec_ctx *exec_ctx, const verify_params params,
         exec_ctx, grpc_slice_intern(grpc_slice_from_static_string(key)),
         value_slice);
   }
-  e[0].prev = NULL;
-  e[nheaders - 1].next = NULL;
+  e[0].prev = nullptr;
+  e[nheaders - 1].next = nullptr;
   va_end(l);
 
   b.list.head = &e[0];
@@ -89,7 +90,8 @@ static void verify(grpc_exec_ctx *exec_ctx, const verify_params params,
 
   if (cap_to_delete == num_to_delete) {
     cap_to_delete = GPR_MAX(2 * cap_to_delete, 1000);
-    to_delete = gpr_realloc(to_delete, sizeof(*to_delete) * cap_to_delete);
+    to_delete = static_cast<void**>(
+        gpr_realloc(to_delete, sizeof(*to_delete) * cap_to_delete));
   }
   to_delete[num_to_delete++] = e;
 
@@ -98,21 +100,21 @@ static void verify(grpc_exec_ctx *exec_ctx, const verify_params params,
   grpc_transport_one_way_stats stats;
   memset(&stats, 0, sizeof(stats));
   grpc_encode_header_options hopt = {
-      .stream_id = 0xdeadbeef,
-      .is_eof = params.eof,
-      .use_true_binary_metadata = params.use_true_binary_metadata,
-      .max_frame_size = 16384,
-      .stats = &stats,
+      0xdeadbeef,                      /* stream_id */
+      params.eof,                      /* is_eof */
+      params.use_true_binary_metadata, /* use_true_binary_metadata */
+      16384,                           /* max_frame_size */
+      &stats                           /* stats */
   };
-  grpc_chttp2_encode_header(exec_ctx, &g_compressor, NULL, 0, &b, &hopt,
+  grpc_chttp2_encode_header(exec_ctx, &g_compressor, nullptr, 0, &b, &hopt,
                             &output);
   merged = grpc_slice_merge(output.slices, output.count);
   grpc_slice_buffer_destroy_internal(exec_ctx, &output);
   grpc_metadata_batch_destroy(exec_ctx, &b);
 
   if (!grpc_slice_eq(merged, expect)) {
-    char *expect_str = grpc_dump_slice(expect, GPR_DUMP_HEX | GPR_DUMP_ASCII);
-    char *got_str = grpc_dump_slice(merged, GPR_DUMP_HEX | GPR_DUMP_ASCII);
+    char* expect_str = grpc_dump_slice(expect, GPR_DUMP_HEX | GPR_DUMP_ASCII);
+    char* got_str = grpc_dump_slice(merged, GPR_DUMP_HEX | GPR_DUMP_ASCII);
     gpr_log(GPR_ERROR, "mismatched output for %s", expected);
     gpr_log(GPR_ERROR, "EXPECT: %s", expect_str);
     gpr_log(GPR_ERROR, "GOT:    %s", got_str);
@@ -125,11 +127,13 @@ static void verify(grpc_exec_ctx *exec_ctx, const verify_params params,
   grpc_slice_unref_internal(exec_ctx, expect);
 }
 
-static void test_basic_headers(grpc_exec_ctx *exec_ctx) {
+static void test_basic_headers(grpc_exec_ctx* exec_ctx) {
   int i;
 
   verify_params params = {
-      .eof = false, .use_true_binary_metadata = false, .only_intern_key = false,
+      false,
+      false,
+      false,
   };
   verify(exec_ctx, params, "000005 0104 deadbeef 40 0161 0161", 1, "a", "a");
   verify(exec_ctx, params, "000001 0104 deadbeef be", 1, "a", "a");
@@ -151,7 +155,7 @@ static void test_basic_headers(grpc_exec_ctx *exec_ctx) {
   verify(exec_ctx, params, "000004 0104 deadbeef 0f 2f 0176", 1, "a", "v");
 }
 
-static void encode_int_to_str(int i, char *p) {
+static void encode_int_to_str(int i, char* p) {
   p[0] = (char)('a' + i % 26);
   i /= 26;
   GPR_ASSERT(i < 26);
@@ -159,13 +163,15 @@ static void encode_int_to_str(int i, char *p) {
   p[2] = 0;
 }
 
-static void test_decode_table_overflow(grpc_exec_ctx *exec_ctx) {
+static void test_decode_table_overflow(grpc_exec_ctx* exec_ctx) {
   int i;
   char key[3], value[3];
-  char *expect;
+  char* expect;
 
   verify_params params = {
-      .eof = false, .use_true_binary_metadata = false, .only_intern_key = false,
+      false,
+      false,
+      false,
   };
 
   for (i = 0; i < 114; i++) {
@@ -199,9 +205,9 @@ static void test_decode_table_overflow(grpc_exec_ctx *exec_ctx) {
          "ba");
 }
 
-static void verify_table_size_change_match_elem_size(grpc_exec_ctx *exec_ctx,
-                                                     const char *key,
-                                                     const char *value,
+static void verify_table_size_change_match_elem_size(grpc_exec_ctx* exec_ctx,
+                                                     const char* key,
+                                                     const char* value,
                                                      bool use_true_binary) {
   grpc_slice_buffer output;
   grpc_mdelem elem = grpc_mdelem_from_slices(
@@ -209,12 +215,13 @@ static void verify_table_size_change_match_elem_size(grpc_exec_ctx *exec_ctx,
       grpc_slice_intern(grpc_slice_from_static_string(value)));
   size_t elem_size = grpc_mdelem_get_size_in_hpack_table(elem, use_true_binary);
   size_t initial_table_size = g_compressor.table_size;
-  grpc_linked_mdelem *e = gpr_malloc(sizeof(*e));
+  grpc_linked_mdelem* e =
+      static_cast<grpc_linked_mdelem*>(gpr_malloc(sizeof(*e)));
   grpc_metadata_batch b;
   grpc_metadata_batch_init(&b);
   e[0].md = elem;
-  e[0].prev = NULL;
-  e[0].next = NULL;
+  e[0].prev = nullptr;
+  e[0].next = nullptr;
   b.list.head = &e[0];
   b.list.tail = &e[0];
   b.list.count = 1;
@@ -223,12 +230,12 @@ static void verify_table_size_change_match_elem_size(grpc_exec_ctx *exec_ctx,
   grpc_transport_one_way_stats stats;
   memset(&stats, 0, sizeof(stats));
   grpc_encode_header_options hopt = {
-      .stream_id = 0xdeadbeef,
-      .is_eof = false,
-      .use_true_binary_metadata = use_true_binary,
-      .max_frame_size = 16384,
-      .stats = &stats};
-  grpc_chttp2_encode_header(exec_ctx, &g_compressor, NULL, 0, &b, &hopt,
+      0xdeadbeef,      /* stream_id */
+      false,           /* is_eof */
+      use_true_binary, /* use_true_binary_metadata */
+      16384,           /* max_frame_size */
+      &stats /* stats */};
+  grpc_chttp2_encode_header(exec_ctx, &g_compressor, nullptr, 0, &b, &hopt,
                             &output);
   grpc_slice_buffer_destroy_internal(exec_ctx, &output);
   grpc_metadata_batch_destroy(exec_ctx, &b);
@@ -237,7 +244,7 @@ static void verify_table_size_change_match_elem_size(grpc_exec_ctx *exec_ctx,
   gpr_free(e);
 }
 
-static void test_encode_header_size(grpc_exec_ctx *exec_ctx) {
+static void test_encode_header_size(grpc_exec_ctx* exec_ctx) {
   verify_table_size_change_match_elem_size(exec_ctx, "hello", "world", false);
   verify_table_size_change_match_elem_size(exec_ctx, "hello-bin", "world",
                                            false);
@@ -245,11 +252,9 @@ static void test_encode_header_size(grpc_exec_ctx *exec_ctx) {
                                            "I_am_true_binary_value", true);
 }
 
-static void test_interned_key_indexed(grpc_exec_ctx *exec_ctx) {
+static void test_interned_key_indexed(grpc_exec_ctx* exec_ctx) {
   int i;
-  verify_params params = {
-      .eof = false, .use_true_binary_metadata = false, .only_intern_key = true,
-  };
+  verify_params params = {false, false, true};
   verify(exec_ctx, params, "000009 0104 deadbeef 40 0161 0162 0f2f 0163", 2,
          "a", "b", "a", "c");
   for (i = 0; i < 10; i++) {
@@ -258,7 +263,7 @@ static void test_interned_key_indexed(grpc_exec_ctx *exec_ctx) {
   }
 }
 
-static void run_test(void (*test)(grpc_exec_ctx *exec_ctx), const char *name) {
+static void run_test(void (*test)(grpc_exec_ctx* exec_ctx), const char* name) {
   gpr_log(GPR_INFO, "RUN TEST: %s", name);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_chttp2_hpack_compressor_init(&g_compressor);
@@ -267,7 +272,7 @@ static void run_test(void (*test)(grpc_exec_ctx *exec_ctx), const char *name) {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   size_t i;
   grpc_test_only_set_slice_hash_seed(0);
   grpc_test_init(argc, argv);
diff --git a/test/core/transport/chttp2/hpack_parser_fuzzer_test.c b/test/core/transport/chttp2/hpack_parser_fuzzer_test.cc
index 03834084cb..942f25e0b7 100644
--- a/test/core/transport/chttp2/hpack_parser_fuzzer_test.c
+++ b/test/core/transport/chttp2/hpack_parser_fuzzer_test.cc
@@ -29,12 +29,12 @@
 bool squelch = true;
 bool leak_check = true;
 
-static void onhdr(grpc_exec_ctx *exec_ctx, void *ud, grpc_mdelem md) {
+static void onhdr(grpc_exec_ctx* exec_ctx, void* ud, grpc_mdelem md) {
   GRPC_MDELEM_UNREF(exec_ctx, md);
 }
-static void dont_log(gpr_log_func_args *args) {}
+static void dont_log(gpr_log_func_args* args) {}
 
-int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   grpc_test_only_set_slice_hash_seed(0);
   if (squelch) gpr_set_log_function(dont_log);
   grpc_init();
diff --git a/test/core/transport/chttp2/hpack_parser_test.c b/test/core/transport/chttp2/hpack_parser_test.cc
index 0946c05261..82fb20aced 100644
--- a/test/core/transport/chttp2/hpack_parser_test.c
+++ b/test/core/transport/chttp2/hpack_parser_test.cc
@@ -28,25 +28,27 @@
 #include "test/core/util/slice_splitter.h"
 #include "test/core/util/test_config.h"
 
-typedef struct { va_list args; } test_checker;
+typedef struct {
+  va_list args;
+} test_checker;
 
-static void onhdr(grpc_exec_ctx *exec_ctx, void *ud, grpc_mdelem md) {
+static void onhdr(grpc_exec_ctx* exec_ctx, void* ud, grpc_mdelem md) {
   const char *ekey, *evalue;
-  test_checker *chk = ud;
-  ekey = va_arg(chk->args, char *);
+  test_checker* chk = static_cast<test_checker*>(ud);
+  ekey = va_arg(chk->args, char*);
   GPR_ASSERT(ekey);
-  evalue = va_arg(chk->args, char *);
+  evalue = va_arg(chk->args, char*);
   GPR_ASSERT(evalue);
   GPR_ASSERT(grpc_slice_str_cmp(GRPC_MDKEY(md), ekey) == 0);
   GPR_ASSERT(grpc_slice_str_cmp(GRPC_MDVALUE(md), evalue) == 0);
   GRPC_MDELEM_UNREF(exec_ctx, md);
 }
 
-static void test_vector(grpc_chttp2_hpack_parser *parser,
-                        grpc_slice_split_mode mode, const char *hexstring,
+static void test_vector(grpc_chttp2_hpack_parser* parser,
+                        grpc_slice_split_mode mode, const char* hexstring,
                         ... /* char *key, char *value */) {
   grpc_slice input = parse_hexstring(hexstring);
-  grpc_slice *slices;
+  grpc_slice* slices;
   size_t nslices;
   size_t i;
   test_checker chk;
@@ -71,7 +73,7 @@ static void test_vector(grpc_chttp2_hpack_parser *parser,
   }
   gpr_free(slices);
 
-  GPR_ASSERT(NULL == va_arg(chk.args, char *));
+  GPR_ASSERT(nullptr == va_arg(chk.args, char*));
 
   va_end(chk.args);
 }
@@ -206,7 +208,7 @@ static void test_vectors(grpc_slice_split_mode mode) {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   test_vectors(GRPC_SLICE_SPLIT_MERGE_ALL);
diff --git a/test/core/transport/chttp2/hpack_table_test.c b/test/core/transport/chttp2/hpack_table_test.cc
index 430ece33c7..ff7c2de538 100644
--- a/test/core/transport/chttp2/hpack_table_test.c
+++ b/test/core/transport/chttp2/hpack_table_test.cc
@@ -31,13 +31,13 @@
 
 #define LOG_TEST(x) gpr_log(GPR_INFO, "%s", x)
 
-static void assert_str(const grpc_chttp2_hptbl *tbl, grpc_slice mdstr,
-                       const char *str) {
+static void assert_str(const grpc_chttp2_hptbl* tbl, grpc_slice mdstr,
+                       const char* str) {
   GPR_ASSERT(grpc_slice_str_cmp(mdstr, str) == 0);
 }
 
-static void assert_index(const grpc_chttp2_hptbl *tbl, uint32_t idx,
-                         const char *key, const char *value) {
+static void assert_index(const grpc_chttp2_hptbl* tbl, uint32_t idx,
+                         const char* key, const char* value) {
   grpc_mdelem md = grpc_chttp2_hptbl_lookup(tbl, idx);
   assert_str(tbl, GRPC_MDKEY(md), key);
   assert_str(tbl, GRPC_MDVALUE(md), value);
@@ -119,8 +119,8 @@ static void test_static_lookup(void) {
 static void test_many_additions(void) {
   grpc_chttp2_hptbl tbl;
   int i;
-  char *key;
-  char *value;
+  char* key;
+  char* value;
 
   LOG_TEST("test_many_additions");
 
@@ -152,9 +152,9 @@ static void test_many_additions(void) {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static grpc_chttp2_hptbl_find_result find_simple(grpc_chttp2_hptbl *tbl,
-                                                 const char *key,
-                                                 const char *value) {
+static grpc_chttp2_hptbl_find_result find_simple(grpc_chttp2_hptbl* tbl,
+                                                 const char* key,
+                                                 const char* value) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_mdelem md =
       grpc_mdelem_from_slices(&exec_ctx, grpc_slice_from_copied_string(key),
@@ -274,7 +274,7 @@ static void test_find(void) {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   test_static_lookup();
diff --git a/test/core/transport/chttp2/stream_map_test.c b/test/core/transport/chttp2/stream_map_test.cc
index ae2583ab84..9b21cb2364 100644
--- a/test/core/transport/chttp2/stream_map_test.c
+++ b/test/core/transport/chttp2/stream_map_test.cc
@@ -39,7 +39,7 @@ static void test_empty_find(void) {
   LOG_TEST("test_empty_find");
 
   grpc_chttp2_stream_map_init(&map, 8);
-  GPR_ASSERT(NULL == grpc_chttp2_stream_map_find(&map, 39128));
+  GPR_ASSERT(nullptr == grpc_chttp2_stream_map_find(&map, 39128));
   grpc_chttp2_stream_map_destroy(&map);
 }
 
@@ -51,18 +51,18 @@ static void test_double_deletion(void) {
 
   grpc_chttp2_stream_map_init(&map, 8);
   GPR_ASSERT(0 == grpc_chttp2_stream_map_size(&map));
-  grpc_chttp2_stream_map_add(&map, 1, (void *)1);
-  GPR_ASSERT((void *)1 == grpc_chttp2_stream_map_find(&map, 1));
+  grpc_chttp2_stream_map_add(&map, 1, (void*)1);
+  GPR_ASSERT((void*)1 == grpc_chttp2_stream_map_find(&map, 1));
   GPR_ASSERT(1 == grpc_chttp2_stream_map_size(&map));
-  GPR_ASSERT((void *)1 == grpc_chttp2_stream_map_delete(&map, 1));
+  GPR_ASSERT((void*)1 == grpc_chttp2_stream_map_delete(&map, 1));
   GPR_ASSERT(0 == grpc_chttp2_stream_map_size(&map));
-  GPR_ASSERT(NULL == grpc_chttp2_stream_map_find(&map, 1));
-  GPR_ASSERT(NULL == grpc_chttp2_stream_map_delete(&map, 1));
-  GPR_ASSERT(NULL == grpc_chttp2_stream_map_find(&map, 1));
-  GPR_ASSERT(NULL == grpc_chttp2_stream_map_delete(&map, 1));
-  GPR_ASSERT(NULL == grpc_chttp2_stream_map_find(&map, 1));
-  GPR_ASSERT(NULL == grpc_chttp2_stream_map_delete(&map, 1));
-  GPR_ASSERT(NULL == grpc_chttp2_stream_map_find(&map, 1));
+  GPR_ASSERT(nullptr == grpc_chttp2_stream_map_find(&map, 1));
+  GPR_ASSERT(nullptr == grpc_chttp2_stream_map_delete(&map, 1));
+  GPR_ASSERT(nullptr == grpc_chttp2_stream_map_find(&map, 1));
+  GPR_ASSERT(nullptr == grpc_chttp2_stream_map_delete(&map, 1));
+  GPR_ASSERT(nullptr == grpc_chttp2_stream_map_find(&map, 1));
+  GPR_ASSERT(nullptr == grpc_chttp2_stream_map_delete(&map, 1));
+  GPR_ASSERT(nullptr == grpc_chttp2_stream_map_find(&map, 1));
   grpc_chttp2_stream_map_destroy(&map);
 }
 
@@ -78,11 +78,11 @@ static void test_basic_add_find(uint32_t n) {
   grpc_chttp2_stream_map_init(&map, 8);
   GPR_ASSERT(0 == grpc_chttp2_stream_map_size(&map));
   for (i = 1; i <= n; i++) {
-    grpc_chttp2_stream_map_add(&map, i, (void *)(uintptr_t)i);
+    grpc_chttp2_stream_map_add(&map, i, (void*)(uintptr_t)i);
   }
   GPR_ASSERT(n == grpc_chttp2_stream_map_size(&map));
-  GPR_ASSERT(NULL == grpc_chttp2_stream_map_find(&map, 0));
-  GPR_ASSERT(NULL == grpc_chttp2_stream_map_find(&map, n + 1));
+  GPR_ASSERT(nullptr == grpc_chttp2_stream_map_find(&map, 0));
+  GPR_ASSERT(nullptr == grpc_chttp2_stream_map_find(&map, n + 1));
   for (i = 1; i <= n; i++) {
     got = (uintptr_t)grpc_chttp2_stream_map_find(&map, i);
     GPR_ASSERT(i == got);
@@ -91,26 +91,26 @@ static void test_basic_add_find(uint32_t n) {
 }
 
 /* verify that for_each gets the right values during test_delete_evens_XXX */
-static void verify_for_each(void *user_data, uint32_t stream_id, void *ptr) {
-  uint32_t *for_each_check = user_data;
+static void verify_for_each(void* user_data, uint32_t stream_id, void* ptr) {
+  uint32_t* for_each_check = static_cast<uint32_t*>(user_data);
   GPR_ASSERT(ptr);
   GPR_ASSERT(*for_each_check == stream_id);
   *for_each_check += 2;
 }
 
-static void check_delete_evens(grpc_chttp2_stream_map *map, uint32_t n) {
+static void check_delete_evens(grpc_chttp2_stream_map* map, uint32_t n) {
   uint32_t for_each_check = 1;
   uint32_t i;
   size_t got;
 
-  GPR_ASSERT(NULL == grpc_chttp2_stream_map_find(map, 0));
-  GPR_ASSERT(NULL == grpc_chttp2_stream_map_find(map, n + 1));
+  GPR_ASSERT(nullptr == grpc_chttp2_stream_map_find(map, 0));
+  GPR_ASSERT(nullptr == grpc_chttp2_stream_map_find(map, n + 1));
   for (i = 1; i <= n; i++) {
     if (i & 1) {
       got = (uintptr_t)grpc_chttp2_stream_map_find(map, i);
       GPR_ASSERT(i == got);
     } else {
-      GPR_ASSERT(NULL == grpc_chttp2_stream_map_find(map, i));
+      GPR_ASSERT(nullptr == grpc_chttp2_stream_map_find(map, i));
     }
   }
 
@@ -133,12 +133,11 @@ static void test_delete_evens_sweep(uint32_t n) {
 
   grpc_chttp2_stream_map_init(&map, 8);
   for (i = 1; i <= n; i++) {
-    grpc_chttp2_stream_map_add(&map, i, (void *)(uintptr_t)i);
+    grpc_chttp2_stream_map_add(&map, i, (void*)(uintptr_t)i);
   }
   for (i = 1; i <= n; i++) {
     if ((i & 1) == 0) {
-      GPR_ASSERT((void *)(uintptr_t)i ==
-                 grpc_chttp2_stream_map_delete(&map, i));
+      GPR_ASSERT((void*)(uintptr_t)i == grpc_chttp2_stream_map_delete(&map, i));
     }
   }
   check_delete_evens(&map, n);
@@ -156,7 +155,7 @@ static void test_delete_evens_incremental(uint32_t n) {
 
   grpc_chttp2_stream_map_init(&map, 8);
   for (i = 1; i <= n; i++) {
-    grpc_chttp2_stream_map_add(&map, i, (void *)(uintptr_t)i);
+    grpc_chttp2_stream_map_add(&map, i, (void*)(uintptr_t)i);
     if ((i & 1) == 0) {
       grpc_chttp2_stream_map_delete(&map, i);
     }
@@ -178,10 +177,10 @@ static void test_periodic_compaction(uint32_t n) {
   grpc_chttp2_stream_map_init(&map, 16);
   GPR_ASSERT(map.capacity == 16);
   for (i = 1; i <= n; i++) {
-    grpc_chttp2_stream_map_add(&map, i, (void *)(uintptr_t)i);
+    grpc_chttp2_stream_map_add(&map, i, (void*)(uintptr_t)i);
     if (i > 8) {
       del = i - 8;
-      GPR_ASSERT((void *)(uintptr_t)del ==
+      GPR_ASSERT((void*)(uintptr_t)del ==
                  grpc_chttp2_stream_map_delete(&map, del));
     }
   }
@@ -189,7 +188,7 @@ static void test_periodic_compaction(uint32_t n) {
   grpc_chttp2_stream_map_destroy(&map);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   uint32_t n = 1;
   uint32_t prev = 1;
   uint32_t tmp;
diff --git a/test/core/transport/chttp2/varint_test.c b/test/core/transport/chttp2/varint_test.cc
index 0986a2cde6..413b461b3a 100644
--- a/test/core/transport/chttp2/varint_test.c
+++ b/test/core/transport/chttp2/varint_test.cc
@@ -24,7 +24,7 @@
 #include "test/core/util/test_config.h"
 
 static void test_varint(uint32_t value, uint32_t prefix_bits, uint8_t prefix_or,
-                        const char *expect_bytes, size_t expect_length) {
+                        const char* expect_bytes, size_t expect_length) {
   uint32_t nbytes = GRPC_CHTTP2_VARINT_LENGTH(value, prefix_bits);
   grpc_slice expect =
       grpc_slice_from_copied_buffer(expect_bytes, expect_length);
@@ -42,7 +42,7 @@ static void test_varint(uint32_t value, uint32_t prefix_bits, uint8_t prefix_or,
 #define TEST_VARINT(value, prefix_bits, prefix_or, expect) \
   test_varint(value, prefix_bits, prefix_or, expect, sizeof(expect) - 1)
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   TEST_VARINT(0, 1, 0, "\x00");
   TEST_VARINT(128, 1, 0, "\x7f\x01");
diff --git a/test/core/transport/connectivity_state_test.c b/test/core/transport/connectivity_state_test.cc
index 4ef8683107..11046e126e 100644
--- a/test/core/transport/connectivity_state_test.c
+++ b/test/core/transport/connectivity_state_test.cc
@@ -23,19 +23,20 @@
 #include <grpc/support/log.h>
 
 #include "test/core/util/test_config.h"
+#include "test/core/util/tracer_util.h"
 
-#define THE_ARG ((void *)(size_t)0xcafebabe)
+#define THE_ARG ((void*)(size_t)0xcafebabe)
 
 int g_counter;
 
-static void must_succeed(grpc_exec_ctx *exec_ctx, void *arg,
-                         grpc_error *error) {
+static void must_succeed(grpc_exec_ctx* exec_ctx, void* arg,
+                         grpc_error* error) {
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   GPR_ASSERT(arg == THE_ARG);
   g_counter++;
 }
 
-static void must_fail(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
+static void must_fail(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
   GPR_ASSERT(error != GRPC_ERROR_NONE);
   GPR_ASSERT(arg == THE_ARG);
   g_counter++;
@@ -59,7 +60,7 @@ static void test_connectivity_state_name(void) {
 static void test_check(void) {
   grpc_connectivity_state_tracker tracker;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_error *error;
+  grpc_error* error;
   gpr_log(GPR_DEBUG, "test_check");
   grpc_connectivity_state_init(&tracker, GRPC_CHANNEL_IDLE, "xxx");
   GPR_ASSERT(grpc_connectivity_state_get(&tracker, &error) ==
@@ -72,7 +73,7 @@ static void test_check(void) {
 
 static void test_subscribe_then_unsubscribe(void) {
   grpc_connectivity_state_tracker tracker;
-  grpc_closure *closure =
+  grpc_closure* closure =
       GRPC_CLOSURE_CREATE(must_fail, THE_ARG, grpc_schedule_on_exec_ctx);
   grpc_connectivity_state state = GRPC_CHANNEL_IDLE;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -84,7 +85,7 @@ static void test_subscribe_then_unsubscribe(void) {
   grpc_exec_ctx_flush(&exec_ctx);
   GPR_ASSERT(state == GRPC_CHANNEL_IDLE);
   GPR_ASSERT(g_counter == 0);
-  grpc_connectivity_state_notify_on_state_change(&exec_ctx, &tracker, NULL,
+  grpc_connectivity_state_notify_on_state_change(&exec_ctx, &tracker, nullptr,
                                                  closure);
   grpc_exec_ctx_flush(&exec_ctx);
   GPR_ASSERT(state == GRPC_CHANNEL_IDLE);
@@ -96,7 +97,7 @@ static void test_subscribe_then_unsubscribe(void) {
 
 static void test_subscribe_then_destroy(void) {
   grpc_connectivity_state_tracker tracker;
-  grpc_closure *closure =
+  grpc_closure* closure =
       GRPC_CLOSURE_CREATE(must_succeed, THE_ARG, grpc_schedule_on_exec_ctx);
   grpc_connectivity_state state = GRPC_CHANNEL_IDLE;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -116,7 +117,7 @@ static void test_subscribe_then_destroy(void) {
 
 static void test_subscribe_with_failure_then_destroy(void) {
   grpc_connectivity_state_tracker tracker;
-  grpc_closure *closure =
+  grpc_closure* closure =
       GRPC_CLOSURE_CREATE(must_fail, THE_ARG, grpc_schedule_on_exec_ctx);
   grpc_connectivity_state state = GRPC_CHANNEL_SHUTDOWN;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -134,9 +135,9 @@ static void test_subscribe_with_failure_then_destroy(void) {
   GPR_ASSERT(g_counter == 1);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
-  grpc_connectivity_state_trace.value = 1;
+  grpc_core::testing::grpc_tracer_enable_flag(&grpc_connectivity_state_trace);
   test_connectivity_state_name();
   test_check();
   test_subscribe_then_unsubscribe();
diff --git a/test/core/transport/metadata_test.c b/test/core/transport/metadata_test.cc
index f7124d29a7..b60a9619fb 100644
--- a/test/core/transport/metadata_test.c
+++ b/test/core/transport/metadata_test.cc
@@ -114,7 +114,8 @@ static void test_create_many_ephemeral_metadata(bool intern_keys,
 static void test_create_many_persistant_metadata(void) {
   char buffer[GPR_LTOA_MIN_BUFSIZE];
   long i;
-  grpc_mdelem *created = gpr_malloc(sizeof(grpc_mdelem) * MANY);
+  grpc_mdelem* created =
+      static_cast<grpc_mdelem*>(gpr_malloc(sizeof(grpc_mdelem) * MANY));
   grpc_mdelem md;
 
   gpr_log(GPR_INFO, "test_create_many_persistant_metadata");
@@ -224,10 +225,11 @@ static void test_identity_laws(bool intern_keys, bool intern_values) {
 
 static void test_things_stick_around(void) {
   size_t i, j;
-  char *buffer;
+  char* buffer;
   size_t nstrs = 1000;
-  grpc_slice *strs = gpr_malloc(sizeof(grpc_slice) * nstrs);
-  size_t *shuf = gpr_malloc(sizeof(size_t) * nstrs);
+  grpc_slice* strs =
+      static_cast<grpc_slice*>(gpr_malloc(sizeof(grpc_slice) * nstrs));
+  size_t* shuf = static_cast<size_t*>(gpr_malloc(sizeof(size_t) * nstrs));
   grpc_slice test;
 
   gpr_log(GPR_INFO, "test_things_stick_around");
@@ -274,16 +276,16 @@ static void test_things_stick_around(void) {
 }
 
 static void test_user_data_works(void) {
-  int *ud1;
-  int *ud2;
+  int* ud1;
+  int* ud2;
   grpc_mdelem md;
   gpr_log(GPR_INFO, "test_user_data_works");
 
   grpc_init();
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  ud1 = gpr_malloc(sizeof(int));
+  ud1 = static_cast<int*>(gpr_malloc(sizeof(int)));
   *ud1 = 1;
-  ud2 = gpr_malloc(sizeof(int));
+  ud2 = static_cast<int*>(gpr_malloc(sizeof(int)));
   *ud2 = 2;
   md = grpc_mdelem_from_slices(
       &exec_ctx, grpc_slice_intern(grpc_slice_from_static_string("abc")),
@@ -296,8 +298,8 @@ static void test_user_data_works(void) {
   grpc_shutdown();
 }
 
-static void verify_ascii_header_size(grpc_exec_ctx *exec_ctx, const char *key,
-                                     const char *value, bool intern_key,
+static void verify_ascii_header_size(grpc_exec_ctx* exec_ctx, const char* key,
+                                     const char* value, bool intern_key,
                                      bool intern_value) {
   grpc_mdelem elem = grpc_mdelem_from_slices(
       exec_ctx, maybe_intern(grpc_slice_from_static_string(key), intern_key),
@@ -308,8 +310,8 @@ static void verify_ascii_header_size(grpc_exec_ctx *exec_ctx, const char *key,
   GRPC_MDELEM_UNREF(exec_ctx, elem);
 }
 
-static void verify_binary_header_size(grpc_exec_ctx *exec_ctx, const char *key,
-                                      const uint8_t *value, size_t value_len,
+static void verify_binary_header_size(grpc_exec_ctx* exec_ctx, const char* key,
+                                      const uint8_t* value, size_t value_len,
                                       bool intern_key, bool intern_value) {
   grpc_mdelem elem = grpc_mdelem_from_slices(
       exec_ctx, maybe_intern(grpc_slice_from_static_string(key), intern_key),
@@ -318,7 +320,7 @@ static void verify_binary_header_size(grpc_exec_ctx *exec_ctx, const char *key,
   GPR_ASSERT(grpc_is_binary_header(GRPC_MDKEY(elem)));
   size_t elem_size = grpc_mdelem_get_size_in_hpack_table(elem, false);
   grpc_slice value_slice =
-      grpc_slice_from_copied_buffer((const char *)value, value_len);
+      grpc_slice_from_copied_buffer((const char*)value, value_len);
   grpc_slice base64_encoded = grpc_chttp2_base64_encode(value_slice);
   size_t expected_size = 32 + strlen(key) + GRPC_SLICE_LENGTH(base64_encoded);
   GPR_ASSERT(expected_size == elem_size);
@@ -382,7 +384,7 @@ static void test_copied_static_metadata(bool dup_key, bool dup_value) {
   grpc_shutdown();
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_no_op();
   for (int k = 0; k <= 1; k++) {
diff --git a/test/core/transport/status_conversion_test.c b/test/core/transport/status_conversion_test.cc
index de8fa4458a..7af5d12cb7 100644
--- a/test/core/transport/status_conversion_test.c
+++ b/test/core/transport/status_conversion_test.cc
@@ -34,10 +34,11 @@
 #define HTTP2_STATUS_TO_GRPC_STATUS(a, b) \
   GPR_ASSERT(grpc_http2_status_to_grpc_status(a) == (b))
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   int i;
 
   grpc_test_init(argc, argv);
+  grpc_init();
 
   GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_OK, GRPC_HTTP2_NO_ERROR);
   GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_CANCELLED, GRPC_HTTP2_CANCEL);
@@ -129,6 +130,11 @@ int main(int argc, char **argv) {
                              GRPC_STATUS_INTERNAL);
   HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_REFUSED_STREAM, after_deadline,
                              GRPC_STATUS_UNAVAILABLE);
+  // We only have millisecond granularity in our timing code. This sleeps for 5
+  // millis to ensure that the status conversion code will pick up the fact
+  // that the deadline has expired.
+  gpr_sleep_until(gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
+                               gpr_time_from_millis(5, GPR_TIMESPAN)));
   HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_CANCEL, after_deadline,
                              GRPC_STATUS_DEADLINE_EXCEEDED);
   HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_COMPRESSION_ERROR, after_deadline,
@@ -158,5 +164,7 @@ int main(int argc, char **argv) {
     grpc_http2_status_to_grpc_status(i);
   }
 
+  grpc_shutdown();
+
   return 0;
 }
diff --git a/test/core/transport/stream_owned_slice_test.c b/test/core/transport/stream_owned_slice_test.cc
index 774ad4e72e..e82df2117d 100644
--- a/test/core/transport/stream_owned_slice_test.c
+++ b/test/core/transport/stream_owned_slice_test.cc
@@ -22,14 +22,14 @@
 
 #include <grpc/support/log.h>
 
-static void do_nothing(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {}
+static void do_nothing(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {}
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
 
   uint8_t buffer[] = "abc123";
   grpc_stream_refcount r;
-  GRPC_STREAM_REF_INIT(&r, 1, do_nothing, NULL, "test");
+  GRPC_STREAM_REF_INIT(&r, 1, do_nothing, nullptr, "test");
   GPR_ASSERT(r.refs.count == 1);
   grpc_slice slice =
       grpc_slice_from_stream_owned_buffer(&r, buffer, sizeof(buffer));
diff --git a/test/core/transport/timeout_encoding_test.c b/test/core/transport/timeout_encoding_test.cc
index 30357faed3..0930bc836d 100644
--- a/test/core/transport/timeout_encoding_test.c
+++ b/test/core/transport/timeout_encoding_test.cc
@@ -31,7 +31,7 @@
 
 #define LOG_TEST(x) gpr_log(GPR_INFO, "%s", x)
 
-static void assert_encodes_as(grpc_millis ts, const char *s) {
+static void assert_encodes_as(grpc_millis ts, const char* s) {
   char buffer[GRPC_HTTP2_TIMEOUT_ENCODE_MIN_BUFSIZE];
   grpc_http2_encode_timeout(ts, buffer);
   gpr_log(GPR_INFO, "check '%s' == '%s'", buffer, s);
@@ -63,7 +63,7 @@ void test_encoding(void) {
   assert_encodes_as(10 * 60 * 60 * GPR_MS_PER_SEC, "10H");
 }
 
-static void assert_decodes_as(const char *buffer, grpc_millis expected) {
+static void assert_decodes_as(const char* buffer, grpc_millis expected) {
   grpc_millis got;
   uint32_t hash = gpr_murmur_hash3(buffer, strlen(buffer), 0);
   gpr_log(GPR_INFO, "check decoding '%s' (hash=0x%x)", buffer, hash);
@@ -81,7 +81,7 @@ void decode_suite(char ext, grpc_millis (*answer)(int64_t x)) {
                       1234567, 12345678, 123456789, 98765432, 9876543, 987654,
                       98765,   9876,     987,       98,       9};
   unsigned i;
-  char *input;
+  char* input;
   for (i = 0; i < GPR_ARRAY_SIZE(test_vals); i++) {
     gpr_asprintf(&input, "%ld%c", test_vals[i], ext);
     assert_decodes_as(input, answer(test_vals[i]));
@@ -133,7 +133,7 @@ void test_decoding(void) {
   assert_decodes_as("9999999999S", GRPC_MILLIS_INF_FUTURE);
 }
 
-static void assert_decoding_fails(const char *s) {
+static void assert_decoding_fails(const char* s) {
   grpc_millis x;
   GPR_ASSERT(0 ==
              grpc_http2_decode_timeout(grpc_slice_from_static_string(s), &x));
@@ -152,7 +152,7 @@ void test_decoding_fails(void) {
   assert_decoding_fails("-1u");
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_encoding();
   test_decoding();
diff --git a/test/core/tsi/BUILD b/test/core/tsi/BUILD
index 0c5509dda6..e28c0b5f84 100644
--- a/test/core/tsi/BUILD
+++ b/test/core/tsi/BUILD
@@ -20,7 +20,7 @@ grpc_package(name = "test/core/tsi")
 
 grpc_cc_library(
     name = "transport_security_test_lib",
-    srcs = ["transport_security_test_lib.c"],
+    srcs = ["transport_security_test_lib.cc"],
     hdrs = ["transport_security_test_lib.h"],
     deps = [
         "//:grpc",
@@ -30,8 +30,8 @@ grpc_cc_library(
 
 grpc_cc_test(
     name = "fake_transport_security_test",
-    srcs = ["fake_transport_security_test.c"],
-    language = "C",
+    srcs = ["fake_transport_security_test.cc"],
+    language = "C++",
     deps = [
         ":transport_security_test_lib",
         "//:grpc",
@@ -44,7 +44,7 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "ssl_transport_security_test",
-    srcs = ["ssl_transport_security_test.c"],
+    srcs = ["ssl_transport_security_test.cc"],
     data = [
         "//src/core/tsi/test_creds:badclient.key",
         "//src/core/tsi/test_creds:badclient.pem",
@@ -58,7 +58,7 @@ grpc_cc_test(
         "//src/core/tsi/test_creds:server1.key",
         "//src/core/tsi/test_creds:server1.pem",
     ],
-    language = "C",
+    language = "C++",
     deps = [
         ":transport_security_test_lib",
         "//:grpc",
@@ -70,8 +70,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "transport_security_test",
-    srcs = ["transport_security_test.c"],
-    language = "C",
+    srcs = ["transport_security_test.cc"],
+    language = "C++",
     deps = [
         "//:grpc",
         "//:gpr",
diff --git a/test/core/tsi/fake_transport_security_test.c b/test/core/tsi/fake_transport_security_test.cc
index 11be8802b7..73643fc9fd 100644
--- a/test/core/tsi/fake_transport_security_test.c
+++ b/test/core/tsi/fake_transport_security_test.cc
@@ -33,66 +33,67 @@ typedef struct fake_tsi_test_fixture {
   tsi_test_fixture base;
 } fake_tsi_test_fixture;
 
-static void fake_test_setup_handshakers(tsi_test_fixture *fixture) {
+static void fake_test_setup_handshakers(tsi_test_fixture* fixture) {
   fixture->client_handshaker =
       tsi_create_fake_handshaker(true /* is_client. */);
   fixture->server_handshaker =
       tsi_create_fake_handshaker(false /* is_client. */);
 }
 
-static void validate_handshaker_peers(tsi_handshaker_result *result) {
-  GPR_ASSERT(result != NULL);
+static void validate_handshaker_peers(tsi_handshaker_result* result) {
+  GPR_ASSERT(result != nullptr);
   tsi_peer peer;
   GPR_ASSERT(tsi_handshaker_result_extract_peer(result, &peer) == TSI_OK);
-  const tsi_peer_property *property =
+  const tsi_peer_property* property =
       tsi_peer_get_property_by_name(&peer, TSI_CERTIFICATE_TYPE_PEER_PROPERTY);
-  GPR_ASSERT(property != NULL);
+  GPR_ASSERT(property != nullptr);
   GPR_ASSERT(memcmp(property->value.data, TSI_FAKE_CERTIFICATE_TYPE,
                     property->value.length) == 0);
   tsi_peer_destruct(&peer);
 }
 
-static void fake_test_check_handshaker_peers(tsi_test_fixture *fixture) {
+static void fake_test_check_handshaker_peers(tsi_test_fixture* fixture) {
   validate_handshaker_peers(fixture->client_result);
   validate_handshaker_peers(fixture->server_result);
 }
 
-static void fake_test_destruct(tsi_test_fixture *fixture) {}
+static void fake_test_destruct(tsi_test_fixture* fixture) {}
 
 static const struct tsi_test_fixture_vtable vtable = {
     fake_test_setup_handshakers, fake_test_check_handshaker_peers,
     fake_test_destruct};
 
-static tsi_test_fixture *fake_tsi_test_fixture_create() {
-  fake_tsi_test_fixture *fake_fixture = gpr_zalloc(sizeof(*fake_fixture));
+static tsi_test_fixture* fake_tsi_test_fixture_create() {
+  fake_tsi_test_fixture* fake_fixture =
+      static_cast<fake_tsi_test_fixture*>(gpr_zalloc(sizeof(*fake_fixture)));
   tsi_test_fixture_init(&fake_fixture->base);
   fake_fixture->base.vtable = &vtable;
   return &fake_fixture->base;
 }
 
 void fake_tsi_test_do_handshake_tiny_handshake_buffer() {
-  tsi_test_fixture *fixture = fake_tsi_test_fixture_create();
+  tsi_test_fixture* fixture = fake_tsi_test_fixture_create();
   fixture->handshake_buffer_size = TSI_TEST_TINY_HANDSHAKE_BUFFER_SIZE;
   tsi_test_do_handshake(fixture);
   tsi_test_fixture_destroy(fixture);
 }
 
 void fake_tsi_test_do_handshake_small_handshake_buffer() {
-  tsi_test_fixture *fixture = fake_tsi_test_fixture_create();
+  tsi_test_fixture* fixture = fake_tsi_test_fixture_create();
   fixture->handshake_buffer_size = TSI_TEST_SMALL_HANDSHAKE_BUFFER_SIZE;
   tsi_test_do_handshake(fixture);
   tsi_test_fixture_destroy(fixture);
 }
 
 void fake_tsi_test_do_handshake() {
-  tsi_test_fixture *fixture = fake_tsi_test_fixture_create();
+  tsi_test_fixture* fixture = fake_tsi_test_fixture_create();
   tsi_test_do_handshake(fixture);
   tsi_test_fixture_destroy(fixture);
 }
 
 void fake_tsi_test_do_round_trip_for_all_configs() {
-  unsigned int *bit_array =
-      gpr_zalloc(sizeof(unsigned int) * TSI_TEST_NUM_OF_ARGUMENTS);
+  unsigned int* bit_array = static_cast<unsigned int*>(
+      gpr_zalloc(sizeof(unsigned int) * TSI_TEST_NUM_OF_ARGUMENTS));
   const unsigned int mask = 1U << (TSI_TEST_NUM_OF_ARGUMENTS - 1);
   for (unsigned int val = 0; val < TSI_TEST_NUM_OF_COMBINATIONS; val++) {
     unsigned int v = val;
@@ -100,8 +101,8 @@ void fake_tsi_test_do_round_trip_for_all_configs() {
       bit_array[ind] = (v & mask) ? 1 : 0;
       v <<= 1;
     }
-    tsi_test_fixture *fixture = fake_tsi_test_fixture_create();
-    fake_tsi_test_fixture *fake_fixture = (fake_tsi_test_fixture *)fixture;
+    tsi_test_fixture* fixture = fake_tsi_test_fixture_create();
+    fake_tsi_test_fixture* fake_fixture = (fake_tsi_test_fixture*)fixture;
     tsi_test_frame_protector_config_destroy(fake_fixture->base.config);
     fake_fixture->base.config = tsi_test_frame_protector_config_create(
         bit_array[0], bit_array[1], bit_array[2], bit_array[3], bit_array[4],
@@ -120,9 +121,9 @@ void fake_tsi_test_do_round_trip_odd_buffer_size() {
       for (size_t ind3 = 0; ind3 < size; ind3++) {
         for (size_t ind4 = 0; ind4 < size; ind4++) {
           for (size_t ind5 = 0; ind5 < size; ind5++) {
-            tsi_test_fixture *fixture = fake_tsi_test_fixture_create();
-            fake_tsi_test_fixture *fake_fixture =
-                (fake_tsi_test_fixture *)fixture;
+            tsi_test_fixture* fixture = fake_tsi_test_fixture_create();
+            fake_tsi_test_fixture* fake_fixture =
+                (fake_tsi_test_fixture*)fixture;
             tsi_test_frame_protector_config_set_buffer_size(
                 fake_fixture->base.config, odd_sizes[ind1], odd_sizes[ind2],
                 odd_sizes[ind3], odd_sizes[ind4], odd_sizes[ind5]);
@@ -135,7 +136,7 @@ void fake_tsi_test_do_round_trip_odd_buffer_size() {
   }
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   fake_tsi_test_do_handshake_tiny_handshake_buffer();
diff --git a/test/core/tsi/ssl_transport_security_test.c b/test/core/tsi/ssl_transport_security_test.cc
index 2399b054b1..8939c0434b 100644
--- a/test/core/tsi/ssl_transport_security_test.c
+++ b/test/core/tsi/ssl_transport_security_test.cc
@@ -52,8 +52,8 @@ typedef enum AlpnMode {
 
 typedef struct ssl_alpn_lib {
   AlpnMode alpn_mode;
-  char **server_alpn_protocols;
-  char **client_alpn_protocols;
+  char** server_alpn_protocols;
+  char** client_alpn_protocols;
   uint16_t num_server_alpn_protocols;
   uint16_t num_client_alpn_protocols;
 } ssl_alpn_lib;
@@ -61,9 +61,9 @@ typedef struct ssl_alpn_lib {
 typedef struct ssl_key_cert_lib {
   bool use_bad_server_cert;
   bool use_bad_client_cert;
-  char *root_cert;
-  tsi_ssl_pem_key_cert_pair *server_pem_key_cert_pairs;
-  tsi_ssl_pem_key_cert_pair *bad_server_pem_key_cert_pairs;
+  char* root_cert;
+  tsi_ssl_pem_key_cert_pair* server_pem_key_cert_pairs;
+  tsi_ssl_pem_key_cert_pair* bad_server_pem_key_cert_pairs;
   tsi_ssl_pem_key_cert_pair client_pem_key_cert_pair;
   tsi_ssl_pem_key_cert_pair bad_client_pem_key_cert_pair;
   uint16_t server_num_key_cert_pairs;
@@ -72,29 +72,29 @@ typedef struct ssl_key_cert_lib {
 
 typedef struct ssl_tsi_test_fixture {
   tsi_test_fixture base;
-  ssl_key_cert_lib *key_cert_lib;
-  ssl_alpn_lib *alpn_lib;
+  ssl_key_cert_lib* key_cert_lib;
+  ssl_alpn_lib* alpn_lib;
   bool force_client_auth;
-  char *server_name_indication;
-  tsi_ssl_server_handshaker_factory *server_handshaker_factory;
-  tsi_ssl_client_handshaker_factory *client_handshaker_factory;
+  char* server_name_indication;
+  tsi_ssl_server_handshaker_factory* server_handshaker_factory;
+  tsi_ssl_client_handshaker_factory* client_handshaker_factory;
 } ssl_tsi_test_fixture;
 
-static void ssl_test_setup_handshakers(tsi_test_fixture *fixture) {
-  ssl_tsi_test_fixture *ssl_fixture = (ssl_tsi_test_fixture *)fixture;
-  GPR_ASSERT(ssl_fixture != NULL);
-  GPR_ASSERT(ssl_fixture->key_cert_lib != NULL);
-  GPR_ASSERT(ssl_fixture->alpn_lib != NULL);
-  ssl_key_cert_lib *key_cert_lib = ssl_fixture->key_cert_lib;
-  ssl_alpn_lib *alpn_lib = ssl_fixture->alpn_lib;
+static void ssl_test_setup_handshakers(tsi_test_fixture* fixture) {
+  ssl_tsi_test_fixture* ssl_fixture = (ssl_tsi_test_fixture*)fixture;
+  GPR_ASSERT(ssl_fixture != nullptr);
+  GPR_ASSERT(ssl_fixture->key_cert_lib != nullptr);
+  GPR_ASSERT(ssl_fixture->alpn_lib != nullptr);
+  ssl_key_cert_lib* key_cert_lib = ssl_fixture->key_cert_lib;
+  ssl_alpn_lib* alpn_lib = ssl_fixture->alpn_lib;
   /* Create client handshaker factory. */
-  tsi_ssl_pem_key_cert_pair *client_key_cert_pair = NULL;
+  tsi_ssl_pem_key_cert_pair* client_key_cert_pair = nullptr;
   if (ssl_fixture->force_client_auth) {
     client_key_cert_pair = key_cert_lib->use_bad_client_cert
                                ? &key_cert_lib->bad_client_pem_key_cert_pair
                                : &key_cert_lib->client_pem_key_cert_pair;
   }
-  char **client_alpn_protocols = NULL;
+  char** client_alpn_protocols = nullptr;
   uint16_t num_client_alpn_protocols = 0;
   if (alpn_lib->alpn_mode == ALPN_CLIENT_NO_SERVER ||
       alpn_lib->alpn_mode == ALPN_CLIENT_SERVER_OK ||
@@ -103,12 +103,11 @@ static void ssl_test_setup_handshakers(tsi_test_fixture *fixture) {
     num_client_alpn_protocols = alpn_lib->num_client_alpn_protocols;
   }
   GPR_ASSERT(tsi_create_ssl_client_handshaker_factory(
-                 client_key_cert_pair, key_cert_lib->root_cert, NULL,
-                 (const char **)client_alpn_protocols,
-                 num_client_alpn_protocols,
+                 client_key_cert_pair, key_cert_lib->root_cert, nullptr,
+                 (const char**)client_alpn_protocols, num_client_alpn_protocols,
                  &ssl_fixture->client_handshaker_factory) == TSI_OK);
   /* Create server handshaker factory. */
-  char **server_alpn_protocols = NULL;
+  char** server_alpn_protocols = nullptr;
   uint16_t num_server_alpn_protocols = 0;
   if (alpn_lib->alpn_mode == ALPN_SERVER_NO_CLIENT ||
       alpn_lib->alpn_mode == ALPN_CLIENT_SERVER_OK ||
@@ -126,19 +125,19 @@ static void ssl_test_setup_handshakers(tsi_test_fixture *fixture) {
                  key_cert_lib->use_bad_server_cert
                      ? key_cert_lib->bad_server_num_key_cert_pairs
                      : key_cert_lib->server_num_key_cert_pairs,
-                 key_cert_lib->root_cert, ssl_fixture->force_client_auth, NULL,
-                 (const char **)server_alpn_protocols,
+                 key_cert_lib->root_cert, ssl_fixture->force_client_auth,
+                 nullptr, (const char**)server_alpn_protocols,
                  num_server_alpn_protocols,
                  &ssl_fixture->server_handshaker_factory) == TSI_OK);
   /* Create server and client handshakers. */
-  tsi_handshaker *client_handshaker = NULL;
+  tsi_handshaker* client_handshaker = nullptr;
   GPR_ASSERT(tsi_ssl_client_handshaker_factory_create_handshaker(
                  ssl_fixture->client_handshaker_factory,
                  ssl_fixture->server_name_indication,
                  &client_handshaker) == TSI_OK);
   ssl_fixture->base.client_handshaker =
       tsi_create_adapter_handshaker(client_handshaker);
-  tsi_handshaker *server_handshaker = NULL;
+  tsi_handshaker* server_handshaker = nullptr;
   GPR_ASSERT(tsi_ssl_server_handshaker_factory_create_handshaker(
                  ssl_fixture->server_handshaker_factory, &server_handshaker) ==
              TSI_OK);
@@ -146,45 +145,45 @@ static void ssl_test_setup_handshakers(tsi_test_fixture *fixture) {
       tsi_create_adapter_handshaker(server_handshaker);
 }
 
-static void check_alpn(ssl_tsi_test_fixture *ssl_fixture,
-                       const tsi_peer *peer) {
-  GPR_ASSERT(ssl_fixture != NULL);
-  GPR_ASSERT(ssl_fixture->alpn_lib != NULL);
-  ssl_alpn_lib *alpn_lib = ssl_fixture->alpn_lib;
-  const tsi_peer_property *alpn_property =
+static void check_alpn(ssl_tsi_test_fixture* ssl_fixture,
+                       const tsi_peer* peer) {
+  GPR_ASSERT(ssl_fixture != nullptr);
+  GPR_ASSERT(ssl_fixture->alpn_lib != nullptr);
+  ssl_alpn_lib* alpn_lib = ssl_fixture->alpn_lib;
+  const tsi_peer_property* alpn_property =
       tsi_peer_get_property_by_name(peer, TSI_SSL_ALPN_SELECTED_PROTOCOL);
   if (alpn_lib->alpn_mode != ALPN_CLIENT_SERVER_OK) {
-    GPR_ASSERT(alpn_property == NULL);
+    GPR_ASSERT(alpn_property == nullptr);
   } else {
-    GPR_ASSERT(alpn_property != NULL);
-    const char *expected_match = "baz";
+    GPR_ASSERT(alpn_property != nullptr);
+    const char* expected_match = "baz";
     GPR_ASSERT(memcmp(alpn_property->value.data, expected_match,
                       alpn_property->value.length) == 0);
   }
 }
 
-static const tsi_peer_property *
-check_basic_authenticated_peer_and_get_common_name(const tsi_peer *peer) {
-  const tsi_peer_property *cert_type_property =
+static const tsi_peer_property*
+check_basic_authenticated_peer_and_get_common_name(const tsi_peer* peer) {
+  const tsi_peer_property* cert_type_property =
       tsi_peer_get_property_by_name(peer, TSI_CERTIFICATE_TYPE_PEER_PROPERTY);
-  GPR_ASSERT(cert_type_property != NULL);
+  GPR_ASSERT(cert_type_property != nullptr);
   GPR_ASSERT(memcmp(cert_type_property->value.data, TSI_X509_CERTIFICATE_TYPE,
                     cert_type_property->value.length) == 0);
-  const tsi_peer_property *property = tsi_peer_get_property_by_name(
+  const tsi_peer_property* property = tsi_peer_get_property_by_name(
       peer, TSI_X509_SUBJECT_COMMON_NAME_PEER_PROPERTY);
-  GPR_ASSERT(property != NULL);
+  GPR_ASSERT(property != nullptr);
   return property;
 }
 
-void check_server0_peer(tsi_peer *peer) {
-  const tsi_peer_property *property =
+void check_server0_peer(tsi_peer* peer) {
+  const tsi_peer_property* property =
       check_basic_authenticated_peer_and_get_common_name(peer);
-  const char *expected_match = "*.test.google.com.au";
+  const char* expected_match = "*.test.google.com.au";
   GPR_ASSERT(memcmp(property->value.data, expected_match,
                     property->value.length) == 0);
   GPR_ASSERT(tsi_peer_get_property_by_name(
                  peer, TSI_X509_SUBJECT_ALTERNATIVE_NAME_PEER_PROPERTY) ==
-             NULL);
+             nullptr);
   GPR_ASSERT(tsi_ssl_peer_matches_name(peer, "foo.test.google.com.au") == 1);
   GPR_ASSERT(tsi_ssl_peer_matches_name(peer, "bar.test.google.com.au") == 1);
   GPR_ASSERT(tsi_ssl_peer_matches_name(peer, "bar.test.google.blah") == 0);
@@ -194,9 +193,9 @@ void check_server0_peer(tsi_peer *peer) {
   tsi_peer_destruct(peer);
 }
 
-static bool check_subject_alt_name(tsi_peer *peer, const char *name) {
+static bool check_subject_alt_name(tsi_peer* peer, const char* name) {
   for (size_t i = 0; i < peer->property_count; i++) {
-    const tsi_peer_property *prop = &peer->properties[i];
+    const tsi_peer_property* prop = &peer->properties[i];
     if (strcmp(prop->name, TSI_X509_SUBJECT_ALTERNATIVE_NAME_PEER_PROPERTY) ==
         0) {
       if (memcmp(prop->value.data, name, prop->value.length) == 0) {
@@ -207,10 +206,10 @@ static bool check_subject_alt_name(tsi_peer *peer, const char *name) {
   return false;
 }
 
-void check_server1_peer(tsi_peer *peer) {
-  const tsi_peer_property *property =
+void check_server1_peer(tsi_peer* peer) {
+  const tsi_peer_property* property =
       check_basic_authenticated_peer_and_get_common_name(peer);
-  const char *expected_match = "*.test.google.com";
+  const char* expected_match = "*.test.google.com";
   GPR_ASSERT(memcmp(property->value.data, expected_match,
                     property->value.length) == 0);
   GPR_ASSERT(check_subject_alt_name(peer, "*.test.google.fr") == 1);
@@ -226,29 +225,29 @@ void check_server1_peer(tsi_peer *peer) {
   tsi_peer_destruct(peer);
 }
 
-static void check_client_peer(ssl_tsi_test_fixture *ssl_fixture,
-                              tsi_peer *peer) {
-  GPR_ASSERT(ssl_fixture != NULL);
-  GPR_ASSERT(ssl_fixture->alpn_lib != NULL);
-  ssl_alpn_lib *alpn_lib = ssl_fixture->alpn_lib;
+static void check_client_peer(ssl_tsi_test_fixture* ssl_fixture,
+                              tsi_peer* peer) {
+  GPR_ASSERT(ssl_fixture != nullptr);
+  GPR_ASSERT(ssl_fixture->alpn_lib != nullptr);
+  ssl_alpn_lib* alpn_lib = ssl_fixture->alpn_lib;
   if (!ssl_fixture->force_client_auth) {
     GPR_ASSERT(peer->property_count ==
                (alpn_lib->alpn_mode == ALPN_CLIENT_SERVER_OK ? 1 : 0));
   } else {
-    const tsi_peer_property *property =
+    const tsi_peer_property* property =
         check_basic_authenticated_peer_and_get_common_name(peer);
-    const char *expected_match = "testclient";
+    const char* expected_match = "testclient";
     GPR_ASSERT(memcmp(property->value.data, expected_match,
                       property->value.length) == 0);
   }
   tsi_peer_destruct(peer);
 }
 
-static void ssl_test_check_handshaker_peers(tsi_test_fixture *fixture) {
-  ssl_tsi_test_fixture *ssl_fixture = (ssl_tsi_test_fixture *)fixture;
-  GPR_ASSERT(ssl_fixture != NULL);
-  GPR_ASSERT(ssl_fixture->key_cert_lib != NULL);
-  ssl_key_cert_lib *key_cert_lib = ssl_fixture->key_cert_lib;
+static void ssl_test_check_handshaker_peers(tsi_test_fixture* fixture) {
+  ssl_tsi_test_fixture* ssl_fixture = (ssl_tsi_test_fixture*)fixture;
+  GPR_ASSERT(ssl_fixture != nullptr);
+  GPR_ASSERT(ssl_fixture->key_cert_lib != nullptr);
+  ssl_key_cert_lib* key_cert_lib = ssl_fixture->key_cert_lib;
   tsi_peer peer;
   bool expect_success =
       !(key_cert_lib->use_bad_server_cert ||
@@ -258,13 +257,13 @@ static void ssl_test_check_handshaker_peers(tsi_test_fixture *fixture) {
                    ssl_fixture->base.client_result, &peer) == TSI_OK);
     check_alpn(ssl_fixture, &peer);
 
-    if (ssl_fixture->server_name_indication != NULL) {
+    if (ssl_fixture->server_name_indication != nullptr) {
       check_server1_peer(&peer);
     } else {
       check_server0_peer(&peer);
     }
   } else {
-    GPR_ASSERT(ssl_fixture->base.client_result == NULL);
+    GPR_ASSERT(ssl_fixture->base.client_result == nullptr);
   }
   if (expect_success) {
     GPR_ASSERT(tsi_handshaker_result_extract_peer(
@@ -272,22 +271,22 @@ static void ssl_test_check_handshaker_peers(tsi_test_fixture *fixture) {
     check_alpn(ssl_fixture, &peer);
     check_client_peer(ssl_fixture, &peer);
   } else {
-    GPR_ASSERT(ssl_fixture->base.server_result == NULL);
+    GPR_ASSERT(ssl_fixture->base.server_result == nullptr);
   }
 }
 
 static void ssl_test_pem_key_cert_pair_destroy(tsi_ssl_pem_key_cert_pair kp) {
-  gpr_free((void *)kp.private_key);
-  gpr_free((void *)kp.cert_chain);
+  gpr_free((void*)kp.private_key);
+  gpr_free((void*)kp.cert_chain);
 }
 
-static void ssl_test_destruct(tsi_test_fixture *fixture) {
-  ssl_tsi_test_fixture *ssl_fixture = (ssl_tsi_test_fixture *)fixture;
-  if (ssl_fixture == NULL) {
+static void ssl_test_destruct(tsi_test_fixture* fixture) {
+  ssl_tsi_test_fixture* ssl_fixture = (ssl_tsi_test_fixture*)fixture;
+  if (ssl_fixture == nullptr) {
     return;
   }
   /* Destroy ssl_alpn_lib. */
-  ssl_alpn_lib *alpn_lib = ssl_fixture->alpn_lib;
+  ssl_alpn_lib* alpn_lib = ssl_fixture->alpn_lib;
   for (size_t i = 0; i < alpn_lib->num_server_alpn_protocols; i++) {
     gpr_free(alpn_lib->server_alpn_protocols[i]);
   }
@@ -298,7 +297,7 @@ static void ssl_test_destruct(tsi_test_fixture *fixture) {
   gpr_free(alpn_lib->client_alpn_protocols);
   gpr_free(alpn_lib);
   /* Destroy ssl_key_cert_lib. */
-  ssl_key_cert_lib *key_cert_lib = ssl_fixture->key_cert_lib;
+  ssl_key_cert_lib* key_cert_lib = ssl_fixture->key_cert_lib;
   for (size_t i = 0; i < key_cert_lib->server_num_key_cert_pairs; i++) {
     ssl_test_pem_key_cert_pair_destroy(
         key_cert_lib->server_pem_key_cert_pairs[i]);
@@ -325,26 +324,28 @@ static const struct tsi_test_fixture_vtable vtable = {
     ssl_test_setup_handshakers, ssl_test_check_handshaker_peers,
     ssl_test_destruct};
 
-static char *load_file(const char *dir_path, const char *file_name) {
-  char *file_path =
-      gpr_zalloc(sizeof(char) * (strlen(dir_path) + strlen(file_name) + 1));
+static char* load_file(const char* dir_path, const char* file_name) {
+  char* file_path = static_cast<char*>(
+      gpr_zalloc(sizeof(char) * (strlen(dir_path) + strlen(file_name) + 1)));
   memcpy(file_path, dir_path, strlen(dir_path));
   memcpy(file_path + strlen(dir_path), file_name, strlen(file_name));
   grpc_slice slice;
   GPR_ASSERT(grpc_load_file(file_path, 1, &slice) == GRPC_ERROR_NONE);
-  char *data = grpc_slice_to_c_string(slice);
+  char* data = grpc_slice_to_c_string(slice);
   grpc_slice_unref(slice);
   gpr_free(file_path);
   return data;
 }
 
-static tsi_test_fixture *ssl_tsi_test_fixture_create() {
-  ssl_tsi_test_fixture *ssl_fixture = gpr_zalloc(sizeof(*ssl_fixture));
+static tsi_test_fixture* ssl_tsi_test_fixture_create() {
+  ssl_tsi_test_fixture* ssl_fixture =
+      static_cast<ssl_tsi_test_fixture*>(gpr_zalloc(sizeof(*ssl_fixture)));
   tsi_test_fixture_init(&ssl_fixture->base);
   ssl_fixture->base.test_unused_bytes = false;
   ssl_fixture->base.vtable = &vtable;
   /* Create ssl_key_cert_lib. */
-  ssl_key_cert_lib *key_cert_lib = gpr_zalloc(sizeof(*key_cert_lib));
+  ssl_key_cert_lib* key_cert_lib =
+      static_cast<ssl_key_cert_lib*>(gpr_zalloc(sizeof(*key_cert_lib)));
   key_cert_lib->use_bad_server_cert = false;
   key_cert_lib->use_bad_client_cert = false;
   key_cert_lib->server_num_key_cert_pairs =
@@ -352,11 +353,13 @@ static tsi_test_fixture *ssl_tsi_test_fixture_create() {
   key_cert_lib->bad_server_num_key_cert_pairs =
       SSL_TSI_TEST_BAD_SERVER_KEY_CERT_PAIRS_NUM;
   key_cert_lib->server_pem_key_cert_pairs =
-      gpr_malloc(sizeof(tsi_ssl_pem_key_cert_pair) *
-                 key_cert_lib->server_num_key_cert_pairs);
+      static_cast<tsi_ssl_pem_key_cert_pair*>(
+          gpr_malloc(sizeof(tsi_ssl_pem_key_cert_pair) *
+                     key_cert_lib->server_num_key_cert_pairs));
   key_cert_lib->bad_server_pem_key_cert_pairs =
-      gpr_malloc(sizeof(tsi_ssl_pem_key_cert_pair) *
-                 key_cert_lib->bad_server_num_key_cert_pairs);
+      static_cast<tsi_ssl_pem_key_cert_pair*>(
+          gpr_malloc(sizeof(tsi_ssl_pem_key_cert_pair) *
+                     key_cert_lib->bad_server_num_key_cert_pairs));
   key_cert_lib->server_pem_key_cert_pairs[0].private_key =
       load_file(SSL_TSI_TEST_CREDENTIALS_DIR, "server0.key");
   key_cert_lib->server_pem_key_cert_pairs[0].cert_chain =
@@ -380,11 +383,12 @@ static tsi_test_fixture *ssl_tsi_test_fixture_create() {
   key_cert_lib->root_cert = load_file(SSL_TSI_TEST_CREDENTIALS_DIR, "ca.pem");
   ssl_fixture->key_cert_lib = key_cert_lib;
   /* Create ssl_alpn_lib. */
-  ssl_alpn_lib *alpn_lib = gpr_zalloc(sizeof(*alpn_lib));
+  ssl_alpn_lib* alpn_lib =
+      static_cast<ssl_alpn_lib*>(gpr_zalloc(sizeof(*alpn_lib)));
   alpn_lib->server_alpn_protocols =
-      gpr_zalloc(sizeof(char *) * SSL_TSI_TEST_ALPN_NUM);
+      static_cast<char**>(gpr_zalloc(sizeof(char*) * SSL_TSI_TEST_ALPN_NUM));
   alpn_lib->client_alpn_protocols =
-      gpr_zalloc(sizeof(char *) * SSL_TSI_TEST_ALPN_NUM);
+      static_cast<char**>(gpr_zalloc(sizeof(char*) * SSL_TSI_TEST_ALPN_NUM));
   alpn_lib->server_alpn_protocols[0] = gpr_strdup(SSL_TSI_TEST_ALPN1);
   alpn_lib->server_alpn_protocols[1] = gpr_strdup(SSL_TSI_TEST_ALPN3);
   alpn_lib->client_alpn_protocols[0] = gpr_strdup(SSL_TSI_TEST_ALPN2);
@@ -394,34 +398,34 @@ static tsi_test_fixture *ssl_tsi_test_fixture_create() {
   alpn_lib->alpn_mode = NO_ALPN;
   ssl_fixture->alpn_lib = alpn_lib;
   ssl_fixture->base.vtable = &vtable;
-  ssl_fixture->server_name_indication = NULL;
+  ssl_fixture->server_name_indication = nullptr;
   ssl_fixture->force_client_auth = false;
   return &ssl_fixture->base;
 }
 
 void ssl_tsi_test_do_handshake_tiny_handshake_buffer() {
-  tsi_test_fixture *fixture = ssl_tsi_test_fixture_create();
+  tsi_test_fixture* fixture = ssl_tsi_test_fixture_create();
   fixture->handshake_buffer_size = TSI_TEST_TINY_HANDSHAKE_BUFFER_SIZE;
   tsi_test_do_handshake(fixture);
   tsi_test_fixture_destroy(fixture);
 }
 
 void ssl_tsi_test_do_handshake_small_handshake_buffer() {
-  tsi_test_fixture *fixture = ssl_tsi_test_fixture_create();
+  tsi_test_fixture* fixture = ssl_tsi_test_fixture_create();
   fixture->handshake_buffer_size = TSI_TEST_SMALL_HANDSHAKE_BUFFER_SIZE;
   tsi_test_do_handshake(fixture);
   tsi_test_fixture_destroy(fixture);
 }
 
 void ssl_tsi_test_do_handshake() {
-  tsi_test_fixture *fixture = ssl_tsi_test_fixture_create();
+  tsi_test_fixture* fixture = ssl_tsi_test_fixture_create();
   tsi_test_do_handshake(fixture);
   tsi_test_fixture_destroy(fixture);
 }
 
 void ssl_tsi_test_do_handshake_with_client_authentication() {
-  tsi_test_fixture *fixture = ssl_tsi_test_fixture_create();
-  ssl_tsi_test_fixture *ssl_fixture = (ssl_tsi_test_fixture *)fixture;
+  tsi_test_fixture* fixture = ssl_tsi_test_fixture_create();
+  ssl_tsi_test_fixture* ssl_fixture = (ssl_tsi_test_fixture*)fixture;
   ssl_fixture->force_client_auth = true;
   tsi_test_do_handshake(fixture);
   tsi_test_fixture_destroy(fixture);
@@ -429,33 +433,35 @@ void ssl_tsi_test_do_handshake_with_client_authentication() {
 
 void ssl_tsi_test_do_handshake_with_server_name_indication_exact_domain() {
   /* server1 cert contains "waterzooi.test.google.be" in SAN. */
-  tsi_test_fixture *fixture = ssl_tsi_test_fixture_create();
-  ssl_tsi_test_fixture *ssl_fixture = (ssl_tsi_test_fixture *)fixture;
-  ssl_fixture->server_name_indication = "waterzooi.test.google.be";
+  tsi_test_fixture* fixture = ssl_tsi_test_fixture_create();
+  ssl_tsi_test_fixture* ssl_fixture = (ssl_tsi_test_fixture*)fixture;
+  ssl_fixture->server_name_indication =
+      const_cast<char*>("waterzooi.test.google.be");
   tsi_test_do_handshake(fixture);
   tsi_test_fixture_destroy(fixture);
 }
 
 void ssl_tsi_test_do_handshake_with_server_name_indication_wild_star_domain() {
   /* server1 cert contains "*.test.google.fr" in SAN. */
-  tsi_test_fixture *fixture = ssl_tsi_test_fixture_create();
-  ssl_tsi_test_fixture *ssl_fixture = (ssl_tsi_test_fixture *)fixture;
-  ssl_fixture->server_name_indication = "juju.test.google.fr";
+  tsi_test_fixture* fixture = ssl_tsi_test_fixture_create();
+  ssl_tsi_test_fixture* ssl_fixture = (ssl_tsi_test_fixture*)fixture;
+  ssl_fixture->server_name_indication =
+      const_cast<char*>("juju.test.google.fr");
   tsi_test_do_handshake(fixture);
   tsi_test_fixture_destroy(fixture);
 }
 
 void ssl_tsi_test_do_handshake_with_bad_server_cert() {
-  tsi_test_fixture *fixture = ssl_tsi_test_fixture_create();
-  ssl_tsi_test_fixture *ssl_fixture = (ssl_tsi_test_fixture *)fixture;
+  tsi_test_fixture* fixture = ssl_tsi_test_fixture_create();
+  ssl_tsi_test_fixture* ssl_fixture = (ssl_tsi_test_fixture*)fixture;
   ssl_fixture->key_cert_lib->use_bad_server_cert = true;
   tsi_test_do_handshake(fixture);
   tsi_test_fixture_destroy(fixture);
 }
 
 void ssl_tsi_test_do_handshake_with_bad_client_cert() {
-  tsi_test_fixture *fixture = ssl_tsi_test_fixture_create();
-  ssl_tsi_test_fixture *ssl_fixture = (ssl_tsi_test_fixture *)fixture;
+  tsi_test_fixture* fixture = ssl_tsi_test_fixture_create();
+  ssl_tsi_test_fixture* ssl_fixture = (ssl_tsi_test_fixture*)fixture;
   ssl_fixture->key_cert_lib->use_bad_client_cert = true;
   ssl_fixture->force_client_auth = true;
   tsi_test_do_handshake(fixture);
@@ -463,40 +469,40 @@ void ssl_tsi_test_do_handshake_with_bad_client_cert() {
 }
 
 void ssl_tsi_test_do_handshake_alpn_client_no_server() {
-  tsi_test_fixture *fixture = ssl_tsi_test_fixture_create();
-  ssl_tsi_test_fixture *ssl_fixture = (ssl_tsi_test_fixture *)fixture;
+  tsi_test_fixture* fixture = ssl_tsi_test_fixture_create();
+  ssl_tsi_test_fixture* ssl_fixture = (ssl_tsi_test_fixture*)fixture;
   ssl_fixture->alpn_lib->alpn_mode = ALPN_CLIENT_NO_SERVER;
   tsi_test_do_handshake(fixture);
   tsi_test_fixture_destroy(fixture);
 }
 
 void ssl_tsi_test_do_handshake_alpn_server_no_client() {
-  tsi_test_fixture *fixture = ssl_tsi_test_fixture_create();
-  ssl_tsi_test_fixture *ssl_fixture = (ssl_tsi_test_fixture *)fixture;
+  tsi_test_fixture* fixture = ssl_tsi_test_fixture_create();
+  ssl_tsi_test_fixture* ssl_fixture = (ssl_tsi_test_fixture*)fixture;
   ssl_fixture->alpn_lib->alpn_mode = ALPN_SERVER_NO_CLIENT;
   tsi_test_do_handshake(fixture);
   tsi_test_fixture_destroy(fixture);
 }
 
 void ssl_tsi_test_do_handshake_alpn_client_server_mismatch() {
-  tsi_test_fixture *fixture = ssl_tsi_test_fixture_create();
-  ssl_tsi_test_fixture *ssl_fixture = (ssl_tsi_test_fixture *)fixture;
+  tsi_test_fixture* fixture = ssl_tsi_test_fixture_create();
+  ssl_tsi_test_fixture* ssl_fixture = (ssl_tsi_test_fixture*)fixture;
   ssl_fixture->alpn_lib->alpn_mode = ALPN_CLIENT_SERVER_MISMATCH;
   tsi_test_do_handshake(fixture);
   tsi_test_fixture_destroy(fixture);
 }
 
 void ssl_tsi_test_do_handshake_alpn_client_server_ok() {
-  tsi_test_fixture *fixture = ssl_tsi_test_fixture_create();
-  ssl_tsi_test_fixture *ssl_fixture = (ssl_tsi_test_fixture *)fixture;
+  tsi_test_fixture* fixture = ssl_tsi_test_fixture_create();
+  ssl_tsi_test_fixture* ssl_fixture = (ssl_tsi_test_fixture*)fixture;
   ssl_fixture->alpn_lib->alpn_mode = ALPN_CLIENT_SERVER_OK;
   tsi_test_do_handshake(fixture);
   tsi_test_fixture_destroy(fixture);
 }
 
 void ssl_tsi_test_do_round_trip_for_all_configs() {
-  unsigned int *bit_array =
-      gpr_zalloc(sizeof(unsigned int) * TSI_TEST_NUM_OF_ARGUMENTS);
+  unsigned int* bit_array = static_cast<unsigned int*>(
+      gpr_zalloc(sizeof(unsigned int) * TSI_TEST_NUM_OF_ARGUMENTS));
   const unsigned int mask = 1U << (TSI_TEST_NUM_OF_ARGUMENTS - 1);
   for (unsigned int val = 0; val < TSI_TEST_NUM_OF_COMBINATIONS; val++) {
     unsigned int v = val;
@@ -504,8 +510,8 @@ void ssl_tsi_test_do_round_trip_for_all_configs() {
       bit_array[ind] = (v & mask) ? 1 : 0;
       v <<= 1;
     }
-    tsi_test_fixture *fixture = ssl_tsi_test_fixture_create();
-    ssl_tsi_test_fixture *ssl_fixture = (ssl_tsi_test_fixture *)fixture;
+    tsi_test_fixture* fixture = ssl_tsi_test_fixture_create();
+    ssl_tsi_test_fixture* ssl_fixture = (ssl_tsi_test_fixture*)fixture;
     tsi_test_frame_protector_config_destroy(ssl_fixture->base.config);
     ssl_fixture->base.config = tsi_test_frame_protector_config_create(
         bit_array[0], bit_array[1], bit_array[2], bit_array[3], bit_array[4],
@@ -524,8 +530,8 @@ void ssl_tsi_test_do_round_trip_odd_buffer_size() {
       for (size_t ind3 = 0; ind3 < size; ind3++) {
         for (size_t ind4 = 0; ind4 < size; ind4++) {
           for (size_t ind5 = 0; ind5 < size; ind5++) {
-            tsi_test_fixture *fixture = ssl_tsi_test_fixture_create();
-            ssl_tsi_test_fixture *ssl_fixture = (ssl_tsi_test_fixture *)fixture;
+            tsi_test_fixture* fixture = ssl_tsi_test_fixture_create();
+            ssl_tsi_test_fixture* ssl_fixture = (ssl_tsi_test_fixture*)fixture;
             tsi_test_frame_protector_config_set_buffer_size(
                 ssl_fixture->base.config, odd_sizes[ind1], odd_sizes[ind2],
                 odd_sizes[ind3], odd_sizes[ind4], odd_sizes[ind5]);
@@ -538,14 +544,14 @@ void ssl_tsi_test_do_round_trip_odd_buffer_size() {
   }
 }
 
-static const tsi_ssl_handshaker_factory_vtable *original_vtable;
+static const tsi_ssl_handshaker_factory_vtable* original_vtable;
 static bool handshaker_factory_destructor_called;
 
 static void ssl_tsi_test_handshaker_factory_destructor(
-    tsi_ssl_handshaker_factory *factory) {
-  GPR_ASSERT(factory != NULL);
+    tsi_ssl_handshaker_factory* factory) {
+  GPR_ASSERT(factory != nullptr);
   handshaker_factory_destructor_called = true;
-  if (original_vtable != NULL && original_vtable->destroy != NULL) {
+  if (original_vtable != nullptr && original_vtable->destroy != nullptr) {
     original_vtable->destroy(factory);
   }
 }
@@ -555,20 +561,20 @@ static tsi_ssl_handshaker_factory_vtable test_handshaker_factory_vtable = {
 
 void test_tsi_ssl_client_handshaker_factory_refcounting() {
   int i;
-  const char *cert_chain =
+  const char* cert_chain =
       load_file(SSL_TSI_TEST_CREDENTIALS_DIR, "client.pem");
 
-  tsi_ssl_client_handshaker_factory *client_handshaker_factory;
+  tsi_ssl_client_handshaker_factory* client_handshaker_factory;
   GPR_ASSERT(tsi_create_ssl_client_handshaker_factory(
-                 NULL, cert_chain, NULL, NULL, 0, &client_handshaker_factory) ==
-             TSI_OK);
+                 nullptr, cert_chain, nullptr, nullptr, 0,
+                 &client_handshaker_factory) == TSI_OK);
 
   handshaker_factory_destructor_called = false;
   original_vtable = tsi_ssl_handshaker_factory_swap_vtable(
-      (tsi_ssl_handshaker_factory *)client_handshaker_factory,
+      (tsi_ssl_handshaker_factory*)client_handshaker_factory,
       &test_handshaker_factory_vtable);
 
-  tsi_handshaker *handshaker[3];
+  tsi_handshaker* handshaker[3];
 
   for (i = 0; i < 3; ++i) {
     GPR_ASSERT(tsi_ssl_client_handshaker_factory_create_handshaker(
@@ -588,14 +594,14 @@ void test_tsi_ssl_client_handshaker_factory_refcounting() {
   tsi_handshaker_destroy(handshaker[2]);
   GPR_ASSERT(handshaker_factory_destructor_called);
 
-  gpr_free((void *)cert_chain);
+  gpr_free((void*)cert_chain);
 }
 
 void test_tsi_ssl_server_handshaker_factory_refcounting() {
   int i;
-  tsi_ssl_server_handshaker_factory *server_handshaker_factory;
-  tsi_handshaker *handshaker[3];
-  const char *cert_chain =
+  tsi_ssl_server_handshaker_factory* server_handshaker_factory;
+  tsi_handshaker* handshaker[3];
+  const char* cert_chain =
       load_file(SSL_TSI_TEST_CREDENTIALS_DIR, "server0.pem");
   tsi_ssl_pem_key_cert_pair cert_pair;
 
@@ -604,12 +610,12 @@ void test_tsi_ssl_server_handshaker_factory_refcounting() {
       load_file(SSL_TSI_TEST_CREDENTIALS_DIR, "server0.key");
 
   GPR_ASSERT(tsi_create_ssl_server_handshaker_factory(
-                 &cert_pair, 1, cert_chain, 0, NULL, NULL, 0,
+                 &cert_pair, 1, cert_chain, 0, nullptr, nullptr, 0,
                  &server_handshaker_factory) == TSI_OK);
 
   handshaker_factory_destructor_called = false;
   original_vtable = tsi_ssl_handshaker_factory_swap_vtable(
-      (tsi_ssl_handshaker_factory *)server_handshaker_factory,
+      (tsi_ssl_handshaker_factory*)server_handshaker_factory,
       &test_handshaker_factory_vtable);
 
   for (i = 0; i < 3; ++i) {
@@ -635,12 +641,12 @@ void test_tsi_ssl_server_handshaker_factory_refcounting() {
 /* Attempting to create a handshaker factory with invalid parameters should fail
  * but not crash. */
 void test_tsi_ssl_client_handshaker_factory_bad_params() {
-  const char *cert_chain = "This is not a valid PEM file.";
+  const char* cert_chain = "This is not a valid PEM file.";
 
-  tsi_ssl_client_handshaker_factory *client_handshaker_factory;
+  tsi_ssl_client_handshaker_factory* client_handshaker_factory;
   GPR_ASSERT(tsi_create_ssl_client_handshaker_factory(
-                 NULL, cert_chain, NULL, NULL, 0, &client_handshaker_factory) ==
-             TSI_INVALID_ARGUMENT);
+                 nullptr, cert_chain, nullptr, nullptr, 0,
+                 &client_handshaker_factory) == TSI_INVALID_ARGUMENT);
   tsi_ssl_client_handshaker_factory_unref(client_handshaker_factory);
 }
 
@@ -650,7 +656,7 @@ void ssl_tsi_test_handshaker_factory_internals() {
   test_tsi_ssl_client_handshaker_factory_bad_params();
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   ssl_tsi_test_do_handshake_tiny_handshake_buffer();
diff --git a/test/core/tsi/transport_security_test.c b/test/core/tsi/transport_security_test.cc
index 27932a8169..c788ad96ad 100644
--- a/test/core/tsi/transport_security_test.c
+++ b/test/core/tsi/transport_security_test.cc
@@ -37,46 +37,46 @@ typedef struct {
   int expected;
 
   /* Host name to match. */
-  const char *host_name;
+  const char* host_name;
 
   /* Common name (CN). */
-  const char *common_name;
+  const char* common_name;
 
   /* Comma separated list of certificate names to match against. Any occurrence
      of '#' will be replaced with a null character before processing. */
-  const char *dns_names;
+  const char* dns_names;
 
   /* Comma separated list of IP SANs to match aggainst */
-  const char *ip_names;
+  const char* ip_names;
 } cert_name_test_entry;
 
 /* Largely inspired from:
    chromium/src/net/cert/x509_certificate_unittest.cc.
    TODO(jboeuf) uncomment test cases as we fix tsi_ssl_peer_matches_name. */
 const cert_name_test_entry cert_name_test_entries[] = {
-    {1, "foo.com", "foo.com", NULL, NULL},
-    {1, "f", "f", NULL, NULL},
-    {0, "h", "i", NULL, NULL},
-    {1, "bar.foo.com", "*.foo.com", NULL, NULL},
+    {1, "foo.com", "foo.com", nullptr, nullptr},
+    {1, "f", "f", nullptr, nullptr},
+    {0, "h", "i", nullptr, nullptr},
+    {1, "bar.foo.com", "*.foo.com", nullptr, nullptr},
     {1, "www.test.fr", "common.name",
-     "*.test.com,*.test.co.uk,*.test.de,*.test.fr", NULL},
+     "*.test.com,*.test.co.uk,*.test.de,*.test.fr", nullptr},
     /*
        {1, "wwW.tESt.fr", "common.name", ",*.*,*.test.de,*.test.FR,www"},
      */
-    {0, "f.uk", ".uk", NULL, NULL},
-    {0, "w.bar.foo.com", "?.bar.foo.com", NULL, NULL},
-    {0, "www.foo.com", "(www|ftp).foo.com", NULL, NULL},
-    {0, "www.foo.com", "www.foo.com#", NULL, NULL}, /* # = null char. */
-    {0, "www.foo.com", "", "www.foo.com#*.foo.com,#,#", NULL},
-    {0, "www.house.example", "ww.house.example", NULL, NULL},
-    {0, "test.org", "", "www.test.org,*.test.org,*.org", NULL},
-    {0, "w.bar.foo.com", "w*.bar.foo.com", NULL, NULL},
-    {0, "www.bar.foo.com", "ww*ww.bar.foo.com", NULL, NULL},
-    {0, "wwww.bar.foo.com", "ww*ww.bar.foo.com", NULL, NULL},
-    {0, "wwww.bar.foo.com", "w*w.bar.foo.com", NULL, NULL},
-    {0, "wwww.bar.foo.com", "w*w.bar.foo.c0m", NULL, NULL},
-    {0, "WALLY.bar.foo.com", "wa*.bar.foo.com", NULL, NULL},
-    {0, "wally.bar.foo.com", "*Ly.bar.foo.com", NULL, NULL},
+    {0, "f.uk", ".uk", nullptr, nullptr},
+    {0, "w.bar.foo.com", "?.bar.foo.com", nullptr, nullptr},
+    {0, "www.foo.com", "(www|ftp).foo.com", nullptr, nullptr},
+    {0, "www.foo.com", "www.foo.com#", nullptr, nullptr}, /* # = null char. */
+    {0, "www.foo.com", "", "www.foo.com#*.foo.com,#,#", nullptr},
+    {0, "www.house.example", "ww.house.example", nullptr, nullptr},
+    {0, "test.org", "", "www.test.org,*.test.org,*.org", nullptr},
+    {0, "w.bar.foo.com", "w*.bar.foo.com", nullptr, nullptr},
+    {0, "www.bar.foo.com", "ww*ww.bar.foo.com", nullptr, nullptr},
+    {0, "wwww.bar.foo.com", "ww*ww.bar.foo.com", nullptr, nullptr},
+    {0, "wwww.bar.foo.com", "w*w.bar.foo.com", nullptr, nullptr},
+    {0, "wwww.bar.foo.com", "w*w.bar.foo.c0m", nullptr, nullptr},
+    {0, "WALLY.bar.foo.com", "wa*.bar.foo.com", nullptr, nullptr},
+    {0, "wally.bar.foo.com", "*Ly.bar.foo.com", nullptr, nullptr},
     /*
        {1, "ww%57.foo.com", "", "www.foo.com"},
        {1, "www&.foo.com", "www%26.foo.com", NULL},
@@ -84,134 +84,138 @@ const cert_name_test_entry cert_name_test_entries[] = {
 
     /* Common name must not be used if subject alternative name was provided. */
     {0, "www.test.co.jp", "www.test.co.jp",
-     "*.test.de,*.jp,www.test.co.uk,www.*.co.jp", NULL},
+     "*.test.de,*.jp,www.test.co.uk,www.*.co.jp", nullptr},
     {0, "www.bar.foo.com", "www.bar.foo.com",
-     "*.foo.com,*.*.foo.com,*.*.bar.foo.com,*..bar.foo.com,", NULL},
+     "*.foo.com,*.*.foo.com,*.*.bar.foo.com,*..bar.foo.com,", nullptr},
 
     /* IDN tests */
-    {1, "xn--poema-9qae5a.com.br", "xn--poema-9qae5a.com.br", NULL, NULL},
-    {1, "www.xn--poema-9qae5a.com.br", "*.xn--poema-9qae5a.com.br", NULL, NULL},
+    {1, "xn--poema-9qae5a.com.br", "xn--poema-9qae5a.com.br", nullptr, nullptr},
+    {1, "www.xn--poema-9qae5a.com.br", "*.xn--poema-9qae5a.com.br", nullptr,
+     nullptr},
     {0, "xn--poema-9qae5a.com.br", "",
      "*.xn--poema-9qae5a.com.br,"
      "xn--poema-*.com.br,"
      "xn--*-9qae5a.com.br,"
      "*--poema-9qae5a.com.br",
-     NULL},
+     nullptr},
 
     /* The following are adapted from the  examples quoted from
        http://tools.ietf.org/html/rfc6125#section-6.4.3
        (e.g., *.example.com would match foo.example.com but
        not bar.foo.example.com or example.com). */
-    {1, "foo.example.com", "*.example.com", NULL, NULL},
-    {0, "bar.foo.example.com", "*.example.com", NULL, NULL},
-    {0, "example.com", "*.example.com", NULL, NULL},
+    {1, "foo.example.com", "*.example.com", nullptr, nullptr},
+    {0, "bar.foo.example.com", "*.example.com", nullptr, nullptr},
+    {0, "example.com", "*.example.com", nullptr, nullptr},
 
     /* Partial wildcards are disallowed, though RFC 2818 rules allow them.
        That is, forms such as baz*.example.net, *baz.example.net, and
        b*z.example.net should NOT match domains. Instead, the wildcard must
        always be the left-most label, and only a single label. */
-    {0, "baz1.example.net", "baz*.example.net", NULL, NULL},
-    {0, "foobaz.example.net", "*baz.example.net", NULL, NULL},
-    {0, "buzz.example.net", "b*z.example.net", NULL, NULL},
-    {0, "www.test.example.net", "www.*.example.net", NULL, NULL},
+    {0, "baz1.example.net", "baz*.example.net", nullptr, nullptr},
+    {0, "foobaz.example.net", "*baz.example.net", nullptr, nullptr},
+    {0, "buzz.example.net", "b*z.example.net", nullptr, nullptr},
+    {0, "www.test.example.net", "www.*.example.net", nullptr, nullptr},
 
     /* Wildcards should not be valid for public registry controlled domains,
        and unknown/unrecognized domains, at least three domain components must
        be present. */
-    {1, "www.test.example", "*.test.example", NULL, NULL},
-    {1, "test.example.co.uk", "*.example.co.uk", NULL, NULL},
-    {0, "test.example", "*.example", NULL, NULL},
+    {1, "www.test.example", "*.test.example", nullptr, nullptr},
+    {1, "test.example.co.uk", "*.example.co.uk", nullptr, nullptr},
+    {0, "test.example", "*.example", nullptr, nullptr},
     /*
        {0, "example.co.uk", "*.co.uk", NULL},
      */
-    {0, "foo.com", "*.com", NULL, NULL},
-    {0, "foo.us", "*.us", NULL, NULL},
-    {0, "foo", "*", NULL, NULL},
+    {0, "foo.com", "*.com", nullptr, nullptr},
+    {0, "foo.us", "*.us", nullptr, nullptr},
+    {0, "foo", "*", nullptr, nullptr},
 
     /* IDN variants of wildcards and registry controlled domains. */
-    {1, "www.xn--poema-9qae5a.com.br", "*.xn--poema-9qae5a.com.br", NULL, NULL},
-    {1, "test.example.xn--mgbaam7a8h", "*.example.xn--mgbaam7a8h", NULL, NULL},
+    {1, "www.xn--poema-9qae5a.com.br", "*.xn--poema-9qae5a.com.br", nullptr,
+     nullptr},
+    {1, "test.example.xn--mgbaam7a8h", "*.example.xn--mgbaam7a8h", nullptr,
+     nullptr},
     /*
        {0, "xn--poema-9qae5a.com.br", "*.com.br", NULL},
      */
-    {0, "example.xn--mgbaam7a8h", "*.xn--mgbaam7a8h", NULL, NULL},
+    {0, "example.xn--mgbaam7a8h", "*.xn--mgbaam7a8h", nullptr, nullptr},
 
     /* Wildcards should be permissible for 'private' registry controlled
        domains. */
-    {1, "www.appspot.com", "*.appspot.com", NULL, NULL},
-    {1, "foo.s3.amazonaws.com", "*.s3.amazonaws.com", NULL, NULL},
+    {1, "www.appspot.com", "*.appspot.com", nullptr, nullptr},
+    {1, "foo.s3.amazonaws.com", "*.s3.amazonaws.com", nullptr, nullptr},
 
     /* Multiple wildcards are not valid. */
-    {0, "foo.example.com", "*.*.com", NULL, NULL},
-    {0, "foo.bar.example.com", "*.bar.*.com", NULL, NULL},
+    {0, "foo.example.com", "*.*.com", nullptr, nullptr},
+    {0, "foo.bar.example.com", "*.bar.*.com", nullptr, nullptr},
 
     /* Absolute vs relative DNS name tests. Although not explicitly specified
        in RFC 6125, absolute reference names (those ending in a .) should
        match either absolute or relative presented names. */
-    {1, "foo.com", "foo.com.", NULL, NULL},
-    {1, "foo.com.", "foo.com", NULL, NULL},
-    {1, "foo.com.", "foo.com.", NULL, NULL},
-    {1, "f", "f.", NULL, NULL},
-    {1, "f.", "f", NULL, NULL},
-    {1, "f.", "f.", NULL, NULL},
-    {1, "www-3.bar.foo.com", "*.bar.foo.com.", NULL, NULL},
-    {1, "www-3.bar.foo.com.", "*.bar.foo.com", NULL, NULL},
-    {1, "www-3.bar.foo.com.", "*.bar.foo.com.", NULL, NULL},
-    {0, ".", ".", NULL, NULL},
-    {0, "example.com", "*.com.", NULL, NULL},
-    {0, "example.com.", "*.com", NULL, NULL},
-    {0, "example.com.", "*.com.", NULL, NULL},
-    {0, "foo.", "*.", NULL, NULL},
-    {0, "foo", "*.", NULL, NULL},
+    {1, "foo.com", "foo.com.", nullptr, nullptr},
+    {1, "foo.com.", "foo.com", nullptr, nullptr},
+    {1, "foo.com.", "foo.com.", nullptr, nullptr},
+    {1, "f", "f.", nullptr, nullptr},
+    {1, "f.", "f", nullptr, nullptr},
+    {1, "f.", "f.", nullptr, nullptr},
+    {1, "www-3.bar.foo.com", "*.bar.foo.com.", nullptr, nullptr},
+    {1, "www-3.bar.foo.com.", "*.bar.foo.com", nullptr, nullptr},
+    {1, "www-3.bar.foo.com.", "*.bar.foo.com.", nullptr, nullptr},
+    {0, ".", ".", nullptr, nullptr},
+    {0, "example.com", "*.com.", nullptr, nullptr},
+    {0, "example.com.", "*.com", nullptr, nullptr},
+    {0, "example.com.", "*.com.", nullptr, nullptr},
+    {0, "foo.", "*.", nullptr, nullptr},
+    {0, "foo", "*.", nullptr, nullptr},
     /*
        {0, "foo.co.uk", "*.co.uk.", NULL},
        {0, "foo.co.uk.", "*.co.uk.", NULL},
      */
 
     /* An empty CN is OK. */
-    {1, "test.foo.com", "", "test.foo.com", NULL},
+    {1, "test.foo.com", "", "test.foo.com", nullptr},
 
     /* An IP should not be used for the CN. */
-    {0, "173.194.195.139", "173.194.195.139", NULL, NULL},
+    {0, "173.194.195.139", "173.194.195.139", nullptr, nullptr},
     /* An IP can be used if the SAN IP is present */
-    {1, "173.194.195.139", "foo.example.com", NULL, "173.194.195.139"},
-    {0, "173.194.195.139", "foo.example.com", NULL, "8.8.8.8"},
-    {0, "173.194.195.139", "foo.example.com", NULL, "8.8.8.8,8.8.4.4"},
-    {1, "173.194.195.139", "foo.example.com", NULL, "8.8.8.8,173.194.195.139"},
-    {0, "173.194.195.139", "foo.example.com", NULL, "173.194.195.13"},
-    {0, "2001:db8:a0b:12f0::1", "foo.example.com", NULL, "173.194.195.13"},
-    {1, "2001:db8:a0b:12f0::1", "foo.example.com", NULL,
+    {1, "173.194.195.139", "foo.example.com", nullptr, "173.194.195.139"},
+    {0, "173.194.195.139", "foo.example.com", nullptr, "8.8.8.8"},
+    {0, "173.194.195.139", "foo.example.com", nullptr, "8.8.8.8,8.8.4.4"},
+    {1, "173.194.195.139", "foo.example.com", nullptr,
+     "8.8.8.8,173.194.195.139"},
+    {0, "173.194.195.139", "foo.example.com", nullptr, "173.194.195.13"},
+    {0, "2001:db8:a0b:12f0::1", "foo.example.com", nullptr, "173.194.195.13"},
+    {1, "2001:db8:a0b:12f0::1", "foo.example.com", nullptr,
      "2001:db8:a0b:12f0::1"},
-    {0, "2001:db8:a0b:12f0::1", "foo.example.com", NULL,
+    {0, "2001:db8:a0b:12f0::1", "foo.example.com", nullptr,
      "2001:db8:a0b:12f0::2"},
-    {1, "2001:db8:a0b:12f0::1", "foo.example.com", NULL,
+    {1, "2001:db8:a0b:12f0::1", "foo.example.com", nullptr,
      "2001:db8:a0b:12f0::2,2001:db8:a0b:12f0::1,8.8.8.8"},
 };
 
 typedef struct name_list {
-  const char *name;
-  struct name_list *next;
+  const char* name;
+  struct name_list* next;
 } name_list;
 
 typedef struct {
   size_t name_count;
-  char *buffer;
-  name_list *names;
+  char* buffer;
+  name_list* names;
 } parsed_names;
 
-name_list *name_list_add(const char *n) {
-  name_list *result = gpr_malloc(sizeof(name_list));
+name_list* name_list_add(const char* n) {
+  name_list* result = static_cast<name_list*>(gpr_malloc(sizeof(name_list)));
   result->name = n;
-  result->next = NULL;
+  result->next = nullptr;
   return result;
 }
 
-static parsed_names parse_names(const char *names_str) {
+static parsed_names parse_names(const char* names_str) {
   parsed_names result;
-  name_list *current_nl;
+  name_list* current_nl;
   size_t i;
   memset(&result, 0, sizeof(parsed_names));
-  if (names_str == 0) return result;
+  if (names_str == nullptr) return result;
   result.name_count = 1;
   result.buffer = gpr_strdup(names_str);
   result.names = name_list_add(result.buffer);
@@ -228,18 +232,18 @@ static parsed_names parse_names(const char *names_str) {
   return result;
 }
 
-static void destruct_parsed_names(parsed_names *pdn) {
-  name_list *nl = pdn->names;
-  if (pdn->buffer != NULL) gpr_free(pdn->buffer);
-  while (nl != NULL) {
-    name_list *to_be_free = nl;
+static void destruct_parsed_names(parsed_names* pdn) {
+  name_list* nl = pdn->names;
+  if (pdn->buffer != nullptr) gpr_free(pdn->buffer);
+  while (nl != nullptr) {
+    name_list* to_be_free = nl;
     nl = nl->next;
     gpr_free(to_be_free);
   }
 }
 
-static char *processed_name(const char *name) {
-  char *result = gpr_strdup(name);
+static char* processed_name(const char* name) {
+  char* result = gpr_strdup(name);
   size_t i;
   for (i = 0; i < strlen(result); i++) {
     if (result[i] == '#') {
@@ -250,10 +254,10 @@ static char *processed_name(const char *name) {
 }
 
 static tsi_peer peer_from_cert_name_test_entry(
-    const cert_name_test_entry *entry) {
+    const cert_name_test_entry* entry) {
   size_t i;
   tsi_peer peer;
-  name_list *nl;
+  name_list* nl;
   parsed_names dns_entries = parse_names(entry->dns_names);
   parsed_names ip_entries = parse_names(entry->ip_names);
   nl = dns_entries.names;
@@ -264,8 +268,8 @@ static tsi_peer peer_from_cert_name_test_entry(
                  TSI_X509_SUBJECT_COMMON_NAME_PEER_PROPERTY, entry->common_name,
                  &peer.properties[0]) == TSI_OK);
   i = 1;
-  while (nl != NULL) {
-    char *processed = processed_name(nl->name);
+  while (nl != nullptr) {
+    char* processed = processed_name(nl->name);
     GPR_ASSERT(tsi_construct_string_peer_property(
                    TSI_X509_SUBJECT_ALTERNATIVE_NAME_PEER_PROPERTY, processed,
                    strlen(nl->name), &peer.properties[i++]) == TSI_OK);
@@ -274,8 +278,8 @@ static tsi_peer peer_from_cert_name_test_entry(
   }
 
   nl = ip_entries.names;
-  while (nl != NULL) {
-    char *processed = processed_name(nl->name);
+  while (nl != nullptr) {
+    char* processed = processed_name(nl->name);
     GPR_ASSERT(tsi_construct_string_peer_property(
                    TSI_X509_SUBJECT_ALTERNATIVE_NAME_PEER_PROPERTY, processed,
                    strlen(nl->name), &peer.properties[i++]) == TSI_OK);
@@ -287,26 +291,26 @@ static tsi_peer peer_from_cert_name_test_entry(
   return peer;
 }
 
-char *cert_name_test_entry_to_string(const cert_name_test_entry *entry) {
-  char *s;
+char* cert_name_test_entry_to_string(const cert_name_test_entry* entry) {
+  char* s;
   gpr_asprintf(&s,
                "{ success = %s, host_name = %s, common_name = %s, dns_names = "
                "%s, ip_names = %s}",
                entry->expected ? "true" : "false", entry->host_name,
                entry->common_name,
-               entry->dns_names != NULL ? entry->dns_names : "",
-               entry->ip_names != NULL ? entry->ip_names : "");
+               entry->dns_names != nullptr ? entry->dns_names : "",
+               entry->ip_names != nullptr ? entry->ip_names : "");
   return s;
 }
 
 static void test_peer_matches_name(void) {
   size_t i = 0;
   for (i = 0; i < GPR_ARRAY_SIZE(cert_name_test_entries); i++) {
-    const cert_name_test_entry *entry = &cert_name_test_entries[i];
+    const cert_name_test_entry* entry = &cert_name_test_entries[i];
     tsi_peer peer = peer_from_cert_name_test_entry(entry);
     int result = tsi_ssl_peer_matches_name(&peer, entry->host_name);
     if (result != entry->expected) {
-      char *entry_str = cert_name_test_entry_to_string(entry);
+      char* entry_str = cert_name_test_entry_to_string(entry);
       gpr_log(GPR_ERROR, "%s", entry_str);
       gpr_free(entry_str);
       GPR_ASSERT(0); /* Unexpected result. */
@@ -317,7 +321,7 @@ static void test_peer_matches_name(void) {
 
 typedef struct {
   tsi_result res;
-  const char *str;
+  const char* str;
 } tsi_result_string_pair;
 
 static void test_result_strings(void) {
@@ -344,38 +348,39 @@ static void test_result_strings(void) {
 }
 
 static void test_protector_invalid_args(void) {
-  GPR_ASSERT(tsi_frame_protector_protect(NULL, NULL, NULL, NULL, NULL) ==
-             TSI_INVALID_ARGUMENT);
-  GPR_ASSERT(tsi_frame_protector_protect_flush(NULL, NULL, NULL, NULL) ==
-             TSI_INVALID_ARGUMENT);
-  GPR_ASSERT(tsi_frame_protector_unprotect(NULL, NULL, NULL, NULL, NULL) ==
-             TSI_INVALID_ARGUMENT);
+  GPR_ASSERT(tsi_frame_protector_protect(nullptr, nullptr, nullptr, nullptr,
+                                         nullptr) == TSI_INVALID_ARGUMENT);
+  GPR_ASSERT(tsi_frame_protector_protect_flush(
+                 nullptr, nullptr, nullptr, nullptr) == TSI_INVALID_ARGUMENT);
+  GPR_ASSERT(tsi_frame_protector_unprotect(nullptr, nullptr, nullptr, nullptr,
+                                           nullptr) == TSI_INVALID_ARGUMENT);
 }
 
 static void test_handshaker_invalid_args(void) {
-  GPR_ASSERT(tsi_handshaker_get_result(NULL) == TSI_INVALID_ARGUMENT);
-  GPR_ASSERT(tsi_handshaker_extract_peer(NULL, NULL) == TSI_INVALID_ARGUMENT);
-  GPR_ASSERT(tsi_handshaker_create_frame_protector(NULL, NULL, NULL) ==
-             TSI_INVALID_ARGUMENT);
-  GPR_ASSERT(tsi_handshaker_process_bytes_from_peer(NULL, NULL, NULL) ==
-             TSI_INVALID_ARGUMENT);
-  GPR_ASSERT(tsi_handshaker_get_bytes_to_send_to_peer(NULL, NULL, NULL) ==
+  GPR_ASSERT(tsi_handshaker_get_result(nullptr) == TSI_INVALID_ARGUMENT);
+  GPR_ASSERT(tsi_handshaker_extract_peer(nullptr, nullptr) ==
              TSI_INVALID_ARGUMENT);
-  GPR_ASSERT(tsi_handshaker_next(NULL, NULL, 0, NULL, NULL, NULL, NULL, NULL) ==
+  GPR_ASSERT(tsi_handshaker_create_frame_protector(nullptr, nullptr, nullptr) ==
              TSI_INVALID_ARGUMENT);
+  GPR_ASSERT(tsi_handshaker_process_bytes_from_peer(
+                 nullptr, nullptr, nullptr) == TSI_INVALID_ARGUMENT);
+  GPR_ASSERT(tsi_handshaker_get_bytes_to_send_to_peer(
+                 nullptr, nullptr, nullptr) == TSI_INVALID_ARGUMENT);
+  GPR_ASSERT(tsi_handshaker_next(nullptr, nullptr, 0, nullptr, nullptr, nullptr,
+                                 nullptr, nullptr) == TSI_INVALID_ARGUMENT);
 }
 
 static void test_handshaker_invalid_state(void) {
-  tsi_handshaker *h = tsi_create_fake_handshaker(0);
+  tsi_handshaker* h = tsi_create_fake_handshaker(0);
   tsi_peer peer;
-  tsi_frame_protector *p;
+  tsi_frame_protector* p;
   GPR_ASSERT(tsi_handshaker_extract_peer(h, &peer) == TSI_FAILED_PRECONDITION);
-  GPR_ASSERT(tsi_handshaker_create_frame_protector(h, NULL, &p) ==
+  GPR_ASSERT(tsi_handshaker_create_frame_protector(h, nullptr, &p) ==
              TSI_FAILED_PRECONDITION);
   tsi_handshaker_destroy(h);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_peer_matches_name();
   test_result_strings();
diff --git a/test/core/tsi/transport_security_test_lib.c b/test/core/tsi/transport_security_test_lib.cc
index 329b2371bf..3537366de9 100644
--- a/test/core/tsi/transport_security_test_lib.c
+++ b/test/core/tsi/transport_security_test_lib.cc
@@ -27,14 +27,14 @@
 #include "src/core/lib/security/transport/tsi_error.h"
 #include "test/core/tsi/transport_security_test_lib.h"
 
-static void notification_signal(tsi_test_fixture *fixture) {
+static void notification_signal(tsi_test_fixture* fixture) {
   gpr_mu_lock(&fixture->mu);
   fixture->notified = true;
   gpr_cv_signal(&fixture->cv);
   gpr_mu_unlock(&fixture->mu);
 }
 
-static void notification_wait(tsi_test_fixture *fixture) {
+static void notification_wait(tsi_test_fixture* fixture) {
   gpr_mu_lock(&fixture->mu);
   while (!fixture->notified) {
     gpr_cv_wait(&fixture->cv, &fixture->mu, gpr_inf_future(GPR_CLOCK_REALTIME));
@@ -44,51 +44,53 @@ static void notification_wait(tsi_test_fixture *fixture) {
 }
 
 typedef struct handshaker_args {
-  tsi_test_fixture *fixture;
-  unsigned char *handshake_buffer;
+  tsi_test_fixture* fixture;
+  unsigned char* handshake_buffer;
   size_t handshake_buffer_size;
   bool is_client;
   bool transferred_data;
   bool appended_unused_bytes;
-  grpc_error *error;
+  grpc_error* error;
 } handshaker_args;
 
-static handshaker_args *handshaker_args_create(tsi_test_fixture *fixture,
+static handshaker_args* handshaker_args_create(tsi_test_fixture* fixture,
                                                bool is_client) {
-  GPR_ASSERT(fixture != NULL);
-  GPR_ASSERT(fixture->config != NULL);
-  handshaker_args *args = gpr_zalloc(sizeof(*args));
+  GPR_ASSERT(fixture != nullptr);
+  GPR_ASSERT(fixture->config != nullptr);
+  handshaker_args* args =
+      static_cast<handshaker_args*>(gpr_zalloc(sizeof(*args)));
   args->fixture = fixture;
   args->handshake_buffer_size = fixture->handshake_buffer_size;
-  args->handshake_buffer = gpr_zalloc(args->handshake_buffer_size);
+  args->handshake_buffer =
+      static_cast<unsigned char*>(gpr_zalloc(args->handshake_buffer_size));
   args->is_client = is_client;
   args->error = GRPC_ERROR_NONE;
   return args;
 }
 
-static void handshaker_args_destroy(handshaker_args *args) {
+static void handshaker_args_destroy(handshaker_args* args) {
   gpr_free(args->handshake_buffer);
   GRPC_ERROR_UNREF(args->error);
   gpr_free(args);
 }
 
-static void do_handshaker_next(handshaker_args *args);
+static void do_handshaker_next(handshaker_args* args);
 
-static void setup_handshakers(tsi_test_fixture *fixture) {
-  GPR_ASSERT(fixture != NULL);
-  GPR_ASSERT(fixture->vtable != NULL);
-  GPR_ASSERT(fixture->vtable->setup_handshakers != NULL);
+static void setup_handshakers(tsi_test_fixture* fixture) {
+  GPR_ASSERT(fixture != nullptr);
+  GPR_ASSERT(fixture->vtable != nullptr);
+  GPR_ASSERT(fixture->vtable->setup_handshakers != nullptr);
   fixture->vtable->setup_handshakers(fixture);
 }
 
-static void check_unused_bytes(tsi_test_fixture *fixture) {
-  tsi_handshaker_result *result_with_unused_bytes =
+static void check_unused_bytes(tsi_test_fixture* fixture) {
+  tsi_handshaker_result* result_with_unused_bytes =
       fixture->has_client_finished_first ? fixture->server_result
                                          : fixture->client_result;
-  tsi_handshaker_result *result_without_unused_bytes =
+  tsi_handshaker_result* result_without_unused_bytes =
       fixture->has_client_finished_first ? fixture->client_result
                                          : fixture->server_result;
-  const unsigned char *bytes = NULL;
+  const unsigned char* bytes = nullptr;
   size_t bytes_size = 0;
   GPR_ASSERT(tsi_handshaker_result_get_unused_bytes(
                  result_with_unused_bytes, &bytes, &bytes_size) == TSI_OK);
@@ -97,18 +99,19 @@ static void check_unused_bytes(tsi_test_fixture *fixture) {
   GPR_ASSERT(tsi_handshaker_result_get_unused_bytes(
                  result_without_unused_bytes, &bytes, &bytes_size) == TSI_OK);
   GPR_ASSERT(bytes_size == 0);
-  GPR_ASSERT(bytes == NULL);
+  GPR_ASSERT(bytes == nullptr);
 }
 
-static void check_handshake_results(tsi_test_fixture *fixture) {
-  GPR_ASSERT(fixture != NULL);
-  GPR_ASSERT(fixture->vtable != NULL);
-  GPR_ASSERT(fixture->vtable->check_handshaker_peers != NULL);
+static void check_handshake_results(tsi_test_fixture* fixture) {
+  GPR_ASSERT(fixture != nullptr);
+  GPR_ASSERT(fixture->vtable != nullptr);
+  GPR_ASSERT(fixture->vtable->check_handshaker_peers != nullptr);
   /* Check handshaker peers. */
   fixture->vtable->check_handshaker_peers(fixture);
   /* Check unused bytes. */
   if (fixture->test_unused_bytes) {
-    if (fixture->server_result != NULL && fixture->client_result != NULL) {
+    if (fixture->server_result != nullptr &&
+        fixture->client_result != nullptr) {
       check_unused_bytes(fixture);
     }
     fixture->bytes_written_to_server_channel = 0;
@@ -118,52 +121,53 @@ static void check_handshake_results(tsi_test_fixture *fixture) {
   }
 }
 
-static void send_bytes_to_peer(tsi_test_fixture *fixture,
-                               const unsigned char *buf, size_t buf_size,
+static void send_bytes_to_peer(tsi_test_fixture* fixture,
+                               const unsigned char* buf, size_t buf_size,
                                bool is_client) {
-  GPR_ASSERT(fixture != NULL);
-  GPR_ASSERT(buf != NULL);
-  uint8_t *channel =
+  GPR_ASSERT(fixture != nullptr);
+  GPR_ASSERT(buf != nullptr);
+  uint8_t* channel =
       is_client ? fixture->server_channel : fixture->client_channel;
-  GPR_ASSERT(channel != NULL);
-  size_t *bytes_written = is_client ? &fixture->bytes_written_to_server_channel
+  GPR_ASSERT(channel != nullptr);
+  size_t* bytes_written = is_client ? &fixture->bytes_written_to_server_channel
                                     : &fixture->bytes_written_to_client_channel;
-  GPR_ASSERT(bytes_written != NULL);
+  GPR_ASSERT(bytes_written != nullptr);
   GPR_ASSERT(*bytes_written + buf_size <= TSI_TEST_DEFAULT_CHANNEL_SIZE);
   /* Write data to channel. */
   memcpy(channel + *bytes_written, buf, buf_size);
   *bytes_written += buf_size;
 }
 
-static void maybe_append_unused_bytes(handshaker_args *args) {
-  GPR_ASSERT(args != NULL);
-  GPR_ASSERT(args->fixture != NULL);
-  tsi_test_fixture *fixture = args->fixture;
+static void maybe_append_unused_bytes(handshaker_args* args) {
+  GPR_ASSERT(args != nullptr);
+  GPR_ASSERT(args->fixture != nullptr);
+  tsi_test_fixture* fixture = args->fixture;
   if (fixture->test_unused_bytes && !args->appended_unused_bytes) {
     args->appended_unused_bytes = true;
-    send_bytes_to_peer(fixture, (const unsigned char *)TSI_TEST_UNUSED_BYTES,
+    send_bytes_to_peer(fixture, (const unsigned char*)TSI_TEST_UNUSED_BYTES,
                        strlen(TSI_TEST_UNUSED_BYTES), args->is_client);
-    if (fixture->client_result != NULL && fixture->server_result == NULL) {
+    if (fixture->client_result != nullptr &&
+        fixture->server_result == nullptr) {
       fixture->has_client_finished_first = true;
     }
   }
 }
 
-static void receive_bytes_from_peer(tsi_test_fixture *fixture,
-                                    unsigned char **buf, size_t *buf_size,
+static void receive_bytes_from_peer(tsi_test_fixture* fixture,
+                                    unsigned char** buf, size_t* buf_size,
                                     bool is_client) {
-  GPR_ASSERT(fixture != NULL);
-  GPR_ASSERT(*buf != NULL);
-  GPR_ASSERT(buf_size != NULL);
-  uint8_t *channel =
+  GPR_ASSERT(fixture != nullptr);
+  GPR_ASSERT(*buf != nullptr);
+  GPR_ASSERT(buf_size != nullptr);
+  uint8_t* channel =
       is_client ? fixture->client_channel : fixture->server_channel;
-  GPR_ASSERT(channel != NULL);
-  size_t *bytes_read = is_client ? &fixture->bytes_read_from_client_channel
+  GPR_ASSERT(channel != nullptr);
+  size_t* bytes_read = is_client ? &fixture->bytes_read_from_client_channel
                                  : &fixture->bytes_read_from_server_channel;
-  size_t *bytes_written = is_client ? &fixture->bytes_written_to_client_channel
+  size_t* bytes_written = is_client ? &fixture->bytes_written_to_client_channel
                                     : &fixture->bytes_written_to_server_channel;
-  GPR_ASSERT(bytes_read != NULL);
-  GPR_ASSERT(bytes_written != NULL);
+  GPR_ASSERT(bytes_read != nullptr);
+  GPR_ASSERT(bytes_written != nullptr);
   size_t to_read = *buf_size < *bytes_written - *bytes_read
                        ? *buf_size
                        : *bytes_written - *bytes_read;
@@ -173,21 +177,22 @@ static void receive_bytes_from_peer(tsi_test_fixture *fixture,
   *bytes_read += to_read;
 }
 
-static void send_message_to_peer(tsi_test_fixture *fixture,
-                                 tsi_frame_protector *protector,
+static void send_message_to_peer(tsi_test_fixture* fixture,
+                                 tsi_frame_protector* protector,
                                  bool is_client) {
   /* Initialization. */
-  GPR_ASSERT(fixture != NULL);
-  GPR_ASSERT(fixture->config != NULL);
-  GPR_ASSERT(protector != NULL);
-  tsi_test_frame_protector_config *config = fixture->config;
-  unsigned char *protected_buffer = gpr_zalloc(config->protected_buffer_size);
+  GPR_ASSERT(fixture != nullptr);
+  GPR_ASSERT(fixture->config != nullptr);
+  GPR_ASSERT(protector != nullptr);
+  tsi_test_frame_protector_config* config = fixture->config;
+  unsigned char* protected_buffer =
+      static_cast<unsigned char*>(gpr_zalloc(config->protected_buffer_size));
   size_t message_size =
       is_client ? config->client_message_size : config->server_message_size;
-  uint8_t *message =
+  uint8_t* message =
       is_client ? config->client_message : config->server_message;
-  GPR_ASSERT(message != NULL);
-  const unsigned char *message_bytes = (const unsigned char *)message;
+  GPR_ASSERT(message != nullptr);
+  const unsigned char* message_bytes = (const unsigned char*)message;
   tsi_result result = TSI_OK;
   /* Do protect and send protected data to peer. */
   while (message_size > 0 && result == TSI_OK) {
@@ -222,25 +227,26 @@ static void send_message_to_peer(tsi_test_fixture *fixture,
   gpr_free(protected_buffer);
 }
 
-static void receive_message_from_peer(tsi_test_fixture *fixture,
-                                      tsi_frame_protector *protector,
-                                      unsigned char *message,
-                                      size_t *bytes_received, bool is_client) {
+static void receive_message_from_peer(tsi_test_fixture* fixture,
+                                      tsi_frame_protector* protector,
+                                      unsigned char* message,
+                                      size_t* bytes_received, bool is_client) {
   /* Initialization. */
-  GPR_ASSERT(fixture != NULL);
-  GPR_ASSERT(protector != NULL);
-  GPR_ASSERT(message != NULL);
-  GPR_ASSERT(bytes_received != NULL);
-  GPR_ASSERT(fixture->config != NULL);
-  tsi_test_frame_protector_config *config = fixture->config;
+  GPR_ASSERT(fixture != nullptr);
+  GPR_ASSERT(protector != nullptr);
+  GPR_ASSERT(message != nullptr);
+  GPR_ASSERT(bytes_received != nullptr);
+  GPR_ASSERT(fixture->config != nullptr);
+  tsi_test_frame_protector_config* config = fixture->config;
   size_t read_offset = 0;
   size_t message_offset = 0;
   size_t read_from_peer_size = 0;
   tsi_result result = TSI_OK;
   bool done = false;
-  unsigned char *read_buffer = gpr_zalloc(config->read_buffer_allocated_size);
-  unsigned char *message_buffer =
-      gpr_zalloc(config->message_buffer_allocated_size);
+  unsigned char* read_buffer = static_cast<unsigned char*>(
+      gpr_zalloc(config->read_buffer_allocated_size));
+  unsigned char* message_buffer = static_cast<unsigned char*>(
+      gpr_zalloc(config->message_buffer_allocated_size));
   /* Do unprotect on data received from peer. */
   while (!done && result == TSI_OK) {
     /* Receive data from peer. */
@@ -278,15 +284,15 @@ static void receive_message_from_peer(tsi_test_fixture *fixture,
   gpr_free(message_buffer);
 }
 
-grpc_error *on_handshake_next_done(tsi_result result, void *user_data,
-                                   const unsigned char *bytes_to_send,
+grpc_error* on_handshake_next_done(tsi_result result, void* user_data,
+                                   const unsigned char* bytes_to_send,
                                    size_t bytes_to_send_size,
-                                   tsi_handshaker_result *handshaker_result) {
-  handshaker_args *args = (handshaker_args *)user_data;
-  GPR_ASSERT(args != NULL);
-  GPR_ASSERT(args->fixture != NULL);
-  tsi_test_fixture *fixture = args->fixture;
-  grpc_error *error = GRPC_ERROR_NONE;
+                                   tsi_handshaker_result* handshaker_result) {
+  handshaker_args* args = (handshaker_args*)user_data;
+  GPR_ASSERT(args != nullptr);
+  GPR_ASSERT(args->fixture != nullptr);
+  tsi_test_fixture* fixture = args->fixture;
+  grpc_error* error = GRPC_ERROR_NONE;
   /* Read more data if we need to. */
   if (result == TSI_INCOMPLETE_DATA) {
     GPR_ASSERT(bytes_to_send_size == 0);
@@ -299,10 +305,10 @@ grpc_error *on_handshake_next_done(tsi_result result, void *user_data,
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Handshake failed"), result);
   }
   /* Update handshaker result. */
-  if (handshaker_result != NULL) {
-    tsi_handshaker_result **result_to_write =
+  if (handshaker_result != nullptr) {
+    tsi_handshaker_result** result_to_write =
         args->is_client ? &fixture->client_result : &fixture->server_result;
-    GPR_ASSERT(*result_to_write == NULL);
+    GPR_ASSERT(*result_to_write == nullptr);
     *result_to_write = handshaker_result;
   }
   /* Send data to peer, if needed. */
@@ -311,7 +317,7 @@ grpc_error *on_handshake_next_done(tsi_result result, void *user_data,
                        args->is_client);
     args->transferred_data = true;
   }
-  if (handshaker_result != NULL) {
+  if (handshaker_result != nullptr) {
     maybe_append_unused_bytes(args);
   }
   notification_signal(fixture);
@@ -319,65 +325,68 @@ grpc_error *on_handshake_next_done(tsi_result result, void *user_data,
 }
 
 static void on_handshake_next_done_wrapper(
-    tsi_result result, void *user_data, const unsigned char *bytes_to_send,
-    size_t bytes_to_send_size, tsi_handshaker_result *handshaker_result) {
-  handshaker_args *args = (handshaker_args *)user_data;
+    tsi_result result, void* user_data, const unsigned char* bytes_to_send,
+    size_t bytes_to_send_size, tsi_handshaker_result* handshaker_result) {
+  handshaker_args* args = (handshaker_args*)user_data;
   args->error = on_handshake_next_done(result, user_data, bytes_to_send,
                                        bytes_to_send_size, handshaker_result);
 }
 
-static bool is_handshake_finished_properly(handshaker_args *args) {
-  GPR_ASSERT(args != NULL);
-  GPR_ASSERT(args->fixture != NULL);
-  tsi_test_fixture *fixture = args->fixture;
-  if ((args->is_client && fixture->client_result != NULL) ||
-      (!args->is_client && fixture->server_result != NULL)) {
+static bool is_handshake_finished_properly(handshaker_args* args) {
+  GPR_ASSERT(args != nullptr);
+  GPR_ASSERT(args->fixture != nullptr);
+  tsi_test_fixture* fixture = args->fixture;
+  if ((args->is_client && fixture->client_result != nullptr) ||
+      (!args->is_client && fixture->server_result != nullptr)) {
     return true;
   }
   return false;
 }
 
-static void do_handshaker_next(handshaker_args *args) {
+static void do_handshaker_next(handshaker_args* args) {
   /* Initialization. */
-  GPR_ASSERT(args != NULL);
-  GPR_ASSERT(args->fixture != NULL);
-  tsi_test_fixture *fixture = args->fixture;
-  tsi_handshaker *handshaker =
+  GPR_ASSERT(args != nullptr);
+  GPR_ASSERT(args->fixture != nullptr);
+  tsi_test_fixture* fixture = args->fixture;
+  tsi_handshaker* handshaker =
       args->is_client ? fixture->client_handshaker : fixture->server_handshaker;
   if (is_handshake_finished_properly(args)) {
     return;
   }
-  tsi_handshaker_result *handshaker_result = NULL;
-  unsigned char *bytes_to_send = NULL;
+  tsi_handshaker_result* handshaker_result = nullptr;
+  unsigned char* bytes_to_send = nullptr;
   size_t bytes_to_send_size = 0;
+  tsi_result result = TSI_OK;
   /* Receive data from peer, if available. */
-  size_t buf_size = args->handshake_buffer_size;
-  receive_bytes_from_peer(args->fixture, &args->handshake_buffer, &buf_size,
-                          args->is_client);
-  if (buf_size > 0) {
-    args->transferred_data = true;
-  }
-  /* Peform handshaker next. */
-  tsi_result result = tsi_handshaker_next(
-      handshaker, args->handshake_buffer, buf_size,
-      (const unsigned char **)&bytes_to_send, &bytes_to_send_size,
-      &handshaker_result, &on_handshake_next_done_wrapper, args);
-  if (result != TSI_ASYNC) {
-    args->error = on_handshake_next_done(result, args, bytes_to_send,
-                                         bytes_to_send_size, handshaker_result);
-    if (args->error != GRPC_ERROR_NONE) {
-      return;
+  do {
+    size_t buf_size = args->handshake_buffer_size;
+    receive_bytes_from_peer(args->fixture, &args->handshake_buffer, &buf_size,
+                            args->is_client);
+    if (buf_size > 0) {
+      args->transferred_data = true;
     }
-  }
+    /* Peform handshaker next. */
+    result = tsi_handshaker_next(handshaker, args->handshake_buffer, buf_size,
+                                 (const unsigned char**)&bytes_to_send,
+                                 &bytes_to_send_size, &handshaker_result,
+                                 &on_handshake_next_done_wrapper, args);
+    if (result != TSI_ASYNC) {
+      args->error = on_handshake_next_done(
+          result, args, bytes_to_send, bytes_to_send_size, handshaker_result);
+      if (args->error != GRPC_ERROR_NONE) {
+        return;
+      }
+    }
+  } while (result == TSI_INCOMPLETE_DATA);
   notification_wait(fixture);
 }
 
-void tsi_test_do_handshake(tsi_test_fixture *fixture) {
+void tsi_test_do_handshake(tsi_test_fixture* fixture) {
   /* Initializaiton. */
   setup_handshakers(fixture);
-  handshaker_args *client_args =
+  handshaker_args* client_args =
       handshaker_args_create(fixture, true /* is_client */);
-  handshaker_args *server_args =
+  handshaker_args* server_args =
       handshaker_args_create(fixture, false /* is_client */);
   /* Do handshake. */
   do {
@@ -392,7 +401,8 @@ void tsi_test_do_handshake(tsi_test_fixture *fixture) {
       break;
     }
     GPR_ASSERT(client_args->transferred_data || server_args->transferred_data);
-  } while (fixture->client_result == NULL || fixture->server_result == NULL);
+  } while (fixture->client_result == nullptr ||
+           fixture->server_result == nullptr);
   /* Verify handshake results. */
   check_handshake_results(fixture);
   /* Cleanup. */
@@ -400,13 +410,13 @@ void tsi_test_do_handshake(tsi_test_fixture *fixture) {
   handshaker_args_destroy(server_args);
 }
 
-void tsi_test_do_round_trip(tsi_test_fixture *fixture) {
+void tsi_test_do_round_trip(tsi_test_fixture* fixture) {
   /* Initialization. */
-  GPR_ASSERT(fixture != NULL);
-  GPR_ASSERT(fixture->config != NULL);
-  tsi_test_frame_protector_config *config = fixture->config;
-  tsi_frame_protector *client_frame_protector = NULL;
-  tsi_frame_protector *server_frame_protector = NULL;
+  GPR_ASSERT(fixture != nullptr);
+  GPR_ASSERT(fixture->config != nullptr);
+  tsi_test_frame_protector_config* config = fixture->config;
+  tsi_frame_protector* client_frame_protector = nullptr;
+  tsi_frame_protector* server_frame_protector = nullptr;
   /* Perform handshake. */
   tsi_test_do_handshake(fixture);
   /* Create frame protectors.*/
@@ -415,7 +425,7 @@ void tsi_test_do_round_trip(tsi_test_fixture *fixture) {
   GPR_ASSERT(tsi_handshaker_result_create_frame_protector(
                  fixture->client_result,
                  client_max_output_protected_frame_size == 0
-                     ? NULL
+                     ? nullptr
                      : &client_max_output_protected_frame_size,
                  &client_frame_protector) == TSI_OK);
   size_t server_max_output_protected_frame_size =
@@ -423,13 +433,13 @@ void tsi_test_do_round_trip(tsi_test_fixture *fixture) {
   GPR_ASSERT(tsi_handshaker_result_create_frame_protector(
                  fixture->server_result,
                  server_max_output_protected_frame_size == 0
-                     ? NULL
+                     ? nullptr
                      : &server_max_output_protected_frame_size,
                  &server_frame_protector) == TSI_OK);
   /* Client sends a message to server. */
   send_message_to_peer(fixture, client_frame_protector, true /* is_client */);
-  unsigned char *server_received_message =
-      gpr_zalloc(TSI_TEST_DEFAULT_CHANNEL_SIZE);
+  unsigned char* server_received_message =
+      static_cast<unsigned char*>(gpr_zalloc(TSI_TEST_DEFAULT_CHANNEL_SIZE));
   size_t server_received_message_size = 0;
   receive_message_from_peer(
       fixture, server_frame_protector, server_received_message,
@@ -439,8 +449,8 @@ void tsi_test_do_round_trip(tsi_test_fixture *fixture) {
                     server_received_message_size) == 0);
   /* Server sends a message to client. */
   send_message_to_peer(fixture, server_frame_protector, false /* is_client */);
-  unsigned char *client_received_message =
-      gpr_zalloc(TSI_TEST_DEFAULT_CHANNEL_SIZE);
+  unsigned char* client_received_message =
+      static_cast<unsigned char*>(gpr_zalloc(TSI_TEST_DEFAULT_CHANNEL_SIZE));
   size_t client_received_message_size = 0;
   receive_message_from_peer(
       fixture, client_frame_protector, client_received_message,
@@ -455,17 +465,18 @@ void tsi_test_do_round_trip(tsi_test_fixture *fixture) {
   gpr_free(client_received_message);
 }
 
-static unsigned char *generate_random_message(size_t size) {
+static unsigned char* generate_random_message(size_t size) {
   size_t i;
   unsigned char chars[] = "abcdefghijklmnopqrstuvwxyz1234567890";
-  unsigned char *output = gpr_zalloc(sizeof(unsigned char) * size);
+  unsigned char* output =
+      static_cast<unsigned char*>(gpr_zalloc(sizeof(unsigned char) * size));
   for (i = 0; i < size - 1; ++i) {
     output[i] = chars[rand() % (int)(sizeof(chars) - 1)];
   }
   return output;
 }
 
-tsi_test_frame_protector_config *tsi_test_frame_protector_config_create(
+tsi_test_frame_protector_config* tsi_test_frame_protector_config_create(
     bool use_default_read_buffer_allocated_size,
     bool use_default_message_buffer_allocated_size,
     bool use_default_protected_buffer_size, bool use_default_client_message,
@@ -473,7 +484,9 @@ tsi_test_frame_protector_config *tsi_test_frame_protector_config_create(
     bool use_default_client_max_output_protected_frame_size,
     bool use_default_server_max_output_protected_frame_size,
     bool use_default_handshake_buffer_size) {
-  tsi_test_frame_protector_config *config = gpr_zalloc(sizeof(*config));
+  tsi_test_frame_protector_config* config =
+      static_cast<tsi_test_frame_protector_config*>(
+          gpr_zalloc(sizeof(*config)));
   /* Set the value for read_buffer_allocated_size. */
   config->read_buffer_allocated_size =
       use_default_read_buffer_allocated_size
@@ -522,11 +535,11 @@ tsi_test_frame_protector_config *tsi_test_frame_protector_config_create(
 }
 
 void tsi_test_frame_protector_config_set_buffer_size(
-    tsi_test_frame_protector_config *config, size_t read_buffer_allocated_size,
+    tsi_test_frame_protector_config* config, size_t read_buffer_allocated_size,
     size_t message_buffer_allocated_size, size_t protected_buffer_size,
     size_t client_max_output_protected_frame_size,
     size_t server_max_output_protected_frame_size) {
-  GPR_ASSERT(config != NULL);
+  GPR_ASSERT(config != nullptr);
   config->read_buffer_allocated_size = read_buffer_allocated_size;
   config->message_buffer_allocated_size = message_buffer_allocated_size;
   config->protected_buffer_size = protected_buffer_size;
@@ -537,19 +550,21 @@ void tsi_test_frame_protector_config_set_buffer_size(
 }
 
 void tsi_test_frame_protector_config_destroy(
-    tsi_test_frame_protector_config *config) {
-  GPR_ASSERT(config != NULL);
+    tsi_test_frame_protector_config* config) {
+  GPR_ASSERT(config != nullptr);
   gpr_free(config->client_message);
   gpr_free(config->server_message);
   gpr_free(config);
 }
 
-void tsi_test_fixture_init(tsi_test_fixture *fixture) {
+void tsi_test_fixture_init(tsi_test_fixture* fixture) {
   fixture->config = tsi_test_frame_protector_config_create(
       true, true, true, true, true, true, true, true);
   fixture->handshake_buffer_size = TSI_TEST_DEFAULT_BUFFER_SIZE;
-  fixture->client_channel = gpr_zalloc(TSI_TEST_DEFAULT_CHANNEL_SIZE);
-  fixture->server_channel = gpr_zalloc(TSI_TEST_DEFAULT_CHANNEL_SIZE);
+  fixture->client_channel =
+      static_cast<uint8_t*>(gpr_zalloc(TSI_TEST_DEFAULT_CHANNEL_SIZE));
+  fixture->server_channel =
+      static_cast<uint8_t*>(gpr_zalloc(TSI_TEST_DEFAULT_CHANNEL_SIZE));
   fixture->bytes_written_to_client_channel = 0;
   fixture->bytes_written_to_server_channel = 0;
   fixture->bytes_read_from_client_channel = 0;
@@ -561,8 +576,8 @@ void tsi_test_fixture_init(tsi_test_fixture *fixture) {
   fixture->notified = false;
 }
 
-void tsi_test_fixture_destroy(tsi_test_fixture *fixture) {
-  GPR_ASSERT(fixture != NULL);
+void tsi_test_fixture_destroy(tsi_test_fixture* fixture) {
+  GPR_ASSERT(fixture != nullptr);
   tsi_test_frame_protector_config_destroy(fixture->config);
   tsi_handshaker_destroy(fixture->client_handshaker);
   tsi_handshaker_destroy(fixture->server_handshaker);
@@ -570,8 +585,8 @@ void tsi_test_fixture_destroy(tsi_test_fixture *fixture) {
   tsi_handshaker_result_destroy(fixture->server_result);
   gpr_free(fixture->client_channel);
   gpr_free(fixture->server_channel);
-  GPR_ASSERT(fixture->vtable != NULL);
-  GPR_ASSERT(fixture->vtable->destruct != NULL);
+  GPR_ASSERT(fixture->vtable != nullptr);
+  GPR_ASSERT(fixture->vtable->destruct != nullptr);
   fixture->vtable->destruct(fixture);
   gpr_mu_destroy(&fixture->mu);
   gpr_cv_destroy(&fixture->cv);
diff --git a/test/core/tsi/transport_security_test_lib.h b/test/core/tsi/transport_security_test_lib.h
index ed8ff856df..9b07448cc5 100644
--- a/test/core/tsi/transport_security_test_lib.h
+++ b/test/core/tsi/transport_security_test_lib.h
@@ -21,9 +21,7 @@
 
 #include "src/core/tsi/transport_security_interface.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+#include <grpc/support/sync.h>
 
 #define TSI_TEST_TINY_HANDSHAKE_BUFFER_SIZE 32
 #define TSI_TEST_SMALL_HANDSHAKE_BUFFER_SIZE 128
@@ -57,29 +55,29 @@ typedef struct tsi_test_frame_protector_config tsi_test_frame_protector_config;
 /* V-table for tsi_test_fixture operations that are implemented differently in
    different TSI implementations. */
 typedef struct tsi_test_fixture_vtable {
-  void (*setup_handshakers)(tsi_test_fixture *fixture);
-  void (*check_handshaker_peers)(tsi_test_fixture *fixture);
-  void (*destruct)(tsi_test_fixture *fixture);
+  void (*setup_handshakers)(tsi_test_fixture* fixture);
+  void (*check_handshaker_peers)(tsi_test_fixture* fixture);
+  void (*destruct)(tsi_test_fixture* fixture);
 } tsi_test_fixture_vtable;
 
 struct tsi_test_fixture {
-  const tsi_test_fixture_vtable *vtable;
+  const tsi_test_fixture_vtable* vtable;
   /* client/server TSI handshaker used to perform TSI handshakes, and will get
      instantiated during the call to setup_handshakers. */
-  tsi_handshaker *client_handshaker;
-  tsi_handshaker *server_handshaker;
+  tsi_handshaker* client_handshaker;
+  tsi_handshaker* server_handshaker;
   /* client/server TSI handshaker results used to store the result of TSI
      handshake. If the handshake fails, the result will store NULL upon
      finishing the handshake. */
-  tsi_handshaker_result *client_result;
-  tsi_handshaker_result *server_result;
+  tsi_handshaker_result* client_result;
+  tsi_handshaker_result* server_result;
   /* size of buffer used to store data received from the peer. */
   size_t handshake_buffer_size;
   /* simulated channels between client and server. If the server (client)
      wants to send data to the client (server), he will write data to
      client_channel (server_channel), which will be read by client (server). */
-  uint8_t *client_channel;
-  uint8_t *server_channel;
+  uint8_t* client_channel;
+  uint8_t* server_channel;
   /* size of data written to the client/server channel. */
   size_t bytes_written_to_client_channel;
   size_t bytes_written_to_server_channel;
@@ -87,7 +85,7 @@ struct tsi_test_fixture {
   size_t bytes_read_from_client_channel;
   size_t bytes_read_from_server_channel;
   /* tsi_test_frame_protector_config instance */
-  tsi_test_frame_protector_config *config;
+  tsi_test_frame_protector_config* config;
   /* a flag indicating if client has finished TSI handshake first (i.e., before
      server).
      The flag should be referred if and only if TSI handshake finishes
@@ -119,8 +117,8 @@ struct tsi_test_frame_protector_config {
   size_t client_max_output_protected_frame_size;
   size_t server_max_output_protected_frame_size;
   /* pointer that points to client/server message to be protected. */
-  uint8_t *client_message;
-  uint8_t *server_message;
+  uint8_t* client_message;
+  uint8_t* server_message;
   /* size of client/server message. */
   size_t client_message_size;
   size_t server_message_size;
@@ -131,7 +129,7 @@ struct tsi_test_frame_protector_config {
    corresponding parameter with a default value or not. If it's false, it will
    be set with a specific value which is usually much smaller than the default.
    Both values are defined with #define directive. */
-tsi_test_frame_protector_config *tsi_test_frame_protector_config_create(
+tsi_test_frame_protector_config* tsi_test_frame_protector_config_create(
     bool use_default_read_buffer_allocated_size,
     bool use_default_message_buffer_allocated_size,
     bool use_default_protected_buffer_size, bool use_default_client_message,
@@ -143,38 +141,34 @@ tsi_test_frame_protector_config *tsi_test_frame_protector_config_create(
 /* This method sets different buffer and frame sizes of a
    tsi_test_frame_protector_config instance with user provided values. */
 void tsi_test_frame_protector_config_set_buffer_size(
-    tsi_test_frame_protector_config *config, size_t read_buffer_allocated_size,
+    tsi_test_frame_protector_config* config, size_t read_buffer_allocated_size,
     size_t message_buffer_allocated_size, size_t protected_buffer_size,
     size_t client_max_output_protected_frame_size,
     size_t server_max_output_protected_frame_size);
 
 /* This method destroys a tsi_test_frame_protector_config instance. */
 void tsi_test_frame_protector_config_destroy(
-    tsi_test_frame_protector_config *config);
+    tsi_test_frame_protector_config* config);
 
 /* This method initializes members of tsi_test_fixture instance.
    Note that the struct instance should be allocated before making
    this call. */
-void tsi_test_fixture_init(tsi_test_fixture *fixture);
+void tsi_test_fixture_init(tsi_test_fixture* fixture);
 
 /* This method destroys a tsi_test_fixture instance. Note that the
    fixture intance must be dynamically allocated and will be freed by
    this function. */
-void tsi_test_fixture_destroy(tsi_test_fixture *fixture);
+void tsi_test_fixture_destroy(tsi_test_fixture* fixture);
 
 /* This method performs a full TSI handshake between a client and a server.
    Note that the test library will implement the new TSI handshaker API to
    perform handshakes. */
-void tsi_test_do_handshake(tsi_test_fixture *fixture);
+void tsi_test_do_handshake(tsi_test_fixture* fixture);
 
 /* This method performs a round trip test between the client and the server.
    That is, the client sends a protected message to a server who receives the
    message, and unprotects it. The same operation is triggered again with
    the client and server switching its role. */
-void tsi_test_do_round_trip(tsi_test_fixture *fixture);
-
-#ifdef __cplusplus
-}
-#endif
+void tsi_test_do_round_trip(tsi_test_fixture* fixture);
 
 #endif  // GRPC_TEST_CORE_TSI_TRANSPORT_SECURITY_TEST_LIB_H_
diff --git a/test/core/util/BUILD b/test/core/util/BUILD
index 5844a17728..6443553466 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,17 @@ 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",
+        "tracer_util.cc",
+        "trickle_endpoint.cc",
     ],
     hdrs = [
         "grpc_profiler.h",
@@ -69,9 +70,10 @@ grpc_cc_library(
         "reconnect_server.h",
         "slice_splitter.h",
         "test_tcp_server.h",
+        "tracer_util.h",
         "trickle_endpoint.h",
     ],
-    language = "C",
+    language = "C++",
     deps = [
         ":gpr_test_util",
         "//:grpc_common",
@@ -83,7 +85,7 @@ grpc_cc_library(
     name = "grpc_test_util",
     srcs = [],
     hdrs = [],
-    language = "C",
+    language = "C++",
     deps = [
         ":grpc_test_util_base",
         "//:grpc",
@@ -94,7 +96,7 @@ grpc_cc_library(
     name = "grpc_test_util_unsecure",
     srcs = [],
     hdrs = [],
-    language = "C",
+    language = "C++",
     deps = [
         ":grpc_test_util_base",
         "//:grpc_unsecure",
@@ -103,6 +105,7 @@ grpc_cc_library(
 
 grpc_cc_library(
     name = "fuzzer_corpus_test",
+    testonly = 1,
     srcs = ["fuzzer_corpus_test.cc"],
     deps = [
         ":gpr_test_util",
diff --git a/test/core/util/debugger_macros.cc b/test/core/util/debugger_macros.cc
index 72384f2dd7..f1e4ffd3af 100644
--- a/test/core/util/debugger_macros.cc
+++ b/test/core/util/debugger_macros.cc
@@ -29,28 +29,28 @@
 #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);
-      if (scc == NULL) {
+      grpc_subchannel_call* scc = grpc_client_channel_get_subchannel_call(el);
+      if (scc == nullptr) {
         fprintf(stderr, "No subchannel-call");
-        return NULL;
+        return nullptr;
       }
       cs = grpc_subchannel_call_get_call_stack(scc);
     } else if (el->filter == &grpc_connected_filter) {
       return grpc_connected_channel_get_stream(el);
     } else {
       fprintf(stderr, "Unrecognized filter: %s", el->filter->name);
-      return NULL;
+      return nullptr;
     }
   }
 }
 
-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/fuzzer_corpus_test.cc b/test/core/util/fuzzer_corpus_test.cc
index a5e99a1bac..d7aea54262 100644
--- a/test/core/util/fuzzer_corpus_test.cc
+++ b/test/core/util/fuzzer_corpus_test.cc
@@ -32,6 +32,13 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size);
 extern "C" bool squelch;
 extern "C" bool leak_check;
 
+// In some distros, gflags is in the namespace google, and in some others,
+// in gflags. This hack is enabling us to find both.
+namespace google {}
+namespace gflags {}
+using namespace google;
+using namespace gflags;
+
 DEFINE_string(file, "", "Use this file as test data");
 DEFINE_string(directory, "", "Use this directory as test data");
 
@@ -65,7 +72,7 @@ class ExampleGenerator
         struct dirent* ep;
         dp = opendir(FLAGS_directory.c_str());
 
-        if (dp != NULL) {
+        if (dp != nullptr) {
           while ((ep = readdir(dp)) != nullptr) {
             if (ep->d_type == DT_REG) {
               examples_.push_back(FLAGS_directory + "/" + ep->d_name);
@@ -129,7 +136,7 @@ INSTANTIATE_TEST_CASE_P(
 
 int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
-  ::gflags::ParseCommandLineFlags(&argc, &argv, true);
+  ParseCommandLineFlags(&argc, &argv, true);
   ::testing::InitGoogleTest(&argc, argv);
 
   return RUN_ALL_TESTS();
diff --git a/test/core/util/grpc_fuzzer.bzl b/test/core/util/grpc_fuzzer.bzl
index 55b6f1c1a5..b8b270ecd0 100644
--- a/test/core/util/grpc_fuzzer.bzl
+++ b/test/core/util/grpc_fuzzer.bzl
@@ -19,8 +19,7 @@ def grpc_fuzzer(name, corpus, srcs = [], deps = [], **kwargs):
     name = name,
     srcs = srcs,
     deps = deps + ["//test/core/util:fuzzer_corpus_test"],
-    data = [corpus],
-    args = ['--directory', '$(location %s)' % corpus],
+    data = native.glob([corpus + "/**"]),
     external_deps = [
       'gtest',
     ],
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..32d7b89c9a 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,39 +41,39 @@ 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;
-  if (!size) return NULL;
+static void* guard_malloc(size_t size) {
+  size_t* ptr;
+  if (!size) return nullptr;
   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;
-  if (vptr == NULL) {
+static void* guard_realloc(void* vptr, size_t size) {
+  size_t* ptr = (size_t*)vptr;
+  if (vptr == nullptr) {
     return guard_malloc(size);
   }
   if (size == 0) {
     guard_free(vptr);
-    return NULL;
+    return nullptr;
   }
   --ptr;
   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)*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);
@@ -81,7 +81,7 @@ static void guard_free(void *vptr) {
   g_old_allocs.free_fn(ptr);
 }
 
-struct gpr_allocation_functions g_guard_allocs = {guard_malloc, NULL,
+struct gpr_allocation_functions g_guard_allocs = {guard_malloc, nullptr,
                                                   guard_realloc, guard_free};
 
 void grpc_memory_counters_init() {
diff --git a/test/core/util/mock_endpoint.c b/test/core/util/mock_endpoint.cc
index bd386b2148..d9545efa49 100644
--- a/test/core/util/mock_endpoint.c
+++ 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_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                    grpc_slice_buffer *slices, grpc_closure *cb) {
-  grpc_mock_endpoint *m = (grpc_mock_endpoint *)ep;
+static void me_read(grpc_exec_ctx* exec_ctx, 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,83 +54,94 @@ static void me_read(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
   gpr_mu_unlock(&m->mu);
 }
 
-static void me_write(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                     grpc_slice_buffer *slices, grpc_closure *cb) {
-  grpc_mock_endpoint *m = (grpc_mock_endpoint *)ep;
+static void me_write(grpc_exec_ctx* exec_ctx, 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(exec_ctx, cb, GRPC_ERROR_NONE);
 }
 
-static void me_add_to_pollset(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                              grpc_pollset *pollset) {}
+static void me_add_to_pollset(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep,
+                              grpc_pollset* pollset) {}
 
-static void me_add_to_pollset_set(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                                  grpc_pollset_set *pollset) {}
+static void me_add_to_pollset_set(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep,
+                                  grpc_pollset_set* pollset) {}
 
-static void me_shutdown(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                        grpc_error *why) {
-  grpc_mock_endpoint *m = (grpc_mock_endpoint *)ep;
+static void me_delete_from_pollset_set(grpc_exec_ctx* exec_ctx,
+                                       grpc_endpoint* ep,
+                                       grpc_pollset_set* pollset) {}
+
+static void me_shutdown(grpc_exec_ctx* exec_ctx, 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(exec_ctx, m->on_read,
                        GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                            "Endpoint Shutdown", &why, 1));
-    m->on_read = NULL;
+    m->on_read = nullptr;
   }
   gpr_mu_unlock(&m->mu);
   grpc_resource_user_shutdown(exec_ctx, m->resource_user);
   GRPC_ERROR_UNREF(why);
 }
 
-static void me_destroy(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep) {
-  grpc_mock_endpoint *m = (grpc_mock_endpoint *)ep;
+static void me_destroy(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep) {
+  grpc_mock_endpoint* m = (grpc_mock_endpoint*)ep;
   grpc_slice_buffer_destroy(&m->read_buffer);
   grpc_resource_user_unref(exec_ctx, 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);
   grpc_slice_buffer_init(&m->read_buffer);
   gpr_mu_init(&m->mu);
   m->on_write = on_write;
-  m->on_read = NULL;
+  m->on_read = nullptr;
   return &m->base;
 }
 
-void grpc_mock_endpoint_put_read(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
+void grpc_mock_endpoint_put_read(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep,
                                  grpc_slice slice) {
-  grpc_mock_endpoint *m = (grpc_mock_endpoint *)ep;
+  grpc_mock_endpoint* m = (grpc_mock_endpoint*)ep;
   gpr_mu_lock(&m->mu);
-  if (m->on_read != NULL) {
+  if (m->on_read != nullptr) {
     grpc_slice_buffer_add(m->on_read_out, slice);
     GRPC_CLOSURE_SCHED(exec_ctx, m->on_read, GRPC_ERROR_NONE);
-    m->on_read = NULL;
+    m->on_read = nullptr;
   } else {
     grpc_slice_buffer_add(&m->read_buffer, slice);
   }
diff --git a/test/core/util/mock_endpoint.h b/test/core/util/mock_endpoint.h
index 73b08dca31..ccabaf7c3b 100644
--- a/test/core/util/mock_endpoint.h
+++ b/test/core/util/mock_endpoint.h
@@ -21,10 +21,10 @@
 
 #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_exec_ctx *exec_ctx,
-                                 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_exec_ctx* exec_ctx,
+                                 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..622642a298 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 = nullptr;
+  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.c b/test/core/util/passthru_endpoint.cc
index 38a47584d5..a9efe22b69 100644
--- a/test/core/util/passthru_endpoint.c
+++ 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_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                    grpc_slice_buffer *slices, grpc_closure *cb) {
-  half *m = (half *)ep;
+static void me_read(grpc_exec_ctx* exec_ctx, 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,25 +72,25 @@ static void me_read(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
   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_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                     grpc_slice_buffer *slices, grpc_closure *cb) {
-  half *m = other_half((half *)ep);
+static void me_write(grpc_exec_ctx* exec_ctx, 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) {
+  } else if (m->on_read != nullptr) {
     for (size_t i = 0; i < slices->count; i++) {
       grpc_slice_buffer_add(m->on_read_out, grpc_slice_copy(slices->slices[i]));
     }
     GRPC_CLOSURE_SCHED(exec_ctx, m->on_read, GRPC_ERROR_NONE);
-    m->on_read = NULL;
+    m->on_read = nullptr;
   } else {
     for (size_t i = 0; i < slices->count; i++) {
       grpc_slice_buffer_add(&m->read_buffer,
@@ -101,37 +101,41 @@ static void me_write(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
   GRPC_CLOSURE_SCHED(exec_ctx, cb, error);
 }
 
-static void me_add_to_pollset(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                              grpc_pollset *pollset) {}
+static void me_add_to_pollset(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep,
+                              grpc_pollset* pollset) {}
 
-static void me_add_to_pollset_set(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                                  grpc_pollset_set *pollset) {}
+static void me_add_to_pollset_set(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep,
+                                  grpc_pollset_set* pollset) {}
 
-static void me_shutdown(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                        grpc_error *why) {
-  half *m = (half *)ep;
+static void me_delete_from_pollset_set(grpc_exec_ctx* exec_ctx,
+                                       grpc_endpoint* ep,
+                                       grpc_pollset_set* pollset) {}
+
+static void me_shutdown(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep,
+                        grpc_error* why) {
+  half* m = (half*)ep;
   gpr_mu_lock(&m->parent->mu);
   m->parent->shutdown = true;
   if (m->on_read) {
     GRPC_CLOSURE_SCHED(
         exec_ctx, m->on_read,
         GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING("Shutdown", &why, 1));
-    m->on_read = NULL;
+    m->on_read = nullptr;
   }
   m = other_half(m);
   if (m->on_read) {
     GRPC_CLOSURE_SCHED(
         exec_ctx, m->on_read,
         GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING("Shutdown", &why, 1));
-    m->on_read = NULL;
+    m->on_read = nullptr;
   }
   gpr_mu_unlock(&m->parent->mu);
   grpc_resource_user_shutdown(exec_ctx, m->resource_user);
   GRPC_ERROR_UNREF(why);
 }
 
-static void me_destroy(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep) {
-  passthru_endpoint *p = ((half *)ep)->parent;
+static void me_destroy(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep) {
+  passthru_endpoint* p = ((half*)ep)->parent;
   gpr_mu_lock(&p->mu);
   if (0 == --p->halves) {
     gpr_mu_unlock(&p->mu);
@@ -146,47 +150,54 @@ static void me_destroy(grpc_exec_ctx *exec_ctx, 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;
+  m->on_read = nullptr;
+  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;
+  m->stats = stats == nullptr ? &m->dummy_stats : stats;
   memset(m->stats, 0, sizeof(*m->stats));
   half_init(&m->client, m, resource_quota, "client");
   half_init(&m->server, m, resource_quota, "server");
diff --git a/test/core/util/passthru_endpoint.h b/test/core/util/passthru_endpoint.h
index da769024a5..bddd8ea6a2 100644
--- a/test/core/util/passthru_endpoint.h
+++ b/test/core/util/passthru_endpoint.h
@@ -19,13 +19,17 @@
 #ifndef MOCK_ENDPOINT_H
 #define MOCK_ENDPOINT_H
 
+#include <grpc/support/atm.h>
+
 #include "src/core/lib/iomgr/endpoint.h"
 
-typedef struct { int num_writes; } grpc_passthru_endpoint_stats;
+typedef struct {
+  gpr_atm num_writes;
+} grpc_passthru_endpoint_stats;
 
-void grpc_passthru_endpoint_create(grpc_endpoint **client,
-                                   grpc_endpoint **server,
-                                   grpc_resource_quota *resource_quota,
-                                   grpc_passthru_endpoint_stats *stats);
+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.c b/test/core/util/port.cc
index 61f2e5018f..9d02b673ed 100644
--- a/test/core/util/port.c
+++ 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 = nullptr;
 static size_t num_chosen_ports = 0;
 
 static int free_chosen_port(int port) {
@@ -71,12 +71,12 @@ static void free_chosen_ports(void) {
 }
 
 static void chose_port(int port) {
-  if (chosen_ports == NULL) {
+  if (chosen_ports == nullptr) {
     atexit(free_chosen_ports);
   }
   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;
 }
 
@@ -123,9 +123,9 @@ void grpc_recycle_unused_port(int port) {
 }
 
 void grpc_set_pick_port_functions(grpc_pick_port_functions functions) {
-  GPR_ASSERT(functions.pick_unused_port_fn != NULL);
-  GPR_ASSERT(functions.pick_unused_port_or_die_fn != NULL);
-  GPR_ASSERT(functions.recycle_unused_port_fn != NULL);
+  GPR_ASSERT(functions.pick_unused_port_fn != nullptr);
+  GPR_ASSERT(functions.pick_unused_port_or_die_fn != nullptr);
+  GPR_ASSERT(functions.recycle_unused_port_fn != nullptr);
   g_pick_port_functions = functions;
 }
 
diff --git a/test/core/util/port_server_client.c b/test/core/util/port_server_client.cc
index 7b94ac4ada..edec50b424 100644
--- a/test/core/util/port_server_client.c
+++ b/test/core/util/port_server_client.cc
@@ -35,27 +35,27 @@
 #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(grpc_exec_ctx *exec_ctx, void *p,
-                                      grpc_error *error) {
-  grpc_pollset *pollset = grpc_polling_entity_pollset((grpc_polling_entity *)p);
+static void destroy_pops_and_shutdown(grpc_exec_ctx* exec_ctx, void* p,
+                                      grpc_error* error) {
+  grpc_pollset* pollset = grpc_polling_entity_pollset((grpc_polling_entity*)p);
   grpc_pollset_destroy(exec_ctx, pollset);
   gpr_free(pollset);
 }
 
-static void freed_port_from_server(grpc_exec_ctx *exec_ctx, void *arg,
-                                   grpc_error *error) {
-  freereq *pr = (freereq *)arg;
+static void freed_port_from_server(grpc_exec_ctx* exec_ctx, void* arg,
+                                   grpc_error* error) {
+  freereq* pr = (freereq*)arg;
   gpr_mu_lock(pr->mu);
   pr->done = 1;
   GRPC_LOG_IF_ERROR(
       "pollset_kick",
       grpc_pollset_kick(exec_ctx, grpc_polling_entity_pollset(&pr->pops),
-                        NULL));
+                        nullptr));
   gpr_mu_unlock(pr->mu);
 }
 
@@ -64,9 +64,9 @@ void grpc_free_port_using_server(int port) {
   grpc_httpcli_request req;
   grpc_httpcli_response rsp;
   freereq pr;
-  char *path;
+  char* path;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_closure *shutdown_closure;
+  grpc_closure* shutdown_closure;
 
   grpc_init();
 
@@ -74,18 +74,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 = 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(&exec_ctx, &context, &pr.pops, resource_quota, &req,
                    grpc_exec_ctx_now(&exec_ctx) + 30 * GPR_MS_PER_SEC,
@@ -96,7 +96,7 @@ void grpc_free_port_using_server(int port) {
   grpc_exec_ctx_flush(&exec_ctx);
   gpr_mu_lock(pr.mu);
   while (!pr.done) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     if (!GRPC_LOG_IF_ERROR(
             "pollset_work",
             grpc_pollset_work(&exec_ctx, grpc_polling_entity_pollset(&pr.pops),
@@ -118,26 +118,26 @@ 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(grpc_exec_ctx *exec_ctx, void *arg,
-                                 grpc_error *error) {
+static void got_port_from_server(grpc_exec_ctx* exec_ctx, 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) {
@@ -155,7 +155,7 @@ static void got_port_from_server(grpc_exec_ctx *exec_ctx, void *arg,
       GRPC_LOG_IF_ERROR(
           "pollset_kick",
           grpc_pollset_kick(exec_ctx, grpc_polling_entity_pollset(&pr->pops),
-                            NULL));
+                            nullptr));
       gpr_mu_unlock(pr->mu);
       return;
     }
@@ -167,10 +167,10 @@ static void got_port_from_server(grpc_exec_ctx *exec_ctx, void *arg,
             GPR_TIMESPAN)));
     pr->retries++;
     req.host = pr->server;
-    req.http.path = "/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(exec_ctx, pr->ctx, &pr->pops, resource_quota, &req,
                      grpc_exec_ctx_now(exec_ctx) + 30 * GPR_MS_PER_SEC,
@@ -192,7 +192,7 @@ static void got_port_from_server(grpc_exec_ctx *exec_ctx, void *arg,
   GRPC_LOG_IF_ERROR(
       "pollset_kick",
       grpc_pollset_kick(exec_ctx, grpc_polling_entity_pollset(&pr->pops),
-                        NULL));
+                        nullptr));
   gpr_mu_unlock(pr->mu);
 }
 
@@ -201,26 +201,26 @@ int grpc_pick_port_using_server(void) {
   grpc_httpcli_request req;
   portreq pr;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  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 = GRPC_PORT_SERVER_ADDRESS;
+  pr.server = const_cast<char*>(GRPC_PORT_SERVER_ADDRESS);
   pr.ctx = &context;
 
-  req.host = GRPC_PORT_SERVER_ADDRESS;
-  req.http.path = "/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(
       &exec_ctx, &context, &pr.pops, resource_quota, &req,
@@ -231,7 +231,7 @@ int grpc_pick_port_using_server(void) {
   grpc_exec_ctx_flush(&exec_ctx);
   gpr_mu_lock(pr.mu);
   while (pr.port == -1) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     if (!GRPC_LOG_IF_ERROR(
             "pollset_work",
             grpc_pollset_work(&exec_ctx, grpc_polling_entity_pollset(&pr.pops),
diff --git a/test/core/util/reconnect_server.c b/test/core/util/reconnect_server.cc
index 9c56e02e8e..4775b074eb 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,25 +55,25 @@ static void pretty_print_backoffs(reconnect_server *server) {
   }
 }
 
-static void on_connect(grpc_exec_ctx *exec_ctx, void *arg, grpc_endpoint *tcp,
-                       grpc_pollset *accepting_pollset,
-                       grpc_tcp_server_acceptor *acceptor) {
+static void on_connect(grpc_exec_ctx* exec_ctx, 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(exec_ctx, tcp,
                          GRPC_ERROR_CREATE_FROM_STATIC_STRING("Connected"));
   grpc_endpoint_destroy(exec_ctx, tcp);
   if (peer) {
     last_colon = strrchr(peer, ':');
-    if (server->peer == NULL) {
+    if (server->peer == nullptr) {
       server->peer = peer;
     } else {
-      if (last_colon == NULL) {
+      if (last_colon == nullptr) {
         gpr_log(GPR_ERROR, "peer does not contain a ':'");
       } else if (strncmp(server->peer, peer, (size_t)(last_colon - peer)) !=
                  0) {
@@ -82,10 +82,10 @@ static void on_connect(grpc_exec_ctx *exec_ctx, 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) {
+  new_tail->next = nullptr;
+  if (server->tail == nullptr) {
     server->head = new_tail;
     server->tail = new_tail;
   } else {
@@ -95,35 +95,35 @@ static void on_connect(grpc_exec_ctx *exec_ctx, 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;
-  server->peer = NULL;
+  server->head = nullptr;
+  server->tail = nullptr;
+  server->peer = nullptr;
   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);
     server->head = new_head;
   }
-  server->tail = NULL;
+  server->tail = nullptr;
   gpr_free(server->peer);
-  server->peer = NULL;
+  server->peer = nullptr;
 }
 
-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..7225b6dc03 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 = nullptr;
   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..9ebb52d83e 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,8 +202,8 @@ static void install_crash_handler() {
 
 #define SIGNAL_NAMES_LENGTH 32
 
-static const char *const signal_names[] = {
-    NULL,      "SIGHUP",  "SIGINT",    "SIGQUIT", "SIGILL",    "SIGTRAP",
+static const char* const signal_names[] = {
+    nullptr,   "SIGHUP",  "SIGINT",    "SIGQUIT", "SIGILL",    "SIGTRAP",
     "SIGABRT", "SIGBUS",  "SIGFPE",    "SIGKILL", "SIGUSR1",   "SIGSEGV",
     "SIGUSR2", "SIGPIPE", "SIGALRM",   "SIGTERM", "SIGSTKFLT", "SIGCHLD",
     "SIGCONT", "SIGSTOP", "SIGTSTP",   "SIGTTIN", "SIGTTOU",   "SIGURG",
@@ -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 ");
@@ -263,15 +263,15 @@ static void install_crash_handler() {
   memset(&sa, 0, sizeof(sa));
   ss.ss_size = sizeof(g_alt_stack);
   ss.ss_sp = g_alt_stack;
-  GPR_ASSERT(sigaltstack(&ss, NULL) == 0);
+  GPR_ASSERT(sigaltstack(&ss, nullptr) == 0);
   sa.sa_flags = (int)(SA_SIGINFO | SA_ONSTACK | SA_RESETHAND);
   sa.sa_sigaction = crash_handler;
-  GPR_ASSERT(sigaction(SIGILL, &sa, NULL) == 0);
-  GPR_ASSERT(sigaction(SIGABRT, &sa, NULL) == 0);
-  GPR_ASSERT(sigaction(SIGBUS, &sa, NULL) == 0);
-  GPR_ASSERT(sigaction(SIGSEGV, &sa, NULL) == 0);
-  GPR_ASSERT(sigaction(SIGTERM, &sa, NULL) == 0);
-  GPR_ASSERT(sigaction(SIGQUIT, &sa, NULL) == 0);
+  GPR_ASSERT(sigaction(SIGILL, &sa, nullptr) == 0);
+  GPR_ASSERT(sigaction(SIGABRT, &sa, nullptr) == 0);
+  GPR_ASSERT(sigaction(SIGBUS, &sa, nullptr) == 0);
+  GPR_ASSERT(sigaction(SIGSEGV, &sa, nullptr) == 0);
+  GPR_ASSERT(sigaction(SIGTERM, &sa, nullptr) == 0);
+  GPR_ASSERT(sigaction(SIGQUIT, &sa, nullptr) == 0);
 }
 #else
 static void install_crash_handler() {}
@@ -376,11 +376,11 @@ 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");
-    if (s != NULL && 0 == strcmp(s, "poll-cv")) {
+    char* s = gpr_getenv("GRPC_POLL_STRATEGY");
+    if (s != nullptr && 0 == strcmp(s, "poll-cv")) {
       g_poller_slowdown_factor = 5;
     }
     gpr_free(s);
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.c b/test/core/util/test_tcp_server.cc
index 611ecb330c..da34da6fd0 100644
--- a/test/core/util/test_tcp_server.c
+++ b/test/core/util/test_tcp_server.cc
@@ -33,28 +33,28 @@
 #include "test/core/util/port.h"
 #include "test/core/util/test_config.h"
 
-static void on_server_destroyed(grpc_exec_ctx *exec_ctx, void *data,
-                                grpc_error *error) {
-  test_tcp_server *server = data;
+static void on_server_destroyed(grpc_exec_ctx* exec_ctx, 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;
+  server->tcp_server = nullptr;
   GRPC_CLOSURE_INIT(&server->shutdown_complete, on_server_destroyed, server,
                     grpc_schedule_on_exec_ctx);
   server->shutdown = 0;
-  server->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;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
@@ -62,8 +62,8 @@ 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(
-      &exec_ctx, &server->shutdown_complete, NULL, &server->tcp_server);
+  grpc_error* error = grpc_tcp_server_create(
+      &exec_ctx, &server->shutdown_complete, nullptr, &server->tcp_server);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   error =
       grpc_tcp_server_add_port(server->tcp_server, &resolved_addr, &port_added);
@@ -77,8 +77,8 @@ void test_tcp_server_start(test_tcp_server *server, int port) {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-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 = nullptr;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_millis deadline = grpc_timespec_to_millis_round_up(
       grpc_timeout_seconds_to_deadline(seconds));
@@ -90,18 +90,18 @@ void test_tcp_server_poll(test_tcp_server *server, int seconds) {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void do_nothing(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {}
-static void finish_pollset(grpc_exec_ctx *exec_ctx, void *arg,
-                           grpc_error *error) {
-  grpc_pollset_destroy(exec_ctx, arg);
+static void do_nothing(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {}
+static void finish_pollset(grpc_exec_ctx* exec_ctx, void* arg,
+                           grpc_error* error) {
+  grpc_pollset_destroy(exec_ctx, static_cast<grpc_pollset*>(arg));
 }
 
-void test_tcp_server_destroy(test_tcp_server *server) {
+void test_tcp_server_destroy(test_tcp_server* server) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   gpr_timespec shutdown_deadline;
   grpc_closure do_nothing_cb;
   grpc_tcp_server_unref(&exec_ctx, server->tcp_server);
-  GRPC_CLOSURE_INIT(&do_nothing_cb, do_nothing, NULL,
+  GRPC_CLOSURE_INIT(&do_nothing_cb, do_nothing, nullptr,
                     grpc_schedule_on_exec_ctx);
   shutdown_deadline = gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC),
                                    gpr_time_from_seconds(5, GPR_TIMESPAN));
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/tracer_util.cc b/test/core/util/tracer_util.cc
new file mode 100644
index 0000000000..34a132daa7
--- /dev/null
+++ b/test/core/util/tracer_util.cc
@@ -0,0 +1,31 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "test/core/util/test_config.h"
+
+#include "src/core/lib/debug/trace.h"
+
+namespace grpc_core {
+namespace testing {
+
+void grpc_tracer_enable_flag(grpc_core::TraceFlag* flag) {
+  flag->set_enabled(1);
+}
+
+}  // namespace testing
+}  // namespace grpc_core
diff --git a/test/core/util/tracer_util.h b/test/core/util/tracer_util.h
new file mode 100644
index 0000000000..0b432ffa46
--- /dev/null
+++ b/test/core/util/tracer_util.h
@@ -0,0 +1,32 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef GRPC_TEST_CORE_UTIL_TRACER_UTIL_H
+#define GRPC_TEST_CORE_UTIL_TRACER_UTIL_H
+
+namespace grpc_core {
+class TraceFlag;
+
+namespace testing {
+// enables the TraceFlag passed to it. Used for testing purposes.
+void grpc_tracer_enable_flag(grpc_core::TraceFlag* flag);
+
+}  // namespace testing
+}  // namespace grpc_core
+
+#endif /* GRPC_TEST_CORE_UTIL_TRACER_UTIL_H */
diff --git a/test/core/util/trickle_endpoint.c b/test/core/util/trickle_endpoint.cc
index fc066f9d80..4544fb7f49 100644
--- a/test/core/util/trickle_endpoint.c
+++ b/test/core/util/trickle_endpoint.cc
@@ -34,37 +34,38 @@
 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_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                    grpc_slice_buffer *slices, grpc_closure *cb) {
-  trickle_endpoint *te = (trickle_endpoint *)ep;
+static void te_read(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep,
+                    grpc_slice_buffer* slices, grpc_closure* cb) {
+  trickle_endpoint* te = (trickle_endpoint*)ep;
   grpc_endpoint_read(exec_ctx, te->wrapped, slices, cb);
 }
 
-static void maybe_call_write_cb_locked(grpc_exec_ctx *exec_ctx,
-                                       trickle_endpoint *te) {
-  if (te->write_cb != NULL && (te->error != GRPC_ERROR_NONE ||
-                               te->write_buffer.length <= WRITE_BUFFER_SIZE)) {
+static void maybe_call_write_cb_locked(grpc_exec_ctx* exec_ctx,
+                                       trickle_endpoint* te) {
+  if (te->write_cb != nullptr &&
+      (te->error != GRPC_ERROR_NONE ||
+       te->write_buffer.length <= WRITE_BUFFER_SIZE)) {
     GRPC_CLOSURE_SCHED(exec_ctx, te->write_cb, GRPC_ERROR_REF(te->error));
-    te->write_cb = NULL;
+    te->write_cb = nullptr;
   }
 }
 
-static void te_write(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                     grpc_slice_buffer *slices, grpc_closure *cb) {
-  trickle_endpoint *te = (trickle_endpoint *)ep;
+static void te_write(grpc_exec_ctx* exec_ctx, 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);
+  GPR_ASSERT(te->write_cb == nullptr);
   if (te->write_buffer.length == 0) {
     te->last_write = gpr_now(GPR_CLOCK_MONOTONIC);
   }
@@ -77,21 +78,28 @@ static void te_write(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
   gpr_mu_unlock(&te->mu);
 }
 
-static void te_add_to_pollset(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                              grpc_pollset *pollset) {
-  trickle_endpoint *te = (trickle_endpoint *)ep;
+static void te_add_to_pollset(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep,
+                              grpc_pollset* pollset) {
+  trickle_endpoint* te = (trickle_endpoint*)ep;
   grpc_endpoint_add_to_pollset(exec_ctx, te->wrapped, pollset);
 }
 
-static void te_add_to_pollset_set(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                                  grpc_pollset_set *pollset_set) {
-  trickle_endpoint *te = (trickle_endpoint *)ep;
+static void te_add_to_pollset_set(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep,
+                                  grpc_pollset_set* pollset_set) {
+  trickle_endpoint* te = (trickle_endpoint*)ep;
   grpc_endpoint_add_to_pollset_set(exec_ctx, te->wrapped, pollset_set);
 }
 
-static void te_shutdown(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                        grpc_error *why) {
-  trickle_endpoint *te = (trickle_endpoint *)ep;
+static void te_delete_from_pollset_set(grpc_exec_ctx* exec_ctx,
+                                       grpc_endpoint* ep,
+                                       grpc_pollset_set* pollset_set) {
+  trickle_endpoint* te = (trickle_endpoint*)ep;
+  grpc_endpoint_delete_from_pollset_set(exec_ctx, te->wrapped, pollset_set);
+}
+
+static void te_shutdown(grpc_exec_ctx* exec_ctx, 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);
@@ -101,8 +109,8 @@ static void te_shutdown(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
   grpc_endpoint_shutdown(exec_ctx, te->wrapped, why);
 }
 
-static void te_destroy(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep) {
-  trickle_endpoint *te = (trickle_endpoint *)ep;
+static void te_destroy(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep) {
+  trickle_endpoint* te = (trickle_endpoint*)ep;
   grpc_endpoint_destroy(exec_ctx, te->wrapped);
   gpr_mu_destroy(&te->mu);
   grpc_slice_buffer_destroy_internal(exec_ctx, &te->write_buffer);
@@ -111,42 +119,48 @@ static void te_destroy(grpc_exec_ctx *exec_ctx, 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(grpc_exec_ctx *exec_ctx, void *arg,
-                            grpc_error *error) {
-  trickle_endpoint *te = (trickle_endpoint *)arg;
+static void te_finish_write(grpc_exec_ctx* exec_ctx, 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;
-  te->write_cb = NULL;
+  te->write_cb = nullptr;
   gpr_mu_init(&te->mu);
   grpc_slice_buffer_init(&te->write_buffer);
   grpc_slice_buffer_init(&te->writing_buffer);
@@ -159,9 +173,9 @@ static double ts2dbl(gpr_timespec s) {
   return (double)s.tv_sec + 1e-9 * (double)s.tv_nsec;
 }
 
-size_t grpc_trickle_endpoint_trickle(grpc_exec_ctx *exec_ctx,
-                                     grpc_endpoint *ep) {
-  trickle_endpoint *te = (trickle_endpoint *)ep;
+size_t grpc_trickle_endpoint_trickle(grpc_exec_ctx* exec_ctx,
+                                     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);
@@ -185,8 +199,8 @@ size_t grpc_trickle_endpoint_trickle(grpc_exec_ctx *exec_ctx,
   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 ca39638ba0..11c113bda8 100644
--- a/test/core/util/trickle_endpoint.h
+++ b/test/core/util/trickle_endpoint.h
@@ -21,21 +21,13 @@
 
 #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_exec_ctx *exec_ctx,
-                                     grpc_endpoint *endpoint);
-
-size_t grpc_trickle_get_backlog(grpc_endpoint *endpoint);
+size_t grpc_trickle_endpoint_trickle(grpc_exec_ctx* exec_ctx,
+                                     grpc_endpoint* endpoint);
 
-#ifdef __cplusplus
-}
-#endif  // __cplusplus
+size_t grpc_trickle_get_backlog(grpc_endpoint* endpoint);
 
 #endif
diff --git a/test/cpp/client/BUILD b/test/cpp/client/BUILD
new file mode 100644
index 0000000000..12825e88c2
--- /dev/null
+++ b/test/cpp/client/BUILD
@@ -0,0 +1,51 @@
+# Copyright 2017 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+licenses(["notice"])  # Apache v2
+
+load("//bazel:grpc_build_system.bzl", "grpc_cc_library", "grpc_cc_test", "grpc_package")
+
+grpc_package(name = "test/cpp/client")
+
+grpc_cc_test(
+    name = "credentials_test",
+    srcs = ["credentials_test.cc"],
+    external_deps = [
+        "gtest",
+    ],
+    deps = [
+        "//:gpr",
+        "//:grpc",
+        "//:grpc++",
+    ],
+)
+
+grpc_cc_test(
+    name = "client_channel_stress_test",
+    srcs = ["client_channel_stress_test.cc"],
+    deps = [
+        "//:gpr",
+        "//:grpc",
+        "//:grpc++",
+        "//:grpc_resolver_fake",
+        "//src/proto/grpc/lb/v1:load_balancer_proto",
+        "//src/proto/grpc/testing:echo_messages_proto",
+        "//src/proto/grpc/testing:echo_proto",
+        "//src/proto/grpc/testing/duplicate:echo_duplicate_proto",
+        "//test/core/util:gpr_test_util",
+        "//test/core/util:grpc_test_util",
+        "//test/cpp/end2end:test_service_impl",
+        "//test/cpp/util:test_util",
+    ],
+)
diff --git a/test/cpp/client/client_channel_stress_test.cc b/test/cpp/client/client_channel_stress_test.cc
new file mode 100644
index 0000000000..8940f6ff9e
--- /dev/null
+++ b/test/cpp/client/client_channel_stress_test.cc
@@ -0,0 +1,329 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <atomic>
+#include <memory>
+#include <mutex>
+#include <sstream>
+#include <thread>
+
+#include <grpc++/channel.h>
+#include <grpc++/client_context.h>
+#include <grpc++/create_channel.h>
+#include <grpc++/server.h>
+#include <grpc++/server_builder.h>
+#include <grpc/grpc.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
+#include <grpc/support/thd.h>
+#include <grpc/support/time.h>
+
+extern "C" {
+#include "src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h"
+#include "src/core/lib/iomgr/sockaddr.h"
+}
+
+#include "test/core/util/port.h"
+#include "test/core/util/test_config.h"
+#include "test/cpp/end2end/test_service_impl.h"
+
+#include "src/proto/grpc/lb/v1/load_balancer.grpc.pb.h"
+#include "src/proto/grpc/testing/echo.grpc.pb.h"
+
+using grpc::lb::v1::LoadBalanceRequest;
+using grpc::lb::v1::LoadBalanceResponse;
+using grpc::lb::v1::LoadBalancer;
+
+namespace grpc {
+namespace testing {
+namespace {
+
+const size_t kNumBackends = 10;
+const size_t kNumBalancers = 5;
+const size_t kNumClientThreads = 100;
+const int kResolutionUpdateIntervalMs = 50;
+const int kServerlistUpdateIntervalMs = 10;
+const int kTestDurationSec = 30;
+
+using BackendServiceImpl = TestServiceImpl;
+
+class BalancerServiceImpl : public LoadBalancer::Service {
+ public:
+  using Stream = ServerReaderWriter<LoadBalanceResponse, LoadBalanceRequest>;
+
+  explicit BalancerServiceImpl(const std::vector<int>& all_backend_ports)
+      : all_backend_ports_(all_backend_ports) {}
+
+  Status BalanceLoad(ServerContext* context, Stream* stream) override {
+    gpr_log(GPR_INFO, "LB[%p]: Start BalanceLoad.", this);
+    LoadBalanceRequest request;
+    stream->Read(&request);
+    while (!shutdown_) {
+      stream->Write(BuildRandomResponseForBackends());
+      std::this_thread::sleep_for(
+          std::chrono::milliseconds(kServerlistUpdateIntervalMs));
+    }
+    gpr_log(GPR_INFO, "LB[%p]: Finish BalanceLoad.", this);
+    return Status::OK;
+  }
+
+  void Shutdown() { shutdown_ = true; }
+
+ private:
+  grpc::string Ip4ToPackedString(const char* ip_str) {
+    struct in_addr ip4;
+    GPR_ASSERT(inet_pton(AF_INET, ip_str, &ip4) == 1);
+    return grpc::string(reinterpret_cast<const char*>(&ip4), sizeof(ip4));
+  }
+
+  LoadBalanceResponse BuildRandomResponseForBackends() {
+    // Generate a random serverlist with varying size (if N =
+    // all_backend_ports_.size(), num_non_drop_entry is in [0, 2N],
+    // num_drop_entry is in [0, N]), order, duplicate, and drop rate.
+    size_t num_non_drop_entry =
+        std::rand() % (all_backend_ports_.size() * 2 + 1);
+    size_t num_drop_entry = std::rand() % (all_backend_ports_.size() + 1);
+    std::vector<int> random_backend_indices;
+    for (size_t i = 0; i < num_non_drop_entry; ++i) {
+      random_backend_indices.push_back(std::rand() % all_backend_ports_.size());
+    }
+    for (size_t i = 0; i < num_drop_entry; ++i) {
+      random_backend_indices.push_back(-1);
+    }
+    std::random_shuffle(random_backend_indices.begin(),
+                        random_backend_indices.end());
+    // Build the response according to the random list generated above.
+    LoadBalanceResponse response;
+    for (int index : random_backend_indices) {
+      auto* server = response.mutable_server_list()->add_servers();
+      if (index < 0) {
+        server->set_drop(true);
+        server->set_load_balance_token("load_balancing");
+      } else {
+        server->set_ip_address(Ip4ToPackedString("127.0.0.1"));
+        server->set_port(all_backend_ports_[index]);
+      }
+    }
+    return response;
+  }
+
+  std::atomic_bool shutdown_{false};
+  const std::vector<int> all_backend_ports_;
+};
+
+class ClientChannelStressTest {
+ public:
+  void Run() {
+    Start();
+    // Keep updating resolution for the test duration.
+    gpr_log(GPR_INFO, "Start updating resolution.");
+    const auto wait_duration =
+        std::chrono::milliseconds(kResolutionUpdateIntervalMs);
+    std::vector<AddressData> addresses;
+    auto start_time = std::chrono::steady_clock::now();
+    while (true) {
+      if (std::chrono::duration_cast<std::chrono::seconds>(
+              std::chrono::steady_clock::now() - start_time)
+              .count() > kTestDurationSec) {
+        break;
+      }
+      // Generate a random subset of balancers.
+      addresses.clear();
+      for (const auto& balancer_server : balancer_servers_) {
+        // Select each address with probability of 0.8.
+        if (std::rand() % 10 < 8) {
+          addresses.emplace_back(AddressData{balancer_server.port_, true, ""});
+        }
+      }
+      std::random_shuffle(addresses.begin(), addresses.end());
+      SetNextResolution(addresses);
+      std::this_thread::sleep_for(wait_duration);
+    }
+    gpr_log(GPR_INFO, "Finish updating resolution.");
+    Shutdown();
+  }
+
+ private:
+  template <typename T>
+  struct ServerThread {
+    explicit ServerThread(const grpc::string& type,
+                          const grpc::string& server_host, T* service)
+        : type_(type), service_(service) {
+      std::mutex mu;
+      // We need to acquire the lock here in order to prevent the notify_one
+      // by ServerThread::Start from firing before the wait below is hit.
+      std::unique_lock<std::mutex> lock(mu);
+      port_ = grpc_pick_unused_port_or_die();
+      gpr_log(GPR_INFO, "starting %s server on port %d", type_.c_str(), port_);
+      std::condition_variable cond;
+      thread_.reset(new std::thread(
+          std::bind(&ServerThread::Start, this, server_host, &mu, &cond)));
+      cond.wait(lock);
+      gpr_log(GPR_INFO, "%s server startup complete", type_.c_str());
+    }
+
+    void Start(const grpc::string& server_host, std::mutex* mu,
+               std::condition_variable* cond) {
+      // We need to acquire the lock here in order to prevent the notify_one
+      // below from firing before its corresponding wait is executed.
+      std::lock_guard<std::mutex> lock(*mu);
+      std::ostringstream server_address;
+      server_address << server_host << ":" << port_;
+      ServerBuilder builder;
+      builder.AddListeningPort(server_address.str(),
+                               InsecureServerCredentials());
+      builder.RegisterService(service_);
+      server_ = builder.BuildAndStart();
+      cond->notify_one();
+    }
+
+    void Shutdown() {
+      gpr_log(GPR_INFO, "%s about to shutdown", type_.c_str());
+      server_->Shutdown(grpc_timeout_milliseconds_to_deadline(0));
+      thread_->join();
+      gpr_log(GPR_INFO, "%s shutdown completed", type_.c_str());
+    }
+
+    int port_;
+    grpc::string type_;
+    std::unique_ptr<Server> server_;
+    T* service_;
+    std::unique_ptr<std::thread> thread_;
+  };
+
+  struct AddressData {
+    int port;
+    bool is_balancer;
+    grpc::string balancer_name;
+  };
+
+  void SetNextResolution(const std::vector<AddressData>& address_data) {
+    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+    grpc_lb_addresses* addresses =
+        grpc_lb_addresses_create(address_data.size(), nullptr);
+    for (size_t i = 0; i < address_data.size(); ++i) {
+      char* lb_uri_str;
+      gpr_asprintf(&lb_uri_str, "ipv4:127.0.0.1:%d", address_data[i].port);
+      grpc_uri* lb_uri = grpc_uri_parse(&exec_ctx, lb_uri_str, true);
+      GPR_ASSERT(lb_uri != nullptr);
+      grpc_lb_addresses_set_address_from_uri(
+          addresses, i, lb_uri, address_data[i].is_balancer,
+          address_data[i].balancer_name.c_str(), nullptr);
+      grpc_uri_destroy(lb_uri);
+      gpr_free(lb_uri_str);
+    }
+    grpc_arg fake_addresses = grpc_lb_addresses_create_channel_arg(addresses);
+    grpc_channel_args fake_result = {1, &fake_addresses};
+    grpc_fake_resolver_response_generator_set_response(
+        &exec_ctx, response_generator_, &fake_result);
+    grpc_lb_addresses_destroy(&exec_ctx, addresses);
+    grpc_exec_ctx_finish(&exec_ctx);
+  }
+
+  void KeepSendingRequests() {
+    gpr_log(GPR_INFO, "Start sending requests.");
+    while (!shutdown_) {
+      ClientContext context;
+      context.set_deadline(grpc_timeout_milliseconds_to_deadline(1000));
+      EchoRequest request;
+      request.set_message("test");
+      EchoResponse response;
+      {
+        std::lock_guard<std::mutex> lock(stub_mutex_);
+        stub_->Echo(&context, request, &response);
+      }
+    }
+    gpr_log(GPR_INFO, "Finish sending requests.");
+  }
+
+  void CreateStub() {
+    ChannelArguments args;
+    response_generator_ = grpc_fake_resolver_response_generator_create();
+    args.SetPointer(GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR,
+                    response_generator_);
+    std::ostringstream uri;
+    uri << "fake:///servername_not_used";
+    channel_ =
+        CreateCustomChannel(uri.str(), InsecureChannelCredentials(), args);
+    stub_ = grpc::testing::EchoTestService::NewStub(channel_);
+  }
+
+  void Start() {
+    // Start the backends.
+    std::vector<int> backend_ports;
+    for (size_t i = 0; i < kNumBackends; ++i) {
+      backends_.emplace_back(new BackendServiceImpl());
+      backend_servers_.emplace_back(ServerThread<BackendServiceImpl>(
+          "backend", server_host_, backends_.back().get()));
+      backend_ports.push_back(backend_servers_.back().port_);
+    }
+    // Start the load balancers.
+    for (size_t i = 0; i < kNumBalancers; ++i) {
+      balancers_.emplace_back(new BalancerServiceImpl(backend_ports));
+      balancer_servers_.emplace_back(ServerThread<BalancerServiceImpl>(
+          "balancer", server_host_, balancers_.back().get()));
+    }
+    // Start sending RPCs in multiple threads.
+    CreateStub();
+    for (size_t i = 0; i < kNumClientThreads; ++i) {
+      client_threads_.emplace_back(
+          std::thread(&ClientChannelStressTest::KeepSendingRequests, this));
+    }
+  }
+
+  void Shutdown() {
+    shutdown_ = true;
+    for (size_t i = 0; i < client_threads_.size(); ++i) {
+      client_threads_[i].join();
+    }
+    for (size_t i = 0; i < balancers_.size(); ++i) {
+      balancers_[i]->Shutdown();
+      balancer_servers_[i].Shutdown();
+    }
+    for (size_t i = 0; i < backends_.size(); ++i) {
+      backend_servers_[i].Shutdown();
+    }
+    grpc_fake_resolver_response_generator_unref(response_generator_);
+  }
+
+  std::atomic_bool shutdown_{false};
+  const grpc::string server_host_ = "localhost";
+  std::shared_ptr<Channel> channel_;
+  std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_;
+  std::mutex stub_mutex_;
+  std::vector<std::unique_ptr<BackendServiceImpl>> backends_;
+  std::vector<std::unique_ptr<BalancerServiceImpl>> balancers_;
+  std::vector<ServerThread<BackendServiceImpl>> backend_servers_;
+  std::vector<ServerThread<BalancerServiceImpl>> balancer_servers_;
+  grpc_fake_resolver_response_generator* response_generator_;
+  std::vector<std::thread> client_threads_;
+};
+
+}  // namespace
+}  // namespace testing
+}  // namespace grpc
+
+int main(int argc, char** argv) {
+  grpc_init();
+  grpc_test_init(argc, argv);
+  grpc::testing::ClientChannelStressTest test;
+  test.Run();
+  grpc_shutdown();
+  return 0;
+}
diff --git a/test/cpp/codegen/BUILD b/test/cpp/codegen/BUILD
index 8de46be816..6cc81e3398 100644
--- a/test/cpp/codegen/BUILD
+++ b/test/cpp/codegen/BUILD
@@ -51,6 +51,7 @@ grpc_cc_test(
     ],
     external_deps = [
         "gtest",
+        "protobuf",
     ],
 )
 
diff --git a/test/cpp/codegen/compiler_test_golden b/test/cpp/codegen/compiler_test_golden
index 3d664e8825..026a94112a 100644
--- a/test/cpp/codegen/compiler_test_golden
+++ b/test/cpp/codegen/compiler_test_golden
@@ -39,7 +39,6 @@
 namespace grpc {
 class CompletionQueue;
 class Channel;
-class RpcService;
 class ServerCompletionQueue;
 class ServerContext;
 }  // namespace grpc
@@ -169,10 +168,10 @@ class ServiceA final {
     ::grpc::ClientReaderWriter< ::grpc::testing::Request, ::grpc::testing::Response>* MethodA4Raw(::grpc::ClientContext* context) override;
     ::grpc::ClientAsyncReaderWriter< ::grpc::testing::Request, ::grpc::testing::Response>* AsyncMethodA4Raw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override;
     ::grpc::ClientAsyncReaderWriter< ::grpc::testing::Request, ::grpc::testing::Response>* PrepareAsyncMethodA4Raw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override;
-    const ::grpc::RpcMethod rpcmethod_MethodA1_;
-    const ::grpc::RpcMethod rpcmethod_MethodA2_;
-    const ::grpc::RpcMethod rpcmethod_MethodA3_;
-    const ::grpc::RpcMethod rpcmethod_MethodA4_;
+    const ::grpc::internal::RpcMethod rpcmethod_MethodA1_;
+    const ::grpc::internal::RpcMethod rpcmethod_MethodA2_;
+    const ::grpc::internal::RpcMethod rpcmethod_MethodA3_;
+    const ::grpc::internal::RpcMethod rpcmethod_MethodA4_;
   };
   static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
 
@@ -352,7 +351,7 @@ class ServiceA final {
    public:
     WithStreamedUnaryMethod_MethodA1() {
       ::grpc::Service::MarkMethodStreamed(0,
-        new ::grpc::StreamedUnaryHandler< ::grpc::testing::Request, ::grpc::testing::Response>(std::bind(&WithStreamedUnaryMethod_MethodA1<BaseClass>::StreamedMethodA1, this, std::placeholders::_1, std::placeholders::_2)));
+        new ::grpc::internal::StreamedUnaryHandler< ::grpc::testing::Request, ::grpc::testing::Response>(std::bind(&WithStreamedUnaryMethod_MethodA1<BaseClass>::StreamedMethodA1, this, std::placeholders::_1, std::placeholders::_2)));
     }
     ~WithStreamedUnaryMethod_MethodA1() override {
       BaseClassMustBeDerivedFromService(this);
@@ -373,7 +372,7 @@ class ServiceA final {
    public:
     WithSplitStreamingMethod_MethodA3() {
       ::grpc::Service::MarkMethodStreamed(2,
-        new ::grpc::SplitServerStreamingHandler< ::grpc::testing::Request, ::grpc::testing::Response>(std::bind(&WithSplitStreamingMethod_MethodA3<BaseClass>::StreamedMethodA3, this, std::placeholders::_1, std::placeholders::_2)));
+        new ::grpc::internal::SplitServerStreamingHandler< ::grpc::testing::Request, ::grpc::testing::Response>(std::bind(&WithSplitStreamingMethod_MethodA3<BaseClass>::StreamedMethodA3, this, std::placeholders::_1, std::placeholders::_2)));
     }
     ~WithSplitStreamingMethod_MethodA3() override {
       BaseClassMustBeDerivedFromService(this);
@@ -427,7 +426,7 @@ class ServiceB final {
     std::shared_ptr< ::grpc::ChannelInterface> channel_;
     ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>* AsyncMethodB1Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) override;
     ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>* PrepareAsyncMethodB1Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) override;
-    const ::grpc::RpcMethod rpcmethod_MethodB1_;
+    const ::grpc::internal::RpcMethod rpcmethod_MethodB1_;
   };
   static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
 
@@ -484,7 +483,7 @@ class ServiceB final {
    public:
     WithStreamedUnaryMethod_MethodB1() {
       ::grpc::Service::MarkMethodStreamed(0,
-        new ::grpc::StreamedUnaryHandler< ::grpc::testing::Request, ::grpc::testing::Response>(std::bind(&WithStreamedUnaryMethod_MethodB1<BaseClass>::StreamedMethodB1, this, std::placeholders::_1, std::placeholders::_2)));
+        new ::grpc::internal::StreamedUnaryHandler< ::grpc::testing::Request, ::grpc::testing::Response>(std::bind(&WithStreamedUnaryMethod_MethodB1<BaseClass>::StreamedMethodB1, this, std::placeholders::_1, std::placeholders::_2)));
     }
     ~WithStreamedUnaryMethod_MethodB1() override {
       BaseClassMustBeDerivedFromService(this);
diff --git a/test/cpp/codegen/golden_file_test.cc b/test/cpp/codegen/golden_file_test.cc
index 5df1b8a16b..14880982b5 100644
--- a/test/cpp/codegen/golden_file_test.cc
+++ b/test/cpp/codegen/golden_file_test.cc
@@ -58,7 +58,7 @@ TEST(GoldenMockFileTest, TestGeneratedMockFile) {
            kMockGoldenFilePath);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   ::testing::InitGoogleTest(&argc, argv);
   ::google::ParseCommandLineFlags(&argc, &argv, true);
   if (FLAGS_generated_file_path.empty()) {
diff --git a/test/cpp/codegen/proto_utils_test.cc b/test/cpp/codegen/proto_utils_test.cc
index fd05c90e9d..cc355bb24a 100644
--- a/test/cpp/codegen/proto_utils_test.cc
+++ b/test/cpp/codegen/proto_utils_test.cc
@@ -16,15 +16,16 @@
  *
  */
 
+#include <grpc++/impl/codegen/grpc_library.h>
 #include <grpc++/impl/codegen/proto_utils.h>
 #include <grpc++/impl/grpc_library.h>
+#include <grpc/impl/codegen/byte_buffer.h>
+#include <grpc/slice.h>
 #include <gtest/gtest.h>
 
 namespace grpc {
 namespace internal {
 
-static GrpcLibraryInitializer g_gli_initializer;
-
 // Provide access to GrpcBufferWriter internals.
 class GrpcBufferWriterPeer {
  public:
@@ -44,35 +45,120 @@ class ProtoUtilsTest : public ::testing::Test {};
 // GrpcBufferWriter Next()/Backup() invocations could result in a dangling
 // pointer returned by Next() due to the interaction between grpc_slice inlining
 // and GRPC_SLICE_START_PTR.
-TEST_F(ProtoUtilsTest, BackupNext) {
-  // Ensure the GrpcBufferWriter internals are initialized.
-  g_gli_initializer.summon();
-
+TEST_F(ProtoUtilsTest, TinyBackupThenNext) {
   grpc_byte_buffer* bp;
-  GrpcBufferWriter writer(&bp, 8192);
+  const int block_size = 1024;
+  GrpcBufferWriter writer(&bp, block_size, 8192);
   GrpcBufferWriterPeer peer(&writer);
 
   void* data;
   int size;
   // Allocate a slice.
   ASSERT_TRUE(writer.Next(&data, &size));
-  EXPECT_EQ(8192, size);
-  // Return a single byte. Before the fix that this test acts as a regression
-  // for, this would have resulted in an inlined backup slice.
+  EXPECT_EQ(block_size, size);
+  // Return a single byte.
   writer.BackUp(1);
-  EXPECT_TRUE(!peer.have_backup());
-  // On the next allocation, the slice is non-inlined.
+  EXPECT_FALSE(peer.have_backup());
+  // On the next allocation, the returned slice is non-inlined.
   ASSERT_TRUE(writer.Next(&data, &size));
-  EXPECT_TRUE(peer.slice().refcount != NULL);
+  EXPECT_TRUE(peer.slice().refcount != nullptr);
+  EXPECT_EQ(block_size, size);
 
   // Cleanup.
   g_core_codegen_interface->grpc_byte_buffer_destroy(bp);
 }
 
+namespace {
+
+// Set backup_size to 0 to indicate no backup is needed.
+void BufferWriterTest(int block_size, int total_size, int backup_size) {
+  grpc_byte_buffer* bp;
+  GrpcBufferWriter writer(&bp, block_size, total_size);
+
+  int written_size = 0;
+  void* data;
+  int size = 0;
+  bool backed_up_entire_slice = false;
+
+  while (written_size < total_size) {
+    EXPECT_TRUE(writer.Next(&data, &size));
+    EXPECT_GT(size, 0);
+    EXPECT_TRUE(data);
+    int write_size = size;
+    bool should_backup = false;
+    if (backup_size > 0 && size > backup_size) {
+      write_size = size - backup_size;
+      should_backup = true;
+    } else if (size == backup_size && !backed_up_entire_slice) {
+      // only backup entire slice once.
+      backed_up_entire_slice = true;
+      should_backup = true;
+      write_size = 0;
+    }
+    // May need a last backup.
+    if (write_size + written_size > total_size) {
+      write_size = total_size - written_size;
+      should_backup = true;
+      backup_size = size - write_size;
+      ASSERT_GT(backup_size, 0);
+    }
+    for (int i = 0; i < write_size; i++) {
+      ((uint8_t*)data)[i] = written_size % 128;
+      written_size++;
+    }
+    if (should_backup) {
+      writer.BackUp(backup_size);
+    }
+  }
+  EXPECT_EQ(grpc_byte_buffer_length(bp), (size_t)total_size);
+
+  grpc_byte_buffer_reader reader;
+  grpc_byte_buffer_reader_init(&reader, bp);
+  int read_bytes = 0;
+  while (read_bytes < total_size) {
+    grpc_slice s;
+    EXPECT_TRUE(grpc_byte_buffer_reader_next(&reader, &s));
+    for (size_t i = 0; i < GRPC_SLICE_LENGTH(s); i++) {
+      EXPECT_EQ(GRPC_SLICE_START_PTR(s)[i], read_bytes % 128);
+      read_bytes++;
+    }
+    grpc_slice_unref(s);
+  }
+  EXPECT_EQ(read_bytes, total_size);
+  grpc_byte_buffer_reader_destroy(&reader);
+  grpc_byte_buffer_destroy(bp);
+}
+
+TEST(WriterTest, TinyBlockTinyBackup) {
+  for (int i = 2; i < (int)GRPC_SLICE_INLINED_SIZE; i++) {
+    BufferWriterTest(i, 256, 1);
+  }
+}
+
+TEST(WriterTest, SmallBlockTinyBackup) { BufferWriterTest(64, 256, 1); }
+
+TEST(WriterTest, SmallBlockNoBackup) { BufferWriterTest(64, 256, 0); }
+
+TEST(WriterTest, SmallBlockFullBackup) { BufferWriterTest(64, 256, 64); }
+
+TEST(WriterTest, LargeBlockTinyBackup) { BufferWriterTest(4096, 8192, 1); }
+
+TEST(WriterTest, LargeBlockNoBackup) { BufferWriterTest(4096, 8192, 0); }
+
+TEST(WriterTest, LargeBlockFullBackup) { BufferWriterTest(4096, 8192, 4096); }
+
+TEST(WriterTest, LargeBlockLargeBackup) { BufferWriterTest(4096, 8192, 4095); }
+
+}  // namespace
 }  // namespace internal
 }  // namespace grpc
 
 int main(int argc, char** argv) {
+  // Ensure the GrpcBufferWriter internals are initialized.
+  grpc::internal::GrpcLibraryInitializer init;
+  init.summon();
+  grpc::GrpcLibraryCodegen lib;
+
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }
diff --git a/test/cpp/common/auth_property_iterator_test.cc b/test/cpp/common/auth_property_iterator_test.cc
index e25d2a7597..fce409aa2f 100644
--- a/test/cpp/common/auth_property_iterator_test.cc
+++ b/test/cpp/common/auth_property_iterator_test.cc
@@ -22,9 +22,7 @@
 #include "src/cpp/common/secure_auth_context.h"
 #include "test/cpp/util/string_ref_helper.h"
 
-extern "C" {
 #include "src/core/lib/security/context/security_context.h"
-}
 
 using ::grpc::testing::ToString;
 
@@ -42,7 +40,7 @@ class TestAuthPropertyIterator : public AuthPropertyIterator {
 class AuthPropertyIteratorTest : public ::testing::Test {
  protected:
   void SetUp() override {
-    ctx_ = grpc_auth_context_create(NULL);
+    ctx_ = grpc_auth_context_create(nullptr);
     grpc_auth_context_add_cstring_property(ctx_, "name", "chapi");
     grpc_auth_context_add_cstring_property(ctx_, "name", "chapo");
     grpc_auth_context_add_cstring_property(ctx_, "foo", "bar");
diff --git a/test/cpp/common/channel_arguments_test.cc b/test/cpp/common/channel_arguments_test.cc
index cfe64f11b1..d6ed2e5aa2 100644
--- a/test/cpp/common/channel_arguments_test.cc
+++ b/test/cpp/common/channel_arguments_test.cc
@@ -23,10 +23,8 @@
 #include <grpc/support/useful.h>
 #include <gtest/gtest.h>
 
-extern "C" {
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/socket_mutator.h"
-}
 
 namespace grpc {
 namespace testing {
@@ -72,7 +70,7 @@ grpc_socket_mutator_vtable test_mutator_vtable = {
 TestSocketMutator::TestSocketMutator() {
   grpc_socket_mutator_init(this, &test_mutator_vtable);
 }
-}
+}  // namespace
 
 class ChannelArgumentsTest : public ::testing::Test {
  protected:
diff --git a/test/cpp/common/secure_auth_context_test.cc b/test/cpp/common/secure_auth_context_test.cc
index 91c7a3b5df..7a0530c20a 100644
--- a/test/cpp/common/secure_auth_context_test.cc
+++ b/test/cpp/common/secure_auth_context_test.cc
@@ -22,9 +22,7 @@
 #include <gtest/gtest.h>
 #include "test/cpp/util/string_ref_helper.h"
 
-extern "C" {
 #include "src/core/lib/security/context/security_context.h"
-}
 
 using grpc::testing::ToString;
 
@@ -44,7 +42,7 @@ TEST_F(SecureAuthContextTest, EmptyContext) {
 }
 
 TEST_F(SecureAuthContextTest, Properties) {
-  grpc_auth_context* ctx = grpc_auth_context_create(NULL);
+  grpc_auth_context* ctx = grpc_auth_context_create(nullptr);
   SecureAuthContext context(ctx, true);
   context.AddProperty("name", "chapi");
   context.AddProperty("name", "chapo");
@@ -62,7 +60,7 @@ TEST_F(SecureAuthContextTest, Properties) {
 }
 
 TEST_F(SecureAuthContextTest, Iterators) {
-  grpc_auth_context* ctx = grpc_auth_context_create(NULL);
+  grpc_auth_context* ctx = grpc_auth_context_create(nullptr);
   SecureAuthContext context(ctx, true);
   context.AddProperty("name", "chapi");
   context.AddProperty("name", "chapo");
diff --git a/test/cpp/end2end/async_end2end_test.cc b/test/cpp/end2end/async_end2end_test.cc
index 2a33e8ae11..1ea087e706 100644
--- a/test/cpp/end2end/async_end2end_test.cc
+++ b/test/cpp/end2end/async_end2end_test.cc
@@ -28,12 +28,14 @@
 #include <grpc++/server_builder.h>
 #include <grpc++/server_context.h>
 #include <grpc/grpc.h>
+#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/thd.h>
 #include <grpc/support/time.h>
 #include <grpc/support/tls.h>
 
 #include "src/core/lib/iomgr/port.h"
+#include "src/core/lib/support/env.h"
 #include "src/proto/grpc/health/v1/health.grpc.pb.h"
 #include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h"
 #include "src/proto/grpc/testing/echo.grpc.pb.h"
@@ -99,7 +101,7 @@ class PollingOverrider {
 
 class Verifier {
  public:
-  explicit Verifier(bool spin) : spin_(spin) {}
+  explicit Verifier(bool spin) : spin_(spin), lambda_run_(false) {}
   // Expect sets the expected ok value for a specific tag
   Verifier& Expect(int i, bool expect_ok) {
     return ExpectUnless(i, expect_ok, false);
@@ -142,6 +144,18 @@ class Verifier {
     return detag(got_tag);
   }
 
+  template <typename T>
+  CompletionQueue::NextStatus DoOnceThenAsyncNext(
+      CompletionQueue* cq, void** got_tag, bool* ok, T deadline,
+      std::function<void(void)> lambda) {
+    if (lambda_run_) {
+      return cq->AsyncNext(got_tag, ok, deadline);
+    } else {
+      lambda_run_ = true;
+      return cq->DoThenAsyncNext(lambda, got_tag, ok, deadline);
+    }
+  }
+
   // Verify keeps calling Next until all currently set
   // expected tags are complete
   void Verify(CompletionQueue* cq) { Verify(cq, false); }
@@ -154,6 +168,7 @@ class Verifier {
       Next(cq, ignore_ok);
     }
   }
+
   // This version of Verify stops after a certain deadline
   void Verify(CompletionQueue* cq,
               std::chrono::system_clock::time_point deadline) {
@@ -193,6 +208,47 @@ class Verifier {
     }
   }
 
+  // This version of Verify stops after a certain deadline, and uses the
+  // DoThenAsyncNext API
+  // to call the lambda
+  void Verify(CompletionQueue* cq,
+              std::chrono::system_clock::time_point deadline,
+              std::function<void(void)> lambda) {
+    if (expectations_.empty()) {
+      bool ok;
+      void* got_tag;
+      if (spin_) {
+        while (std::chrono::system_clock::now() < deadline) {
+          EXPECT_EQ(DoOnceThenAsyncNext(cq, &got_tag, &ok, deadline, lambda),
+                    CompletionQueue::TIMEOUT);
+        }
+      } else {
+        EXPECT_EQ(DoOnceThenAsyncNext(cq, &got_tag, &ok, deadline, lambda),
+                  CompletionQueue::TIMEOUT);
+      }
+    } else {
+      while (!expectations_.empty()) {
+        bool ok;
+        void* got_tag;
+        if (spin_) {
+          for (;;) {
+            GPR_ASSERT(std::chrono::system_clock::now() < deadline);
+            auto r = DoOnceThenAsyncNext(
+                cq, &got_tag, &ok, gpr_time_0(GPR_CLOCK_REALTIME), lambda);
+            if (r == CompletionQueue::TIMEOUT) continue;
+            if (r == CompletionQueue::GOT_EVENT) break;
+            gpr_log(GPR_ERROR, "unexpected result from AsyncNext");
+            abort();
+          }
+        } else {
+          EXPECT_EQ(DoOnceThenAsyncNext(cq, &got_tag, &ok, deadline, lambda),
+                    CompletionQueue::GOT_EVENT);
+        }
+        GotTag(got_tag, ok, false);
+      }
+    }
+  }
+
  private:
   void GotTag(void* got_tag, bool ok, bool ignore_ok) {
     auto it = expectations_.find(got_tag);
@@ -226,6 +282,7 @@ class Verifier {
   std::map<void*, bool> expectations_;
   std::map<void*, MaybeExpect> maybe_expectations_;
   bool spin_;
+  bool lambda_run_;
 };
 
 bool plugin_has_sync_methods(std::unique_ptr<ServerBuilderPlugin>& plugin) {
@@ -401,9 +458,18 @@ TEST_P(AsyncEnd2endTest, SequentialRpcs) {
 }
 
 TEST_P(AsyncEnd2endTest, ReconnectChannel) {
+  // GRPC_CLIENT_CHANNEL_BACKUP_POLL_INTERVAL_MS is set to 100ms in main()
   if (GetParam().inproc) {
     return;
   }
+  int poller_slowdown_factor = 1;
+  // It needs 2 pollset_works to reconnect the channel with polling engine
+  // "poll"
+  char* s = gpr_getenv("GRPC_POLL_STRATEGY");
+  if (s != nullptr && 0 == strcmp(s, "poll")) {
+    poller_slowdown_factor = 2;
+  }
+  gpr_free(s);
   ResetStub();
   SendRpc(1);
   server_->Shutdown();
@@ -413,10 +479,13 @@ TEST_P(AsyncEnd2endTest, ReconnectChannel) {
   while (cq_->Next(&ignored_tag, &ignored_ok))
     ;
   BuildAndStartServer();
-  // It needs more than kConnectivityCheckIntervalMsec time to reconnect the
-  // channel.
-  gpr_sleep_until(gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
-                               gpr_time_from_millis(1600, GPR_TIMESPAN)));
+  // It needs more than GRPC_CLIENT_CHANNEL_BACKUP_POLL_INTERVAL_MS time to
+  // reconnect the channel.
+  gpr_sleep_until(gpr_time_add(
+      gpr_now(GPR_CLOCK_REALTIME),
+      gpr_time_from_millis(
+          300 * poller_slowdown_factor * grpc_test_slowdown_factor(),
+          GPR_TIMESPAN)));
   SendRpc(1);
 }
 
@@ -490,6 +559,60 @@ TEST_P(AsyncEnd2endTest, AsyncNextRpc) {
   EXPECT_TRUE(recv_status.ok());
 }
 
+// Test a simple RPC using the async version of Next
+TEST_P(AsyncEnd2endTest, DoThenAsyncNextRpc) {
+  ResetStub();
+
+  EchoRequest send_request;
+  EchoRequest recv_request;
+  EchoResponse send_response;
+  EchoResponse recv_response;
+  Status recv_status;
+
+  ClientContext cli_ctx;
+  ServerContext srv_ctx;
+  grpc::ServerAsyncResponseWriter<EchoResponse> response_writer(&srv_ctx);
+
+  send_request.set_message(GetParam().message_content);
+  std::unique_ptr<ClientAsyncResponseReader<EchoResponse>> response_reader(
+      stub_->AsyncEcho(&cli_ctx, send_request, cq_.get()));
+
+  std::chrono::system_clock::time_point time_now(
+      std::chrono::system_clock::now());
+  std::chrono::system_clock::time_point time_limit(
+      std::chrono::system_clock::now() + std::chrono::seconds(10));
+  Verifier(GetParam().disable_blocking).Verify(cq_.get(), time_now);
+  Verifier(GetParam().disable_blocking).Verify(cq_.get(), time_now);
+
+  auto resp_writer_ptr = &response_writer;
+  auto lambda_2 = [&, this, resp_writer_ptr]() {
+    gpr_log(GPR_ERROR, "CALLED");
+    service_->RequestEcho(&srv_ctx, &recv_request, resp_writer_ptr, cq_.get(),
+                          cq_.get(), tag(2));
+  };
+
+  Verifier(GetParam().disable_blocking)
+      .Expect(2, true)
+      .Verify(cq_.get(), time_limit, lambda_2);
+  EXPECT_EQ(send_request.message(), recv_request.message());
+
+  auto recv_resp_ptr = &recv_response;
+  auto status_ptr = &recv_status;
+  send_response.set_message(recv_request.message());
+  auto lambda_3 = [&, this, resp_writer_ptr, send_response]() {
+    resp_writer_ptr->Finish(send_response, Status::OK, tag(3));
+  };
+  response_reader->Finish(recv_resp_ptr, status_ptr, tag(4));
+  Verifier(GetParam().disable_blocking)
+      .Expect(3, true)
+      .Expect(4, true)
+      .Verify(cq_.get(), std::chrono::system_clock::time_point::max(),
+              lambda_3);
+
+  EXPECT_EQ(send_response.message(), recv_response.message());
+  EXPECT_TRUE(recv_status.ok());
+}
+
 // Two pings and a final pong.
 TEST_P(AsyncEnd2endTest, SimpleClientStreaming) {
   ResetStub();
@@ -1890,6 +2013,9 @@ INSTANTIATE_TEST_CASE_P(AsyncEnd2endServerTryCancel,
 }  // namespace grpc
 
 int main(int argc, char** argv) {
+  // Change the backup poll interval from 5s to 100ms to speed up the
+  // ReconnectChannel test
+  gpr_setenv("GRPC_CLIENT_CHANNEL_BACKUP_POLL_INTERVAL_MS", "100");
   grpc_test_init(argc, argv);
   gpr_tls_init(&g_is_async_end2end_test);
   ::testing::InitGoogleTest(&argc, argv);
diff --git a/test/cpp/end2end/client_crash_test.cc b/test/cpp/end2end/client_crash_test.cc
index 4d2304feca..f34b27511b 100644
--- a/test/cpp/end2end/client_crash_test.cc
+++ b/test/cpp/end2end/client_crash_test.cc
@@ -56,7 +56,8 @@ class CrashTest : public ::testing::Test {
     addr_stream << "localhost:" << port;
     auto addr = addr_stream.str();
     server_.reset(new SubProcess({
-        g_root + "/client_crash_test_server", "--address=" + addr,
+        g_root + "/client_crash_test_server",
+        "--address=" + addr,
     }));
     GPR_ASSERT(server_);
     return grpc::testing::EchoTestService::NewStub(
diff --git a/test/cpp/end2end/client_crash_test_server.cc b/test/cpp/end2end/client_crash_test_server.cc
index 01dcd40f9a..887504d308 100644
--- a/test/cpp/end2end/client_crash_test_server.cc
+++ b/test/cpp/end2end/client_crash_test_server.cc
@@ -68,8 +68,8 @@ void RunServer() {
   std::cout << "Server listening on " << FLAGS_address << std::endl;
   server->Wait();
 }
-}
-}
+}  // namespace testing
+}  // namespace grpc
 
 int main(int argc, char** argv) {
   ParseCommandLineFlags(&argc, &argv, true);
diff --git a/test/cpp/end2end/client_lb_end2end_test.cc b/test/cpp/end2end/client_lb_end2end_test.cc
index c236f76e89..f8bb12fde1 100644
--- a/test/cpp/end2end/client_lb_end2end_test.cc
+++ b/test/cpp/end2end/client_lb_end2end_test.cc
@@ -33,10 +33,9 @@
 #include <grpc/support/thd.h>
 #include <grpc/support/time.h>
 
-extern "C" {
 #include "src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h"
 #include "src/core/ext/filters/client_channel/subchannel_index.h"
-}
+#include "src/core/lib/support/env.h"
 
 #include "src/proto/grpc/testing/echo.grpc.pb.h"
 #include "test/core/util/port.h"
@@ -86,7 +85,11 @@ class MyTestServiceImpl : public TestServiceImpl {
 class ClientLbEnd2endTest : public ::testing::Test {
  protected:
   ClientLbEnd2endTest()
-      : server_host_("localhost"), kRequestMessage_("Live long and prosper.") {}
+      : server_host_("localhost"), kRequestMessage_("Live long and prosper.") {
+    // Make the backup poller poll very frequently in order to pick up
+    // updates from all the subchannels's FDs.
+    gpr_setenv("GRPC_CLIENT_CHANNEL_BACKUP_POLL_INTERVAL_MS", "1");
+  }
 
   void SetUp() override {
     response_generator_ = grpc_fake_resolver_response_generator_create();
@@ -110,22 +113,23 @@ class ClientLbEnd2endTest : public ::testing::Test {
 
   void SetNextResolution(const std::vector<int>& ports) {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_lb_addresses* addresses = grpc_lb_addresses_create(ports.size(), NULL);
+    grpc_lb_addresses* addresses =
+        grpc_lb_addresses_create(ports.size(), nullptr);
     for (size_t i = 0; i < ports.size(); ++i) {
       char* lb_uri_str;
       gpr_asprintf(&lb_uri_str, "ipv4:127.0.0.1:%d", ports[i]);
       grpc_uri* lb_uri = grpc_uri_parse(&exec_ctx, lb_uri_str, true);
-      GPR_ASSERT(lb_uri != NULL);
+      GPR_ASSERT(lb_uri != nullptr);
       grpc_lb_addresses_set_address_from_uri(addresses, i, lb_uri,
                                              false /* is balancer */,
-                                             "" /* balancer name */, NULL);
+                                             "" /* balancer name */, nullptr);
       grpc_uri_destroy(lb_uri);
       gpr_free(lb_uri_str);
     }
     const grpc_arg fake_addresses =
         grpc_lb_addresses_create_channel_arg(addresses);
     grpc_channel_args* fake_result =
-        grpc_channel_args_copy_and_add(NULL, &fake_addresses, 1);
+        grpc_channel_args_copy_and_add(nullptr, &fake_addresses, 1);
     grpc_fake_resolver_response_generator_set_response(
         &exec_ctx, response_generator_, fake_result);
     grpc_channel_args_destroy(&exec_ctx, fake_result);
@@ -305,7 +309,7 @@ TEST_F(ClientLbEnd2endTest, PickFirstUpdates) {
   ports.clear();
   SetNextResolution(ports);
   gpr_log(GPR_INFO, "****** SET none *******");
-  grpc_connectivity_state channel_state = GRPC_CHANNEL_INIT;
+  grpc_connectivity_state channel_state;
   do {
     channel_state = channel_->GetState(true /* try to connect */);
   } while (channel_state == GRPC_CHANNEL_READY);
@@ -481,7 +485,7 @@ TEST_F(ClientLbEnd2endTest, RoundRobinUpdates) {
   // An empty update will result in the channel going into TRANSIENT_FAILURE.
   ports.clear();
   SetNextResolution(ports);
-  grpc_connectivity_state channel_state = GRPC_CHANNEL_INIT;
+  grpc_connectivity_state channel_state;
   do {
     channel_state = channel_->GetState(true /* try to connect */);
   } while (channel_state == GRPC_CHANNEL_READY);
diff --git a/test/cpp/end2end/end2end_test.cc b/test/cpp/end2end/end2end_test.cc
index 1aa547d4e3..c71034bbe8 100644
--- a/test/cpp/end2end/end2end_test.cc
+++ b/test/cpp/end2end/end2end_test.cc
@@ -30,11 +30,13 @@
 #include <grpc++/server_builder.h>
 #include <grpc++/server_context.h>
 #include <grpc/grpc.h>
+#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/thd.h>
 #include <grpc/support/time.h>
 
 #include "src/core/lib/security/credentials/credentials.h"
+#include "src/core/lib/support/env.h"
 #include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h"
 #include "src/proto/grpc/testing/echo.grpc.pb.h"
 #include "test/core/util/port.h"
@@ -704,13 +706,25 @@ TEST_P(End2endTest, ReconnectChannel) {
   if (GetParam().inproc) {
     return;
   }
+  gpr_setenv("GRPC_CLIENT_CHANNEL_BACKUP_POLL_INTERVAL_MS", "200");
+  int poller_slowdown_factor = 1;
+  // It needs 2 pollset_works to reconnect the channel with polling engine
+  // "poll"
+  char* s = gpr_getenv("GRPC_POLL_STRATEGY");
+  if (s != nullptr && 0 == strcmp(s, "poll")) {
+    poller_slowdown_factor = 2;
+  }
+  gpr_free(s);
   ResetStub();
   SendRpc(stub_.get(), 1, false);
   RestartServer(std::shared_ptr<AuthMetadataProcessor>());
-  // It needs more than kConnectivityCheckIntervalMsec time to reconnect the
-  // channel.
-  gpr_sleep_until(gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
-                               gpr_time_from_millis(1600, GPR_TIMESPAN)));
+  // It needs more than GRPC_CLIENT_CHANNEL_BACKUP_POLL_INTERVAL_MS time to
+  // reconnect the channel.
+  gpr_sleep_until(gpr_time_add(
+      gpr_now(GPR_CLOCK_REALTIME),
+      gpr_time_from_millis(
+          300 * poller_slowdown_factor * grpc_test_slowdown_factor(),
+          GPR_TIMESPAN)));
   SendRpc(stub_.get(), 1, false);
 }
 
@@ -1134,7 +1148,7 @@ TEST_P(End2endTest, ChannelState) {
   CompletionQueue cq;
   std::chrono::system_clock::time_point deadline =
       std::chrono::system_clock::now() + std::chrono::milliseconds(10);
-  channel_->NotifyOnStateChange(GRPC_CHANNEL_IDLE, deadline, &cq, NULL);
+  channel_->NotifyOnStateChange(GRPC_CHANNEL_IDLE, deadline, &cq, nullptr);
   void* tag;
   bool ok = true;
   cq.Next(&tag, &ok);
diff --git a/test/cpp/end2end/generic_end2end_test.cc b/test/cpp/end2end/generic_end2end_test.cc
index 9450182302..40949e8f3a 100644
--- a/test/cpp/end2end/generic_end2end_test.cc
+++ b/test/cpp/end2end/generic_end2end_test.cc
@@ -216,9 +216,10 @@ TEST_F(GenericEnd2endTest, SequentialUnaryRpcs) {
 
     std::unique_ptr<ByteBuffer> cli_send_buffer =
         SerializeToByteBuffer(&send_request);
+    // Use the same cq as server so that events can be polled in time.
     std::unique_ptr<GenericClientAsyncResponseReader> call =
         generic_stub_->PrepareUnaryCall(&cli_ctx, kMethodName,
-                                        *cli_send_buffer.get(), &cli_cq_);
+                                        *cli_send_buffer.get(), srv_cq_.get());
     call->StartCall();
     ByteBuffer cli_recv_buffer;
     call->Finish(&cli_recv_buffer, &recv_status, tag(1));
@@ -226,7 +227,7 @@ TEST_F(GenericEnd2endTest, SequentialUnaryRpcs) {
     generic_service_.RequestCall(&srv_ctx, &stream, srv_cq_.get(),
                                  srv_cq_.get(), tag(4));
 
-    verify_ok(srv_cq_.get(), 4, true);
+    server_ok(4);
     EXPECT_EQ(server_host_, srv_ctx.host().substr(0, server_host_.length()));
     EXPECT_EQ(kMethodName, srv_ctx.method());
 
@@ -245,7 +246,7 @@ TEST_F(GenericEnd2endTest, SequentialUnaryRpcs) {
     stream.Finish(Status::OK, tag(7));
     server_ok(7);
 
-    client_ok(1);
+    verify_ok(srv_cq_.get(), 1, true);
     EXPECT_TRUE(ParseFromByteBuffer(&cli_recv_buffer, &recv_response));
     EXPECT_EQ(send_response.message(), recv_response.message());
     EXPECT_TRUE(recv_status.ok());
@@ -321,8 +322,9 @@ TEST_F(GenericEnd2endTest, SimpleBidiStreaming) {
 
 TEST_F(GenericEnd2endTest, Deadline) {
   ResetStub();
-  SendRpc(1, true, gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC),
-                                gpr_time_from_seconds(10, GPR_TIMESPAN)));
+  SendRpc(1, true,
+          gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC),
+                       gpr_time_from_seconds(10, GPR_TIMESPAN)));
 }
 
 }  // namespace
diff --git a/test/cpp/end2end/grpclb_end2end_test.cc b/test/cpp/end2end/grpclb_end2end_test.cc
index f73a9c1791..c15ab88da1 100644
--- a/test/cpp/end2end/grpclb_end2end_test.cc
+++ b/test/cpp/end2end/grpclb_end2end_test.cc
@@ -33,10 +33,9 @@
 #include <grpc/support/thd.h>
 #include <grpc/support/time.h>
 
-extern "C" {
 #include "src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h"
 #include "src/core/lib/iomgr/sockaddr.h"
-}
+#include "src/core/lib/support/env.h"
 
 #include "test/core/util/port.h"
 #include "test/core/util/test_config.h"
@@ -332,8 +331,11 @@ class GrpclbEnd2endTest : public ::testing::Test {
         num_backends_(num_backends),
         num_balancers_(num_balancers),
         client_load_reporting_interval_seconds_(
-            client_load_reporting_interval_seconds),
-        kRequestMessage_("Live long and prosper.") {}
+            client_load_reporting_interval_seconds) {
+    // Make the backup poller poll very frequently in order to pick up
+    // updates from all the subchannels's FDs.
+    gpr_setenv("GRPC_CLIENT_CHANNEL_BACKUP_POLL_INTERVAL_MS", "1");
+  }
 
   void SetUp() override {
     response_generator_ = grpc_fake_resolver_response_generator_create();
@@ -559,7 +561,6 @@ class GrpclbEnd2endTest : public ::testing::Test {
     std::unique_ptr<std::thread> thread_;
   };
 
-  const grpc::string kMessage_ = "Live long and prosper.";
   const grpc::string server_host_;
   const size_t num_backends_;
   const size_t num_balancers_;
@@ -571,7 +572,7 @@ class GrpclbEnd2endTest : public ::testing::Test {
   std::vector<ServerThread<BackendService>> backend_servers_;
   std::vector<ServerThread<BalancerService>> balancer_servers_;
   grpc_fake_resolver_response_generator* response_generator_;
-  const grpc::string kRequestMessage_;
+  const grpc::string kRequestMessage_ = "Live long and prosper.";
 };
 
 class SingleBalancerTest : public GrpclbEnd2endTest {
@@ -658,8 +659,9 @@ TEST_F(SingleBalancerTest, Fallback) {
 
   // Send non-empty serverlist only after kServerlistDelayMs.
   ScheduleResponseForBalancer(
-      0, BalancerServiceImpl::BuildResponseForBackends(
-             GetBackendPorts(kNumBackendInResolution /* start_index */), {}),
+      0,
+      BalancerServiceImpl::BuildResponseForBackends(
+          GetBackendPorts(kNumBackendInResolution /* start_index */), {}),
       kServerlistDelayMs);
 
   // Wait until all the fallback backends are reachable.
@@ -724,10 +726,11 @@ TEST_F(SingleBalancerTest, FallbackUpdate) {
 
   // Send non-empty serverlist only after kServerlistDelayMs.
   ScheduleResponseForBalancer(
-      0, BalancerServiceImpl::BuildResponseForBackends(
-             GetBackendPorts(kNumBackendInResolution +
-                             kNumBackendInResolutionUpdate /* start_index */),
-             {}),
+      0,
+      BalancerServiceImpl::BuildResponseForBackends(
+          GetBackendPorts(kNumBackendInResolution +
+                          kNumBackendInResolutionUpdate /* start_index */),
+          {}),
       kServerlistDelayMs);
 
   // Wait until all the fallback backends are reachable.
@@ -1068,10 +1071,11 @@ TEST_F(SingleBalancerTest, Drop) {
                                     num_of_drop_by_load_balancing_addresses;
   const int num_total_addresses = num_backends_ + num_of_drop_addresses;
   ScheduleResponseForBalancer(
-      0, BalancerServiceImpl::BuildResponseForBackends(
-             GetBackendPorts(),
-             {{"rate_limiting", num_of_drop_by_rate_limiting_addresses},
-              {"load_balancing", num_of_drop_by_load_balancing_addresses}}),
+      0,
+      BalancerServiceImpl::BuildResponseForBackends(
+          GetBackendPorts(),
+          {{"rate_limiting", num_of_drop_by_rate_limiting_addresses},
+           {"load_balancing", num_of_drop_by_load_balancing_addresses}}),
       0);
   // Wait until all backends are ready.
   WaitForAllBackends();
@@ -1086,7 +1090,7 @@ TEST_F(SingleBalancerTest, Drop) {
     } else {
       EXPECT_TRUE(status.ok()) << "code=" << status.error_code()
                                << " message=" << status.error_message();
-      EXPECT_EQ(response.message(), kMessage_);
+      EXPECT_EQ(response.message(), kRequestMessage_);
     }
   }
   EXPECT_EQ(kNumRpcsPerAddress * num_of_drop_addresses, num_drops);
@@ -1107,9 +1111,10 @@ TEST_F(SingleBalancerTest, DropAllFirst) {
   const int num_of_drop_by_rate_limiting_addresses = 1;
   const int num_of_drop_by_load_balancing_addresses = 1;
   ScheduleResponseForBalancer(
-      0, BalancerServiceImpl::BuildResponseForBackends(
-             {}, {{"rate_limiting", num_of_drop_by_rate_limiting_addresses},
-                  {"load_balancing", num_of_drop_by_load_balancing_addresses}}),
+      0,
+      BalancerServiceImpl::BuildResponseForBackends(
+          {}, {{"rate_limiting", num_of_drop_by_rate_limiting_addresses},
+               {"load_balancing", num_of_drop_by_load_balancing_addresses}}),
       0);
   const Status status = SendRpc();
   EXPECT_FALSE(status.ok());
@@ -1123,9 +1128,10 @@ TEST_F(SingleBalancerTest, DropAll) {
   const int num_of_drop_by_rate_limiting_addresses = 1;
   const int num_of_drop_by_load_balancing_addresses = 1;
   ScheduleResponseForBalancer(
-      0, BalancerServiceImpl::BuildResponseForBackends(
-             {}, {{"rate_limiting", num_of_drop_by_rate_limiting_addresses},
-                  {"load_balancing", num_of_drop_by_load_balancing_addresses}}),
+      0,
+      BalancerServiceImpl::BuildResponseForBackends(
+          {}, {{"rate_limiting", num_of_drop_by_rate_limiting_addresses},
+               {"load_balancing", num_of_drop_by_load_balancing_addresses}}),
       1000);
 
   // First call succeeds.
@@ -1187,10 +1193,11 @@ TEST_F(SingleBalancerWithClientLoadReportingTest, Drop) {
                                     num_of_drop_by_load_balancing_addresses;
   const int num_total_addresses = num_backends_ + num_of_drop_addresses;
   ScheduleResponseForBalancer(
-      0, BalancerServiceImpl::BuildResponseForBackends(
-             GetBackendPorts(),
-             {{"rate_limiting", num_of_drop_by_rate_limiting_addresses},
-              {"load_balancing", num_of_drop_by_load_balancing_addresses}}),
+      0,
+      BalancerServiceImpl::BuildResponseForBackends(
+          GetBackendPorts(),
+          {{"rate_limiting", num_of_drop_by_rate_limiting_addresses},
+           {"load_balancing", num_of_drop_by_load_balancing_addresses}}),
       0);
   // Wait until all backends are ready.
   int num_warmup_ok = 0;
@@ -1210,7 +1217,7 @@ TEST_F(SingleBalancerWithClientLoadReportingTest, Drop) {
     } else {
       EXPECT_TRUE(status.ok()) << "code=" << status.error_code()
                                << " message=" << status.error_message();
-      EXPECT_EQ(response.message(), kMessage_);
+      EXPECT_EQ(response.message(), kRequestMessage_);
     }
   }
   EXPECT_EQ(kNumRpcsPerAddress * num_of_drop_addresses, num_drops);
diff --git a/test/cpp/end2end/mock_test.cc b/test/cpp/end2end/mock_test.cc
index 0b63c25055..61f4111e3b 100644
--- a/test/cpp/end2end/mock_test.cc
+++ b/test/cpp/end2end/mock_test.cc
@@ -44,19 +44,19 @@
 #include <iostream>
 
 using namespace std;
+using ::testing::AtLeast;
+using ::testing::DoAll;
+using ::testing::Invoke;
+using ::testing::Return;
+using ::testing::SaveArg;
+using ::testing::SetArgPointee;
+using ::testing::WithArg;
+using ::testing::_;
 using grpc::testing::EchoRequest;
 using grpc::testing::EchoResponse;
 using grpc::testing::EchoTestService;
 using grpc::testing::MockClientReaderWriter;
 using std::chrono::system_clock;
-using ::testing::AtLeast;
-using ::testing::SetArgPointee;
-using ::testing::SaveArg;
-using ::testing::_;
-using ::testing::Return;
-using ::testing::Invoke;
-using ::testing::WithArg;
-using ::testing::DoAll;
 
 namespace grpc {
 namespace testing {
diff --git a/test/cpp/end2end/thread_stress_test.cc b/test/cpp/end2end/thread_stress_test.cc
index f990a7ed9d..90b2eddbbb 100644
--- a/test/cpp/end2end/thread_stress_test.cc
+++ b/test/cpp/end2end/thread_stress_test.cc
@@ -50,23 +50,6 @@ const int kNumRpcs = 1000;  // Number of RPCs per thread
 namespace grpc {
 namespace testing {
 
-namespace {
-
-// When echo_deadline is requested, deadline seen in the ServerContext is set in
-// the response in seconds.
-void MaybeEchoDeadline(ServerContext* context, const EchoRequest* request,
-                       EchoResponse* response) {
-  if (request->has_param() && request->param().echo_deadline()) {
-    gpr_timespec deadline = gpr_inf_future(GPR_CLOCK_REALTIME);
-    if (context->deadline() != system_clock::time_point::max()) {
-      Timepoint2Timespec(context->deadline(), &deadline);
-    }
-    response->mutable_param()->set_request_deadline(deadline.tv_sec);
-  }
-}
-
-}  // namespace
-
 class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
  public:
   TestServiceImpl() : signal_client_(false) {}
@@ -74,29 +57,6 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
   Status Echo(ServerContext* context, const EchoRequest* request,
               EchoResponse* response) override {
     response->set_message(request->message());
-    MaybeEchoDeadline(context, request, response);
-    if (request->has_param() && request->param().client_cancel_after_us()) {
-      {
-        std::unique_lock<std::mutex> lock(mu_);
-        signal_client_ = true;
-      }
-      while (!context->IsCancelled()) {
-        gpr_sleep_until(gpr_time_add(
-            gpr_now(GPR_CLOCK_REALTIME),
-            gpr_time_from_micros(request->param().client_cancel_after_us(),
-                                 GPR_TIMESPAN)));
-      }
-      return Status::CANCELLED;
-    } else if (request->has_param() &&
-               request->param().server_cancel_after_us()) {
-      gpr_sleep_until(gpr_time_add(
-          gpr_now(GPR_CLOCK_REALTIME),
-          gpr_time_from_micros(request->param().server_cancel_after_us(),
-                               GPR_TIMESPAN)));
-      return Status::CANCELLED;
-    } else {
-      EXPECT_FALSE(context->IsCancelled());
-    }
     return Status::OK;
   }
 
diff --git a/test/cpp/grpclb/grpclb_api_test.cc b/test/cpp/grpclb/grpclb_api_test.cc
index 6b0350e1f9..7b62080b49 100644
--- a/test/cpp/grpclb/grpclb_api_test.cc
+++ b/test/cpp/grpclb/grpclb_api_test.cc
@@ -48,7 +48,7 @@ grpc::string PackedStringToIp(const grpc_grpclb_ip_address& pb_ip) {
   } else {
     abort();
   }
-  GPR_ASSERT(inet_ntop(af, (void*)pb_ip.bytes, ip_str, 46) != NULL);
+  GPR_ASSERT(inet_ntop(af, (void*)pb_ip.bytes, ip_str, 46) != nullptr);
   return ip_str;
 }
 
diff --git a/test/cpp/grpclb/grpclb_test.cc b/test/cpp/grpclb/grpclb_test.cc
index e740ea513a..ca846c72fd 100644
--- a/test/cpp/grpclb/grpclb_test.cc
+++ b/test/cpp/grpclb/grpclb_test.cc
@@ -35,13 +35,14 @@
 #include <grpc/support/time.h>
 
 #include <grpc++/impl/codegen/config.h>
-extern "C" {
+
 #include "src/core/ext/filters/client_channel/client_channel.h"
 #include "src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/security/credentials/fake/fake_credentials.h"
+#include "src/core/lib/support/env.h"
 #include "src/core/lib/support/string.h"
 #include "src/core/lib/support/tmpfile.h"
 #include "src/core/lib/surface/channel.h"
@@ -49,7 +50,6 @@ extern "C" {
 #include "test/core/end2end/cq_verifier.h"
 #include "test/core/util/port.h"
 #include "test/core/util/test_config.h"
-}
 
 #include "src/proto/grpc/lb/v1/load_balancer.pb.h"
 
@@ -87,19 +87,19 @@ namespace grpc {
 namespace {
 
 typedef struct client_fixture {
-  grpc_channel *client;
-  char *server_uri;
-  grpc_completion_queue *cq;
+  grpc_channel* client;
+  char* server_uri;
+  grpc_completion_queue* cq;
 } client_fixture;
 
 typedef struct server_fixture {
-  grpc_server *server;
-  grpc_call *server_call;
-  grpc_completion_queue *cq;
-  char *servers_hostport;
-  const char *balancer_name;
+  grpc_server* server;
+  grpc_call* server_call;
+  grpc_completion_queue* cq;
+  char* servers_hostport;
+  const char* balancer_name;
   int port;
-  const char *lb_token_prefix;
+  const char* lb_token_prefix;
   gpr_thd_id tid;
   int num_calls_serviced;
 } server_fixture;
@@ -111,12 +111,12 @@ typedef struct test_fixture {
   int lb_server_update_delay_ms;
 } test_fixture;
 
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
 
 static grpc_slice build_response_payload_slice(
-    const char *host, int *ports, size_t nports,
+    const char* host, int* ports, size_t nports,
     int64_t expiration_interval_secs, int32_t expiration_interval_nanos,
-    const char *token_prefix) {
+    const char* token_prefix) {
   // server_list {
   //   servers {
   //     ip_address: <in_addr/6 bytes of an IP>
@@ -126,10 +126,10 @@ static grpc_slice build_response_payload_slice(
   //   ...
   // }
   grpc::lb::v1::LoadBalanceResponse response;
-  auto *serverlist = response.mutable_server_list();
+  auto* serverlist = response.mutable_server_list();
 
   if (expiration_interval_secs > 0 || expiration_interval_nanos > 0) {
-    auto *expiration_interval = serverlist->mutable_expiration_interval();
+    auto* expiration_interval = serverlist->mutable_expiration_interval();
     if (expiration_interval_secs > 0) {
       expiration_interval->set_seconds(expiration_interval_secs);
     }
@@ -138,12 +138,12 @@ static grpc_slice build_response_payload_slice(
     }
   }
   for (size_t i = 0; i < nports; i++) {
-    auto *server = serverlist->add_servers();
+    auto* server = serverlist->add_servers();
     // TODO(dgq): test ipv6
     struct in_addr ip4;
     GPR_ASSERT(inet_pton(AF_INET, host, &ip4) == 1);
     server->set_ip_address(
-        string(reinterpret_cast<const char *>(&ip4), sizeof(ip4)));
+        string(reinterpret_cast<const char*>(&ip4), sizeof(ip4)));
     server->set_port(ports[i]);
     // Missing tokens are acceptable. Test that path.
     if (strlen(token_prefix) > 0) {
@@ -151,15 +151,15 @@ static grpc_slice build_response_payload_slice(
       server->set_load_balance_token(token_data);
     }
   }
-  const string &enc_resp = response.SerializeAsString();
+  const string& enc_resp = response.SerializeAsString();
   return grpc_slice_from_copied_buffer(enc_resp.data(), enc_resp.size());
 }
 
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
     ev = grpc_completion_queue_next(cq, grpc_timeout_seconds_to_deadline(5),
-                                    NULL);
+                                    nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
@@ -168,18 +168,18 @@ static void sleep_ms(int delay_ms) {
                                gpr_time_from_millis(delay_ms, GPR_TIMESPAN)));
 }
 
-static void start_lb_server(server_fixture *sf, int *ports, size_t nports,
+static void start_lb_server(server_fixture* sf, int* ports, size_t nports,
                             int update_delay_ms) {
-  grpc_call *s;
-  cq_verifier *cqv = cq_verifier_create(sf->cq);
+  grpc_call* s;
+  cq_verifier* cqv = cq_verifier_create(sf->cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array request_metadata_recv;
   grpc_call_details call_details;
   grpc_call_error error;
   int was_cancelled = 2;
-  grpc_byte_buffer *request_payload_recv;
-  grpc_byte_buffer *response_payload;
+  grpc_byte_buffer* request_payload_recv;
+  grpc_byte_buffer* response_payload;
 
   memset(ops, 0, sizeof(ops));
   grpc_metadata_array_init(&request_metadata_recv);
@@ -198,16 +198,16 @@ static void start_lb_server(server_fixture *sf, int *ports, size_t nports,
 
   // make sure we've received the initial metadata from the grpclb request.
   GPR_ASSERT(request_metadata_recv.count > 0);
-  GPR_ASSERT(request_metadata_recv.metadata != NULL);
+  GPR_ASSERT(request_metadata_recv.metadata != nullptr);
 
   // receive request for backends
   op = ops;
   op->op = GRPC_OP_RECV_MESSAGE;
   op->data.recv_message.recv_message = &request_payload_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(202), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(202), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
   CQ_EXPECT_COMPLETION(cqv, tag(202), 1);
   cq_verify(cqv);
@@ -232,14 +232,14 @@ static void start_lb_server(server_fixture *sf, int *ports, size_t nports,
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(201), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(201), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
   gpr_log(GPR_INFO, "LB Server[%s](%s) after tag 201", sf->servers_hostport,
           sf->balancer_name);
@@ -262,9 +262,10 @@ static void start_lb_server(server_fixture *sf, int *ports, size_t nports,
     op->op = GRPC_OP_SEND_MESSAGE;
     op->data.send_message.send_message = response_payload;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(203), NULL);
+    error =
+        grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(203), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
     CQ_EXPECT_COMPLETION(cqv, tag(203), 1);
     cq_verify(cqv);
@@ -284,9 +285,9 @@ static void start_lb_server(server_fixture *sf, int *ports, size_t nports,
   grpc_slice status_details = grpc_slice_from_static_string("xyz");
   op->data.send_status_from_server.status_details = &status_details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(204), NULL);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(204), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(201), 1);
@@ -303,17 +304,17 @@ static void start_lb_server(server_fixture *sf, int *ports, size_t nports,
   grpc_call_details_destroy(&call_details);
 }
 
-static void start_backend_server(server_fixture *sf) {
-  grpc_call *s;
-  cq_verifier *cqv;
+static void start_backend_server(server_fixture* sf) {
+  grpc_call* s;
+  cq_verifier* cqv;
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array request_metadata_recv;
   grpc_call_details call_details;
   grpc_call_error error;
   int was_cancelled;
-  grpc_byte_buffer *request_payload_recv;
-  grpc_byte_buffer *response_payload;
+  grpc_byte_buffer* request_payload_recv;
+  grpc_byte_buffer* response_payload;
   grpc_event ev;
 
   while (true) {
@@ -328,8 +329,8 @@ static void start_backend_server(server_fixture *sf) {
                                      tag(100));
     GPR_ASSERT(GRPC_CALL_OK == error);
     gpr_log(GPR_INFO, "Server[%s] up", sf->servers_hostport);
-    ev = grpc_completion_queue_next(sf->cq,
-                                    grpc_timeout_seconds_to_deadline(60), NULL);
+    ev = grpc_completion_queue_next(
+        sf->cq, grpc_timeout_seconds_to_deadline(60), nullptr);
     if (!ev.success) {
       gpr_log(GPR_INFO, "Server[%s] being torn down", sf->servers_hostport);
       cq_verifier_destroy(cqv);
@@ -339,8 +340,9 @@ static void start_backend_server(server_fixture *sf) {
     }
     GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
     const string expected_token =
-        strlen(sf->lb_token_prefix) == 0 ? "" : sf->lb_token_prefix +
-                                                    std::to_string(sf->port);
+        strlen(sf->lb_token_prefix) == 0
+            ? ""
+            : sf->lb_token_prefix + std::to_string(sf->port);
     GPR_ASSERT(contains_metadata(&request_metadata_recv, "lb-token",
                                  expected_token.c_str()));
 
@@ -350,14 +352,15 @@ static void start_backend_server(server_fixture *sf) {
     op->op = GRPC_OP_SEND_INITIAL_METADATA;
     op->data.send_initial_metadata.count = 0;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
     op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
     op->data.recv_close_on_server.cancelled = &was_cancelled;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(101), NULL);
+    error =
+        grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(101), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
     gpr_log(GPR_INFO, "Server[%s] after tag 101", sf->servers_hostport);
 
@@ -368,15 +371,16 @@ static void start_backend_server(server_fixture *sf) {
       op->op = GRPC_OP_RECV_MESSAGE;
       op->data.recv_message.recv_message = &request_payload_recv;
       op->flags = 0;
-      op->reserved = NULL;
+      op->reserved = nullptr;
       op++;
-      error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+      error =
+          grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
       GPR_ASSERT(GRPC_CALL_OK == error);
       ev = grpc_completion_queue_next(
-          sf->cq, grpc_timeout_seconds_to_deadline(3), NULL);
+          sf->cq, grpc_timeout_seconds_to_deadline(3), nullptr);
       if (ev.type == GRPC_OP_COMPLETE && ev.success) {
         GPR_ASSERT(ev.tag = tag(102));
-        if (request_payload_recv == NULL) {
+        if (request_payload_recv == nullptr) {
           exit = true;
           gpr_log(GPR_INFO,
                   "Server[%s] recv \"close\" from client, exiting. Call #%d",
@@ -397,13 +401,13 @@ static void start_backend_server(server_fixture *sf) {
         op->op = GRPC_OP_SEND_MESSAGE;
         op->data.send_message.send_message = response_payload;
         op->flags = 0;
-        op->reserved = NULL;
+        op->reserved = nullptr;
         op++;
-        error =
-            grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), NULL);
+        error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103),
+                                      nullptr);
         GPR_ASSERT(GRPC_CALL_OK == error);
         ev = grpc_completion_queue_next(
-            sf->cq, grpc_timeout_seconds_to_deadline(3), NULL);
+            sf->cq, grpc_timeout_seconds_to_deadline(3), nullptr);
         if (ev.type == GRPC_OP_COMPLETE && ev.success) {
           GPR_ASSERT(ev.tag = tag(103));
         } else {
@@ -431,9 +435,10 @@ static void start_backend_server(server_fixture *sf) {
         grpc_slice_from_static_string("Backend server out a-ok");
     op->data.send_status_from_server.status_details = &status_details;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(104), NULL);
+    error =
+        grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(104), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
 
     CQ_EXPECT_COMPLETION(cqv, tag(101), 1);
@@ -449,18 +454,18 @@ static void start_backend_server(server_fixture *sf) {
   }
 }
 
-static void perform_request(client_fixture *cf) {
-  grpc_call *c;
-  cq_verifier *cqv = cq_verifier_create(cf->cq);
+static void perform_request(client_fixture* cf) {
+  grpc_call* c;
+  cq_verifier* cqv = cq_verifier_create(cf->cq);
   grpc_op ops[6];
-  grpc_op *op;
+  grpc_op* op;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_status_code status;
   grpc_call_error error;
   grpc_slice details;
-  grpc_byte_buffer *request_payload;
-  grpc_byte_buffer *response_payload_recv;
+  grpc_byte_buffer* request_payload;
+  grpc_byte_buffer* response_payload_recv;
   int i;
 
   memset(ops, 0, sizeof(ops));
@@ -468,13 +473,13 @@ static void perform_request(client_fixture *cf) {
       grpc_slice_from_copied_string("hello world");
 
   grpc_slice host = grpc_slice_from_static_string("foo.test.google.fr:1234");
-  c = grpc_channel_create_call(cf->client, NULL, GRPC_PROPAGATE_DEFAULTS,
+  c = grpc_channel_create_call(cf->client, nullptr, GRPC_PROPAGATE_DEFAULTS,
                                cf->cq, grpc_slice_from_static_string("/foo"),
                                &host, grpc_timeout_seconds_to_deadline(5),
-                               NULL);
+                               nullptr);
   gpr_log(GPR_INFO, "Call 0x%" PRIxPTR " created", (intptr_t)c);
   GPR_ASSERT(c);
-  char *peer;
+  char* peer;
 
   grpc_metadata_array_init(&initial_metadata_recv);
   grpc_metadata_array_init(&trailing_metadata_recv);
@@ -483,21 +488,21 @@ static void perform_request(client_fixture *cf) {
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_INITIAL_METADATA;
   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   for (i = 0; i < 4; i++) {
@@ -507,14 +512,14 @@ static void perform_request(client_fixture *cf) {
     op->op = GRPC_OP_SEND_MESSAGE;
     op->data.send_message.send_message = request_payload;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
     op->op = GRPC_OP_RECV_MESSAGE;
     op->data.recv_message.recv_message = &response_payload_recv;
     op->flags = 0;
-    op->reserved = NULL;
+    op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), NULL);
+    error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
 
     CQ_EXPECT_COMPLETION(cqv, tag(2), 1);
@@ -531,9 +536,9 @@ static void perform_request(client_fixture *cf) {
   op = ops;
   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
   op->flags = 0;
-  op->reserved = NULL;
+  op->reserved = nullptr;
   op++;
-  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(3), NULL);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(3), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
@@ -555,47 +560,47 @@ static void perform_request(client_fixture *cf) {
 }
 
 #define BALANCERS_NAME "lb.name"
-static void setup_client(const server_fixture *lb_server,
-                         const server_fixture *backends, client_fixture *cf) {
+static void setup_client(const server_fixture* lb_server,
+                         const server_fixture* backends, client_fixture* cf) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
-  char *expected_target_names = NULL;
-  const char *backends_name = lb_server->servers_hostport;
+  char* expected_target_names = nullptr;
+  const char* backends_name = lb_server->servers_hostport;
   gpr_asprintf(&expected_target_names, "%s;%s", backends_name, BALANCERS_NAME);
 
-  grpc_fake_resolver_response_generator *response_generator =
+  grpc_fake_resolver_response_generator* response_generator =
       grpc_fake_resolver_response_generator_create();
 
-  grpc_lb_addresses *addresses = grpc_lb_addresses_create(1, NULL);
-  char *lb_uri_str;
+  grpc_lb_addresses* addresses = grpc_lb_addresses_create(1, nullptr);
+  char* lb_uri_str;
   gpr_asprintf(&lb_uri_str, "ipv4:%s", lb_server->servers_hostport);
-  grpc_uri *lb_uri = grpc_uri_parse(&exec_ctx, lb_uri_str, true);
-  GPR_ASSERT(lb_uri != NULL);
+  grpc_uri* lb_uri = grpc_uri_parse(&exec_ctx, lb_uri_str, true);
+  GPR_ASSERT(lb_uri != nullptr);
   grpc_lb_addresses_set_address_from_uri(addresses, 0, lb_uri, true,
-                                         lb_server->balancer_name, NULL);
+                                         lb_server->balancer_name, nullptr);
   grpc_uri_destroy(lb_uri);
   gpr_free(lb_uri_str);
 
   gpr_asprintf(&cf->server_uri, "fake:///%s", lb_server->servers_hostport);
   const grpc_arg fake_addresses =
       grpc_lb_addresses_create_channel_arg(addresses);
-  grpc_channel_args *fake_result =
-      grpc_channel_args_copy_and_add(NULL, &fake_addresses, 1);
+  grpc_channel_args* fake_result =
+      grpc_channel_args_copy_and_add(nullptr, &fake_addresses, 1);
   grpc_lb_addresses_destroy(&exec_ctx, addresses);
 
   const grpc_arg new_args[] = {
       grpc_fake_transport_expected_targets_arg(expected_target_names),
       grpc_fake_resolver_response_generator_arg(response_generator)};
 
-  grpc_channel_args *args =
-      grpc_channel_args_copy_and_add(NULL, new_args, GPR_ARRAY_SIZE(new_args));
+  grpc_channel_args* args = grpc_channel_args_copy_and_add(
+      nullptr, new_args, GPR_ARRAY_SIZE(new_args));
   gpr_free(expected_target_names);
 
-  cf->cq = grpc_completion_queue_create_for_next(NULL);
-  grpc_channel_credentials *fake_creds =
+  cf->cq = grpc_completion_queue_create_for_next(nullptr);
+  grpc_channel_credentials* fake_creds =
       grpc_fake_transport_security_credentials_create();
   cf->client =
-      grpc_secure_channel_create(fake_creds, cf->server_uri, args, NULL);
+      grpc_secure_channel_create(fake_creds, cf->server_uri, args, nullptr);
   grpc_fake_resolver_response_generator_set_response(
       &exec_ctx, response_generator, fake_result);
   grpc_channel_args_destroy(&exec_ctx, fake_result);
@@ -605,23 +610,23 @@ static void setup_client(const server_fixture *lb_server,
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void teardown_client(client_fixture *cf) {
+static void teardown_client(client_fixture* cf) {
   grpc_completion_queue_shutdown(cf->cq);
   drain_cq(cf->cq);
   grpc_completion_queue_destroy(cf->cq);
-  cf->cq = NULL;
+  cf->cq = nullptr;
   grpc_channel_destroy(cf->client);
-  cf->client = NULL;
+  cf->client = nullptr;
   gpr_free(cf->server_uri);
 }
 
-static void setup_server(const char *host, server_fixture *sf) {
+static void setup_server(const char* host, server_fixture* sf) {
   int assigned_port;
 
-  sf->cq = grpc_completion_queue_create_for_next(NULL);
-  const char *colon_idx = strchr(host, ':');
+  sf->cq = grpc_completion_queue_create_for_next(nullptr);
+  const char* colon_idx = strchr(host, ':');
   if (colon_idx) {
-    const char *port_str = colon_idx + 1;
+    const char* port_str = colon_idx + 1;
     sf->port = atoi(port_str);
     sf->servers_hostport = gpr_strdup(host);
   } else {
@@ -629,11 +634,11 @@ static void setup_server(const char *host, server_fixture *sf) {
     gpr_join_host_port(&sf->servers_hostport, host, sf->port);
   }
 
-  grpc_server_credentials *server_creds =
+  grpc_server_credentials* server_creds =
       grpc_fake_transport_security_server_credentials_create();
 
-  sf->server = grpc_server_create(NULL, NULL);
-  grpc_server_register_completion_queue(sf->server, sf->cq, NULL);
+  sf->server = grpc_server_create(nullptr, nullptr);
+  grpc_server_register_completion_queue(sf->server, sf->cq, nullptr);
   GPR_ASSERT((assigned_port = grpc_server_add_secure_http2_port(
                   sf->server, sf->servers_hostport, server_creds)) > 0);
   grpc_server_credentials_release(server_creds);
@@ -641,23 +646,23 @@ static void setup_server(const char *host, server_fixture *sf) {
   grpc_server_start(sf->server);
 }
 
-static void teardown_server(server_fixture *sf) {
+static void teardown_server(server_fixture* sf) {
   if (!sf->server) return;
 
   gpr_log(GPR_INFO, "Server[%s] shutting down", sf->servers_hostport);
 
-  grpc_completion_queue *shutdown_cq =
-      grpc_completion_queue_create_for_pluck(NULL);
+  grpc_completion_queue* shutdown_cq =
+      grpc_completion_queue_create_for_pluck(nullptr);
   grpc_server_shutdown_and_notify(sf->server, shutdown_cq, tag(1000));
   GPR_ASSERT(grpc_completion_queue_pluck(shutdown_cq, tag(1000),
                                          grpc_timeout_seconds_to_deadline(5),
-                                         NULL)
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_completion_queue_destroy(shutdown_cq);
   grpc_server_destroy(sf->server);
   gpr_thd_join(sf->tid);
 
-  sf->server = NULL;
+  sf->server = nullptr;
   grpc_completion_queue_shutdown(sf->cq);
   drain_cq(sf->cq);
   grpc_completion_queue_destroy(sf->cq);
@@ -666,13 +671,13 @@ static void teardown_server(server_fixture *sf) {
   gpr_free(sf->servers_hostport);
 }
 
-static void fork_backend_server(void *arg) {
-  server_fixture *sf = static_cast<server_fixture *>(arg);
+static void fork_backend_server(void* arg) {
+  server_fixture* sf = static_cast<server_fixture*>(arg);
   start_backend_server(sf);
 }
 
-static void fork_lb_server(void *arg) {
-  test_fixture *tf = static_cast<test_fixture *>(arg);
+static void fork_lb_server(void* arg) {
+  test_fixture* tf = static_cast<test_fixture*>(arg);
   int ports[NUM_BACKENDS];
   for (int i = 0; i < NUM_BACKENDS; i++) {
     ports[i] = tf->lb_backends[i].port;
@@ -710,7 +715,7 @@ static test_fixture setup_test_fixture(int lb_server_update_delay_ms) {
   return tf;
 }
 
-static void teardown_test_fixture(test_fixture *tf) {
+static void teardown_test_fixture(test_fixture* tf) {
   teardown_client(&tf->client);
   for (int i = 0; i < NUM_BACKENDS; ++i) {
     teardown_server(&tf->lb_backends[i]);
@@ -787,9 +792,12 @@ TEST(GrpclbTest, InvalidAddressInServerlist) {}
 }  // namespace
 }  // namespace grpc
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   ::testing::InitGoogleTest(&argc, argv);
   grpc_test_init(argc, argv);
+  // Make the backup poller poll very frequently in order to pick up
+  // updates from all the subchannels's FDs.
+  gpr_setenv("GRPC_CLIENT_CHANNEL_BACKUP_POLL_INTERVAL_MS", "1");
   grpc_init();
   const auto result = RUN_ALL_TESTS();
   grpc_shutdown();
diff --git a/test/cpp/interop/http2_client.cc b/test/cpp/interop/http2_client.cc
index 1e04e57d09..2de7abcf17 100644
--- a/test/cpp/interop/http2_client.cc
+++ b/test/cpp/interop/http2_client.cc
@@ -217,7 +217,7 @@ int main(int argc, char** argv) {
         "goaway",         "max_streams",      "ping",
         "rst_after_data", "rst_after_header", "rst_during_data"};
     char* joined_testcases =
-        gpr_strjoin_sep(testcases, GPR_ARRAY_SIZE(testcases), "\n", NULL);
+        gpr_strjoin_sep(testcases, GPR_ARRAY_SIZE(testcases), "\n", nullptr);
 
     gpr_log(GPR_ERROR, "Unsupported test case %s. Valid options are\n%s",
             FLAGS_test_case.c_str(), joined_testcases);
diff --git a/test/cpp/interop/interop_server.cc b/test/cpp/interop/interop_server.cc
index 4149724b1e..a24cdc7d2d 100644
--- a/test/cpp/interop/interop_server.cc
+++ b/test/cpp/interop/interop_server.cc
@@ -51,8 +51,9 @@ using grpc::ServerCredentials;
 using grpc::ServerReader;
 using grpc::ServerReaderWriter;
 using grpc::ServerWriter;
-using grpc::WriteOptions;
 using grpc::SslServerCredentialsOptions;
+using grpc::Status;
+using grpc::WriteOptions;
 using grpc::testing::InteropServerContextInspector;
 using grpc::testing::Payload;
 using grpc::testing::SimpleRequest;
@@ -62,7 +63,6 @@ using grpc::testing::StreamingInputCallResponse;
 using grpc::testing::StreamingOutputCallRequest;
 using grpc::testing::StreamingOutputCallResponse;
 using grpc::testing::TestService;
-using grpc::Status;
 
 const char kEchoInitialMetadataKey[] = "x-grpc-test-echo-initial";
 const char kEchoTrailingBinMetadataKey[] = "x-grpc-test-echo-trailing-bin";
diff --git a/test/cpp/interop/interop_test.cc b/test/cpp/interop/interop_test.cc
index c18fe1ec1f..1bf0d8d10f 100644
--- a/test/cpp/interop/interop_test.cc
+++ b/test/cpp/interop/interop_test.cc
@@ -37,10 +37,8 @@
 #include "test/core/util/port.h"
 #include "test/cpp/util/test_config.h"
 
-extern "C" {
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 #include "src/core/lib/support/string.h"
-}
 
 DEFINE_string(extra_server_flags, "", "Extra flags to pass to server.");
 
diff --git a/test/cpp/interop/reconnect_interop_server.cc b/test/cpp/interop/reconnect_interop_server.cc
index 50af8fcc8a..5e257e1b38 100644
--- a/test/cpp/interop/reconnect_interop_server.cc
+++ b/test/cpp/interop/reconnect_interop_server.cc
@@ -53,9 +53,9 @@ using grpc::ServerWriter;
 using grpc::SslServerCredentialsOptions;
 using grpc::Status;
 using grpc::testing::Empty;
-using grpc::testing::ReconnectService;
 using grpc::testing::ReconnectInfo;
 using grpc::testing::ReconnectParams;
+using grpc::testing::ReconnectService;
 
 static bool got_sigint = false;
 
diff --git a/test/cpp/interop/stress_test.cc b/test/cpp/interop/stress_test.cc
index c6d3600be8..028ff11b20 100644
--- a/test/cpp/interop/stress_test.cc
+++ b/test/cpp/interop/stress_test.cc
@@ -106,13 +106,13 @@ DEFINE_bool(use_test_ca, false, "False to use SSL roots for google");
 DEFINE_string(server_host_override, "foo.test.google.fr",
               "Override the server host which is sent in HTTP header");
 
-using grpc::testing::kTestCaseList;
 using grpc::testing::MetricsService;
 using grpc::testing::MetricsServiceImpl;
 using grpc::testing::StressTestInteropClient;
 using grpc::testing::TestCaseType;
 using grpc::testing::UNKNOWN_TEST;
 using grpc::testing::WeightedRandomTestSelector;
+using grpc::testing::kTestCaseList;
 
 static int log_level = GPR_LOG_SEVERITY_DEBUG;
 
@@ -230,7 +230,7 @@ int main(int argc, char** argv) {
   log_level = FLAGS_log_level;
   gpr_set_log_function(TestLogFunction);
 
-  srand(time(NULL));
+  srand(time(nullptr));
 
   // Parse the server addresses
   std::vector<grpc::string> server_addresses;
diff --git a/test/cpp/microbenchmarks/bm_arena.cc b/test/cpp/microbenchmarks/bm_arena.cc
index 165b74670d..5b7c611919 100644
--- a/test/cpp/microbenchmarks/bm_arena.cc
+++ b/test/cpp/microbenchmarks/bm_arena.cc
@@ -18,9 +18,7 @@
 
 /* Benchmark arenas */
 
-extern "C" {
 #include "src/core/lib/support/arena.h"
-}
 #include "test/cpp/microbenchmarks/helpers.h"
 #include "third_party/benchmark/include/benchmark/benchmark.h"
 
diff --git a/test/cpp/microbenchmarks/bm_call_create.cc b/test/cpp/microbenchmarks/bm_call_create.cc
index cf9a42e8c6..a45c577320 100644
--- a/test/cpp/microbenchmarks/bm_call_create.cc
+++ b/test/cpp/microbenchmarks/bm_call_create.cc
@@ -29,7 +29,6 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 
-extern "C" {
 #include "src/core/ext/filters/client_channel/client_channel.h"
 #include "src/core/ext/filters/deadline/deadline_filter.h"
 #include "src/core/ext/filters/http/client/http_client_filter.h"
@@ -43,15 +42,14 @@ extern "C" {
 #include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/transport/transport_impl.h"
-}
 
 #include "src/cpp/client/create_channel_internal.h"
 #include "src/proto/grpc/testing/echo.grpc.pb.h"
 #include "test/cpp/microbenchmarks/helpers.h"
 
-auto &force_library_initialization = Library::get();
+auto& force_library_initialization = Library::get();
 
-void BM_Zalloc(benchmark::State &state) {
+void BM_Zalloc(benchmark::State& state) {
   // speed of light for call creation is zalloc, so benchmark a few interesting
   // sizes
   TrackCounters track_counters;
@@ -80,20 +78,20 @@ BENCHMARK(BM_Zalloc)
 
 class BaseChannelFixture {
  public:
-  BaseChannelFixture(grpc_channel *channel) : channel_(channel) {}
+  BaseChannelFixture(grpc_channel* channel) : channel_(channel) {}
   ~BaseChannelFixture() { grpc_channel_destroy(channel_); }
 
-  grpc_channel *channel() const { return channel_; }
+  grpc_channel* channel() const { return channel_; }
 
  private:
-  grpc_channel *const channel_;
+  grpc_channel* const channel_;
 };
 
 class InsecureChannel : public BaseChannelFixture {
  public:
   InsecureChannel()
       : BaseChannelFixture(
-            grpc_insecure_channel_create("localhost:1234", NULL, NULL)) {}
+            grpc_insecure_channel_create("localhost:1234", nullptr, nullptr)) {}
 };
 
 class LameChannel : public BaseChannelFixture {
@@ -104,17 +102,17 @@ class LameChannel : public BaseChannelFixture {
 };
 
 template <class Fixture>
-static void BM_CallCreateDestroy(benchmark::State &state) {
+static void BM_CallCreateDestroy(benchmark::State& state) {
   TrackCounters track_counters;
   Fixture fixture;
-  grpc_completion_queue *cq = grpc_completion_queue_create_for_next(NULL);
+  grpc_completion_queue* cq = grpc_completion_queue_create_for_next(nullptr);
   gpr_timespec deadline = gpr_inf_future(GPR_CLOCK_MONOTONIC);
-  void *method_hdl =
-      grpc_channel_register_call(fixture.channel(), "/foo/bar", NULL, NULL);
+  void* method_hdl = grpc_channel_register_call(fixture.channel(), "/foo/bar",
+                                                nullptr, nullptr);
   while (state.KeepRunning()) {
     grpc_call_unref(grpc_channel_create_registered_call(
-        fixture.channel(), NULL, GRPC_PROPAGATE_DEFAULTS, cq, method_hdl,
-        deadline, NULL));
+        fixture.channel(), nullptr, GRPC_PROPAGATE_DEFAULTS, cq, method_hdl,
+        deadline, nullptr));
   }
   grpc_completion_queue_destroy(cq);
   track_counters.Finish(state);
@@ -126,11 +124,11 @@ BENCHMARK_TEMPLATE(BM_CallCreateDestroy, LameChannel);
 ////////////////////////////////////////////////////////////////////////////////
 // Benchmarks isolating individual filters
 
-static void *tag(int i) {
-  return reinterpret_cast<void *>(static_cast<intptr_t>(i));
+static void* tag(int i) {
+  return reinterpret_cast<void*>(static_cast<intptr_t>(i));
 }
 
-static void BM_LameChannelCallCreateCpp(benchmark::State &state) {
+static void BM_LameChannelCallCreateCpp(benchmark::State& state) {
   TrackCounters track_counters;
   auto stub =
       grpc::testing::EchoTestService::NewStub(grpc::CreateChannelInternal(
@@ -145,7 +143,7 @@ static void BM_LameChannelCallCreateCpp(benchmark::State &state) {
     grpc::ClientContext cli_ctx;
     auto reader = stub->AsyncEcho(&cli_ctx, send_request, &cq);
     reader->Finish(&recv_response, &recv_status, tag(0));
-    void *t;
+    void* t;
     bool ok;
     GPR_ASSERT(cq.Next(&t, &ok));
     GPR_ASSERT(ok);
@@ -154,16 +152,16 @@ static void BM_LameChannelCallCreateCpp(benchmark::State &state) {
 }
 BENCHMARK(BM_LameChannelCallCreateCpp);
 
-static void do_nothing(void *ignored) {}
+static void do_nothing(void* ignored) {}
 
-static void BM_LameChannelCallCreateCore(benchmark::State &state) {
+static void BM_LameChannelCallCreateCore(benchmark::State& state) {
   TrackCounters track_counters;
 
-  grpc_channel *channel;
-  grpc_completion_queue *cq;
+  grpc_channel* channel;
+  grpc_completion_queue* cq;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
-  grpc_byte_buffer *response_payload_recv = NULL;
+  grpc_byte_buffer* response_payload_recv = nullptr;
   grpc_status_code status;
   grpc_slice details;
   grpc::testing::EchoRequest send_request;
@@ -172,23 +170,23 @@ static void BM_LameChannelCallCreateCore(benchmark::State &state) {
 
   channel = grpc_lame_client_channel_create(
       "localhost:1234", GRPC_STATUS_UNAUTHENTICATED, "blah");
-  cq = grpc_completion_queue_create_for_next(NULL);
-  void *rc = grpc_channel_register_call(
-      channel, "/grpc.testing.EchoTestService/Echo", NULL, NULL);
+  cq = grpc_completion_queue_create_for_next(nullptr);
+  void* rc = grpc_channel_register_call(
+      channel, "/grpc.testing.EchoTestService/Echo", nullptr, nullptr);
   while (state.KeepRunning()) {
     GPR_TIMER_SCOPE("BenchmarkCycle", 0);
-    grpc_call *call = grpc_channel_create_registered_call(
-        channel, NULL, GRPC_PROPAGATE_DEFAULTS, cq, rc,
-        gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+    grpc_call* call = grpc_channel_create_registered_call(
+        channel, nullptr, GRPC_PROPAGATE_DEFAULTS, cq, rc,
+        gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
     grpc_metadata_array_init(&initial_metadata_recv);
     grpc_metadata_array_init(&trailing_metadata_recv);
-    grpc_byte_buffer *request_payload_send =
+    grpc_byte_buffer* request_payload_send =
         grpc_raw_byte_buffer_create(&send_request_slice, 1);
 
     // Fill in call ops
     grpc_op ops[6];
     memset(ops, 0, sizeof(ops));
-    grpc_op *op = ops;
+    grpc_op* op = ops;
     op->op = GRPC_OP_SEND_INITIAL_METADATA;
     op->data.send_initial_metadata.count = 0;
     op++;
@@ -212,9 +210,9 @@ static void BM_LameChannelCallCreateCore(benchmark::State &state) {
 
     GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(call, ops,
                                                      (size_t)(op - ops),
-                                                     (void *)1, NULL));
+                                                     (void*)1, nullptr));
     grpc_event ev = grpc_completion_queue_next(
-        cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+        cq, gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
     GPR_ASSERT(ev.type != GRPC_QUEUE_SHUTDOWN);
     GPR_ASSERT(ev.success != 0);
     grpc_call_unref(call);
@@ -230,14 +228,14 @@ static void BM_LameChannelCallCreateCore(benchmark::State &state) {
 }
 BENCHMARK(BM_LameChannelCallCreateCore);
 
-static void BM_LameChannelCallCreateCoreSeparateBatch(benchmark::State &state) {
+static void BM_LameChannelCallCreateCoreSeparateBatch(benchmark::State& state) {
   TrackCounters track_counters;
 
-  grpc_channel *channel;
-  grpc_completion_queue *cq;
+  grpc_channel* channel;
+  grpc_completion_queue* cq;
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
-  grpc_byte_buffer *response_payload_recv = NULL;
+  grpc_byte_buffer* response_payload_recv = nullptr;
   grpc_status_code status;
   grpc_slice details;
   grpc::testing::EchoRequest send_request;
@@ -246,23 +244,23 @@ static void BM_LameChannelCallCreateCoreSeparateBatch(benchmark::State &state) {
 
   channel = grpc_lame_client_channel_create(
       "localhost:1234", GRPC_STATUS_UNAUTHENTICATED, "blah");
-  cq = grpc_completion_queue_create_for_next(NULL);
-  void *rc = grpc_channel_register_call(
-      channel, "/grpc.testing.EchoTestService/Echo", NULL, NULL);
+  cq = grpc_completion_queue_create_for_next(nullptr);
+  void* rc = grpc_channel_register_call(
+      channel, "/grpc.testing.EchoTestService/Echo", nullptr, nullptr);
   while (state.KeepRunning()) {
     GPR_TIMER_SCOPE("BenchmarkCycle", 0);
-    grpc_call *call = grpc_channel_create_registered_call(
-        channel, NULL, GRPC_PROPAGATE_DEFAULTS, cq, rc,
-        gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+    grpc_call* call = grpc_channel_create_registered_call(
+        channel, nullptr, GRPC_PROPAGATE_DEFAULTS, cq, rc,
+        gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
     grpc_metadata_array_init(&initial_metadata_recv);
     grpc_metadata_array_init(&trailing_metadata_recv);
-    grpc_byte_buffer *request_payload_send =
+    grpc_byte_buffer* request_payload_send =
         grpc_raw_byte_buffer_create(&send_request_slice, 1);
 
     // Fill in call ops
     grpc_op ops[3];
     memset(ops, 0, sizeof(ops));
-    grpc_op *op = ops;
+    grpc_op* op = ops;
     op->op = GRPC_OP_SEND_INITIAL_METADATA;
     op->data.send_initial_metadata.count = 0;
     op++;
@@ -273,7 +271,7 @@ static void BM_LameChannelCallCreateCoreSeparateBatch(benchmark::State &state) {
     op++;
     GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(call, ops,
                                                      (size_t)(op - ops),
-                                                     (void *)0, NULL));
+                                                     (void*)nullptr, nullptr));
     memset(ops, 0, sizeof(ops));
     op = ops;
     op->op = GRPC_OP_RECV_INITIAL_METADATA;
@@ -291,13 +289,13 @@ static void BM_LameChannelCallCreateCoreSeparateBatch(benchmark::State &state) {
 
     GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(call, ops,
                                                      (size_t)(op - ops),
-                                                     (void *)1, NULL));
+                                                     (void*)1, nullptr));
     grpc_event ev = grpc_completion_queue_next(
-        cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+        cq, gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
     GPR_ASSERT(ev.type != GRPC_QUEUE_SHUTDOWN);
     GPR_ASSERT(ev.success == 0);
     ev = grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME),
-                                    NULL);
+                                    nullptr);
     GPR_ASSERT(ev.type != GRPC_QUEUE_SHUTDOWN);
     GPR_ASSERT(ev.success != 0);
     grpc_call_unref(call);
@@ -313,31 +311,31 @@ static void BM_LameChannelCallCreateCoreSeparateBatch(benchmark::State &state) {
 }
 BENCHMARK(BM_LameChannelCallCreateCoreSeparateBatch);
 
-static void FilterDestroy(grpc_exec_ctx *exec_ctx, void *arg,
-                          grpc_error *error) {
+static void FilterDestroy(grpc_exec_ctx* exec_ctx, void* arg,
+                          grpc_error* error) {
   gpr_free(arg);
 }
 
-static void DoNothing(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {}
+static void DoNothing(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {}
 
 class FakeClientChannelFactory : public grpc_client_channel_factory {
  public:
   FakeClientChannelFactory() { vtable = &vtable_; }
 
  private:
-  static void NoRef(grpc_client_channel_factory *factory) {}
-  static void NoUnref(grpc_exec_ctx *exec_ctx,
-                      grpc_client_channel_factory *factory) {}
-  static grpc_subchannel *CreateSubchannel(grpc_exec_ctx *exec_ctx,
-                                           grpc_client_channel_factory *factory,
-                                           const grpc_subchannel_args *args) {
+  static void NoRef(grpc_client_channel_factory* factory) {}
+  static void NoUnref(grpc_exec_ctx* exec_ctx,
+                      grpc_client_channel_factory* factory) {}
+  static grpc_subchannel* CreateSubchannel(grpc_exec_ctx* exec_ctx,
+                                           grpc_client_channel_factory* factory,
+                                           const grpc_subchannel_args* args) {
     return nullptr;
   }
-  static grpc_channel *CreateClientChannel(grpc_exec_ctx *exec_ctx,
-                                           grpc_client_channel_factory *factory,
-                                           const char *target,
+  static grpc_channel* CreateClientChannel(grpc_exec_ctx* exec_ctx,
+                                           grpc_client_channel_factory* factory,
+                                           const char* target,
                                            grpc_client_channel_type type,
-                                           const grpc_channel_args *args) {
+                                           const grpc_channel_args* args) {
     return nullptr;
   }
 
@@ -347,11 +345,11 @@ class FakeClientChannelFactory : public grpc_client_channel_factory {
 const grpc_client_channel_factory_vtable FakeClientChannelFactory::vtable_ = {
     NoRef, NoUnref, CreateSubchannel, CreateClientChannel};
 
-static grpc_arg StringArg(const char *key, const char *value) {
+static grpc_arg StringArg(const char* key, const char* value) {
   grpc_arg a;
   a.type = GRPC_ARG_STRING;
-  a.key = const_cast<char *>(key);
-  a.value.string = const_cast<char *>(value);
+  a.key = const_cast<char*>(key);
+  a.value.string = const_cast<char*>(value);
   return a;
 }
 
@@ -360,45 +358,45 @@ enum FixtureFlags : uint32_t {
   REQUIRES_TRANSPORT = 2,
 };
 
-template <const grpc_channel_filter *kFilter, uint32_t kFlags>
+template <const grpc_channel_filter* kFilter, uint32_t kFlags>
 struct Fixture {
-  const grpc_channel_filter *filter = kFilter;
+  const grpc_channel_filter* filter = kFilter;
   const uint32_t flags = kFlags;
 };
 
 namespace dummy_filter {
 
-static void StartTransportStreamOp(grpc_exec_ctx *exec_ctx,
-                                   grpc_call_element *elem,
-                                   grpc_transport_stream_op_batch *op) {}
+static void StartTransportStreamOp(grpc_exec_ctx* exec_ctx,
+                                   grpc_call_element* elem,
+                                   grpc_transport_stream_op_batch* op) {}
 
-static void StartTransportOp(grpc_exec_ctx *exec_ctx,
-                             grpc_channel_element *elem,
-                             grpc_transport_op *op) {}
+static void StartTransportOp(grpc_exec_ctx* exec_ctx,
+                             grpc_channel_element* elem,
+                             grpc_transport_op* op) {}
 
-static grpc_error *InitCallElem(grpc_exec_ctx *exec_ctx,
-                                grpc_call_element *elem,
-                                const grpc_call_element_args *args) {
+static grpc_error* InitCallElem(grpc_exec_ctx* exec_ctx,
+                                grpc_call_element* elem,
+                                const grpc_call_element_args* args) {
   return GRPC_ERROR_NONE;
 }
 
-static void SetPollsetOrPollsetSet(grpc_exec_ctx *exec_ctx,
-                                   grpc_call_element *elem,
-                                   grpc_polling_entity *pollent) {}
+static void SetPollsetOrPollsetSet(grpc_exec_ctx* exec_ctx,
+                                   grpc_call_element* elem,
+                                   grpc_polling_entity* pollent) {}
 
-static void DestroyCallElem(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
-                            const grpc_call_final_info *final_info,
-                            grpc_closure *then_sched_closure) {}
+static void DestroyCallElem(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+                            const grpc_call_final_info* final_info,
+                            grpc_closure* then_sched_closure) {}
 
-grpc_error *InitChannelElem(grpc_exec_ctx *exec_ctx, grpc_channel_element *elem,
-                            grpc_channel_element_args *args) {
+grpc_error* InitChannelElem(grpc_exec_ctx* exec_ctx, grpc_channel_element* elem,
+                            grpc_channel_element_args* args) {
   return GRPC_ERROR_NONE;
 }
 
-void DestroyChannelElem(grpc_exec_ctx *exec_ctx, grpc_channel_element *elem) {}
+void DestroyChannelElem(grpc_exec_ctx* exec_ctx, grpc_channel_element* elem) {}
 
-void GetChannelInfo(grpc_exec_ctx *exec_ctx, grpc_channel_element *elem,
-                    const grpc_channel_info *channel_info) {}
+void GetChannelInfo(grpc_exec_ctx* exec_ctx, grpc_channel_element* elem,
+                    const grpc_channel_info* channel_info) {}
 
 static const grpc_channel_filter dummy_filter = {StartTransportStreamOp,
                                                  StartTransportOp,
@@ -421,42 +419,42 @@ namespace dummy_transport {
 size_t sizeof_stream; /* = sizeof(transport stream) */
 
 /* name of this transport implementation */
-const char *name;
+const char* name;
 
 /* implementation of grpc_transport_init_stream */
-int InitStream(grpc_exec_ctx *exec_ctx, grpc_transport *self,
-               grpc_stream *stream, grpc_stream_refcount *refcount,
-               const void *server_data, gpr_arena *arena) {
+int InitStream(grpc_exec_ctx* exec_ctx, grpc_transport* self,
+               grpc_stream* stream, grpc_stream_refcount* refcount,
+               const void* server_data, gpr_arena* arena) {
   return 0;
 }
 
 /* implementation of grpc_transport_set_pollset */
-void SetPollset(grpc_exec_ctx *exec_ctx, grpc_transport *self,
-                grpc_stream *stream, grpc_pollset *pollset) {}
+void SetPollset(grpc_exec_ctx* exec_ctx, grpc_transport* self,
+                grpc_stream* stream, grpc_pollset* pollset) {}
 
 /* implementation of grpc_transport_set_pollset */
-void SetPollsetSet(grpc_exec_ctx *exec_ctx, grpc_transport *self,
-                   grpc_stream *stream, grpc_pollset_set *pollset_set) {}
+void SetPollsetSet(grpc_exec_ctx* exec_ctx, grpc_transport* self,
+                   grpc_stream* stream, grpc_pollset_set* pollset_set) {}
 
 /* implementation of grpc_transport_perform_stream_op */
-void PerformStreamOp(grpc_exec_ctx *exec_ctx, grpc_transport *self,
-                     grpc_stream *stream, grpc_transport_stream_op_batch *op) {
+void PerformStreamOp(grpc_exec_ctx* exec_ctx, grpc_transport* self,
+                     grpc_stream* stream, grpc_transport_stream_op_batch* op) {
   GRPC_CLOSURE_SCHED(exec_ctx, op->on_complete, GRPC_ERROR_NONE);
 }
 
 /* implementation of grpc_transport_perform_op */
-void PerformOp(grpc_exec_ctx *exec_ctx, grpc_transport *self,
-               grpc_transport_op *op) {}
+void PerformOp(grpc_exec_ctx* exec_ctx, grpc_transport* self,
+               grpc_transport_op* op) {}
 
 /* implementation of grpc_transport_destroy_stream */
-void DestroyStream(grpc_exec_ctx *exec_ctx, grpc_transport *self,
-                   grpc_stream *stream, grpc_closure *then_sched_closure) {}
+void DestroyStream(grpc_exec_ctx* exec_ctx, grpc_transport* self,
+                   grpc_stream* stream, grpc_closure* then_sched_closure) {}
 
 /* implementation of grpc_transport_destroy */
-void Destroy(grpc_exec_ctx *exec_ctx, grpc_transport *self) {}
+void Destroy(grpc_exec_ctx* exec_ctx, grpc_transport* self) {}
 
 /* implementation of grpc_transport_get_endpoint */
-grpc_endpoint *GetEndpoint(grpc_exec_ctx *exec_ctx, grpc_transport *self) {
+grpc_endpoint* GetEndpoint(grpc_exec_ctx* exec_ctx, grpc_transport* self) {
   return nullptr;
 }
 
@@ -474,8 +472,8 @@ class NoOp {
  public:
   class Op {
    public:
-    Op(grpc_exec_ctx *exec_ctx, NoOp *p, grpc_call_stack *s) {}
-    void Finish(grpc_exec_ctx *exec_ctx) {}
+    Op(grpc_exec_ctx* exec_ctx, NoOp* p, grpc_call_stack* s) {}
+    void Finish(grpc_exec_ctx* exec_ctx) {}
   };
 };
 
@@ -491,11 +489,11 @@ class SendEmptyMetadata {
 
   class Op {
    public:
-    Op(grpc_exec_ctx *exec_ctx, SendEmptyMetadata *p, grpc_call_stack *s) {
+    Op(grpc_exec_ctx* exec_ctx, SendEmptyMetadata* p, grpc_call_stack* s) {
       grpc_metadata_batch_init(&batch_);
       p->op_payload_.send_initial_metadata.send_initial_metadata = &batch_;
     }
-    void Finish(grpc_exec_ctx *exec_ctx) {
+    void Finish(grpc_exec_ctx* exec_ctx) {
       grpc_metadata_batch_destroy(exec_ctx, &batch_);
     }
 
@@ -516,7 +514,7 @@ class SendEmptyMetadata {
 // Fixture<> template to specify this), and TestOp defines some unit of work to
 // perform on said filter.
 template <class Fixture, class TestOp>
-static void BM_IsolatedFilter(benchmark::State &state) {
+static void BM_IsolatedFilter(benchmark::State& state) {
   TrackCounters track_counters;
   Fixture fixture;
   std::ostringstream label;
@@ -529,7 +527,7 @@ static void BM_IsolatedFilter(benchmark::State &state) {
 
   grpc_channel_args channel_args = {args.size(), &args[0]};
 
-  std::vector<const grpc_channel_filter *> filters;
+  std::vector<const grpc_channel_filter*> filters;
   if (fixture.filter != nullptr) {
     filters.push_back(fixture.filter);
   }
@@ -540,9 +538,9 @@ static void BM_IsolatedFilter(benchmark::State &state) {
 
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   size_t channel_size = grpc_channel_stack_size(
-      filters.size() == 0 ? NULL : &filters[0], filters.size());
-  grpc_channel_stack *channel_stack =
-      static_cast<grpc_channel_stack *>(gpr_zalloc(channel_size));
+      filters.size() == 0 ? nullptr : &filters[0], filters.size());
+  grpc_channel_stack* channel_stack =
+      static_cast<grpc_channel_stack*>(gpr_zalloc(channel_size));
   GPR_ASSERT(GRPC_LOG_IF_ERROR(
       "channel_stack_init",
       grpc_channel_stack_init(&exec_ctx, 1, FilterDestroy, channel_stack,
@@ -552,8 +550,8 @@ static void BM_IsolatedFilter(benchmark::State &state) {
                                   : nullptr,
                               "CHANNEL", channel_stack)));
   grpc_exec_ctx_flush(&exec_ctx);
-  grpc_call_stack *call_stack = static_cast<grpc_call_stack *>(
-      gpr_zalloc(channel_stack->call_stack_size));
+  grpc_call_stack* call_stack =
+      static_cast<grpc_call_stack*>(gpr_zalloc(channel_stack->call_stack_size));
   grpc_millis deadline = GRPC_MILLIS_INF_FUTURE;
   gpr_timespec start_time = gpr_now(GPR_CLOCK_MONOTONIC);
   grpc_slice method = grpc_slice_from_static_string("/foo/bar");
@@ -561,8 +559,8 @@ static void BM_IsolatedFilter(benchmark::State &state) {
   TestOp test_op_data;
   grpc_call_element_args call_args;
   call_args.call_stack = call_stack;
-  call_args.server_transport_data = NULL;
-  call_args.context = NULL;
+  call_args.server_transport_data = nullptr;
+  call_args.context = nullptr;
   call_args.path = method;
   call_args.start_time = start_time;
   call_args.deadline = deadline;
@@ -571,9 +569,9 @@ static void BM_IsolatedFilter(benchmark::State &state) {
   while (state.KeepRunning()) {
     GPR_TIMER_SCOPE("BenchmarkCycle", 0);
     GRPC_ERROR_UNREF(grpc_call_stack_init(&exec_ctx, channel_stack, 1,
-                                          DoNothing, NULL, &call_args));
+                                          DoNothing, nullptr, &call_args));
     typename TestOp::Op op(&exec_ctx, &test_op_data, call_stack);
-    grpc_call_stack_destroy(&exec_ctx, call_stack, &final_info, NULL);
+    grpc_call_stack_destroy(&exec_ctx, call_stack, &final_info, nullptr);
     op.Finish(&exec_ctx);
     grpc_exec_ctx_flush(&exec_ctx);
     // recreate arena every 64k iterations to avoid oom
@@ -630,12 +628,14 @@ BENCHMARK_TEMPLATE(BM_IsolatedFilter, LoadReportingFilter, SendEmptyMetadata);
 
 namespace isolated_call_filter {
 
-typedef struct { grpc_call_combiner *call_combiner; } call_data;
+typedef struct {
+  grpc_call_combiner* call_combiner;
+} call_data;
 
-static void StartTransportStreamOp(grpc_exec_ctx *exec_ctx,
-                                   grpc_call_element *elem,
-                                   grpc_transport_stream_op_batch *op) {
-  call_data *calld = static_cast<call_data *>(elem->call_data);
+static void StartTransportStreamOp(grpc_exec_ctx* exec_ctx,
+                                   grpc_call_element* elem,
+                                   grpc_transport_stream_op_batch* op) {
+  call_data* calld = static_cast<call_data*>(elem->call_data);
   if (op->recv_initial_metadata) {
     GRPC_CALL_COMBINER_START(
         exec_ctx, calld->call_combiner,
@@ -650,42 +650,42 @@ static void StartTransportStreamOp(grpc_exec_ctx *exec_ctx,
   GRPC_CLOSURE_SCHED(exec_ctx, op->on_complete, GRPC_ERROR_NONE);
 }
 
-static void StartTransportOp(grpc_exec_ctx *exec_ctx,
-                             grpc_channel_element *elem,
-                             grpc_transport_op *op) {
+static void StartTransportOp(grpc_exec_ctx* exec_ctx,
+                             grpc_channel_element* elem,
+                             grpc_transport_op* op) {
   if (op->disconnect_with_error != GRPC_ERROR_NONE) {
     GRPC_ERROR_UNREF(op->disconnect_with_error);
   }
   GRPC_CLOSURE_SCHED(exec_ctx, op->on_consumed, GRPC_ERROR_NONE);
 }
 
-static grpc_error *InitCallElem(grpc_exec_ctx *exec_ctx,
-                                grpc_call_element *elem,
-                                const grpc_call_element_args *args) {
-  call_data *calld = static_cast<call_data *>(elem->call_data);
+static grpc_error* InitCallElem(grpc_exec_ctx* exec_ctx,
+                                grpc_call_element* elem,
+                                const grpc_call_element_args* args) {
+  call_data* calld = static_cast<call_data*>(elem->call_data);
   calld->call_combiner = args->call_combiner;
   return GRPC_ERROR_NONE;
 }
 
-static void SetPollsetOrPollsetSet(grpc_exec_ctx *exec_ctx,
-                                   grpc_call_element *elem,
-                                   grpc_polling_entity *pollent) {}
+static void SetPollsetOrPollsetSet(grpc_exec_ctx* exec_ctx,
+                                   grpc_call_element* elem,
+                                   grpc_polling_entity* pollent) {}
 
-static void DestroyCallElem(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
-                            const grpc_call_final_info *final_info,
-                            grpc_closure *then_sched_closure) {
+static void DestroyCallElem(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+                            const grpc_call_final_info* final_info,
+                            grpc_closure* then_sched_closure) {
   GRPC_CLOSURE_SCHED(exec_ctx, then_sched_closure, GRPC_ERROR_NONE);
 }
 
-grpc_error *InitChannelElem(grpc_exec_ctx *exec_ctx, grpc_channel_element *elem,
-                            grpc_channel_element_args *args) {
+grpc_error* InitChannelElem(grpc_exec_ctx* exec_ctx, grpc_channel_element* elem,
+                            grpc_channel_element_args* args) {
   return GRPC_ERROR_NONE;
 }
 
-void DestroyChannelElem(grpc_exec_ctx *exec_ctx, grpc_channel_element *elem) {}
+void DestroyChannelElem(grpc_exec_ctx* exec_ctx, grpc_channel_element* elem) {}
 
-void GetChannelInfo(grpc_exec_ctx *exec_ctx, grpc_channel_element *elem,
-                    const grpc_channel_info *channel_info) {}
+void GetChannelInfo(grpc_exec_ctx* exec_ctx, grpc_channel_element* elem,
+                    const grpc_channel_info* channel_info) {}
 
 static const grpc_channel_filter isolated_call_filter = {
     StartTransportStreamOp,
@@ -704,57 +704,58 @@ static const grpc_channel_filter isolated_call_filter = {
 class IsolatedCallFixture : public TrackCounters {
  public:
   IsolatedCallFixture() {
-    grpc_channel_stack_builder *builder = grpc_channel_stack_builder_create();
+    grpc_channel_stack_builder* builder = grpc_channel_stack_builder_create();
     grpc_channel_stack_builder_set_name(builder, "dummy");
     grpc_channel_stack_builder_set_target(builder, "dummy_target");
     GPR_ASSERT(grpc_channel_stack_builder_append_filter(
-        builder, &isolated_call_filter::isolated_call_filter, NULL, NULL));
+        builder, &isolated_call_filter::isolated_call_filter, nullptr,
+        nullptr));
     {
       grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
       channel_ = grpc_channel_create_with_builder(&exec_ctx, builder,
                                                   GRPC_CLIENT_CHANNEL);
       grpc_exec_ctx_finish(&exec_ctx);
     }
-    cq_ = grpc_completion_queue_create_for_next(NULL);
+    cq_ = grpc_completion_queue_create_for_next(nullptr);
   }
 
-  void Finish(benchmark::State &state) {
+  void Finish(benchmark::State& state) {
     grpc_completion_queue_destroy(cq_);
     grpc_channel_destroy(channel_);
     TrackCounters::Finish(state);
   }
 
-  grpc_channel *channel() const { return channel_; }
-  grpc_completion_queue *cq() const { return cq_; }
+  grpc_channel* channel() const { return channel_; }
+  grpc_completion_queue* cq() const { return cq_; }
 
  private:
-  grpc_completion_queue *cq_;
-  grpc_channel *channel_;
+  grpc_completion_queue* cq_;
+  grpc_channel* channel_;
 };
 
-static void BM_IsolatedCall_NoOp(benchmark::State &state) {
+static void BM_IsolatedCall_NoOp(benchmark::State& state) {
   IsolatedCallFixture fixture;
   gpr_timespec deadline = gpr_inf_future(GPR_CLOCK_MONOTONIC);
-  void *method_hdl =
-      grpc_channel_register_call(fixture.channel(), "/foo/bar", NULL, NULL);
+  void* method_hdl = grpc_channel_register_call(fixture.channel(), "/foo/bar",
+                                                nullptr, nullptr);
   while (state.KeepRunning()) {
     GPR_TIMER_SCOPE("BenchmarkCycle", 0);
     grpc_call_unref(grpc_channel_create_registered_call(
         fixture.channel(), nullptr, GRPC_PROPAGATE_DEFAULTS, fixture.cq(),
-        method_hdl, deadline, NULL));
+        method_hdl, deadline, nullptr));
   }
   fixture.Finish(state);
 }
 BENCHMARK(BM_IsolatedCall_NoOp);
 
-static void BM_IsolatedCall_Unary(benchmark::State &state) {
+static void BM_IsolatedCall_Unary(benchmark::State& state) {
   IsolatedCallFixture fixture;
   gpr_timespec deadline = gpr_inf_future(GPR_CLOCK_MONOTONIC);
-  void *method_hdl =
-      grpc_channel_register_call(fixture.channel(), "/foo/bar", NULL, NULL);
+  void* method_hdl = grpc_channel_register_call(fixture.channel(), "/foo/bar",
+                                                nullptr, nullptr);
   grpc_slice slice = grpc_slice_from_static_string("hello world");
-  grpc_byte_buffer *send_message = grpc_raw_byte_buffer_create(&slice, 1);
-  grpc_byte_buffer *recv_message = NULL;
+  grpc_byte_buffer* send_message = grpc_raw_byte_buffer_create(&slice, 1);
+  grpc_byte_buffer* recv_message = nullptr;
   grpc_status_code status_code;
   grpc_slice status_details = grpc_empty_slice();
   grpc_metadata_array recv_initial_metadata;
@@ -778,12 +779,12 @@ static void BM_IsolatedCall_Unary(benchmark::State &state) {
   ops[5].data.recv_status_on_client.trailing_metadata = &recv_trailing_metadata;
   while (state.KeepRunning()) {
     GPR_TIMER_SCOPE("BenchmarkCycle", 0);
-    grpc_call *call = grpc_channel_create_registered_call(
+    grpc_call* call = grpc_channel_create_registered_call(
         fixture.channel(), nullptr, GRPC_PROPAGATE_DEFAULTS, fixture.cq(),
-        method_hdl, deadline, NULL);
-    grpc_call_start_batch(call, ops, 6, tag(1), NULL);
+        method_hdl, deadline, nullptr);
+    grpc_call_start_batch(call, ops, 6, tag(1), nullptr);
     grpc_completion_queue_next(fixture.cq(),
-                               gpr_inf_future(GPR_CLOCK_MONOTONIC), NULL);
+                               gpr_inf_future(GPR_CLOCK_MONOTONIC), nullptr);
     grpc_call_unref(call);
   }
   fixture.Finish(state);
@@ -793,13 +794,13 @@ static void BM_IsolatedCall_Unary(benchmark::State &state) {
 }
 BENCHMARK(BM_IsolatedCall_Unary);
 
-static void BM_IsolatedCall_StreamingSend(benchmark::State &state) {
+static void BM_IsolatedCall_StreamingSend(benchmark::State& state) {
   IsolatedCallFixture fixture;
   gpr_timespec deadline = gpr_inf_future(GPR_CLOCK_MONOTONIC);
-  void *method_hdl =
-      grpc_channel_register_call(fixture.channel(), "/foo/bar", NULL, NULL);
+  void* method_hdl = grpc_channel_register_call(fixture.channel(), "/foo/bar",
+                                                nullptr, nullptr);
   grpc_slice slice = grpc_slice_from_static_string("hello world");
-  grpc_byte_buffer *send_message = grpc_raw_byte_buffer_create(&slice, 1);
+  grpc_byte_buffer* send_message = grpc_raw_byte_buffer_create(&slice, 1);
   grpc_metadata_array recv_initial_metadata;
   grpc_metadata_array_init(&recv_initial_metadata);
   grpc_metadata_array recv_trailing_metadata;
@@ -810,20 +811,20 @@ static void BM_IsolatedCall_StreamingSend(benchmark::State &state) {
   ops[1].op = GRPC_OP_RECV_INITIAL_METADATA;
   ops[1].data.recv_initial_metadata.recv_initial_metadata =
       &recv_initial_metadata;
-  grpc_call *call = grpc_channel_create_registered_call(
+  grpc_call* call = grpc_channel_create_registered_call(
       fixture.channel(), nullptr, GRPC_PROPAGATE_DEFAULTS, fixture.cq(),
-      method_hdl, deadline, NULL);
-  grpc_call_start_batch(call, ops, 2, tag(1), NULL);
+      method_hdl, deadline, nullptr);
+  grpc_call_start_batch(call, ops, 2, tag(1), nullptr);
   grpc_completion_queue_next(fixture.cq(), gpr_inf_future(GPR_CLOCK_MONOTONIC),
-                             NULL);
+                             nullptr);
   memset(ops, 0, sizeof(ops));
   ops[0].op = GRPC_OP_SEND_MESSAGE;
   ops[0].data.send_message.send_message = send_message;
   while (state.KeepRunning()) {
     GPR_TIMER_SCOPE("BenchmarkCycle", 0);
-    grpc_call_start_batch(call, ops, 1, tag(2), NULL);
+    grpc_call_start_batch(call, ops, 1, tag(2), nullptr);
     grpc_completion_queue_next(fixture.cq(),
-                               gpr_inf_future(GPR_CLOCK_MONOTONIC), NULL);
+                               gpr_inf_future(GPR_CLOCK_MONOTONIC), nullptr);
   }
   grpc_call_unref(call);
   fixture.Finish(state);
diff --git a/test/cpp/microbenchmarks/bm_chttp2_hpack.cc b/test/cpp/microbenchmarks/bm_chttp2_hpack.cc
index 5428cc47e7..3fff8b02d6 100644
--- a/test/cpp/microbenchmarks/bm_chttp2_hpack.cc
+++ b/test/cpp/microbenchmarks/bm_chttp2_hpack.cc
@@ -22,21 +22,22 @@
 #include <grpc/support/log.h>
 #include <string.h>
 #include <sstream>
-extern "C" {
+
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parser.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/transport/static_metadata.h"
-}
+#include "src/core/lib/transport/timeout_encoding.h"
+
 #include "test/cpp/microbenchmarks/helpers.h"
 #include "third_party/benchmark/include/benchmark/benchmark.h"
 
-auto &force_library_initialization = Library::get();
+auto& force_library_initialization = Library::get();
 
 static grpc_slice MakeSlice(std::vector<uint8_t> bytes) {
   grpc_slice s = grpc_slice_malloc(bytes.size());
-  uint8_t *p = GRPC_SLICE_START_PTR(s);
+  uint8_t* p = GRPC_SLICE_START_PTR(s);
   for (auto b : bytes) {
     *p++ = b;
   }
@@ -47,7 +48,7 @@ static grpc_slice MakeSlice(std::vector<uint8_t> bytes) {
 // HPACK encoder
 //
 
-static void BM_HpackEncoderInitDestroy(benchmark::State &state) {
+static void BM_HpackEncoderInitDestroy(benchmark::State& state) {
   TrackCounters track_counters;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_chttp2_hpack_compressor c;
@@ -61,7 +62,7 @@ static void BM_HpackEncoderInitDestroy(benchmark::State &state) {
 }
 BENCHMARK(BM_HpackEncoderInitDestroy);
 
-static void BM_HpackEncoderEncodeDeadline(benchmark::State &state) {
+static void BM_HpackEncoderEncodeDeadline(benchmark::State& state) {
   TrackCounters track_counters;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_millis saved_now = grpc_exec_ctx_now(&exec_ctx);
@@ -84,7 +85,7 @@ static void BM_HpackEncoderEncodeDeadline(benchmark::State &state) {
         (size_t)1024,
         &stats,
     };
-    grpc_chttp2_encode_header(&exec_ctx, &c, NULL, 0, &b, &hopt, &outbuf);
+    grpc_chttp2_encode_header(&exec_ctx, &c, nullptr, 0, &b, &hopt, &outbuf);
     grpc_slice_buffer_reset_and_unref_internal(&exec_ctx, &outbuf);
     grpc_exec_ctx_flush(&exec_ctx);
   }
@@ -94,17 +95,19 @@ static void BM_HpackEncoderEncodeDeadline(benchmark::State &state) {
   grpc_exec_ctx_finish(&exec_ctx);
 
   std::ostringstream label;
-  label << "framing_bytes/iter:" << (static_cast<double>(stats.framing_bytes) /
-                                     static_cast<double>(state.iterations()))
-        << " header_bytes/iter:" << (static_cast<double>(stats.header_bytes) /
-                                     static_cast<double>(state.iterations()));
+  label << "framing_bytes/iter:"
+        << (static_cast<double>(stats.framing_bytes) /
+            static_cast<double>(state.iterations()))
+        << " header_bytes/iter:"
+        << (static_cast<double>(stats.header_bytes) /
+            static_cast<double>(state.iterations()));
   track_counters.AddLabel(label.str());
   track_counters.Finish(state);
 }
 BENCHMARK(BM_HpackEncoderEncodeDeadline);
 
 template <class Fixture>
-static void BM_HpackEncoderEncodeHeader(benchmark::State &state) {
+static void BM_HpackEncoderEncodeHeader(benchmark::State& state) {
   TrackCounters track_counters;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   static bool logged_representative_output = false;
@@ -133,11 +136,11 @@ static void BM_HpackEncoderEncodeHeader(benchmark::State &state) {
         (size_t)state.range(1),
         &stats,
     };
-    grpc_chttp2_encode_header(&exec_ctx, &c, NULL, 0, &b, &hopt, &outbuf);
+    grpc_chttp2_encode_header(&exec_ctx, &c, nullptr, 0, &b, &hopt, &outbuf);
     if (!logged_representative_output && state.iterations() > 3) {
       logged_representative_output = true;
       for (size_t i = 0; i < outbuf.count; i++) {
-        char *s = grpc_dump_slice(outbuf.slices[i], GPR_DUMP_HEX);
+        char* s = grpc_dump_slice(outbuf.slices[i], GPR_DUMP_HEX);
         gpr_log(GPR_DEBUG, "%" PRIdPTR ": %s", i, s);
         gpr_free(s);
       }
@@ -151,10 +154,12 @@ static void BM_HpackEncoderEncodeHeader(benchmark::State &state) {
   grpc_exec_ctx_finish(&exec_ctx);
 
   std::ostringstream label;
-  label << "framing_bytes/iter:" << (static_cast<double>(stats.framing_bytes) /
-                                     static_cast<double>(state.iterations()))
-        << " header_bytes/iter:" << (static_cast<double>(stats.header_bytes) /
-                                     static_cast<double>(state.iterations()));
+  label << "framing_bytes/iter:"
+        << (static_cast<double>(stats.framing_bytes) /
+            static_cast<double>(state.iterations()))
+        << " header_bytes/iter:"
+        << (static_cast<double>(stats.header_bytes) /
+            static_cast<double>(state.iterations()));
   track_counters.AddLabel(label.str());
   track_counters.Finish(state);
 }
@@ -164,7 +169,7 @@ namespace hpack_encoder_fixtures {
 class EmptyBatch {
  public:
   static constexpr bool kEnableTrueBinary = false;
-  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx *exec_ctx) {
+  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx* exec_ctx) {
     return {};
   }
 };
@@ -172,7 +177,7 @@ class EmptyBatch {
 class SingleStaticElem {
  public:
   static constexpr bool kEnableTrueBinary = false;
-  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx *exec_ctx) {
+  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx* exec_ctx) {
     return {GRPC_MDELEM_GRPC_ACCEPT_ENCODING_IDENTITY_COMMA_DEFLATE};
   }
 };
@@ -180,7 +185,7 @@ class SingleStaticElem {
 class SingleInternedElem {
  public:
   static constexpr bool kEnableTrueBinary = false;
-  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx *exec_ctx) {
+  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx* exec_ctx) {
     return {grpc_mdelem_from_slices(
         exec_ctx, grpc_slice_intern(grpc_slice_from_static_string("abc")),
         grpc_slice_intern(grpc_slice_from_static_string("def")))};
@@ -191,7 +196,7 @@ template <int kLength, bool kTrueBinary>
 class SingleInternedBinaryElem {
  public:
   static constexpr bool kEnableTrueBinary = kTrueBinary;
-  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx *exec_ctx) {
+  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx* exec_ctx) {
     grpc_slice bytes = MakeBytes();
     std::vector<grpc_mdelem> out = {grpc_mdelem_from_slices(
         exec_ctx, grpc_slice_intern(grpc_slice_from_static_string("abc-bin")),
@@ -213,7 +218,7 @@ class SingleInternedBinaryElem {
 class SingleInternedKeyElem {
  public:
   static constexpr bool kEnableTrueBinary = false;
-  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx *exec_ctx) {
+  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx* exec_ctx) {
     return {grpc_mdelem_from_slices(
         exec_ctx, grpc_slice_intern(grpc_slice_from_static_string("abc")),
         grpc_slice_from_static_string("def"))};
@@ -223,7 +228,7 @@ class SingleInternedKeyElem {
 class SingleNonInternedElem {
  public:
   static constexpr bool kEnableTrueBinary = false;
-  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx *exec_ctx) {
+  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx* exec_ctx) {
     return {grpc_mdelem_from_slices(exec_ctx,
                                     grpc_slice_from_static_string("abc"),
                                     grpc_slice_from_static_string("def"))};
@@ -234,7 +239,7 @@ template <int kLength, bool kTrueBinary>
 class SingleNonInternedBinaryElem {
  public:
   static constexpr bool kEnableTrueBinary = kTrueBinary;
-  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx *exec_ctx) {
+  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx* exec_ctx) {
     return {grpc_mdelem_from_slices(
         exec_ctx, grpc_slice_from_static_string("abc-bin"), MakeBytes())};
   }
@@ -252,9 +257,10 @@ class SingleNonInternedBinaryElem {
 class RepresentativeClientInitialMetadata {
  public:
   static constexpr bool kEnableTrueBinary = true;
-  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx *exec_ctx) {
+  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx* exec_ctx) {
     return {
-        GRPC_MDELEM_SCHEME_HTTP, GRPC_MDELEM_METHOD_POST,
+        GRPC_MDELEM_SCHEME_HTTP,
+        GRPC_MDELEM_METHOD_POST,
         grpc_mdelem_from_slices(
             exec_ctx, GRPC_MDSTR_PATH,
             grpc_slice_intern(grpc_slice_from_static_string("/foo/bar"))),
@@ -277,9 +283,10 @@ class RepresentativeClientInitialMetadata {
 class MoreRepresentativeClientInitialMetadata {
  public:
   static constexpr bool kEnableTrueBinary = true;
-  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx *exec_ctx) {
+  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx* exec_ctx) {
     return {
-        GRPC_MDELEM_SCHEME_HTTP, GRPC_MDELEM_METHOD_POST,
+        GRPC_MDELEM_SCHEME_HTTP,
+        GRPC_MDELEM_METHOD_POST,
         grpc_mdelem_from_slices(exec_ctx, GRPC_MDSTR_PATH,
                                 grpc_slice_intern(grpc_slice_from_static_string(
                                     "/grpc.test.FooService/BarMethod"))),
@@ -313,7 +320,7 @@ class MoreRepresentativeClientInitialMetadata {
 class RepresentativeServerInitialMetadata {
  public:
   static constexpr bool kEnableTrueBinary = true;
-  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx *exec_ctx) {
+  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx* exec_ctx) {
     return {GRPC_MDELEM_STATUS_200,
             GRPC_MDELEM_CONTENT_TYPE_APPLICATION_SLASH_GRPC,
             GRPC_MDELEM_GRPC_ACCEPT_ENCODING_IDENTITY_COMMA_DEFLATE_COMMA_GZIP};
@@ -323,7 +330,7 @@ class RepresentativeServerInitialMetadata {
 class RepresentativeServerTrailingMetadata {
  public:
   static constexpr bool kEnableTrueBinary = true;
-  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx *exec_ctx) {
+  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx* exec_ctx) {
     return {GRPC_MDELEM_GRPC_STATUS_0};
   }
 };
@@ -422,7 +429,7 @@ BENCHMARK_TEMPLATE(BM_HpackEncoderEncodeHeader,
 // HPACK parser
 //
 
-static void BM_HpackParserInitDestroy(benchmark::State &state) {
+static void BM_HpackParserInitDestroy(benchmark::State& state) {
   TrackCounters track_counters;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_chttp2_hpack_parser p;
@@ -436,20 +443,20 @@ static void BM_HpackParserInitDestroy(benchmark::State &state) {
 }
 BENCHMARK(BM_HpackParserInitDestroy);
 
-static void UnrefHeader(grpc_exec_ctx *exec_ctx, void *user_data,
+static void UnrefHeader(grpc_exec_ctx* exec_ctx, void* user_data,
                         grpc_mdelem md) {
   GRPC_MDELEM_UNREF(exec_ctx, md);
 }
 
-template <class Fixture>
-static void BM_HpackParserParseHeader(benchmark::State &state) {
+template <class Fixture, void (*OnHeader)(grpc_exec_ctx*, void*, grpc_mdelem)>
+static void BM_HpackParserParseHeader(benchmark::State& state) {
   TrackCounters track_counters;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   std::vector<grpc_slice> init_slices = Fixture::GetInitSlices();
   std::vector<grpc_slice> benchmark_slices = Fixture::GetBenchmarkSlices();
   grpc_chttp2_hpack_parser p;
   grpc_chttp2_hpack_parser_init(&exec_ctx, &p);
-  p.on_header = UnrefHeader;
+  p.on_header = OnHeader;
   p.on_header_user_data = nullptr;
   for (auto slice : init_slices) {
     GPR_ASSERT(GRPC_ERROR_NONE ==
@@ -759,32 +766,97 @@ class RepresentativeServerTrailingMetadata {
   }
 };
 
-BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, EmptyBatch);
-BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, IndexedSingleStaticElem);
-BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, AddIndexedSingleStaticElem);
-BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, KeyIndexedSingleStaticElem);
-BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, IndexedSingleInternedElem);
-BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, AddIndexedSingleInternedElem);
-BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, KeyIndexedSingleInternedElem);
-BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, NonIndexedElem);
-BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, NonIndexedBinaryElem<1, false>);
-BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, NonIndexedBinaryElem<3, false>);
-BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, NonIndexedBinaryElem<10, false>);
-BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, NonIndexedBinaryElem<31, false>);
-BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, NonIndexedBinaryElem<100, false>);
-BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, NonIndexedBinaryElem<1, true>);
-BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, NonIndexedBinaryElem<3, true>);
-BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, NonIndexedBinaryElem<10, true>);
-BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, NonIndexedBinaryElem<31, true>);
-BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, NonIndexedBinaryElem<100, true>);
+static void free_timeout(void* p) { gpr_free(p); }
+
+// New implementation.
+static void OnHeaderNew(grpc_exec_ctx* exec_ctx, void* user_data,
+                        grpc_mdelem md) {
+  if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_GRPC_TIMEOUT)) {
+    grpc_millis* cached_timeout =
+        static_cast<grpc_millis*>(grpc_mdelem_get_user_data(md, free_timeout));
+    grpc_millis timeout;
+    if (cached_timeout != nullptr) {
+      timeout = *cached_timeout;
+    } else {
+      if (!grpc_http2_decode_timeout(GRPC_MDVALUE(md), &timeout)) {
+        char* val = grpc_slice_to_c_string(GRPC_MDVALUE(md));
+        gpr_log(GPR_ERROR, "Ignoring bad timeout value '%s'", val);
+        gpr_free(val);
+        timeout = GRPC_MILLIS_INF_FUTURE;
+      }
+      if (GRPC_MDELEM_IS_INTERNED(md)) {
+        /* not already parsed: parse it now, and store the
+         * result away */
+        cached_timeout = (grpc_millis*)gpr_malloc(sizeof(grpc_millis));
+        *cached_timeout = timeout;
+        grpc_mdelem_set_user_data(md, free_timeout, cached_timeout);
+      }
+    }
+    benchmark::DoNotOptimize(timeout);
+    GRPC_MDELEM_UNREF(exec_ctx, md);
+  } else {
+    GPR_ASSERT(0);
+  }
+}
+
+// Send the same deadline repeatedly
+class SameDeadline {
+ public:
+  static std::vector<grpc_slice> GetInitSlices() {
+    return {
+        grpc_slice_from_static_string("@\x0cgrpc-timeout\x03"
+                                      "30S")};
+  }
+  static std::vector<grpc_slice> GetBenchmarkSlices() {
+    // Use saved key and literal value.
+    return {MakeSlice({0x0f, 0x2f, 0x03, '3', '0', 'S'})};
+  }
+};
+
+BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, EmptyBatch, UnrefHeader);
+BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, IndexedSingleStaticElem,
+                   UnrefHeader);
+BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, AddIndexedSingleStaticElem,
+                   UnrefHeader);
+BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, KeyIndexedSingleStaticElem,
+                   UnrefHeader);
+BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, IndexedSingleInternedElem,
+                   UnrefHeader);
+BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, AddIndexedSingleInternedElem,
+                   UnrefHeader);
+BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, KeyIndexedSingleInternedElem,
+                   UnrefHeader);
+BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, NonIndexedElem, UnrefHeader);
+BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, NonIndexedBinaryElem<1, false>,
+                   UnrefHeader);
+BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, NonIndexedBinaryElem<3, false>,
+                   UnrefHeader);
+BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, NonIndexedBinaryElem<10, false>,
+                   UnrefHeader);
+BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, NonIndexedBinaryElem<31, false>,
+                   UnrefHeader);
+BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, NonIndexedBinaryElem<100, false>,
+                   UnrefHeader);
+BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, NonIndexedBinaryElem<1, true>,
+                   UnrefHeader);
+BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, NonIndexedBinaryElem<3, true>,
+                   UnrefHeader);
+BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, NonIndexedBinaryElem<10, true>,
+                   UnrefHeader);
+BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, NonIndexedBinaryElem<31, true>,
+                   UnrefHeader);
+BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, NonIndexedBinaryElem<100, true>,
+                   UnrefHeader);
 BENCHMARK_TEMPLATE(BM_HpackParserParseHeader,
-                   RepresentativeClientInitialMetadata);
+                   RepresentativeClientInitialMetadata, UnrefHeader);
 BENCHMARK_TEMPLATE(BM_HpackParserParseHeader,
-                   MoreRepresentativeClientInitialMetadata);
+                   MoreRepresentativeClientInitialMetadata, UnrefHeader);
 BENCHMARK_TEMPLATE(BM_HpackParserParseHeader,
-                   RepresentativeServerInitialMetadata);
+                   RepresentativeServerInitialMetadata, UnrefHeader);
 BENCHMARK_TEMPLATE(BM_HpackParserParseHeader,
-                   RepresentativeServerTrailingMetadata);
+                   RepresentativeServerTrailingMetadata, UnrefHeader);
+
+BENCHMARK_TEMPLATE(BM_HpackParserParseHeader, SameDeadline, OnHeaderNew);
 
 }  // namespace hpack_parser_fixtures
 
diff --git a/test/cpp/microbenchmarks/bm_chttp2_transport.cc b/test/cpp/microbenchmarks/bm_chttp2_transport.cc
index 3a484bb790..b95ee0cc01 100644
--- a/test/cpp/microbenchmarks/bm_chttp2_transport.cc
+++ b/test/cpp/microbenchmarks/bm_chttp2_transport.cc
@@ -35,7 +35,7 @@
 #include "test/cpp/microbenchmarks/helpers.h"
 #include "third_party/benchmark/include/benchmark/benchmark.h"
 
-auto &force_library_initialization = Library::get();
+auto& force_library_initialization = Library::get();
 
 ////////////////////////////////////////////////////////////////////////////////
 // Helper classes
@@ -44,15 +44,21 @@ auto &force_library_initialization = Library::get();
 class DummyEndpoint : public grpc_endpoint {
  public:
   DummyEndpoint() {
-    static const grpc_endpoint_vtable my_vtable = {
-        read,     write,   add_to_pollset,    add_to_pollset_set,
-        shutdown, destroy, get_resource_user, get_peer,
-        get_fd};
+    static const grpc_endpoint_vtable my_vtable = {read,
+                                                   write,
+                                                   add_to_pollset,
+                                                   add_to_pollset_set,
+                                                   delete_from_pollset_set,
+                                                   shutdown,
+                                                   destroy,
+                                                   get_resource_user,
+                                                   get_peer,
+                                                   get_fd};
     grpc_endpoint::vtable = &my_vtable;
     ru_ = grpc_resource_user_create(Library::get().rq(), "dummy_endpoint");
   }
 
-  void PushInput(grpc_exec_ctx *exec_ctx, grpc_slice slice) {
+  void PushInput(grpc_exec_ctx* exec_ctx, grpc_slice slice) {
     if (read_cb_ == nullptr) {
       GPR_ASSERT(!have_slice_);
       buffered_slice_ = slice;
@@ -65,14 +71,14 @@ class DummyEndpoint : public grpc_endpoint {
   }
 
  private:
-  grpc_resource_user *ru_;
-  grpc_closure *read_cb_ = nullptr;
-  grpc_slice_buffer *slices_ = nullptr;
+  grpc_resource_user* ru_;
+  grpc_closure* read_cb_ = nullptr;
+  grpc_slice_buffer* slices_ = nullptr;
   bool have_slice_ = false;
   grpc_slice buffered_slice_;
 
-  void QueueRead(grpc_exec_ctx *exec_ctx, grpc_slice_buffer *slices,
-                 grpc_closure *cb) {
+  void QueueRead(grpc_exec_ctx* exec_ctx, grpc_slice_buffer* slices,
+                 grpc_closure* cb) {
     GPR_ASSERT(read_cb_ == nullptr);
     if (have_slice_) {
       have_slice_ = false;
@@ -84,51 +90,54 @@ class DummyEndpoint : public grpc_endpoint {
     slices_ = slices;
   }
 
-  static void read(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                   grpc_slice_buffer *slices, grpc_closure *cb) {
-    static_cast<DummyEndpoint *>(ep)->QueueRead(exec_ctx, slices, cb);
+  static void read(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep,
+                   grpc_slice_buffer* slices, grpc_closure* cb) {
+    static_cast<DummyEndpoint*>(ep)->QueueRead(exec_ctx, slices, cb);
   }
 
-  static void write(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                    grpc_slice_buffer *slices, grpc_closure *cb) {
+  static void write(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep,
+                    grpc_slice_buffer* slices, grpc_closure* cb) {
     GRPC_CLOSURE_SCHED(exec_ctx, cb, GRPC_ERROR_NONE);
   }
 
-  static grpc_workqueue *get_workqueue(grpc_endpoint *ep) { return NULL; }
+  static grpc_workqueue* get_workqueue(grpc_endpoint* ep) { return nullptr; }
 
-  static void add_to_pollset(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                             grpc_pollset *pollset) {}
+  static void add_to_pollset(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep,
+                             grpc_pollset* pollset) {}
 
-  static void add_to_pollset_set(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                                 grpc_pollset_set *pollset) {}
+  static void add_to_pollset_set(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep,
+                                 grpc_pollset_set* pollset) {}
 
-  static void shutdown(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                       grpc_error *why) {
-    grpc_resource_user_shutdown(exec_ctx,
-                                static_cast<DummyEndpoint *>(ep)->ru_);
-    GRPC_CLOSURE_SCHED(exec_ctx, static_cast<DummyEndpoint *>(ep)->read_cb_,
+  static void delete_from_pollset_set(grpc_exec_ctx* exec_ctx,
+                                      grpc_endpoint* ep,
+                                      grpc_pollset_set* pollset) {}
+
+  static void shutdown(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep,
+                       grpc_error* why) {
+    grpc_resource_user_shutdown(exec_ctx, static_cast<DummyEndpoint*>(ep)->ru_);
+    GRPC_CLOSURE_SCHED(exec_ctx, static_cast<DummyEndpoint*>(ep)->read_cb_,
                        why);
   }
 
-  static void destroy(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep) {
-    grpc_resource_user_unref(exec_ctx, static_cast<DummyEndpoint *>(ep)->ru_);
-    delete static_cast<DummyEndpoint *>(ep);
+  static void destroy(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep) {
+    grpc_resource_user_unref(exec_ctx, static_cast<DummyEndpoint*>(ep)->ru_);
+    delete static_cast<DummyEndpoint*>(ep);
   }
 
-  static grpc_resource_user *get_resource_user(grpc_endpoint *ep) {
-    return static_cast<DummyEndpoint *>(ep)->ru_;
+  static grpc_resource_user* get_resource_user(grpc_endpoint* ep) {
+    return static_cast<DummyEndpoint*>(ep)->ru_;
   }
-  static char *get_peer(grpc_endpoint *ep) { return gpr_strdup("test"); }
-  static int get_fd(grpc_endpoint *ep) { return 0; }
+  static char* get_peer(grpc_endpoint* ep) { return gpr_strdup("test"); }
+  static int get_fd(grpc_endpoint* ep) { return 0; }
 };
 
 class Fixture {
  public:
-  Fixture(const grpc::ChannelArguments &args, bool client) {
+  Fixture(const grpc::ChannelArguments& args, bool client) {
     grpc_channel_args c_args = args.c_channel_args();
     ep_ = new DummyEndpoint;
     t_ = grpc_create_chttp2_transport(exec_ctx(), &c_args, ep_, client);
-    grpc_chttp2_transport_start_reading(exec_ctx(), t_, NULL);
+    grpc_chttp2_transport_start_reading(exec_ctx(), t_, nullptr);
     FlushExecCtx();
   }
 
@@ -139,18 +148,18 @@ class Fixture {
     grpc_exec_ctx_finish(&exec_ctx_);
   }
 
-  grpc_chttp2_transport *chttp2_transport() {
-    return reinterpret_cast<grpc_chttp2_transport *>(t_);
+  grpc_chttp2_transport* chttp2_transport() {
+    return reinterpret_cast<grpc_chttp2_transport*>(t_);
   }
-  grpc_transport *transport() { return t_; }
-  grpc_exec_ctx *exec_ctx() { return &exec_ctx_; }
+  grpc_transport* transport() { return t_; }
+  grpc_exec_ctx* exec_ctx() { return &exec_ctx_; }
 
   void PushInput(grpc_slice slice) { ep_->PushInput(exec_ctx(), slice); }
 
  private:
-  DummyEndpoint *ep_;
+  DummyEndpoint* ep_;
   grpc_exec_ctx exec_ctx_ = GRPC_EXEC_CTX_INIT;
-  grpc_transport *t_;
+  grpc_transport* t_;
 };
 
 class Closure : public grpc_closure {
@@ -160,37 +169,37 @@ class Closure : public grpc_closure {
 
 template <class F>
 std::unique_ptr<Closure> MakeClosure(
-    F f, grpc_closure_scheduler *sched = grpc_schedule_on_exec_ctx) {
+    F f, grpc_closure_scheduler* sched = grpc_schedule_on_exec_ctx) {
   struct C : public Closure {
-    C(const F &f, grpc_closure_scheduler *sched) : f_(f) {
+    C(const F& f, grpc_closure_scheduler* sched) : f_(f) {
       GRPC_CLOSURE_INIT(this, Execute, this, sched);
     }
     F f_;
-    static void Execute(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-      static_cast<C *>(arg)->f_(exec_ctx, error);
+    static void Execute(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+      static_cast<C*>(arg)->f_(exec_ctx, error);
     }
   };
   return std::unique_ptr<Closure>(new C(f, sched));
 }
 
 template <class F>
-grpc_closure *MakeOnceClosure(
-    F f, grpc_closure_scheduler *sched = grpc_schedule_on_exec_ctx) {
+grpc_closure* MakeOnceClosure(
+    F f, grpc_closure_scheduler* sched = grpc_schedule_on_exec_ctx) {
   struct C : public grpc_closure {
-    C(const F &f) : f_(f) {}
+    C(const F& f) : f_(f) {}
     F f_;
-    static void Execute(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-      static_cast<C *>(arg)->f_(exec_ctx, error);
-      delete static_cast<C *>(arg);
+    static void Execute(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+      static_cast<C*>(arg)->f_(exec_ctx, error);
+      delete static_cast<C*>(arg);
     }
   };
-  auto *c = new C{f};
+  auto* c = new C{f};
   return GRPC_CLOSURE_INIT(c, C::Execute, c, sched);
 }
 
 class Stream {
  public:
-  Stream(Fixture *f) : f_(f) {
+  Stream(Fixture* f) : f_(f) {
     stream_size_ = grpc_transport_stream_size(f->transport());
     stream_ = gpr_malloc(stream_size_);
     arena_ = gpr_arena_create(4096);
@@ -202,7 +211,7 @@ class Stream {
     gpr_arena_destroy(arena_);
   }
 
-  void Init(benchmark::State &state) {
+  void Init(benchmark::State& state) {
     GRPC_STREAM_REF_INIT(&refcount_, 1, &Stream::FinishDestroy, this,
                          "test_stream");
     gpr_event_init(&done_);
@@ -212,11 +221,11 @@ class Stream {
       arena_ = gpr_arena_create(4096);
     }
     grpc_transport_init_stream(f_->exec_ctx(), f_->transport(),
-                               static_cast<grpc_stream *>(stream_), &refcount_,
-                               NULL, arena_);
+                               static_cast<grpc_stream*>(stream_), &refcount_,
+                               nullptr, arena_);
   }
 
-  void DestroyThen(grpc_exec_ctx *exec_ctx, grpc_closure *closure) {
+  void DestroyThen(grpc_exec_ctx* exec_ctx, grpc_closure* closure) {
     destroy_closure_ = closure;
 #ifndef NDEBUG
     grpc_stream_unref(exec_ctx, &refcount_, "DestroyThen");
@@ -225,31 +234,31 @@ class Stream {
 #endif
   }
 
-  void Op(grpc_exec_ctx *exec_ctx, grpc_transport_stream_op_batch *op) {
+  void Op(grpc_exec_ctx* exec_ctx, grpc_transport_stream_op_batch* op) {
     grpc_transport_perform_stream_op(exec_ctx, f_->transport(),
-                                     static_cast<grpc_stream *>(stream_), op);
+                                     static_cast<grpc_stream*>(stream_), op);
   }
 
-  grpc_chttp2_stream *chttp2_stream() {
-    return static_cast<grpc_chttp2_stream *>(stream_);
+  grpc_chttp2_stream* chttp2_stream() {
+    return static_cast<grpc_chttp2_stream*>(stream_);
   }
 
  private:
-  static void FinishDestroy(grpc_exec_ctx *exec_ctx, void *arg,
-                            grpc_error *error) {
-    auto stream = static_cast<Stream *>(arg);
+  static void FinishDestroy(grpc_exec_ctx* exec_ctx, void* arg,
+                            grpc_error* error) {
+    auto stream = static_cast<Stream*>(arg);
     grpc_transport_destroy_stream(exec_ctx, stream->f_->transport(),
-                                  static_cast<grpc_stream *>(stream->stream_),
+                                  static_cast<grpc_stream*>(stream->stream_),
                                   stream->destroy_closure_);
-    gpr_event_set(&stream->done_, (void *)1);
+    gpr_event_set(&stream->done_, (void*)1);
   }
 
-  Fixture *f_;
+  Fixture* f_;
   grpc_stream_refcount refcount_;
-  gpr_arena *arena_;
+  gpr_arena* arena_;
   size_t stream_size_;
-  void *stream_;
-  grpc_closure *destroy_closure_ = nullptr;
+  void* stream_;
+  grpc_closure* destroy_closure_ = nullptr;
   gpr_event done_;
 };
 
@@ -257,7 +266,7 @@ class Stream {
 // Benchmarks
 //
 
-static void BM_StreamCreateDestroy(benchmark::State &state) {
+static void BM_StreamCreateDestroy(benchmark::State& state) {
   TrackCounters track_counters;
   Fixture f(grpc::ChannelArguments(), true);
   Stream s(&f);
@@ -268,7 +277,7 @@ static void BM_StreamCreateDestroy(benchmark::State &state) {
   op.payload = &op_payload;
   op_payload.cancel_stream.cancel_error = GRPC_ERROR_CANCELLED;
   std::unique_ptr<Closure> next =
-      MakeClosure([&](grpc_exec_ctx *exec_ctx, grpc_error *error) {
+      MakeClosure([&](grpc_exec_ctx* exec_ctx, grpc_error* error) {
         if (!state.KeepRunning()) return;
         s.Init(state);
         s.Op(exec_ctx, &op);
@@ -282,9 +291,10 @@ BENCHMARK(BM_StreamCreateDestroy);
 
 class RepresentativeClientInitialMetadata {
  public:
-  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx *exec_ctx) {
+  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx* exec_ctx) {
     return {
-        GRPC_MDELEM_SCHEME_HTTP, GRPC_MDELEM_METHOD_POST,
+        GRPC_MDELEM_SCHEME_HTTP,
+        GRPC_MDELEM_METHOD_POST,
         grpc_mdelem_from_slices(
             exec_ctx, GRPC_MDSTR_PATH,
             grpc_slice_intern(grpc_slice_from_static_string("/foo/bar"))),
@@ -302,7 +312,7 @@ class RepresentativeClientInitialMetadata {
 };
 
 template <class Metadata>
-static void BM_StreamCreateSendInitialMetadataDestroy(benchmark::State &state) {
+static void BM_StreamCreateSendInitialMetadataDestroy(benchmark::State& state) {
   TrackCounters track_counters;
   Fixture f(grpc::ChannelArguments(), true);
   Stream s(&f);
@@ -329,7 +339,7 @@ static void BM_StreamCreateSendInitialMetadataDestroy(benchmark::State &state) {
   }
 
   f.FlushExecCtx();
-  start = MakeClosure([&](grpc_exec_ctx *exec_ctx, grpc_error *error) {
+  start = MakeClosure([&](grpc_exec_ctx* exec_ctx, grpc_error* error) {
     if (!state.KeepRunning()) return;
     s.Init(state);
     reset_op();
@@ -338,7 +348,7 @@ static void BM_StreamCreateSendInitialMetadataDestroy(benchmark::State &state) {
     op.payload->send_initial_metadata.send_initial_metadata = &b;
     s.Op(exec_ctx, &op);
   });
-  done = MakeClosure([&](grpc_exec_ctx *exec_ctx, grpc_error *error) {
+  done = MakeClosure([&](grpc_exec_ctx* exec_ctx, grpc_error* error) {
     reset_op();
     op.cancel_stream = true;
     op.payload->cancel_stream.cancel_error = GRPC_ERROR_CANCELLED;
@@ -353,7 +363,7 @@ static void BM_StreamCreateSendInitialMetadataDestroy(benchmark::State &state) {
 BENCHMARK_TEMPLATE(BM_StreamCreateSendInitialMetadataDestroy,
                    RepresentativeClientInitialMetadata);
 
-static void BM_TransportEmptyOp(benchmark::State &state) {
+static void BM_TransportEmptyOp(benchmark::State& state) {
   TrackCounters track_counters;
   Fixture f(grpc::ChannelArguments(), true);
   Stream s(&f);
@@ -366,7 +376,7 @@ static void BM_TransportEmptyOp(benchmark::State &state) {
     op.payload = &op_payload;
   };
   std::unique_ptr<Closure> c =
-      MakeClosure([&](grpc_exec_ctx *exec_ctx, grpc_error *error) {
+      MakeClosure([&](grpc_exec_ctx* exec_ctx, grpc_error* error) {
         if (!state.KeepRunning()) return;
         reset_op();
         op.on_complete = c.get();
@@ -378,8 +388,8 @@ static void BM_TransportEmptyOp(benchmark::State &state) {
   op.cancel_stream = true;
   op_payload.cancel_stream.cancel_error = GRPC_ERROR_CANCELLED;
   s.Op(f.exec_ctx(), &op);
-  s.DestroyThen(f.exec_ctx(), MakeOnceClosure([](grpc_exec_ctx *exec_ctx,
-                                                 grpc_error *error) {}));
+  s.DestroyThen(f.exec_ctx(), MakeOnceClosure([](grpc_exec_ctx* exec_ctx,
+                                                 grpc_error* error) {}));
   f.FlushExecCtx();
   track_counters.Finish(state);
 }
@@ -387,7 +397,7 @@ BENCHMARK(BM_TransportEmptyOp);
 
 std::vector<std::unique_ptr<gpr_event>> done_events;
 
-static void BM_TransportStreamSend(benchmark::State &state) {
+static void BM_TransportStreamSend(benchmark::State& state) {
   TrackCounters track_counters;
   Fixture f(grpc::ChannelArguments(), true);
   auto s = std::unique_ptr<Stream>(new Stream(&f));
@@ -418,13 +428,13 @@ static void BM_TransportStreamSend(benchmark::State &state) {
         grpc_metadata_batch_add_tail(f.exec_ctx(), &b, &storage[i], elems[i])));
   }
 
-  gpr_event *bm_done = new gpr_event;
+  gpr_event* bm_done = new gpr_event;
   gpr_event_init(bm_done);
 
   std::unique_ptr<Closure> c =
-      MakeClosure([&](grpc_exec_ctx *exec_ctx, grpc_error *error) {
+      MakeClosure([&](grpc_exec_ctx* exec_ctx, grpc_error* error) {
         if (!state.KeepRunning()) {
-          gpr_event_set(bm_done, (void *)1);
+          gpr_event_set(bm_done, (void*)1);
           return;
         }
         // force outgoing window to be yuge
@@ -452,8 +462,8 @@ static void BM_TransportStreamSend(benchmark::State &state) {
   op.cancel_stream = true;
   op.payload->cancel_stream.cancel_error = GRPC_ERROR_CANCELLED;
   s->Op(f.exec_ctx(), &op);
-  s->DestroyThen(f.exec_ctx(), MakeOnceClosure([](grpc_exec_ctx *exec_ctx,
-                                                  grpc_error *error) {}));
+  s->DestroyThen(f.exec_ctx(), MakeOnceClosure([](grpc_exec_ctx* exec_ctx,
+                                                  grpc_error* error) {}));
   f.FlushExecCtx();
   s.reset();
   track_counters.Finish(state);
@@ -519,7 +529,7 @@ static grpc_slice CreateIncomingDataSlice(size_t length, size_t frame_size) {
   return grpc_slice_from_copied_buffer(framed.data(), framed.size());
 }
 
-static void BM_TransportStreamRecv(benchmark::State &state) {
+static void BM_TransportStreamRecv(benchmark::State& state) {
   TrackCounters track_counters;
   Fixture f(grpc::ChannelArguments(), true);
   Stream s(&f);
@@ -527,7 +537,7 @@ static void BM_TransportStreamRecv(benchmark::State &state) {
   grpc_transport_stream_op_batch_payload op_payload;
   memset(&op_payload, 0, sizeof(op_payload));
   grpc_transport_stream_op_batch op;
-  grpc_byte_stream *recv_stream;
+  grpc_byte_stream* recv_stream;
   grpc_slice incoming_data = CreateIncomingDataSlice(state.range(0), 16384);
 
   auto reset_op = [&]() {
@@ -550,7 +560,7 @@ static void BM_TransportStreamRecv(benchmark::State &state) {
   }
 
   std::unique_ptr<Closure> do_nothing =
-      MakeClosure([](grpc_exec_ctx *exec_ctx, grpc_error *error) {});
+      MakeClosure([](grpc_exec_ctx* exec_ctx, grpc_error* error) {});
 
   uint32_t received;
 
@@ -560,7 +570,7 @@ static void BM_TransportStreamRecv(benchmark::State &state) {
   grpc_slice recv_slice;
 
   std::unique_ptr<Closure> c =
-      MakeClosure([&](grpc_exec_ctx *exec_ctx, grpc_error *error) {
+      MakeClosure([&](grpc_exec_ctx* exec_ctx, grpc_error* error) {
         if (!state.KeepRunning()) return;
         // force outgoing window to be yuge
         s.chttp2_stream()->flow_control->TestOnlyForceHugeWindow();
@@ -575,15 +585,15 @@ static void BM_TransportStreamRecv(benchmark::State &state) {
         f.PushInput(grpc_slice_ref(incoming_data));
       });
 
-  drain_start = MakeClosure([&](grpc_exec_ctx *exec_ctx, grpc_error *error) {
-    if (recv_stream == NULL) {
+  drain_start = MakeClosure([&](grpc_exec_ctx* exec_ctx, grpc_error* error) {
+    if (recv_stream == nullptr) {
       GPR_ASSERT(!state.KeepRunning());
       return;
     }
     GRPC_CLOSURE_RUN(exec_ctx, drain.get(), GRPC_ERROR_NONE);
   });
 
-  drain = MakeClosure([&](grpc_exec_ctx *exec_ctx, grpc_error *error) {
+  drain = MakeClosure([&](grpc_exec_ctx* exec_ctx, grpc_error* error) {
     do {
       if (received == recv_stream->length) {
         grpc_byte_stream_destroy(exec_ctx, recv_stream);
@@ -599,7 +609,7 @@ static void BM_TransportStreamRecv(benchmark::State &state) {
               grpc_slice_unref_internal(exec_ctx, recv_slice), true));
   });
 
-  drain_continue = MakeClosure([&](grpc_exec_ctx *exec_ctx, grpc_error *error) {
+  drain_continue = MakeClosure([&](grpc_exec_ctx* exec_ctx, grpc_error* error) {
     grpc_byte_stream_pull(exec_ctx, recv_stream, &recv_slice);
     received += GRPC_SLICE_LENGTH(recv_slice);
     grpc_slice_unref_internal(exec_ctx, recv_slice);
@@ -633,8 +643,8 @@ static void BM_TransportStreamRecv(benchmark::State &state) {
   op.cancel_stream = true;
   op.payload->cancel_stream.cancel_error = GRPC_ERROR_CANCELLED;
   s.Op(f.exec_ctx(), &op);
-  s.DestroyThen(f.exec_ctx(), MakeOnceClosure([](grpc_exec_ctx *exec_ctx,
-                                                 grpc_error *error) {}));
+  s.DestroyThen(f.exec_ctx(), MakeOnceClosure([](grpc_exec_ctx* exec_ctx,
+                                                 grpc_error* error) {}));
   f.FlushExecCtx();
   track_counters.Finish(state);
   grpc_metadata_batch_destroy(f.exec_ctx(), &b);
diff --git a/test/cpp/microbenchmarks/bm_closure.cc b/test/cpp/microbenchmarks/bm_closure.cc
index 41649b8a73..2434d4e84e 100644
--- a/test/cpp/microbenchmarks/bm_closure.cc
+++ b/test/cpp/microbenchmarks/bm_closure.cc
@@ -22,12 +22,10 @@
 #include <grpc/grpc.h>
 #include <sstream>
 
-extern "C" {
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/combiner.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/support/spinlock.h"
-}
 
 #include "test/cpp/microbenchmarks/helpers.h"
 
@@ -61,7 +59,7 @@ static void BM_ClosureInitAgainstExecCtx(benchmark::State& state) {
   grpc_closure c;
   while (state.KeepRunning()) {
     benchmark::DoNotOptimize(
-        GRPC_CLOSURE_INIT(&c, DoNothing, NULL, grpc_schedule_on_exec_ctx));
+        GRPC_CLOSURE_INIT(&c, DoNothing, nullptr, grpc_schedule_on_exec_ctx));
   }
   track_counters.Finish(state);
 }
@@ -74,7 +72,7 @@ static void BM_ClosureInitAgainstCombiner(benchmark::State& state) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
     benchmark::DoNotOptimize(GRPC_CLOSURE_INIT(
-        &c, DoNothing, NULL, grpc_combiner_scheduler(combiner)));
+        &c, DoNothing, nullptr, grpc_combiner_scheduler(combiner)));
   }
   GRPC_COMBINER_UNREF(&exec_ctx, combiner, "finished");
   grpc_exec_ctx_finish(&exec_ctx);
@@ -85,7 +83,7 @@ BENCHMARK(BM_ClosureInitAgainstCombiner);
 static void BM_ClosureRunOnExecCtx(benchmark::State& state) {
   TrackCounters track_counters;
   grpc_closure c;
-  GRPC_CLOSURE_INIT(&c, DoNothing, NULL, grpc_schedule_on_exec_ctx);
+  GRPC_CLOSURE_INIT(&c, DoNothing, nullptr, grpc_schedule_on_exec_ctx);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
     GRPC_CLOSURE_RUN(&exec_ctx, &c, GRPC_ERROR_NONE);
@@ -100,9 +98,10 @@ static void BM_ClosureCreateAndRun(benchmark::State& state) {
   TrackCounters track_counters;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
-    GRPC_CLOSURE_RUN(&exec_ctx, GRPC_CLOSURE_CREATE(DoNothing, NULL,
-                                                    grpc_schedule_on_exec_ctx),
-                     GRPC_ERROR_NONE);
+    GRPC_CLOSURE_RUN(
+        &exec_ctx,
+        GRPC_CLOSURE_CREATE(DoNothing, nullptr, grpc_schedule_on_exec_ctx),
+        GRPC_ERROR_NONE);
   }
   grpc_exec_ctx_finish(&exec_ctx);
   track_counters.Finish(state);
@@ -114,9 +113,10 @@ static void BM_ClosureInitAndRun(benchmark::State& state) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_closure c;
   while (state.KeepRunning()) {
-    GRPC_CLOSURE_RUN(&exec_ctx, GRPC_CLOSURE_INIT(&c, DoNothing, NULL,
-                                                  grpc_schedule_on_exec_ctx),
-                     GRPC_ERROR_NONE);
+    GRPC_CLOSURE_RUN(
+        &exec_ctx,
+        GRPC_CLOSURE_INIT(&c, DoNothing, nullptr, grpc_schedule_on_exec_ctx),
+        GRPC_ERROR_NONE);
   }
   grpc_exec_ctx_finish(&exec_ctx);
   track_counters.Finish(state);
@@ -126,7 +126,7 @@ BENCHMARK(BM_ClosureInitAndRun);
 static void BM_ClosureSchedOnExecCtx(benchmark::State& state) {
   TrackCounters track_counters;
   grpc_closure c;
-  GRPC_CLOSURE_INIT(&c, DoNothing, NULL, grpc_schedule_on_exec_ctx);
+  GRPC_CLOSURE_INIT(&c, DoNothing, nullptr, grpc_schedule_on_exec_ctx);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
     GRPC_CLOSURE_SCHED(&exec_ctx, &c, GRPC_ERROR_NONE);
@@ -141,8 +141,8 @@ static void BM_ClosureSched2OnExecCtx(benchmark::State& state) {
   TrackCounters track_counters;
   grpc_closure c1;
   grpc_closure c2;
-  GRPC_CLOSURE_INIT(&c1, DoNothing, NULL, grpc_schedule_on_exec_ctx);
-  GRPC_CLOSURE_INIT(&c2, DoNothing, NULL, grpc_schedule_on_exec_ctx);
+  GRPC_CLOSURE_INIT(&c1, DoNothing, nullptr, grpc_schedule_on_exec_ctx);
+  GRPC_CLOSURE_INIT(&c2, DoNothing, nullptr, grpc_schedule_on_exec_ctx);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
     GRPC_CLOSURE_SCHED(&exec_ctx, &c1, GRPC_ERROR_NONE);
@@ -159,9 +159,9 @@ static void BM_ClosureSched3OnExecCtx(benchmark::State& state) {
   grpc_closure c1;
   grpc_closure c2;
   grpc_closure c3;
-  GRPC_CLOSURE_INIT(&c1, DoNothing, NULL, grpc_schedule_on_exec_ctx);
-  GRPC_CLOSURE_INIT(&c2, DoNothing, NULL, grpc_schedule_on_exec_ctx);
-  GRPC_CLOSURE_INIT(&c3, DoNothing, NULL, grpc_schedule_on_exec_ctx);
+  GRPC_CLOSURE_INIT(&c1, DoNothing, nullptr, grpc_schedule_on_exec_ctx);
+  GRPC_CLOSURE_INIT(&c2, DoNothing, nullptr, grpc_schedule_on_exec_ctx);
+  GRPC_CLOSURE_INIT(&c3, DoNothing, nullptr, grpc_schedule_on_exec_ctx);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
     GRPC_CLOSURE_SCHED(&exec_ctx, &c1, GRPC_ERROR_NONE);
@@ -182,7 +182,7 @@ static void BM_AcquireMutex(benchmark::State& state) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
     gpr_mu_lock(&mu);
-    DoNothing(&exec_ctx, NULL, GRPC_ERROR_NONE);
+    DoNothing(&exec_ctx, nullptr, GRPC_ERROR_NONE);
     gpr_mu_unlock(&mu);
   }
   grpc_exec_ctx_finish(&exec_ctx);
@@ -198,7 +198,7 @@ static void BM_TryAcquireMutex(benchmark::State& state) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
     if (gpr_mu_trylock(&mu)) {
-      DoNothing(&exec_ctx, NULL, GRPC_ERROR_NONE);
+      DoNothing(&exec_ctx, nullptr, GRPC_ERROR_NONE);
       gpr_mu_unlock(&mu);
     } else {
       abort();
@@ -216,7 +216,7 @@ static void BM_AcquireSpinlock(benchmark::State& state) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
     gpr_spinlock_lock(&mu);
-    DoNothing(&exec_ctx, NULL, GRPC_ERROR_NONE);
+    DoNothing(&exec_ctx, nullptr, GRPC_ERROR_NONE);
     gpr_spinlock_unlock(&mu);
   }
   grpc_exec_ctx_finish(&exec_ctx);
@@ -231,7 +231,7 @@ static void BM_TryAcquireSpinlock(benchmark::State& state) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
     if (gpr_spinlock_trylock(&mu)) {
-      DoNothing(&exec_ctx, NULL, GRPC_ERROR_NONE);
+      DoNothing(&exec_ctx, nullptr, GRPC_ERROR_NONE);
       gpr_spinlock_unlock(&mu);
     } else {
       abort();
@@ -246,7 +246,7 @@ static void BM_ClosureSchedOnCombiner(benchmark::State& state) {
   TrackCounters track_counters;
   grpc_combiner* combiner = grpc_combiner_create();
   grpc_closure c;
-  GRPC_CLOSURE_INIT(&c, DoNothing, NULL, grpc_combiner_scheduler(combiner));
+  GRPC_CLOSURE_INIT(&c, DoNothing, nullptr, grpc_combiner_scheduler(combiner));
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
     GRPC_CLOSURE_SCHED(&exec_ctx, &c, GRPC_ERROR_NONE);
@@ -263,8 +263,8 @@ static void BM_ClosureSched2OnCombiner(benchmark::State& state) {
   grpc_combiner* combiner = grpc_combiner_create();
   grpc_closure c1;
   grpc_closure c2;
-  GRPC_CLOSURE_INIT(&c1, DoNothing, NULL, grpc_combiner_scheduler(combiner));
-  GRPC_CLOSURE_INIT(&c2, DoNothing, NULL, grpc_combiner_scheduler(combiner));
+  GRPC_CLOSURE_INIT(&c1, DoNothing, nullptr, grpc_combiner_scheduler(combiner));
+  GRPC_CLOSURE_INIT(&c2, DoNothing, nullptr, grpc_combiner_scheduler(combiner));
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
     GRPC_CLOSURE_SCHED(&exec_ctx, &c1, GRPC_ERROR_NONE);
@@ -283,9 +283,9 @@ static void BM_ClosureSched3OnCombiner(benchmark::State& state) {
   grpc_closure c1;
   grpc_closure c2;
   grpc_closure c3;
-  GRPC_CLOSURE_INIT(&c1, DoNothing, NULL, grpc_combiner_scheduler(combiner));
-  GRPC_CLOSURE_INIT(&c2, DoNothing, NULL, grpc_combiner_scheduler(combiner));
-  GRPC_CLOSURE_INIT(&c3, DoNothing, NULL, grpc_combiner_scheduler(combiner));
+  GRPC_CLOSURE_INIT(&c1, DoNothing, nullptr, grpc_combiner_scheduler(combiner));
+  GRPC_CLOSURE_INIT(&c2, DoNothing, nullptr, grpc_combiner_scheduler(combiner));
+  GRPC_CLOSURE_INIT(&c3, DoNothing, nullptr, grpc_combiner_scheduler(combiner));
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
     GRPC_CLOSURE_SCHED(&exec_ctx, &c1, GRPC_ERROR_NONE);
@@ -305,8 +305,10 @@ static void BM_ClosureSched2OnTwoCombiners(benchmark::State& state) {
   grpc_combiner* combiner2 = grpc_combiner_create();
   grpc_closure c1;
   grpc_closure c2;
-  GRPC_CLOSURE_INIT(&c1, DoNothing, NULL, grpc_combiner_scheduler(combiner1));
-  GRPC_CLOSURE_INIT(&c2, DoNothing, NULL, grpc_combiner_scheduler(combiner2));
+  GRPC_CLOSURE_INIT(&c1, DoNothing, nullptr,
+                    grpc_combiner_scheduler(combiner1));
+  GRPC_CLOSURE_INIT(&c2, DoNothing, nullptr,
+                    grpc_combiner_scheduler(combiner2));
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
     GRPC_CLOSURE_SCHED(&exec_ctx, &c1, GRPC_ERROR_NONE);
@@ -328,10 +330,14 @@ static void BM_ClosureSched4OnTwoCombiners(benchmark::State& state) {
   grpc_closure c2;
   grpc_closure c3;
   grpc_closure c4;
-  GRPC_CLOSURE_INIT(&c1, DoNothing, NULL, grpc_combiner_scheduler(combiner1));
-  GRPC_CLOSURE_INIT(&c2, DoNothing, NULL, grpc_combiner_scheduler(combiner2));
-  GRPC_CLOSURE_INIT(&c3, DoNothing, NULL, grpc_combiner_scheduler(combiner1));
-  GRPC_CLOSURE_INIT(&c4, DoNothing, NULL, grpc_combiner_scheduler(combiner2));
+  GRPC_CLOSURE_INIT(&c1, DoNothing, nullptr,
+                    grpc_combiner_scheduler(combiner1));
+  GRPC_CLOSURE_INIT(&c2, DoNothing, nullptr,
+                    grpc_combiner_scheduler(combiner2));
+  GRPC_CLOSURE_INIT(&c3, DoNothing, nullptr,
+                    grpc_combiner_scheduler(combiner1));
+  GRPC_CLOSURE_INIT(&c4, DoNothing, nullptr,
+                    grpc_combiner_scheduler(combiner2));
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
     GRPC_CLOSURE_SCHED(&exec_ctx, &c1, GRPC_ERROR_NONE);
diff --git a/test/cpp/microbenchmarks/bm_cq.cc b/test/cpp/microbenchmarks/bm_cq.cc
index a0c0414f2f..f0dede7333 100644
--- a/test/cpp/microbenchmarks/bm_cq.cc
+++ b/test/cpp/microbenchmarks/bm_cq.cc
@@ -26,9 +26,7 @@
 #include <grpc/support/log.h>
 #include "test/cpp/microbenchmarks/helpers.h"
 
-extern "C" {
 #include "src/core/lib/surface/completion_queue.h"
-}
 
 namespace grpc {
 namespace testing {
@@ -49,7 +47,7 @@ static void BM_CreateDestroyCpp2(benchmark::State& state) {
   TrackCounters track_counters;
   while (state.KeepRunning()) {
     grpc_completion_queue* core_cq =
-        grpc_completion_queue_create_for_next(NULL);
+        grpc_completion_queue_create_for_next(nullptr);
     CompletionQueue cq(core_cq);
   }
   track_counters.Finish(state);
@@ -61,7 +59,8 @@ static void BM_CreateDestroyCore(benchmark::State& state) {
   while (state.KeepRunning()) {
     // TODO: sreek Templatize this benchmark and pass completion type and
     // polling type as parameters
-    grpc_completion_queue_destroy(grpc_completion_queue_create_for_next(NULL));
+    grpc_completion_queue_destroy(
+        grpc_completion_queue_create_for_next(nullptr));
   }
   track_counters.Finish(state);
 }
@@ -70,7 +69,7 @@ BENCHMARK(BM_CreateDestroyCore);
 static void DoneWithCompletionOnStack(grpc_exec_ctx* exec_ctx, void* arg,
                                       grpc_cq_completion* completion) {}
 
-class DummyTag final : public CompletionQueueTag {
+class DummyTag final : public internal::CompletionQueueTag {
  public:
   bool FinalizeResult(void** tag, bool* status) override { return true; }
 };
@@ -85,7 +84,7 @@ static void BM_Pass1Cpp(benchmark::State& state) {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     GPR_ASSERT(grpc_cq_begin_op(c_cq, &dummy_tag));
     grpc_cq_end_op(&exec_ctx, c_cq, &dummy_tag, GRPC_ERROR_NONE,
-                   DoneWithCompletionOnStack, NULL, &completion);
+                   DoneWithCompletionOnStack, nullptr, &completion);
     grpc_exec_ctx_finish(&exec_ctx);
     void* tag;
     bool ok;
@@ -98,16 +97,16 @@ BENCHMARK(BM_Pass1Cpp);
 static void BM_Pass1Core(benchmark::State& state) {
   TrackCounters track_counters;
   // TODO: sreek Templatize this benchmark and pass polling_type as a param
-  grpc_completion_queue* cq = grpc_completion_queue_create_for_next(NULL);
+  grpc_completion_queue* cq = grpc_completion_queue_create_for_next(nullptr);
   gpr_timespec deadline = gpr_inf_future(GPR_CLOCK_MONOTONIC);
   while (state.KeepRunning()) {
     grpc_cq_completion completion;
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    GPR_ASSERT(grpc_cq_begin_op(cq, NULL));
-    grpc_cq_end_op(&exec_ctx, cq, NULL, GRPC_ERROR_NONE,
-                   DoneWithCompletionOnStack, NULL, &completion);
+    GPR_ASSERT(grpc_cq_begin_op(cq, nullptr));
+    grpc_cq_end_op(&exec_ctx, cq, nullptr, GRPC_ERROR_NONE,
+                   DoneWithCompletionOnStack, nullptr, &completion);
     grpc_exec_ctx_finish(&exec_ctx);
-    grpc_completion_queue_next(cq, deadline, NULL);
+    grpc_completion_queue_next(cq, deadline, nullptr);
   }
   grpc_completion_queue_destroy(cq);
   track_counters.Finish(state);
@@ -117,16 +116,16 @@ BENCHMARK(BM_Pass1Core);
 static void BM_Pluck1Core(benchmark::State& state) {
   TrackCounters track_counters;
   // TODO: sreek Templatize this benchmark and pass polling_type as a param
-  grpc_completion_queue* cq = grpc_completion_queue_create_for_pluck(NULL);
+  grpc_completion_queue* cq = grpc_completion_queue_create_for_pluck(nullptr);
   gpr_timespec deadline = gpr_inf_future(GPR_CLOCK_MONOTONIC);
   while (state.KeepRunning()) {
     grpc_cq_completion completion;
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    GPR_ASSERT(grpc_cq_begin_op(cq, NULL));
-    grpc_cq_end_op(&exec_ctx, cq, NULL, GRPC_ERROR_NONE,
-                   DoneWithCompletionOnStack, NULL, &completion);
+    GPR_ASSERT(grpc_cq_begin_op(cq, nullptr));
+    grpc_cq_end_op(&exec_ctx, cq, nullptr, GRPC_ERROR_NONE,
+                   DoneWithCompletionOnStack, nullptr, &completion);
     grpc_exec_ctx_finish(&exec_ctx);
-    grpc_completion_queue_pluck(cq, NULL, deadline, NULL);
+    grpc_completion_queue_pluck(cq, nullptr, deadline, nullptr);
   }
   grpc_completion_queue_destroy(cq);
   track_counters.Finish(state);
@@ -136,10 +135,10 @@ BENCHMARK(BM_Pluck1Core);
 static void BM_EmptyCore(benchmark::State& state) {
   TrackCounters track_counters;
   // TODO: sreek Templatize this benchmark and pass polling_type as a param
-  grpc_completion_queue* cq = grpc_completion_queue_create_for_next(NULL);
+  grpc_completion_queue* cq = grpc_completion_queue_create_for_next(nullptr);
   gpr_timespec deadline = gpr_inf_past(GPR_CLOCK_MONOTONIC);
   while (state.KeepRunning()) {
-    grpc_completion_queue_next(cq, deadline, NULL);
+    grpc_completion_queue_next(cq, deadline, nullptr);
   }
   grpc_completion_queue_destroy(cq);
   track_counters.Finish(state);
diff --git a/test/cpp/microbenchmarks/bm_cq_multiple_threads.cc b/test/cpp/microbenchmarks/bm_cq_multiple_threads.cc
index 57a69acf01..7ccebb55ee 100644
--- a/test/cpp/microbenchmarks/bm_cq_multiple_threads.cc
+++ b/test/cpp/microbenchmarks/bm_cq_multiple_threads.cc
@@ -25,11 +25,9 @@
 #include <grpc/support/log.h>
 #include "test/cpp/microbenchmarks/helpers.h"
 
-extern "C" {
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/surface/completion_queue.h"
-}
 
 struct grpc_pollset {
   gpr_mu mu;
@@ -82,7 +80,7 @@ static grpc_error* pollset_work(grpc_exec_ctx* exec_ctx, grpc_pollset* ps,
 
   gpr_mu_unlock(&ps->mu);
   GPR_ASSERT(grpc_cq_begin_op(g_cq, g_tag));
-  grpc_cq_end_op(exec_ctx, g_cq, g_tag, GRPC_ERROR_NONE, cq_done_cb, NULL,
+  grpc_cq_end_op(exec_ctx, g_cq, g_tag, GRPC_ERROR_NONE, cq_done_cb, nullptr,
                  (grpc_cq_completion*)gpr_malloc(sizeof(grpc_cq_completion)));
   grpc_exec_ctx_flush(exec_ctx);
   gpr_mu_lock(&ps->mu);
@@ -110,7 +108,7 @@ static void setup() {
   g_old_vtable = grpc_get_event_engine_test_only();
   grpc_set_event_engine_test_only(&g_vtable);
 
-  g_cq = grpc_completion_queue_create_for_next(NULL);
+  g_cq = grpc_completion_queue_create_for_next(nullptr);
 }
 
 static void teardown() {
@@ -118,7 +116,7 @@ static void teardown() {
 
   /* Drain any events */
   gpr_timespec deadline = gpr_time_0(GPR_CLOCK_MONOTONIC);
-  while (grpc_completion_queue_next(g_cq, deadline, NULL).type !=
+  while (grpc_completion_queue_next(g_cq, deadline, nullptr).type !=
          GRPC_QUEUE_SHUTDOWN) {
     /* Do nothing */
   }
@@ -153,7 +151,7 @@ static void BM_Cq_Throughput(benchmark::State& state) {
   }
 
   while (state.KeepRunning()) {
-    GPR_ASSERT(grpc_completion_queue_next(g_cq, deadline, NULL).type ==
+    GPR_ASSERT(grpc_completion_queue_next(g_cq, deadline, nullptr).type ==
                GRPC_OP_COMPLETE);
   }
 
diff --git a/test/cpp/microbenchmarks/bm_error.cc b/test/cpp/microbenchmarks/bm_error.cc
index 56b80dfcf6..bbd8b3c339 100644
--- a/test/cpp/microbenchmarks/bm_error.cc
+++ b/test/cpp/microbenchmarks/bm_error.cc
@@ -21,10 +21,8 @@
 #include <benchmark/benchmark.h>
 #include <memory>
 
-extern "C" {
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/transport/error_utils.h"
-}
 
 #include "test/cpp/microbenchmarks/helpers.h"
 
@@ -253,7 +251,7 @@ static void BM_ErrorGetStatus(benchmark::State& state) {
     grpc_status_code status;
     grpc_slice slice;
     grpc_error_get_status(&exec_ctx, fixture.error(), fixture.deadline(),
-                          &status, &slice, NULL);
+                          &status, &slice, nullptr, nullptr);
   }
   grpc_exec_ctx_finish(&exec_ctx);
   track_counters.Finish(state);
@@ -267,7 +265,7 @@ static void BM_ErrorGetStatusCode(benchmark::State& state) {
   while (state.KeepRunning()) {
     grpc_status_code status;
     grpc_error_get_status(&exec_ctx, fixture.error(), fixture.deadline(),
-                          &status, NULL, NULL);
+                          &status, nullptr, nullptr, nullptr);
   }
   grpc_exec_ctx_finish(&exec_ctx);
   track_counters.Finish(state);
@@ -280,8 +278,8 @@ static void BM_ErrorHttpError(benchmark::State& state) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
     grpc_http2_error_code error;
-    grpc_error_get_status(&exec_ctx, fixture.error(), fixture.deadline(), NULL,
-                          NULL, &error);
+    grpc_error_get_status(&exec_ctx, fixture.error(), fixture.deadline(),
+                          nullptr, nullptr, &error, nullptr);
   }
   grpc_exec_ctx_finish(&exec_ctx);
   track_counters.Finish(state);
diff --git a/test/cpp/microbenchmarks/bm_fullstack_trickle.cc b/test/cpp/microbenchmarks/bm_fullstack_trickle.cc
index 389b8c90ab..bb974fad50 100644
--- a/test/cpp/microbenchmarks/bm_fullstack_trickle.cc
+++ b/test/cpp/microbenchmarks/bm_fullstack_trickle.cc
@@ -21,6 +21,7 @@
 #include <benchmark/benchmark.h>
 #include <gflags/gflags.h>
 #include <fstream>
+
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/lib/iomgr/timer_manager.h"
@@ -134,25 +135,26 @@ class TrickledCHTTP2 : public EndpointPairFixture {
             ? static_cast<grpc_chttp2_stream*>(server->stream_map.values[0])
             : nullptr;
     write_csv(
-        log_.get(), static_cast<double>(now.tv_sec) +
-                        1e-9 * static_cast<double>(now.tv_nsec),
+        log_.get(),
+        static_cast<double>(now.tv_sec) +
+            1e-9 * static_cast<double>(now.tv_nsec),
         iteration, grpc_trickle_get_backlog(endpoint_pair_.client),
         grpc_trickle_get_backlog(endpoint_pair_.server),
         client->lists[GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT].head != nullptr,
         client->lists[GRPC_CHTTP2_LIST_STALLED_BY_STREAM].head != nullptr,
         server->lists[GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT].head != nullptr,
         server->lists[GRPC_CHTTP2_LIST_STALLED_BY_STREAM].head != nullptr,
-        client->flow_control->remote_window(),
-        server->flow_control->remote_window(),
-        client->flow_control->announced_window(),
-        server->flow_control->announced_window(),
-        client_stream ? client_stream->flow_control->remote_window_delta() : -1,
-        server_stream ? server_stream->flow_control->remote_window_delta() : -1,
-        client_stream ? client_stream->flow_control->local_window_delta() : -1,
-        server_stream ? server_stream->flow_control->local_window_delta() : -1,
-        client_stream ? client_stream->flow_control->announced_window_delta()
+        client->flow_control->remote_window_,
+        server->flow_control->remote_window_,
+        client->flow_control->announced_window_,
+        server->flow_control->announced_window_,
+        client_stream ? client_stream->flow_control->remote_window_delta_ : -1,
+        server_stream ? server_stream->flow_control->remote_window_delta_ : -1,
+        client_stream ? client_stream->flow_control->local_window_delta_ : -1,
+        server_stream ? server_stream->flow_control->local_window_delta_ : -1,
+        client_stream ? client_stream->flow_control->announced_window_delta_
                       : -1,
-        server_stream ? server_stream->flow_control->announced_window_delta()
+        server_stream ? server_stream->flow_control->announced_window_delta_
                       : -1,
         client->settings[GRPC_PEER_SETTINGS]
                         [GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE],
@@ -214,10 +216,10 @@ class TrickledCHTTP2 : public EndpointPairFixture {
   void UpdateStats(grpc_chttp2_transport* t, Stats* s,
                    size_t backlog) GPR_ATTRIBUTE_NO_TSAN {
     if (backlog == 0) {
-      if (t->lists[GRPC_CHTTP2_LIST_STALLED_BY_STREAM].head != NULL) {
+      if (t->lists[GRPC_CHTTP2_LIST_STALLED_BY_STREAM].head != nullptr) {
         s->streams_stalled_due_to_stream_flow_control++;
       }
-      if (t->lists[GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT].head != NULL) {
+      if (t->lists[GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT].head != nullptr) {
         s->streams_stalled_due_to_transport_flow_control++;
       }
     }
@@ -440,8 +442,8 @@ static void UnaryTrickleArgs(benchmark::internal::Benchmark* b) {
   }
 }
 BENCHMARK(BM_PumpUnbalancedUnary_Trickle)->Apply(UnaryTrickleArgs);
-}
-}
+}  // namespace testing
+}  // namespace grpc
 
 extern "C" gpr_timespec (*gpr_now_impl)(gpr_clock_type clock_type);
 
diff --git a/test/cpp/microbenchmarks/bm_metadata.cc b/test/cpp/microbenchmarks/bm_metadata.cc
index 360bbabe13..73bce08466 100644
--- a/test/cpp/microbenchmarks/bm_metadata.cc
+++ b/test/cpp/microbenchmarks/bm_metadata.cc
@@ -21,10 +21,8 @@
 #include <benchmark/benchmark.h>
 #include <grpc/grpc.h>
 
-extern "C" {
 #include "src/core/lib/transport/metadata.h"
 #include "src/core/lib/transport/static_metadata.h"
-}
 
 #include "test/cpp/microbenchmarks/helpers.h"
 
@@ -94,7 +92,7 @@ static void BM_MetadataFromNonInternedSlices(benchmark::State& state) {
   gpr_slice v = grpc_slice_from_static_string("value");
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
-    GRPC_MDELEM_UNREF(&exec_ctx, grpc_mdelem_create(&exec_ctx, k, v, NULL));
+    GRPC_MDELEM_UNREF(&exec_ctx, grpc_mdelem_create(&exec_ctx, k, v, nullptr));
   }
   grpc_exec_ctx_finish(&exec_ctx);
   track_counters.Finish(state);
@@ -107,7 +105,7 @@ static void BM_MetadataFromInternedSlices(benchmark::State& state) {
   gpr_slice v = grpc_slice_intern(grpc_slice_from_static_string("value"));
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
-    GRPC_MDELEM_UNREF(&exec_ctx, grpc_mdelem_create(&exec_ctx, k, v, NULL));
+    GRPC_MDELEM_UNREF(&exec_ctx, grpc_mdelem_create(&exec_ctx, k, v, nullptr));
   }
   grpc_exec_ctx_finish(&exec_ctx);
   grpc_slice_unref(k);
@@ -122,9 +120,9 @@ static void BM_MetadataFromInternedSlicesAlreadyInIndex(
   gpr_slice k = grpc_slice_intern(grpc_slice_from_static_string("key"));
   gpr_slice v = grpc_slice_intern(grpc_slice_from_static_string("value"));
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_mdelem seed = grpc_mdelem_create(&exec_ctx, k, v, NULL);
+  grpc_mdelem seed = grpc_mdelem_create(&exec_ctx, k, v, nullptr);
   while (state.KeepRunning()) {
-    GRPC_MDELEM_UNREF(&exec_ctx, grpc_mdelem_create(&exec_ctx, k, v, NULL));
+    GRPC_MDELEM_UNREF(&exec_ctx, grpc_mdelem_create(&exec_ctx, k, v, nullptr));
   }
   GRPC_MDELEM_UNREF(&exec_ctx, seed);
   grpc_exec_ctx_finish(&exec_ctx);
@@ -140,7 +138,7 @@ static void BM_MetadataFromInternedKey(benchmark::State& state) {
   gpr_slice v = grpc_slice_from_static_string("value");
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
-    GRPC_MDELEM_UNREF(&exec_ctx, grpc_mdelem_create(&exec_ctx, k, v, NULL));
+    GRPC_MDELEM_UNREF(&exec_ctx, grpc_mdelem_create(&exec_ctx, k, v, nullptr));
   }
   grpc_exec_ctx_finish(&exec_ctx);
   grpc_slice_unref(k);
@@ -211,7 +209,7 @@ static void BM_MetadataFromStaticMetadataStrings(benchmark::State& state) {
   gpr_slice v = GRPC_MDSTR_200;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
-    GRPC_MDELEM_UNREF(&exec_ctx, grpc_mdelem_create(&exec_ctx, k, v, NULL));
+    GRPC_MDELEM_UNREF(&exec_ctx, grpc_mdelem_create(&exec_ctx, k, v, nullptr));
   }
   grpc_exec_ctx_finish(&exec_ctx);
   grpc_slice_unref(k);
@@ -226,7 +224,7 @@ static void BM_MetadataFromStaticMetadataStringsNotIndexed(
   gpr_slice v = GRPC_MDSTR_GZIP;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
-    GRPC_MDELEM_UNREF(&exec_ctx, grpc_mdelem_create(&exec_ctx, k, v, NULL));
+    GRPC_MDELEM_UNREF(&exec_ctx, grpc_mdelem_create(&exec_ctx, k, v, nullptr));
   }
   grpc_exec_ctx_finish(&exec_ctx);
   grpc_slice_unref(k);
@@ -275,7 +273,7 @@ static void BM_MetadataRefUnrefAllocated(benchmark::State& state) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_mdelem el =
       grpc_mdelem_create(&exec_ctx, grpc_slice_from_static_string("a"),
-                         grpc_slice_from_static_string("b"), NULL);
+                         grpc_slice_from_static_string("b"), nullptr);
   while (state.KeepRunning()) {
     GRPC_MDELEM_UNREF(&exec_ctx, GRPC_MDELEM_REF(el));
   }
@@ -289,7 +287,7 @@ static void BM_MetadataRefUnrefStatic(benchmark::State& state) {
   TrackCounters track_counters;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_mdelem el =
-      grpc_mdelem_create(&exec_ctx, GRPC_MDSTR_STATUS, GRPC_MDSTR_200, NULL);
+      grpc_mdelem_create(&exec_ctx, GRPC_MDSTR_STATUS, GRPC_MDSTR_200, nullptr);
   while (state.KeepRunning()) {
     GRPC_MDELEM_UNREF(&exec_ctx, GRPC_MDELEM_REF(el));
   }
diff --git a/test/cpp/microbenchmarks/bm_pollset.cc b/test/cpp/microbenchmarks/bm_pollset.cc
index eab1e89480..4da79693f1 100644
--- a/test/cpp/microbenchmarks/bm_pollset.cc
+++ b/test/cpp/microbenchmarks/bm_pollset.cc
@@ -23,12 +23,10 @@
 #include <grpc/support/log.h>
 #include <grpc/support/useful.h>
 
-extern "C" {
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/pollset.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
-}
 
 #include "test/cpp/microbenchmarks/helpers.h"
 #include "third_party/benchmark/include/benchmark/benchmark.h"
@@ -119,7 +117,7 @@ static void BM_PollEmptyPollset(benchmark::State& state) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   gpr_mu_lock(mu);
   while (state.KeepRunning()) {
-    GRPC_ERROR_UNREF(grpc_pollset_work(&exec_ctx, ps, NULL, 0));
+    GRPC_ERROR_UNREF(grpc_pollset_work(&exec_ctx, ps, nullptr, 0));
   }
   grpc_closure shutdown_ps_closure;
   GRPC_CLOSURE_INIT(&shutdown_ps_closure, shutdown_ps, ps,
@@ -147,7 +145,8 @@ static void BM_PollAddFd(benchmark::State& state) {
     grpc_pollset_add_fd(&exec_ctx, ps, fd);
     grpc_exec_ctx_flush(&exec_ctx);
   }
-  grpc_fd_orphan(&exec_ctx, fd, NULL, NULL, false /* already_closed */, "xxx");
+  grpc_fd_orphan(&exec_ctx, fd, nullptr, nullptr, false /* already_closed */,
+                 "xxx");
   grpc_closure shutdown_ps_closure;
   GRPC_CLOSURE_INIT(&shutdown_ps_closure, shutdown_ps, ps,
                     grpc_schedule_on_exec_ctx);
@@ -242,10 +241,10 @@ static void BM_SingleThreadPollOneFd(benchmark::State& state) {
   gpr_mu_lock(mu);
   while (!done) {
     GRPC_ERROR_UNREF(
-        grpc_pollset_work(&exec_ctx, ps, NULL, GRPC_MILLIS_INF_FUTURE));
+        grpc_pollset_work(&exec_ctx, ps, nullptr, GRPC_MILLIS_INF_FUTURE));
   }
-  grpc_fd_orphan(&exec_ctx, wakeup, NULL, NULL, false /* already_closed */,
-                 "done");
+  grpc_fd_orphan(&exec_ctx, wakeup, nullptr, nullptr,
+                 false /* already_closed */, "done");
   wakeup_fd.read_fd = 0;
   grpc_closure shutdown_ps_closure;
   GRPC_CLOSURE_INIT(&shutdown_ps_closure, shutdown_ps, ps,
diff --git a/test/cpp/microbenchmarks/fullstack_fixtures.h b/test/cpp/microbenchmarks/fullstack_fixtures.h
index a7f8504505..7f1aa48b56 100644
--- a/test/cpp/microbenchmarks/fullstack_fixtures.h
+++ b/test/cpp/microbenchmarks/fullstack_fixtures.h
@@ -25,9 +25,9 @@
 #include <grpc++/security/server_credentials.h>
 #include <grpc++/server.h>
 #include <grpc++/server_builder.h>
+#include <grpc/support/atm.h>
 #include <grpc/support/log.h>
 
-extern "C" {
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/endpoint.h"
@@ -39,7 +39,6 @@ extern "C" {
 #include "src/core/lib/surface/server.h"
 #include "test/core/util/passthru_endpoint.h"
 #include "test/core/util/port.h"
-}
 
 #include "src/cpp/client/create_channel_internal.h"
 #include "test/cpp/microbenchmarks/helpers.h"
@@ -186,8 +185,9 @@ class EndpointPairFixture : public BaseFixture {
       }
 
       grpc_server_setup_transport(&exec_ctx, server_->c_server(),
-                                  server_transport_, NULL, server_args);
-      grpc_chttp2_transport_start_reading(&exec_ctx, server_transport_, NULL);
+                                  server_transport_, nullptr, server_args);
+      grpc_chttp2_transport_start_reading(&exec_ctx, server_transport_,
+                                          nullptr);
     }
 
     /* create channel */
@@ -203,7 +203,8 @@ class EndpointPairFixture : public BaseFixture {
       grpc_channel* channel =
           grpc_channel_create(&exec_ctx, "target", &c_args,
                               GRPC_CLIENT_DIRECT_CHANNEL, client_transport_);
-      grpc_chttp2_transport_start_reading(&exec_ctx, client_transport_, NULL);
+      grpc_chttp2_transport_start_reading(&exec_ctx, client_transport_,
+                                          nullptr);
 
       channel_ = CreateChannelInternal("", channel);
     }
@@ -245,7 +246,7 @@ class SockPair : public EndpointPairFixture {
   SockPair(Service* service, const FixtureConfiguration& fixture_configuration =
                                  FixtureConfiguration())
       : EndpointPairFixture(service,
-                            grpc_iomgr_create_endpoint_pair("test", NULL),
+                            grpc_iomgr_create_endpoint_pair("test", nullptr),
                             fixture_configuration) {}
 };
 
@@ -259,7 +260,8 @@ class InProcessCHTTP2 : public EndpointPairFixture {
   void AddToLabel(std::ostream& out, benchmark::State& state) {
     EndpointPairFixture::AddToLabel(out, state);
     out << " writes/iter:"
-        << (double)stats_.num_writes / (double)state.iterations();
+        << static_cast<double>(gpr_atm_no_barrier_load(&stats_.num_writes)) /
+               static_cast<double>(state.iterations());
   }
 
  private:
diff --git a/test/cpp/microbenchmarks/fullstack_streaming_ping_pong.h b/test/cpp/microbenchmarks/fullstack_streaming_ping_pong.h
index 6df044f344..0763d07855 100644
--- a/test/cpp/microbenchmarks/fullstack_streaming_ping_pong.h
+++ b/test/cpp/microbenchmarks/fullstack_streaming_ping_pong.h
@@ -278,7 +278,7 @@ static void BM_StreamingPingPongWithCoalescingApi(benchmark::State& state) {
 
       void* t;
       bool ok;
-      int need_tags;
+      int expect_tags = 0;
 
       // Send 'max_ping_pongs' number of ping pong messages
       int ping_pong_cnt = 0;
@@ -289,7 +289,7 @@ static void BM_StreamingPingPongWithCoalescingApi(benchmark::State& state) {
           request_rw->Write(send_request, tag(2));  // Start client send
         }
 
-        need_tags = (1 << 2) | (1 << 3) | (1 << 4) | (1 << 5);
+        int await_tags = (1 << 2);
 
         if (ping_pong_cnt == 0) {
           // wait for the server call structure (call_hook, etc.) to be
@@ -301,8 +301,8 @@ static void BM_StreamingPingPongWithCoalescingApi(benchmark::State& state) {
             // In some cases tag:2 comes before tag:0 (write tag comes out
             // first), this while loop is to make sure get tag:0.
             int i = (int)(intptr_t)t;
-            GPR_ASSERT(need_tags & (1 << i));
-            need_tags &= ~(1 << i);
+            GPR_ASSERT(await_tags & (1 << i));
+            await_tags &= ~(1 << i);
             GPR_ASSERT(fixture->cq()->Next(&t, &ok));
           }
         }
@@ -310,7 +310,11 @@ static void BM_StreamingPingPongWithCoalescingApi(benchmark::State& state) {
         response_rw.Read(&recv_request, tag(3));   // Start server recv
         request_rw->Read(&recv_response, tag(4));  // Start client recv
 
-        while (need_tags) {
+        await_tags |= (1 << 3) | (1 << 4);
+        expect_tags = await_tags;
+        await_tags |= (1 << 5);
+
+        while (await_tags != 0) {
           GPR_ASSERT(fixture->cq()->Next(&t, &ok));
           GPR_ASSERT(ok);
           int i = (int)(intptr_t)t;
@@ -321,34 +325,39 @@ static void BM_StreamingPingPongWithCoalescingApi(benchmark::State& state) {
               if (write_and_finish == 1) {
                 response_rw.WriteAndFinish(send_response, WriteOptions(),
                                            Status::OK, tag(5));
+                expect_tags |= (1 << 5);
               } else {
                 response_rw.WriteLast(send_response, WriteOptions(), tag(5));
-                // WriteLast buffers the write, so neither server write op nor
-                // client read op will finish inside the while loop.
-                need_tags &= ~(1 << 4);
-                need_tags &= ~(1 << 5);
+                // WriteLast buffers the write, so it's possible neither server
+                // write op nor client read op will finish inside the while
+                // loop.
+                await_tags &= ~(1 << 4);
+                await_tags &= ~(1 << 5);
+                expect_tags |= (1 << 5);
               }
             } else {
               response_rw.Write(send_response, tag(5));
+              expect_tags |= (1 << 5);
             }
           }
 
-          GPR_ASSERT(need_tags & (1 << i));
-          need_tags &= ~(1 << i);
+          GPR_ASSERT(expect_tags & (1 << i));
+          expect_tags &= ~(1 << i);
+          await_tags &= ~(1 << i);
         }
 
         ping_pong_cnt++;
       }
 
       if (max_ping_pongs == 0) {
-        need_tags = (1 << 6) | (1 << 7) | (1 << 8);
+        expect_tags |= (1 << 6) | (1 << 7) | (1 << 8);
       } else {
         if (write_and_finish == 1) {
-          need_tags = (1 << 8);
+          expect_tags |= (1 << 8);
         } else {
           // server's buffered write and the client's read of the buffered write
           // tags should come up.
-          need_tags = (1 << 4) | (1 << 5) | (1 << 7) | (1 << 8);
+          expect_tags |= (1 << 7) | (1 << 8);
         }
       }
 
@@ -360,8 +369,8 @@ static void BM_StreamingPingPongWithCoalescingApi(benchmark::State& state) {
         GPR_ASSERT(fixture->cq()->Next(&t, &ok));
         while ((int)(intptr_t)t != 0) {
           int i = (int)(intptr_t)t;
-          GPR_ASSERT(need_tags & (1 << i));
-          need_tags &= ~(1 << i);
+          GPR_ASSERT(expect_tags & (1 << i));
+          expect_tags &= ~(1 << i);
           GPR_ASSERT(fixture->cq()->Next(&t, &ok));
         }
         response_rw.Finish(Status::OK, tag(7));
@@ -374,11 +383,11 @@ static void BM_StreamingPingPongWithCoalescingApi(benchmark::State& state) {
       Status recv_status;
       request_rw->Finish(&recv_status, tag(8));
 
-      while (need_tags) {
+      while (expect_tags) {
         GPR_ASSERT(fixture->cq()->Next(&t, &ok));
         int i = (int)(intptr_t)t;
-        GPR_ASSERT(need_tags & (1 << i));
-        need_tags &= ~(1 << i);
+        GPR_ASSERT(expect_tags & (1 << i));
+        expect_tags &= ~(1 << i);
       }
 
       GPR_ASSERT(recv_status.ok());
diff --git a/test/cpp/microbenchmarks/helpers.cc b/test/cpp/microbenchmarks/helpers.cc
index 6802a0aa99..a4c0a3a0ce 100644
--- a/test/cpp/microbenchmarks/helpers.cc
+++ b/test/cpp/microbenchmarks/helpers.cc
@@ -16,11 +16,13 @@
  *
  */
 
+#include <string.h>
+
 #include "test/cpp/microbenchmarks/helpers.h"
 
-void TrackCounters::Finish(benchmark::State &state) {
+void TrackCounters::Finish(benchmark::State& state) {
   std::ostringstream out;
-  for (const auto &l : labels_) {
+  for (const auto& l : labels_) {
     out << l << ' ';
   }
   AddToLabel(out, state);
@@ -31,11 +33,11 @@ void TrackCounters::Finish(benchmark::State &state) {
   state.SetLabel(label.c_str());
 }
 
-void TrackCounters::AddLabel(const grpc::string &label) {
+void TrackCounters::AddLabel(const grpc::string& label) {
   labels_.push_back(label);
 }
 
-void TrackCounters::AddToLabel(std::ostream &out, benchmark::State &state) {
+void TrackCounters::AddToLabel(std::ostream& out, benchmark::State& state) {
   grpc_stats_data stats_end;
   grpc_stats_collect(&stats_end);
   grpc_stats_data stats;
@@ -45,16 +47,21 @@ void TrackCounters::AddToLabel(std::ostream &out, benchmark::State &state) {
         << "/iter:" << ((double)stats.counters[i] / (double)state.iterations());
   }
   for (int i = 0; i < GRPC_STATS_HISTOGRAM_COUNT; i++) {
-    out << " " << grpc_stats_histogram_name[i] << "-median:"
-        << grpc_stats_histo_percentile(&stats, (grpc_stats_histograms)i, 50.0)
-        << " " << grpc_stats_histogram_name[i] << "-99p:"
-        << grpc_stats_histo_percentile(&stats, (grpc_stats_histograms)i, 99.0);
+    std::ostringstream median_ss;
+    median_ss << grpc_stats_histogram_name[i] << "-median";
+    state.counters[median_ss.str()] = benchmark::Counter(
+        grpc_stats_histo_percentile(&stats, (grpc_stats_histograms)i, 50.0));
+    std::ostringstream tail_ss;
+    tail_ss << grpc_stats_histogram_name[i] << "-99p";
+    state.counters[tail_ss.str()] = benchmark::Counter(
+        grpc_stats_histo_percentile(&stats, (grpc_stats_histograms)i, 99.0));
   }
 #ifdef GPR_LOW_LEVEL_COUNTERS
   grpc_memory_counters counters_at_end = grpc_memory_counters_snapshot();
-  out << " locks/iter:" << ((double)(gpr_atm_no_barrier_load(&gpr_mu_locks) -
-                                     mu_locks_at_start_) /
-                            (double)state.iterations())
+  out << " locks/iter:"
+      << ((double)(gpr_atm_no_barrier_load(&gpr_mu_locks) -
+                   mu_locks_at_start_) /
+          (double)state.iterations())
       << " atm_cas/iter:"
       << ((double)(gpr_atm_no_barrier_load(&gpr_counter_atm_cas) -
                    atm_cas_at_start_) /
diff --git a/test/cpp/microbenchmarks/helpers.h b/test/cpp/microbenchmarks/helpers.h
index b6cea7c317..07be589df6 100644
--- a/test/cpp/microbenchmarks/helpers.h
+++ b/test/cpp/microbenchmarks/helpers.h
@@ -22,11 +22,9 @@
 #include <sstream>
 #include <vector>
 
-extern "C" {
 #include <grpc/support/port_platform.h>
 #include "src/core/lib/debug/stats.h"
 #include "test/core/util/memory_counters.h"
-}
 
 #include <benchmark/benchmark.h>
 #include <grpc++/impl/grpc_library.h>
diff --git a/test/cpp/naming/README.md b/test/cpp/naming/README.md
index e33184620c..e0dd208465 100644
--- a/test/cpp/naming/README.md
+++ b/test/cpp/naming/README.md
@@ -31,7 +31,7 @@ After making a change to `resolver_test_record_groups.yaml`:
 3. From the repo root, run:
 
 ```
-$ test/cpp/naming/create_dns_private_zone.sh
+$ test/cpp/naming/create_private_dns_zone.sh
 $ test/cpp/naming/private_dns_zone_init.sh
 ```
 
diff --git a/test/cpp/naming/create_private_dns_zone.sh b/test/cpp/naming/create_private_dns_zone.sh
index 3d7520b90a..55a4cfe36e 100755
--- a/test/cpp/naming/create_private_dns_zone.sh
+++ b/test/cpp/naming/create_private_dns_zone.sh
@@ -20,8 +20,8 @@ set -ex
 cd $(dirname $0)/../../..
 
 gcloud alpha dns managed-zones create \
-  resolver-tests-version-1-grpctestingexp-zone-id \
-  --dns-name=resolver-tests-version-1.grpctestingexp. \
+  resolver-tests-version-4-grpctestingexp-zone-id \
+  --dns-name=resolver-tests-version-4.grpctestingexp. \
   --description="GCE-DNS-private-zone-for-GRPC-testing" \
   --visibility=private \
   --networks=default
diff --git a/test/cpp/naming/private_dns_zone_init.sh b/test/cpp/naming/private_dns_zone_init.sh
index 4eaf750ab7..8fa5a8a475 100755
--- a/test/cpp/naming/private_dns_zone_init.sh
+++ b/test/cpp/naming/private_dns_zone_init.sh
@@ -19,197 +19,197 @@ set -ex
 
 cd $(dirname $0)/../../..
 
-gcloud dns record-sets transaction start -z=resolver-tests-version-1-grpctestingexp-zone-id
+gcloud dns record-sets transaction start -z=resolver-tests-version-4-grpctestingexp-zone-id
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=_grpclb._tcp.srv-ipv4-single-target.resolver-tests-version-1.grpctestingexp. \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=_grpclb._tcp.srv-ipv4-single-target.resolver-tests-version-4.grpctestingexp. \
   --type=SRV \
   --ttl=2100 \
-  "0 0 1234 ipv4-single-target.resolver-tests-version-1.grpctestingexp."
+  "0 0 1234 ipv4-single-target.resolver-tests-version-4.grpctestingexp."
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=ipv4-single-target.resolver-tests-version-1.grpctestingexp. \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=ipv4-single-target.resolver-tests-version-4.grpctestingexp. \
   --type=A \
   --ttl=2100 \
   "1.2.3.4"
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=_grpclb._tcp.srv-ipv4-multi-target.resolver-tests-version-1.grpctestingexp. \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=_grpclb._tcp.srv-ipv4-multi-target.resolver-tests-version-4.grpctestingexp. \
   --type=SRV \
   --ttl=2100 \
-  "0 0 1234 ipv4-multi-target.resolver-tests-version-1.grpctestingexp."
+  "0 0 1234 ipv4-multi-target.resolver-tests-version-4.grpctestingexp."
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=ipv4-multi-target.resolver-tests-version-1.grpctestingexp. \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=ipv4-multi-target.resolver-tests-version-4.grpctestingexp. \
   --type=A \
   --ttl=2100 \
   "1.2.3.5" "1.2.3.6" "1.2.3.7"
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=_grpclb._tcp.srv-ipv6-single-target.resolver-tests-version-1.grpctestingexp. \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=_grpclb._tcp.srv-ipv6-single-target.resolver-tests-version-4.grpctestingexp. \
   --type=SRV \
   --ttl=2100 \
-  "0 0 1234 ipv6-single-target.resolver-tests-version-1.grpctestingexp."
+  "0 0 1234 ipv6-single-target.resolver-tests-version-4.grpctestingexp."
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=ipv6-single-target.resolver-tests-version-1.grpctestingexp. \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=ipv6-single-target.resolver-tests-version-4.grpctestingexp. \
   --type=AAAA \
   --ttl=2100 \
   "2607:f8b0:400a:801::1001"
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=_grpclb._tcp.srv-ipv6-multi-target.resolver-tests-version-1.grpctestingexp. \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=_grpclb._tcp.srv-ipv6-multi-target.resolver-tests-version-4.grpctestingexp. \
   --type=SRV \
   --ttl=2100 \
-  "0 0 1234 ipv6-multi-target.resolver-tests-version-1.grpctestingexp."
+  "0 0 1234 ipv6-multi-target.resolver-tests-version-4.grpctestingexp."
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=ipv6-multi-target.resolver-tests-version-1.grpctestingexp. \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=ipv6-multi-target.resolver-tests-version-4.grpctestingexp. \
   --type=AAAA \
   --ttl=2100 \
   "2607:f8b0:400a:801::1002" "2607:f8b0:400a:801::1003" "2607:f8b0:400a:801::1004"
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=srv-ipv4-simple-service-config.resolver-tests-version-1.grpctestingexp. \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=_grpc_config.srv-ipv4-simple-service-config.resolver-tests-version-4.grpctestingexp. \
   --type=TXT \
   --ttl=2100 \
   '"grpc_config=[{\"serviceConfig\":{\"loadBalancingPolicy\":\"round_robin\",\"methodConfig\":[{\"name\":[{\"method\":\"Foo\",\"service\":\"SimpleService\",\"waitForReady\":true}]}]}}]"'
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=ipv4-simple-service-config.resolver-tests-version-1.grpctestingexp. \
-  --type=A \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=_grpclb._tcp.srv-ipv4-simple-service-config.resolver-tests-version-4.grpctestingexp. \
+  --type=SRV \
   --ttl=2100 \
-  "1.2.3.4"
+  "0 0 1234 ipv4-simple-service-config.resolver-tests-version-4.grpctestingexp."
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=_grpclb._tcp.srv-ipv4-simple-service-config.resolver-tests-version-1.grpctestingexp. \
-  --type=SRV \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=ipv4-simple-service-config.resolver-tests-version-4.grpctestingexp. \
+  --type=A \
   --ttl=2100 \
-  "0 0 1234 ipv4-simple-service-config.resolver-tests-version-1.grpctestingexp."
+  "1.2.3.4"
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=ipv4-no-srv-simple-service-config.resolver-tests-version-1.grpctestingexp. \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=ipv4-no-srv-simple-service-config.resolver-tests-version-4.grpctestingexp. \
   --type=A \
   --ttl=2100 \
   "1.2.3.4"
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=ipv4-no-srv-simple-service-config.resolver-tests-version-1.grpctestingexp. \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=_grpc_config.ipv4-no-srv-simple-service-config.resolver-tests-version-4.grpctestingexp. \
   --type=TXT \
   --ttl=2100 \
   '"grpc_config=[{\"serviceConfig\":{\"loadBalancingPolicy\":\"round_robin\",\"methodConfig\":[{\"name\":[{\"method\":\"Foo\",\"service\":\"NoSrvSimpleService\",\"waitForReady\":true}]}]}}]"'
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=ipv4-no-config-for-cpp.resolver-tests-version-1.grpctestingexp. \
-  --type=A \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=_grpc_config.ipv4-no-config-for-cpp.resolver-tests-version-4.grpctestingexp. \
+  --type=TXT \
   --ttl=2100 \
-  "1.2.3.4"
+  '"grpc_config=[{\"clientLanguage\":[\"python\"],\"serviceConfig\":{\"loadBalancingPolicy\":\"round_robin\",\"methodConfig\":[{\"name\":[{\"method\":\"Foo\",\"service\":\"PythonService\",\"waitForReady\":true}]}]}}]"'
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=ipv4-no-config-for-cpp.resolver-tests-version-1.grpctestingexp. \
-  --type=TXT \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=ipv4-no-config-for-cpp.resolver-tests-version-4.grpctestingexp. \
+  --type=A \
   --ttl=2100 \
-  '"grpc_config=[{\"clientLanguage\":[\"python\"],\"serviceConfig\":{\"loadBalancingPolicy\":\"round_robin\",\"methodConfig\":[{\"name\":[{\"method\":\"Foo\",\"service\":\"PythonService\",\"waitForReady\":true}]}]}}]"'
+  "1.2.3.4"
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=ipv4-cpp-config-has-zero-percentage.resolver-tests-version-1.grpctestingexp. \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=ipv4-cpp-config-has-zero-percentage.resolver-tests-version-4.grpctestingexp. \
   --type=A \
   --ttl=2100 \
   "1.2.3.4"
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=ipv4-cpp-config-has-zero-percentage.resolver-tests-version-1.grpctestingexp. \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=_grpc_config.ipv4-cpp-config-has-zero-percentage.resolver-tests-version-4.grpctestingexp. \
   --type=TXT \
   --ttl=2100 \
   '"grpc_config=[{\"percentage\":0,\"serviceConfig\":{\"loadBalancingPolicy\":\"round_robin\",\"methodConfig\":[{\"name\":[{\"method\":\"Foo\",\"service\":\"CppService\",\"waitForReady\":true}]}]}}]"'
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=ipv4-second-language-is-cpp.resolver-tests-version-1.grpctestingexp. \
-  --type=A \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=_grpc_config.ipv4-second-language-is-cpp.resolver-tests-version-4.grpctestingexp. \
+  --type=TXT \
   --ttl=2100 \
-  "1.2.3.4"
+  '"grpc_config=[{\"clientLanguage\":[\"go\"],\"serviceConfig\":{\"loadBalancingPolicy\":\"round_robin\",\"methodConfig\":[{\"name\":[{\"method\":\"Foo\",\"service\":\"GoService\",\"waitForReady\":true}]}]}},{\"clientLanguage\":[\"c++\"],\"serviceConfig\":{" "\"loadBalancingPolicy\":\"round_robin\",\"methodConfig\":[{\"name\":[{\"method\":\"Foo\",\"service\":\"CppService\",\"waitForReady\":true}]}]}}]"'
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=ipv4-second-language-is-cpp.resolver-tests-version-1.grpctestingexp. \
-  --type=TXT \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=ipv4-second-language-is-cpp.resolver-tests-version-4.grpctestingexp. \
+  --type=A \
   --ttl=2100 \
-  '"grpc_config=[{\"clientLanguage\":[\"go\"],\"serviceConfig\":{\"loadBalancingPolicy\":\"round_robin\",\"methodConfig\":[{\"name\":[{\"method\":\"Foo\",\"service\":\"GoService\",\"waitForReady\":true}]}]}},{\"clientLanguage\":[\"c++\"],\"serviceConfig\":{" "\"loadBalancingPolicy\":\"round_robin\",\"methodConfig\":[{\"name\":[{\"method\":\"Foo\",\"service\":\"CppService\",\"waitForReady\":true}]}]}}]"'
+  "1.2.3.4"
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=ipv4-config-with-percentages.resolver-tests-version-1.grpctestingexp. \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=ipv4-config-with-percentages.resolver-tests-version-4.grpctestingexp. \
   --type=A \
   --ttl=2100 \
   "1.2.3.4"
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=ipv4-config-with-percentages.resolver-tests-version-1.grpctestingexp. \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=_grpc_config.ipv4-config-with-percentages.resolver-tests-version-4.grpctestingexp. \
   --type=TXT \
   --ttl=2100 \
   '"grpc_config=[{\"percentage\":0,\"serviceConfig\":{\"loadBalancingPolicy\":\"round_robin\",\"methodConfig\":[{\"name\":[{\"method\":\"Foo\",\"service\":\"NeverPickedService\",\"waitForReady\":true}]}]}},{\"percentage\":100,\"serviceConfig\":{\"loadBalanc" "ingPolicy\":\"round_robin\",\"methodConfig\":[{\"name\":[{\"method\":\"Foo\",\"service\":\"AlwaysPickedService\",\"waitForReady\":true}]}]}}]"'
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=_grpclb._tcp.srv-ipv4-target-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp. \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=_grpclb._tcp.srv-ipv4-target-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp. \
   --type=SRV \
   --ttl=2100 \
-  "0 0 1234 balancer-for-ipv4-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp."
+  "0 0 1234 balancer-for-ipv4-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp."
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=balancer-for-ipv4-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp. \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=balancer-for-ipv4-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp. \
   --type=A \
   --ttl=2100 \
   "1.2.3.4"
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=srv-ipv4-target-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp. \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=srv-ipv4-target-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp. \
   --type=A \
   --ttl=2100 \
   "1.2.3.4"
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=_grpclb._tcp.srv-ipv6-target-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp. \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=_grpclb._tcp.srv-ipv6-target-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp. \
   --type=SRV \
   --ttl=2100 \
-  "0 0 1234 balancer-for-ipv6-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp."
+  "0 0 1234 balancer-for-ipv6-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp."
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=balancer-for-ipv6-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp. \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=balancer-for-ipv6-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp. \
   --type=AAAA \
   --ttl=2100 \
   "2607:f8b0:400a:801::1002"
 
 gcloud dns record-sets transaction add \
-  -z=resolver-tests-version-1-grpctestingexp-zone-id \
-  --name=srv-ipv6-target-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp. \
+  -z=resolver-tests-version-4-grpctestingexp-zone-id \
+  --name=srv-ipv6-target-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp. \
   --type=AAAA \
   --ttl=2100 \
   "2607:f8b0:400a:801::1002"
 
-gcloud dns record-sets transaction describe -z=resolver-tests-version-1-grpctestingexp-zone-id
-gcloud dns record-sets transaction execute -z=resolver-tests-version-1-grpctestingexp-zone-id
-gcloud dns record-sets list -z=resolver-tests-version-1-grpctestingexp-zone-id
+gcloud dns record-sets transaction describe -z=resolver-tests-version-4-grpctestingexp-zone-id
+gcloud dns record-sets transaction execute -z=resolver-tests-version-4-grpctestingexp-zone-id
+gcloud dns record-sets list -z=resolver-tests-version-4-grpctestingexp-zone-id
diff --git a/test/cpp/naming/resolver_component_test.cc b/test/cpp/naming/resolver_component_test.cc
index 7d0371bea4..6f1f0c44b9 100644
--- a/test/cpp/naming/resolver_component_test.cc
+++ b/test/cpp/naming/resolver_component_test.cc
@@ -32,7 +32,6 @@
 #include "test/cpp/util/subprocess.h"
 #include "test/cpp/util/test_config.h"
 
-extern "C" {
 #include "src/core/ext/filters/client_channel/client_channel.h"
 #include "src/core/ext/filters/client_channel/resolver.h"
 #include "src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.h"
@@ -47,10 +46,9 @@ extern "C" {
 #include "src/core/lib/support/string.h"
 #include "test/core/util/port.h"
 #include "test/core/util/test_config.h"
-}
 
-using std::vector;
 using grpc::SubProcess;
+using std::vector;
 using testing::UnorderedElementsAreArray;
 
 // Hack copied from "test/cpp/end2end/server_crash_test_client.cc"!
@@ -85,12 +83,12 @@ class GrpcLBAddress final {
   GrpcLBAddress(std::string address, bool is_balancer)
       : is_balancer(is_balancer), address(address) {}
 
-  bool operator==(const GrpcLBAddress &other) const {
+  bool operator==(const GrpcLBAddress& other) const {
     return this->is_balancer == other.is_balancer &&
            this->address == other.address;
   }
 
-  bool operator!=(const GrpcLBAddress &other) const {
+  bool operator!=(const GrpcLBAddress& other) const {
     return !(*this == other);
   }
 
@@ -141,35 +139,36 @@ gpr_timespec TestDeadline(void) {
 struct ArgsStruct {
   gpr_event ev;
   gpr_atm done_atm;
-  gpr_mu *mu;
-  grpc_pollset *pollset;
-  grpc_pollset_set *pollset_set;
-  grpc_combiner *lock;
-  grpc_channel_args *channel_args;
+  gpr_mu* mu;
+  grpc_pollset* pollset;
+  grpc_pollset_set* pollset_set;
+  grpc_combiner* lock;
+  grpc_channel_args* channel_args;
   vector<GrpcLBAddress> expected_addrs;
   std::string expected_service_config_string;
   std::string expected_lb_policy;
 };
 
-void ArgsInit(grpc_exec_ctx *exec_ctx, ArgsStruct *args) {
+void ArgsInit(grpc_exec_ctx* exec_ctx, ArgsStruct* args) {
   gpr_event_init(&args->ev);
-  args->pollset = (grpc_pollset *)gpr_zalloc(grpc_pollset_size());
+  args->pollset = (grpc_pollset*)gpr_zalloc(grpc_pollset_size());
   grpc_pollset_init(args->pollset, &args->mu);
   args->pollset_set = grpc_pollset_set_create();
   grpc_pollset_set_add_pollset(exec_ctx, args->pollset_set, args->pollset);
   args->lock = grpc_combiner_create();
   gpr_atm_rel_store(&args->done_atm, 0);
-  args->channel_args = NULL;
+  args->channel_args = nullptr;
 }
 
-void DoNothing(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {}
+void DoNothing(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {}
 
-void ArgsFinish(grpc_exec_ctx *exec_ctx, ArgsStruct *args) {
+void ArgsFinish(grpc_exec_ctx* exec_ctx, ArgsStruct* args) {
   GPR_ASSERT(gpr_event_wait(&args->ev, TestDeadline()));
   grpc_pollset_set_del_pollset(exec_ctx, args->pollset_set, args->pollset);
   grpc_pollset_set_destroy(exec_ctx, args->pollset_set);
   grpc_closure DoNothing_cb;
-  GRPC_CLOSURE_INIT(&DoNothing_cb, DoNothing, NULL, grpc_schedule_on_exec_ctx);
+  GRPC_CLOSURE_INIT(&DoNothing_cb, DoNothing, nullptr,
+                    grpc_schedule_on_exec_ctx);
   grpc_pollset_shutdown(exec_ctx, args->pollset, &DoNothing_cb);
   // exec_ctx needs to be flushed before calling grpc_pollset_destroy()
   grpc_channel_args_destroy(exec_ctx, args->channel_args);
@@ -184,7 +183,7 @@ gpr_timespec NSecondDeadline(int seconds) {
                       gpr_time_from_seconds(seconds, GPR_TIMESPAN));
 }
 
-void PollPollsetUntilRequestDone(ArgsStruct *args) {
+void PollPollsetUntilRequestDone(ArgsStruct* args) {
   gpr_timespec deadline = NSecondDeadline(10);
   while (true) {
     bool done = gpr_atm_acq_load(&args->done_atm) != 0;
@@ -196,7 +195,7 @@ void PollPollsetUntilRequestDone(ArgsStruct *args) {
     gpr_log(GPR_DEBUG, "done=%d, time_left=%" PRId64 ".%09d", done,
             time_left.tv_sec, time_left.tv_nsec);
     GPR_ASSERT(gpr_time_cmp(time_left, gpr_time_0(GPR_TIMESPAN)) >= 0);
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     gpr_mu_lock(args->mu);
     GRPC_LOG_IF_ERROR("pollset_work",
@@ -206,53 +205,53 @@ void PollPollsetUntilRequestDone(ArgsStruct *args) {
     gpr_mu_unlock(args->mu);
     grpc_exec_ctx_finish(&exec_ctx);
   }
-  gpr_event_set(&args->ev, (void *)1);
+  gpr_event_set(&args->ev, (void*)1);
 }
 
-void CheckServiceConfigResultLocked(grpc_channel_args *channel_args,
-                                    ArgsStruct *args) {
-  const grpc_arg *service_config_arg =
+void CheckServiceConfigResultLocked(grpc_channel_args* channel_args,
+                                    ArgsStruct* args) {
+  const grpc_arg* service_config_arg =
       grpc_channel_args_find(channel_args, GRPC_ARG_SERVICE_CONFIG);
   if (args->expected_service_config_string != "") {
-    GPR_ASSERT(service_config_arg != NULL);
+    GPR_ASSERT(service_config_arg != nullptr);
     GPR_ASSERT(service_config_arg->type == GRPC_ARG_STRING);
     EXPECT_EQ(service_config_arg->value.string,
               args->expected_service_config_string);
   } else {
-    GPR_ASSERT(service_config_arg == NULL);
+    GPR_ASSERT(service_config_arg == nullptr);
   }
 }
 
-void CheckLBPolicyResultLocked(grpc_channel_args *channel_args,
-                               ArgsStruct *args) {
-  const grpc_arg *lb_policy_arg =
+void CheckLBPolicyResultLocked(grpc_channel_args* channel_args,
+                               ArgsStruct* args) {
+  const grpc_arg* lb_policy_arg =
       grpc_channel_args_find(channel_args, GRPC_ARG_LB_POLICY_NAME);
   if (args->expected_lb_policy != "") {
-    GPR_ASSERT(lb_policy_arg != NULL);
+    GPR_ASSERT(lb_policy_arg != nullptr);
     GPR_ASSERT(lb_policy_arg->type == GRPC_ARG_STRING);
     EXPECT_EQ(lb_policy_arg->value.string, args->expected_lb_policy);
   } else {
-    GPR_ASSERT(lb_policy_arg == NULL);
+    GPR_ASSERT(lb_policy_arg == nullptr);
   }
 }
 
-void CheckResolverResultLocked(grpc_exec_ctx *exec_ctx, void *argsp,
-                               grpc_error *err) {
-  ArgsStruct *args = (ArgsStruct *)argsp;
-  grpc_channel_args *channel_args = args->channel_args;
-  const grpc_arg *channel_arg =
+void CheckResolverResultLocked(grpc_exec_ctx* exec_ctx, void* argsp,
+                               grpc_error* err) {
+  ArgsStruct* args = (ArgsStruct*)argsp;
+  grpc_channel_args* channel_args = args->channel_args;
+  const grpc_arg* channel_arg =
       grpc_channel_args_find(channel_args, GRPC_ARG_LB_ADDRESSES);
-  GPR_ASSERT(channel_arg != NULL);
+  GPR_ASSERT(channel_arg != nullptr);
   GPR_ASSERT(channel_arg->type == GRPC_ARG_POINTER);
-  grpc_lb_addresses *addresses =
-      (grpc_lb_addresses *)channel_arg->value.pointer.p;
+  grpc_lb_addresses* addresses =
+      (grpc_lb_addresses*)channel_arg->value.pointer.p;
   gpr_log(GPR_INFO, "num addrs found: %" PRIdPTR ". expected %" PRIdPTR,
           addresses->num_addresses, args->expected_addrs.size());
   GPR_ASSERT(addresses->num_addresses == args->expected_addrs.size());
   std::vector<GrpcLBAddress> found_lb_addrs;
   for (size_t i = 0; i < addresses->num_addresses; i++) {
     grpc_lb_address addr = addresses->addresses[i];
-    char *str;
+    char* str;
     grpc_sockaddr_to_string(&str, &addr.address, 1 /* normalize */);
     gpr_log(GPR_INFO, "%s", str);
     found_lb_addrs.emplace_back(
@@ -260,8 +259,9 @@ void CheckResolverResultLocked(grpc_exec_ctx *exec_ctx, void *argsp,
     gpr_free(str);
   }
   if (args->expected_addrs.size() != found_lb_addrs.size()) {
-    gpr_log(GPR_DEBUG, "found lb addrs size is: %" PRIdPTR
-                       ". expected addrs size is %" PRIdPTR,
+    gpr_log(GPR_DEBUG,
+            "found lb addrs size is: %" PRIdPTR
+            ". expected addrs size is %" PRIdPTR,
             found_lb_addrs.size(), args->expected_addrs.size());
     abort();
   }
@@ -273,7 +273,7 @@ void CheckResolverResultLocked(grpc_exec_ctx *exec_ctx, void *argsp,
   gpr_atm_rel_store(&args->done_atm, 1);
   gpr_mu_lock(args->mu);
   GRPC_LOG_IF_ERROR("pollset_kick",
-                    grpc_pollset_kick(exec_ctx, args->pollset, NULL));
+                    grpc_pollset_kick(exec_ctx, args->pollset, nullptr));
   gpr_mu_unlock(args->mu);
 }
 
@@ -285,17 +285,17 @@ TEST(ResolverComponentTest, TestResolvesRelevantRecords) {
   args.expected_service_config_string = FLAGS_expected_chosen_service_config;
   args.expected_lb_policy = FLAGS_expected_lb_policy;
   // maybe build the address with an authority
-  char *whole_uri = NULL;
+  char* whole_uri = nullptr;
   GPR_ASSERT(asprintf(&whole_uri, "dns://%s/%s",
                       FLAGS_local_dns_server_address.c_str(),
                       FLAGS_target_name.c_str()));
   // create resolver and resolve
-  grpc_resolver *resolver = grpc_resolver_create(&exec_ctx, whole_uri, NULL,
+  grpc_resolver* resolver = grpc_resolver_create(&exec_ctx, whole_uri, nullptr,
                                                  args.pollset_set, args.lock);
   gpr_free(whole_uri);
   grpc_closure on_resolver_result_changed;
   GRPC_CLOSURE_INIT(&on_resolver_result_changed, CheckResolverResultLocked,
-                    (void *)&args, grpc_combiner_scheduler(args.lock));
+                    (void*)&args, grpc_combiner_scheduler(args.lock));
   grpc_resolver_next_locked(&exec_ctx, resolver, &args.channel_args,
                             &on_resolver_result_changed);
   grpc_exec_ctx_flush(&exec_ctx);
@@ -307,7 +307,7 @@ TEST(ResolverComponentTest, TestResolvesRelevantRecords) {
 
 }  // namespace
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_init();
   grpc_test_init(argc, argv);
   ::testing::InitGoogleTest(&argc, argv);
diff --git a/test/cpp/naming/resolver_component_tests_runner.sh b/test/cpp/naming/resolver_component_tests_runner.sh
index 407db5ed66..11a45d72ce 100755
--- a/test/cpp/naming/resolver_component_tests_runner.sh
+++ b/test/cpp/naming/resolver_component_tests_runner.sh
@@ -73,7 +73,7 @@ EXIT_CODE=0
 # in the resolver.
 
 $FLAGS_test_bin_path \
-  --target_name='srv-ipv4-single-target.resolver-tests-version-1.grpctestingexp.' \
+  --target_name='srv-ipv4-single-target.resolver-tests-version-4.grpctestingexp.' \
   --expected_addrs='1.2.3.4:1234,True' \
   --expected_chosen_service_config='' \
   --expected_lb_policy='' \
@@ -81,7 +81,7 @@ $FLAGS_test_bin_path \
 wait $! || EXIT_CODE=1
 
 $FLAGS_test_bin_path \
-  --target_name='srv-ipv4-multi-target.resolver-tests-version-1.grpctestingexp.' \
+  --target_name='srv-ipv4-multi-target.resolver-tests-version-4.grpctestingexp.' \
   --expected_addrs='1.2.3.5:1234,True;1.2.3.6:1234,True;1.2.3.7:1234,True' \
   --expected_chosen_service_config='' \
   --expected_lb_policy='' \
@@ -89,7 +89,7 @@ $FLAGS_test_bin_path \
 wait $! || EXIT_CODE=1
 
 $FLAGS_test_bin_path \
-  --target_name='srv-ipv6-single-target.resolver-tests-version-1.grpctestingexp.' \
+  --target_name='srv-ipv6-single-target.resolver-tests-version-4.grpctestingexp.' \
   --expected_addrs='[2607:f8b0:400a:801::1001]:1234,True' \
   --expected_chosen_service_config='' \
   --expected_lb_policy='' \
@@ -97,7 +97,7 @@ $FLAGS_test_bin_path \
 wait $! || EXIT_CODE=1
 
 $FLAGS_test_bin_path \
-  --target_name='srv-ipv6-multi-target.resolver-tests-version-1.grpctestingexp.' \
+  --target_name='srv-ipv6-multi-target.resolver-tests-version-4.grpctestingexp.' \
   --expected_addrs='[2607:f8b0:400a:801::1002]:1234,True;[2607:f8b0:400a:801::1003]:1234,True;[2607:f8b0:400a:801::1004]:1234,True' \
   --expected_chosen_service_config='' \
   --expected_lb_policy='' \
@@ -105,7 +105,7 @@ $FLAGS_test_bin_path \
 wait $! || EXIT_CODE=1
 
 $FLAGS_test_bin_path \
-  --target_name='srv-ipv4-simple-service-config.resolver-tests-version-1.grpctestingexp.' \
+  --target_name='srv-ipv4-simple-service-config.resolver-tests-version-4.grpctestingexp.' \
   --expected_addrs='1.2.3.4:1234,True' \
   --expected_chosen_service_config='{"loadBalancingPolicy":"round_robin","methodConfig":[{"name":[{"method":"Foo","service":"SimpleService","waitForReady":true}]}]}' \
   --expected_lb_policy='round_robin' \
@@ -113,7 +113,7 @@ $FLAGS_test_bin_path \
 wait $! || EXIT_CODE=1
 
 $FLAGS_test_bin_path \
-  --target_name='ipv4-no-srv-simple-service-config.resolver-tests-version-1.grpctestingexp.' \
+  --target_name='ipv4-no-srv-simple-service-config.resolver-tests-version-4.grpctestingexp.' \
   --expected_addrs='1.2.3.4:443,False' \
   --expected_chosen_service_config='{"loadBalancingPolicy":"round_robin","methodConfig":[{"name":[{"method":"Foo","service":"NoSrvSimpleService","waitForReady":true}]}]}' \
   --expected_lb_policy='round_robin' \
@@ -121,7 +121,7 @@ $FLAGS_test_bin_path \
 wait $! || EXIT_CODE=1
 
 $FLAGS_test_bin_path \
-  --target_name='ipv4-no-config-for-cpp.resolver-tests-version-1.grpctestingexp.' \
+  --target_name='ipv4-no-config-for-cpp.resolver-tests-version-4.grpctestingexp.' \
   --expected_addrs='1.2.3.4:443,False' \
   --expected_chosen_service_config='' \
   --expected_lb_policy='' \
@@ -129,7 +129,7 @@ $FLAGS_test_bin_path \
 wait $! || EXIT_CODE=1
 
 $FLAGS_test_bin_path \
-  --target_name='ipv4-cpp-config-has-zero-percentage.resolver-tests-version-1.grpctestingexp.' \
+  --target_name='ipv4-cpp-config-has-zero-percentage.resolver-tests-version-4.grpctestingexp.' \
   --expected_addrs='1.2.3.4:443,False' \
   --expected_chosen_service_config='' \
   --expected_lb_policy='' \
@@ -137,7 +137,7 @@ $FLAGS_test_bin_path \
 wait $! || EXIT_CODE=1
 
 $FLAGS_test_bin_path \
-  --target_name='ipv4-second-language-is-cpp.resolver-tests-version-1.grpctestingexp.' \
+  --target_name='ipv4-second-language-is-cpp.resolver-tests-version-4.grpctestingexp.' \
   --expected_addrs='1.2.3.4:443,False' \
   --expected_chosen_service_config='{"loadBalancingPolicy":"round_robin","methodConfig":[{"name":[{"method":"Foo","service":"CppService","waitForReady":true}]}]}' \
   --expected_lb_policy='round_robin' \
@@ -145,7 +145,7 @@ $FLAGS_test_bin_path \
 wait $! || EXIT_CODE=1
 
 $FLAGS_test_bin_path \
-  --target_name='ipv4-config-with-percentages.resolver-tests-version-1.grpctestingexp.' \
+  --target_name='ipv4-config-with-percentages.resolver-tests-version-4.grpctestingexp.' \
   --expected_addrs='1.2.3.4:443,False' \
   --expected_chosen_service_config='{"loadBalancingPolicy":"round_robin","methodConfig":[{"name":[{"method":"Foo","service":"AlwaysPickedService","waitForReady":true}]}]}' \
   --expected_lb_policy='round_robin' \
@@ -153,7 +153,7 @@ $FLAGS_test_bin_path \
 wait $! || EXIT_CODE=1
 
 $FLAGS_test_bin_path \
-  --target_name='srv-ipv4-target-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp.' \
+  --target_name='srv-ipv4-target-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp.' \
   --expected_addrs='1.2.3.4:1234,True;1.2.3.4:443,False' \
   --expected_chosen_service_config='' \
   --expected_lb_policy='' \
@@ -161,7 +161,7 @@ $FLAGS_test_bin_path \
 wait $! || EXIT_CODE=1
 
 $FLAGS_test_bin_path \
-  --target_name='srv-ipv6-target-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp.' \
+  --target_name='srv-ipv6-target-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp.' \
   --expected_addrs='[2607:f8b0:400a:801::1002]:1234,True;[2607:f8b0:400a:801::1002]:443,False' \
   --expected_chosen_service_config='' \
   --expected_lb_policy='' \
@@ -169,7 +169,7 @@ $FLAGS_test_bin_path \
 wait $! || EXIT_CODE=1
 
 $FLAGS_test_bin_path \
-  --target_name='ipv4-config-causing-fallback-to-tcp.resolver-tests-version-1.grpctestingexp.' \
+  --target_name='ipv4-config-causing-fallback-to-tcp.resolver-tests-version-4.grpctestingexp.' \
   --expected_addrs='1.2.3.4:443,False' \
   --expected_chosen_service_config='{"loadBalancingPolicy":"round_robin","methodConfig":[{"name":[{"method":"Foo","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooTwo","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooThree","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooFour","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooFive","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooSix","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooSeven","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooEight","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooNine","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooTen","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooEleven","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooTwelve","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooTwelve","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooTwelve","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooTwelve","service":"SimpleService","waitForReady":true}]}]}' \
   --expected_lb_policy='' \
diff --git a/test/cpp/naming/resolver_component_tests_runner_invoker.cc b/test/cpp/naming/resolver_component_tests_runner_invoker.cc
index b14391284d..0beb27de1b 100644
--- a/test/cpp/naming/resolver_component_tests_runner_invoker.cc
+++ b/test/cpp/naming/resolver_component_tests_runner_invoker.cc
@@ -32,10 +32,8 @@
 #include "test/cpp/util/subprocess.h"
 #include "test/cpp/util/test_config.h"
 
-extern "C" {
 #include "src/core/lib/support/env.h"
 #include "test/core/util/port.h"
-}
 
 DEFINE_bool(
     running_under_bazel, false,
@@ -62,16 +60,16 @@ static void register_sighandler() {
   struct sigaction act;
   memset(&act, 0, sizeof(act));
   act.sa_handler = sighandler;
-  sigaction(SIGINT, &act, NULL);
-  sigaction(SIGTERM, &act, NULL);
+  sigaction(SIGINT, &act, nullptr);
+  sigaction(SIGTERM, &act, nullptr);
 }
 
 namespace {
 
 const int kTestTimeoutSeconds = 60 * 2;
 
-void RunSigHandlingThread(SubProcess *test_driver, gpr_mu *test_driver_mu,
-                          gpr_cv *test_driver_cv, int *test_driver_done) {
+void RunSigHandlingThread(SubProcess* test_driver, gpr_mu* test_driver_mu,
+                          gpr_cv* test_driver_cv, int* test_driver_done) {
   gpr_timespec overall_deadline =
       gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC),
                    gpr_time_from_seconds(kTestTimeoutSeconds, GPR_TIMESPAN));
@@ -94,7 +92,7 @@ void RunSigHandlingThread(SubProcess *test_driver, gpr_mu *test_driver_mu,
   test_driver->Interrupt();
   return;
 }
-}
+}  // namespace
 
 namespace grpc {
 
@@ -106,7 +104,7 @@ void InvokeResolverComponentTestsRunner(std::string test_runner_bin_path,
                                         std::string records_config_path) {
   int test_dns_server_port = grpc_pick_unused_port_or_die();
 
-  SubProcess *test_driver = new SubProcess(
+  SubProcess* test_driver = new SubProcess(
       {test_runner_bin_path, "--test_bin_path=" + test_bin_path,
        "--dns_server_bin_path=" + dns_server_bin_path,
        "--records_config_path=" + records_config_path,
@@ -153,7 +151,7 @@ void InvokeResolverComponentTestsRunner(std::string test_runner_bin_path,
 
 }  // namespace grpc
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc::testing::InitTest(&argc, &argv, true);
   grpc_init();
   GPR_ASSERT(FLAGS_test_bin_name != "");
diff --git a/test/cpp/naming/resolver_gce_integration_tests_runner.sh b/test/cpp/naming/resolver_gce_integration_tests_runner.sh
index b20d18d9d1..091f9efbbd 100755
--- a/test/cpp/naming/resolver_gce_integration_tests_runner.sh
+++ b/test/cpp/naming/resolver_gce_integration_tests_runner.sh
@@ -34,191 +34,191 @@ echo "Sanity check DNS records are resolveable with dig:"
 EXIT_CODE=0
 
 ONE_FAILED=0
-dig SRV _grpclb._tcp.srv-ipv4-single-target.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig SRV _grpclb._tcp.srv-ipv4-single-target.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig SRV _grpclb._tcp.srv-ipv4-single-target.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig SRV _grpclb._tcp.srv-ipv4-single-target.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig A ipv4-single-target.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig A ipv4-single-target.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig A ipv4-single-target.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig A ipv4-single-target.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig SRV _grpclb._tcp.srv-ipv4-multi-target.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig SRV _grpclb._tcp.srv-ipv4-multi-target.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig SRV _grpclb._tcp.srv-ipv4-multi-target.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig SRV _grpclb._tcp.srv-ipv4-multi-target.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig A ipv4-multi-target.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig A ipv4-multi-target.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig A ipv4-multi-target.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig A ipv4-multi-target.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig SRV _grpclb._tcp.srv-ipv6-single-target.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig SRV _grpclb._tcp.srv-ipv6-single-target.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig SRV _grpclb._tcp.srv-ipv6-single-target.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig SRV _grpclb._tcp.srv-ipv6-single-target.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig AAAA ipv6-single-target.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig AAAA ipv6-single-target.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig AAAA ipv6-single-target.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig AAAA ipv6-single-target.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig SRV _grpclb._tcp.srv-ipv6-multi-target.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig SRV _grpclb._tcp.srv-ipv6-multi-target.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig SRV _grpclb._tcp.srv-ipv6-multi-target.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig SRV _grpclb._tcp.srv-ipv6-multi-target.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig AAAA ipv6-multi-target.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig AAAA ipv6-multi-target.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig AAAA ipv6-multi-target.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig AAAA ipv6-multi-target.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig TXT srv-ipv4-simple-service-config.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig TXT _grpc_config.srv-ipv4-simple-service-config.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig TXT srv-ipv4-simple-service-config.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig TXT _grpc_config.srv-ipv4-simple-service-config.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig A ipv4-simple-service-config.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig SRV _grpclb._tcp.srv-ipv4-simple-service-config.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig A ipv4-simple-service-config.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig SRV _grpclb._tcp.srv-ipv4-simple-service-config.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig SRV _grpclb._tcp.srv-ipv4-simple-service-config.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig A ipv4-simple-service-config.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig SRV _grpclb._tcp.srv-ipv4-simple-service-config.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig A ipv4-simple-service-config.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig A ipv4-no-srv-simple-service-config.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig A ipv4-no-srv-simple-service-config.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig A ipv4-no-srv-simple-service-config.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig A ipv4-no-srv-simple-service-config.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig TXT ipv4-no-srv-simple-service-config.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig TXT _grpc_config.ipv4-no-srv-simple-service-config.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig TXT ipv4-no-srv-simple-service-config.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig TXT _grpc_config.ipv4-no-srv-simple-service-config.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig A ipv4-no-config-for-cpp.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig TXT _grpc_config.ipv4-no-config-for-cpp.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig A ipv4-no-config-for-cpp.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig TXT _grpc_config.ipv4-no-config-for-cpp.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig TXT ipv4-no-config-for-cpp.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig A ipv4-no-config-for-cpp.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig TXT ipv4-no-config-for-cpp.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig A ipv4-no-config-for-cpp.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig A ipv4-cpp-config-has-zero-percentage.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig A ipv4-cpp-config-has-zero-percentage.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig A ipv4-cpp-config-has-zero-percentage.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig A ipv4-cpp-config-has-zero-percentage.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig TXT ipv4-cpp-config-has-zero-percentage.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig TXT _grpc_config.ipv4-cpp-config-has-zero-percentage.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig TXT ipv4-cpp-config-has-zero-percentage.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig TXT _grpc_config.ipv4-cpp-config-has-zero-percentage.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig A ipv4-second-language-is-cpp.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig TXT _grpc_config.ipv4-second-language-is-cpp.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig A ipv4-second-language-is-cpp.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig TXT _grpc_config.ipv4-second-language-is-cpp.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig TXT ipv4-second-language-is-cpp.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig A ipv4-second-language-is-cpp.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig TXT ipv4-second-language-is-cpp.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig A ipv4-second-language-is-cpp.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig A ipv4-config-with-percentages.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig A ipv4-config-with-percentages.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig A ipv4-config-with-percentages.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig A ipv4-config-with-percentages.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig TXT ipv4-config-with-percentages.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig TXT _grpc_config.ipv4-config-with-percentages.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig TXT ipv4-config-with-percentages.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig TXT _grpc_config.ipv4-config-with-percentages.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig SRV _grpclb._tcp.srv-ipv4-target-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig SRV _grpclb._tcp.srv-ipv4-target-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig SRV _grpclb._tcp.srv-ipv4-target-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig SRV _grpclb._tcp.srv-ipv4-target-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig A balancer-for-ipv4-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig A balancer-for-ipv4-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig A balancer-for-ipv4-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig A balancer-for-ipv4-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig A srv-ipv4-target-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig A srv-ipv4-target-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig A srv-ipv4-target-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig A srv-ipv4-target-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig SRV _grpclb._tcp.srv-ipv6-target-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig SRV _grpclb._tcp.srv-ipv6-target-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig SRV _grpclb._tcp.srv-ipv6-target-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig SRV _grpclb._tcp.srv-ipv6-target-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig AAAA balancer-for-ipv6-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig AAAA balancer-for-ipv6-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig AAAA balancer-for-ipv6-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig AAAA balancer-for-ipv6-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
 ONE_FAILED=0
-dig AAAA srv-ipv6-target-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
+dig AAAA srv-ipv6-target-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp. | grep 'ANSWER SECTION' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Sanity check: dig AAAA srv-ipv6-target-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Sanity check: dig AAAA srv-ipv6-target-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp. FAILED"
   exit 1
 fi
 
@@ -226,133 +226,133 @@ echo "Sanity check PASSED. Run resolver tests:"
 
 ONE_FAILED=0
 bins/$CONFIG/resolver_component_test \
-  --target_name='srv-ipv4-single-target.resolver-tests-version-1.grpctestingexp.' \
+  --target_name='srv-ipv4-single-target.resolver-tests-version-4.grpctestingexp.' \
   --expected_addrs='1.2.3.4:1234,True' \
   --expected_chosen_service_config='' \
   --expected_lb_policy='' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Test based on target record: srv-ipv4-single-target.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Test based on target record: srv-ipv4-single-target.resolver-tests-version-4.grpctestingexp. FAILED"
   EXIT_CODE=1
 fi
 
 ONE_FAILED=0
 bins/$CONFIG/resolver_component_test \
-  --target_name='srv-ipv4-multi-target.resolver-tests-version-1.grpctestingexp.' \
+  --target_name='srv-ipv4-multi-target.resolver-tests-version-4.grpctestingexp.' \
   --expected_addrs='1.2.3.5:1234,True;1.2.3.6:1234,True;1.2.3.7:1234,True' \
   --expected_chosen_service_config='' \
   --expected_lb_policy='' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Test based on target record: srv-ipv4-multi-target.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Test based on target record: srv-ipv4-multi-target.resolver-tests-version-4.grpctestingexp. FAILED"
   EXIT_CODE=1
 fi
 
 ONE_FAILED=0
 bins/$CONFIG/resolver_component_test \
-  --target_name='srv-ipv6-single-target.resolver-tests-version-1.grpctestingexp.' \
+  --target_name='srv-ipv6-single-target.resolver-tests-version-4.grpctestingexp.' \
   --expected_addrs='[2607:f8b0:400a:801::1001]:1234,True' \
   --expected_chosen_service_config='' \
   --expected_lb_policy='' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Test based on target record: srv-ipv6-single-target.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Test based on target record: srv-ipv6-single-target.resolver-tests-version-4.grpctestingexp. FAILED"
   EXIT_CODE=1
 fi
 
 ONE_FAILED=0
 bins/$CONFIG/resolver_component_test \
-  --target_name='srv-ipv6-multi-target.resolver-tests-version-1.grpctestingexp.' \
+  --target_name='srv-ipv6-multi-target.resolver-tests-version-4.grpctestingexp.' \
   --expected_addrs='[2607:f8b0:400a:801::1002]:1234,True;[2607:f8b0:400a:801::1003]:1234,True;[2607:f8b0:400a:801::1004]:1234,True' \
   --expected_chosen_service_config='' \
   --expected_lb_policy='' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Test based on target record: srv-ipv6-multi-target.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Test based on target record: srv-ipv6-multi-target.resolver-tests-version-4.grpctestingexp. FAILED"
   EXIT_CODE=1
 fi
 
 ONE_FAILED=0
 bins/$CONFIG/resolver_component_test \
-  --target_name='srv-ipv4-simple-service-config.resolver-tests-version-1.grpctestingexp.' \
+  --target_name='srv-ipv4-simple-service-config.resolver-tests-version-4.grpctestingexp.' \
   --expected_addrs='1.2.3.4:1234,True' \
   --expected_chosen_service_config='{"loadBalancingPolicy":"round_robin","methodConfig":[{"name":[{"method":"Foo","service":"SimpleService","waitForReady":true}]}]}' \
   --expected_lb_policy='round_robin' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Test based on target record: srv-ipv4-simple-service-config.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Test based on target record: srv-ipv4-simple-service-config.resolver-tests-version-4.grpctestingexp. FAILED"
   EXIT_CODE=1
 fi
 
 ONE_FAILED=0
 bins/$CONFIG/resolver_component_test \
-  --target_name='ipv4-no-srv-simple-service-config.resolver-tests-version-1.grpctestingexp.' \
+  --target_name='ipv4-no-srv-simple-service-config.resolver-tests-version-4.grpctestingexp.' \
   --expected_addrs='1.2.3.4:443,False' \
   --expected_chosen_service_config='{"loadBalancingPolicy":"round_robin","methodConfig":[{"name":[{"method":"Foo","service":"NoSrvSimpleService","waitForReady":true}]}]}' \
   --expected_lb_policy='round_robin' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Test based on target record: ipv4-no-srv-simple-service-config.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Test based on target record: ipv4-no-srv-simple-service-config.resolver-tests-version-4.grpctestingexp. FAILED"
   EXIT_CODE=1
 fi
 
 ONE_FAILED=0
 bins/$CONFIG/resolver_component_test \
-  --target_name='ipv4-no-config-for-cpp.resolver-tests-version-1.grpctestingexp.' \
+  --target_name='ipv4-no-config-for-cpp.resolver-tests-version-4.grpctestingexp.' \
   --expected_addrs='1.2.3.4:443,False' \
   --expected_chosen_service_config='' \
   --expected_lb_policy='' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Test based on target record: ipv4-no-config-for-cpp.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Test based on target record: ipv4-no-config-for-cpp.resolver-tests-version-4.grpctestingexp. FAILED"
   EXIT_CODE=1
 fi
 
 ONE_FAILED=0
 bins/$CONFIG/resolver_component_test \
-  --target_name='ipv4-cpp-config-has-zero-percentage.resolver-tests-version-1.grpctestingexp.' \
+  --target_name='ipv4-cpp-config-has-zero-percentage.resolver-tests-version-4.grpctestingexp.' \
   --expected_addrs='1.2.3.4:443,False' \
   --expected_chosen_service_config='' \
   --expected_lb_policy='' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Test based on target record: ipv4-cpp-config-has-zero-percentage.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Test based on target record: ipv4-cpp-config-has-zero-percentage.resolver-tests-version-4.grpctestingexp. FAILED"
   EXIT_CODE=1
 fi
 
 ONE_FAILED=0
 bins/$CONFIG/resolver_component_test \
-  --target_name='ipv4-second-language-is-cpp.resolver-tests-version-1.grpctestingexp.' \
+  --target_name='ipv4-second-language-is-cpp.resolver-tests-version-4.grpctestingexp.' \
   --expected_addrs='1.2.3.4:443,False' \
   --expected_chosen_service_config='{"loadBalancingPolicy":"round_robin","methodConfig":[{"name":[{"method":"Foo","service":"CppService","waitForReady":true}]}]}' \
   --expected_lb_policy='round_robin' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Test based on target record: ipv4-second-language-is-cpp.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Test based on target record: ipv4-second-language-is-cpp.resolver-tests-version-4.grpctestingexp. FAILED"
   EXIT_CODE=1
 fi
 
 ONE_FAILED=0
 bins/$CONFIG/resolver_component_test \
-  --target_name='ipv4-config-with-percentages.resolver-tests-version-1.grpctestingexp.' \
+  --target_name='ipv4-config-with-percentages.resolver-tests-version-4.grpctestingexp.' \
   --expected_addrs='1.2.3.4:443,False' \
   --expected_chosen_service_config='{"loadBalancingPolicy":"round_robin","methodConfig":[{"name":[{"method":"Foo","service":"AlwaysPickedService","waitForReady":true}]}]}' \
   --expected_lb_policy='round_robin' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Test based on target record: ipv4-config-with-percentages.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Test based on target record: ipv4-config-with-percentages.resolver-tests-version-4.grpctestingexp. FAILED"
   EXIT_CODE=1
 fi
 
 ONE_FAILED=0
 bins/$CONFIG/resolver_component_test \
-  --target_name='srv-ipv4-target-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp.' \
+  --target_name='srv-ipv4-target-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp.' \
   --expected_addrs='1.2.3.4:1234,True;1.2.3.4:443,False' \
   --expected_chosen_service_config='' \
   --expected_lb_policy='' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Test based on target record: srv-ipv4-target-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Test based on target record: srv-ipv4-target-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp. FAILED"
   EXIT_CODE=1
 fi
 
 ONE_FAILED=0
 bins/$CONFIG/resolver_component_test \
-  --target_name='srv-ipv6-target-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp.' \
+  --target_name='srv-ipv6-target-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp.' \
   --expected_addrs='[2607:f8b0:400a:801::1002]:1234,True;[2607:f8b0:400a:801::1002]:443,False' \
   --expected_chosen_service_config='' \
   --expected_lb_policy='' || ONE_FAILED=1
 if [[ "$ONE_FAILED" != 0 ]]; then
-  echo "Test based on target record: srv-ipv6-target-has-backend-and-balancer.resolver-tests-version-1.grpctestingexp. FAILED"
+  echo "Test based on target record: srv-ipv6-target-has-backend-and-balancer.resolver-tests-version-4.grpctestingexp. FAILED"
   EXIT_CODE=1
 fi
 
diff --git a/test/cpp/naming/resolver_test_record_groups.yaml b/test/cpp/naming/resolver_test_record_groups.yaml
index 2b3204335c..6c4f89d09b 100644
--- a/test/cpp/naming/resolver_test_record_groups.yaml
+++ b/test/cpp/naming/resolver_test_record_groups.yaml
@@ -1,4 +1,4 @@
-resolver_tests_common_zone_name: resolver-tests-version-1.grpctestingexp.
+resolver_tests_common_zone_name: resolver-tests-version-4.grpctestingexp.
 resolver_component_tests:
 - expected_addrs:
   - {address: '1.2.3.4:1234', is_balancer: true}
@@ -58,7 +58,7 @@ resolver_component_tests:
     - {TTL: '2100', data: 0 0 1234 ipv4-simple-service-config, type: SRV}
     ipv4-simple-service-config:
     - {TTL: '2100', data: 1.2.3.4, type: A}
-    srv-ipv4-simple-service-config:
+    _grpc_config.srv-ipv4-simple-service-config:
     - {TTL: '2100', data: 'grpc_config=[{"serviceConfig":{"loadBalancingPolicy":"round_robin","methodConfig":[{"name":[{"method":"Foo","service":"SimpleService","waitForReady":true}]}]}}]',
       type: TXT}
 - expected_addrs:
@@ -69,6 +69,7 @@ resolver_component_tests:
   records:
     ipv4-no-srv-simple-service-config:
     - {TTL: '2100', data: 1.2.3.4, type: A}
+    _grpc_config.ipv4-no-srv-simple-service-config:
     - {TTL: '2100', data: 'grpc_config=[{"serviceConfig":{"loadBalancingPolicy":"round_robin","methodConfig":[{"name":[{"method":"Foo","service":"NoSrvSimpleService","waitForReady":true}]}]}}]',
       type: TXT}
 - expected_addrs:
@@ -79,6 +80,7 @@ resolver_component_tests:
   records:
     ipv4-no-config-for-cpp:
     - {TTL: '2100', data: 1.2.3.4, type: A}
+    _grpc_config.ipv4-no-config-for-cpp:
     - {TTL: '2100', data: 'grpc_config=[{"clientLanguage":["python"],"serviceConfig":{"loadBalancingPolicy":"round_robin","methodConfig":[{"name":[{"method":"Foo","service":"PythonService","waitForReady":true}]}]}}]',
       type: TXT}
 - expected_addrs:
@@ -89,6 +91,7 @@ resolver_component_tests:
   records:
     ipv4-cpp-config-has-zero-percentage:
     - {TTL: '2100', data: 1.2.3.4, type: A}
+    _grpc_config.ipv4-cpp-config-has-zero-percentage:
     - {TTL: '2100', data: 'grpc_config=[{"percentage":0,"serviceConfig":{"loadBalancingPolicy":"round_robin","methodConfig":[{"name":[{"method":"Foo","service":"CppService","waitForReady":true}]}]}}]',
       type: TXT}
 - expected_addrs:
@@ -99,6 +102,7 @@ resolver_component_tests:
   records:
     ipv4-second-language-is-cpp:
     - {TTL: '2100', data: 1.2.3.4, type: A}
+    _grpc_config.ipv4-second-language-is-cpp:
     - {TTL: '2100', data: 'grpc_config=[{"clientLanguage":["go"],"serviceConfig":{"loadBalancingPolicy":"round_robin","methodConfig":[{"name":[{"method":"Foo","service":"GoService","waitForReady":true}]}]}},{"clientLanguage":["c++"],"serviceConfig":{"loadBalancingPolicy":"round_robin","methodConfig":[{"name":[{"method":"Foo","service":"CppService","waitForReady":true}]}]}}]',
       type: TXT}
 - expected_addrs:
@@ -109,6 +113,7 @@ resolver_component_tests:
   records:
     ipv4-config-with-percentages:
     - {TTL: '2100', data: 1.2.3.4, type: A}
+    _grpc_config.ipv4-config-with-percentages:
     - {TTL: '2100', data: 'grpc_config=[{"percentage":0,"serviceConfig":{"loadBalancingPolicy":"round_robin","methodConfig":[{"name":[{"method":"Foo","service":"NeverPickedService","waitForReady":true}]}]}},{"percentage":100,"serviceConfig":{"loadBalancingPolicy":"round_robin","methodConfig":[{"name":[{"method":"Foo","service":"AlwaysPickedService","waitForReady":true}]}]}}]',
       type: TXT}
 - expected_addrs:
@@ -145,5 +150,6 @@ resolver_component_tests:
   records:
     ipv4-config-causing-fallback-to-tcp:
     - {TTL: '2100', data: 1.2.3.4, type: A}
+    _grpc_config.ipv4-config-causing-fallback-to-tcp:
     - {TTL: '2100', data: 'grpc_config=[{"serviceConfig":{"loadBalancingPolicy":"round_robin","methodConfig":[{"name":[{"method":"Foo","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooTwo","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooThree","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooFour","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooFive","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooSix","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooSeven","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooEight","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooNine","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooTen","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooEleven","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooTwelve","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooTwelve","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooTwelve","service":"SimpleService","waitForReady":true}]},{"name":[{"method":"FooTwelve","service":"SimpleService","waitForReady":true}]}]}}]',
       type: TXT}
diff --git a/test/cpp/performance/writes_per_rpc_test.cc b/test/cpp/performance/writes_per_rpc_test.cc
index f4f794cb88..23fff2ea8b 100644
--- a/test/cpp/performance/writes_per_rpc_test.cc
+++ b/test/cpp/performance/writes_per_rpc_test.cc
@@ -26,7 +26,6 @@
 #include <grpc/support/log.h>
 #include <gtest/gtest.h>
 
-extern "C" {
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/endpoint.h"
@@ -38,7 +37,7 @@ extern "C" {
 #include "src/core/lib/surface/server.h"
 #include "test/core/util/passthru_endpoint.h"
 #include "test/core/util/port.h"
-}
+
 #include "src/cpp/client/create_channel_internal.h"
 #include "src/proto/grpc/testing/echo.grpc.pb.h"
 #include "test/core/util/test_config.h"
@@ -101,8 +100,8 @@ class EndpointPairFixture {
       }
 
       grpc_server_setup_transport(&exec_ctx, server_->c_server(), transport,
-                                  NULL, server_args);
-      grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL);
+                                  nullptr, server_args);
+      grpc_chttp2_transport_start_reading(&exec_ctx, transport, nullptr);
     }
 
     /* create channel */
@@ -117,7 +116,7 @@ class EndpointPairFixture {
       GPR_ASSERT(transport);
       grpc_channel* channel = grpc_channel_create(
           &exec_ctx, "target", &c_args, GRPC_CLIENT_DIRECT_CHANNEL, transport);
-      grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL);
+      grpc_chttp2_transport_start_reading(&exec_ctx, transport, nullptr);
 
       channel_ = CreateChannelInternal("", channel);
     }
diff --git a/test/cpp/qps/BUILD b/test/cpp/qps/BUILD
index 3352269517..0d91d52f22 100644
--- a/test/cpp/qps/BUILD
+++ b/test/cpp/qps/BUILD
@@ -109,6 +109,18 @@ grpc_cc_library(
     deps = ["//:gpr"],
 )
 
+grpc_cc_test(
+    name = "inproc_sync_unary_ping_pong_test",
+    srcs = ["inproc_sync_unary_ping_pong_test.cc"],
+    deps = [
+        ":benchmark_config",
+        ":driver_impl",
+        "//:grpc++",
+        "//test/cpp/util:test_config",
+        "//test/cpp/util:test_util",
+    ],
+)
+
 grpc_cc_library(
     name = "interarrival",
     hdrs = ["interarrival.h"],
diff --git a/test/cpp/qps/client.h b/test/cpp/qps/client.h
index abf755b393..82c6361abd 100644
--- a/test/cpp/qps/client.h
+++ b/test/cpp/qps/client.h
@@ -37,10 +37,14 @@
 #include "src/cpp/util/core_stats.h"
 #include "test/cpp/qps/histogram.h"
 #include "test/cpp/qps/interarrival.h"
+#include "test/cpp/qps/qps_worker.h"
+#include "test/cpp/qps/server.h"
 #include "test/cpp/qps/usage_timer.h"
 #include "test/cpp/util/create_test_channel.h"
 #include "test/cpp/util/test_credentials_provider.h"
 
+#define INPROC_NAME_PREFIX "qpsinproc:"
+
 namespace grpc {
 namespace testing {
 
@@ -226,8 +230,6 @@ class Client {
   }
 
   virtual void DestroyMultithreading() = 0;
-  virtual void InitThreadFunc(size_t thread_idx) = 0;
-  virtual bool ThreadFunc(HistogramEntry* histogram, size_t thread_idx) = 0;
 
   void SetupLoadTest(const ClientConfig& config, size_t num_threads) {
     // Set up the load distribution based on the number of threads
@@ -275,7 +277,6 @@ class Client {
                         : std::bind(&Client::NextIssueTime, this, thread_idx);
   }
 
- private:
   class Thread {
    public:
     Thread(Client* client, size_t idx)
@@ -295,6 +296,16 @@ class Client {
       MergeStatusHistogram(statuses_, s);
     }
 
+    void UpdateHistogram(HistogramEntry* entry) {
+      std::lock_guard<std::mutex> g(mu_);
+      if (entry->value_used()) {
+        histogram_.Add(entry->value());
+      }
+      if (entry->status_used()) {
+        statuses_[entry->status()]++;
+      }
+    }
+
    private:
     Thread(const Thread&);
     Thread& operator=(const Thread&);
@@ -310,29 +321,8 @@ class Client {
         wait_loop++;
       }
 
-      client_->InitThreadFunc(idx_);
-
-      for (;;) {
-        // run the loop body
-        HistogramEntry entry;
-        const bool thread_still_ok = client_->ThreadFunc(&entry, idx_);
-        // lock, update histogram if needed and see if we're done
-        std::lock_guard<std::mutex> g(mu_);
-        if (entry.value_used()) {
-          histogram_.Add(entry.value());
-        }
-        if (entry.status_used()) {
-          statuses_[entry.status()]++;
-        }
-        if (!thread_still_ok) {
-          gpr_log(GPR_ERROR, "Finishing client thread due to RPC error");
-        }
-        if (!thread_still_ok ||
-            static_cast<bool>(gpr_atm_acq_load(&client_->thread_pool_done_))) {
-          client_->CompleteThread();
-          return;
-        }
-      }
+      client_->ThreadFunc(idx_, this);
+      client_->CompleteThread();
     }
 
     std::mutex mu_;
@@ -343,6 +333,12 @@ class Client {
     std::thread impl_;
   };
 
+  bool ThreadCompleted() {
+    return static_cast<bool>(gpr_atm_acq_load(&thread_pool_done_));
+  }
+
+  virtual void ThreadFunc(size_t thread_idx, Client::Thread* t) = 0;
+
   std::vector<std::unique_ptr<Thread>> threads_;
   std::unique_ptr<UsageTimer> timer_;
 
@@ -422,11 +418,21 @@ class ClientImpl : public Client {
         type = config.security_params().cred_type();
       }
 
-      channel_ = CreateTestChannel(
-          target, type, config.security_params().server_host_override(),
-          !config.security_params().use_test_ca(),
-          std::shared_ptr<CallCredentials>(), args);
-      gpr_log(GPR_INFO, "Connecting to %s", target.c_str());
+      grpc::string inproc_pfx(INPROC_NAME_PREFIX);
+      if (target.find(inproc_pfx) != 0) {
+        channel_ = CreateTestChannel(
+            target, type, config.security_params().server_host_override(),
+            !config.security_params().use_test_ca(),
+            std::shared_ptr<CallCredentials>(), args);
+        gpr_log(GPR_INFO, "Connecting to %s", target.c_str());
+        is_inproc_ = false;
+      } else {
+        grpc::string tgt = target;
+        tgt.erase(0, inproc_pfx.length());
+        int srv_num = std::stoi(tgt);
+        channel_ = (*g_inproc_servers)[srv_num]->InProcessChannel(args);
+        is_inproc_ = true;
+      }
       stub_ = create_stub(channel_);
     }
     Channel* get_channel() { return channel_.get(); }
@@ -434,9 +440,11 @@ class ClientImpl : public Client {
 
     std::unique_ptr<std::thread> WaitForReady() {
       return std::unique_ptr<std::thread>(new std::thread([this]() {
-        GPR_ASSERT(channel_->WaitForConnected(
-            gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
-                         gpr_time_from_seconds(10, GPR_TIMESPAN))));
+        if (!is_inproc_) {
+          GPR_ASSERT(channel_->WaitForConnected(
+              gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
+                           gpr_time_from_seconds(10, GPR_TIMESPAN))));
+        }
       }));
     }
 
@@ -455,6 +463,7 @@ class ClientImpl : public Client {
 
     std::shared_ptr<Channel> channel_;
     std::unique_ptr<StubType> stub_;
+    bool is_inproc_;
   };
   std::vector<ClientChannelInfo> channels_;
   std::function<std::unique_ptr<StubType>(const std::shared_ptr<Channel>&)>
diff --git a/test/cpp/qps/client_async.cc b/test/cpp/qps/client_async.cc
index 9ed4e0b355..07888214e7 100644
--- a/test/cpp/qps/client_async.cc
+++ b/test/cpp/qps/client_async.cc
@@ -149,9 +149,9 @@ class AsyncClient : public ClientImpl<StubType, RequestType> {
   // Specify which protected members we are using since there is no
   // member name resolution until the template types are fully resolved
  public:
+  using Client::NextIssuer;
   using Client::SetupLoadTest;
   using Client::closed_loop_;
-  using Client::NextIssuer;
   using ClientImpl<StubType, RequestType>::cores_;
   using ClientImpl<StubType, RequestType>::channels_;
   using ClientImpl<StubType, RequestType>::request_;
@@ -236,32 +236,56 @@ class AsyncClient : public ClientImpl<StubType, RequestType> {
     this->EndThreads();  // this needed for resolution
   }
 
-  void InitThreadFunc(size_t thread_idx) override final {}
-  bool ThreadFunc(HistogramEntry* entry, size_t thread_idx) override final {
-    void* got_tag;
-    bool ok;
-
-    if (cli_cqs_[cq_[thread_idx]]->Next(&got_tag, &ok)) {
-      // Got a regular event, so process it
-      ClientRpcContext* ctx = ClientRpcContext::detag(got_tag);
-      // Proceed while holding a lock to make sure that
-      // this thread isn't supposed to shut down
-      std::lock_guard<std::mutex> l(shutdown_state_[thread_idx]->mutex);
-      if (shutdown_state_[thread_idx]->shutdown) {
+  ClientRpcContext* ProcessTag(size_t thread_idx, void* tag) {
+    ClientRpcContext* ctx = ClientRpcContext::detag(tag);
+    if (shutdown_state_[thread_idx]->shutdown) {
+      ctx->TryCancel();
+      delete ctx;
+      bool ok;
+      while (cli_cqs_[cq_[thread_idx]]->Next(&tag, &ok)) {
+        ctx = ClientRpcContext::detag(tag);
         ctx->TryCancel();
         delete ctx;
-        return true;
       }
-      if (!ctx->RunNextState(ok, entry)) {
-        // The RPC and callback are done, so clone the ctx
-        // and kickstart the new one
-        ctx->StartNewClone(cli_cqs_[cq_[thread_idx]].get());
-        delete ctx;
+      return nullptr;
+    }
+    return ctx;
+  }
+
+  void ThreadFunc(size_t thread_idx, Client::Thread* t) override final {
+    void* got_tag;
+    bool ok;
+
+    HistogramEntry entry;
+    HistogramEntry* entry_ptr = &entry;
+    if (!cli_cqs_[cq_[thread_idx]]->Next(&got_tag, &ok)) {
+      return;
+    }
+    std::mutex* shutdown_mu = &shutdown_state_[thread_idx]->mutex;
+    shutdown_mu->lock();
+    ClientRpcContext* ctx = ProcessTag(thread_idx, got_tag);
+    if (ctx == nullptr) {
+      shutdown_mu->unlock();
+      return;
+    }
+    while (cli_cqs_[cq_[thread_idx]]->DoThenAsyncNext(
+        [&, ctx, ok, entry_ptr, shutdown_mu]() {
+          if (!ctx->RunNextState(ok, entry_ptr)) {
+            // The RPC and callback are done, so clone the ctx
+            // and kickstart the new one
+            ctx->StartNewClone(cli_cqs_[cq_[thread_idx]].get());
+            delete ctx;
+          }
+          shutdown_mu->unlock();
+        },
+        &got_tag, &ok, gpr_inf_future(GPR_CLOCK_REALTIME))) {
+      t->UpdateHistogram(entry_ptr);
+      shutdown_mu->lock();
+      ctx = ProcessTag(thread_idx, got_tag);
+      if (ctx == nullptr) {
+        shutdown_mu->unlock();
+        return;
       }
-      return true;
-    } else {
-      // queue is shutting down, so we must be  done
-      return true;
     }
   }
 
diff --git a/test/cpp/qps/client_sync.cc b/test/cpp/qps/client_sync.cc
index 94554a46b2..9f20b148eb 100644
--- a/test/cpp/qps/client_sync.cc
+++ b/test/cpp/qps/client_sync.cc
@@ -62,6 +62,25 @@ class SynchronousClient
 
   virtual ~SynchronousClient(){};
 
+  virtual void InitThreadFuncImpl(size_t thread_idx) = 0;
+  virtual bool ThreadFuncImpl(HistogramEntry* entry, size_t thread_idx) = 0;
+
+  void ThreadFunc(size_t thread_idx, Thread* t) override {
+    InitThreadFuncImpl(thread_idx);
+    for (;;) {
+      // run the loop body
+      HistogramEntry entry;
+      const bool thread_still_ok = ThreadFuncImpl(&entry, thread_idx);
+      t->UpdateHistogram(&entry);
+      if (!thread_still_ok) {
+        gpr_log(GPR_ERROR, "Finishing client thread due to RPC error");
+      }
+      if (!thread_still_ok || ThreadCompleted()) {
+        return;
+      }
+    }
+  }
+
  protected:
   // WaitToIssue returns false if we realize that we need to break out
   bool WaitToIssue(int thread_idx) {
@@ -103,9 +122,9 @@ class SynchronousUnaryClient final : public SynchronousClient {
   }
   ~SynchronousUnaryClient() {}
 
-  void InitThreadFunc(size_t thread_idx) override {}
+  void InitThreadFuncImpl(size_t thread_idx) override {}
 
-  bool ThreadFunc(HistogramEntry* entry, size_t thread_idx) override {
+  bool ThreadFuncImpl(HistogramEntry* entry, size_t thread_idx) override {
     if (!WaitToIssue(thread_idx)) {
       return true;
     }
@@ -192,13 +211,13 @@ class SynchronousStreamingPingPongClient final
     }
   }
 
-  void InitThreadFunc(size_t thread_idx) override {
+  void InitThreadFuncImpl(size_t thread_idx) override {
     auto* stub = channels_[thread_idx % channels_.size()].get_stub();
     stream_[thread_idx] = stub->StreamingCall(&context_[thread_idx]);
     messages_issued_[thread_idx] = 0;
   }
 
-  bool ThreadFunc(HistogramEntry* entry, size_t thread_idx) override {
+  bool ThreadFuncImpl(HistogramEntry* entry, size_t thread_idx) override {
     if (!WaitToIssue(thread_idx)) {
       return true;
     }
@@ -246,14 +265,14 @@ class SynchronousStreamingFromClientClient final
     }
   }
 
-  void InitThreadFunc(size_t thread_idx) override {
+  void InitThreadFuncImpl(size_t thread_idx) override {
     auto* stub = channels_[thread_idx % channels_.size()].get_stub();
     stream_[thread_idx] = stub->StreamingFromClient(&context_[thread_idx],
                                                     &responses_[thread_idx]);
     last_issue_[thread_idx] = UsageTimer::Now();
   }
 
-  bool ThreadFunc(HistogramEntry* entry, size_t thread_idx) override {
+  bool ThreadFuncImpl(HistogramEntry* entry, size_t thread_idx) override {
     // Figure out how to make histogram sensible if this is rate-paced
     if (!WaitToIssue(thread_idx)) {
       return true;
@@ -282,13 +301,13 @@ class SynchronousStreamingFromServerClient final
  public:
   SynchronousStreamingFromServerClient(const ClientConfig& config)
       : SynchronousStreamingClient(config), last_recv_(num_threads_) {}
-  void InitThreadFunc(size_t thread_idx) override {
+  void InitThreadFuncImpl(size_t thread_idx) override {
     auto* stub = channels_[thread_idx % channels_.size()].get_stub();
     stream_[thread_idx] =
         stub->StreamingFromServer(&context_[thread_idx], request_);
     last_recv_[thread_idx] = UsageTimer::Now();
   }
-  bool ThreadFunc(HistogramEntry* entry, size_t thread_idx) override {
+  bool ThreadFuncImpl(HistogramEntry* entry, size_t thread_idx) override {
     GPR_TIMER_SCOPE("SynchronousStreamingFromServerClient::ThreadFunc", 0);
     if (stream_[thread_idx]->Read(&responses_[thread_idx])) {
       double now = UsageTimer::Now();
@@ -328,11 +347,11 @@ class SynchronousStreamingBothWaysClient final
     }
   }
 
-  void InitThreadFunc(size_t thread_idx) override {
+  void InitThreadFuncImpl(size_t thread_idx) override {
     auto* stub = channels_[thread_idx % channels_.size()].get_stub();
     stream_[thread_idx] = stub->StreamingBothWays(&context_[thread_idx]);
   }
-  bool ThreadFunc(HistogramEntry* entry, size_t thread_idx) override {
+  bool ThreadFuncImpl(HistogramEntry* entry, size_t thread_idx) override {
     // TODO (vjpai): Do this
     return true;
   }
diff --git a/test/cpp/qps/driver.cc b/test/cpp/qps/driver.cc
index 4458e389e7..22d039d4b7 100644
--- a/test/cpp/qps/driver.cc
+++ b/test/cpp/qps/driver.cc
@@ -36,16 +36,17 @@
 #include "src/proto/grpc/testing/services.grpc.pb.h"
 #include "test/core/util/port.h"
 #include "test/core/util/test_config.h"
+#include "test/cpp/qps/client.h"
 #include "test/cpp/qps/driver.h"
 #include "test/cpp/qps/histogram.h"
 #include "test/cpp/qps/qps_worker.h"
 #include "test/cpp/qps/stats.h"
 #include "test/cpp/util/test_credentials_provider.h"
 
+using std::deque;
 using std::list;
 using std::thread;
 using std::unique_ptr;
-using std::deque;
 using std::vector;
 
 namespace grpc {
@@ -63,11 +64,11 @@ static std::string get_host(const std::string& worker) {
 }
 
 static deque<string> get_workers(const string& env_name) {
+  deque<string> out;
   char* env = gpr_getenv(env_name.c_str());
   if (!env) {
     env = gpr_strdup("");
   }
-  deque<string> out;
   char* p = env;
   if (strlen(env) != 0) {
     for (;;) {
@@ -146,9 +147,8 @@ static void postprocess_scenario_result(ScenarioResult* result) {
     result->mutable_summary()->set_server_cpu_usage(0);
   } else {
     auto server_cpu_usage =
-        100 -
-        100 * average(result->server_stats(), ServerIdleCpuTime) /
-            average(result->server_stats(), ServerTotalCpuTime);
+        100 - 100 * average(result->server_stats(), ServerIdleCpuTime) /
+                  average(result->server_stats(), ServerTotalCpuTime);
     result->mutable_summary()->set_server_cpu_usage(server_cpu_usage);
   }
 
@@ -187,12 +187,17 @@ static void postprocess_scenario_result(ScenarioResult* result) {
       client_queries_per_cpu_sec);
 }
 
+std::vector<grpc::testing::Server*>* g_inproc_servers = nullptr;
+
 std::unique_ptr<ScenarioResult> RunScenario(
     const ClientConfig& initial_client_config, size_t num_clients,
     const ServerConfig& initial_server_config, size_t num_servers,
     int warmup_seconds, int benchmark_seconds, int spawn_local_worker_count,
     const grpc::string& qps_server_target_override,
-    const grpc::string& credential_type) {
+    const grpc::string& credential_type, bool run_inproc) {
+  if (run_inproc) {
+    g_inproc_servers = new std::vector<grpc::testing::Server*>;
+  }
   // Log everything from the driver
   gpr_set_log_verbosity(GPR_LOG_SEVERITY_DEBUG);
 
@@ -210,8 +215,8 @@ std::unique_ptr<ScenarioResult> RunScenario(
   ClientConfig result_client_config;
   const ServerConfig result_server_config = initial_server_config;
 
-  // Get client, server lists
-  auto workers = get_workers("QPS_WORKERS");
+  // Get client, server lists; ignore if inproc test
+  auto workers = (!run_inproc) ? get_workers("QPS_WORKERS") : deque<string>();
   ClientConfig client_config = initial_client_config;
 
   // Spawn some local workers if desired
@@ -227,9 +232,10 @@ std::unique_ptr<ScenarioResult> RunScenario(
       called_init = true;
     }
 
-    int driver_port = grpc_pick_unused_port_or_die();
-    local_workers.emplace_back(new QpsWorker(driver_port, 0, credential_type));
     char addr[256];
+    // we use port # of -1 to indicate inproc
+    int driver_port = (!run_inproc) ? grpc_pick_unused_port_or_die() : -1;
+    local_workers.emplace_back(new QpsWorker(driver_port, 0, credential_type));
     sprintf(addr, "localhost:%d", driver_port);
     if (spawn_local_worker_count < 0) {
       workers.push_front(addr);
@@ -265,9 +271,14 @@ std::unique_ptr<ScenarioResult> RunScenario(
   for (size_t i = 0; i < num_servers; i++) {
     gpr_log(GPR_INFO, "Starting server on %s (worker #%" PRIuPTR ")",
             workers[i].c_str(), i);
-    servers[i].stub = WorkerService::NewStub(CreateChannel(
-        workers[i], GetCredentialsProvider()->GetChannelCredentials(
-                        credential_type, &channel_args)));
+    if (!run_inproc) {
+      servers[i].stub = WorkerService::NewStub(CreateChannel(
+          workers[i], GetCredentialsProvider()->GetChannelCredentials(
+                          credential_type, &channel_args)));
+    } else {
+      servers[i].stub = WorkerService::NewStub(
+          local_workers[i]->InProcessChannel(channel_args));
+    }
 
     ServerConfig server_config = initial_server_config;
     if (server_config.core_limit() != 0) {
@@ -289,6 +300,10 @@ std::unique_ptr<ScenarioResult> RunScenario(
       // overriding the qps server target only works if there is 1 server
       GPR_ASSERT(num_servers == 1);
       client_config.add_server_targets(qps_server_target_override);
+    } else if (run_inproc) {
+      std::string cli_target(INPROC_NAME_PREFIX);
+      cli_target += std::to_string(i);
+      client_config.add_server_targets(cli_target);
     } else {
       std::string host;
       char* cli_target;
@@ -312,9 +327,14 @@ std::unique_ptr<ScenarioResult> RunScenario(
     const auto& worker = workers[i + num_servers];
     gpr_log(GPR_INFO, "Starting client on %s (worker #%" PRIuPTR ")",
             worker.c_str(), i + num_servers);
-    clients[i].stub = WorkerService::NewStub(
-        CreateChannel(worker, GetCredentialsProvider()->GetChannelCredentials(
-                                  credential_type, &channel_args)));
+    if (!run_inproc) {
+      clients[i].stub = WorkerService::NewStub(
+          CreateChannel(worker, GetCredentialsProvider()->GetChannelCredentials(
+                                    credential_type, &channel_args)));
+    } else {
+      clients[i].stub = WorkerService::NewStub(
+          local_workers[i + num_servers]->InProcessChannel(channel_args));
+    }
     ClientConfig per_client_config = client_config;
 
     if (initial_client_config.core_limit() != 0) {
@@ -495,6 +515,9 @@ std::unique_ptr<ScenarioResult> RunScenario(
     }
   }
 
+  if (g_inproc_servers != nullptr) {
+    delete g_inproc_servers;
+  }
   postprocess_scenario_result(result.get());
   return result;
 }
diff --git a/test/cpp/qps/driver.h b/test/cpp/qps/driver.h
index 29f2776d79..fede4d8045 100644
--- a/test/cpp/qps/driver.h
+++ b/test/cpp/qps/driver.h
@@ -32,7 +32,7 @@ std::unique_ptr<ScenarioResult> RunScenario(
     const grpc::testing::ServerConfig& server_config, size_t num_servers,
     int warmup_seconds, int benchmark_seconds, int spawn_local_worker_count,
     const grpc::string& qps_server_target_override,
-    const grpc::string& credential_type);
+    const grpc::string& credential_type, bool run_inproc);
 
 bool RunQuit(const grpc::string& credential_type);
 }  // namespace testing
diff --git a/test/cpp/qps/gen_build_yaml.py b/test/cpp/qps/gen_build_yaml.py
index 65553f57f1..1ef8f65b0b 100755
--- a/test/cpp/qps/gen_build_yaml.py
+++ b/test/cpp/qps/gen_build_yaml.py
@@ -85,6 +85,24 @@ print yaml.dump({
     if 'scalable' in scenario_json.get('CATEGORIES', [])
   ] + [
     {
+      'name': 'qps_json_driver',
+      'shortname': 'qps_json_driver:inproc_%s' % scenario_json['name'],
+      'args': ['--run_inproc', '--scenarios_json', _scenario_json_string(scenario_json, False)],
+      'ci_platforms': ['linux'],
+      'platforms': ['linux'],
+      'flaky': False,
+      'language': 'c++',
+      'boringssl': True,
+      'defaults': 'boringssl',
+      'cpu_cost': guess_cpu(scenario_json, False),
+      'exclude_configs': ['tsan', 'asan'],
+      'timeout_seconds': 6*60,
+      'excluded_poll_engines': scenario_json.get('EXCLUDED_POLL_ENGINES', [])
+    }
+    for scenario_json in scenario_config.CXXLanguage().scenarios()
+    if 'inproc' in scenario_json.get('CATEGORIES', [])
+  ] + [
+    {
       'name': 'json_run_localhost',
       'shortname': 'json_run_localhost:%s_low_thread_count' % scenario_json['name'],
       'args': ['--scenarios_json', _scenario_json_string(scenario_json, True)],
diff --git a/test/cpp/qps/histogram.h b/test/cpp/qps/histogram.h
index 3d04ee57da..e31d5d78a8 100644
--- a/test/cpp/qps/histogram.h
+++ b/test/cpp/qps/histogram.h
@@ -70,7 +70,7 @@ class Histogram {
 
   gpr_histogram* impl_;
 };
-}
-}
+}  // namespace testing
+}  // namespace grpc
 
 #endif /* TEST_QPS_HISTOGRAM_H */
diff --git a/test/cpp/qps/inproc_sync_unary_ping_pong_test.cc b/test/cpp/qps/inproc_sync_unary_ping_pong_test.cc
new file mode 100644
index 0000000000..f2e977d48b
--- /dev/null
+++ b/test/cpp/qps/inproc_sync_unary_ping_pong_test.cc
@@ -0,0 +1,66 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <set>
+
+#include <grpc/support/log.h>
+
+#include "test/cpp/qps/benchmark_config.h"
+#include "test/cpp/qps/driver.h"
+#include "test/cpp/qps/report.h"
+#include "test/cpp/qps/server.h"
+#include "test/cpp/util/test_config.h"
+#include "test/cpp/util/test_credentials_provider.h"
+
+namespace grpc {
+namespace testing {
+
+static const int WARMUP = 5;
+static const int BENCHMARK = 5;
+
+static void RunSynchronousUnaryPingPong() {
+  gpr_log(GPR_INFO, "Running Synchronous Unary Ping Pong");
+
+  ClientConfig client_config;
+  client_config.set_client_type(SYNC_CLIENT);
+  client_config.set_outstanding_rpcs_per_channel(1);
+  client_config.set_client_channels(1);
+  client_config.set_rpc_type(UNARY);
+  client_config.mutable_load_params()->mutable_closed_loop();
+
+  ServerConfig server_config;
+  server_config.set_server_type(SYNC_SERVER);
+
+  const auto result =
+      RunScenario(client_config, 1, server_config, 1, WARMUP, BENCHMARK, -2, "",
+                  kInsecureCredentialsType, true);
+
+  GetReporter()->ReportQPS(*result);
+  GetReporter()->ReportLatency(*result);
+}
+
+}  // namespace testing
+}  // namespace grpc
+
+int main(int argc, char** argv) {
+  grpc::testing::InitTest(&argc, &argv, true);
+
+  grpc::testing::RunSynchronousUnaryPingPong();
+
+  return 0;
+}
diff --git a/test/cpp/qps/interarrival.h b/test/cpp/qps/interarrival.h
index 1fa310c209..9c48066c9c 100644
--- a/test/cpp/qps/interarrival.h
+++ b/test/cpp/qps/interarrival.h
@@ -102,7 +102,7 @@ class InterarrivalTimer {
   std::vector<time_table::const_iterator> thread_posns_;
   time_table random_table_;
 };
-}
-}
+}  // namespace testing
+}  // namespace grpc
 
 #endif
diff --git a/test/cpp/qps/json_run_localhost.cc b/test/cpp/qps/json_run_localhost.cc
index 1d394b216f..db8b2a3943 100644
--- a/test/cpp/qps/json_run_localhost.cc
+++ b/test/cpp/qps/json_run_localhost.cc
@@ -46,7 +46,7 @@ std::string as_string(const T& val) {
 
 static void sighandler(int sig) {
   const int errno_saved = errno;
-  if (g_driver != NULL) g_driver->Interrupt();
+  if (g_driver != nullptr) g_driver->Interrupt();
   for (int i = 0; i < kNumWorkers; ++i) {
     if (g_workers[i]) g_workers[i]->Interrupt();
   }
@@ -58,8 +58,8 @@ static void register_sighandler() {
   memset(&act, 0, sizeof(act));
   act.sa_handler = sighandler;
 
-  sigaction(SIGINT, &act, NULL);
-  sigaction(SIGTERM, &act, NULL);
+  sigaction(SIGINT, &act, nullptr);
+  sigaction(SIGTERM, &act, nullptr);
 }
 
 static void LogStatus(int status, const char* label) {
@@ -117,8 +117,14 @@ int main(int argc, char** argv) {
     }
   }
 
-  delete g_driver;
-  g_driver = NULL;
-  for (int i = 0; i < kNumWorkers; ++i) delete g_workers[i];
+  if (g_driver != nullptr) {
+    delete g_driver;
+  }
+  g_driver = nullptr;
+  for (int i = 0; i < kNumWorkers; ++i) {
+    if (g_workers[i] != nullptr) {
+      delete g_workers[i];
+    }
+  }
   GPR_ASSERT(driver_join_status == 0);
 }
diff --git a/test/cpp/qps/parse_json.cc b/test/cpp/qps/parse_json.cc
index 343e073f3f..a98ae394db 100644
--- a/test/cpp/qps/parse_json.cc
+++ b/test/cpp/qps/parse_json.cc
@@ -61,5 +61,5 @@ grpc::string SerializeJson(const GRPC_CUSTOM_MESSAGE& msg,
   return json_string;
 }
 
-}  // testing
-}  // grpc
+}  // namespace testing
+}  // namespace grpc
diff --git a/test/cpp/qps/parse_json.h b/test/cpp/qps/parse_json.h
index b320d26c1a..f2fffb52d4 100644
--- a/test/cpp/qps/parse_json.h
+++ b/test/cpp/qps/parse_json.h
@@ -31,7 +31,7 @@ void ParseJson(const grpc::string& json, const grpc::string& type,
 grpc::string SerializeJson(const GRPC_CUSTOM_MESSAGE& msg,
                            const grpc::string& type);
 
-}  // testing
-}  // grpc
+}  // namespace testing
+}  // namespace grpc
 
 #endif  // TEST_QPS_PARSE_JSON_H
diff --git a/test/cpp/qps/qps_interarrival_test.cc b/test/cpp/qps/qps_interarrival_test.cc
index 87f09e8c5f..461bf624ce 100644
--- a/test/cpp/qps/qps_interarrival_test.cc
+++ b/test/cpp/qps/qps_interarrival_test.cc
@@ -25,13 +25,13 @@
 #include "test/cpp/qps/interarrival.h"
 #include "test/cpp/util/test_config.h"
 
-using grpc::testing::RandomDistInterface;
 using grpc::testing::InterarrivalTimer;
+using grpc::testing::RandomDistInterface;
 
-static void RunTest(RandomDistInterface &&r, int threads, std::string title) {
+static void RunTest(RandomDistInterface&& r, int threads, std::string title) {
   InterarrivalTimer timer;
   timer.init(r, threads);
-  gpr_histogram *h(gpr_histogram_create(0.01, 60e9));
+  gpr_histogram* h(gpr_histogram_create(0.01, 60e9));
 
   for (int i = 0; i < 10000000; i++) {
     for (int j = 0; j < threads; j++) {
@@ -50,7 +50,7 @@ static void RunTest(RandomDistInterface &&r, int threads, std::string title) {
 
 using grpc::testing::ExpDist;
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc::testing::InitTest(&argc, &argv, true);
 
   RunTest(ExpDist(10.0), 5, std::string("Exponential(10)"));
diff --git a/test/cpp/qps/qps_json_driver.cc b/test/cpp/qps/qps_json_driver.cc
index cca59f64d8..b2449da69c 100644
--- a/test/cpp/qps/qps_json_driver.cc
+++ b/test/cpp/qps/qps_json_driver.cc
@@ -30,6 +30,7 @@
 #include "test/cpp/qps/driver.h"
 #include "test/cpp/qps/parse_json.h"
 #include "test/cpp/qps/report.h"
+#include "test/cpp/qps/server.h"
 #include "test/cpp/util/test_config.h"
 #include "test/cpp/util/test_credentials_provider.h"
 
@@ -64,6 +65,7 @@ DEFINE_string(json_file_out, "", "File to write the JSON output to.");
 
 DEFINE_string(credential_type, grpc::testing::kInsecureCredentialsType,
               "Credential type for communication with workers");
+DEFINE_bool(run_inproc, false, "Perform an in-process transport test");
 
 namespace grpc {
 namespace testing {
@@ -75,8 +77,9 @@ static std::unique_ptr<ScenarioResult> RunAndReport(const Scenario& scenario,
       RunScenario(scenario.client_config(), scenario.num_clients(),
                   scenario.server_config(), scenario.num_servers(),
                   scenario.warmup_seconds(), scenario.benchmark_seconds(),
-                  scenario.spawn_local_worker_count(),
-                  FLAGS_qps_server_target_override, FLAGS_credential_type);
+                  !FLAGS_run_inproc ? scenario.spawn_local_worker_count() : -2,
+                  FLAGS_qps_server_target_override, FLAGS_credential_type,
+                  FLAGS_run_inproc);
 
   // Amend the result with scenario config. Eventually we should adjust
   // RunScenario contract so we don't need to touch the result here.
@@ -178,7 +181,7 @@ static bool QpsDriver() {
   if (scfile) {
     // Read the json data from disk
     FILE* json_file = fopen(FLAGS_scenarios_file.c_str(), "r");
-    GPR_ASSERT(json_file != NULL);
+    GPR_ASSERT(json_file != nullptr);
     fseek(json_file, 0, SEEK_END);
     long len = ftell(json_file);
     char* data = new char[len];
diff --git a/test/cpp/qps/qps_openloop_test.cc b/test/cpp/qps/qps_openloop_test.cc
index 069b3fa076..df929b9811 100644
--- a/test/cpp/qps/qps_openloop_test.cc
+++ b/test/cpp/qps/qps_openloop_test.cc
@@ -24,6 +24,7 @@
 #include "test/cpp/qps/benchmark_config.h"
 #include "test/cpp/qps/driver.h"
 #include "test/cpp/qps/report.h"
+#include "test/cpp/qps/server.h"
 #include "test/cpp/util/test_config.h"
 #include "test/cpp/util/test_credentials_provider.h"
 
@@ -49,8 +50,9 @@ static void RunQPS() {
   server_config.set_server_type(ASYNC_SERVER);
   server_config.set_async_server_threads(8);
 
-  const auto result = RunScenario(client_config, 1, server_config, 1, WARMUP,
-                                  BENCHMARK, -2, "", kInsecureCredentialsType);
+  const auto result =
+      RunScenario(client_config, 1, server_config, 1, WARMUP, BENCHMARK, -2, "",
+                  kInsecureCredentialsType, false);
 
   GetReporter()->ReportQPSPerCore(*result);
   GetReporter()->ReportLatency(*result);
diff --git a/test/cpp/qps/qps_worker.cc b/test/cpp/qps/qps_worker.cc
index d20bc1b074..c288b03ec5 100644
--- a/test/cpp/qps/qps_worker.cc
+++ b/test/cpp/qps/qps_worker.cc
@@ -225,11 +225,14 @@ class WorkerServiceImpl final : public WorkerService::Service {
     if (!args.has_setup()) {
       return Status(StatusCode::INVALID_ARGUMENT, "Bad server creation args");
     }
-    if (server_port_ != 0) {
+    if (server_port_ > 0) {
       args.mutable_setup()->set_port(server_port_);
     }
     gpr_log(GPR_INFO, "RunServerBody: about to create server");
     auto server = CreateServer(args.setup());
+    if (g_inproc_servers != nullptr) {
+      g_inproc_servers->push_back(server.get());
+    }
     if (!server) {
       return Status(StatusCode::INVALID_ARGUMENT, "Couldn't create server");
     }
@@ -269,17 +272,17 @@ QpsWorker::QpsWorker(int driver_port, int server_port,
   impl_.reset(new WorkerServiceImpl(server_port, this));
   gpr_atm_rel_store(&done_, static_cast<gpr_atm>(0));
 
-  char* server_address = NULL;
-  gpr_join_host_port(&server_address, "::", driver_port);
-
   ServerBuilder builder;
-  builder.AddListeningPort(
-      server_address,
-      GetCredentialsProvider()->GetServerCredentials(credential_type));
+  if (driver_port >= 0) {
+    char* server_address = nullptr;
+    gpr_join_host_port(&server_address, "::", driver_port);
+    builder.AddListeningPort(
+        server_address,
+        GetCredentialsProvider()->GetServerCredentials(credential_type));
+    gpr_free(server_address);
+  }
   builder.RegisterService(impl_.get());
 
-  gpr_free(server_address);
-
   server_ = builder.BuildAndStart();
 }
 
diff --git a/test/cpp/qps/qps_worker.h b/test/cpp/qps/qps_worker.h
index 360125fb17..a5167426d0 100644
--- a/test/cpp/qps/qps_worker.h
+++ b/test/cpp/qps/qps_worker.h
@@ -21,17 +21,21 @@
 
 #include <memory>
 
+#include <grpc++/server.h>
+#include <grpc++/support/channel_arguments.h>
 #include <grpc++/support/config.h>
 #include <grpc/support/atm.h>
 
-namespace grpc {
+#include "test/cpp/qps/server.h"
 
-class Server;
+namespace grpc {
 
 namespace testing {
 
 class WorkerServiceImpl;
 
+extern std::vector<grpc::testing::Server*>* g_inproc_servers;
+
 class QpsWorker {
  public:
   explicit QpsWorker(int driver_port, int server_port,
@@ -41,9 +45,13 @@ class QpsWorker {
   bool Done() const;
   void MarkDone();
 
+  std::shared_ptr<Channel> InProcessChannel(const ChannelArguments& args) {
+    return server_->InProcessChannel(args);
+  }
+
  private:
   std::unique_ptr<WorkerServiceImpl> impl_;
-  std::unique_ptr<Server> server_;
+  std::unique_ptr<grpc::Server> server_;
 
   gpr_atm done_;
 };
diff --git a/test/cpp/qps/secure_sync_unary_ping_pong_test.cc b/test/cpp/qps/secure_sync_unary_ping_pong_test.cc
index 137b33ee25..bb415e9d63 100644
--- a/test/cpp/qps/secure_sync_unary_ping_pong_test.cc
+++ b/test/cpp/qps/secure_sync_unary_ping_pong_test.cc
@@ -23,6 +23,7 @@
 #include "test/cpp/qps/benchmark_config.h"
 #include "test/cpp/qps/driver.h"
 #include "test/cpp/qps/report.h"
+#include "test/cpp/qps/server.h"
 #include "test/cpp/util/test_config.h"
 #include "test/cpp/util/test_credentials_provider.h"
 
@@ -52,8 +53,9 @@ static void RunSynchronousUnaryPingPong() {
   client_config.mutable_security_params()->CopyFrom(security);
   server_config.mutable_security_params()->CopyFrom(security);
 
-  const auto result = RunScenario(client_config, 1, server_config, 1, WARMUP,
-                                  BENCHMARK, -2, "", kInsecureCredentialsType);
+  const auto result =
+      RunScenario(client_config, 1, server_config, 1, WARMUP, BENCHMARK, -2, "",
+                  kInsecureCredentialsType, false);
 
   GetReporter()->ReportQPS(*result);
   GetReporter()->ReportLatency(*result);
diff --git a/test/cpp/qps/server.h b/test/cpp/qps/server.h
index 16d101d5e6..9da33566dd 100644
--- a/test/cpp/qps/server.h
+++ b/test/cpp/qps/server.h
@@ -42,10 +42,9 @@ class Server {
   explicit Server(const ServerConfig& config)
       : timer_(new UsageTimer), last_reset_poll_count_(0) {
     cores_ = gpr_cpu_num_cores();
-    if (config.port()) {
+    if (config.port()) {  // positive for a fixed port, negative for inproc
       port_ = config.port();
-
-    } else {
+    } else {  // zero for dynamic port
       port_ = grpc_pick_unused_port_or_die();
     }
   }
@@ -115,6 +114,9 @@ class Server {
     return 0;
   }
 
+  virtual std::shared_ptr<Channel> InProcessChannel(
+      const ChannelArguments& args) = 0;
+
  protected:
   static void ApplyConfigToBuilder(const ServerConfig& config,
                                    ServerBuilder* builder) {
diff --git a/test/cpp/qps/server_async.cc b/test/cpp/qps/server_async.cc
index 4a82f98199..72ae772147 100644
--- a/test/cpp/qps/server_async.cc
+++ b/test/cpp/qps/server_async.cc
@@ -48,40 +48,43 @@ template <class RequestType, class ResponseType, class ServiceType,
 class AsyncQpsServerTest final : public grpc::testing::Server {
  public:
   AsyncQpsServerTest(
-      const ServerConfig &config,
-      std::function<void(ServerBuilder *, ServiceType *)> register_service,
-      std::function<void(ServiceType *, ServerContextType *, RequestType *,
-                         ServerAsyncResponseWriter<ResponseType> *,
-                         CompletionQueue *, ServerCompletionQueue *, void *)>
+      const ServerConfig& config,
+      std::function<void(ServerBuilder*, ServiceType*)> register_service,
+      std::function<void(ServiceType*, ServerContextType*, RequestType*,
+                         ServerAsyncResponseWriter<ResponseType>*,
+                         CompletionQueue*, ServerCompletionQueue*, void*)>
           request_unary_function,
-      std::function<void(ServiceType *, ServerContextType *,
-                         ServerAsyncReaderWriter<ResponseType, RequestType> *,
-                         CompletionQueue *, ServerCompletionQueue *, void *)>
+      std::function<void(ServiceType*, ServerContextType*,
+                         ServerAsyncReaderWriter<ResponseType, RequestType>*,
+                         CompletionQueue*, ServerCompletionQueue*, void*)>
           request_streaming_function,
-      std::function<void(ServiceType *, ServerContextType *,
-                         ServerAsyncReader<ResponseType, RequestType> *,
-                         CompletionQueue *, ServerCompletionQueue *, void *)>
+      std::function<void(ServiceType*, ServerContextType*,
+                         ServerAsyncReader<ResponseType, RequestType>*,
+                         CompletionQueue*, ServerCompletionQueue*, void*)>
           request_streaming_from_client_function,
-      std::function<void(ServiceType *, ServerContextType *, RequestType *,
-                         ServerAsyncWriter<ResponseType> *, CompletionQueue *,
-                         ServerCompletionQueue *, void *)>
+      std::function<void(ServiceType*, ServerContextType*, RequestType*,
+                         ServerAsyncWriter<ResponseType>*, CompletionQueue*,
+                         ServerCompletionQueue*, void*)>
           request_streaming_from_server_function,
-      std::function<void(ServiceType *, ServerContextType *,
-                         ServerAsyncReaderWriter<ResponseType, RequestType> *,
-                         CompletionQueue *, ServerCompletionQueue *, void *)>
+      std::function<void(ServiceType*, ServerContextType*,
+                         ServerAsyncReaderWriter<ResponseType, RequestType>*,
+                         CompletionQueue*, ServerCompletionQueue*, void*)>
           request_streaming_both_ways_function,
-      std::function<grpc::Status(const PayloadConfig &, const RequestType *,
-                                 ResponseType *)>
+      std::function<grpc::Status(const PayloadConfig&, RequestType*,
+                                 ResponseType*)>
           process_rpc)
       : Server(config) {
-    char *server_address = NULL;
-
-    gpr_join_host_port(&server_address, "::", port());
-
     ServerBuilder builder;
-    builder.AddListeningPort(server_address,
-                             Server::CreateServerCredentials(config));
-    gpr_free(server_address);
+
+    auto port_num = port();
+    // Negative port number means inproc server, so no listen port needed
+    if (port_num >= 0) {
+      char* server_address = nullptr;
+      gpr_join_host_port(&server_address, "::", port_num);
+      builder.AddListeningPort(server_address,
+                               Server::CreateServerCredentials(config));
+      gpr_free(server_address);
+    }
 
     register_service(&builder, &async_service_);
 
@@ -168,7 +171,7 @@ class AsyncQpsServerTest final : public grpc::testing::Server {
     }
     for (auto cq = srv_cqs_.begin(); cq != srv_cqs_.end(); ++cq) {
       bool ok;
-      void *got_tag;
+      void* got_tag;
       while ((*cq)->Next(&got_tag, &ok))
         ;
     }
@@ -183,6 +186,11 @@ class AsyncQpsServerTest final : public grpc::testing::Server {
     return count;
   }
 
+  std::shared_ptr<Channel> InProcessChannel(
+      const ChannelArguments& args) override {
+    return server_->InProcessChannel(args);
+  }
+
  private:
   void ShutdownThreadFunc() {
     // TODO (vpai): Remove this deadline and allow Shutdown to finish properly
@@ -193,24 +201,32 @@ class AsyncQpsServerTest final : public grpc::testing::Server {
   void ThreadFunc(int thread_idx) {
     // Wait until work is available or we are shutting down
     bool ok;
-    void *got_tag;
-    while (srv_cqs_[cq_[thread_idx]]->Next(&got_tag, &ok)) {
-      ServerRpcContext *ctx = detag(got_tag);
+    void* got_tag;
+    if (!srv_cqs_[cq_[thread_idx]]->Next(&got_tag, &ok)) {
+      return;
+    }
+    ServerRpcContext* ctx;
+    std::mutex* mu_ptr = &shutdown_state_[thread_idx]->mutex;
+    do {
+      ctx = detag(got_tag);
       // The tag is a pointer to an RPC context to invoke
       // Proceed while holding a lock to make sure that
       // this thread isn't supposed to shut down
-      std::lock_guard<std::mutex> l(shutdown_state_[thread_idx]->mutex);
+      mu_ptr->lock();
       if (shutdown_state_[thread_idx]->shutdown) {
+        mu_ptr->unlock();
         return;
       }
-      std::lock_guard<ServerRpcContext> l2(*ctx);
-      const bool still_going = ctx->RunNextState(ok);
-      // if this RPC context is done, refresh it
-      if (!still_going) {
-        ctx->Reset();
-      }
-    }
-    return;
+    } while (srv_cqs_[cq_[thread_idx]]->DoThenAsyncNext(
+        [&, ctx, ok, mu_ptr]() {
+          ctx->lock();
+          if (!ctx->RunNextState(ok)) {
+            ctx->Reset();
+          }
+          ctx->unlock();
+          mu_ptr->unlock();
+        },
+        &got_tag, &ok, gpr_inf_future(GPR_CLOCK_REALTIME)));
   }
 
   class ServerRpcContext {
@@ -224,22 +240,21 @@ class AsyncQpsServerTest final : public grpc::testing::Server {
    private:
     std::mutex mu_;
   };
-  static void *tag(ServerRpcContext *func) {
-    return reinterpret_cast<void *>(func);
+  static void* tag(ServerRpcContext* func) {
+    return reinterpret_cast<void*>(func);
   }
-  static ServerRpcContext *detag(void *tag) {
-    return reinterpret_cast<ServerRpcContext *>(tag);
+  static ServerRpcContext* detag(void* tag) {
+    return reinterpret_cast<ServerRpcContext*>(tag);
   }
 
   class ServerRpcContextUnaryImpl final : public ServerRpcContext {
    public:
     ServerRpcContextUnaryImpl(
-        std::function<void(ServerContextType *, RequestType *,
-                           grpc::ServerAsyncResponseWriter<ResponseType> *,
-                           void *)>
+        std::function<void(ServerContextType*, RequestType*,
+                           grpc::ServerAsyncResponseWriter<ResponseType>*,
+                           void*)>
             request_method,
-        std::function<grpc::Status(const RequestType *, ResponseType *)>
-            invoke_method)
+        std::function<grpc::Status(RequestType*, ResponseType*)> invoke_method)
         : srv_ctx_(new ServerContextType),
           next_state_(&ServerRpcContextUnaryImpl::invoker),
           request_method_(request_method),
@@ -281,11 +296,10 @@ class AsyncQpsServerTest final : public grpc::testing::Server {
     RequestType req_;
     ResponseType response_;
     bool (ServerRpcContextUnaryImpl::*next_state_)(bool);
-    std::function<void(ServerContextType *, RequestType *,
-                       grpc::ServerAsyncResponseWriter<ResponseType> *, void *)>
+    std::function<void(ServerContextType*, RequestType*,
+                       grpc::ServerAsyncResponseWriter<ResponseType>*, void*)>
         request_method_;
-    std::function<grpc::Status(const RequestType *, ResponseType *)>
-        invoke_method_;
+    std::function<grpc::Status(RequestType*, ResponseType*)> invoke_method_;
     grpc::ServerAsyncResponseWriter<ResponseType> response_writer_;
   };
 
@@ -293,11 +307,10 @@ class AsyncQpsServerTest final : public grpc::testing::Server {
    public:
     ServerRpcContextStreamingImpl(
         std::function<void(
-            ServerContextType *,
-            grpc::ServerAsyncReaderWriter<ResponseType, RequestType> *, void *)>
+            ServerContextType*,
+            grpc::ServerAsyncReaderWriter<ResponseType, RequestType>*, void*)>
             request_method,
-        std::function<grpc::Status(const RequestType *, ResponseType *)>
-            invoke_method)
+        std::function<grpc::Status(RequestType*, ResponseType*)> invoke_method)
         : srv_ctx_(new ServerContextType),
           next_state_(&ServerRpcContextStreamingImpl::request_done),
           request_method_(request_method),
@@ -361,11 +374,10 @@ class AsyncQpsServerTest final : public grpc::testing::Server {
     ResponseType response_;
     bool (ServerRpcContextStreamingImpl::*next_state_)(bool);
     std::function<void(
-        ServerContextType *,
-        grpc::ServerAsyncReaderWriter<ResponseType, RequestType> *, void *)>
+        ServerContextType*,
+        grpc::ServerAsyncReaderWriter<ResponseType, RequestType>*, void*)>
         request_method_;
-    std::function<grpc::Status(const RequestType *, ResponseType *)>
-        invoke_method_;
+    std::function<grpc::Status(RequestType*, ResponseType*)> invoke_method_;
     grpc::ServerAsyncReaderWriter<ResponseType, RequestType> stream_;
   };
 
@@ -373,12 +385,11 @@ class AsyncQpsServerTest final : public grpc::testing::Server {
       : public ServerRpcContext {
    public:
     ServerRpcContextStreamingFromClientImpl(
-        std::function<void(ServerContextType *,
-                           grpc::ServerAsyncReader<ResponseType, RequestType> *,
-                           void *)>
+        std::function<void(ServerContextType*,
+                           grpc::ServerAsyncReader<ResponseType, RequestType>*,
+                           void*)>
             request_method,
-        std::function<grpc::Status(const RequestType *, ResponseType *)>
-            invoke_method)
+        std::function<grpc::Status(RequestType*, ResponseType*)> invoke_method)
         : srv_ctx_(new ServerContextType),
           next_state_(&ServerRpcContextStreamingFromClientImpl::request_done),
           request_method_(request_method),
@@ -431,12 +442,11 @@ class AsyncQpsServerTest final : public grpc::testing::Server {
     RequestType req_;
     ResponseType response_;
     bool (ServerRpcContextStreamingFromClientImpl::*next_state_)(bool);
-    std::function<void(ServerContextType *,
-                       grpc::ServerAsyncReader<ResponseType, RequestType> *,
-                       void *)>
+    std::function<void(ServerContextType*,
+                       grpc::ServerAsyncReader<ResponseType, RequestType>*,
+                       void*)>
         request_method_;
-    std::function<grpc::Status(const RequestType *, ResponseType *)>
-        invoke_method_;
+    std::function<grpc::Status(RequestType*, ResponseType*)> invoke_method_;
     grpc::ServerAsyncReader<ResponseType, RequestType> stream_;
   };
 
@@ -444,11 +454,10 @@ class AsyncQpsServerTest final : public grpc::testing::Server {
       : public ServerRpcContext {
    public:
     ServerRpcContextStreamingFromServerImpl(
-        std::function<void(ServerContextType *, RequestType *,
-                           grpc::ServerAsyncWriter<ResponseType> *, void *)>
+        std::function<void(ServerContextType*, RequestType*,
+                           grpc::ServerAsyncWriter<ResponseType>*, void*)>
             request_method,
-        std::function<grpc::Status(const RequestType *, ResponseType *)>
-            invoke_method)
+        std::function<grpc::Status(RequestType*, ResponseType*)> invoke_method)
         : srv_ctx_(new ServerContextType),
           next_state_(&ServerRpcContextStreamingFromServerImpl::request_done),
           request_method_(request_method),
@@ -501,11 +510,10 @@ class AsyncQpsServerTest final : public grpc::testing::Server {
     RequestType req_;
     ResponseType response_;
     bool (ServerRpcContextStreamingFromServerImpl::*next_state_)(bool);
-    std::function<void(ServerContextType *, RequestType *,
-                       grpc::ServerAsyncWriter<ResponseType> *, void *)>
+    std::function<void(ServerContextType*, RequestType*,
+                       grpc::ServerAsyncWriter<ResponseType>*, void*)>
         request_method_;
-    std::function<grpc::Status(const RequestType *, ResponseType *)>
-        invoke_method_;
+    std::function<grpc::Status(RequestType*, ResponseType*)> invoke_method_;
     grpc::ServerAsyncWriter<ResponseType> stream_;
   };
 
@@ -525,30 +533,34 @@ class AsyncQpsServerTest final : public grpc::testing::Server {
   std::vector<std::unique_ptr<PerThreadShutdownState>> shutdown_state_;
 };
 
-static void RegisterBenchmarkService(ServerBuilder *builder,
-                                     BenchmarkService::AsyncService *service) {
+static void RegisterBenchmarkService(ServerBuilder* builder,
+                                     BenchmarkService::AsyncService* service) {
   builder->RegisterService(service);
 }
-static void RegisterGenericService(ServerBuilder *builder,
-                                   grpc::AsyncGenericService *service) {
+static void RegisterGenericService(ServerBuilder* builder,
+                                   grpc::AsyncGenericService* service) {
   builder->RegisterAsyncGenericService(service);
 }
 
-static Status ProcessSimpleRPC(const PayloadConfig &,
-                               const SimpleRequest *request,
-                               SimpleResponse *response) {
+static Status ProcessSimpleRPC(const PayloadConfig&, SimpleRequest* request,
+                               SimpleResponse* response) {
   if (request->response_size() > 0) {
     if (!Server::SetPayload(request->response_type(), request->response_size(),
                             response->mutable_payload())) {
       return Status(grpc::StatusCode::INTERNAL, "Error creating payload.");
     }
   }
+  // We are done using the request. Clear it to reduce working memory.
+  // This proves to reduce cache misses in large message size cases.
+  request->Clear();
   return Status::OK;
 }
 
-static Status ProcessGenericRPC(const PayloadConfig &payload_config,
-                                const ByteBuffer *request,
-                                ByteBuffer *response) {
+static Status ProcessGenericRPC(const PayloadConfig& payload_config,
+                                ByteBuffer* request, ByteBuffer* response) {
+  // We are done using the request. Clear it to reduce working memory.
+  // This proves to reduce cache misses in large message size cases.
+  request->Clear();
   int resp_size = payload_config.bytebuf_params().resp_size();
   std::unique_ptr<char[]> buf(new char[resp_size]);
   Slice slice(buf.get(), resp_size);
@@ -556,7 +568,7 @@ static Status ProcessGenericRPC(const PayloadConfig &payload_config,
   return Status::OK;
 }
 
-std::unique_ptr<Server> CreateAsyncServer(const ServerConfig &config) {
+std::unique_ptr<Server> CreateAsyncServer(const ServerConfig& config) {
   return std::unique_ptr<Server>(
       new AsyncQpsServerTest<SimpleRequest, SimpleResponse,
                              BenchmarkService::AsyncService,
@@ -569,7 +581,7 @@ std::unique_ptr<Server> CreateAsyncServer(const ServerConfig &config) {
           &BenchmarkService::AsyncService::RequestStreamingBothWays,
           ProcessSimpleRPC));
 }
-std::unique_ptr<Server> CreateAsyncGenericServer(const ServerConfig &config) {
+std::unique_ptr<Server> CreateAsyncGenericServer(const ServerConfig& config) {
   return std::unique_ptr<Server>(
       new AsyncQpsServerTest<ByteBuffer, ByteBuffer, grpc::AsyncGenericService,
                              grpc::GenericServerContext>(
diff --git a/test/cpp/qps/server_sync.cc b/test/cpp/qps/server_sync.cc
index 9954e2c0bf..ea89a30e2e 100644
--- a/test/cpp/qps/server_sync.cc
+++ b/test/cpp/qps/server_sync.cc
@@ -156,12 +156,15 @@ class SynchronousServer final : public grpc::testing::Server {
   explicit SynchronousServer(const ServerConfig& config) : Server(config) {
     ServerBuilder builder;
 
-    char* server_address = NULL;
-
-    gpr_join_host_port(&server_address, "::", port());
-    builder.AddListeningPort(server_address,
-                             Server::CreateServerCredentials(config));
-    gpr_free(server_address);
+    auto port_num = port();
+    // Negative port number means inproc server, so no listen port needed
+    if (port_num >= 0) {
+      char* server_address = nullptr;
+      gpr_join_host_port(&server_address, "::", port_num);
+      builder.AddListeningPort(server_address,
+                               Server::CreateServerCredentials(config));
+      gpr_free(server_address);
+    }
 
     ApplyConfigToBuilder(config, &builder);
 
@@ -170,6 +173,11 @@ class SynchronousServer final : public grpc::testing::Server {
     impl_ = builder.BuildAndStart();
   }
 
+  std::shared_ptr<Channel> InProcessChannel(
+      const ChannelArguments& args) override {
+    return impl_->InProcessChannel(args);
+  }
+
  private:
   BenchmarkServiceImpl service_;
   std::unique_ptr<grpc::Server> impl_;
diff --git a/test/cpp/qps/worker.cc b/test/cpp/qps/worker.cc
index 27010b7315..38287464d9 100644
--- a/test/cpp/qps/worker.cc
+++ b/test/cpp/qps/worker.cc
@@ -20,6 +20,7 @@
 
 #include <chrono>
 #include <thread>
+#include <vector>
 
 #include <gflags/gflags.h>
 #include <grpc/grpc.h>
@@ -41,6 +42,8 @@ static void sigint_handler(int x) { got_sigint = true; }
 namespace grpc {
 namespace testing {
 
+std::vector<grpc::testing::Server*>* g_inproc_servers = nullptr;
+
 static void RunServer() {
   QpsWorker worker(FLAGS_driver_port, FLAGS_server_port, FLAGS_credential_type);
 
diff --git a/test/cpp/test/server_context_test_spouse_test.cc b/test/cpp/test/server_context_test_spouse_test.cc
index c1ddb0019b..d1dc9d7cac 100644
--- a/test/cpp/test/server_context_test_spouse_test.cc
+++ b/test/cpp/test/server_context_test_spouse_test.cc
@@ -87,7 +87,7 @@ TEST(ServerContextTestSpouseTest, TrailingMetadata) {
   ASSERT_EQ(metadata, spouse.GetTrailingMetadata());
 }
 
-}  // namespace
+}  // namespace testing
 }  // namespace grpc
 
 int main(int argc, char** argv) {
diff --git a/test/cpp/thread_manager/thread_manager_test.cc b/test/cpp/thread_manager/thread_manager_test.cc
index 85e58f466e..8282d46694 100644
--- a/test/cpp/thread_manager/thread_manager_test.cc
+++ b/test/cpp/thread_manager/thread_manager_test.cc
@@ -37,8 +37,8 @@ class ThreadManagerTest final : public grpc::ThreadManager {
         num_poll_for_work_(0),
         num_work_found_(0) {}
 
-  grpc::ThreadManager::WorkStatus PollForWork(void **tag, bool *ok) override;
-  void DoWork(void *tag, bool ok) override;
+  grpc::ThreadManager::WorkStatus PollForWork(void** tag, bool* ok) override;
+  void DoWork(void* tag, bool ok) override;
   void PerformTest();
 
  private:
@@ -65,8 +65,8 @@ void ThreadManagerTest::SleepForMs(int duration_ms) {
   gpr_sleep_until(sleep_time);
 }
 
-grpc::ThreadManager::WorkStatus ThreadManagerTest::PollForWork(void **tag,
-                                                               bool *ok) {
+grpc::ThreadManager::WorkStatus ThreadManagerTest::PollForWork(void** tag,
+                                                               bool* ok) {
   int call_num = gpr_atm_no_barrier_fetch_add(&num_poll_for_work_, 1);
 
   if (call_num >= kMaxNumPollForWork) {
@@ -89,7 +89,7 @@ grpc::ThreadManager::WorkStatus ThreadManagerTest::PollForWork(void **tag,
   }
 }
 
-void ThreadManagerTest::DoWork(void *tag, bool ok) {
+void ThreadManagerTest::DoWork(void* tag, bool ok) {
   gpr_atm_no_barrier_fetch_add(&num_do_work_, 1);
   SleepForMs(kDoWorkDurationMsec);  // Simulate doing work by sleeping
 }
@@ -110,8 +110,8 @@ void ThreadManagerTest::PerformTest() {
 }
 }  // namespace grpc
 
-int main(int argc, char **argv) {
-  std::srand(std::time(NULL));
+int main(int argc, char** argv) {
+  std::srand(std::time(nullptr));
 
   grpc::testing::InitTest(&argc, &argv, true);
   grpc::ThreadManagerTest test_rpc_manager;
diff --git a/test/cpp/util/create_test_channel.cc b/test/cpp/util/create_test_channel.cc
index 34b6d60d01..4d047473b9 100644
--- a/test/cpp/util/create_test_channel.cc
+++ b/test/cpp/util/create_test_channel.cc
@@ -74,7 +74,7 @@ std::shared_ptr<Channel> CreateTestChannel(
   ChannelArguments channel_args(args);
   std::shared_ptr<ChannelCredentials> channel_creds;
   if (cred_type.empty()) {
-    return CreateChannel(server, InsecureChannelCredentials());
+    return CreateCustomChannel(server, InsecureChannelCredentials(), args);
   } else if (cred_type == testing::kTlsCredentialsType) {  // cred_type == "ssl"
     if (use_prod_roots) {
       gpr_once_init(&g_once_init_add_prod_ssl_provider, &AddProdSslType);
@@ -101,7 +101,7 @@ std::shared_ptr<Channel> CreateTestChannel(
         cred_type, &channel_args);
     GPR_ASSERT(channel_creds != nullptr);
 
-    return CreateChannel(server, channel_creds);
+    return CreateCustomChannel(server, channel_creds, args);
   }
 }
 
diff --git a/test/cpp/util/error_details_test.cc b/test/cpp/util/error_details_test.cc
index 69a6876a3f..16a00fb201 100644
--- a/test/cpp/util/error_details_test.cc
+++ b/test/cpp/util/error_details_test.cc
@@ -82,7 +82,7 @@ TEST(SetTest, NullInput) {
 
 TEST(SetTest, OutOfScopeErrorCode) {
   google::rpc::Status expected;
-  expected.set_code(20);  // Out of scope (DATA_LOSS is 15).
+  expected.set_code(17);  // Out of scope (UNAUTHENTICATED is 16).
   expected.set_message("I am an error message");
   testing::EchoRequest expected_details;
   expected_details.set_message(grpc::string(100, '\0'));
@@ -96,6 +96,24 @@ TEST(SetTest, OutOfScopeErrorCode) {
   EXPECT_EQ(expected.SerializeAsString(), to.error_details());
 }
 
+TEST(SetTest, ValidScopeErrorCode) {
+  for (int c = StatusCode::OK; c <= StatusCode::UNAUTHENTICATED; c++) {
+    google::rpc::Status expected;
+    expected.set_code(c);
+    expected.set_message("I am an error message");
+    testing::EchoRequest expected_details;
+    expected_details.set_message(grpc::string(100, '\0'));
+    expected.add_details()->PackFrom(expected_details);
+
+    Status to;
+    Status s = SetErrorDetails(expected, &to);
+    EXPECT_TRUE(s.ok());
+    EXPECT_EQ(c, to.error_code());
+    EXPECT_EQ(expected.message(), to.error_message());
+    EXPECT_EQ(expected.SerializeAsString(), to.error_details());
+  }
+}
+
 }  // namespace
 }  // namespace grpc
 
diff --git a/test/cpp/util/grpc_tool.cc b/test/cpp/util/grpc_tool.cc
index cd6084ac6d..a6d08cd83c 100644
--- a/test/cpp/util/grpc_tool.cc
+++ b/test/cpp/util/grpc_tool.cc
@@ -230,7 +230,7 @@ const Command* FindCommand(const grpc::string& name) {
       return &ops[i];
     }
   }
-  return NULL;
+  return nullptr;
 }
 }  // namespace
 
@@ -245,13 +245,13 @@ int GrpcToolMainLib(int argc, const char** argv, const CliCredentials& cred,
   argv += 2;
 
   const Command* cmd = FindCommand(command);
-  if (cmd != NULL) {
+  if (cmd != nullptr) {
     GrpcTool grpc_tool;
     if (argc < cmd->min_args || argc > cmd->max_args) {
       // Force the command to print its usage message
       fprintf(stderr, "\nWrong number of arguments for %s\n", command.c_str());
       grpc_tool.SetPrintCommandMode(1);
-      return cmd->function(&grpc_tool, -1, NULL, cred, callback);
+      return cmd->function(&grpc_tool, -1, nullptr, cred, callback);
     }
     const bool ok = cmd->function(&grpc_tool, argc, argv, cred, callback);
     return ok ? 0 : 1;
@@ -281,11 +281,11 @@ bool GrpcTool::Help(int argc, const char** argv, const CliCredentials& cred,
     Usage("");
   } else {
     const Command* cmd = FindCommand(argv[0]);
-    if (cmd == NULL) {
+    if (cmd == nullptr) {
       Usage("Unknown command '" + grpc::string(argv[0]) + "'");
     }
     SetPrintCommandMode(0);
-    cmd->function(this, -1, NULL, cred, callback);
+    cmd->function(this, -1, nullptr, cred, callback);
   }
   return true;
 }
diff --git a/test/cpp/util/grpc_tool.h b/test/cpp/util/grpc_tool.h
index 076ce530d9..a10422f882 100644
--- a/test/cpp/util/grpc_tool.h
+++ b/test/cpp/util/grpc_tool.h
@@ -28,9 +28,9 @@
 namespace grpc {
 namespace testing {
 
-typedef std::function<bool(const grpc::string &)> GrpcToolOutputCallback;
+typedef std::function<bool(const grpc::string&)> GrpcToolOutputCallback;
 
-int GrpcToolMainLib(int argc, const char **argv, const CliCredentials &cred,
+int GrpcToolMainLib(int argc, const char** argv, const CliCredentials& cred,
                     GrpcToolOutputCallback callback);
 
 }  // namespace testing
diff --git a/test/cpp/util/grpc_tool_test.cc b/test/cpp/util/grpc_tool_test.cc
index d0b3d7b81b..1c07b2a8ef 100644
--- a/test/cpp/util/grpc_tool_test.cc
+++ b/test/cpp/util/grpc_tool_test.cc
@@ -395,7 +395,7 @@ TEST_F(GrpcToolTest, CallCommand) {
                                    std::bind(PrintStream, &output_stream,
                                              std::placeholders::_1)));
   // Expected output: "message: \"Hello\""
-  EXPECT_TRUE(NULL !=
+  EXPECT_TRUE(nullptr !=
               strstr(output_stream.str().c_str(), "message: \"Hello\""));
   ShutdownServer();
 }
@@ -421,9 +421,9 @@ TEST_F(GrpcToolTest, CallCommandBatch) {
 
   // Expected output: "message: "Hello0"\nmessage: "Hello1"\nmessage:
   // "Hello2"\n"
-  EXPECT_TRUE(NULL != strstr(output_stream.str().c_str(),
-                             "message: \"Hello0\"\nmessage: "
-                             "\"Hello1\"\nmessage: \"Hello2\"\n"));
+  EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
+                                "message: \"Hello0\"\nmessage: "
+                                "\"Hello1\"\nmessage: \"Hello2\"\n"));
   std::cin.rdbuf(orig);
   ShutdownServer();
 }
@@ -448,8 +448,8 @@ TEST_F(GrpcToolTest, CallCommandBatchWithBadRequest) {
   FLAGS_batch = false;
 
   // Expected output: "message: "Hello0"\nmessage: "Hello2"\n"
-  EXPECT_TRUE(NULL != strstr(output_stream.str().c_str(),
-                             "message: \"Hello0\"\nmessage: \"Hello2\"\n"));
+  EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
+                                "message: \"Hello0\"\nmessage: \"Hello2\"\n"));
   std::cin.rdbuf(orig);
   ShutdownServer();
 }
@@ -473,8 +473,8 @@ TEST_F(GrpcToolTest, CallCommandRequestStream) {
                                              std::placeholders::_1)));
 
   // Expected output: "message: \"Hello0Hello1Hello2\""
-  EXPECT_TRUE(NULL != strstr(output_stream.str().c_str(),
-                             "message: \"Hello0Hello1Hello2\""));
+  EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
+                                "message: \"Hello0Hello1Hello2\""));
   std::cin.rdbuf(orig);
   ShutdownServer();
 }
@@ -498,7 +498,7 @@ TEST_F(GrpcToolTest, CallCommandRequestStreamWithBadRequest) {
                                              std::placeholders::_1)));
 
   // Expected output: "message: \"Hello0Hello2\""
-  EXPECT_TRUE(NULL !=
+  EXPECT_TRUE(nullptr !=
               strstr(output_stream.str().c_str(), "message: \"Hello0Hello2\""));
   std::cin.rdbuf(orig);
   ShutdownServer();
@@ -521,8 +521,8 @@ TEST_F(GrpcToolTest, CallCommandResponseStream) {
   for (int i = 0; i < kServerDefaultResponseStreamsToSend; i++) {
     grpc::string expected_response_text =
         "message: \"Hello" + grpc::to_string(i) + "\"\n";
-    EXPECT_TRUE(NULL != strstr(output_stream.str().c_str(),
-                               expected_response_text.c_str()));
+    EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
+                                  expected_response_text.c_str()));
   }
 
   ShutdownServer();
@@ -547,9 +547,9 @@ TEST_F(GrpcToolTest, CallCommandBidiStream) {
 
   // Expected output: "message: \"Hello0\"\nmessage: \"Hello1\"\nmessage:
   // \"Hello2\"\n\n"
-  EXPECT_TRUE(NULL != strstr(output_stream.str().c_str(),
-                             "message: \"Hello0\"\nmessage: "
-                             "\"Hello1\"\nmessage: \"Hello2\"\n"));
+  EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
+                                "message: \"Hello0\"\nmessage: "
+                                "\"Hello1\"\nmessage: \"Hello2\"\n"));
   std::cin.rdbuf(orig);
   ShutdownServer();
 }
@@ -573,8 +573,8 @@ TEST_F(GrpcToolTest, CallCommandBidiStreamWithBadRequest) {
 
   // Expected output: "message: \"Hello0\"\nmessage: \"Hello1\"\nmessage:
   // \"Hello2\"\n\n"
-  EXPECT_TRUE(NULL != strstr(output_stream.str().c_str(),
-                             "message: \"Hello0\"\nmessage: \"Hello2\"\n"));
+  EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
+                                "message: \"Hello0\"\nmessage: \"Hello2\"\n"));
   std::cin.rdbuf(orig);
 
   ShutdownServer();
diff --git a/test/cpp/util/proto_reflection_descriptor_database.cc b/test/cpp/util/proto_reflection_descriptor_database.cc
index 184828c7b6..0f77934672 100644
--- a/test/cpp/util/proto_reflection_descriptor_database.cc
+++ b/test/cpp/util/proto_reflection_descriptor_database.cc
@@ -22,11 +22,11 @@
 
 #include <grpc/support/log.h>
 
+using grpc::reflection::v1alpha::ErrorResponse;
+using grpc::reflection::v1alpha::ListServiceResponse;
 using grpc::reflection::v1alpha::ServerReflection;
 using grpc::reflection::v1alpha::ServerReflectionRequest;
 using grpc::reflection::v1alpha::ServerReflectionResponse;
-using grpc::reflection::v1alpha::ListServiceResponse;
-using grpc::reflection::v1alpha::ErrorResponse;
 
 namespace grpc {
 
diff --git a/test/cpp/util/service_describer.h b/test/cpp/util/service_describer.h
index b7a8c9207f..b7ab7578b4 100644
--- a/test/cpp/util/service_describer.h
+++ b/test/cpp/util/service_describer.h
@@ -36,7 +36,7 @@ grpc::string SummarizeService(const grpc::protobuf::ServiceDescriptor* service);
 
 grpc::string SummarizeMethod(const grpc::protobuf::MethodDescriptor* method);
 
-}  // namespase testing
+}  // namespace testing
 }  // namespace grpc
 
 #endif  // GRPC_TEST_CPP_UTIL_SERVICE_DESCRIBER_H
diff --git a/test/cpp/util/test_config_cc.cc b/test/cpp/util/test_config_cc.cc
index f7e034253e..e4b6886335 100644
--- a/test/cpp/util/test_config_cc.cc
+++ b/test/cpp/util/test_config_cc.cc
@@ -16,8 +16,8 @@
  *
  */
 
-#include "test/cpp/util/test_config.h"
 #include <gflags/gflags.h>
+#include "test/cpp/util/test_config.h"
 
 // In some distros, gflags is in the namespace google, and in some others,
 // in gflags. This hack is enabling us to find both.
diff --git a/test/distrib/node/distrib_test.js b/test/distrib/node/distrib_test.js
deleted file mode 100755
index 62191f0ff2..0000000000
--- a/test/distrib/node/distrib_test.js
+++ /dev/null
@@ -1,42 +0,0 @@
-#!/usr/bin/env node
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-var grpc = require('grpc');
-
-function identity(x) {
-  return x;
-}
-
-var Client = grpc.makeGenericClientConstructor({
-  'echo' : {
-    path: '/buffer/echo',
-    requestStream: false,
-    responseStream: false,
-    requestSerialize: identity,
-    requestDeserialize: identity,
-    responseSerialize: identity,
-    responseDeserialize: identity
-  }
-});
-
-var client = new Client("localhost:1000", grpc.credentials.createInsecure());
-
-client.$channel.close();
-
-console.log("Success!");
diff --git a/test/distrib/node/package.json b/test/distrib/node/package.json
deleted file mode 100644
index b02a796c97..0000000000
--- a/test/distrib/node/package.json
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-  "name": "grpc-distrib-test",
-  "version": "0.0.1",
-  "dependencies": {
-    "grpc": "*"
-  }
-}
diff --git a/test/distrib/node/run_distrib_test.sh b/test/distrib/node/run_distrib_test.sh
deleted file mode 100755
index a806f84f7c..0000000000
--- a/test/distrib/node/run_distrib_test.sh
+++ /dev/null
@@ -1,48 +0,0 @@
-#!/bin/bash
-# Copyright 2015 gRPC authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-function finish() {
-  rv=$?
-  kill $STATIC_PID || true
-  curl "localhost:32767/drop/$STATIC_PORT" || true
-  exit $rv
-}
-
-trap finish EXIT
-
-NODE_VERSION=$1
-source ~/.nvm/nvm.sh
-
-cd $(dirname $0)
-
-nvm install $NODE_VERSION
-set -ex
-
-npm install -g node-static
-
-STATIC_SERVER=127.0.0.1
-# If port_server is running, get port from that. Otherwise, assume we're in
-# docker and use 12345
-STATIC_PORT=$(curl 'localhost:32767/get' || echo '12345')
-
-# Serves the input_artifacts directory statically at localhost:
-static "$EXTERNAL_GIT_ROOT/input_artifacts" -a $STATIC_SERVER -p $STATIC_PORT &
-STATIC_PID=$!
-
-STATIC_URL="http://$STATIC_SERVER:$STATIC_PORT/"
-
-npm install --unsafe-perm $STATIC_URL/grpc.tgz --grpc_node_binary_host_mirror=$STATIC_URL
-
-./distrib_test.js