Merge with master

10 files changed, 285 insertions, 262 deletions

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 446e5ef9d6..aabe8dea3c 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,21 +116,21 @@ 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);
   } 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);
   grpc_server_shutdown_and_notify(f->servers[i], f->shutdown_cq, tag(10000));
@@ -145,10 +146,10 @@ 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);
@@ -169,19 +170,23 @@ 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->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(NULL);
   f->shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
   for (i = 0; i < num_servers; i++) {
@@ -194,7 +199,7 @@ static servers_fixture *setup_servers(const char *server_host,
   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++) {
@@ -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++) {
@@ -418,15 +424,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);
   }
@@ -457,29 +464,30 @@ static grpc_call **perform_multirequest(servers_fixture *f,
   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,
+  servers_hostports_str = gpr_strjoin_sep((const char**)f->servers_hostports,
                                           f->num_servers, ",", NULL);
   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;
 
@@ -501,25 +509,27 @@ 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,
+  servers_hostports_str = gpr_strjoin_sep((const char**)f->servers_hostports,
                                           f->num_servers, ",", NULL);
   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;
@@ -532,15 +542,16 @@ 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);
 
@@ -580,13 +591,13 @@ 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);
@@ -609,7 +620,7 @@ static void test_pending_calls(size_t concurrent_calls) {
 }
 
 static void test_get_channel_info() {
-  grpc_channel *channel =
+  grpc_channel* channel =
       grpc_insecure_channel_create("ipv4:127.0.0.1:1234", NULL, NULL);
   // Ensures that resolver returns.
   grpc_channel_check_connectivity_state(channel, true /* try_to_connect */);
@@ -618,7 +629,7 @@ 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 = NULL;
   channel_info.lb_policy_name = &lb_policy_name;
   grpc_channel_get_info(channel, &channel_info);
   GPR_ASSERT(lb_policy_name != NULL);
@@ -626,7 +637,7 @@ static void test_get_channel_info() {
   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);
@@ -634,12 +645,13 @@ static void test_get_channel_info() {
   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);
+  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(NULL, &arg, 1);
   channel = grpc_insecure_channel_create("ipv4:127.0.0.1:1234", args, NULL);
   {
-    exec_ctx = GRPC_EXEC_CTX_INIT;
+    ExecCtx _local_exec_ctx;
     grpc_channel_args_destroy(args);
     grpc_exec_ctx_finish();
   }
@@ -654,8 +666,8 @@ static void test_get_channel_info() {
   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));
@@ -871,9 +890,9 @@ static void dump_array(const char *desc, const int *data, const size_t count) {
   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) {
-  exec_ctx = GRPC_EXEC_CTX_INIT;
-  test_spec *spec;
+int main(int argc, char** argv) {
+  ExecCtx _local_exec_ctx;
+  test_spec* spec;
   size_t i;
   const size_t NUM_ITERS = 10;
   const size_t NUM_SERVERS = 4;
diff --git a/test/core/client_channel/parse_address_test.c b/test/core/client_channel/parse_address_test.cc
index 6e1a69a581..17725ba5ff 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) {
-  exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_uri *uri = grpc_uri_parse(uri_text, 0);
+static void test_grpc_parse_unix(const char* uri_text, const char* pathname) {
+  ExecCtx _local_exec_ctx;
+  grpc_uri* uri = grpc_uri_parse(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,19 +48,19 @@ 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) {
-  exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_uri *uri = grpc_uri_parse(uri_text, 0);
+  ExecCtx _local_exec_ctx;
+  grpc_uri* uri = grpc_uri_parse(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)));
@@ -71,15 +71,15 @@ static void test_grpc_parse_ipv4(const char *uri_text, const char *host,
   grpc_exec_ctx_finish();
 }
 
-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) {
-  exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_uri *uri = grpc_uri_parse(uri_text, 0);
+  ExecCtx _local_exec_ctx;
+  grpc_uri* uri = grpc_uri_parse(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)));
@@ -91,7 +91,7 @@ static void test_grpc_parse_ipv6(const char *uri_text, const char *host,
   grpc_exec_ctx_finish();
 }
 
-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 3715fbdc02..e2823a4501 100644
--- a/test/core/client_channel/resolvers/dns_resolver_connectivity_test.c
+++ b/test/core/client_channel/resolvers/dns_resolver_connectivity_test.cc
@@ -33,37 +33,38 @@
 
 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(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(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(on_done, error);
 }
 
-static grpc_ares_request *my_dns_lookup_ares(
-    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(
+    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);
@@ -77,33 +78,33 @@ static grpc_ares_request *my_dns_lookup_ares(
   return NULL;
 }
 
-static grpc_resolver *create_resolver(const char *name) {
-  grpc_resolver_factory *factory = grpc_resolver_factory_lookup("dns");
-  grpc_uri *uri = grpc_uri_parse(name, 0);
+static grpc_resolver* create_resolver(const char* name) {
+  grpc_resolver_factory* factory = grpc_resolver_factory_lookup("dns");
+  grpc_uri* uri = grpc_uri_parse(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(factory, &args);
   grpc_resolver_factory_unref(factory);
   grpc_uri_destroy(uri);
   return resolver;
 }
 
-static void on_done(void *ev, grpc_error *error) {
-  gpr_event_set(ev, (void *)1);
+static void on_done(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--;
 
-    exec_ctx = GRPC_EXEC_CTX_INIT;
+    ExecCtx _local_exec_ctx;
     grpc_timer_check(NULL);
     grpc_exec_ctx_finish();
   }
@@ -111,22 +112,22 @@ static bool wait_loop(int deadline_seconds, gpr_event *ev) {
 }
 
 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(void *arg,
-                                              grpc_error *error_unused) {
-  next_args *a = arg;
+static void call_resolver_next_now_lock_taken(void* arg,
+                                              grpc_error* error_unused) {
+  next_args* a = static_cast<next_args*>(arg);
   grpc_resolver_next_locked(a->resolver, a->result, a->on_complete);
   gpr_free(a);
 }
 
-static void call_resolver_next_after_locking(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_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;
@@ -136,7 +137,7 @@ static void call_resolver_next_after_locking(grpc_resolver *resolver,
       GRPC_ERROR_NONE);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
 
   grpc_init();
@@ -144,10 +145,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;
 
-  exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_resolver *resolver = create_resolver("dns:test");
+  ExecCtx _local_exec_ctx;
+  grpc_resolver* resolver = create_resolver("dns:test");
   gpr_event ev1;
   gpr_event_init(&ev1);
   call_resolver_next_after_locking(
diff --git a/test/core/client_channel/resolvers/dns_resolver_test.c b/test/core/client_channel/resolvers/dns_resolver_test.cc
index 3717d0efd7..8b40360263 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) {
-  exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_uri *uri = grpc_uri_parse(string, 0);
+static void test_succeeds(grpc_resolver_factory* factory, const char* string) {
+  ExecCtx _local_exec_ctx;
+  grpc_uri* uri = grpc_uri_parse(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);
@@ -45,11 +45,11 @@ static void test_succeeds(grpc_resolver_factory *factory, const char *string) {
   grpc_exec_ctx_finish();
 }
 
-static void test_fails(grpc_resolver_factory *factory, const char *string) {
-  exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_uri *uri = grpc_uri_parse(string, 0);
+static void test_fails(grpc_resolver_factory* factory, const char* string) {
+  ExecCtx _local_exec_ctx;
+  grpc_uri* uri = grpc_uri_parse(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);
@@ -62,8 +62,8 @@ static void test_fails(grpc_resolver_factory *factory, const char *string) {
   grpc_exec_ctx_finish();
 }
 
-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();
 
@@ -82,7 +82,7 @@ int main(int argc, char **argv) {
 
   grpc_resolver_factory_unref(dns);
   {
-    exec_ctx = GRPC_EXEC_CTX_INIT;
+    ExecCtx _local_exec_ctx;
     GRPC_COMBINER_UNREF(g_combiner, "test");
     grpc_exec_ctx_finish();
   }
diff --git a/test/core/client_channel/resolvers/fake_resolver_test.c b/test/core/client_channel/resolvers/fake_resolver_test.cc
index 8cc5fc6ce5..ec49558f87 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_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_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,49 +43,49 @@ 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(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(void *arg, grpc_error *error) {
-  on_resolution_arg *res = arg;
+void on_resolution_cb(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(res->resolver_result);
   grpc_channel_args_destroy(res->expected_resolver_result);
-  gpr_event_set(&res->ev, (void *)1);
+  gpr_event_set(&res->ev, (void*)1);
 }
 
 static void test_fake_resolver() {
-  exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_combiner *combiner = grpc_combiner_create();
+  ExecCtx _local_exec_ctx;
+  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 = build_fake_resolver(combiner, response_generator);
+  grpc_resolver* resolver = build_fake_resolver(combiner, response_generator);
   GPR_ASSERT(resolver != NULL);
 
   // Setup expectations.
-  grpc_uri *uris[] = {grpc_uri_parse("ipv4:10.2.1.1:1234", true),
+  grpc_uri* uris[] = {grpc_uri_parse("ipv4:10.2.1.1:1234", true),
                       grpc_uri_parse("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, NULL);
   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);
@@ -93,14 +93,14 @@ static void test_fake_resolver() {
   }
   const grpc_arg addresses_arg =
       grpc_lb_addresses_create_channel_arg(addresses);
-  grpc_channel_args *results =
+  grpc_channel_args* results =
       grpc_channel_args_copy_and_add(NULL, &addresses_arg, 1);
   grpc_lb_addresses_destroy(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
@@ -114,10 +114,10 @@ static void test_fake_resolver() {
                             grpc_timeout_seconds_to_deadline(5)) != NULL);
 
   // Setup update.
-  grpc_uri *uris_update[] = {grpc_uri_parse("ipv4:192.168.1.0:31416", true)};
-  char *balancer_names_update[] = {"name3"};
+  grpc_uri* uris_update[] = {grpc_uri_parse("ipv4:192.168.1.0:31416", true)};
+  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, NULL);
   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],
@@ -127,7 +127,7 @@ static void test_fake_resolver() {
 
   grpc_arg addresses_update_arg =
       grpc_lb_addresses_create_channel_arg(addresses_update);
-  grpc_channel_args *results_update =
+  grpc_channel_args* results_update =
       grpc_channel_args_copy_and_add(NULL, &addresses_update_arg, 1);
   grpc_lb_addresses_destroy(addresses_update);
 
@@ -164,7 +164,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 e69c68141b..dbc8a965d5 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(void *arg, grpc_error *error) {
-  on_resolution_arg *res = arg;
+void on_resolution_cb(void* arg, grpc_error* error) {
+  on_resolution_arg* res = static_cast<on_resolution_arg*>(arg);
   grpc_channel_args_destroy(res->resolver_result);
 }
 
-static void test_succeeds(grpc_resolver_factory *factory, const char *string) {
-  exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_uri *uri = grpc_uri_parse(string, 0);
+static void test_succeeds(grpc_resolver_factory* factory, const char* string) {
+  ExecCtx _local_exec_ctx;
+  grpc_uri* uri = grpc_uri_parse(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);
@@ -57,7 +57,7 @@ static void test_succeeds(grpc_resolver_factory *factory, const char *string) {
   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(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) {
-  exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_uri *uri = grpc_uri_parse(string, 0);
+static void test_fails(grpc_resolver_factory* factory, const char* string) {
+  ExecCtx _local_exec_ctx;
+  grpc_uri* uri = grpc_uri_parse(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);
@@ -84,7 +84,7 @@ static void test_fails(grpc_resolver_factory *factory, const char *string) {
   grpc_exec_ctx_finish();
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_resolver_factory *ipv4, *ipv6;
   grpc_test_init(argc, argv);
   grpc_init();
@@ -112,7 +112,7 @@ int main(int argc, char **argv) {
   grpc_resolver_factory_unref(ipv6);
 
   {
-    exec_ctx = GRPC_EXEC_CTX_INIT;
+    ExecCtx _local_exec_ctx;
     GRPC_COMBINER_UNREF(g_combiner, "test");
     grpc_exec_ctx_finish();
   }
diff --git a/test/core/client_channel/uri_fuzzer_test.c b/test/core/client_channel/uri_fuzzer_test.cc
index 2d91b92925..805becad18 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;
 
-  exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_uri *x;
+  ExecCtx _local_exec_ctx;
+  grpc_uri* x;
   if ((x = grpc_uri_parse(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 643035d9eb..591c642f4e 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) {
-  exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_uri *uri = grpc_uri_parse(uri_text, 0);
+static void test_succeeds(const char* uri_text, const char* scheme,
+                          const char* authority, const char* path,
+                          const char* query, const char* fragment) {
+  ExecCtx _local_exec_ctx;
+  grpc_uri* uri = grpc_uri_parse(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) {
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+static void test_fails(const char* uri_text) {
+  ExecCtx _local_exec_ctx;
   GPR_ASSERT(NULL == grpc_uri_parse(uri_text, 0));
   grpc_exec_ctx_finish();
 }
 
 static void test_query_parts() {
   {
-    exec_ctx = GRPC_EXEC_CTX_INIT;
-    const char *uri_text = "http://foo/path?a&b=B&c=&#frag";
-    grpc_uri *uri = grpc_uri_parse(uri_text, 0);
+    ExecCtx _local_exec_ctx;
+    const char* uri_text = "http://foo/path?a&b=B&c=&#frag";
+    grpc_uri* uri = grpc_uri_parse(uri_text, 0);
     GPR_ASSERT(uri);
 
     GPR_ASSERT(0 == strcmp("http", uri->scheme));
@@ -82,9 +82,9 @@ static void test_query_parts() {
   }
   {
     /* test the current behavior of multiple query part values */
-    exec_ctx = GRPC_EXEC_CTX_INIT;
-    const char *uri_text = "http://auth/path?foo=bar=baz&foobar==";
-    grpc_uri *uri = grpc_uri_parse(uri_text, 0);
+    ExecCtx _local_exec_ctx;
+    const char* uri_text = "http://auth/path?foo=bar=baz&foobar==";
+    grpc_uri* uri = grpc_uri_parse(uri_text, 0);
     GPR_ASSERT(uri);
 
     GPR_ASSERT(0 == strcmp("http", uri->scheme));
@@ -101,9 +101,9 @@ static void test_query_parts() {
   }
   {
     /* empty query */
-    exec_ctx = GRPC_EXEC_CTX_INIT;
-    const char *uri_text = "http://foo/path";
-    grpc_uri *uri = grpc_uri_parse(uri_text, 0);
+    ExecCtx _local_exec_ctx;
+    const char* uri_text = "http://foo/path";
+    grpc_uri* uri = grpc_uri_parse(uri_text, 0);
     GPR_ASSERT(uri);
 
     GPR_ASSERT(0 == strcmp("http", uri->scheme));
@@ -119,7 +119,7 @@ static void test_query_parts() {
   }
 }
 
-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", "", "");