indent pass to get logical source lines on one physical line

4 files changed, 403 insertions, 346 deletions

diff --git a/test/core/surface/byte_buffer_reader_test.c b/test/core/surface/byte_buffer_reader_test.c
index 560e0ac7b2..dd56ba86e4 100644
--- a/test/core/surface/byte_buffer_reader_test.c
+++ b/test/core/surface/byte_buffer_reader_test.c
@@ -48,72 +48,79 @@
 
 #define LOG_TEST(x) gpr_log(GPR_INFO, "%s", x)
 
-static void test_read_one_slice(void) {
+static void
+test_read_one_slice (void)
+{
   gpr_slice slice;
   grpc_byte_buffer *buffer;
   grpc_byte_buffer_reader reader;
   gpr_slice first_slice, second_slice;
   int first_code, second_code;
 
-  LOG_TEST("test_read_one_slice");
-  slice = gpr_slice_from_copied_string("test");
-  buffer = grpc_raw_byte_buffer_create(&slice, 1);
-  gpr_slice_unref(slice);
-  grpc_byte_buffer_reader_init(&reader, buffer);
-  first_code = grpc_byte_buffer_reader_next(&reader, &first_slice);
-  GPR_ASSERT(first_code != 0);
-  GPR_ASSERT(memcmp(GPR_SLICE_START_PTR(first_slice), "test", 4) == 0);
-  gpr_slice_unref(first_slice);
-  second_code = grpc_byte_buffer_reader_next(&reader, &second_slice);
-  GPR_ASSERT(second_code == 0);
-  grpc_byte_buffer_destroy(buffer);
+  LOG_TEST ("test_read_one_slice");
+  slice = gpr_slice_from_copied_string ("test");
+  buffer = grpc_raw_byte_buffer_create (&slice, 1);
+  gpr_slice_unref (slice);
+  grpc_byte_buffer_reader_init (&reader, buffer);
+  first_code = grpc_byte_buffer_reader_next (&reader, &first_slice);
+  GPR_ASSERT (first_code != 0);
+  GPR_ASSERT (memcmp (GPR_SLICE_START_PTR (first_slice), "test", 4) == 0);
+  gpr_slice_unref (first_slice);
+  second_code = grpc_byte_buffer_reader_next (&reader, &second_slice);
+  GPR_ASSERT (second_code == 0);
+  grpc_byte_buffer_destroy (buffer);
 }
 
-static void test_read_one_slice_malloc(void) {
+static void
+test_read_one_slice_malloc (void)
+{
   gpr_slice slice;
   grpc_byte_buffer *buffer;
   grpc_byte_buffer_reader reader;
   gpr_slice first_slice, second_slice;
   int first_code, second_code;
 
-  LOG_TEST("test_read_one_slice_malloc");
-  slice = gpr_slice_malloc(4);
-  memcpy(GPR_SLICE_START_PTR(slice), "test", 4);
-  buffer = grpc_raw_byte_buffer_create(&slice, 1);
-  gpr_slice_unref(slice);
-  grpc_byte_buffer_reader_init(&reader, buffer);
-  first_code = grpc_byte_buffer_reader_next(&reader, &first_slice);
-  GPR_ASSERT(first_code != 0);
-  GPR_ASSERT(memcmp(GPR_SLICE_START_PTR(first_slice), "test", 4) == 0);
-  gpr_slice_unref(first_slice);
-  second_code = grpc_byte_buffer_reader_next(&reader, &second_slice);
-  GPR_ASSERT(second_code == 0);
-  grpc_byte_buffer_destroy(buffer);
+  LOG_TEST ("test_read_one_slice_malloc");
+  slice = gpr_slice_malloc (4);
+  memcpy (GPR_SLICE_START_PTR (slice), "test", 4);
+  buffer = grpc_raw_byte_buffer_create (&slice, 1);
+  gpr_slice_unref (slice);
+  grpc_byte_buffer_reader_init (&reader, buffer);
+  first_code = grpc_byte_buffer_reader_next (&reader, &first_slice);
+  GPR_ASSERT (first_code != 0);
+  GPR_ASSERT (memcmp (GPR_SLICE_START_PTR (first_slice), "test", 4) == 0);
+  gpr_slice_unref (first_slice);
+  second_code = grpc_byte_buffer_reader_next (&reader, &second_slice);
+  GPR_ASSERT (second_code == 0);
+  grpc_byte_buffer_destroy (buffer);
 }
 
-static void test_read_none_compressed_slice(void) {
+static void
+test_read_none_compressed_slice (void)
+{
   gpr_slice slice;
   grpc_byte_buffer *buffer;
   grpc_byte_buffer_reader reader;
   gpr_slice first_slice, second_slice;
   int first_code, second_code;
 
-  LOG_TEST("test_read_none_compressed_slice");
-  slice = gpr_slice_from_copied_string("test");
-  buffer = grpc_raw_byte_buffer_create(&slice, 1);
-  gpr_slice_unref(slice);
-  grpc_byte_buffer_reader_init(&reader, buffer);
-  first_code = grpc_byte_buffer_reader_next(&reader, &first_slice);
-  GPR_ASSERT(first_code != 0);
-  GPR_ASSERT(memcmp(GPR_SLICE_START_PTR(first_slice), "test", 4) == 0);
-  gpr_slice_unref(first_slice);
-  second_code = grpc_byte_buffer_reader_next(&reader, &second_slice);
-  GPR_ASSERT(second_code == 0);
-  grpc_byte_buffer_destroy(buffer);
+  LOG_TEST ("test_read_none_compressed_slice");
+  slice = gpr_slice_from_copied_string ("test");
+  buffer = grpc_raw_byte_buffer_create (&slice, 1);
+  gpr_slice_unref (slice);
+  grpc_byte_buffer_reader_init (&reader, buffer);
+  first_code = grpc_byte_buffer_reader_next (&reader, &first_slice);
+  GPR_ASSERT (first_code != 0);
+  GPR_ASSERT (memcmp (GPR_SLICE_START_PTR (first_slice), "test", 4) == 0);
+  gpr_slice_unref (first_slice);
+  second_code = grpc_byte_buffer_reader_next (&reader, &second_slice);
+  GPR_ASSERT (second_code == 0);
+  grpc_byte_buffer_destroy (buffer);
 }
 
-static void read_compressed_slice(grpc_compression_algorithm algorithm,
-                                  size_t input_size) {
+static void
+read_compressed_slice (grpc_compression_algorithm algorithm, size_t input_size)
+{
   gpr_slice input_slice;
   gpr_slice_buffer sliceb_in;
   gpr_slice_buffer sliceb_out;
@@ -122,76 +129,80 @@ static void read_compressed_slice(grpc_compression_algorithm algorithm,
   gpr_slice read_slice;
   size_t read_count = 0;
 
-  gpr_slice_buffer_init(&sliceb_in);
-  gpr_slice_buffer_init(&sliceb_out);
-
-  input_slice = gpr_slice_malloc(input_size);
-  memset(GPR_SLICE_START_PTR(input_slice), 'a', input_size);
-  gpr_slice_buffer_add(&sliceb_in, input_slice); /* takes ownership */
-  GPR_ASSERT(grpc_msg_compress(algorithm, &sliceb_in, &sliceb_out));
-
-  buffer = grpc_raw_compressed_byte_buffer_create(sliceb_out.slices,
-                                                  sliceb_out.count, algorithm);
-  grpc_byte_buffer_reader_init(&reader, buffer);
-
-  while (grpc_byte_buffer_reader_next(&reader, &read_slice)) {
-    GPR_ASSERT(memcmp(GPR_SLICE_START_PTR(read_slice),
-                      GPR_SLICE_START_PTR(input_slice) + read_count,
-                      GPR_SLICE_LENGTH(read_slice)) == 0);
-    read_count += GPR_SLICE_LENGTH(read_slice);
-    gpr_slice_unref(read_slice);
-  }
-  GPR_ASSERT(read_count == input_size);
-  grpc_byte_buffer_reader_destroy(&reader);
-  grpc_byte_buffer_destroy(buffer);
-  gpr_slice_buffer_destroy(&sliceb_out);
-  gpr_slice_buffer_destroy(&sliceb_in);
+  gpr_slice_buffer_init (&sliceb_in);
+  gpr_slice_buffer_init (&sliceb_out);
+
+  input_slice = gpr_slice_malloc (input_size);
+  memset (GPR_SLICE_START_PTR (input_slice), 'a', input_size);
+  gpr_slice_buffer_add (&sliceb_in, input_slice);	/* takes ownership */
+  GPR_ASSERT (grpc_msg_compress (algorithm, &sliceb_in, &sliceb_out));
+
+  buffer = grpc_raw_compressed_byte_buffer_create (sliceb_out.slices, sliceb_out.count, algorithm);
+  grpc_byte_buffer_reader_init (&reader, buffer);
+
+  while (grpc_byte_buffer_reader_next (&reader, &read_slice))
+    {
+      GPR_ASSERT (memcmp (GPR_SLICE_START_PTR (read_slice), GPR_SLICE_START_PTR (input_slice) + read_count, GPR_SLICE_LENGTH (read_slice)) == 0);
+      read_count += GPR_SLICE_LENGTH (read_slice);
+      gpr_slice_unref (read_slice);
+    }
+  GPR_ASSERT (read_count == input_size);
+  grpc_byte_buffer_reader_destroy (&reader);
+  grpc_byte_buffer_destroy (buffer);
+  gpr_slice_buffer_destroy (&sliceb_out);
+  gpr_slice_buffer_destroy (&sliceb_in);
 }
 
-static void test_read_gzip_compressed_slice(void) {
+static void
+test_read_gzip_compressed_slice (void)
+{
   const size_t INPUT_SIZE = 2048;
-  LOG_TEST("test_read_gzip_compressed_slice");
-  read_compressed_slice(GRPC_COMPRESS_GZIP, INPUT_SIZE);
+  LOG_TEST ("test_read_gzip_compressed_slice");
+  read_compressed_slice (GRPC_COMPRESS_GZIP, INPUT_SIZE);
 }
 
-static void test_read_deflate_compressed_slice(void) {
+static void
+test_read_deflate_compressed_slice (void)
+{
   const size_t INPUT_SIZE = 2048;
-  LOG_TEST("test_read_deflate_compressed_slice");
-  read_compressed_slice(GRPC_COMPRESS_DEFLATE, INPUT_SIZE);
+  LOG_TEST ("test_read_deflate_compressed_slice");
+  read_compressed_slice (GRPC_COMPRESS_DEFLATE, INPUT_SIZE);
 }
 
-static void test_byte_buffer_from_reader(void) {
+static void
+test_byte_buffer_from_reader (void)
+{
   gpr_slice slice;
   grpc_byte_buffer *buffer, *buffer_from_reader;
   grpc_byte_buffer_reader reader;
 
-  LOG_TEST("test_byte_buffer_from_reader");
-  slice = gpr_slice_malloc(4);
-  memcpy(GPR_SLICE_START_PTR(slice), "test", 4);
-  buffer = grpc_raw_byte_buffer_create(&slice, 1);
-  gpr_slice_unref(slice);
-  grpc_byte_buffer_reader_init(&reader, buffer);
-
-  buffer_from_reader = grpc_raw_byte_buffer_from_reader(&reader);
-  GPR_ASSERT(buffer->type == buffer_from_reader->type);
-  GPR_ASSERT(buffer_from_reader->data.raw.compression == GRPC_COMPRESS_NONE);
-  GPR_ASSERT(buffer_from_reader->data.raw.slice_buffer.count == 1);
-  GPR_ASSERT(memcmp(GPR_SLICE_START_PTR(
-                        buffer_from_reader->data.raw.slice_buffer.slices[0]),
-                    "test", 4) == 0);
-
-  grpc_byte_buffer_destroy(buffer);
-  grpc_byte_buffer_destroy(buffer_from_reader);
+  LOG_TEST ("test_byte_buffer_from_reader");
+  slice = gpr_slice_malloc (4);
+  memcpy (GPR_SLICE_START_PTR (slice), "test", 4);
+  buffer = grpc_raw_byte_buffer_create (&slice, 1);
+  gpr_slice_unref (slice);
+  grpc_byte_buffer_reader_init (&reader, buffer);
+
+  buffer_from_reader = grpc_raw_byte_buffer_from_reader (&reader);
+  GPR_ASSERT (buffer->type == buffer_from_reader->type);
+  GPR_ASSERT (buffer_from_reader->data.raw.compression == GRPC_COMPRESS_NONE);
+  GPR_ASSERT (buffer_from_reader->data.raw.slice_buffer.count == 1);
+  GPR_ASSERT (memcmp (GPR_SLICE_START_PTR (buffer_from_reader->data.raw.slice_buffer.slices[0]), "test", 4) == 0);
+
+  grpc_byte_buffer_destroy (buffer);
+  grpc_byte_buffer_destroy (buffer_from_reader);
 }
 
-int main(int argc, char **argv) {
-  grpc_test_init(argc, argv);
-  test_read_one_slice();
-  test_read_one_slice_malloc();
-  test_read_none_compressed_slice();
-  test_read_gzip_compressed_slice();
-  test_read_deflate_compressed_slice();
-  test_byte_buffer_from_reader();
+int
+main (int argc, char **argv)
+{
+  grpc_test_init (argc, argv);
+  test_read_one_slice ();
+  test_read_one_slice_malloc ();
+  test_read_none_compressed_slice ();
+  test_read_gzip_compressed_slice ();
+  test_read_deflate_compressed_slice ();
+  test_byte_buffer_from_reader ();
 
   return 0;
 }
diff --git a/test/core/surface/completion_queue_test.c b/test/core/surface/completion_queue_test.c
index 3dee8f23af..cd0bce8fc2 100644
--- a/test/core/surface/completion_queue_test.c
+++ b/test/core/surface/completion_queue_test.c
@@ -43,141 +43,159 @@
 
 #define LOG_TEST(x) gpr_log(GPR_INFO, "%s", x)
 
-static void *create_test_tag(void) {
+static void *
+create_test_tag (void)
+{
   static gpr_intptr i = 0;
-  return (void *)(++i);
+  return (void *) (++i);
 }
 
 /* helper for tests to shutdown correctly and tersely */
-static void shutdown_and_destroy(grpc_completion_queue *cc) {
+static void
+shutdown_and_destroy (grpc_completion_queue * cc)
+{
   grpc_event ev;
-  grpc_completion_queue_shutdown(cc);
-  ev = grpc_completion_queue_next(cc, gpr_inf_past(GPR_CLOCK_REALTIME), NULL);
-  GPR_ASSERT(ev.type == GRPC_QUEUE_SHUTDOWN);
-  grpc_completion_queue_destroy(cc);
+  grpc_completion_queue_shutdown (cc);
+  ev = grpc_completion_queue_next (cc, gpr_inf_past (GPR_CLOCK_REALTIME), NULL);
+  GPR_ASSERT (ev.type == GRPC_QUEUE_SHUTDOWN);
+  grpc_completion_queue_destroy (cc);
 }
 
 /* ensure we can create and destroy a completion channel */
-static void test_no_op(void) {
-  LOG_TEST("test_no_op");
-  shutdown_and_destroy(grpc_completion_queue_create(NULL));
+static void
+test_no_op (void)
+{
+  LOG_TEST ("test_no_op");
+  shutdown_and_destroy (grpc_completion_queue_create (NULL));
 }
 
-static void test_wait_empty(void) {
+static void
+test_wait_empty (void)
+{
   grpc_completion_queue *cc;
   grpc_event event;
 
-  LOG_TEST("test_wait_empty");
+  LOG_TEST ("test_wait_empty");
 
-  cc = grpc_completion_queue_create(NULL);
-  event = grpc_completion_queue_next(cc, gpr_now(GPR_CLOCK_REALTIME), NULL);
-  GPR_ASSERT(event.type == GRPC_QUEUE_TIMEOUT);
-  shutdown_and_destroy(cc);
+  cc = grpc_completion_queue_create (NULL);
+  event = grpc_completion_queue_next (cc, gpr_now (GPR_CLOCK_REALTIME), NULL);
+  GPR_ASSERT (event.type == GRPC_QUEUE_TIMEOUT);
+  shutdown_and_destroy (cc);
 }
 
-static void do_nothing_end_completion(void *arg, grpc_cq_completion *c,
-                                      grpc_closure_list *closure_list) {}
+static void
+do_nothing_end_completion (void *arg, grpc_cq_completion * c, grpc_closure_list * closure_list)
+{
+}
 
-static void test_cq_end_op(void) {
+static void
+test_cq_end_op (void)
+{
   grpc_event ev;
   grpc_completion_queue *cc;
   grpc_cq_completion completion;
   grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
-  void *tag = create_test_tag();
+  void *tag = create_test_tag ();
 
-  LOG_TEST("test_cq_end_op");
+  LOG_TEST ("test_cq_end_op");
 
-  cc = grpc_completion_queue_create(NULL);
+  cc = grpc_completion_queue_create (NULL);
 
-  grpc_cq_begin_op(cc);
-  grpc_cq_end_op(cc, tag, 1, do_nothing_end_completion, NULL, &completion,
-                 &closure_list);
+  grpc_cq_begin_op (cc);
+  grpc_cq_end_op (cc, tag, 1, do_nothing_end_completion, NULL, &completion, &closure_list);
 
-  ev = grpc_completion_queue_next(cc, gpr_inf_past(GPR_CLOCK_REALTIME), NULL);
-  GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
-  GPR_ASSERT(ev.tag == tag);
-  GPR_ASSERT(ev.success);
+  ev = grpc_completion_queue_next (cc, gpr_inf_past (GPR_CLOCK_REALTIME), NULL);
+  GPR_ASSERT (ev.type == GRPC_OP_COMPLETE);
+  GPR_ASSERT (ev.tag == tag);
+  GPR_ASSERT (ev.success);
 
-  shutdown_and_destroy(cc);
-  GPR_ASSERT(grpc_closure_list_empty(closure_list));
+  shutdown_and_destroy (cc);
+  GPR_ASSERT (grpc_closure_list_empty (closure_list));
 }
 
-static void test_shutdown_then_next_polling(void) {
+static void
+test_shutdown_then_next_polling (void)
+{
   grpc_completion_queue *cc;
   grpc_event event;
-  LOG_TEST("test_shutdown_then_next_polling");
-
-  cc = grpc_completion_queue_create(NULL);
-  grpc_completion_queue_shutdown(cc);
-  event =
-      grpc_completion_queue_next(cc, gpr_inf_past(GPR_CLOCK_REALTIME), NULL);
-  GPR_ASSERT(event.type == GRPC_QUEUE_SHUTDOWN);
-  grpc_completion_queue_destroy(cc);
+  LOG_TEST ("test_shutdown_then_next_polling");
+
+  cc = grpc_completion_queue_create (NULL);
+  grpc_completion_queue_shutdown (cc);
+  event = grpc_completion_queue_next (cc, gpr_inf_past (GPR_CLOCK_REALTIME), NULL);
+  GPR_ASSERT (event.type == GRPC_QUEUE_SHUTDOWN);
+  grpc_completion_queue_destroy (cc);
 }
 
-static void test_shutdown_then_next_with_timeout(void) {
+static void
+test_shutdown_then_next_with_timeout (void)
+{
   grpc_completion_queue *cc;
   grpc_event event;
-  LOG_TEST("test_shutdown_then_next_with_timeout");
-
-  cc = grpc_completion_queue_create(NULL);
-  grpc_completion_queue_shutdown(cc);
-  event =
-      grpc_completion_queue_next(cc, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
-  GPR_ASSERT(event.type == GRPC_QUEUE_SHUTDOWN);
-  grpc_completion_queue_destroy(cc);
+  LOG_TEST ("test_shutdown_then_next_with_timeout");
+
+  cc = grpc_completion_queue_create (NULL);
+  grpc_completion_queue_shutdown (cc);
+  event = grpc_completion_queue_next (cc, gpr_inf_future (GPR_CLOCK_REALTIME), NULL);
+  GPR_ASSERT (event.type == GRPC_QUEUE_SHUTDOWN);
+  grpc_completion_queue_destroy (cc);
 }
 
-static void test_pluck(void) {
+static void
+test_pluck (void)
+{
   grpc_event ev;
   grpc_completion_queue *cc;
   void *tags[128];
-  grpc_cq_completion completions[GPR_ARRAY_SIZE(tags)];
+  grpc_cq_completion completions[GPR_ARRAY_SIZE (tags)];
   grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
   unsigned i, j;
 
-  LOG_TEST("test_pluck");
+  LOG_TEST ("test_pluck");
+
+  for (i = 0; i < GPR_ARRAY_SIZE (tags); i++)
+    {
+      tags[i] = create_test_tag ();
+      for (j = 0; j < i; j++)
+	{
+	  GPR_ASSERT (tags[i] != tags[j]);
+	}
+    }
+
+  cc = grpc_completion_queue_create (NULL);
+
+  for (i = 0; i < GPR_ARRAY_SIZE (tags); i++)
+    {
+      grpc_cq_begin_op (cc);
+      grpc_cq_end_op (cc, tags[i], 1, do_nothing_end_completion, NULL, &completions[i], &closure_list);
+    }
+
+  for (i = 0; i < GPR_ARRAY_SIZE (tags); i++)
+    {
+      ev = grpc_completion_queue_pluck (cc, tags[i], gpr_inf_past (GPR_CLOCK_REALTIME), NULL);
+      GPR_ASSERT (ev.tag == tags[i]);
+    }
+
+  for (i = 0; i < GPR_ARRAY_SIZE (tags); i++)
+    {
+      grpc_cq_begin_op (cc);
+      grpc_cq_end_op (cc, tags[i], 1, do_nothing_end_completion, NULL, &completions[i], &closure_list);
+    }
 
-  for (i = 0; i < GPR_ARRAY_SIZE(tags); i++) {
-    tags[i] = create_test_tag();
-    for (j = 0; j < i; j++) {
-      GPR_ASSERT(tags[i] != tags[j]);
+  for (i = 0; i < GPR_ARRAY_SIZE (tags); i++)
+    {
+      ev = grpc_completion_queue_pluck (cc, tags[GPR_ARRAY_SIZE (tags) - i - 1], gpr_inf_past (GPR_CLOCK_REALTIME), NULL);
+      GPR_ASSERT (ev.tag == tags[GPR_ARRAY_SIZE (tags) - i - 1]);
     }
-  }
-
-  cc = grpc_completion_queue_create(NULL);
-
-  for (i = 0; i < GPR_ARRAY_SIZE(tags); i++) {
-    grpc_cq_begin_op(cc);
-    grpc_cq_end_op(cc, tags[i], 1, do_nothing_end_completion, NULL,
-                   &completions[i], &closure_list);
-  }
-
-  for (i = 0; i < GPR_ARRAY_SIZE(tags); i++) {
-    ev = grpc_completion_queue_pluck(cc, tags[i],
-                                     gpr_inf_past(GPR_CLOCK_REALTIME), NULL);
-    GPR_ASSERT(ev.tag == tags[i]);
-  }
-
-  for (i = 0; i < GPR_ARRAY_SIZE(tags); i++) {
-    grpc_cq_begin_op(cc);
-    grpc_cq_end_op(cc, tags[i], 1, do_nothing_end_completion, NULL,
-                   &completions[i], &closure_list);
-  }
-
-  for (i = 0; i < GPR_ARRAY_SIZE(tags); i++) {
-    ev = grpc_completion_queue_pluck(cc, tags[GPR_ARRAY_SIZE(tags) - i - 1],
-                                     gpr_inf_past(GPR_CLOCK_REALTIME), NULL);
-    GPR_ASSERT(ev.tag == tags[GPR_ARRAY_SIZE(tags) - i - 1]);
-  }
-
-  shutdown_and_destroy(cc);
-  GPR_ASSERT(grpc_closure_list_empty(closure_list));
+
+  shutdown_and_destroy (cc);
+  GPR_ASSERT (grpc_closure_list_empty (closure_list));
 }
 
 #define TEST_THREAD_EVENTS 10000
 
-typedef struct test_thread_options {
+typedef struct test_thread_options
+{
   gpr_event on_started;
   gpr_event *phase1;
   gpr_event on_phase1_done;
@@ -188,164 +206,181 @@ typedef struct test_thread_options {
   grpc_completion_queue *cc;
 } test_thread_options;
 
-gpr_timespec ten_seconds_time(void) {
-  return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(10);
+gpr_timespec
+ten_seconds_time (void)
+{
+  return GRPC_TIMEOUT_SECONDS_TO_DEADLINE (10);
 }
 
-static void free_completion(void *arg, grpc_cq_completion *completion,
-                            grpc_closure_list *closure_list) {
-  gpr_free(completion);
+static void
+free_completion (void *arg, grpc_cq_completion * completion, grpc_closure_list * closure_list)
+{
+  gpr_free (completion);
 }
 
-static void producer_thread(void *arg) {
+static void
+producer_thread (void *arg)
+{
   test_thread_options *opt = arg;
   int i;
   grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
 
-  gpr_log(GPR_INFO, "producer %d started", opt->id);
-  gpr_event_set(&opt->on_started, (void *)(gpr_intptr)1);
-  GPR_ASSERT(gpr_event_wait(opt->phase1, ten_seconds_time()));
-
-  gpr_log(GPR_INFO, "producer %d phase 1", opt->id);
-  for (i = 0; i < TEST_THREAD_EVENTS; i++) {
-    grpc_cq_begin_op(opt->cc);
-  }
-
-  gpr_log(GPR_INFO, "producer %d phase 1 done", opt->id);
-  gpr_event_set(&opt->on_phase1_done, (void *)(gpr_intptr)1);
-  GPR_ASSERT(gpr_event_wait(opt->phase2, ten_seconds_time()));
-
-  gpr_log(GPR_INFO, "producer %d phase 2", opt->id);
-  for (i = 0; i < TEST_THREAD_EVENTS; i++) {
-    grpc_cq_end_op(opt->cc, (void *)(gpr_intptr)1, 1, free_completion, NULL,
-                   gpr_malloc(sizeof(grpc_cq_completion)), &closure_list);
-    opt->events_triggered++;
-    grpc_closure_list_run(&closure_list);
-  }
-
-  gpr_log(GPR_INFO, "producer %d phase 2 done", opt->id);
-  gpr_event_set(&opt->on_finished, (void *)(gpr_intptr)1);
-  GPR_ASSERT(grpc_closure_list_empty(closure_list));
+  gpr_log (GPR_INFO, "producer %d started", opt->id);
+  gpr_event_set (&opt->on_started, (void *) (gpr_intptr) 1);
+  GPR_ASSERT (gpr_event_wait (opt->phase1, ten_seconds_time ()));
+
+  gpr_log (GPR_INFO, "producer %d phase 1", opt->id);
+  for (i = 0; i < TEST_THREAD_EVENTS; i++)
+    {
+      grpc_cq_begin_op (opt->cc);
+    }
+
+  gpr_log (GPR_INFO, "producer %d phase 1 done", opt->id);
+  gpr_event_set (&opt->on_phase1_done, (void *) (gpr_intptr) 1);
+  GPR_ASSERT (gpr_event_wait (opt->phase2, ten_seconds_time ()));
+
+  gpr_log (GPR_INFO, "producer %d phase 2", opt->id);
+  for (i = 0; i < TEST_THREAD_EVENTS; i++)
+    {
+      grpc_cq_end_op (opt->cc, (void *) (gpr_intptr) 1, 1, free_completion, NULL, gpr_malloc (sizeof (grpc_cq_completion)), &closure_list);
+      opt->events_triggered++;
+      grpc_closure_list_run (&closure_list);
+    }
+
+  gpr_log (GPR_INFO, "producer %d phase 2 done", opt->id);
+  gpr_event_set (&opt->on_finished, (void *) (gpr_intptr) 1);
+  GPR_ASSERT (grpc_closure_list_empty (closure_list));
 }
 
-static void consumer_thread(void *arg) {
+static void
+consumer_thread (void *arg)
+{
   test_thread_options *opt = arg;
   grpc_event ev;
 
-  gpr_log(GPR_INFO, "consumer %d started", opt->id);
-  gpr_event_set(&opt->on_started, (void *)(gpr_intptr)1);
-  GPR_ASSERT(gpr_event_wait(opt->phase1, ten_seconds_time()));
-
-  gpr_log(GPR_INFO, "consumer %d phase 1", opt->id);
-
-  gpr_log(GPR_INFO, "consumer %d phase 1 done", opt->id);
-  gpr_event_set(&opt->on_phase1_done, (void *)(gpr_intptr)1);
-  GPR_ASSERT(gpr_event_wait(opt->phase2, ten_seconds_time()));
-
-  gpr_log(GPR_INFO, "consumer %d phase 2", opt->id);
-  for (;;) {
-    ev = grpc_completion_queue_next(opt->cc, ten_seconds_time(), NULL);
-    switch (ev.type) {
-      case GRPC_OP_COMPLETE:
-        GPR_ASSERT(ev.success);
-        opt->events_triggered++;
-        break;
-      case GRPC_QUEUE_SHUTDOWN:
-        gpr_log(GPR_INFO, "consumer %d phase 2 done", opt->id);
-        gpr_event_set(&opt->on_finished, (void *)(gpr_intptr)1);
-        return;
-      case GRPC_QUEUE_TIMEOUT:
-        gpr_log(GPR_ERROR, "Invalid timeout received");
-        abort();
+  gpr_log (GPR_INFO, "consumer %d started", opt->id);
+  gpr_event_set (&opt->on_started, (void *) (gpr_intptr) 1);
+  GPR_ASSERT (gpr_event_wait (opt->phase1, ten_seconds_time ()));
+
+  gpr_log (GPR_INFO, "consumer %d phase 1", opt->id);
+
+  gpr_log (GPR_INFO, "consumer %d phase 1 done", opt->id);
+  gpr_event_set (&opt->on_phase1_done, (void *) (gpr_intptr) 1);
+  GPR_ASSERT (gpr_event_wait (opt->phase2, ten_seconds_time ()));
+
+  gpr_log (GPR_INFO, "consumer %d phase 2", opt->id);
+  for (;;)
+    {
+      ev = grpc_completion_queue_next (opt->cc, ten_seconds_time (), NULL);
+      switch (ev.type)
+	{
+	case GRPC_OP_COMPLETE:
+	  GPR_ASSERT (ev.success);
+	  opt->events_triggered++;
+	  break;
+	case GRPC_QUEUE_SHUTDOWN:
+	  gpr_log (GPR_INFO, "consumer %d phase 2 done", opt->id);
+	  gpr_event_set (&opt->on_finished, (void *) (gpr_intptr) 1);
+	  return;
+	case GRPC_QUEUE_TIMEOUT:
+	  gpr_log (GPR_ERROR, "Invalid timeout received");
+	  abort ();
+	}
     }
-  }
 }
 
-static void test_threading(size_t producers, size_t consumers) {
-  test_thread_options *options =
-      gpr_malloc((producers + consumers) * sizeof(test_thread_options));
+static void
+test_threading (size_t producers, size_t consumers)
+{
+  test_thread_options *options = gpr_malloc ((producers + consumers) * sizeof (test_thread_options));
   gpr_event phase1 = GPR_EVENT_INIT;
   gpr_event phase2 = GPR_EVENT_INIT;
-  grpc_completion_queue *cc = grpc_completion_queue_create(NULL);
+  grpc_completion_queue *cc = grpc_completion_queue_create (NULL);
   size_t i;
   size_t total_consumed = 0;
   static int optid = 101;
 
-  gpr_log(GPR_INFO, "%s: %d producers, %d consumers", "test_threading",
-          producers, consumers);
+  gpr_log (GPR_INFO, "%s: %d producers, %d consumers", "test_threading", producers, consumers);
 
   /* start all threads: they will wait for phase1 */
-  for (i = 0; i < producers + consumers; i++) {
-    gpr_thd_id id;
-    gpr_event_init(&options[i].on_started);
-    gpr_event_init(&options[i].on_phase1_done);
-    gpr_event_init(&options[i].on_finished);
-    options[i].phase1 = &phase1;
-    options[i].phase2 = &phase2;
-    options[i].events_triggered = 0;
-    options[i].cc = cc;
-    options[i].id = optid++;
-    GPR_ASSERT(gpr_thd_new(&id,
-                           i < producers ? producer_thread : consumer_thread,
-                           options + i, NULL));
-    gpr_event_wait(&options[i].on_started, ten_seconds_time());
-  }
+  for (i = 0; i < producers + consumers; i++)
+    {
+      gpr_thd_id id;
+      gpr_event_init (&options[i].on_started);
+      gpr_event_init (&options[i].on_phase1_done);
+      gpr_event_init (&options[i].on_finished);
+      options[i].phase1 = &phase1;
+      options[i].phase2 = &phase2;
+      options[i].events_triggered = 0;
+      options[i].cc = cc;
+      options[i].id = optid++;
+      GPR_ASSERT (gpr_thd_new (&id, i < producers ? producer_thread : consumer_thread, options + i, NULL));
+      gpr_event_wait (&options[i].on_started, ten_seconds_time ());
+    }
 
   /* start phase1: producers will pre-declare all operations they will
      complete */
-  gpr_log(GPR_INFO, "start phase 1");
-  gpr_event_set(&phase1, (void *)(gpr_intptr)1);
+  gpr_log (GPR_INFO, "start phase 1");
+  gpr_event_set (&phase1, (void *) (gpr_intptr) 1);
 
-  gpr_log(GPR_INFO, "wait phase 1");
-  for (i = 0; i < producers + consumers; i++) {
-    GPR_ASSERT(gpr_event_wait(&options[i].on_phase1_done, ten_seconds_time()));
-  }
-  gpr_log(GPR_INFO, "done phase 1");
+  gpr_log (GPR_INFO, "wait phase 1");
+  for (i = 0; i < producers + consumers; i++)
+    {
+      GPR_ASSERT (gpr_event_wait (&options[i].on_phase1_done, ten_seconds_time ()));
+    }
+  gpr_log (GPR_INFO, "done phase 1");
 
   /* start phase2: operations will complete, and consumers will consume them */
-  gpr_log(GPR_INFO, "start phase 2");
-  gpr_event_set(&phase2, (void *)(gpr_intptr)1);
+  gpr_log (GPR_INFO, "start phase 2");
+  gpr_event_set (&phase2, (void *) (gpr_intptr) 1);
 
   /* in parallel, we shutdown the completion channel - all events should still
      be consumed */
-  grpc_completion_queue_shutdown(cc);
+  grpc_completion_queue_shutdown (cc);
 
   /* join all threads */
-  gpr_log(GPR_INFO, "wait phase 2");
-  for (i = 0; i < producers + consumers; i++) {
-    GPR_ASSERT(gpr_event_wait(&options[i].on_finished, ten_seconds_time()));
-  }
-  gpr_log(GPR_INFO, "done phase 2");
+  gpr_log (GPR_INFO, "wait phase 2");
+  for (i = 0; i < producers + consumers; i++)
+    {
+      GPR_ASSERT (gpr_event_wait (&options[i].on_finished, ten_seconds_time ()));
+    }
+  gpr_log (GPR_INFO, "done phase 2");
 
   /* destroy the completion channel */
-  grpc_completion_queue_destroy(cc);
+  grpc_completion_queue_destroy (cc);
 
   /* verify that everything was produced and consumed */
-  for (i = 0; i < producers + consumers; i++) {
-    if (i < producers) {
-      GPR_ASSERT(options[i].events_triggered == TEST_THREAD_EVENTS);
-    } else {
-      total_consumed += options[i].events_triggered;
+  for (i = 0; i < producers + consumers; i++)
+    {
+      if (i < producers)
+	{
+	  GPR_ASSERT (options[i].events_triggered == TEST_THREAD_EVENTS);
+	}
+      else
+	{
+	  total_consumed += options[i].events_triggered;
+	}
     }
-  }
-  GPR_ASSERT(total_consumed == producers * TEST_THREAD_EVENTS);
+  GPR_ASSERT (total_consumed == producers * TEST_THREAD_EVENTS);
 
-  gpr_free(options);
+  gpr_free (options);
 }
 
-int main(int argc, char **argv) {
-  grpc_test_init(argc, argv);
-  grpc_init();
-  test_no_op();
-  test_wait_empty();
-  test_shutdown_then_next_polling();
-  test_shutdown_then_next_with_timeout();
-  test_cq_end_op();
-  test_pluck();
-  test_threading(1, 1);
-  test_threading(1, 10);
-  test_threading(10, 1);
-  test_threading(10, 10);
-  grpc_shutdown();
+int
+main (int argc, char **argv)
+{
+  grpc_test_init (argc, argv);
+  grpc_init ();
+  test_no_op ();
+  test_wait_empty ();
+  test_shutdown_then_next_polling ();
+  test_shutdown_then_next_with_timeout ();
+  test_cq_end_op ();
+  test_pluck ();
+  test_threading (1, 1);
+  test_threading (1, 10);
+  test_threading (10, 1);
+  test_threading (10, 10);
+  grpc_shutdown ();
   return 0;
 }
diff --git a/test/core/surface/lame_client_test.c b/test/core/surface/lame_client_test.c
index 0d29bea555..434779b273 100644
--- a/test/core/surface/lame_client_test.c
+++ b/test/core/surface/lame_client_test.c
@@ -38,9 +38,15 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-static void *tag(gpr_intptr x) { return (void *)x; }
+static void *
+tag (gpr_intptr x)
+{
+  return (void *) x;
+}
 
-int main(int argc, char **argv) {
+int
+main (int argc, char **argv)
+{
   grpc_channel *chan;
   grpc_call *call;
   grpc_completion_queue *cq;
@@ -53,20 +59,17 @@ int main(int argc, char **argv) {
   char *details = NULL;
   size_t details_capacity = 0;
 
-  grpc_test_init(argc, argv);
-  grpc_init();
+  grpc_test_init (argc, argv);
+  grpc_init ();
 
-  grpc_metadata_array_init(&trailing_metadata_recv);
+  grpc_metadata_array_init (&trailing_metadata_recv);
 
-  chan = grpc_lame_client_channel_create(
-      "lampoon:national", GRPC_STATUS_UNKNOWN, "Rpc sent on a lame channel.");
-  GPR_ASSERT(chan);
-  cq = grpc_completion_queue_create(NULL);
-  call = grpc_channel_create_call(chan, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
-                                  "/Foo", "anywhere",
-                                  GRPC_TIMEOUT_SECONDS_TO_DEADLINE(100), NULL);
-  GPR_ASSERT(call);
-  cqv = cq_verifier_create(cq);
+  chan = grpc_lame_client_channel_create ("lampoon:national", GRPC_STATUS_UNKNOWN, "Rpc sent on a lame channel.");
+  GPR_ASSERT (chan);
+  cq = grpc_completion_queue_create (NULL);
+  call = grpc_channel_create_call (chan, NULL, GRPC_PROPAGATE_DEFAULTS, cq, "/Foo", "anywhere", GRPC_TIMEOUT_SECONDS_TO_DEADLINE (100), NULL);
+  GPR_ASSERT (call);
+  cqv = cq_verifier_create (cq);
 
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
@@ -82,22 +85,22 @@ int main(int argc, char **argv) {
   op->flags = 0;
   op->reserved = NULL;
   op++;
-  error = grpc_call_start_batch(call, ops, (size_t)(op - ops), tag(1), NULL);
-  GPR_ASSERT(GRPC_CALL_OK == error);
+  error = grpc_call_start_batch (call, ops, (size_t) (op - ops), tag (1), NULL);
+  GPR_ASSERT (GRPC_CALL_OK == error);
 
   /* the call should immediately fail */
-  cq_expect_completion(cqv, tag(1), 1);
-  cq_verify(cqv);
+  cq_expect_completion (cqv, tag (1), 1);
+  cq_verify (cqv);
 
-  grpc_call_destroy(call);
-  grpc_channel_destroy(chan);
-  cq_verifier_destroy(cqv);
-  grpc_completion_queue_destroy(cq);
+  grpc_call_destroy (call);
+  grpc_channel_destroy (chan);
+  cq_verifier_destroy (cqv);
+  grpc_completion_queue_destroy (cq);
 
-  grpc_metadata_array_destroy(&trailing_metadata_recv);
-  gpr_free(details);
+  grpc_metadata_array_destroy (&trailing_metadata_recv);
+  gpr_free (details);
 
-  grpc_shutdown();
+  grpc_shutdown ();
 
   return 0;
 }
diff --git a/test/core/surface/multi_init_test.c b/test/core/surface/multi_init_test.c
index 99b7a52ff9..fafaae5902 100644
--- a/test/core/surface/multi_init_test.c
+++ b/test/core/surface/multi_init_test.c
@@ -34,30 +34,38 @@
 #include <grpc/grpc.h>
 #include "test/core/util/test_config.h"
 
-static void test(int rounds) {
+static void
+test (int rounds)
+{
   int i;
-  for (i = 0; i < rounds; i++) {
-    grpc_init();
-  }
-  for (i = 0; i < rounds; i++) {
-    grpc_shutdown();
-  }
+  for (i = 0; i < rounds; i++)
+    {
+      grpc_init ();
+    }
+  for (i = 0; i < rounds; i++)
+    {
+      grpc_shutdown ();
+    }
 }
 
-static void test_mixed() {
-  grpc_init();
-  grpc_init();
-  grpc_shutdown();
-  grpc_init();
-  grpc_shutdown();
-  grpc_shutdown();
+static void
+test_mixed ()
+{
+  grpc_init ();
+  grpc_init ();
+  grpc_shutdown ();
+  grpc_init ();
+  grpc_shutdown ();
+  grpc_shutdown ();
 }
 
-int main(int argc, char **argv) {
-  grpc_test_init(argc, argv);
-  test(1);
-  test(2);
-  test(3);
-  test_mixed();
+int
+main (int argc, char **argv)
+{
+  grpc_test_init (argc, argv);
+  test (1);
+  test (2);
+  test (3);
+  test_mixed ();
   return 0;
 }