Update clang-format to 5.0

8 files changed, 203 insertions, 202 deletions

diff --git a/test/core/client_channel/lb_policies_test.c b/test/core/client_channel/lb_policies_test.c
index 0e47d8f324..b557e26361 100644
--- a/test/core/client_channel/lb_policies_test.c
+++ b/test/core/client_channel/lb_policies_test.c
@@ -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 */
   /* indexed by the interation number, value is the client connectivity state */
-  grpc_connectivity_state *connectivity_states;
+  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,15 +84,15 @@ 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->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 = gpr_malloc(sizeof(int*) * num_iters);
+  spec->revive_at = 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);
@@ -102,7 +102,7 @@ static test_spec *test_spec_create(size_t num_iters, size_t num_servers) {
   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 +115,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 +145,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 +169,19 @@ 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 = gpr_malloc(sizeof(servers_fixture));
   size_t i;
 
   f->num_servers = num_servers;
-  f->server_calls = gpr_malloc(sizeof(grpc_call *) * num_servers);
+  f->server_calls = gpr_malloc(sizeof(grpc_call*) * num_servers);
   f->request_metadata_recv =
       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 = 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);
   for (i = 0; i < num_servers; i++) {
@@ -194,7 +194,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++) {
@@ -233,21 +233,21 @@ static request_sequences request_sequences_create(size_t 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;
@@ -258,7 +258,7 @@ static request_sequences perform_request(servers_fixture *f,
   s_valid = 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 +418,15 @@ 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 = gpr_malloc(sizeof(grpc_call*) * concurrent_calls);
   for (i = 0; i < f->num_servers; i++) {
     kill_server(f, i);
   }
@@ -457,12 +457,12 @@ 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 =
@@ -470,7 +470,7 @@ void run_spec(const test_spec *spec) {
   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);
 
@@ -501,14 +501,14 @@ 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);
 
@@ -532,10 +532,10 @@ 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;
@@ -580,11 +580,11 @@ 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);
+  servers_fixture* f;
+  test_spec* spec = test_spec_create(0, 4);
   rdata.call_details =
       gpr_malloc(sizeof(grpc_call_details) * spec->num_servers);
   f = setup_servers("127.0.0.1", &rdata, spec->num_servers);
@@ -609,7 +609,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 +618,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 +626,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 = "dummy_string";
   channel_info.service_config_json = &service_config_json;
   grpc_channel_get_info(channel, &channel_info);
   GPR_ASSERT(service_config_json == NULL);
@@ -636,7 +636,7 @@ static void test_get_channel_info() {
   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);
+  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);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -654,8 +654,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,15 +667,15 @@ 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 =
+  int* expected_connection_sequence =
       gpr_malloc(sizeof(int) * expected_seq_length);
   memcpy(expected_connection_sequence, sequences->connections,
          sizeof(int) * expected_seq_length);
@@ -713,9 +713,9 @@ 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;
 
@@ -765,9 +765,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];
@@ -797,9 +797,9 @@ 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;
 
@@ -854,9 +854,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 +871,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);
 
@@ -936,9 +936,9 @@ static void verify_rebirth_round_robin(const servers_fixture *f,
   }
 }
 
-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;
diff --git a/test/core/client_channel/parse_address_test.c b/test/core/client_channel/parse_address_test.c
index d011176869..5ad6c6d015 100644
--- a/test/core/client_channel/parse_address_test.c
+++ b/test/core/client_channel/parse_address_test.c
@@ -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,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) {
   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)));
@@ -71,15 +71,15 @@ 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)));
@@ -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/dns_resolver_connectivity_test.c b/test/core/client_channel/resolvers/dns_resolver_connectivity_test.c
index 4597285063..cefbaa81dc 100644
--- a/test/core/client_channel/resolvers/dns_resolver_connectivity_test.c
+++ b/test/core/client_channel/resolvers/dns_resolver_connectivity_test.c
@@ -33,16 +33,16 @@
 
 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);
@@ -57,14 +57,14 @@ 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) {
   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);
@@ -78,28 +78,28 @@ static grpc_ares_request *my_dns_lookup_ares(
   return NULL;
 }
 
-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(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;
@@ -113,34 +113,35 @@ 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(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 = 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 = 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 +149,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(
diff --git a/test/core/client_channel/resolvers/dns_resolver_test.c b/test/core/client_channel/resolvers/dns_resolver_test.c
index a14926f173..ef3c1b8216 100644
--- a/test/core/client_channel/resolvers/dns_resolver_test.c
+++ b/test/core/client_channel/resolvers/dns_resolver_test.c
@@ -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);
@@ -45,11 +45,11 @@ static void test_succeeds(grpc_resolver_factory *factory, const char *string) {
   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);
@@ -62,8 +62,8 @@ static void test_fails(grpc_resolver_factory *factory, const char *string) {
   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.c
index 9b0854d6d8..094cd7259d 100644
--- a/test/core/client_channel/resolvers/fake_resolver_test.c
+++ b/test/core/client_channel/resolvers/fake_resolver_test.c
@@ -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,50 +43,50 @@ 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 = 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);
 
   // 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"};
+  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);
@@ -94,14 +94,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(&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
@@ -115,11 +115,11 @@ static void test_fake_resolver() {
                             grpc_timeout_seconds_to_deadline(5)) != NULL);
 
   // 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"};
+  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],
@@ -129,7 +129,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(&exec_ctx, addresses_update);
 
@@ -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.c
index 8b88619164..99ba84c1ea 100644
--- a/test/core/client_channel/resolvers/sockaddr_resolver_test.c
+++ b/test/core/client_channel/resolvers/sockaddr_resolver_test.c
@@ -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 = 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);
@@ -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(&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);
@@ -84,7 +84,7 @@ static void test_fails(grpc_resolver_factory *factory, const char *string) {
   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.c
index e51d0031ec..b4de092438 100644
--- a/test/core/client_channel/uri_fuzzer_test.c
+++ b/test/core/client_channel/uri_fuzzer_test.c
@@ -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);
+int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  char* s = 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.c
index f53cae196b..0bdf57ce4b 100644
--- a/test/core/client_channel/uri_parser_test.c
+++ b/test/core/client_channel/uri_parser_test.c
@@ -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,7 +40,7 @@ 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));
   grpc_exec_ctx_finish(&exec_ctx);
@@ -49,8 +49,8 @@ static void test_fails(const char *uri_text) {
 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));
@@ -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));
@@ -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", "", "");