indent pass to get logical source lines on one physical line

13 files changed, 714 insertions, 566 deletions

diff --git a/test/core/util/grpc_profiler.c b/test/core/util/grpc_profiler.c
index c2c0c9cf53..0df6c13e5d 100644
--- a/test/core/util/grpc_profiler.c
+++ b/test/core/util/grpc_profiler.c
@@ -36,25 +36,34 @@
 #if GRPC_HAVE_PERFTOOLS
 #include <gperftools/profiler.h>
 
-void grpc_profiler_start(const char *filename) { ProfilerStart(filename); }
+void
+grpc_profiler_start (const char *filename)
+{
+  ProfilerStart (filename);
+}
 
-void grpc_profiler_stop() { ProfilerStop(); }
+void
+grpc_profiler_stop ()
+{
+  ProfilerStop ();
+}
 #else
 #include <grpc/support/log.h>
 
-void grpc_profiler_start(const char *filename) {
+void
+grpc_profiler_start (const char *filename)
+{
   static int printed_warning = 0;
-  if (!printed_warning) {
-    gpr_log(GPR_DEBUG,
-            "You do not have google-perftools installed, profiling is disabled "
-            "[for %s]",
-            filename);
-    gpr_log(GPR_DEBUG,
-            "To install on ubuntu: sudo apt-get install google-perftools "
-            "libgoogle-perftools-dev");
-    printed_warning = 1;
-  }
+  if (!printed_warning)
+    {
+      gpr_log (GPR_DEBUG, "You do not have google-perftools installed, profiling is disabled " "[for %s]", filename);
+      gpr_log (GPR_DEBUG, "To install on ubuntu: sudo apt-get install google-perftools " "libgoogle-perftools-dev");
+      printed_warning = 1;
+    }
 }
 
-void grpc_profiler_stop(void) {}
+void
+grpc_profiler_stop (void)
+{
+}
 #endif
diff --git a/test/core/util/grpc_profiler.h b/test/core/util/grpc_profiler.h
index 88ec6bcb0e..423c73b331 100644
--- a/test/core/util/grpc_profiler.h
+++ b/test/core/util/grpc_profiler.h
@@ -35,14 +35,15 @@
 #define GRPC_TEST_CORE_UTIL_GRPC_PROFILER_H
 
 #ifdef __cplusplus
-extern "C" {
-#endif /*  __cplusplus */
+extern "C"
+{
+#endif				/*  __cplusplus */
 
-void grpc_profiler_start(const char *filename);
-void grpc_profiler_stop();
+  void grpc_profiler_start (const char *filename);
+  void grpc_profiler_stop ();
 
 #ifdef __cplusplus
 }
-#endif /*  __cplusplus */
+#endif				/*  __cplusplus */
 
-#endif /* GRPC_TEST_CORE_UTIL_GRPC_PROFILER_H */
+#endif				/* GRPC_TEST_CORE_UTIL_GRPC_PROFILER_H */
diff --git a/test/core/util/parse_hexstring.c b/test/core/util/parse_hexstring.c
index eced3173d1..3d01dfc9a7 100644
--- a/test/core/util/parse_hexstring.c
+++ b/test/core/util/parse_hexstring.c
@@ -34,37 +34,45 @@
 #include "test/core/util/parse_hexstring.h"
 #include <grpc/support/log.h>
 
-gpr_slice parse_hexstring(const char *hexstring) {
+gpr_slice
+parse_hexstring (const char *hexstring)
+{
   size_t nibbles = 0;
   const char *p = 0;
   gpr_uint8 *out;
   gpr_uint8 temp;
   gpr_slice slice;
 
-  for (p = hexstring; *p; p++) {
-    nibbles += (*p >= '0' && *p <= '9') || (*p >= 'a' && *p <= 'f');
-  }
+  for (p = hexstring; *p; p++)
+    {
+      nibbles += (*p >= '0' && *p <= '9') || (*p >= 'a' && *p <= 'f');
+    }
 
-  GPR_ASSERT((nibbles & 1) == 0);
+  GPR_ASSERT ((nibbles & 1) == 0);
 
-  slice = gpr_slice_malloc(nibbles / 2);
-  out = GPR_SLICE_START_PTR(slice);
+  slice = gpr_slice_malloc (nibbles / 2);
+  out = GPR_SLICE_START_PTR (slice);
 
   nibbles = 0;
   temp = 0;
-  for (p = hexstring; *p; p++) {
-    if (*p >= '0' && *p <= '9') {
-      temp = (gpr_uint8)(temp << 4) | (gpr_uint8)(*p - '0');
-      nibbles++;
-    } else if (*p >= 'a' && *p <= 'f') {
-      temp = (gpr_uint8)(temp << 4) | (gpr_uint8)(*p - 'a' + 10);
-      nibbles++;
-    }
-    if (nibbles == 2) {
-      *out++ = temp;
-      nibbles = 0;
+  for (p = hexstring; *p; p++)
+    {
+      if (*p >= '0' && *p <= '9')
+	{
+	  temp = (gpr_uint8) (temp << 4) | (gpr_uint8) (*p - '0');
+	  nibbles++;
+	}
+      else if (*p >= 'a' && *p <= 'f')
+	{
+	  temp = (gpr_uint8) (temp << 4) | (gpr_uint8) (*p - 'a' + 10);
+	  nibbles++;
+	}
+      if (nibbles == 2)
+	{
+	  *out++ = temp;
+	  nibbles = 0;
+	}
     }
-  }
 
   return slice;
 }
diff --git a/test/core/util/parse_hexstring.h b/test/core/util/parse_hexstring.h
index ddbfe541c6..d2c4770330 100644
--- a/test/core/util/parse_hexstring.h
+++ b/test/core/util/parse_hexstring.h
@@ -36,6 +36,6 @@
 
 #include <grpc/support/slice.h>
 
-gpr_slice parse_hexstring(const char *hexstring);
+gpr_slice parse_hexstring (const char *hexstring);
 
 #endif /* GRPC_TEST_CORE_UTIL_PARSE_HEXSTRING_H */
diff --git a/test/core/util/port.h b/test/core/util/port.h
index 93788bcab2..ededcbe854 100644
--- a/test/core/util/port.h
+++ b/test/core/util/port.h
@@ -35,18 +35,19 @@
 #define GRPC_TEST_CORE_UTIL_PORT_H
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
 /* pick a port number that is currently unused by either tcp or udp. return
    0 on failure. */
-int grpc_pick_unused_port();
+  int grpc_pick_unused_port ();
 /* pick a port number that is currently unused by either tcp or udp. abort
    on failure. */
-int grpc_pick_unused_port_or_die();
+  int grpc_pick_unused_port_or_die ();
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* GRPC_TEST_CORE_UTIL_PORT_H */
+#endif				/* GRPC_TEST_CORE_UTIL_PORT_H */
diff --git a/test/core/util/port_posix.c b/test/core/util/port_posix.c
index 602af23c15..2bb545a376 100644
--- a/test/core/util/port_posix.c
+++ b/test/core/util/port_posix.c
@@ -57,38 +57,46 @@
 static int *chosen_ports = NULL;
 static size_t num_chosen_ports = 0;
 
-static int has_port_been_chosen(int port) {
+static int
+has_port_been_chosen (int port)
+{
   size_t i;
-  for (i = 0; i < num_chosen_ports; i++) {
-    if (chosen_ports[i] == port) {
-      return 1;
+  for (i = 0; i < num_chosen_ports; i++)
+    {
+      if (chosen_ports[i] == port)
+	{
+	  return 1;
+	}
     }
-  }
   return 0;
 }
 
-typedef struct freereq {
+typedef struct freereq
+{
   grpc_pollset pollset;
   int done;
 } freereq;
 
-static void destroy_pollset_and_shutdown(void *p, int success,
-                                         grpc_closure_list *closure_list) {
-  grpc_pollset_destroy(p);
-  grpc_shutdown();
+static void
+destroy_pollset_and_shutdown (void *p, int success, grpc_closure_list * closure_list)
+{
+  grpc_pollset_destroy (p);
+  grpc_shutdown ();
 }
 
-static void freed_port_from_server(void *arg,
-                                   const grpc_httpcli_response *response,
-                                   grpc_closure_list *closure_list) {
+static void
+freed_port_from_server (void *arg, const grpc_httpcli_response * response, grpc_closure_list * closure_list)
+{
   freereq *pr = arg;
-  gpr_mu_lock(GRPC_POLLSET_MU(&pr->pollset));
+  gpr_mu_lock (GRPC_POLLSET_MU (&pr->pollset));
   pr->done = 1;
-  grpc_pollset_kick(&pr->pollset, NULL);
-  gpr_mu_unlock(GRPC_POLLSET_MU(&pr->pollset));
+  grpc_pollset_kick (&pr->pollset, NULL);
+  gpr_mu_unlock (GRPC_POLLSET_MU (&pr->pollset));
 }
 
-static void free_port_using_server(char *server, int port) {
+static void
+free_port_using_server (char *server, int port)
+{
   grpc_httpcli_context context;
   grpc_httpcli_request req;
   freereq pr;
@@ -96,111 +104,125 @@ static void free_port_using_server(char *server, int port) {
   grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
   grpc_closure shutdown_closure;
 
-  grpc_init();
+  grpc_init ();
 
-  memset(&pr, 0, sizeof(pr));
-  memset(&req, 0, sizeof(req));
-  grpc_pollset_init(&pr.pollset);
-  grpc_closure_init(&shutdown_closure, destroy_pollset_and_shutdown,
-                    &pr.pollset);
+  memset (&pr, 0, sizeof (pr));
+  memset (&req, 0, sizeof (req));
+  grpc_pollset_init (&pr.pollset);
+  grpc_closure_init (&shutdown_closure, destroy_pollset_and_shutdown, &pr.pollset);
 
   req.host = server;
-  gpr_asprintf(&path, "/drop/%d", port);
+  gpr_asprintf (&path, "/drop/%d", port);
   req.path = path;
 
-  grpc_httpcli_context_init(&context);
-  grpc_httpcli_get(&context, &pr.pollset, &req,
-                   GRPC_TIMEOUT_SECONDS_TO_DEADLINE(10), freed_port_from_server,
-                   &pr, &closure_list);
-  gpr_mu_lock(GRPC_POLLSET_MU(&pr.pollset));
-  while (!pr.done) {
-    grpc_pollset_worker worker;
-    grpc_pollset_work(&pr.pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
-                      GRPC_TIMEOUT_SECONDS_TO_DEADLINE(1), &closure_list);
-  }
-  gpr_mu_unlock(GRPC_POLLSET_MU(&pr.pollset));
-
-  grpc_httpcli_context_destroy(&context);
-  grpc_closure_list_run(&closure_list);
-  grpc_pollset_shutdown(&pr.pollset, &shutdown_closure, &closure_list);
-  grpc_closure_list_run(&closure_list);
-  gpr_free(path);
+  grpc_httpcli_context_init (&context);
+  grpc_httpcli_get (&context, &pr.pollset, &req, GRPC_TIMEOUT_SECONDS_TO_DEADLINE (10), freed_port_from_server, &pr, &closure_list);
+  gpr_mu_lock (GRPC_POLLSET_MU (&pr.pollset));
+  while (!pr.done)
+    {
+      grpc_pollset_worker worker;
+      grpc_pollset_work (&pr.pollset, &worker, gpr_now (GPR_CLOCK_MONOTONIC), GRPC_TIMEOUT_SECONDS_TO_DEADLINE (1), &closure_list);
+    }
+  gpr_mu_unlock (GRPC_POLLSET_MU (&pr.pollset));
+
+  grpc_httpcli_context_destroy (&context);
+  grpc_closure_list_run (&closure_list);
+  grpc_pollset_shutdown (&pr.pollset, &shutdown_closure, &closure_list);
+  grpc_closure_list_run (&closure_list);
+  gpr_free (path);
 }
 
-static void free_chosen_ports() {
-  char *env = gpr_getenv("GRPC_TEST_PORT_SERVER");
-  if (env != NULL) {
-    size_t i;
-    for (i = 0; i < num_chosen_ports; i++) {
-      free_port_using_server(env, chosen_ports[i]);
+static void
+free_chosen_ports ()
+{
+  char *env = gpr_getenv ("GRPC_TEST_PORT_SERVER");
+  if (env != NULL)
+    {
+      size_t i;
+      for (i = 0; i < num_chosen_ports; i++)
+	{
+	  free_port_using_server (env, chosen_ports[i]);
+	}
+      gpr_free (env);
     }
-    gpr_free(env);
-  }
 
-  gpr_free(chosen_ports);
+  gpr_free (chosen_ports);
 }
 
-static void chose_port(int port) {
-  if (chosen_ports == NULL) {
-    atexit(free_chosen_ports);
-  }
+static void
+chose_port (int port)
+{
+  if (chosen_ports == NULL)
+    {
+      atexit (free_chosen_ports);
+    }
   num_chosen_ports++;
-  chosen_ports = gpr_realloc(chosen_ports, sizeof(int) * num_chosen_ports);
+  chosen_ports = gpr_realloc (chosen_ports, sizeof (int) * num_chosen_ports);
   chosen_ports[num_chosen_ports - 1] = port;
 }
 
-static int is_port_available(int *port, int is_tcp) {
+static int
+is_port_available (int *port, int is_tcp)
+{
   const int proto = is_tcp ? IPPROTO_TCP : 0;
-  const int fd = socket(AF_INET, is_tcp ? SOCK_STREAM : SOCK_DGRAM, proto);
+  const int fd = socket (AF_INET, is_tcp ? SOCK_STREAM : SOCK_DGRAM, proto);
   int one = 1;
   struct sockaddr_in addr;
-  socklen_t alen = sizeof(addr);
+  socklen_t alen = sizeof (addr);
   int actual_port;
 
-  GPR_ASSERT(*port >= 0);
-  GPR_ASSERT(*port <= 65535);
-  if (fd < 0) {
-    gpr_log(GPR_ERROR, "socket() failed: %s", strerror(errno));
-    return 0;
-  }
+  GPR_ASSERT (*port >= 0);
+  GPR_ASSERT (*port <= 65535);
+  if (fd < 0)
+    {
+      gpr_log (GPR_ERROR, "socket() failed: %s", strerror (errno));
+      return 0;
+    }
 
   /* Reuseaddr lets us start up a server immediately after it exits */
-  if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)) < 0) {
-    gpr_log(GPR_ERROR, "setsockopt() failed: %s", strerror(errno));
-    close(fd);
-    return 0;
-  }
+  if (setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof (one)) < 0)
+    {
+      gpr_log (GPR_ERROR, "setsockopt() failed: %s", strerror (errno));
+      close (fd);
+      return 0;
+    }
 
   /* Try binding to port */
   addr.sin_family = AF_INET;
   addr.sin_addr.s_addr = INADDR_ANY;
-  addr.sin_port = htons((gpr_uint16)*port);
-  if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
-    gpr_log(GPR_DEBUG, "bind(port=%d) failed: %s", *port, strerror(errno));
-    close(fd);
-    return 0;
-  }
+  addr.sin_port = htons ((gpr_uint16) * port);
+  if (bind (fd, (struct sockaddr *) &addr, sizeof (addr)) < 0)
+    {
+      gpr_log (GPR_DEBUG, "bind(port=%d) failed: %s", *port, strerror (errno));
+      close (fd);
+      return 0;
+    }
 
   /* Get the bound port number */
-  if (getsockname(fd, (struct sockaddr *)&addr, &alen) < 0) {
-    gpr_log(GPR_ERROR, "getsockname() failed: %s", strerror(errno));
-    close(fd);
-    return 0;
-  }
-  GPR_ASSERT(alen <= sizeof(addr));
-  actual_port = ntohs(addr.sin_port);
-  GPR_ASSERT(actual_port > 0);
-  if (*port == 0) {
-    *port = actual_port;
-  } else {
-    GPR_ASSERT(*port == actual_port);
-  }
-
-  close(fd);
+  if (getsockname (fd, (struct sockaddr *) &addr, &alen) < 0)
+    {
+      gpr_log (GPR_ERROR, "getsockname() failed: %s", strerror (errno));
+      close (fd);
+      return 0;
+    }
+  GPR_ASSERT (alen <= sizeof (addr));
+  actual_port = ntohs (addr.sin_port);
+  GPR_ASSERT (actual_port > 0);
+  if (*port == 0)
+    {
+      *port = actual_port;
+    }
+  else
+    {
+      GPR_ASSERT (*port == actual_port);
+    }
+
+  close (fd);
   return 1;
 }
 
-typedef struct portreq {
+typedef struct portreq
+{
   grpc_pollset pollset;
   int port;
   int retries;
@@ -208,54 +230,55 @@ typedef struct portreq {
   grpc_httpcli_context *ctx;
 } portreq;
 
-static void got_port_from_server(void *arg,
-                                 const grpc_httpcli_response *response,
-                                 grpc_closure_list *closure_list) {
+static void
+got_port_from_server (void *arg, const grpc_httpcli_response * response, grpc_closure_list * closure_list)
+{
   size_t i;
   int port = 0;
   portreq *pr = arg;
 
-  if (!response || response->status != 200) {
-    grpc_httpcli_request req;
-    memset(&req, 0, sizeof(req));
-    GPR_ASSERT(pr->retries < 10);
-    pr->retries++;
-    req.host = pr->server;
-    req.path = "/get";
-    gpr_log(GPR_DEBUG, "failed port pick from server: retrying");
-    sleep(1);
-    grpc_httpcli_get(pr->ctx, &pr->pollset, &req,
-                     GRPC_TIMEOUT_SECONDS_TO_DEADLINE(10), got_port_from_server,
-                     pr, closure_list);
-    return;
-  }
-  GPR_ASSERT(response);
-  GPR_ASSERT(response->status == 200);
-  for (i = 0; i < response->body_length; i++) {
-    GPR_ASSERT(response->body[i] >= '0' && response->body[i] <= '9');
-    port = port * 10 + response->body[i] - '0';
-  }
-  GPR_ASSERT(port > 1024);
-  gpr_mu_lock(GRPC_POLLSET_MU(&pr->pollset));
+  if (!response || response->status != 200)
+    {
+      grpc_httpcli_request req;
+      memset (&req, 0, sizeof (req));
+      GPR_ASSERT (pr->retries < 10);
+      pr->retries++;
+      req.host = pr->server;
+      req.path = "/get";
+      gpr_log (GPR_DEBUG, "failed port pick from server: retrying");
+      sleep (1);
+      grpc_httpcli_get (pr->ctx, &pr->pollset, &req, GRPC_TIMEOUT_SECONDS_TO_DEADLINE (10), got_port_from_server, pr, closure_list);
+      return;
+    }
+  GPR_ASSERT (response);
+  GPR_ASSERT (response->status == 200);
+  for (i = 0; i < response->body_length; i++)
+    {
+      GPR_ASSERT (response->body[i] >= '0' && response->body[i] <= '9');
+      port = port * 10 + response->body[i] - '0';
+    }
+  GPR_ASSERT (port > 1024);
+  gpr_mu_lock (GRPC_POLLSET_MU (&pr->pollset));
   pr->port = port;
-  grpc_pollset_kick(&pr->pollset, NULL);
-  gpr_mu_unlock(GRPC_POLLSET_MU(&pr->pollset));
+  grpc_pollset_kick (&pr->pollset, NULL);
+  gpr_mu_unlock (GRPC_POLLSET_MU (&pr->pollset));
 }
 
-static int pick_port_using_server(char *server) {
+static int
+pick_port_using_server (char *server)
+{
   grpc_httpcli_context context;
   grpc_httpcli_request req;
   portreq pr;
   grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
   grpc_closure shutdown_closure;
 
-  grpc_init();
+  grpc_init ();
 
-  memset(&pr, 0, sizeof(pr));
-  memset(&req, 0, sizeof(req));
-  grpc_pollset_init(&pr.pollset);
-  grpc_closure_init(&shutdown_closure, destroy_pollset_and_shutdown,
-                    &pr.pollset);
+  memset (&pr, 0, sizeof (pr));
+  memset (&req, 0, sizeof (req));
+  grpc_pollset_init (&pr.pollset);
+  grpc_closure_init (&shutdown_closure, destroy_pollset_and_shutdown, &pr.pollset);
   pr.port = -1;
   pr.server = server;
   pr.ctx = &context;
@@ -263,27 +286,27 @@ static int pick_port_using_server(char *server) {
   req.host = server;
   req.path = "/get";
 
-  grpc_httpcli_context_init(&context);
-  grpc_httpcli_get(&context, &pr.pollset, &req,
-                   GRPC_TIMEOUT_SECONDS_TO_DEADLINE(10), got_port_from_server,
-                   &pr, &closure_list);
-  grpc_closure_list_run(&closure_list);
-  gpr_mu_lock(GRPC_POLLSET_MU(&pr.pollset));
-  while (pr.port == -1) {
-    grpc_pollset_worker worker;
-    grpc_pollset_work(&pr.pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
-                      GRPC_TIMEOUT_SECONDS_TO_DEADLINE(1), &closure_list);
-  }
-  gpr_mu_unlock(GRPC_POLLSET_MU(&pr.pollset));
-
-  grpc_httpcli_context_destroy(&context);
-  grpc_pollset_shutdown(&pr.pollset, &shutdown_closure, &closure_list);
-  grpc_closure_list_run(&closure_list);
+  grpc_httpcli_context_init (&context);
+  grpc_httpcli_get (&context, &pr.pollset, &req, GRPC_TIMEOUT_SECONDS_TO_DEADLINE (10), got_port_from_server, &pr, &closure_list);
+  grpc_closure_list_run (&closure_list);
+  gpr_mu_lock (GRPC_POLLSET_MU (&pr.pollset));
+  while (pr.port == -1)
+    {
+      grpc_pollset_worker worker;
+      grpc_pollset_work (&pr.pollset, &worker, gpr_now (GPR_CLOCK_MONOTONIC), GRPC_TIMEOUT_SECONDS_TO_DEADLINE (1), &closure_list);
+    }
+  gpr_mu_unlock (GRPC_POLLSET_MU (&pr.pollset));
+
+  grpc_httpcli_context_destroy (&context);
+  grpc_pollset_shutdown (&pr.pollset, &shutdown_closure, &closure_list);
+  grpc_closure_list_run (&closure_list);
 
   return pr.port;
 }
 
-int grpc_pick_unused_port(void) {
+int
+grpc_pick_unused_port (void)
+{
   /* We repeatedly pick a port and then see whether or not it is
      available for use both as a TCP socket and a UDP socket.  First, we
      pick a random large port number.  For subsequent
@@ -300,55 +323,68 @@ int grpc_pick_unused_port(void) {
   int is_tcp = 1;
   int trial = 0;
 
-  char *env = gpr_getenv("GRPC_TEST_PORT_SERVER");
-  if (env) {
-    int port = pick_port_using_server(env);
-    gpr_free(env);
-    if (port != 0) {
-      chose_port(port);
-    }
-    return port;
-  }
-
-  for (;;) {
-    int port;
-    trial++;
-    if (trial == 1) {
-      port = getpid() % (65536 - 30000) + 30000;
-    } else if (trial <= NUM_RANDOM_PORTS_TO_PICK) {
-      port = rand() % (65536 - 30000) + 30000;
-    } else {
-      port = 0;
-    }
-
-    if (has_port_been_chosen(port)) {
-      continue;
+  char *env = gpr_getenv ("GRPC_TEST_PORT_SERVER");
+  if (env)
+    {
+      int port = pick_port_using_server (env);
+      gpr_free (env);
+      if (port != 0)
+	{
+	  chose_port (port);
+	}
+      return port;
     }
 
-    if (!is_port_available(&port, is_tcp)) {
-      continue;
+  for (;;)
+    {
+      int port;
+      trial++;
+      if (trial == 1)
+	{
+	  port = getpid () % (65536 - 30000) + 30000;
+	}
+      else if (trial <= NUM_RANDOM_PORTS_TO_PICK)
+	{
+	  port = rand () % (65536 - 30000) + 30000;
+	}
+      else
+	{
+	  port = 0;
+	}
+
+      if (has_port_been_chosen (port))
+	{
+	  continue;
+	}
+
+      if (!is_port_available (&port, is_tcp))
+	{
+	  continue;
+	}
+
+      GPR_ASSERT (port > 0);
+      /* Check that the port # is free for the other type of socket also */
+      if (!is_port_available (&port, !is_tcp))
+	{
+	  /* In the next iteration trial to bind to the other type first
+	     because perhaps it is more rare. */
+	  is_tcp = !is_tcp;
+	  continue;
+	}
+
+      chose_port (port);
+      return port;
     }
 
-    GPR_ASSERT(port > 0);
-    /* Check that the port # is free for the other type of socket also */
-    if (!is_port_available(&port, !is_tcp)) {
-      /* In the next iteration trial to bind to the other type first
-         because perhaps it is more rare. */
-      is_tcp = !is_tcp;
-      continue;
-    }
-
-    chose_port(port);
-    return port;
-  }
-
   /* The port iterator reached the end without finding a suitable port. */
   return 0;
 }
 
-int grpc_pick_unused_port_or_die(void) {
-  int port = grpc_pick_unused_port();
-  GPR_ASSERT(port > 0);
+int
+grpc_pick_unused_port_or_die (void)
+{
+  int port = grpc_pick_unused_port ();
+  GPR_ASSERT (port > 0);
   return port;
 }
 
diff --git a/test/core/util/port_windows.c b/test/core/util/port_windows.c
index a57fe692e1..fefe33e9ba 100644
--- a/test/core/util/port_windows.c
+++ b/test/core/util/port_windows.c
@@ -55,141 +55,167 @@
 static int *chosen_ports = NULL;
 static size_t num_chosen_ports = 0;
 
-static int has_port_been_chosen(int port) {
+static int
+has_port_been_chosen (int port)
+{
   size_t i;
-  for (i = 0; i < num_chosen_ports; i++) {
-    if (chosen_ports[i] == port) {
-      return 1;
+  for (i = 0; i < num_chosen_ports; i++)
+    {
+      if (chosen_ports[i] == port)
+	{
+	  return 1;
+	}
     }
-  }
   return 0;
 }
 
-static void free_chosen_ports() { gpr_free(chosen_ports); }
+static void
+free_chosen_ports ()
+{
+  gpr_free (chosen_ports);
+}
 
-static void chose_port(int port) {
-  if (chosen_ports == NULL) {
-    atexit(free_chosen_ports);
-  }
+static void
+chose_port (int port)
+{
+  if (chosen_ports == NULL)
+    {
+      atexit (free_chosen_ports);
+    }
   num_chosen_ports++;
-  chosen_ports = gpr_realloc(chosen_ports, sizeof(int) * num_chosen_ports);
+  chosen_ports = gpr_realloc (chosen_ports, sizeof (int) * num_chosen_ports);
   chosen_ports[num_chosen_ports - 1] = port;
 }
 
-static int is_port_available(int *port, int is_tcp) {
+static int
+is_port_available (int *port, int is_tcp)
+{
   const int proto = is_tcp ? IPPROTO_TCP : 0;
-  const SOCKET fd = socket(AF_INET, is_tcp ? SOCK_STREAM : SOCK_DGRAM, proto);
+  const SOCKET fd = socket (AF_INET, is_tcp ? SOCK_STREAM : SOCK_DGRAM, proto);
   int one = 1;
   struct sockaddr_in addr;
-  socklen_t alen = sizeof(addr);
+  socklen_t alen = sizeof (addr);
   int actual_port;
 
-  GPR_ASSERT(*port >= 0);
-  GPR_ASSERT(*port <= 65535);
-  if (INVALID_SOCKET == fd) {
-    gpr_log(GPR_ERROR, "socket() failed: %s", strerror(errno));
-    return 0;
-  }
+  GPR_ASSERT (*port >= 0);
+  GPR_ASSERT (*port <= 65535);
+  if (INVALID_SOCKET == fd)
+    {
+      gpr_log (GPR_ERROR, "socket() failed: %s", strerror (errno));
+      return 0;
+    }
 
   /* Reuseaddr lets us start up a server immediately after it exits */
-  if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&one,
-                 sizeof(one)) < 0) {
-    gpr_log(GPR_ERROR, "setsockopt() failed: %s", strerror(errno));
-    closesocket(fd);
-    return 0;
-  }
+  if (setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, (const char *) &one, sizeof (one)) < 0)
+    {
+      gpr_log (GPR_ERROR, "setsockopt() failed: %s", strerror (errno));
+      closesocket (fd);
+      return 0;
+    }
 
   /* Try binding to port */
   addr.sin_family = AF_INET;
   addr.sin_addr.s_addr = INADDR_ANY;
-  addr.sin_port = htons(*port);
-  if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
-    gpr_log(GPR_DEBUG, "bind(port=%d) failed: %s", *port, strerror(errno));
-    closesocket(fd);
-    return 0;
-  }
+  addr.sin_port = htons (*port);
+  if (bind (fd, (struct sockaddr *) &addr, sizeof (addr)) < 0)
+    {
+      gpr_log (GPR_DEBUG, "bind(port=%d) failed: %s", *port, strerror (errno));
+      closesocket (fd);
+      return 0;
+    }
 
   /* Get the bound port number */
-  if (getsockname(fd, (struct sockaddr *)&addr, &alen) < 0) {
-    gpr_log(GPR_ERROR, "getsockname() failed: %s", strerror(errno));
-    closesocket(fd);
-    return 0;
-  }
-  GPR_ASSERT(alen <= sizeof(addr));
-  actual_port = ntohs(addr.sin_port);
-  GPR_ASSERT(actual_port > 0);
-  if (*port == 0) {
-    *port = actual_port;
-  } else {
-    GPR_ASSERT(*port == actual_port);
-  }
-
-  closesocket(fd);
+  if (getsockname (fd, (struct sockaddr *) &addr, &alen) < 0)
+    {
+      gpr_log (GPR_ERROR, "getsockname() failed: %s", strerror (errno));
+      closesocket (fd);
+      return 0;
+    }
+  GPR_ASSERT (alen <= sizeof (addr));
+  actual_port = ntohs (addr.sin_port);
+  GPR_ASSERT (actual_port > 0);
+  if (*port == 0)
+    {
+      *port = actual_port;
+    }
+  else
+    {
+      GPR_ASSERT (*port == actual_port);
+    }
+
+  closesocket (fd);
   return 1;
 }
 
-typedef struct portreq {
+typedef struct portreq
+{
   grpc_pollset pollset;
   int port;
 } portreq;
 
-static void got_port_from_server(void *arg,
-                                 const grpc_httpcli_response *response) {
+static void
+got_port_from_server (void *arg, const grpc_httpcli_response * response)
+{
   size_t i;
   int port = 0;
   portreq *pr = arg;
-  GPR_ASSERT(response);
-  GPR_ASSERT(response->status == 200);
-  for (i = 0; i < response->body_length; i++) {
-    GPR_ASSERT(response->body[i] >= '0' && response->body[i] <= '9');
-    port = port * 10 + response->body[i] - '0';
-  }
-  GPR_ASSERT(port > 1024);
-  gpr_mu_lock(GRPC_POLLSET_MU(&pr->pollset));
+  GPR_ASSERT (response);
+  GPR_ASSERT (response->status == 200);
+  for (i = 0; i < response->body_length; i++)
+    {
+      GPR_ASSERT (response->body[i] >= '0' && response->body[i] <= '9');
+      port = port * 10 + response->body[i] - '0';
+    }
+  GPR_ASSERT (port > 1024);
+  gpr_mu_lock (GRPC_POLLSET_MU (&pr->pollset));
   pr->port = port;
-  grpc_pollset_kick(&pr->pollset, NULL);
-  gpr_mu_unlock(GRPC_POLLSET_MU(&pr->pollset));
+  grpc_pollset_kick (&pr->pollset, NULL);
+  gpr_mu_unlock (GRPC_POLLSET_MU (&pr->pollset));
 }
 
-static void destroy_pollset_and_shutdown(void *p) {
-  grpc_pollset_destroy(p);
-  grpc_shutdown();
+static void
+destroy_pollset_and_shutdown (void *p)
+{
+  grpc_pollset_destroy (p);
+  grpc_shutdown ();
 }
 
-static int pick_port_using_server(char *server) {
+static int
+pick_port_using_server (char *server)
+{
   grpc_httpcli_context context;
   grpc_httpcli_request req;
   portreq pr;
 
-  grpc_init();
+  grpc_init ();
 
-  memset(&pr, 0, sizeof(pr));
-  memset(&req, 0, sizeof(req));
-  grpc_pollset_init(&pr.pollset);
+  memset (&pr, 0, sizeof (pr));
+  memset (&req, 0, sizeof (req));
+  grpc_pollset_init (&pr.pollset);
   pr.port = -1;
 
   req.host = server;
   req.path = "/get";
 
-  grpc_httpcli_context_init(&context);
-  grpc_httpcli_get(&context, &pr.pollset, &req,
-                   GRPC_TIMEOUT_SECONDS_TO_DEADLINE(10), got_port_from_server,
-                   &pr);
-  gpr_mu_lock(GRPC_POLLSET_MU(&pr.pollset));
-  while (pr.port == -1) {
-    grpc_pollset_worker worker;
-    grpc_pollset_work(&pr.pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
-                      GRPC_TIMEOUT_SECONDS_TO_DEADLINE(1));
-  }
-  gpr_mu_unlock(GRPC_POLLSET_MU(&pr.pollset));
-
-  grpc_httpcli_context_destroy(&context);
-  grpc_pollset_shutdown(&pr.pollset, destroy_pollset_and_shutdown, &pr.pollset);
+  grpc_httpcli_context_init (&context);
+  grpc_httpcli_get (&context, &pr.pollset, &req, GRPC_TIMEOUT_SECONDS_TO_DEADLINE (10), got_port_from_server, &pr);
+  gpr_mu_lock (GRPC_POLLSET_MU (&pr.pollset));
+  while (pr.port == -1)
+    {
+      grpc_pollset_worker worker;
+      grpc_pollset_work (&pr.pollset, &worker, gpr_now (GPR_CLOCK_MONOTONIC), GRPC_TIMEOUT_SECONDS_TO_DEADLINE (1));
+    }
+  gpr_mu_unlock (GRPC_POLLSET_MU (&pr.pollset));
+
+  grpc_httpcli_context_destroy (&context);
+  grpc_pollset_shutdown (&pr.pollset, destroy_pollset_and_shutdown, &pr.pollset);
 
   return pr.port;
 }
 
-int grpc_pick_unused_port(void) {
+int
+grpc_pick_unused_port (void)
+{
   /* We repeatedly pick a port and then see whether or not it is
      available for use both as a TCP socket and a UDP socket.  First, we
      pick a random large port number.  For subsequent
@@ -206,57 +232,70 @@ int grpc_pick_unused_port(void) {
   int is_tcp = 1;
   int trial = 0;
 
-  char *env = gpr_getenv("GRPC_TEST_PORT_SERVER");
-  if (env) {
-    int port = pick_port_using_server(env);
-    gpr_free(env);
-    if (port != 0) {
-      return port;
-    }
-  }
-
-  for (;;) {
-    int port;
-    trial++;
-    if (trial == 1) {
-      port = _getpid() % (65536 - 30000) + 30000;
-    } else if (trial <= NUM_RANDOM_PORTS_TO_PICK) {
-      port = rand() % (65536 - 30000) + 30000;
-    } else {
-      port = 0;
-    }
-
-    if (has_port_been_chosen(port)) {
-      continue;
+  char *env = gpr_getenv ("GRPC_TEST_PORT_SERVER");
+  if (env)
+    {
+      int port = pick_port_using_server (env);
+      gpr_free (env);
+      if (port != 0)
+	{
+	  return port;
+	}
     }
 
-    if (!is_port_available(&port, is_tcp)) {
-      continue;
-    }
-
-    GPR_ASSERT(port > 0);
-    /* Check that the port # is free for the other type of socket also */
-    if (!is_port_available(&port, !is_tcp)) {
-      /* In the next iteration trial to bind to the other type first
-         because perhaps it is more rare. */
-      is_tcp = !is_tcp;
-      continue;
+  for (;;)
+    {
+      int port;
+      trial++;
+      if (trial == 1)
+	{
+	  port = _getpid () % (65536 - 30000) + 30000;
+	}
+      else if (trial <= NUM_RANDOM_PORTS_TO_PICK)
+	{
+	  port = rand () % (65536 - 30000) + 30000;
+	}
+      else
+	{
+	  port = 0;
+	}
+
+      if (has_port_been_chosen (port))
+	{
+	  continue;
+	}
+
+      if (!is_port_available (&port, is_tcp))
+	{
+	  continue;
+	}
+
+      GPR_ASSERT (port > 0);
+      /* Check that the port # is free for the other type of socket also */
+      if (!is_port_available (&port, !is_tcp))
+	{
+	  /* In the next iteration trial to bind to the other type first
+	     because perhaps it is more rare. */
+	  is_tcp = !is_tcp;
+	  continue;
+	}
+
+      /* TODO(ctiller): consider caching this port in some structure, to avoid
+         handing it out again */
+
+      chose_port (port);
+      return port;
     }
 
-    /* TODO(ctiller): consider caching this port in some structure, to avoid
-                      handing it out again */
-
-    chose_port(port);
-    return port;
-  }
-
   /* The port iterator reached the end without finding a suitable port. */
   return 0;
 }
 
-int grpc_pick_unused_port_or_die(void) {
-  int port = grpc_pick_unused_port();
-  GPR_ASSERT(port > 0);
+int
+grpc_pick_unused_port_or_die (void)
+{
+  int port = grpc_pick_unused_port ();
+  GPR_ASSERT (port > 0);
   return port;
 }
 
diff --git a/test/core/util/reconnect_server.c b/test/core/util/reconnect_server.c
index 8092cbc73a..f730303004 100644
--- a/test/core/util/reconnect_server.c
+++ b/test/core/util/reconnect_server.c
@@ -45,133 +45,151 @@
 #include "src/core/iomgr/tcp_server.h"
 #include "test/core/util/port.h"
 
-static void pretty_print_backoffs(reconnect_server *server) {
+static void
+pretty_print_backoffs (reconnect_server * server)
+{
   gpr_timespec diff;
   int i = 1;
   double expected_backoff = 1000.0, backoff;
   timestamp_list *head = server->head;
-  gpr_log(GPR_INFO, "reconnect server: new connection");
-  for (head = server->head; head && head->next; head = head->next, i++) {
-    diff = gpr_time_sub(head->next->timestamp, head->timestamp);
-    backoff = gpr_time_to_millis(diff);
-    gpr_log(GPR_INFO,
-            "retry %2d:backoff %6.2fs,expected backoff %6.2fs, jitter %4.2f%%",
-            i, backoff / 1000.0, expected_backoff / 1000.0,
-            (backoff - expected_backoff) * 100.0 / expected_backoff);
-    expected_backoff *= 1.6;
-    if (expected_backoff > 120 * 1000) {
-      expected_backoff = 120 * 1000;
+  gpr_log (GPR_INFO, "reconnect server: new connection");
+  for (head = server->head; head && head->next; head = head->next, i++)
+    {
+      diff = gpr_time_sub (head->next->timestamp, head->timestamp);
+      backoff = gpr_time_to_millis (diff);
+      gpr_log (GPR_INFO, "retry %2d:backoff %6.2fs,expected backoff %6.2fs, jitter %4.2f%%", i, backoff / 1000.0, expected_backoff / 1000.0, (backoff - expected_backoff) * 100.0 / expected_backoff);
+      expected_backoff *= 1.6;
+      if (expected_backoff > 120 * 1000)
+	{
+	  expected_backoff = 120 * 1000;
+	}
     }
-  }
 }
 
-static void on_connect(void *arg, grpc_endpoint *tcp,
-                       grpc_closure_list *closure_list) {
+static void
+on_connect (void *arg, grpc_endpoint * tcp, grpc_closure_list * closure_list)
+{
   char *peer;
   char *last_colon;
-  reconnect_server *server = (reconnect_server *)arg;
-  gpr_timespec now = gpr_now(GPR_CLOCK_REALTIME);
+  reconnect_server *server = (reconnect_server *) arg;
+  gpr_timespec now = gpr_now (GPR_CLOCK_REALTIME);
   timestamp_list *new_tail;
-  peer = grpc_endpoint_get_peer(tcp);
-  grpc_endpoint_shutdown(tcp, closure_list);
-  grpc_endpoint_destroy(tcp, closure_list);
-  if (peer) {
-    last_colon = strrchr(peer, ':');
-    if (server->peer == NULL) {
-      server->peer = peer;
-    } else {
-      if (last_colon == NULL) {
-        gpr_log(GPR_ERROR, "peer does not contain a ':'");
-      } else if (strncmp(server->peer, peer, (size_t)(last_colon - peer)) !=
-                 0) {
-        gpr_log(GPR_ERROR, "mismatched peer! %s vs %s", server->peer, peer);
-      }
-      gpr_free(peer);
+  peer = grpc_endpoint_get_peer (tcp);
+  grpc_endpoint_shutdown (tcp, closure_list);
+  grpc_endpoint_destroy (tcp, closure_list);
+  if (peer)
+    {
+      last_colon = strrchr (peer, ':');
+      if (server->peer == NULL)
+	{
+	  server->peer = peer;
+	}
+      else
+	{
+	  if (last_colon == NULL)
+	    {
+	      gpr_log (GPR_ERROR, "peer does not contain a ':'");
+	    }
+	  else if (strncmp (server->peer, peer, (size_t) (last_colon - peer)) != 0)
+	    {
+	      gpr_log (GPR_ERROR, "mismatched peer! %s vs %s", server->peer, peer);
+	    }
+	  gpr_free (peer);
+	}
     }
-  }
-  new_tail = gpr_malloc(sizeof(timestamp_list));
+  new_tail = gpr_malloc (sizeof (timestamp_list));
   new_tail->timestamp = now;
   new_tail->next = NULL;
-  if (server->tail == NULL) {
-    server->head = new_tail;
-    server->tail = new_tail;
-  } else {
-    server->tail->next = new_tail;
-    server->tail = new_tail;
-  }
-  pretty_print_backoffs(server);
+  if (server->tail == NULL)
+    {
+      server->head = new_tail;
+      server->tail = new_tail;
+    }
+  else
+    {
+      server->tail->next = new_tail;
+      server->tail = new_tail;
+    }
+  pretty_print_backoffs (server);
 }
 
-void reconnect_server_init(reconnect_server *server) {
-  grpc_init();
+void
+reconnect_server_init (reconnect_server * server)
+{
+  grpc_init ();
   server->tcp_server = NULL;
-  grpc_pollset_init(&server->pollset);
+  grpc_pollset_init (&server->pollset);
   server->pollsets[0] = &server->pollset;
   server->head = NULL;
   server->tail = NULL;
   server->peer = NULL;
 }
 
-void reconnect_server_start(reconnect_server *server, int port) {
+void
+reconnect_server_start (reconnect_server * server, int port)
+{
   struct sockaddr_in addr;
   int port_added;
   grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
 
   addr.sin_family = AF_INET;
-  addr.sin_port = htons((gpr_uint16)port);
-  memset(&addr.sin_addr, 0, sizeof(addr.sin_addr));
+  addr.sin_port = htons ((gpr_uint16) port);
+  memset (&addr.sin_addr, 0, sizeof (addr.sin_addr));
 
-  server->tcp_server = grpc_tcp_server_create();
-  port_added =
-      grpc_tcp_server_add_port(server->tcp_server, &addr, sizeof(addr));
-  GPR_ASSERT(port_added == port);
+  server->tcp_server = grpc_tcp_server_create ();
+  port_added = grpc_tcp_server_add_port (server->tcp_server, &addr, sizeof (addr));
+  GPR_ASSERT (port_added == port);
 
-  grpc_tcp_server_start(server->tcp_server, server->pollsets, 1, on_connect,
-                        server, &closure_list);
-  gpr_log(GPR_INFO, "reconnect tcp server listening on 0.0.0.0:%d", port);
+  grpc_tcp_server_start (server->tcp_server, server->pollsets, 1, on_connect, server, &closure_list);
+  gpr_log (GPR_INFO, "reconnect tcp server listening on 0.0.0.0:%d", port);
 
-  grpc_closure_list_run(&closure_list);
+  grpc_closure_list_run (&closure_list);
 }
 
-void reconnect_server_poll(reconnect_server *server, int seconds) {
+void
+reconnect_server_poll (reconnect_server * server, int seconds)
+{
   grpc_pollset_worker worker;
-  gpr_timespec deadline =
-      gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC),
-                   gpr_time_from_seconds(seconds, GPR_TIMESPAN));
+  gpr_timespec deadline = gpr_time_add (gpr_now (GPR_CLOCK_MONOTONIC),
+					gpr_time_from_seconds (seconds, GPR_TIMESPAN));
   grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
-  gpr_mu_lock(GRPC_POLLSET_MU(&server->pollset));
-  grpc_pollset_work(&server->pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
-                    deadline, &closure_list);
-  gpr_mu_unlock(GRPC_POLLSET_MU(&server->pollset));
-  grpc_closure_list_run(&closure_list);
+  gpr_mu_lock (GRPC_POLLSET_MU (&server->pollset));
+  grpc_pollset_work (&server->pollset, &worker, gpr_now (GPR_CLOCK_MONOTONIC), deadline, &closure_list);
+  gpr_mu_unlock (GRPC_POLLSET_MU (&server->pollset));
+  grpc_closure_list_run (&closure_list);
 }
 
-void reconnect_server_clear_timestamps(reconnect_server *server) {
+void
+reconnect_server_clear_timestamps (reconnect_server * server)
+{
   timestamp_list *new_head = server->head;
-  while (server->head) {
-    new_head = server->head->next;
-    gpr_free(server->head);
-    server->head = new_head;
-  }
+  while (server->head)
+    {
+      new_head = server->head->next;
+      gpr_free (server->head);
+      server->head = new_head;
+    }
   server->tail = NULL;
-  gpr_free(server->peer);
+  gpr_free (server->peer);
   server->peer = NULL;
 }
 
-static void do_nothing(void *ignored, int success,
-                       grpc_closure_list *closure_list) {}
+static void
+do_nothing (void *ignored, int success, grpc_closure_list * closure_list)
+{
+}
 
-void reconnect_server_destroy(reconnect_server *server) {
+void
+reconnect_server_destroy (reconnect_server * server)
+{
   grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
   grpc_closure do_nothing_closure[2];
-  grpc_closure_init(&do_nothing_closure[0], do_nothing, NULL);
-  grpc_closure_init(&do_nothing_closure[1], do_nothing, NULL);
-  grpc_tcp_server_destroy(server->tcp_server, &do_nothing_closure[0],
-                          &closure_list);
-  reconnect_server_clear_timestamps(server);
-  grpc_pollset_shutdown(&server->pollset, &do_nothing_closure[1],
-                        &closure_list);
-  grpc_closure_list_run(&closure_list);
-  grpc_pollset_destroy(&server->pollset);
-  grpc_shutdown();
+  grpc_closure_init (&do_nothing_closure[0], do_nothing, NULL);
+  grpc_closure_init (&do_nothing_closure[1], do_nothing, NULL);
+  grpc_tcp_server_destroy (server->tcp_server, &do_nothing_closure[0], &closure_list);
+  reconnect_server_clear_timestamps (server);
+  grpc_pollset_shutdown (&server->pollset, &do_nothing_closure[1], &closure_list);
+  grpc_closure_list_run (&closure_list);
+  grpc_pollset_destroy (&server->pollset);
+  grpc_shutdown ();
 }
diff --git a/test/core/util/reconnect_server.h b/test/core/util/reconnect_server.h
index 8a278e0c7a..aaf277390c 100644
--- a/test/core/util/reconnect_server.h
+++ b/test/core/util/reconnect_server.h
@@ -39,31 +39,34 @@
 #include "src/core/iomgr/tcp_server.h"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-typedef struct timestamp_list {
-  gpr_timespec timestamp;
-  struct timestamp_list *next;
-} timestamp_list;
+  typedef struct timestamp_list
+  {
+    gpr_timespec timestamp;
+    struct timestamp_list *next;
+  } timestamp_list;
 
-typedef struct reconnect_server {
-  grpc_tcp_server *tcp_server;
-  grpc_pollset pollset;
-  grpc_pollset *pollsets[1];
-  timestamp_list *head;
-  timestamp_list *tail;
-  char *peer;
-} reconnect_server;
+  typedef struct reconnect_server
+  {
+    grpc_tcp_server *tcp_server;
+    grpc_pollset pollset;
+    grpc_pollset *pollsets[1];
+    timestamp_list *head;
+    timestamp_list *tail;
+    char *peer;
+  } reconnect_server;
 
-void reconnect_server_init(reconnect_server *server);
-void reconnect_server_start(reconnect_server *server, int port);
-void reconnect_server_poll(reconnect_server *server, int seconds);
-void reconnect_server_destroy(reconnect_server *server);
-void reconnect_server_clear_timestamps(reconnect_server *server);
+  void reconnect_server_init (reconnect_server * server);
+  void reconnect_server_start (reconnect_server * server, int port);
+  void reconnect_server_poll (reconnect_server * server, int seconds);
+  void reconnect_server_destroy (reconnect_server * server);
+  void reconnect_server_clear_timestamps (reconnect_server * server);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* GRPC_TEST_CORE_UTIL_RECONNECT_SERVER_H */
+#endif				/* GRPC_TEST_CORE_UTIL_RECONNECT_SERVER_H */
diff --git a/test/core/util/slice_splitter.c b/test/core/util/slice_splitter.c
index 0f05072e50..f0282c0aaa 100644
--- a/test/core/util/slice_splitter.c
+++ b/test/core/util/slice_splitter.c
@@ -38,101 +38,114 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/useful.h>
 
-const char *grpc_slice_split_mode_name(grpc_slice_split_mode mode) {
-  switch (mode) {
+const char *
+grpc_slice_split_mode_name (grpc_slice_split_mode mode)
+{
+  switch (mode)
+    {
     case GRPC_SLICE_SPLIT_IDENTITY:
       return "identity";
     case GRPC_SLICE_SPLIT_MERGE_ALL:
       return "merge_all";
     case GRPC_SLICE_SPLIT_ONE_BYTE:
       return "one_byte";
-  }
+    }
   return "error";
 }
 
-void grpc_split_slices(grpc_slice_split_mode mode, gpr_slice *src_slices,
-                       size_t src_slice_count, gpr_slice **dst_slices,
-                       size_t *dst_slice_count) {
+void
+grpc_split_slices (grpc_slice_split_mode mode, gpr_slice * src_slices, size_t src_slice_count, gpr_slice ** dst_slices, size_t * dst_slice_count)
+{
   size_t i, j;
   size_t length;
 
-  switch (mode) {
+  switch (mode)
+    {
     case GRPC_SLICE_SPLIT_IDENTITY:
       *dst_slice_count = src_slice_count;
-      *dst_slices = gpr_malloc(sizeof(gpr_slice) * src_slice_count);
-      for (i = 0; i < src_slice_count; i++) {
-        (*dst_slices)[i] = src_slices[i];
-        gpr_slice_ref((*dst_slices)[i]);
-      }
+      *dst_slices = gpr_malloc (sizeof (gpr_slice) * src_slice_count);
+      for (i = 0; i < src_slice_count; i++)
+	{
+	  (*dst_slices)[i] = src_slices[i];
+	  gpr_slice_ref ((*dst_slices)[i]);
+	}
       break;
     case GRPC_SLICE_SPLIT_MERGE_ALL:
       *dst_slice_count = 1;
       length = 0;
-      for (i = 0; i < src_slice_count; i++) {
-        length += GPR_SLICE_LENGTH(src_slices[i]);
-      }
-      *dst_slices = gpr_malloc(sizeof(gpr_slice));
-      **dst_slices = gpr_slice_malloc(length);
+      for (i = 0; i < src_slice_count; i++)
+	{
+	  length += GPR_SLICE_LENGTH (src_slices[i]);
+	}
+      *dst_slices = gpr_malloc (sizeof (gpr_slice));
+      **dst_slices = gpr_slice_malloc (length);
       length = 0;
-      for (i = 0; i < src_slice_count; i++) {
-        memcpy(GPR_SLICE_START_PTR(**dst_slices) + length,
-               GPR_SLICE_START_PTR(src_slices[i]),
-               GPR_SLICE_LENGTH(src_slices[i]));
-        length += GPR_SLICE_LENGTH(src_slices[i]);
-      }
+      for (i = 0; i < src_slice_count; i++)
+	{
+	  memcpy (GPR_SLICE_START_PTR (**dst_slices) + length, GPR_SLICE_START_PTR (src_slices[i]), GPR_SLICE_LENGTH (src_slices[i]));
+	  length += GPR_SLICE_LENGTH (src_slices[i]);
+	}
       break;
     case GRPC_SLICE_SPLIT_ONE_BYTE:
       length = 0;
-      for (i = 0; i < src_slice_count; i++) {
-        length += GPR_SLICE_LENGTH(src_slices[i]);
-      }
+      for (i = 0; i < src_slice_count; i++)
+	{
+	  length += GPR_SLICE_LENGTH (src_slices[i]);
+	}
       *dst_slice_count = length;
-      *dst_slices = gpr_malloc(sizeof(gpr_slice) * length);
+      *dst_slices = gpr_malloc (sizeof (gpr_slice) * length);
       length = 0;
-      for (i = 0; i < src_slice_count; i++) {
-        for (j = 0; j < GPR_SLICE_LENGTH(src_slices[i]); j++) {
-          (*dst_slices)[length] = gpr_slice_sub(src_slices[i], j, j + 1);
-          length++;
-        }
-      }
+      for (i = 0; i < src_slice_count; i++)
+	{
+	  for (j = 0; j < GPR_SLICE_LENGTH (src_slices[i]); j++)
+	    {
+	      (*dst_slices)[length] = gpr_slice_sub (src_slices[i], j, j + 1);
+	      length++;
+	    }
+	}
       break;
-  }
+    }
 }
 
-void grpc_split_slices_to_buffer(grpc_slice_split_mode mode,
-                                 gpr_slice *src_slices, size_t src_slice_count,
-                                 gpr_slice_buffer *dst) {
+void
+grpc_split_slices_to_buffer (grpc_slice_split_mode mode, gpr_slice * src_slices, size_t src_slice_count, gpr_slice_buffer * dst)
+{
   gpr_slice *slices;
   size_t nslices;
   size_t i;
-  grpc_split_slices(mode, src_slices, src_slice_count, &slices, &nslices);
-  for (i = 0; i < nslices; i++) {
-    /* add indexed to avoid re-merging split slices */
-    gpr_slice_buffer_add_indexed(dst, slices[i]);
-  }
-  gpr_free(slices);
+  grpc_split_slices (mode, src_slices, src_slice_count, &slices, &nslices);
+  for (i = 0; i < nslices; i++)
+    {
+      /* add indexed to avoid re-merging split slices */
+      gpr_slice_buffer_add_indexed (dst, slices[i]);
+    }
+  gpr_free (slices);
 }
 
-void grpc_split_slice_buffer(grpc_slice_split_mode mode, gpr_slice_buffer *src,
-                             gpr_slice_buffer *dst) {
-  grpc_split_slices_to_buffer(mode, src->slices, src->count, dst);
+void
+grpc_split_slice_buffer (grpc_slice_split_mode mode, gpr_slice_buffer * src, gpr_slice_buffer * dst)
+{
+  grpc_split_slices_to_buffer (mode, src->slices, src->count, dst);
 }
 
-gpr_slice grpc_slice_merge(gpr_slice *slices, size_t nslices) {
+gpr_slice
+grpc_slice_merge (gpr_slice * slices, size_t nslices)
+{
   gpr_uint8 *out = NULL;
   size_t length = 0;
   size_t capacity = 0;
   size_t i;
 
-  for (i = 0; i < nslices; i++) {
-    if (GPR_SLICE_LENGTH(slices[i]) + length > capacity) {
-      capacity = GPR_MAX(capacity * 2, GPR_SLICE_LENGTH(slices[i]) + length);
-      out = gpr_realloc(out, capacity);
+  for (i = 0; i < nslices; i++)
+    {
+      if (GPR_SLICE_LENGTH (slices[i]) + length > capacity)
+	{
+	  capacity = GPR_MAX (capacity * 2, GPR_SLICE_LENGTH (slices[i]) + length);
+	  out = gpr_realloc (out, capacity);
+	}
+      memcpy (out + length, GPR_SLICE_START_PTR (slices[i]), GPR_SLICE_LENGTH (slices[i]));
+      length += GPR_SLICE_LENGTH (slices[i]);
     }
-    memcpy(out + length, GPR_SLICE_START_PTR(slices[i]),
-           GPR_SLICE_LENGTH(slices[i]));
-    length += GPR_SLICE_LENGTH(slices[i]);
-  }
 
-  return gpr_slice_new(out, length, gpr_free);
+  return gpr_slice_new (out, length, gpr_free);
 }
diff --git a/test/core/util/slice_splitter.h b/test/core/util/slice_splitter.h
index d030c2cb55..992001730c 100644
--- a/test/core/util/slice_splitter.h
+++ b/test/core/util/slice_splitter.h
@@ -40,7 +40,8 @@
 #include <grpc/support/slice.h>
 #include <grpc/support/slice_buffer.h>
 
-typedef enum {
+typedef enum
+{
   /* merge all input slices into a single slice */
   GRPC_SLICE_SPLIT_MERGE_ALL,
   /* leave slices as is */
@@ -51,18 +52,13 @@ typedef enum {
 
 /* allocates *dst_slices; caller must unref all slices in dst_slices then free
    it */
-void grpc_split_slices(grpc_slice_split_mode mode, gpr_slice *src_slices,
-                       size_t src_slice_count, gpr_slice **dst_slices,
-                       size_t *dst_slice_count);
+void grpc_split_slices (grpc_slice_split_mode mode, gpr_slice * src_slices, size_t src_slice_count, gpr_slice ** dst_slices, size_t * dst_slice_count);
 
-void grpc_split_slices_to_buffer(grpc_slice_split_mode mode,
-                                 gpr_slice *src_slices, size_t src_slice_count,
-                                 gpr_slice_buffer *dst);
-void grpc_split_slice_buffer(grpc_slice_split_mode mode, gpr_slice_buffer *src,
-                             gpr_slice_buffer *dst);
+void grpc_split_slices_to_buffer (grpc_slice_split_mode mode, gpr_slice * src_slices, size_t src_slice_count, gpr_slice_buffer * dst);
+void grpc_split_slice_buffer (grpc_slice_split_mode mode, gpr_slice_buffer * src, gpr_slice_buffer * dst);
 
-gpr_slice grpc_slice_merge(gpr_slice *slices, size_t nslices);
+gpr_slice grpc_slice_merge (gpr_slice * slices, size_t nslices);
 
-const char *grpc_slice_split_mode_name(grpc_slice_split_mode mode);
+const char *grpc_slice_split_mode_name (grpc_slice_split_mode mode);
 
 #endif /* GRPC_TEST_CORE_UTIL_SLICE_SPLITTER_H */
diff --git a/test/core/util/test_config.c b/test/core/util/test_config.c
index f5d5cdb57c..eb2ff22c8b 100644
--- a/test/core/util/test_config.c
+++ b/test/core/util/test_config.c
@@ -42,58 +42,81 @@ double g_fixture_slowdown_factor = 1.0;
 
 #if GPR_GETPID_IN_UNISTD_H
 #include <unistd.h>
-static unsigned seed(void) { return (unsigned)getpid(); }
+static unsigned
+seed (void)
+{
+  return (unsigned) getpid ();
+}
 #endif
 
 #if GPR_GETPID_IN_PROCESS_H
 #include <process.h>
-static unsigned seed(void) { return _getpid(); }
+static unsigned
+seed (void)
+{
+  return _getpid ();
+}
 #endif
 
 #if GPR_WINDOWS_CRASH_HANDLER
-LONG crash_handler(struct _EXCEPTION_POINTERS* ex_info) {
-  gpr_log(GPR_DEBUG, "Exception handler called, dumping information");
-  while (ex_info->ExceptionRecord) {
-    DWORD code = ex_info->ExceptionRecord->ExceptionCode;
-    DWORD flgs = ex_info->ExceptionRecord->ExceptionFlags;
-    PVOID addr = ex_info->ExceptionRecord->ExceptionAddress;
-    gpr_log("code: %x - flags: %d - address: %p", code, flgs, addr);
-    ex_info->ExceptionRecord = ex_info->ExceptionRecord->ExceptionRecord;
-  }
-  if (IsDebuggerPresent()) {
-    __debugbreak();
-  } else {
-    _exit(1);
-  }
+LONG
+crash_handler (struct _EXCEPTION_POINTERS * ex_info)
+{
+  gpr_log (GPR_DEBUG, "Exception handler called, dumping information");
+  while (ex_info->ExceptionRecord)
+    {
+      DWORD code = ex_info->ExceptionRecord->ExceptionCode;
+      DWORD flgs = ex_info->ExceptionRecord->ExceptionFlags;
+      PVOID addr = ex_info->ExceptionRecord->ExceptionAddress;
+      gpr_log ("code: %x - flags: %d - address: %p", code, flgs, addr);
+      ex_info->ExceptionRecord = ex_info->ExceptionRecord->ExceptionRecord;
+    }
+  if (IsDebuggerPresent ())
+    {
+      __debugbreak ();
+    }
+  else
+    {
+      _exit (1);
+    }
   return EXCEPTION_EXECUTE_HANDLER;
 }
 
-void abort_handler(int sig) {
-  gpr_log(GPR_DEBUG, "Abort handler called.");
-  if (IsDebuggerPresent()) {
-    __debugbreak();
-  } else {
-    _exit(1);
-  }
+void
+abort_handler (int sig)
+{
+  gpr_log (GPR_DEBUG, "Abort handler called.");
+  if (IsDebuggerPresent ())
+    {
+      __debugbreak ();
+    }
+  else
+    {
+      _exit (1);
+    }
 }
 
-static void install_crash_handler() {
-  SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)crash_handler);
-  _set_abort_behavior(0, _WRITE_ABORT_MSG);
-  _set_abort_behavior(0, _CALL_REPORTFAULT);
-  signal(SIGABRT, abort_handler);
+static void
+install_crash_handler ()
+{
+  SetUnhandledExceptionFilter ((LPTOP_LEVEL_EXCEPTION_FILTER) crash_handler);
+  _set_abort_behavior (0, _WRITE_ABORT_MSG);
+  _set_abort_behavior (0, _CALL_REPORTFAULT);
+  signal (SIGABRT, abort_handler);
 }
 #else
-static void install_crash_handler() {}
+static void
+install_crash_handler ()
+{
+}
 #endif
 
-void grpc_test_init(int argc, char** argv) {
-  install_crash_handler();
-  gpr_log(GPR_DEBUG, "test slowdown: machine=%f build=%f total=%f",
-          (double)GRPC_TEST_SLOWDOWN_MACHINE_FACTOR,
-          (double)GRPC_TEST_SLOWDOWN_BUILD_FACTOR,
-          (double)GRPC_TEST_SLOWDOWN_FACTOR);
+void
+grpc_test_init (int argc, char **argv)
+{
+  install_crash_handler ();
+  gpr_log (GPR_DEBUG, "test slowdown: machine=%f build=%f total=%f", (double) GRPC_TEST_SLOWDOWN_MACHINE_FACTOR, (double) GRPC_TEST_SLOWDOWN_BUILD_FACTOR, (double) GRPC_TEST_SLOWDOWN_FACTOR);
   /* seed rng with pid, so we don't end up with the same random numbers as a
      concurrently running test binary */
-  srand(seed());
+  srand (seed ());
 }
diff --git a/test/core/util/test_config.h b/test/core/util/test_config.h
index 15b71747fb..05057b9893 100644
--- a/test/core/util/test_config.h
+++ b/test/core/util/test_config.h
@@ -37,8 +37,9 @@
 #include <grpc/support/time.h>
 
 #ifdef __cplusplus
-extern "C" {
-#endif /*  __cplusplus */
+extern "C"
+{
+#endif				/*  __cplusplus */
 
 #ifndef GRPC_TEST_SLOWDOWN_BUILD_FACTOR
 #define GRPC_TEST_SLOWDOWN_BUILD_FACTOR 1.0
@@ -48,7 +49,7 @@ extern "C" {
 #define GRPC_TEST_SLOWDOWN_MACHINE_FACTOR 1.0
 #endif
 
-extern double g_fixture_slowdown_factor;
+  extern double g_fixture_slowdown_factor;
 
 #define GRPC_TEST_SLOWDOWN_FACTOR                                        \
   (GRPC_TEST_SLOWDOWN_BUILD_FACTOR * GRPC_TEST_SLOWDOWN_MACHINE_FACTOR * \
@@ -70,10 +71,10 @@ extern double g_fixture_slowdown_factor;
 #define GRPC_TEST_PICK_PORT
 #endif
 
-void grpc_test_init(int argc, char **argv);
+  void grpc_test_init (int argc, char **argv);
 
 #ifdef __cplusplus
 }
-#endif /*  __cplusplus */
+#endif				/*  __cplusplus */
 
-#endif /* GRPC_TEST_CORE_UTIL_TEST_CONFIG_H */
+#endif				/* GRPC_TEST_CORE_UTIL_TEST_CONFIG_H */