diff --git a/test/core/end2end/tests/max_concurrent_streams.c b/test/core/end2end/tests/max_concurrent_streams.c
index 1d4ba32..87eb4dd 100644
--- a/test/core/end2end/tests/max_concurrent_streams.c
+++ b/test/core/end2end/tests/max_concurrent_streams.c
@@ -43,87 +43,65 @@
 #include <grpc/support/useful.h>
 #include "test/core/end2end/cq_verifier.h"
 
-enum
-{ TIMEOUT = 200000 };
+enum { TIMEOUT = 200000 };
 
-static void *
-tag (gpr_intptr t)
-{
-  return (void *) t;
-}
+static void *tag(gpr_intptr t) { return (void *)t; }
 
-static grpc_end2end_test_fixture
-begin_test (grpc_end2end_test_config config, const char *test_name, grpc_channel_args * client_args, grpc_channel_args * server_args)
-{
+static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
+                                            const char *test_name,
+                                            grpc_channel_args *client_args,
+                                            grpc_channel_args *server_args) {
   grpc_end2end_test_fixture f;
-  gpr_log (GPR_INFO, "%s/%s", test_name, config.name);
-  f = config.create_fixture (client_args, server_args);
-  config.init_client (&f, client_args);
-  config.init_server (&f, server_args);
+  gpr_log(GPR_INFO, "%s/%s", test_name, config.name);
+  f = config.create_fixture(client_args, server_args);
+  config.init_client(&f, client_args);
+  config.init_server(&f, server_args);
   return f;
 }
 
-static gpr_timespec
-n_seconds_time (int n)
-{
-  return GRPC_TIMEOUT_SECONDS_TO_DEADLINE (n);
+static gpr_timespec n_seconds_time(int n) {
+  return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n);
 }
 
-static gpr_timespec
-five_seconds_time (void)
-{
-  return n_seconds_time (5);
-}
+static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); }
 
-static void
-drain_cq (grpc_completion_queue * cq)
-{
+static void drain_cq(grpc_completion_queue *cq) {
   grpc_event ev;
-  do
-    {
-      ev = grpc_completion_queue_next (cq, five_seconds_time (), NULL);
-    }
-  while (ev.type != GRPC_QUEUE_SHUTDOWN);
+  do {
+    ev = grpc_completion_queue_next(cq, five_seconds_time(), NULL);
+  } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
-static void
-shutdown_server (grpc_end2end_test_fixture * f)
-{
-  if (!f->server)
-    return;
-  grpc_server_shutdown_and_notify (f->server, f->cq, tag (1000));
-  GPR_ASSERT (grpc_completion_queue_pluck (f->cq, tag (1000), GRPC_TIMEOUT_SECONDS_TO_DEADLINE (5), NULL).type == GRPC_OP_COMPLETE);
-  grpc_server_destroy (f->server);
+static void shutdown_server(grpc_end2end_test_fixture *f) {
+  if (!f->server) return;
+  grpc_server_shutdown_and_notify(f->server, f->cq, tag(1000));
+  GPR_ASSERT(grpc_completion_queue_pluck(
+                 f->cq, tag(1000), GRPC_TIMEOUT_SECONDS_TO_DEADLINE(5), NULL)
+                 .type == GRPC_OP_COMPLETE);
+  grpc_server_destroy(f->server);
   f->server = NULL;
 }
 
-static void
-shutdown_client (grpc_end2end_test_fixture * f)
-{
-  if (!f->client)
-    return;
-  grpc_channel_destroy (f->client);
+static void shutdown_client(grpc_end2end_test_fixture *f) {
+  if (!f->client) return;
+  grpc_channel_destroy(f->client);
   f->client = NULL;
 }
 
-static void
-end_test (grpc_end2end_test_fixture * f)
-{
-  shutdown_server (f);
-  shutdown_client (f);
+static void end_test(grpc_end2end_test_fixture *f) {
+  shutdown_server(f);
+  shutdown_client(f);
 
-  grpc_completion_queue_shutdown (f->cq);
-  drain_cq (f->cq);
-  grpc_completion_queue_destroy (f->cq);
+  grpc_completion_queue_shutdown(f->cq);
+  drain_cq(f->cq);
+  grpc_completion_queue_destroy(f->cq);
 }
 
-static void
-simple_request_body (grpc_end2end_test_fixture f)
-{
+static void simple_request_body(grpc_end2end_test_fixture f) {
   grpc_call *c;
   grpc_call *s;
-  gpr_timespec deadline = five_seconds_time ();
-  cq_verifier *cqv = cq_verifier_create (f.cq);
+  gpr_timespec deadline = five_seconds_time();
+  cq_verifier *cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
   grpc_op *op;
   grpc_metadata_array initial_metadata_recv;
@@ -136,13 +114,15 @@
   size_t details_capacity = 0;
   int was_cancelled = 2;
 
-  c = grpc_channel_create_call (f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, "/foo", "foo.test.google.fr:1234", deadline, NULL);
-  GPR_ASSERT (c);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr:1234", deadline,
+                               NULL);
+  GPR_ASSERT(c);
 
-  grpc_metadata_array_init (&initial_metadata_recv);
-  grpc_metadata_array_init (&trailing_metadata_recv);
-  grpc_metadata_array_init (&request_metadata_recv);
-  grpc_call_details_init (&call_details);
+  grpc_metadata_array_init(&initial_metadata_recv);
+  grpc_metadata_array_init(&trailing_metadata_recv);
+  grpc_metadata_array_init(&request_metadata_recv);
+  grpc_call_details_init(&call_details);
 
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
@@ -167,13 +147,15 @@
   op->flags = 0;
   op->reserved = NULL;
   op++;
-  error = grpc_call_start_batch (c, ops, (size_t) (op - ops), tag (1), NULL);
-  GPR_ASSERT (GRPC_CALL_OK == error);
+  error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
+  GPR_ASSERT(GRPC_CALL_OK == error);
 
-  error = grpc_server_request_call (f.server, &s, &call_details, &request_metadata_recv, f.cq, f.cq, tag (101));
-  GPR_ASSERT (GRPC_CALL_OK == error);
-  cq_expect_completion (cqv, tag (101), 1);
-  cq_verify (cqv);
+  error =
+      grpc_server_request_call(f.server, &s, &call_details,
+                               &request_metadata_recv, f.cq, f.cq, tag(101));
+  GPR_ASSERT(GRPC_CALL_OK == error);
+  cq_expect_completion(cqv, tag(101), 1);
+  cq_verify(cqv);
 
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
@@ -193,34 +175,32 @@
   op->flags = 0;
   op->reserved = NULL;
   op++;
-  error = grpc_call_start_batch (s, ops, (size_t) (op - ops), tag (102), NULL);
-  GPR_ASSERT (GRPC_CALL_OK == error);
+  error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
+  GPR_ASSERT(GRPC_CALL_OK == error);
 
-  cq_expect_completion (cqv, tag (102), 1);
-  cq_expect_completion (cqv, tag (1), 1);
-  cq_verify (cqv);
+  cq_expect_completion(cqv, tag(102), 1);
+  cq_expect_completion(cqv, tag(1), 1);
+  cq_verify(cqv);
 
-  GPR_ASSERT (status == GRPC_STATUS_UNIMPLEMENTED);
-  GPR_ASSERT (0 == strcmp (details, "xyz"));
-  GPR_ASSERT (0 == strcmp (call_details.method, "/foo"));
-  GPR_ASSERT (0 == strcmp (call_details.host, "foo.test.google.fr:1234"));
-  GPR_ASSERT (was_cancelled == 1);
+  GPR_ASSERT(status == GRPC_STATUS_UNIMPLEMENTED);
+  GPR_ASSERT(0 == strcmp(details, "xyz"));
+  GPR_ASSERT(0 == strcmp(call_details.method, "/foo"));
+  GPR_ASSERT(0 == strcmp(call_details.host, "foo.test.google.fr:1234"));
+  GPR_ASSERT(was_cancelled == 1);
 
-  gpr_free (details);
-  grpc_metadata_array_destroy (&initial_metadata_recv);
-  grpc_metadata_array_destroy (&trailing_metadata_recv);
-  grpc_metadata_array_destroy (&request_metadata_recv);
-  grpc_call_details_destroy (&call_details);
+  gpr_free(details);
+  grpc_metadata_array_destroy(&initial_metadata_recv);
+  grpc_metadata_array_destroy(&trailing_metadata_recv);
+  grpc_metadata_array_destroy(&request_metadata_recv);
+  grpc_call_details_destroy(&call_details);
 
-  grpc_call_destroy (c);
-  grpc_call_destroy (s);
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
 
-  cq_verifier_destroy (cqv);
+  cq_verifier_destroy(cqv);
 }
 
-static void
-test_max_concurrent_streams (grpc_end2end_test_config config)
-{
+static void test_max_concurrent_streams(grpc_end2end_test_config config) {
   grpc_end2end_test_fixture f;
   grpc_arg server_arg;
   grpc_channel_args server_args;
@@ -258,31 +238,37 @@
   server_args.num_args = 1;
   server_args.args = &server_arg;
 
-  f = begin_test (config, "test_max_concurrent_streams", NULL, &server_args);
-  cqv = cq_verifier_create (f.cq);
+  f = begin_test(config, "test_max_concurrent_streams", NULL, &server_args);
+  cqv = cq_verifier_create(f.cq);
 
-  grpc_metadata_array_init (&request_metadata_recv);
-  grpc_metadata_array_init (&initial_metadata_recv1);
-  grpc_metadata_array_init (&trailing_metadata_recv1);
-  grpc_metadata_array_init (&initial_metadata_recv2);
-  grpc_metadata_array_init (&trailing_metadata_recv2);
-  grpc_call_details_init (&call_details);
+  grpc_metadata_array_init(&request_metadata_recv);
+  grpc_metadata_array_init(&initial_metadata_recv1);
+  grpc_metadata_array_init(&trailing_metadata_recv1);
+  grpc_metadata_array_init(&initial_metadata_recv2);
+  grpc_metadata_array_init(&trailing_metadata_recv2);
+  grpc_call_details_init(&call_details);
 
   /* perform a ping-pong to ensure that settings have had a chance to round
      trip */
-  simple_request_body (f);
+  simple_request_body(f);
   /* perform another one to make sure that the one stream case still works */
-  simple_request_body (f);
+  simple_request_body(f);
 
   /* start two requests - ensuring that the second is not accepted until
      the first completes */
-  deadline = n_seconds_time (1000);
-  c1 = grpc_channel_create_call (f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, "/alpha", "foo.test.google.fr:1234", deadline, NULL);
-  GPR_ASSERT (c1);
-  c2 = grpc_channel_create_call (f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, "/beta", "foo.test.google.fr:1234", deadline, NULL);
-  GPR_ASSERT (c2);
+  deadline = n_seconds_time(1000);
+  c1 = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                                "/alpha", "foo.test.google.fr:1234", deadline,
+                                NULL);
+  GPR_ASSERT(c1);
+  c2 = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                                "/beta", "foo.test.google.fr:1234", deadline,
+                                NULL);
+  GPR_ASSERT(c2);
 
-  GPR_ASSERT (GRPC_CALL_OK == grpc_server_request_call (f.server, &s1, &call_details, &request_metadata_recv, f.cq, f.cq, tag (101)));
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(
+                                 f.server, &s1, &call_details,
+                                 &request_metadata_recv, f.cq, f.cq, tag(101)));
 
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
@@ -294,8 +280,8 @@
   op->flags = 0;
   op->reserved = NULL;
   op++;
-  error = grpc_call_start_batch (c1, ops, (size_t) (op - ops), tag (301), NULL);
-  GPR_ASSERT (GRPC_CALL_OK == error);
+  error = grpc_call_start_batch(c1, ops, (size_t)(op - ops), tag(301), NULL);
+  GPR_ASSERT(GRPC_CALL_OK == error);
 
   op = ops;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
@@ -311,8 +297,8 @@
   op->flags = 0;
   op->reserved = NULL;
   op++;
-  error = grpc_call_start_batch (c1, ops, (size_t) (op - ops), tag (302), NULL);
-  GPR_ASSERT (GRPC_CALL_OK == error);
+  error = grpc_call_start_batch(c1, ops, (size_t)(op - ops), tag(302), NULL);
+  GPR_ASSERT(GRPC_CALL_OK == error);
 
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
@@ -324,8 +310,8 @@
   op->flags = 0;
   op->reserved = NULL;
   op++;
-  error = grpc_call_start_batch (c2, ops, (size_t) (op - ops), tag (401), NULL);
-  GPR_ASSERT (GRPC_CALL_OK == error);
+  error = grpc_call_start_batch(c2, ops, (size_t)(op - ops), tag(401), NULL);
+  GPR_ASSERT(GRPC_CALL_OK == error);
 
   op = ops;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
@@ -341,35 +327,32 @@
   op->flags = 0;
   op->reserved = NULL;
   op++;
-  error = grpc_call_start_batch (c2, ops, (size_t) (op - ops), tag (402), NULL);
-  GPR_ASSERT (GRPC_CALL_OK == error);
+  error = grpc_call_start_batch(c2, ops, (size_t)(op - ops), tag(402), NULL);
+  GPR_ASSERT(GRPC_CALL_OK == error);
 
   got_client_start = 0;
   got_server_start = 0;
   live_call = -1;
-  while (!got_client_start || !got_server_start)
-    {
-      ev = grpc_completion_queue_next (f.cq, GRPC_TIMEOUT_SECONDS_TO_DEADLINE (3), NULL);
-      GPR_ASSERT (ev.type == GRPC_OP_COMPLETE);
-      GPR_ASSERT (ev.success);
-      if (ev.tag == tag (101))
-	{
-	  GPR_ASSERT (!got_server_start);
-	  got_server_start = 1;
-	}
-      else
-	{
-	  GPR_ASSERT (!got_client_start);
-	  GPR_ASSERT (ev.tag == tag (301) || ev.tag == tag (401));
-	  /* The /alpha or /beta calls started above could be invoked (but NOT
-	   * both);
-	   * check this here */
-	  /* We'll get tag 303 or 403, we want 300, 400 */
-	  live_call = ((int) (gpr_intptr) ev.tag) - 1;
-	  got_client_start = 1;
-	}
+  while (!got_client_start || !got_server_start) {
+    ev = grpc_completion_queue_next(f.cq, GRPC_TIMEOUT_SECONDS_TO_DEADLINE(3),
+                                    NULL);
+    GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
+    GPR_ASSERT(ev.success);
+    if (ev.tag == tag(101)) {
+      GPR_ASSERT(!got_server_start);
+      got_server_start = 1;
+    } else {
+      GPR_ASSERT(!got_client_start);
+      GPR_ASSERT(ev.tag == tag(301) || ev.tag == tag(401));
+      /* The /alpha or /beta calls started above could be invoked (but NOT
+       * both);
+       * check this here */
+      /* We'll get tag 303 or 403, we want 300, 400 */
+      live_call = ((int)(gpr_intptr)ev.tag) - 1;
+      got_client_start = 1;
     }
-  GPR_ASSERT (live_call == 300 || live_call == 400);
+  }
+  GPR_ASSERT(live_call == 300 || live_call == 400);
 
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
@@ -389,19 +372,21 @@
   op->flags = 0;
   op->reserved = NULL;
   op++;
-  error = grpc_call_start_batch (s1, ops, (size_t) (op - ops), tag (102), NULL);
-  GPR_ASSERT (GRPC_CALL_OK == error);
+  error = grpc_call_start_batch(s1, ops, (size_t)(op - ops), tag(102), NULL);
+  GPR_ASSERT(GRPC_CALL_OK == error);
 
-  cq_expect_completion (cqv, tag (102), 1);
-  cq_expect_completion (cqv, tag (live_call + 2), 1);
+  cq_expect_completion(cqv, tag(102), 1);
+  cq_expect_completion(cqv, tag(live_call + 2), 1);
   /* first request is finished, we should be able to start the second */
   live_call = (live_call == 300) ? 400 : 300;
-  cq_expect_completion (cqv, tag (live_call + 1), 1);
-  cq_verify (cqv);
+  cq_expect_completion(cqv, tag(live_call + 1), 1);
+  cq_verify(cqv);
 
-  GPR_ASSERT (GRPC_CALL_OK == grpc_server_request_call (f.server, &s2, &call_details, &request_metadata_recv, f.cq, f.cq, tag (201)));
-  cq_expect_completion (cqv, tag (201), 1);
-  cq_verify (cqv);
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(
+                                 f.server, &s2, &call_details,
+                                 &request_metadata_recv, f.cq, f.cq, tag(201)));
+  cq_expect_completion(cqv, tag(201), 1);
+  cq_verify(cqv);
 
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
@@ -421,35 +406,33 @@
   op->flags = 0;
   op->reserved = NULL;
   op++;
-  error = grpc_call_start_batch (s2, ops, (size_t) (op - ops), tag (202), NULL);
-  GPR_ASSERT (GRPC_CALL_OK == error);
+  error = grpc_call_start_batch(s2, ops, (size_t)(op - ops), tag(202), NULL);
+  GPR_ASSERT(GRPC_CALL_OK == error);
 
-  cq_expect_completion (cqv, tag (live_call + 2), 1);
-  cq_expect_completion (cqv, tag (202), 1);
-  cq_verify (cqv);
+  cq_expect_completion(cqv, tag(live_call + 2), 1);
+  cq_expect_completion(cqv, tag(202), 1);
+  cq_verify(cqv);
 
-  cq_verifier_destroy (cqv);
+  cq_verifier_destroy(cqv);
 
-  grpc_call_destroy (c1);
-  grpc_call_destroy (s1);
-  grpc_call_destroy (c2);
-  grpc_call_destroy (s2);
+  grpc_call_destroy(c1);
+  grpc_call_destroy(s1);
+  grpc_call_destroy(c2);
+  grpc_call_destroy(s2);
 
-  gpr_free (details1);
-  gpr_free (details2);
-  grpc_metadata_array_destroy (&initial_metadata_recv1);
-  grpc_metadata_array_destroy (&trailing_metadata_recv1);
-  grpc_metadata_array_destroy (&initial_metadata_recv2);
-  grpc_metadata_array_destroy (&trailing_metadata_recv2);
-  grpc_metadata_array_destroy (&request_metadata_recv);
-  grpc_call_details_destroy (&call_details);
+  gpr_free(details1);
+  gpr_free(details2);
+  grpc_metadata_array_destroy(&initial_metadata_recv1);
+  grpc_metadata_array_destroy(&trailing_metadata_recv1);
+  grpc_metadata_array_destroy(&initial_metadata_recv2);
+  grpc_metadata_array_destroy(&trailing_metadata_recv2);
+  grpc_metadata_array_destroy(&request_metadata_recv);
+  grpc_call_details_destroy(&call_details);
 
-  end_test (&f);
-  config.tear_down_data (&f);
+  end_test(&f);
+  config.tear_down_data(&f);
 }
 
-void
-grpc_end2end_tests (grpc_end2end_test_config config)
-{
-  test_max_concurrent_streams (config);
+void grpc_end2end_tests(grpc_end2end_test_config config) {
+  test_max_concurrent_streams(config);
 }