diff --git a/test/core/channel/channel_stack_test.c b/test/core/channel/channel_stack_test.c
new file mode 100644
index 0000000..44ede2f
--- /dev/null
+++ b/test/core/channel/channel_stack_test.c
@@ -0,0 +1,139 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/channel/channel_stack.h"
+
+#include <string.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include "test/core/util/test_config.h"
+
+#define LOG_TEST_NAME() gpr_log(GPR_INFO, "%s", __FUNCTION__)
+
+static void channel_init_func(grpc_channel_element *elem,
+                              const grpc_channel_args *args,
+                              grpc_mdctx *metadata_context, int is_first,
+                              int is_last) {
+  GPR_ASSERT(args->num_args == 1);
+  GPR_ASSERT(args->args[0].type == GRPC_ARG_INTEGER);
+  GPR_ASSERT(0 == strcmp(args->args[0].key, "test_key"));
+  GPR_ASSERT(args->args[0].value.integer == 42);
+  GPR_ASSERT(is_first);
+  GPR_ASSERT(is_last);
+  *(int *)(elem->channel_data) = 0;
+}
+
+static void call_init_func(grpc_call_element *elem,
+                           const void *server_transport_data) {
+  ++*(int *)(elem->channel_data);
+  *(int *)(elem->call_data) = 0;
+}
+
+static void channel_destroy_func(grpc_channel_element *elem) {}
+
+static void call_destroy_func(grpc_call_element *elem) {
+  ++*(int *)(elem->channel_data);
+}
+
+static void call_func(grpc_call_element *elem, grpc_call_op *op) {
+  ++*(int *)(elem->call_data);
+}
+
+static void channel_func(grpc_channel_element *elem, grpc_channel_op *op) {
+  ++*(int *)(elem->channel_data);
+}
+
+static void test_create_channel_stack() {
+  const grpc_channel_filter filter = {
+      call_func,   channel_func,
+
+      sizeof(int), call_init_func,    call_destroy_func,
+
+      sizeof(int), channel_init_func, channel_destroy_func,
+  };
+  const grpc_channel_filter *filters = &filter;
+  grpc_channel_stack *channel_stack;
+  grpc_call_stack *call_stack;
+  grpc_channel_element *channel_elem;
+  grpc_call_element *call_elem;
+  grpc_arg arg;
+  grpc_channel_args chan_args;
+  grpc_mdctx *metadata_context;
+  int *channel_data;
+  int *call_data;
+
+  LOG_TEST_NAME();
+
+  metadata_context = grpc_mdctx_create();
+
+  arg.type = GRPC_ARG_INTEGER;
+  arg.key = "test_key";
+  arg.value.integer = 42;
+
+  chan_args.num_args = 1;
+  chan_args.args = &arg;
+
+  channel_stack = gpr_malloc(grpc_channel_stack_size(&filters, 1));
+  grpc_channel_stack_init(&filters, 1, &chan_args, metadata_context,
+                          channel_stack);
+  GPR_ASSERT(channel_stack->count == 1);
+  channel_elem = grpc_channel_stack_element(channel_stack, 0);
+  channel_data = (int *)channel_elem->channel_data;
+  GPR_ASSERT(*channel_data == 0);
+
+  call_stack = gpr_malloc(channel_stack->call_stack_size);
+  grpc_call_stack_init(channel_stack, NULL, call_stack);
+  GPR_ASSERT(call_stack->count == 1);
+  call_elem = grpc_call_stack_element(call_stack, 0);
+  GPR_ASSERT(call_elem->filter == channel_elem->filter);
+  GPR_ASSERT(call_elem->channel_data == channel_elem->channel_data);
+  call_data = (int *)call_elem->call_data;
+  GPR_ASSERT(*call_data == 0);
+  GPR_ASSERT(*channel_data == 1);
+
+  grpc_call_stack_destroy(call_stack);
+  gpr_free(call_stack);
+  GPR_ASSERT(*channel_data == 2);
+
+  grpc_channel_stack_destroy(channel_stack);
+  gpr_free(channel_stack);
+
+  grpc_mdctx_orphan(metadata_context);
+}
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  test_create_channel_stack();
+  return 0;
+}
diff --git a/test/core/channel/metadata_buffer_test.c b/test/core/channel/metadata_buffer_test.c
new file mode 100644
index 0000000..4a60b53
--- /dev/null
+++ b/test/core/channel/metadata_buffer_test.c
@@ -0,0 +1,194 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/channel/metadata_buffer.h"
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include "test/core/util/test_config.h"
+
+#include <string.h>
+#include <stdio.h>
+
+/* construct a buffer with some prefix followed by an integer converted to
+   a string */
+static gpr_slice construct_buffer(size_t prefix_length, size_t index) {
+  gpr_slice buffer = gpr_slice_malloc(prefix_length + 32);
+  memset(GPR_SLICE_START_PTR(buffer), 'a', prefix_length);
+  GPR_SLICE_SET_LENGTH(
+      buffer, prefix_length +
+                  sprintf((char *)GPR_SLICE_START_PTR(buffer) + prefix_length,
+                          "%d", (int)index));
+  return buffer;
+}
+
+static void do_nothing(void *ignored, grpc_op_error also_ignored) {}
+
+/* we need a fake channel & call stack, which is defined here */
+
+/* a fake channel needs to track some information about the test */
+typedef struct {
+  size_t key_prefix_len;
+  size_t value_prefix_len;
+} channel_data;
+
+static void fail_call_op(grpc_call_element *elem, grpc_call_op *op) { abort(); }
+
+/* verify that the metadata passed on during flush is the same as we expect */
+static void expect_call_op(grpc_call_element *elem, grpc_call_op *op) {
+  size_t *n = elem->call_data;
+  channel_data *cd = elem->channel_data;
+  gpr_slice key = construct_buffer(cd->key_prefix_len, *n);
+  gpr_slice value = construct_buffer(cd->value_prefix_len, *n);
+
+  GPR_ASSERT(op->type == GRPC_SEND_METADATA);
+  GPR_ASSERT(op->dir == GRPC_CALL_DOWN);
+  GPR_ASSERT(op->flags == *n);
+  GPR_ASSERT(op->done_cb == do_nothing);
+  GPR_ASSERT(op->user_data == (void *)(gpr_uintptr) * n);
+  GPR_ASSERT(0 == gpr_slice_cmp(op->data.metadata->key->slice, key));
+  GPR_ASSERT(0 == gpr_slice_cmp(op->data.metadata->value->slice, value));
+
+  ++*n;
+
+  gpr_slice_unref(key);
+  gpr_slice_unref(value);
+  grpc_mdelem_unref(op->data.metadata);
+}
+
+static void fail_channel_op(grpc_channel_element *elem, grpc_channel_op *op) {
+  abort();
+}
+
+static void init_call_elem(grpc_call_element *elem,
+                           const void *transport_server_data) {
+  *(size_t *)elem->call_data = 0;
+}
+
+static void destroy_call_elem(grpc_call_element *elem) {}
+
+static void init_channel_elem(grpc_channel_element *elem,
+                              const grpc_channel_args *args, grpc_mdctx *mdctx,
+                              int is_first, int is_last) {}
+
+static void destroy_channel_elem(grpc_channel_element *elem) {}
+
+static const grpc_channel_filter top_filter = {
+    fail_call_op,      fail_channel_op,     sizeof(size_t),
+    init_call_elem,    destroy_call_elem,   sizeof(channel_data),
+    init_channel_elem, destroy_channel_elem};
+
+static const grpc_channel_filter bottom_filter = {
+    expect_call_op,    fail_channel_op,     sizeof(size_t),
+    init_call_elem,    destroy_call_elem,   sizeof(channel_data),
+    init_channel_elem, destroy_channel_elem};
+
+static const grpc_channel_filter *filters[2] = {&top_filter, &bottom_filter};
+
+/* run a test with differently sized keys, and values, some number of times. */
+static void test_case(size_t key_prefix_len, size_t value_prefix_len,
+                      size_t num_calls) {
+  size_t i;
+  size_t got_calls;
+  grpc_metadata_buffer buffer;
+  grpc_channel_stack *stk;
+  grpc_call_stack *call;
+  grpc_mdctx *mdctx;
+
+  gpr_log(GPR_INFO, "Test %d calls, {key,value}_prefix_len = {%d, %d}",
+          (int)num_calls, (int)key_prefix_len, (int)value_prefix_len);
+
+  mdctx = grpc_mdctx_create();
+
+  grpc_metadata_buffer_init(&buffer);
+
+  /* queue metadata elements */
+  for (i = 0; i < num_calls; i++) {
+    grpc_call_op op;
+    gpr_slice key = construct_buffer(key_prefix_len, i);
+    gpr_slice value = construct_buffer(value_prefix_len, i);
+
+    op.type = GRPC_SEND_METADATA;
+    op.dir = GRPC_CALL_DOWN;
+    op.flags = i;
+    op.data.metadata = grpc_mdelem_from_slices(mdctx, key, value);
+    op.done_cb = do_nothing;
+    op.user_data = (void *)(gpr_uintptr) i;
+
+    grpc_metadata_buffer_queue(&buffer, &op);
+  }
+
+  /* construct a test channel, call stack */
+  stk = gpr_malloc(grpc_channel_stack_size(filters, 2));
+  grpc_channel_stack_init(filters, 2, NULL, mdctx, stk);
+
+  for (i = 0; i < 2; i++) {
+    channel_data *cd =
+        (channel_data *)grpc_channel_stack_element(stk, i)->channel_data;
+    cd->key_prefix_len = key_prefix_len;
+    cd->value_prefix_len = value_prefix_len;
+  }
+
+  call = gpr_malloc(stk->call_stack_size);
+  grpc_call_stack_init(stk, NULL, call);
+
+  /* flush out metadata, verifying each element (see expect_call_op) */
+  grpc_metadata_buffer_flush(&buffer, grpc_call_stack_element(call, 0));
+
+  /* verify expect_call_op was called an appropriate number of times */
+  got_calls = *(size_t *)grpc_call_stack_element(call, 1)->call_data;
+  GPR_ASSERT(num_calls == got_calls);
+
+  /* clean up the things */
+  grpc_call_stack_destroy(call);
+  gpr_free(call);
+  grpc_channel_stack_destroy(stk);
+  gpr_free(stk);
+
+  grpc_metadata_buffer_destroy(&buffer, GRPC_OP_OK);
+  grpc_mdctx_orphan(mdctx);
+}
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  test_case(0, 0, 0);
+  test_case(0, 0, 1);
+  test_case(0, 0, 2);
+  test_case(0, 0, 10000);
+  test_case(10, 10, 1);
+  test_case(10, 10, 2);
+  test_case(10, 10, 10000);
+  test_case(100, 100, 1);
+  test_case(100, 100, 2);
+  test_case(100, 100, 10000);
+  return 0;
+}
diff --git a/test/core/compression/message_compress_test.c b/test/core/compression/message_compress_test.c
new file mode 100644
index 0000000..583f187
--- /dev/null
+++ b/test/core/compression/message_compress_test.c
@@ -0,0 +1,193 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/compression/message_compress.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "test/core/util/test_config.h"
+#include "src/core/support/murmur_hash.h"
+#include <grpc/support/log.h>
+#include <grpc/support/useful.h>
+#include "test/core/util/slice_splitter.h"
+
+typedef enum { ONE_A = 0, ONE_KB_A, ONE_MB_A, TEST_VALUE_COUNT } test_value;
+
+typedef enum {
+  SHOULD_NOT_COMPRESS,
+  SHOULD_COMPRESS,
+  MAYBE_COMPRESSES
+} compressability;
+
+static void assert_passthrough(gpr_slice value,
+                               grpc_compression_algorithm algorithm,
+                               grpc_slice_split_mode uncompressed_split_mode,
+                               grpc_slice_split_mode compressed_split_mode,
+                               compressability compress_result_check) {
+  gpr_slice_buffer input;
+  gpr_slice_buffer compressed_raw;
+  gpr_slice_buffer compressed;
+  gpr_slice_buffer output;
+  gpr_slice final;
+  int was_compressed;
+
+  gpr_log(GPR_INFO,
+          "assert_passthrough: value_length=%d value_hash=0x%08x "
+          "algorithm='%s' uncompressed_split='%s' compressed_split='%s'",
+          GPR_SLICE_LENGTH(value), gpr_murmur_hash3(GPR_SLICE_START_PTR(value),
+                                                    GPR_SLICE_LENGTH(value), 0),
+          grpc_compression_algorithm_name(algorithm),
+          grpc_slice_split_mode_name(uncompressed_split_mode),
+          grpc_slice_split_mode_name(compressed_split_mode));
+
+  gpr_slice_buffer_init(&input);
+  gpr_slice_buffer_init(&compressed_raw);
+  gpr_slice_buffer_init(&compressed);
+  gpr_slice_buffer_init(&output);
+
+  grpc_split_slices_to_buffer(uncompressed_split_mode, &value, 1, &input);
+
+  was_compressed = grpc_msg_compress(algorithm, &input, &compressed_raw);
+  GPR_ASSERT(input.count > 0);
+
+  switch (compress_result_check) {
+    case SHOULD_NOT_COMPRESS:
+      GPR_ASSERT(was_compressed == 0);
+      break;
+    case SHOULD_COMPRESS:
+      GPR_ASSERT(was_compressed == 1);
+      break;
+    case MAYBE_COMPRESSES:
+      /* no check */
+      break;
+  }
+
+  grpc_split_slice_buffer(compressed_split_mode, &compressed_raw, &compressed);
+
+  GPR_ASSERT(grpc_msg_decompress(
+      was_compressed ? algorithm : GRPC_COMPRESS_NONE, &compressed, &output));
+
+  final = grpc_slice_merge(output.slices, output.count);
+  GPR_ASSERT(0 == gpr_slice_cmp(value, final));
+
+  gpr_slice_buffer_destroy(&input);
+  gpr_slice_buffer_destroy(&compressed);
+  gpr_slice_buffer_destroy(&compressed_raw);
+  gpr_slice_buffer_destroy(&output);
+  gpr_slice_unref(final);
+}
+
+static gpr_slice repeated(char c, size_t length) {
+  gpr_slice out = gpr_slice_malloc(length);
+  memset(GPR_SLICE_START_PTR(out), c, length);
+  return out;
+}
+
+static compressability get_compressability(
+    test_value id, grpc_compression_algorithm algorithm) {
+  if (algorithm == GRPC_COMPRESS_NONE) return SHOULD_NOT_COMPRESS;
+  switch (id) {
+    case ONE_A:
+      return SHOULD_NOT_COMPRESS;
+    case ONE_KB_A:
+    case ONE_MB_A:
+      return SHOULD_COMPRESS;
+    case TEST_VALUE_COUNT:
+      abort();
+      break;
+  }
+  return MAYBE_COMPRESSES;
+}
+
+static gpr_slice create_test_value(test_value id) {
+  switch (id) {
+    case ONE_A:
+      return gpr_slice_from_copied_string("a");
+    case ONE_KB_A:
+      return repeated('a', 1024);
+    case ONE_MB_A:
+      return repeated('a', 1024 * 1024);
+    case TEST_VALUE_COUNT:
+      abort();
+      break;
+  }
+  return gpr_slice_from_copied_string("bad value");
+}
+
+static void test_bad_data() {
+  gpr_slice_buffer input;
+  gpr_slice_buffer output;
+  int i;
+
+  gpr_slice_buffer_init(&input);
+  gpr_slice_buffer_init(&output);
+  gpr_slice_buffer_add(&input, gpr_slice_from_copied_string(
+                                   "this is not valid compressed input"));
+
+  for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) {
+    if (i == GRPC_COMPRESS_NONE) continue;
+    GPR_ASSERT(0 == grpc_msg_decompress(i, &input, &output));
+    GPR_ASSERT(0 == output.count);
+  }
+
+  gpr_slice_buffer_destroy(&input);
+  gpr_slice_buffer_destroy(&output);
+}
+
+int main(int argc, char **argv) {
+  int i, j, k, m;
+  grpc_slice_split_mode uncompressed_split_modes[] = {
+      GRPC_SLICE_SPLIT_IDENTITY, GRPC_SLICE_SPLIT_ONE_BYTE};
+  grpc_slice_split_mode compressed_split_modes[] = {GRPC_SLICE_SPLIT_MERGE_ALL,
+                                                    GRPC_SLICE_SPLIT_IDENTITY,
+                                                    GRPC_SLICE_SPLIT_ONE_BYTE};
+
+  grpc_test_init(argc, argv);
+
+  for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) {
+    for (j = 0; j < GPR_ARRAY_SIZE(uncompressed_split_modes); j++) {
+      for (k = 0; k < GPR_ARRAY_SIZE(compressed_split_modes); k++) {
+        for (m = 0; m < TEST_VALUE_COUNT; m++) {
+          gpr_slice slice = create_test_value(m);
+          assert_passthrough(slice, i, j, k, get_compressability(m, i));
+          gpr_slice_unref(slice);
+        }
+      }
+    }
+  }
+
+  test_bad_data();
+
+  return 0;
+}
diff --git a/test/core/echo/client.c b/test/core/echo/client.c
new file mode 100644
index 0000000..1905863
--- /dev/null
+++ b/test/core/echo/client.c
@@ -0,0 +1,139 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <grpc/grpc.h>
+
+#include <string.h>
+
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include <grpc/byte_buffer.h>
+#include "test/core/util/test_config.h"
+
+enum { WRITE_SLICE_LENGTH = 1024, TOTAL_BYTES = 102400 };
+
+/* Start write the next slice, fill slice.data[0..length - 1] with first % 256,
+   (first + 1) % 256, ... (first + length - 1) % 256.
+   Produce a GRPC_WRITE_ACCEPTED event  */
+static void start_write_next_slice(grpc_call *call, int first, int length) {
+  int i = 0;
+  grpc_byte_buffer *byte_buffer = NULL;
+  gpr_slice slice = gpr_slice_malloc(length);
+  for (i = 0; i < length; i++)
+    GPR_SLICE_START_PTR(slice)[i] = (first + i) % 256;
+  byte_buffer = grpc_byte_buffer_create(&slice, 1);
+  GPR_ASSERT(grpc_call_start_write(call, byte_buffer, (void *)1, 0) ==
+             GRPC_CALL_OK);
+  gpr_slice_unref(slice);
+  grpc_byte_buffer_destroy(byte_buffer);
+}
+
+int main(int argc, char **argv) {
+  grpc_channel *channel = NULL;
+  grpc_call *call = NULL;
+  grpc_event *ev = NULL;
+  grpc_byte_buffer_reader *bb_reader = NULL;
+  grpc_completion_queue *cq = NULL;
+  int bytes_written = 0;
+  int bytes_read = 0;
+  int i = 0;
+  int waiting_finishes;
+  gpr_slice read_slice;
+
+  grpc_test_init(argc, argv);
+
+  grpc_init();
+
+  cq = grpc_completion_queue_create();
+
+  GPR_ASSERT(argc == 2);
+  channel = grpc_channel_create(argv[1], NULL);
+  call = grpc_channel_create_call(channel, "/foo", "localhost", gpr_inf_future);
+  GPR_ASSERT(grpc_call_start_invoke(call, cq, (void *)1, (void *)1, (void *)1,
+                                    0) == GRPC_CALL_OK);
+  ev = grpc_completion_queue_next(cq, gpr_inf_future);
+  GPR_ASSERT(ev->data.invoke_accepted == GRPC_OP_OK);
+  grpc_event_finish(ev);
+
+  start_write_next_slice(call, bytes_written, WRITE_SLICE_LENGTH);
+  bytes_written += WRITE_SLICE_LENGTH;
+  GPR_ASSERT(grpc_call_start_read(call, (void *)1) == GRPC_CALL_OK);
+  waiting_finishes = 2;
+  while (waiting_finishes) {
+    ev = grpc_completion_queue_next(cq, gpr_inf_future);
+    switch (ev->type) {
+      case GRPC_WRITE_ACCEPTED:
+        if (bytes_written < TOTAL_BYTES) {
+          start_write_next_slice(call, bytes_written, WRITE_SLICE_LENGTH);
+          bytes_written += WRITE_SLICE_LENGTH;
+        } else {
+          GPR_ASSERT(grpc_call_writes_done(call, (void *)1) == GRPC_CALL_OK);
+        }
+        break;
+      case GRPC_CLIENT_METADATA_READ:
+        break;
+      case GRPC_READ:
+        bb_reader = grpc_byte_buffer_reader_create(ev->data.read);
+        while (grpc_byte_buffer_reader_next(bb_reader, &read_slice)) {
+          for (i = 0; i < GPR_SLICE_LENGTH(read_slice); i++) {
+            GPR_ASSERT(GPR_SLICE_START_PTR(read_slice)[i] == bytes_read % 256);
+            bytes_read++;
+          }
+          gpr_slice_unref(read_slice);
+        }
+        grpc_byte_buffer_reader_destroy(bb_reader);
+        if (bytes_read < TOTAL_BYTES) {
+          GPR_ASSERT(grpc_call_start_read(call, (void *)1) == GRPC_CALL_OK);
+        }
+        break;
+      case GRPC_FINISHED:
+      case GRPC_FINISH_ACCEPTED:
+        waiting_finishes--;
+        break;
+      default:
+        GPR_ASSERT(0 && "unexpected event");
+        break;
+    }
+    grpc_event_finish(ev);
+  }
+  GPR_ASSERT(bytes_read == TOTAL_BYTES);
+  gpr_log(GPR_INFO, "All data have been successfully echoed");
+
+  grpc_call_destroy(call);
+  grpc_channel_destroy(channel);
+  grpc_completion_queue_destroy(cq);
+
+  grpc_shutdown();
+
+  return 0;
+}
diff --git a/test/core/echo/echo_test.c b/test/core/echo/echo_test.c
new file mode 100644
index 0000000..c699f1e
--- /dev/null
+++ b/test/core/echo/echo_test.c
@@ -0,0 +1,106 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#define _POSIX_SOURCE
+#include <unistd.h>
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/host_port.h>
+#include <grpc/support/string.h>
+#include "test/core/util/port.h"
+
+static const char *const kHosts[] = {
+    "127.0.0.1", "::1", "::ffff:127.0.0.1", "localhost",
+};
+
+int main(int argc, char **argv) {
+  char *me = argv[0];
+  char *lslash = strrchr(me, '/');
+  char root[1024];
+  int port = grpc_pick_unused_port_or_die();
+  char *args[3];
+  int status;
+  pid_t svr, cli;
+  int i;
+  /* figure out where we are */
+  if (lslash) {
+    memcpy(root, me, lslash - me);
+    root[lslash - me] = 0;
+  } else {
+    strcpy(root, ".");
+  }
+  /* start the server */
+  svr = fork();
+  if (svr == 0) {
+    gpr_asprintf(&args[0], "%s/echo_server", root);
+    gpr_join_host_port(&args[1], "::", port);
+    args[2] = 0;
+    execv(args[0], args);
+
+    gpr_free(args[0]);
+    gpr_free(args[1]);
+    return 1;
+  }
+  /* wait a little */
+  sleep(2);
+  /* start the clients */
+  for (i = 0; i < sizeof(kHosts) / sizeof(*kHosts); i++) {
+    cli = fork();
+    if (cli == 0) {
+      gpr_asprintf(&args[0], "%s/echo_client", root);
+      gpr_join_host_port(&args[1], kHosts[i], port);
+      args[2] = 0;
+      execv(args[0], args);
+
+      gpr_free(args[0]);
+      gpr_free(args[1]);
+      return 1;
+    }
+    /* wait for client */
+    printf("waiting for client: %s\n", kHosts[i]);
+    if (waitpid(cli, &status, 0) == -1) return 2;
+    if (!WIFEXITED(status)) return 4;
+    if (WEXITSTATUS(status)) return WEXITSTATUS(status);
+  }
+  /* wait for server */
+  printf("checking server\n");
+  if (waitpid(svr, &status, WNOHANG) != 0) return 2;
+  kill(svr, SIGKILL);
+  return 0;
+}
diff --git a/test/core/echo/server.c b/test/core/echo/server.c
new file mode 100644
index 0000000..77383f8
--- /dev/null
+++ b/test/core/echo/server.c
@@ -0,0 +1,149 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <grpc/grpc.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include "test/core/util/test_config.h"
+#include <grpc/support/alloc.h>
+#include <grpc/support/host_port.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string.h>
+#include <grpc/support/time.h>
+#include "test/core/util/port.h"
+
+static grpc_completion_queue *cq;
+static grpc_server *server;
+
+static const grpc_status status_ok = {GRPC_STATUS_OK, NULL};
+
+typedef struct {
+  gpr_refcount pending_ops;
+  gpr_intmax bytes_read;
+} call_state;
+
+static void request_call() {
+  call_state *tag = gpr_malloc(sizeof(*tag));
+  gpr_ref_init(&tag->pending_ops, 2);
+  tag->bytes_read = 0;
+  grpc_server_request_call(server, tag);
+}
+
+static void assert_read_ok(call_state *s, grpc_byte_buffer *b) {
+  grpc_byte_buffer_reader *bb_reader = NULL;
+  gpr_slice read_slice;
+  int i;
+
+  bb_reader = grpc_byte_buffer_reader_create(b);
+  while (grpc_byte_buffer_reader_next(bb_reader, &read_slice)) {
+    for (i = 0; i < GPR_SLICE_LENGTH(read_slice); i++) {
+      GPR_ASSERT(GPR_SLICE_START_PTR(read_slice)[i] == s->bytes_read % 256);
+      s->bytes_read++;
+    }
+    gpr_slice_unref(read_slice);
+  }
+  grpc_byte_buffer_reader_destroy(bb_reader);
+}
+
+int main(int argc, char **argv) {
+  grpc_event *ev;
+  char *addr;
+  call_state *s;
+
+  grpc_test_init(argc, argv);
+
+  grpc_init();
+  srand(clock());
+
+  if (argc == 2) {
+    addr = gpr_strdup(argv[1]);
+  } else {
+    gpr_join_host_port(&addr, "::", grpc_pick_unused_port_or_die());
+  }
+  gpr_log(GPR_INFO, "creating server on: %s", addr);
+
+  cq = grpc_completion_queue_create();
+  server = grpc_server_create(cq, NULL);
+  GPR_ASSERT(grpc_server_add_http2_port(server, addr));
+  gpr_free(addr);
+  grpc_server_start(server);
+
+  request_call();
+
+  for (;;) {
+    ev = grpc_completion_queue_next(cq, gpr_inf_future);
+    GPR_ASSERT(ev);
+    s = ev->tag;
+    switch (ev->type) {
+      case GRPC_SERVER_RPC_NEW:
+        /* initial ops are already started in request_call */
+        grpc_call_accept(ev->call, cq, s, GRPC_WRITE_BUFFER_HINT);
+        GPR_ASSERT(grpc_call_start_read(ev->call, s) == GRPC_CALL_OK);
+        request_call();
+        break;
+      case GRPC_WRITE_ACCEPTED:
+        GPR_ASSERT(ev->data.write_accepted == GRPC_OP_OK);
+        GPR_ASSERT(grpc_call_start_read(ev->call, s) == GRPC_CALL_OK);
+        break;
+      case GRPC_READ:
+        if (ev->data.read) {
+          assert_read_ok(ev->tag, ev->data.read);
+          GPR_ASSERT(grpc_call_start_write(ev->call, ev->data.read, s,
+                                           GRPC_WRITE_BUFFER_HINT) ==
+                     GRPC_CALL_OK);
+        } else {
+          GPR_ASSERT(grpc_call_start_write_status(ev->call, status_ok, s) ==
+                     GRPC_CALL_OK);
+        }
+        break;
+      case GRPC_FINISH_ACCEPTED:
+      case GRPC_FINISHED:
+        if (gpr_unref(&s->pending_ops)) {
+          grpc_call_destroy(ev->call);
+          gpr_free(s);
+        }
+        break;
+      default:
+        abort();
+    }
+    grpc_event_finish(ev);
+  }
+
+  grpc_shutdown();
+
+  return 0;
+}
diff --git a/test/core/end2end/README b/test/core/end2end/README
new file mode 100644
index 0000000..31598b6
--- /dev/null
+++ b/test/core/end2end/README
@@ -0,0 +1,10 @@
+Each fixture (under fixtures/) is paired with each test (under tests/) and
+forms a complete end-to-end test.
+
+To add a new test or fixture:
+- add the code to the relevant directory
+- update gen_build_json.py to reflect the change
+- regenerate projects
+// MOE:begin_strip
+- update net/grpc/c/BUILD to reflect the change
+// MOE:end_strip
\ No newline at end of file
diff --git a/test/core/end2end/cq_verifier.c b/test/core/end2end/cq_verifier.c
new file mode 100644
index 0000000..aebb8b4
--- /dev/null
+++ b/test/core/end2end/cq_verifier.c
@@ -0,0 +1,473 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/cq_verifier.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "src/core/surface/event_string.h"
+#include <grpc/byte_buffer.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string.h>
+#include <grpc/support/time.h>
+#include <grpc/support/useful.h>
+
+/* a set of metadata we expect to find on an event */
+typedef struct metadata {
+  size_t count;
+  size_t cap;
+  const char **keys;
+  const char **values;
+} metadata;
+
+/* details what we expect to find on a single event - and forms a linked
+   list to detail other expectations */
+typedef struct expectation {
+  struct expectation *next;
+  struct expectation *prev;
+  grpc_completion_type type;
+  void *tag;
+  union {
+    grpc_op_error finish_accepted;
+    grpc_op_error write_accepted;
+    grpc_op_error invoke_accepted;
+    struct {
+      const char *method;
+      const char *host;
+      gpr_timespec deadline;
+      grpc_call **output_call;
+      metadata *metadata;
+    } server_rpc_new;
+    metadata *client_metadata_read;
+    struct {
+      grpc_status status;
+      metadata *metadata;
+    } finished;
+    gpr_slice *read;
+  } data;
+} expectation;
+
+/* the verifier itself */
+struct cq_verifier {
+  /* bound completion queue */
+  grpc_completion_queue *cq;
+  /* the root/sentinal expectation */
+  expectation expect;
+};
+
+cq_verifier *cq_verifier_create(grpc_completion_queue *cq) {
+  cq_verifier *v = gpr_malloc(sizeof(cq_verifier));
+  v->expect.type = GRPC_COMPLETION_DO_NOT_USE;
+  v->expect.tag = NULL;
+  v->expect.next = &v->expect;
+  v->expect.prev = &v->expect;
+  v->cq = cq;
+  return v;
+}
+
+void cq_verifier_destroy(cq_verifier *v) {
+  cq_verify(v);
+  gpr_free(v);
+}
+
+static int has_metadata(const grpc_metadata *md, size_t count, const char *key,
+                        const char *value) {
+  size_t i;
+  for (i = 0; i < count; i++) {
+    if (0 == strcmp(key, md[i].key) && strlen(value) == md[i].value_length &&
+        0 == memcmp(md[i].value, value, md[i].value_length)) {
+      return 1;
+    }
+  }
+  return 0;
+}
+
+static void verify_and_destroy_metadata(metadata *md, grpc_metadata *elems,
+                                        size_t count) {
+  size_t i;
+  for (i = 0; i < md->count; i++) {
+    GPR_ASSERT(has_metadata(elems, count, md->keys[i], md->values[i]));
+  }
+  gpr_free(md->keys);
+  gpr_free(md->values);
+  gpr_free(md);
+}
+
+static gpr_slice merge_slices(gpr_slice *slices, int nslices) {
+  size_t i;
+  size_t len = 0;
+  gpr_uint8 *cursor;
+  gpr_slice out;
+
+  for (i = 0; i < nslices; i++) {
+    len += GPR_SLICE_LENGTH(slices[i]);
+  }
+
+  out = gpr_slice_malloc(len);
+  cursor = GPR_SLICE_START_PTR(out);
+
+  for (i = 0; i < nslices; i++) {
+    memcpy(cursor, GPR_SLICE_START_PTR(slices[i]), GPR_SLICE_LENGTH(slices[i]));
+    cursor += GPR_SLICE_LENGTH(slices[i]);
+  }
+
+  return out;
+}
+
+static int byte_buffer_eq_slice(grpc_byte_buffer *bb, gpr_slice b) {
+  gpr_slice a =
+      merge_slices(bb->data.slice_buffer.slices, bb->data.slice_buffer.count);
+  int ok = GPR_SLICE_LENGTH(a) == GPR_SLICE_LENGTH(b) &&
+           0 == memcmp(GPR_SLICE_START_PTR(a), GPR_SLICE_START_PTR(b),
+                       GPR_SLICE_LENGTH(a));
+  gpr_slice_unref(a);
+  gpr_slice_unref(b);
+  return ok;
+}
+
+static int string_equivalent(const char *a, const char *b) {
+  if (a == NULL) return b == NULL || b[0] == 0;
+  if (b == NULL) return a[0] == 0;
+  return strcmp(a, b) == 0;
+}
+
+static void verify_matches(expectation *e, grpc_event *ev) {
+  GPR_ASSERT(e->type == ev->type);
+  switch (e->type) {
+    case GRPC_FINISH_ACCEPTED:
+      GPR_ASSERT(e->data.finish_accepted == ev->data.finish_accepted);
+      break;
+    case GRPC_WRITE_ACCEPTED:
+      GPR_ASSERT(e->data.write_accepted == ev->data.write_accepted);
+      break;
+    case GRPC_INVOKE_ACCEPTED:
+      GPR_ASSERT(e->data.invoke_accepted == ev->data.invoke_accepted);
+      break;
+    case GRPC_SERVER_RPC_NEW:
+      GPR_ASSERT(string_equivalent(e->data.server_rpc_new.method,
+                                   ev->data.server_rpc_new.method));
+      GPR_ASSERT(string_equivalent(e->data.server_rpc_new.host,
+                                   ev->data.server_rpc_new.host));
+      GPR_ASSERT(gpr_time_cmp(e->data.server_rpc_new.deadline,
+                              ev->data.server_rpc_new.deadline) <= 0);
+      *e->data.server_rpc_new.output_call = ev->call;
+      verify_and_destroy_metadata(e->data.server_rpc_new.metadata,
+                                  ev->data.server_rpc_new.metadata_elements,
+                                  ev->data.server_rpc_new.metadata_count);
+      break;
+    case GRPC_CLIENT_METADATA_READ:
+      verify_and_destroy_metadata(e->data.client_metadata_read,
+                                  ev->data.client_metadata_read.elements,
+                                  ev->data.client_metadata_read.count);
+      break;
+    case GRPC_FINISHED:
+      if (e->data.finished.status.code != GRPC_STATUS__DO_NOT_USE) {
+        GPR_ASSERT(e->data.finished.status.code == ev->data.finished.code);
+        GPR_ASSERT(string_equivalent(e->data.finished.status.details,
+                                     ev->data.finished.details));
+      }
+      verify_and_destroy_metadata(e->data.finished.metadata, NULL, 0);
+      break;
+    case GRPC_QUEUE_SHUTDOWN:
+      gpr_log(GPR_ERROR, "premature queue shutdown");
+      abort();
+      break;
+    case GRPC_READ:
+      if (e->data.read) {
+        GPR_ASSERT(byte_buffer_eq_slice(ev->data.read, *e->data.read));
+        gpr_free(e->data.read);
+      } else {
+        GPR_ASSERT(ev->data.read == NULL);
+      }
+      break;
+    case GRPC_COMPLETION_DO_NOT_USE:
+      gpr_log(GPR_ERROR, "not implemented");
+      abort();
+      break;
+  }
+}
+
+static char *metadata_expectation_string(metadata *md) {
+  size_t len;
+  size_t i;
+  char *out;
+  char *p;
+
+  if (!md) return gpr_strdup("nil");
+
+  for (len = 0, i = 0; i < md->count; i++) {
+    len += strlen(md->keys[i]);
+    len += strlen(md->values[i]);
+  }
+  len += 3 + md->count;
+
+  p = out = gpr_malloc(len);
+  *p++ = '{';
+  for (i = 0; i < md->count; i++) {
+    if (i) *p++ = ',';
+    p += sprintf(p, "%s:%s", md->keys[i], md->values[i]);
+  }
+  *p++ = '}';
+  *p++ = 0;
+  return out;
+}
+
+static size_t expectation_to_string(char *out, expectation *e) {
+  gpr_timespec timeout;
+  char *str = NULL;
+  size_t len;
+
+  switch (e->type) {
+    case GRPC_FINISH_ACCEPTED:
+      return sprintf(out, "GRPC_FINISH_ACCEPTED result=%d",
+                     e->data.finish_accepted);
+    case GRPC_WRITE_ACCEPTED:
+      return sprintf(out, "GRPC_WRITE_ACCEPTED result=%d",
+                     e->data.write_accepted);
+    case GRPC_INVOKE_ACCEPTED:
+      return sprintf(out, "GRPC_INVOKE_ACCEPTED result=%d",
+                     e->data.invoke_accepted);
+    case GRPC_SERVER_RPC_NEW:
+      timeout = gpr_time_sub(e->data.server_rpc_new.deadline, gpr_now());
+      return sprintf(out, "GRPC_SERVER_RPC_NEW method=%s host=%s timeout=%fsec",
+                     e->data.server_rpc_new.method, e->data.server_rpc_new.host,
+                     timeout.tv_sec + 1e-9 * timeout.tv_nsec);
+    case GRPC_CLIENT_METADATA_READ:
+      str = metadata_expectation_string(e->data.client_metadata_read);
+      len = sprintf(out, "GRPC_CLIENT_METADATA_READ %s", str);
+      gpr_free(str);
+      return len;
+    case GRPC_FINISHED:
+      str = metadata_expectation_string(e->data.finished.metadata);
+      len = sprintf(out, "GRPC_FINISHED code=%d details=%s %s",
+                    e->data.finished.status.code,
+                    e->data.finished.status.details, str);
+      gpr_free(str);
+      return len;
+    case GRPC_READ:
+      if (e->data.read) {
+        str =
+            gpr_hexdump((char *)GPR_SLICE_START_PTR(*e->data.read),
+                        GPR_SLICE_LENGTH(*e->data.read), GPR_HEXDUMP_PLAINTEXT);
+      }
+      len = sprintf(out, "GRPC_READ data=%s", str);
+      gpr_free(str);
+      return len;
+    case GRPC_COMPLETION_DO_NOT_USE:
+    case GRPC_QUEUE_SHUTDOWN:
+      gpr_log(GPR_ERROR, "not implemented");
+      abort();
+      break;
+  }
+  return 0;
+}
+
+static char *expectations_to_string(cq_verifier *v) {
+  /* allocate a large buffer: we're about to crash anyway */
+  char *buffer = gpr_malloc(32 * 1024 * 1024);
+  char *p = buffer;
+  expectation *e;
+
+  for (e = v->expect.next; e != &v->expect; e = e->next) {
+    p += expectation_to_string(p, e);
+    *p++ = '\n';
+  }
+
+  *p = 0;
+  return buffer;
+}
+
+static void fail_no_event_received(cq_verifier *v) {
+  char *expectations = expectations_to_string(v);
+  gpr_log(GPR_ERROR, "no event received, but expected:\n%s", expectations);
+  gpr_free(expectations);
+  abort();
+}
+
+void cq_verify(cq_verifier *v) {
+  gpr_timespec deadline =
+      gpr_time_add(gpr_now(), gpr_time_from_micros(10 * GPR_US_PER_SEC));
+  grpc_event *ev;
+  expectation *e;
+
+  char have_tags[512] = {0};
+  char *phave = have_tags;
+
+  while (v->expect.next != &v->expect) {
+    ev = grpc_completion_queue_next(v->cq, deadline);
+    if (!ev) {
+      fail_no_event_received(v);
+    }
+
+    for (e = v->expect.next; e != &v->expect; e = e->next) {
+      phave += sprintf(phave, " %p", e->tag);
+      if (e->tag == ev->tag) {
+        verify_matches(e, ev);
+        e->next->prev = e->prev;
+        e->prev->next = e->next;
+        gpr_free(e);
+        break;
+      }
+    }
+    if (e == &v->expect) {
+      char *s = grpc_event_string(ev);
+      gpr_log(GPR_ERROR, "event not found: %s", s);
+      gpr_log(GPR_ERROR, "have tags:%s", have_tags);
+      gpr_free(s);
+      abort();
+    }
+
+    grpc_event_finish(ev);
+  }
+}
+
+void cq_verify_empty(cq_verifier *v) {
+  gpr_timespec deadline =
+      gpr_time_add(gpr_now(), gpr_time_from_micros(3000000));
+  grpc_event *ev;
+
+  GPR_ASSERT(v->expect.next == &v->expect && "expectation queue must be empty");
+
+  ev = grpc_completion_queue_next(v->cq, deadline);
+  GPR_ASSERT(ev == NULL);
+}
+
+static expectation *add(cq_verifier *v, grpc_completion_type type, void *tag) {
+  expectation *e = gpr_malloc(sizeof(expectation));
+  e->type = type;
+  e->tag = tag;
+  e->next = &v->expect;
+  e->prev = e->next->prev;
+  e->next->prev = e->prev->next = e;
+  return e;
+}
+
+static metadata *metadata_from_args(va_list args) {
+  metadata *md = gpr_malloc(sizeof(metadata));
+  const char *key, *value;
+  md->count = 0;
+  md->cap = 0;
+  md->keys = NULL;
+  md->values = NULL;
+
+  for (;;) {
+    key = va_arg(args, const char *);
+    if (!key) return md;
+    value = va_arg(args, const char *);
+    GPR_ASSERT(value);
+
+    if (md->cap == md->count) {
+      md->cap = GPR_MAX(md->cap + 1, md->cap * 3 / 2);
+      md->keys = gpr_realloc(md->keys, sizeof(const char *) * md->cap);
+      md->values = gpr_realloc(md->values, sizeof(const char *) * md->cap);
+    }
+    md->keys[md->count] = key;
+    md->values[md->count] = value;
+    md->count++;
+  }
+}
+
+void cq_expect_invoke_accepted(cq_verifier *v, void *tag,
+                               grpc_op_error result) {
+  add(v, GRPC_INVOKE_ACCEPTED, tag)->data.invoke_accepted = result;
+}
+
+void cq_expect_write_accepted(cq_verifier *v, void *tag, grpc_op_error result) {
+  add(v, GRPC_WRITE_ACCEPTED, tag)->data.write_accepted = result;
+}
+
+void cq_expect_finish_accepted(cq_verifier *v, void *tag,
+                               grpc_op_error result) {
+  add(v, GRPC_FINISH_ACCEPTED, tag)->data.finish_accepted = result;
+}
+
+void cq_expect_read(cq_verifier *v, void *tag, gpr_slice bytes) {
+  expectation *e = add(v, GRPC_READ, tag);
+  e->data.read = gpr_malloc(sizeof(gpr_slice));
+  *e->data.read = bytes;
+}
+
+void cq_expect_empty_read(cq_verifier *v, void *tag) {
+  expectation *e = add(v, GRPC_READ, tag);
+  e->data.read = NULL;
+}
+
+void cq_expect_server_rpc_new(cq_verifier *v, grpc_call **output_call,
+                              void *tag, const char *method, const char *host,
+                              gpr_timespec deadline, ...) {
+  va_list args;
+  expectation *e = add(v, GRPC_SERVER_RPC_NEW, tag);
+  e->data.server_rpc_new.method = method;
+  e->data.server_rpc_new.host = host;
+  e->data.server_rpc_new.deadline = deadline;
+  e->data.server_rpc_new.output_call = output_call;
+
+  va_start(args, deadline);
+  e->data.server_rpc_new.metadata = metadata_from_args(args);
+  va_end(args);
+}
+
+void cq_expect_client_metadata_read(cq_verifier *v, void *tag, ...) {
+  va_list args;
+  expectation *e = add(v, GRPC_CLIENT_METADATA_READ, tag);
+
+  va_start(args, tag);
+  e->data.client_metadata_read = metadata_from_args(args);
+  va_end(args);
+}
+
+static void finished_internal(cq_verifier *v, void *tag, grpc_status status,
+                              va_list args) {
+  expectation *e = add(v, GRPC_FINISHED, tag);
+  e->data.finished.status = status;
+  e->data.finished.metadata = metadata_from_args(args);
+}
+
+void cq_expect_finished_with_status(cq_verifier *v, void *tag,
+                                    grpc_status status, ...) {
+  va_list args;
+  va_start(args, status);
+  finished_internal(v, tag, status, args);
+  va_end(args);
+}
+
+void cq_expect_finished(cq_verifier *v, void *tag, ...) {
+  va_list args;
+  grpc_status status = {GRPC_STATUS__DO_NOT_USE, NULL};
+  va_start(args, tag);
+  finished_internal(v, tag, status, args);
+  va_end(args);
+}
diff --git a/test/core/end2end/cq_verifier.h b/test/core/end2end/cq_verifier.h
new file mode 100644
index 0000000..60f56bd
--- /dev/null
+++ b/test/core/end2end/cq_verifier.h
@@ -0,0 +1,73 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef __GRPC_TEST_END2END_CQ_VERIFIER_H__
+#define __GRPC_TEST_END2END_CQ_VERIFIER_H__
+
+#include <grpc/grpc.h>
+
+/* A cq_verifier can verify that expected events arrive in a timely fashion
+   on a single completion queue */
+
+typedef struct cq_verifier cq_verifier;
+
+/* construct/destroy a cq_verifier */
+cq_verifier *cq_verifier_create(grpc_completion_queue *cq);
+void cq_verifier_destroy(cq_verifier *v);
+
+/* ensure all expected events (and only those events) are present on the
+   bound completion queue */
+void cq_verify(cq_verifier *v);
+
+/* ensure that the completion queue is empty */
+void cq_verify_empty(cq_verifier *v);
+
+/* Various expectation matchers
+   Any functions taking ... expect a NULL terminated list of key/value pairs
+   (each pair using two parameter slots) of metadata that MUST be present in
+   the event. */
+void cq_expect_invoke_accepted(cq_verifier *v, void *tag, grpc_op_error result);
+void cq_expect_write_accepted(cq_verifier *v, void *tag, grpc_op_error result);
+void cq_expect_finish_accepted(cq_verifier *v, void *tag, grpc_op_error result);
+void cq_expect_read(cq_verifier *v, void *tag, gpr_slice bytes);
+void cq_expect_empty_read(cq_verifier *v, void *tag);
+/* *output_call is set the the server call instance */
+void cq_expect_server_rpc_new(cq_verifier *v, grpc_call **output_call,
+                              void *tag, const char *method, const char *host,
+                              gpr_timespec deadline, ...);
+void cq_expect_client_metadata_read(cq_verifier *v, void *tag, ...);
+void cq_expect_finished_with_status(cq_verifier *v, void *tag,
+                                    grpc_status status, ...);
+void cq_expect_finished(cq_verifier *v, void *tag, ...);
+
+#endif  /* __GRPC_TEST_END2END_CQ_VERIFIER_H__ */
diff --git a/test/core/end2end/data/ca_cert.c b/test/core/end2end/data/ca_cert.c
new file mode 100644
index 0000000..458b7f0
--- /dev/null
+++ b/test/core/end2end/data/ca_cert.c
@@ -0,0 +1,102 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+unsigned char test_ca_cert[] = {
+    0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20, 0x43,
+    0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d,
+    0x2d, 0x2d, 0x2d, 0x0a, 0x4d, 0x49, 0x49, 0x43, 0x49, 0x7a, 0x43, 0x43,
+    0x41, 0x59, 0x77, 0x43, 0x43, 0x51, 0x43, 0x46, 0x54, 0x62, 0x46, 0x37,
+    0x58, 0x4e, 0x53, 0x76, 0x76, 0x6a, 0x41, 0x4e, 0x42, 0x67, 0x6b, 0x71,
+    0x68, 0x6b, 0x69, 0x47, 0x39, 0x77, 0x30, 0x42, 0x41, 0x51, 0x55, 0x46,
+    0x41, 0x44, 0x42, 0x57, 0x4d, 0x51, 0x73, 0x77, 0x43, 0x51, 0x59, 0x44,
+    0x56, 0x51, 0x51, 0x47, 0x45, 0x77, 0x4a, 0x42, 0x0a, 0x56, 0x54, 0x45,
+    0x54, 0x4d, 0x42, 0x45, 0x47, 0x41, 0x31, 0x55, 0x45, 0x43, 0x41, 0x77,
+    0x4b, 0x55, 0x32, 0x39, 0x74, 0x5a, 0x53, 0x31, 0x54, 0x64, 0x47, 0x46,
+    0x30, 0x5a, 0x54, 0x45, 0x68, 0x4d, 0x42, 0x38, 0x47, 0x41, 0x31, 0x55,
+    0x45, 0x43, 0x67, 0x77, 0x59, 0x53, 0x57, 0x35, 0x30, 0x5a, 0x58, 0x4a,
+    0x75, 0x5a, 0x58, 0x51, 0x67, 0x56, 0x32, 0x6c, 0x6b, 0x5a, 0x32, 0x6c,
+    0x30, 0x0a, 0x63, 0x79, 0x42, 0x51, 0x64, 0x48, 0x6b, 0x67, 0x54, 0x48,
+    0x52, 0x6b, 0x4d, 0x51, 0x38, 0x77, 0x44, 0x51, 0x59, 0x44, 0x56, 0x51,
+    0x51, 0x44, 0x44, 0x41, 0x5a, 0x30, 0x5a, 0x58, 0x4e, 0x30, 0x59, 0x32,
+    0x45, 0x77, 0x48, 0x68, 0x63, 0x4e, 0x4d, 0x54, 0x51, 0x77, 0x4e, 0x7a,
+    0x45, 0x33, 0x4d, 0x6a, 0x4d, 0x78, 0x4e, 0x7a, 0x55, 0x78, 0x57, 0x68,
+    0x63, 0x4e, 0x4d, 0x6a, 0x51, 0x77, 0x0a, 0x4e, 0x7a, 0x45, 0x30, 0x4d,
+    0x6a, 0x4d, 0x78, 0x4e, 0x7a, 0x55, 0x78, 0x57, 0x6a, 0x42, 0x57, 0x4d,
+    0x51, 0x73, 0x77, 0x43, 0x51, 0x59, 0x44, 0x56, 0x51, 0x51, 0x47, 0x45,
+    0x77, 0x4a, 0x42, 0x56, 0x54, 0x45, 0x54, 0x4d, 0x42, 0x45, 0x47, 0x41,
+    0x31, 0x55, 0x45, 0x43, 0x41, 0x77, 0x4b, 0x55, 0x32, 0x39, 0x74, 0x5a,
+    0x53, 0x31, 0x54, 0x64, 0x47, 0x46, 0x30, 0x5a, 0x54, 0x45, 0x68, 0x0a,
+    0x4d, 0x42, 0x38, 0x47, 0x41, 0x31, 0x55, 0x45, 0x43, 0x67, 0x77, 0x59,
+    0x53, 0x57, 0x35, 0x30, 0x5a, 0x58, 0x4a, 0x75, 0x5a, 0x58, 0x51, 0x67,
+    0x56, 0x32, 0x6c, 0x6b, 0x5a, 0x32, 0x6c, 0x30, 0x63, 0x79, 0x42, 0x51,
+    0x64, 0x48, 0x6b, 0x67, 0x54, 0x48, 0x52, 0x6b, 0x4d, 0x51, 0x38, 0x77,
+    0x44, 0x51, 0x59, 0x44, 0x56, 0x51, 0x51, 0x44, 0x44, 0x41, 0x5a, 0x30,
+    0x5a, 0x58, 0x4e, 0x30, 0x0a, 0x59, 0x32, 0x45, 0x77, 0x67, 0x5a, 0x38,
+    0x77, 0x44, 0x51, 0x59, 0x4a, 0x4b, 0x6f, 0x5a, 0x49, 0x68, 0x76, 0x63,
+    0x4e, 0x41, 0x51, 0x45, 0x42, 0x42, 0x51, 0x41, 0x44, 0x67, 0x59, 0x30,
+    0x41, 0x4d, 0x49, 0x47, 0x4a, 0x41, 0x6f, 0x47, 0x42, 0x41, 0x4d, 0x42,
+    0x41, 0x33, 0x77, 0x56, 0x65, 0x54, 0x47, 0x48, 0x5a, 0x52, 0x31, 0x52,
+    0x79, 0x65, 0x2f, 0x69, 0x2b, 0x4a, 0x38, 0x61, 0x32, 0x0a, 0x63, 0x75,
+    0x35, 0x67, 0x58, 0x77, 0x46, 0x56, 0x36, 0x54, 0x6e, 0x4f, 0x62, 0x7a,
+    0x47, 0x4d, 0x37, 0x62, 0x4c, 0x46, 0x43, 0x4f, 0x35, 0x69, 0x39, 0x76,
+    0x34, 0x6d, 0x4c, 0x6f, 0x34, 0x69, 0x46, 0x7a, 0x50, 0x73, 0x48, 0x6d,
+    0x57, 0x44, 0x55, 0x78, 0x4b, 0x53, 0x33, 0x59, 0x38, 0x69, 0x58, 0x62,
+    0x75, 0x30, 0x65, 0x59, 0x42, 0x6c, 0x4c, 0x6f, 0x4e, 0x59, 0x30, 0x6c,
+    0x53, 0x76, 0x0a, 0x78, 0x44, 0x78, 0x33, 0x33, 0x4f, 0x2b, 0x44, 0x75,
+    0x77, 0x4d, 0x6d, 0x56, 0x4e, 0x2b, 0x44, 0x7a, 0x53, 0x44, 0x2b, 0x45,
+    0x6f, 0x64, 0x39, 0x7a, 0x66, 0x76, 0x77, 0x4f, 0x57, 0x48, 0x73, 0x61,
+    0x7a, 0x59, 0x43, 0x5a, 0x54, 0x32, 0x50, 0x68, 0x4e, 0x78, 0x6e, 0x56,
+    0x57, 0x49, 0x75, 0x4a, 0x58, 0x56, 0x69, 0x59, 0x34, 0x4a, 0x41, 0x48,
+    0x55, 0x47, 0x6f, 0x64, 0x6a, 0x78, 0x2b, 0x0a, 0x51, 0x41, 0x69, 0x36,
+    0x79, 0x43, 0x41, 0x75, 0x72, 0x55, 0x5a, 0x47, 0x76, 0x59, 0x58, 0x47,
+    0x67, 0x5a, 0x53, 0x42, 0x41, 0x67, 0x4d, 0x42, 0x41, 0x41, 0x45, 0x77,
+    0x44, 0x51, 0x59, 0x4a, 0x4b, 0x6f, 0x5a, 0x49, 0x68, 0x76, 0x63, 0x4e,
+    0x41, 0x51, 0x45, 0x46, 0x42, 0x51, 0x41, 0x44, 0x67, 0x59, 0x45, 0x41,
+    0x51, 0x6f, 0x51, 0x56, 0x44, 0x38, 0x62, 0x77, 0x64, 0x74, 0x57, 0x4a,
+    0x0a, 0x41, 0x6e, 0x69, 0x47, 0x42, 0x77, 0x63, 0x43, 0x66, 0x71, 0x59,
+    0x79, 0x48, 0x2b, 0x2f, 0x4b, 0x70, 0x41, 0x31, 0x30, 0x41, 0x63, 0x65,
+    0x62, 0x4a, 0x56, 0x56, 0x54, 0x79, 0x59, 0x62, 0x59, 0x76, 0x49, 0x39,
+    0x51, 0x38, 0x64, 0x36, 0x52, 0x53, 0x56, 0x75, 0x34, 0x50, 0x5a, 0x79,
+    0x39, 0x4f, 0x41, 0x4c, 0x48, 0x52, 0x2f, 0x51, 0x72, 0x57, 0x42, 0x64,
+    0x59, 0x54, 0x41, 0x79, 0x7a, 0x0a, 0x66, 0x4e, 0x41, 0x6d, 0x63, 0x32,
+    0x63, 0x6d, 0x64, 0x6b, 0x53, 0x52, 0x4a, 0x7a, 0x6a, 0x68, 0x49, 0x61,
+    0x4f, 0x73, 0x74, 0x6e, 0x51, 0x79, 0x31, 0x4a, 0x2b, 0x46, 0x6b, 0x30,
+    0x54, 0x39, 0x58, 0x79, 0x76, 0x51, 0x74, 0x71, 0x34, 0x39, 0x39, 0x79,
+    0x46, 0x62, 0x71, 0x39, 0x78, 0x6f, 0x67, 0x55, 0x56, 0x6c, 0x45, 0x47,
+    0x48, 0x36, 0x32, 0x78, 0x50, 0x36, 0x76, 0x48, 0x30, 0x59, 0x0a, 0x35,
+    0x75, 0x6b, 0x4b, 0x2f, 0x2f, 0x64, 0x43, 0x50, 0x41, 0x7a, 0x41, 0x31,
+    0x31, 0x59, 0x75, 0x58, 0x32, 0x72, 0x6e, 0x65, 0x78, 0x30, 0x4a, 0x68,
+    0x75, 0x54, 0x51, 0x66, 0x63, 0x49, 0x3d, 0x0a, 0x2d, 0x2d, 0x2d, 0x2d,
+    0x2d, 0x45, 0x4e, 0x44, 0x20, 0x43, 0x45, 0x52, 0x54, 0x49, 0x46, 0x49,
+    0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a};
+unsigned int test_ca_cert_size = 802;
diff --git a/test/core/end2end/data/server1_cert.c b/test/core/end2end/data/server1_cert.c
new file mode 100644
index 0000000..da1d366
--- /dev/null
+++ b/test/core/end2end/data/server1_cert.c
@@ -0,0 +1,116 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+unsigned char test_server1_cert[] = {
+    0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20, 0x43,
+    0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d,
+    0x2d, 0x2d, 0x2d, 0x0a, 0x4d, 0x49, 0x49, 0x43, 0x6d, 0x7a, 0x43, 0x43,
+    0x41, 0x67, 0x53, 0x67, 0x41, 0x77, 0x49, 0x42, 0x41, 0x67, 0x49, 0x42,
+    0x41, 0x7a, 0x41, 0x4e, 0x42, 0x67, 0x6b, 0x71, 0x68, 0x6b, 0x69, 0x47,
+    0x39, 0x77, 0x30, 0x42, 0x41, 0x51, 0x55, 0x46, 0x41, 0x44, 0x42, 0x57,
+    0x4d, 0x51, 0x73, 0x77, 0x43, 0x51, 0x59, 0x44, 0x56, 0x51, 0x51, 0x47,
+    0x45, 0x77, 0x4a, 0x42, 0x56, 0x54, 0x45, 0x54, 0x0a, 0x4d, 0x42, 0x45,
+    0x47, 0x41, 0x31, 0x55, 0x45, 0x43, 0x41, 0x77, 0x4b, 0x55, 0x32, 0x39,
+    0x74, 0x5a, 0x53, 0x31, 0x54, 0x64, 0x47, 0x46, 0x30, 0x5a, 0x54, 0x45,
+    0x68, 0x4d, 0x42, 0x38, 0x47, 0x41, 0x31, 0x55, 0x45, 0x43, 0x67, 0x77,
+    0x59, 0x53, 0x57, 0x35, 0x30, 0x5a, 0x58, 0x4a, 0x75, 0x5a, 0x58, 0x51,
+    0x67, 0x56, 0x32, 0x6c, 0x6b, 0x5a, 0x32, 0x6c, 0x30, 0x63, 0x79, 0x42,
+    0x51, 0x0a, 0x64, 0x48, 0x6b, 0x67, 0x54, 0x48, 0x52, 0x6b, 0x4d, 0x51,
+    0x38, 0x77, 0x44, 0x51, 0x59, 0x44, 0x56, 0x51, 0x51, 0x44, 0x44, 0x41,
+    0x5a, 0x30, 0x5a, 0x58, 0x4e, 0x30, 0x59, 0x32, 0x45, 0x77, 0x48, 0x68,
+    0x63, 0x4e, 0x4d, 0x54, 0x51, 0x77, 0x4e, 0x7a, 0x49, 0x79, 0x4d, 0x44,
+    0x59, 0x77, 0x4d, 0x44, 0x55, 0x33, 0x57, 0x68, 0x63, 0x4e, 0x4d, 0x6a,
+    0x51, 0x77, 0x4e, 0x7a, 0x45, 0x35, 0x0a, 0x4d, 0x44, 0x59, 0x77, 0x4d,
+    0x44, 0x55, 0x33, 0x57, 0x6a, 0x42, 0x6b, 0x4d, 0x51, 0x73, 0x77, 0x43,
+    0x51, 0x59, 0x44, 0x56, 0x51, 0x51, 0x47, 0x45, 0x77, 0x4a, 0x56, 0x55,
+    0x7a, 0x45, 0x52, 0x4d, 0x41, 0x38, 0x47, 0x41, 0x31, 0x55, 0x45, 0x43,
+    0x42, 0x4d, 0x49, 0x53, 0x57, 0x78, 0x73, 0x61, 0x57, 0x35, 0x76, 0x61,
+    0x58, 0x4d, 0x78, 0x45, 0x44, 0x41, 0x4f, 0x42, 0x67, 0x4e, 0x56, 0x0a,
+    0x42, 0x41, 0x63, 0x54, 0x42, 0x30, 0x4e, 0x6f, 0x61, 0x57, 0x4e, 0x68,
+    0x5a, 0x32, 0x38, 0x78, 0x46, 0x44, 0x41, 0x53, 0x42, 0x67, 0x4e, 0x56,
+    0x42, 0x41, 0x6f, 0x54, 0x43, 0x30, 0x64, 0x76, 0x62, 0x32, 0x64, 0x73,
+    0x5a, 0x53, 0x42, 0x4a, 0x62, 0x6d, 0x4d, 0x75, 0x4d, 0x52, 0x6f, 0x77,
+    0x47, 0x41, 0x59, 0x44, 0x56, 0x51, 0x51, 0x44, 0x46, 0x42, 0x45, 0x71,
+    0x4c, 0x6e, 0x52, 0x6c, 0x0a, 0x63, 0x33, 0x51, 0x75, 0x5a, 0x32, 0x39,
+    0x76, 0x5a, 0x32, 0x78, 0x6c, 0x4c, 0x6d, 0x4e, 0x76, 0x62, 0x54, 0x43,
+    0x42, 0x6e, 0x7a, 0x41, 0x4e, 0x42, 0x67, 0x6b, 0x71, 0x68, 0x6b, 0x69,
+    0x47, 0x39, 0x77, 0x30, 0x42, 0x41, 0x51, 0x45, 0x46, 0x41, 0x41, 0x4f,
+    0x42, 0x6a, 0x51, 0x41, 0x77, 0x67, 0x59, 0x6b, 0x43, 0x67, 0x59, 0x45,
+    0x41, 0x34, 0x63, 0x4d, 0x56, 0x4a, 0x79, 0x67, 0x73, 0x0a, 0x4a, 0x55,
+    0x6d, 0x6c, 0x67, 0x4d, 0x4d, 0x7a, 0x67, 0x64, 0x69, 0x30, 0x68, 0x31,
+    0x58, 0x6f, 0x43, 0x52, 0x37, 0x2b, 0x77, 0x77, 0x31, 0x70, 0x6f, 0x70,
+    0x30, 0x34, 0x4f, 0x4d, 0x4d, 0x79, 0x79, 0x37, 0x48, 0x2f, 0x69, 0x30,
+    0x50, 0x4a, 0x32, 0x57, 0x36, 0x59, 0x33, 0x35, 0x2b, 0x62, 0x34, 0x43,
+    0x4d, 0x38, 0x51, 0x72, 0x6b, 0x59, 0x65, 0x45, 0x61, 0x66, 0x55, 0x47,
+    0x44, 0x4f, 0x0a, 0x52, 0x59, 0x58, 0x36, 0x79, 0x56, 0x2f, 0x63, 0x48,
+    0x47, 0x47, 0x73, 0x44, 0x2f, 0x78, 0x30, 0x32, 0x79, 0x65, 0x36, 0x65,
+    0x79, 0x31, 0x55, 0x44, 0x74, 0x6b, 0x47, 0x41, 0x44, 0x2f, 0x6d, 0x70,
+    0x44, 0x45, 0x78, 0x38, 0x59, 0x43, 0x72, 0x6a, 0x41, 0x63, 0x31, 0x56,
+    0x66, 0x76, 0x74, 0x38, 0x46, 0x6b, 0x36, 0x43, 0x6e, 0x31, 0x57, 0x56,
+    0x49, 0x78, 0x56, 0x2f, 0x4a, 0x33, 0x30, 0x0a, 0x33, 0x78, 0x6a, 0x42,
+    0x73, 0x46, 0x67, 0x42, 0x79, 0x51, 0x35, 0x35, 0x52, 0x42, 0x70, 0x31,
+    0x4f, 0x4c, 0x5a, 0x66, 0x56, 0x4c, 0x6f, 0x36, 0x41, 0x6c, 0x65, 0x42,
+    0x44, 0x53, 0x62, 0x63, 0x78, 0x61, 0x45, 0x43, 0x41, 0x77, 0x45, 0x41,
+    0x41, 0x61, 0x4e, 0x72, 0x4d, 0x47, 0x6b, 0x77, 0x43, 0x51, 0x59, 0x44,
+    0x56, 0x52, 0x30, 0x54, 0x42, 0x41, 0x49, 0x77, 0x41, 0x44, 0x41, 0x4c,
+    0x0a, 0x42, 0x67, 0x4e, 0x56, 0x48, 0x51, 0x38, 0x45, 0x42, 0x41, 0x4d,
+    0x43, 0x42, 0x65, 0x41, 0x77, 0x54, 0x77, 0x59, 0x44, 0x56, 0x52, 0x30,
+    0x52, 0x42, 0x45, 0x67, 0x77, 0x52, 0x6f, 0x49, 0x51, 0x4b, 0x69, 0x35,
+    0x30, 0x5a, 0x58, 0x4e, 0x30, 0x4c, 0x6d, 0x64, 0x76, 0x62, 0x32, 0x64,
+    0x73, 0x5a, 0x53, 0x35, 0x6d, 0x63, 0x6f, 0x49, 0x59, 0x64, 0x32, 0x46,
+    0x30, 0x5a, 0x58, 0x4a, 0x36, 0x0a, 0x62, 0x32, 0x39, 0x70, 0x4c, 0x6e,
+    0x52, 0x6c, 0x63, 0x33, 0x51, 0x75, 0x5a, 0x32, 0x39, 0x76, 0x5a, 0x32,
+    0x78, 0x6c, 0x4c, 0x6d, 0x4a, 0x6c, 0x67, 0x68, 0x49, 0x71, 0x4c, 0x6e,
+    0x52, 0x6c, 0x63, 0x33, 0x51, 0x75, 0x65, 0x57, 0x39, 0x31, 0x64, 0x48,
+    0x56, 0x69, 0x5a, 0x53, 0x35, 0x6a, 0x62, 0x32, 0x32, 0x48, 0x42, 0x4d,
+    0x43, 0x6f, 0x41, 0x51, 0x4d, 0x77, 0x44, 0x51, 0x59, 0x4a, 0x0a, 0x4b,
+    0x6f, 0x5a, 0x49, 0x68, 0x76, 0x63, 0x4e, 0x41, 0x51, 0x45, 0x46, 0x42,
+    0x51, 0x41, 0x44, 0x67, 0x59, 0x45, 0x41, 0x4d, 0x32, 0x49, 0x69, 0x30,
+    0x4c, 0x67, 0x54, 0x47, 0x62, 0x4a, 0x31, 0x6a, 0x34, 0x6f, 0x71, 0x58,
+    0x39, 0x62, 0x78, 0x56, 0x63, 0x78, 0x6d, 0x2b, 0x2f, 0x52, 0x35, 0x59,
+    0x66, 0x38, 0x6f, 0x69, 0x30, 0x61, 0x5a, 0x71, 0x54, 0x4a, 0x6c, 0x6e,
+    0x4c, 0x59, 0x53, 0x0a, 0x77, 0x58, 0x63, 0x42, 0x79, 0x6b, 0x78, 0x54,
+    0x78, 0x31, 0x38, 0x31, 0x73, 0x37, 0x57, 0x79, 0x66, 0x4a, 0x34, 0x39,
+    0x57, 0x77, 0x72, 0x59, 0x58, 0x6f, 0x37, 0x38, 0x7a, 0x54, 0x44, 0x41,
+    0x6e, 0x66, 0x31, 0x6d, 0x61, 0x30, 0x66, 0x50, 0x71, 0x33, 0x65, 0x34,
+    0x6d, 0x70, 0x73, 0x70, 0x76, 0x79, 0x6e, 0x64, 0x4c, 0x68, 0x31, 0x61,
+    0x2b, 0x4f, 0x61, 0x72, 0x48, 0x61, 0x31, 0x65, 0x0a, 0x61, 0x54, 0x30,
+    0x44, 0x49, 0x49, 0x59, 0x6b, 0x37, 0x71, 0x65, 0x45, 0x61, 0x31, 0x59,
+    0x63, 0x56, 0x6c, 0x6a, 0x78, 0x32, 0x4b, 0x79, 0x4c, 0x64, 0x30, 0x72,
+    0x31, 0x42, 0x42, 0x41, 0x66, 0x72, 0x77, 0x79, 0x47, 0x61, 0x45, 0x50,
+    0x56, 0x65, 0x4a, 0x51, 0x56, 0x59, 0x57, 0x61, 0x4f, 0x4a, 0x52, 0x55,
+    0x32, 0x77, 0x65, 0x2f, 0x4b, 0x44, 0x34, 0x6f, 0x6a, 0x66, 0x39, 0x73,
+    0x3d, 0x0a, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x45, 0x4e, 0x44, 0x20, 0x43,
+    0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d,
+    0x2d, 0x2d, 0x2d, 0x0a};
+unsigned int test_server1_cert_size = 964;
diff --git a/test/core/end2end/data/server1_key.c b/test/core/end2end/data/server1_key.c
new file mode 100644
index 0000000..3540505
--- /dev/null
+++ b/test/core/end2end/data/server1_key.c
@@ -0,0 +1,109 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+unsigned char test_server1_key[] = {
+    0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20, 0x52,
+    0x53, 0x41, 0x20, 0x50, 0x52, 0x49, 0x56, 0x41, 0x54, 0x45, 0x20, 0x4b,
+    0x45, 0x59, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x4d, 0x49, 0x49, 0x43,
+    0x57, 0x77, 0x49, 0x42, 0x41, 0x41, 0x4b, 0x42, 0x67, 0x51, 0x44, 0x68,
+    0x77, 0x78, 0x55, 0x6e, 0x4b, 0x43, 0x77, 0x6c, 0x53, 0x61, 0x57, 0x41,
+    0x77, 0x7a, 0x4f, 0x42, 0x32, 0x4c, 0x53, 0x48, 0x56, 0x65, 0x67, 0x4a,
+    0x48, 0x76, 0x37, 0x44, 0x44, 0x57, 0x6d, 0x69, 0x6e, 0x54, 0x67, 0x34,
+    0x77, 0x7a, 0x4c, 0x4c, 0x73, 0x66, 0x2b, 0x4c, 0x51, 0x38, 0x6e, 0x5a,
+    0x0a, 0x62, 0x70, 0x6a, 0x66, 0x6e, 0x35, 0x76, 0x67, 0x49, 0x7a, 0x78,
+    0x43, 0x75, 0x52, 0x68, 0x34, 0x52, 0x70, 0x39, 0x51, 0x59, 0x4d, 0x35,
+    0x46, 0x68, 0x66, 0x72, 0x4a, 0x58, 0x39, 0x77, 0x63, 0x59, 0x61, 0x77,
+    0x50, 0x2f, 0x48, 0x54, 0x62, 0x4a, 0x37, 0x70, 0x37, 0x4c, 0x56, 0x51,
+    0x4f, 0x32, 0x51, 0x59, 0x41, 0x50, 0x2b, 0x61, 0x6b, 0x4d, 0x54, 0x48,
+    0x78, 0x67, 0x4b, 0x75, 0x4d, 0x0a, 0x42, 0x7a, 0x56, 0x56, 0x2b, 0x2b,
+    0x33, 0x77, 0x57, 0x54, 0x6f, 0x4b, 0x66, 0x56, 0x5a, 0x55, 0x6a, 0x46,
+    0x58, 0x38, 0x6e, 0x66, 0x54, 0x66, 0x47, 0x4d, 0x47, 0x77, 0x57, 0x41,
+    0x48, 0x4a, 0x44, 0x6e, 0x6c, 0x45, 0x47, 0x6e, 0x55, 0x34, 0x74, 0x6c,
+    0x39, 0x55, 0x75, 0x6a, 0x6f, 0x43, 0x56, 0x34, 0x45, 0x4e, 0x4a, 0x74,
+    0x7a, 0x46, 0x6f, 0x51, 0x49, 0x44, 0x41, 0x51, 0x41, 0x42, 0x0a, 0x41,
+    0x6f, 0x47, 0x41, 0x4a, 0x2b, 0x36, 0x68, 0x70, 0x7a, 0x4e, 0x72, 0x32,
+    0x34, 0x79, 0x54, 0x51, 0x5a, 0x74, 0x46, 0x57, 0x51, 0x70, 0x44, 0x70,
+    0x45, 0x79, 0x46, 0x70, 0x6c, 0x64, 0x64, 0x4b, 0x4a, 0x4d, 0x4f, 0x78,
+    0x44, 0x79, 0x61, 0x33, 0x53, 0x39, 0x70, 0x70, 0x4b, 0x33, 0x76, 0x54,
+    0x57, 0x72, 0x49, 0x49, 0x54, 0x56, 0x32, 0x78, 0x4e, 0x63, 0x75, 0x63,
+    0x77, 0x37, 0x49, 0x0a, 0x63, 0x65, 0x54, 0x62, 0x64, 0x79, 0x72, 0x47,
+    0x73, 0x79, 0x6a, 0x73, 0x55, 0x30, 0x2f, 0x48, 0x64, 0x43, 0x63, 0x49,
+    0x66, 0x39, 0x79, 0x6d, 0x32, 0x6a, 0x66, 0x6d, 0x47, 0x4c, 0x55, 0x77,
+    0x6d, 0x79, 0x68, 0x6c, 0x74, 0x4b, 0x56, 0x77, 0x30, 0x51, 0x59, 0x63,
+    0x46, 0x42, 0x30, 0x58, 0x4c, 0x6b, 0x63, 0x30, 0x6e, 0x49, 0x35, 0x59,
+    0x76, 0x45, 0x59, 0x6f, 0x65, 0x56, 0x44, 0x67, 0x0a, 0x6f, 0x6d, 0x5a,
+    0x49, 0x58, 0x6e, 0x31, 0x45, 0x33, 0x45, 0x57, 0x2b, 0x73, 0x53, 0x49,
+    0x57, 0x53, 0x62, 0x6b, 0x4d, 0x75, 0x39, 0x62, 0x59, 0x32, 0x6b, 0x73,
+    0x74, 0x4b, 0x58, 0x52, 0x32, 0x55, 0x5a, 0x6d, 0x4d, 0x67, 0x57, 0x44,
+    0x74, 0x6d, 0x42, 0x45, 0x50, 0x4d, 0x61, 0x45, 0x43, 0x51, 0x51, 0x44,
+    0x36, 0x79, 0x54, 0x34, 0x54, 0x41, 0x5a, 0x4d, 0x35, 0x68, 0x47, 0x42,
+    0x62, 0x0a, 0x63, 0x69, 0x42, 0x4b, 0x67, 0x4d, 0x55, 0x50, 0x36, 0x50,
+    0x77, 0x4f, 0x68, 0x50, 0x68, 0x4f, 0x4d, 0x50, 0x49, 0x76, 0x69, 0x6a,
+    0x4f, 0x35, 0x30, 0x41, 0x69, 0x75, 0x36, 0x69, 0x75, 0x43, 0x56, 0x38,
+    0x38, 0x6c, 0x31, 0x51, 0x49, 0x79, 0x33, 0x38, 0x67, 0x57, 0x56, 0x68,
+    0x78, 0x6a, 0x4e, 0x72, 0x71, 0x36, 0x50, 0x33, 0x34, 0x36, 0x6a, 0x34,
+    0x49, 0x42, 0x67, 0x2b, 0x6b, 0x42, 0x0a, 0x39, 0x61, 0x6c, 0x77, 0x70,
+    0x43, 0x4f, 0x44, 0x41, 0x6b, 0x45, 0x41, 0x35, 0x6e, 0x53, 0x6e, 0x6d,
+    0x39, 0x6b, 0x36, 0x79, 0x6b, 0x59, 0x65, 0x51, 0x57, 0x4e, 0x53, 0x30,
+    0x66, 0x4e, 0x57, 0x69, 0x52, 0x69, 0x6e, 0x43, 0x64, 0x6c, 0x32, 0x33,
+    0x41, 0x37, 0x75, 0x73, 0x44, 0x47, 0x53, 0x75, 0x4b, 0x4b, 0x6c, 0x6d,
+    0x30, 0x31, 0x39, 0x69, 0x6f, 0x6d, 0x4a, 0x2f, 0x52, 0x67, 0x64, 0x0a,
+    0x4d, 0x4b, 0x44, 0x4f, 0x70, 0x30, 0x71, 0x2f, 0x32, 0x4f, 0x6f, 0x73,
+    0x74, 0x62, 0x74, 0x65, 0x4f, 0x57, 0x4d, 0x32, 0x4d, 0x52, 0x46, 0x66,
+    0x34, 0x6a, 0x4d, 0x48, 0x33, 0x77, 0x79, 0x56, 0x43, 0x77, 0x4a, 0x41,
+    0x66, 0x41, 0x64, 0x6a, 0x4a, 0x38, 0x73, 0x7a, 0x6f, 0x4e, 0x4b, 0x54,
+    0x52, 0x53, 0x61, 0x67, 0x53, 0x62, 0x68, 0x39, 0x76, 0x57, 0x79, 0x67,
+    0x6e, 0x42, 0x32, 0x76, 0x0a, 0x49, 0x42, 0x79, 0x63, 0x36, 0x6c, 0x34,
+    0x54, 0x54, 0x75, 0x5a, 0x51, 0x4a, 0x52, 0x47, 0x7a, 0x43, 0x76, 0x65,
+    0x61, 0x66, 0x7a, 0x39, 0x6c, 0x6f, 0x76, 0x75, 0x42, 0x33, 0x57, 0x6f,
+    0x68, 0x43, 0x41, 0x42, 0x64, 0x51, 0x52, 0x64, 0x39, 0x75, 0x6b, 0x43,
+    0x58, 0x4c, 0x32, 0x43, 0x70, 0x73, 0x45, 0x70, 0x71, 0x7a, 0x6b, 0x61,
+    0x66, 0x4f, 0x51, 0x4a, 0x41, 0x4a, 0x55, 0x6a, 0x63, 0x0a, 0x55, 0x53,
+    0x65, 0x64, 0x44, 0x6c, 0x71, 0x33, 0x7a, 0x47, 0x5a, 0x77, 0x59, 0x4d,
+    0x31, 0x59, 0x77, 0x38, 0x64, 0x38, 0x52, 0x75, 0x69, 0x72, 0x42, 0x55,
+    0x46, 0x5a, 0x4e, 0x71, 0x4a, 0x65, 0x6c, 0x59, 0x61, 0x69, 0x2b, 0x6e,
+    0x52, 0x59, 0x43, 0x6c, 0x44, 0x6b, 0x52, 0x56, 0x46, 0x67, 0x62, 0x35,
+    0x79, 0x6b, 0x73, 0x6f, 0x59, 0x79, 0x63, 0x62, 0x71, 0x35, 0x54, 0x78,
+    0x47, 0x6f, 0x0a, 0x56, 0x65, 0x71, 0x4b, 0x4f, 0x76, 0x67, 0x50, 0x70,
+    0x6a, 0x34, 0x52, 0x57, 0x50, 0x48, 0x6c, 0x4c, 0x77, 0x4a, 0x41, 0x47,
+    0x55, 0x4d, 0x6b, 0x33, 0x62, 0x71, 0x54, 0x39, 0x31, 0x78, 0x42, 0x55,
+    0x43, 0x6e, 0x4c, 0x52, 0x73, 0x2f, 0x76, 0x66, 0x6f, 0x43, 0x70, 0x48,
+    0x70, 0x67, 0x36, 0x65, 0x79, 0x77, 0x51, 0x54, 0x42, 0x44, 0x41, 0x56,
+    0x36, 0x78, 0x6b, 0x79, 0x7a, 0x34, 0x61, 0x0a, 0x52, 0x48, 0x33, 0x49,
+    0x37, 0x2f, 0x2b, 0x79, 0x6a, 0x33, 0x5a, 0x78, 0x52, 0x32, 0x4a, 0x6f,
+    0x57, 0x48, 0x67, 0x55, 0x77, 0x5a, 0x37, 0x6c, 0x5a, 0x6b, 0x31, 0x56,
+    0x6e, 0x68, 0x66, 0x66, 0x46, 0x79, 0x65, 0x37, 0x53, 0x42, 0x58, 0x79,
+    0x61, 0x67, 0x3d, 0x3d, 0x0a, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x45, 0x4e,
+    0x44, 0x20, 0x52, 0x53, 0x41, 0x20, 0x50, 0x52, 0x49, 0x56, 0x41, 0x54,
+    0x45, 0x20, 0x4b, 0x45, 0x59, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a};
+unsigned int test_server1_key_size = 887;
diff --git a/test/core/end2end/data/ssl_test_data.h b/test/core/end2end/data/ssl_test_data.h
new file mode 100644
index 0000000..75263b8
--- /dev/null
+++ b/test/core/end2end/data/ssl_test_data.h
@@ -0,0 +1,44 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef __GRPC_TEST_END2END_DATA_SSL_TEST_DATA_H__
+#define __GRPC_TEST_END2END_DATA_SSL_TEST_DATA_H__
+
+extern unsigned char test_ca_cert[];
+extern unsigned int test_ca_cert_size;
+extern unsigned char test_server1_cert[];
+extern unsigned int test_server1_cert_size;
+extern unsigned char test_server1_key[];
+extern unsigned int test_server1_key_size;
+
+#endif  /* __GRPC_TEST_END2END_DATA_SSL_TEST_DATA_H__ */
diff --git a/test/core/end2end/end2end_tests.c b/test/core/end2end/end2end_tests.c
new file mode 100644
index 0000000..7174d09
--- /dev/null
+++ b/test/core/end2end/end2end_tests.c
@@ -0,0 +1,1285 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <grpc/byte_buffer.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include <grpc/support/useful.h>
+#include "test/core/end2end/cq_verifier.h"
+
+enum { TIMEOUT = 200000 };
+
+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) {
+  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);
+  return f;
+}
+
+static gpr_timespec n_seconds_time(int n) {
+  return gpr_time_add(gpr_now(), gpr_time_from_micros(GPR_US_PER_SEC * n));
+}
+
+static gpr_timespec five_seconds_time() { return n_seconds_time(5); }
+
+static void drain_cq(grpc_completion_queue *cq) {
+  grpc_event *ev;
+  grpc_completion_type type;
+  do {
+    ev = grpc_completion_queue_next(cq, five_seconds_time());
+    GPR_ASSERT(ev);
+    type = ev->type;
+    grpc_event_finish(ev);
+  } while (type != GRPC_QUEUE_SHUTDOWN);
+}
+
+static void shutdown_server(grpc_end2end_test_fixture *f) {
+  if (!f->server) return;
+  grpc_server_shutdown(f->server);
+  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);
+  f->client = NULL;
+}
+
+static void end_test(grpc_end2end_test_fixture *f) {
+  shutdown_server(f);
+  shutdown_client(f);
+
+  grpc_completion_queue_shutdown(f->server_cq);
+  drain_cq(f->server_cq);
+  grpc_completion_queue_destroy(f->server_cq);
+  grpc_completion_queue_shutdown(f->client_cq);
+  drain_cq(f->client_cq);
+  grpc_completion_queue_destroy(f->client_cq);
+}
+
+static void test_no_op(grpc_end2end_test_config config) {
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+static void simple_request_body(grpc_end2end_test_fixture f) {
+  grpc_call *c;
+  grpc_call *s;
+  grpc_status send_status = {GRPC_STATUS_UNIMPLEMENTED, "xyz"};
+  gpr_timespec deadline = five_seconds_time();
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c, tag(4)));
+  cq_expect_finish_accepted(v_client, tag(4), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_accept(s, f.server_cq, tag(102), 0));
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write_status(s, send_status, tag(5)));
+  cq_expect_finished_with_status(v_client, tag(3), send_status, NULL);
+  cq_verify(v_client);
+
+  cq_expect_finish_accepted(v_server, tag(5), GRPC_OP_OK);
+  cq_verify(v_server);
+  cq_expect_finished(v_server, tag(102), NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+}
+
+/* an alternative ordering of the simple request body */
+static void simple_request_body2(grpc_end2end_test_fixture f) {
+  grpc_call *c;
+  grpc_call *s;
+  grpc_status send_status = {GRPC_STATUS_UNIMPLEMENTED, "xyz"};
+  gpr_timespec deadline = five_seconds_time();
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c, tag(4)));
+  cq_expect_finish_accepted(v_client, tag(4), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_accept(s, f.server_cq, tag(102), 0));
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write_status(s, send_status, tag(5)));
+  cq_expect_finish_accepted(v_server, tag(5), GRPC_OP_OK);
+  cq_verify(v_server);
+
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_verify(v_client);
+
+  cq_expect_finished_with_status(v_client, tag(3), send_status, NULL);
+  cq_verify(v_client);
+
+  cq_expect_finished(v_server, tag(102), NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+}
+
+static void test_invoke_simple_request(
+    grpc_end2end_test_config config, const char *name,
+    void (*body)(grpc_end2end_test_fixture f)) {
+  char fullname[64];
+  grpc_end2end_test_fixture f;
+
+  sprintf(fullname, "%s/%s", __FUNCTION__, name);
+
+  f = begin_test(config, fullname, NULL, NULL);
+  body(f);
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+static void test_invoke_10_simple_requests(grpc_end2end_test_config config) {
+  int i;
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  for (i = 0; i < 10; i++) {
+    simple_request_body(f);
+    gpr_log(GPR_INFO, "Passed simple request %d", i);
+  }
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+static void simple_delayed_request_body(grpc_end2end_test_config config,
+                                        grpc_end2end_test_fixture *f,
+                                        grpc_channel_args *client_args,
+                                        grpc_channel_args *server_args,
+                                        long delay_us) {
+  grpc_call *c;
+  grpc_call *s;
+  grpc_status send_status = {GRPC_STATUS_UNIMPLEMENTED, "xyz"};
+  gpr_timespec deadline = five_seconds_time();
+  cq_verifier *v_client = cq_verifier_create(f->client_cq);
+  cq_verifier *v_server = cq_verifier_create(f->server_cq);
+
+  config.init_client(f, client_args);
+
+  c = grpc_channel_create_call(f->client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_invoke(c, f->client_cq, tag(1),
+                                                    tag(2), tag(3), 0));
+  gpr_sleep_until(gpr_time_add(gpr_now(), gpr_time_from_micros(delay_us)));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+
+  config.init_server(f, server_args);
+
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c, tag(4)));
+  cq_expect_finish_accepted(v_client, tag(4), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f->server, tag(100)));
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_accept(s, f->server_cq, tag(102), 0));
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write_status(s, send_status, tag(5)));
+  cq_expect_finished_with_status(v_client, tag(3), send_status, NULL);
+  cq_verify(v_client);
+
+  cq_expect_finish_accepted(v_server, tag(5), GRPC_OP_OK);
+  cq_expect_finished(v_server, tag(102), NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+}
+
+static void test_simple_delayed_request_short(grpc_end2end_test_config config) {
+  grpc_end2end_test_fixture f;
+
+  gpr_log(GPR_INFO, "%s/%s", __FUNCTION__, config.name);
+  f = config.create_fixture(NULL, NULL);
+  simple_delayed_request_body(config, &f, NULL, NULL, 100000);
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+static void test_simple_delayed_request_long(grpc_end2end_test_config config) {
+  grpc_end2end_test_fixture f;
+
+  gpr_log(GPR_INFO, "%s/%s", __FUNCTION__, config.name);
+  f = config.create_fixture(NULL, NULL);
+  /* This timeout should be longer than a single retry */
+  simple_delayed_request_body(config, &f, NULL, NULL, 1500000);
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+/* Client sends a request with payload, server reads then returns status. */
+static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
+  grpc_call *c;
+  grpc_call *s;
+  grpc_status send_status = {GRPC_STATUS_UNIMPLEMENTED, "xyz"};
+  gpr_slice payload_slice = gpr_slice_from_copied_string("hello world");
+  grpc_byte_buffer *payload = grpc_byte_buffer_create(&payload_slice, 1);
+  gpr_timespec deadline = five_seconds_time();
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+
+  /* byte buffer holds the slice, we can unref it already */
+  gpr_slice_unref(payload_slice);
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_write(c, payload, tag(4), 0));
+  /* destroy byte buffer early to ensure async code keeps track of its contents
+     correctly */
+  grpc_byte_buffer_destroy(payload);
+  cq_expect_write_accepted(v_client, tag(4), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+
+  grpc_call_accept(s, f.server_cq, tag(102), 0);
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read(s, tag(4)));
+  cq_expect_read(v_server, tag(4), gpr_slice_from_copied_string("hello world"));
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c, tag(5)));
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write_status(s, send_status, tag(6)));
+  cq_expect_finish_accepted(v_client, tag(5), GRPC_OP_OK);
+  cq_expect_finished_with_status(v_client, tag(3), send_status, NULL);
+  cq_verify(v_client);
+
+  cq_expect_finish_accepted(v_server, tag(6), GRPC_OP_OK);
+  cq_expect_finished(v_server, tag(102), NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
+
+  end_test(&f);
+  config.tear_down_data(&f);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+}
+
+/* test the case when there is a pending message at the client side,
+   writes_done should not return a status without a start_read.
+   Note: this test will last for 3s. Do not run in a loop. */
+static void test_writes_done_hangs_with_pending_read(
+    grpc_end2end_test_config config) {
+  grpc_call *c;
+  grpc_call *s;
+  grpc_status send_status = {GRPC_STATUS_UNIMPLEMENTED, "xyz"};
+  gpr_slice request_payload_slice = gpr_slice_from_copied_string("hello world");
+  gpr_slice response_payload_slice = gpr_slice_from_copied_string("hello you");
+  grpc_byte_buffer *request_payload =
+      grpc_byte_buffer_create(&request_payload_slice, 1);
+  grpc_byte_buffer *response_payload =
+      grpc_byte_buffer_create(&response_payload_slice, 1);
+  gpr_timespec deadline = five_seconds_time();
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+
+  /* byte buffer holds the slice, we can unref it already */
+  gpr_slice_unref(request_payload_slice);
+  gpr_slice_unref(response_payload_slice);
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write(c, request_payload, tag(4), 0));
+  /* destroy byte buffer early to ensure async code keeps track of its contents
+     correctly */
+  grpc_byte_buffer_destroy(request_payload);
+  cq_expect_write_accepted(v_client, tag(4), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+
+  grpc_call_accept(s, f.server_cq, tag(102), 0);
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read(s, tag(5)));
+  cq_expect_read(v_server, tag(5), gpr_slice_from_copied_string("hello world"));
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write(s, response_payload, tag(6), 0));
+  /* destroy byte buffer early to ensure async code keeps track of its contents
+     correctly */
+  grpc_byte_buffer_destroy(response_payload);
+  cq_expect_write_accepted(v_server, tag(6), GRPC_OP_OK);
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c, tag(6)));
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write_status(s, send_status, tag(7)));
+
+  cq_expect_finish_accepted(v_client, tag(6), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  /* does not return status because there is a pending message to be read */
+  cq_verify_empty(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read(c, tag(8)));
+  cq_expect_read(v_client, tag(8), gpr_slice_from_copied_string("hello you"));
+  cq_verify(v_client);
+
+  cq_expect_finished_with_status(v_client, tag(3), send_status, NULL);
+  cq_verify(v_client);
+
+  cq_expect_finish_accepted(v_server, tag(7), GRPC_OP_OK);
+  cq_expect_finished(v_server, tag(102), NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
+
+  end_test(&f);
+  config.tear_down_data(&f);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+}
+
+static void request_response_with_payload(grpc_end2end_test_fixture f) {
+  grpc_call *c;
+  grpc_call *s;
+  grpc_status send_status = {GRPC_STATUS_UNIMPLEMENTED, "xyz"};
+  gpr_slice request_payload_slice = gpr_slice_from_copied_string("hello world");
+  gpr_slice response_payload_slice = gpr_slice_from_copied_string("hello you");
+  grpc_byte_buffer *request_payload =
+      grpc_byte_buffer_create(&request_payload_slice, 1);
+  grpc_byte_buffer *response_payload =
+      grpc_byte_buffer_create(&response_payload_slice, 1);
+  gpr_timespec deadline = five_seconds_time();
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+
+  /* byte buffer holds the slice, we can unref it already */
+  gpr_slice_unref(request_payload_slice);
+  gpr_slice_unref(response_payload_slice);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write(c, request_payload, tag(4), 0));
+  /* destroy byte buffer early to ensure async code keeps track of its contents
+     correctly */
+  grpc_byte_buffer_destroy(request_payload);
+  cq_expect_write_accepted(v_client, tag(4), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+
+  grpc_call_accept(s, f.server_cq, tag(102), 0);
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read(s, tag(5)));
+  cq_expect_read(v_server, tag(5), gpr_slice_from_copied_string("hello world"));
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write(s, response_payload, tag(6), 0));
+  /* destroy byte buffer early to ensure async code keeps track of its contents
+     correctly */
+  grpc_byte_buffer_destroy(response_payload);
+  cq_expect_write_accepted(v_server, tag(6), GRPC_OP_OK);
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read(c, tag(7)));
+  cq_expect_read(v_client, tag(7), gpr_slice_from_copied_string("hello you"));
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c, tag(8)));
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write_status(s, send_status, tag(9)));
+
+  cq_expect_finish_accepted(v_client, tag(8), GRPC_OP_OK);
+  cq_expect_finished_with_status(v_client, tag(3), send_status, NULL);
+  cq_verify(v_client);
+
+  cq_expect_finish_accepted(v_server, tag(9), GRPC_OP_OK);
+  cq_expect_finished(v_server, tag(102), NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+}
+
+/* Client sends a request with payload, server reads then returns a response
+   payload and status. */
+static void test_invoke_request_response_with_payload(
+    grpc_end2end_test_config config) {
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  request_response_with_payload(f);
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+static void test_invoke_10_request_response_with_payload(
+    grpc_end2end_test_config config) {
+  int i;
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  for (i = 0; i < 10; i++) {
+    request_response_with_payload(f);
+  }
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+/* allow cancellation by either grpc_call_cancel, or by wait_for_deadline (which
+ * does nothing) */
+typedef grpc_call_error (*canceller)(grpc_call *call);
+
+static grpc_call_error wait_for_deadline(grpc_call *call) {
+  return GRPC_CALL_OK;
+}
+
+/* Cancel and do nothing */
+static void test_cancel_in_a_vacuum(grpc_end2end_test_config config,
+                                    canceller call_cancel) {
+  grpc_call *c;
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  gpr_timespec deadline = five_seconds_time();
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK == call_cancel(c));
+
+  grpc_call_destroy(c);
+
+  cq_verifier_destroy(v_client);
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+/* Cancel before invoke */
+static void test_cancel_before_invoke(grpc_end2end_test_config config) {
+  grpc_call *c;
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  gpr_timespec deadline = five_seconds_time();
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  grpc_status chk_status = {GRPC_STATUS_CANCELLED, NULL};
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_cancel(c));
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_ERROR);
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_expect_finished_with_status(v_client, tag(3), chk_status, NULL);
+  cq_verify(v_client);
+
+  grpc_call_destroy(c);
+
+  cq_verifier_destroy(v_client);
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+/* Cancel after invoke, no payload */
+static void test_cancel_after_invoke(grpc_end2end_test_config config,
+                                     canceller call_cancel) {
+  grpc_call *c;
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  gpr_timespec deadline = five_seconds_time();
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  grpc_status chk_status = {GRPC_STATUS_CANCELLED, NULL};
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == call_cancel(c));
+
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_expect_finished_with_status(v_client, tag(3), chk_status, NULL);
+  cq_verify(v_client);
+
+  grpc_call_destroy(c);
+
+  cq_verifier_destroy(v_client);
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+/* Cancel after accept, no payload */
+static void test_cancel_after_accept(grpc_end2end_test_config config,
+                                     canceller call_cancel) {
+  grpc_call *c;
+  grpc_call *s;
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  gpr_timespec deadline = five_seconds_time();
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+  grpc_status chk_status = {GRPC_STATUS_CANCELLED, NULL};
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_accept(s, f.server_cq, tag(102), 0));
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == call_cancel(c));
+
+  cq_expect_finished_with_status(v_client, tag(3), chk_status, NULL);
+  cq_verify(v_client);
+
+  cq_expect_finished_with_status(v_server, tag(102), chk_status, NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+/* Cancel after accept with a writes closed, no payload */
+static void test_cancel_after_accept_and_writes_closed(
+    grpc_end2end_test_config config, canceller call_cancel) {
+  grpc_call *c;
+  grpc_call *s;
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  gpr_timespec deadline = five_seconds_time();
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+  grpc_status chk_status = {GRPC_STATUS_CANCELLED, NULL};
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_accept(s, f.server_cq, tag(102), 0));
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c, tag(4)));
+  cq_expect_finish_accepted(v_client, tag(4), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read(s, tag(101)));
+  cq_expect_empty_read(v_server, tag(101));
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK == call_cancel(c));
+
+  cq_expect_finished_with_status(v_client, tag(3), chk_status, NULL);
+  cq_verify(v_client);
+
+  cq_expect_finished_with_status(v_server, tag(102), chk_status, NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+/* Request/response with metadata and payload.*/
+static void test_request_response_with_metadata_and_payload(
+    grpc_end2end_test_config config) {
+  grpc_call *c;
+  grpc_call *s;
+  grpc_status send_status = {GRPC_STATUS_UNIMPLEMENTED, "xyz"};
+  gpr_slice request_payload_slice = gpr_slice_from_copied_string("hello world");
+  gpr_slice response_payload_slice = gpr_slice_from_copied_string("hello you");
+  grpc_byte_buffer *request_payload =
+      grpc_byte_buffer_create(&request_payload_slice, 1);
+  grpc_byte_buffer *response_payload =
+      grpc_byte_buffer_create(&response_payload_slice, 1);
+  gpr_timespec deadline = five_seconds_time();
+  grpc_metadata meta1 = {"key1", "val1", 4};
+  grpc_metadata meta2 = {"key2", "val2", 4};
+  grpc_metadata meta3 = {"key3", "val3", 4};
+  grpc_metadata meta4 = {"key4", "val4", 4};
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+
+  /* byte buffer holds the slice, we can unref it already */
+  gpr_slice_unref(request_payload_slice);
+  gpr_slice_unref(response_payload_slice);
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  /* add multiple metadata */
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata(c, &meta1, 0));
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata(c, &meta2, 0));
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write(c, request_payload, tag(4), 0));
+  /* destroy byte buffer early to ensure async code keeps track of its contents
+     correctly */
+  grpc_byte_buffer_destroy(request_payload);
+  cq_expect_write_accepted(v_client, tag(4), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, "key1", "val1", "key2", "val2", NULL);
+  cq_verify(v_server);
+
+  /* add multiple metadata */
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata(s, &meta3, 0));
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata(s, &meta4, 0));
+
+  grpc_call_accept(s, f.server_cq, tag(102), 0);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read(s, tag(5)));
+  cq_expect_read(v_server, tag(5), gpr_slice_from_copied_string("hello world"));
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write(s, response_payload, tag(6), 0));
+  /* destroy byte buffer early to ensure async code keeps track of its contents
+     correctly */
+  grpc_byte_buffer_destroy(response_payload);
+  cq_expect_write_accepted(v_server, tag(6), GRPC_OP_OK);
+  cq_verify(v_server);
+
+  /* fetch metadata.. */
+  cq_expect_client_metadata_read(v_client, tag(2), "key3", "val3", "key4",
+                                 "val4", NULL);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read(c, tag(7)));
+  cq_expect_read(v_client, tag(7), gpr_slice_from_copied_string("hello you"));
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c, tag(8)));
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write_status(s, send_status, tag(9)));
+
+  cq_expect_finish_accepted(v_client, tag(8), GRPC_OP_OK);
+  cq_expect_finished_with_status(v_client, tag(3), send_status, NULL);
+  cq_verify(v_client);
+
+  cq_expect_finish_accepted(v_server, tag(9), GRPC_OP_OK);
+  cq_expect_finished(v_server, tag(102), NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
+
+  end_test(&f);
+  config.tear_down_data(&f);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+}
+
+/* Request with a large amount of metadata.*/
+static void test_request_with_large_metadata(grpc_end2end_test_config config) {
+  grpc_call *c;
+  grpc_call *s;
+  grpc_status send_status = {GRPC_STATUS_OK, NULL};
+  gpr_timespec deadline = five_seconds_time();
+  grpc_metadata meta;
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+  const int large_size = 64 * 1024;
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+
+  meta.key = "key";
+  meta.value = gpr_malloc(large_size + 1);
+  memset(meta.value, 'a', large_size);
+  meta.value[large_size] = 0;
+  meta.value_length = large_size;
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  /* add the metadata */
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata(c, &meta, 0));
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, "key", meta.value, NULL);
+  cq_verify(v_server);
+
+  grpc_call_accept(s, f.server_cq, tag(102), 0);
+
+  /* fetch metadata.. */
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c, tag(8)));
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write_status(s, send_status, tag(9)));
+
+  cq_expect_finish_accepted(v_client, tag(8), GRPC_OP_OK);
+  cq_expect_finished_with_status(v_client, tag(3), send_status, NULL);
+  cq_verify(v_client);
+
+  cq_expect_finish_accepted(v_server, tag(9), GRPC_OP_OK);
+  cq_expect_finished(v_server, tag(102), NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
+
+  end_test(&f);
+  config.tear_down_data(&f);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+
+  gpr_free(meta.value);
+}
+
+/* Client pings and server pongs. Repeat messages rounds before finishing. */
+static void test_pingpong_streaming(grpc_end2end_test_config config,
+                                    int messages) {
+  int i;
+  grpc_call *c;
+  grpc_call *s = NULL;
+  grpc_status send_status = {GRPC_STATUS_UNIMPLEMENTED, "xyz"};
+  gpr_slice request_payload_slice = gpr_slice_from_copied_string("hello world");
+  gpr_slice response_payload_slice = gpr_slice_from_copied_string("hello you");
+  grpc_byte_buffer *request_payload = NULL;
+  grpc_byte_buffer *response_payload = NULL;
+  gpr_timespec deadline = n_seconds_time(messages * 5);
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+
+  gpr_log(GPR_INFO, "testing with %d message pairs.", messages);
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+  grpc_call_accept(s, f.server_cq, tag(102), 0);
+
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_verify(v_client);
+
+  for (i = 0; i < messages; i++) {
+    request_payload = grpc_byte_buffer_create(&request_payload_slice, 1);
+    GPR_ASSERT(GRPC_CALL_OK ==
+               grpc_call_start_write(c, request_payload, tag(2), 0));
+    /* destroy byte buffer early to ensure async code keeps track of its
+       contents
+       correctly */
+    grpc_byte_buffer_destroy(request_payload);
+    cq_expect_write_accepted(v_client, tag(2), GRPC_OP_OK);
+    cq_verify(v_client);
+
+    GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read(s, tag(3)));
+    cq_expect_read(v_server, tag(3),
+                   gpr_slice_from_copied_string("hello world"));
+    cq_verify(v_server);
+
+    response_payload = grpc_byte_buffer_create(&response_payload_slice, 1);
+    GPR_ASSERT(GRPC_CALL_OK ==
+               grpc_call_start_write(s, response_payload, tag(4), 0));
+    /* destroy byte buffer early to ensure async code keeps track of its
+       contents
+       correctly */
+    grpc_byte_buffer_destroy(response_payload);
+    cq_expect_write_accepted(v_server, tag(4), GRPC_OP_OK);
+    cq_verify(v_server);
+
+    GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read(c, tag(5)));
+    cq_expect_read(v_client, tag(5), gpr_slice_from_copied_string("hello you"));
+    cq_verify(v_client);
+  }
+
+  gpr_slice_unref(request_payload_slice);
+  gpr_slice_unref(response_payload_slice);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c, tag(6)));
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write_status(s, send_status, tag(7)));
+
+  cq_expect_finish_accepted(v_client, tag(6), GRPC_OP_OK);
+  cq_expect_finished_with_status(v_client, tag(3), send_status, NULL);
+  cq_verify(v_client);
+
+  cq_expect_finish_accepted(v_server, tag(7), GRPC_OP_OK);
+  cq_expect_finished(v_server, tag(102), NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
+
+  end_test(&f);
+  config.tear_down_data(&f);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+}
+
+static void test_early_server_shutdown_finishes_tags(
+    grpc_end2end_test_config config) {
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+  grpc_call *s = (void *)1;
+
+  /* upon shutdown, the server should finish all requested calls indicating
+     no new call */
+  grpc_server_request_call(f.server, tag(1000));
+  grpc_server_shutdown(f.server);
+  cq_expect_server_rpc_new(v_server, &s, tag(1000), NULL, NULL, gpr_inf_past,
+                           NULL);
+  cq_verify(v_server);
+  GPR_ASSERT(s == NULL);
+
+  end_test(&f);
+  config.tear_down_data(&f);
+  cq_verifier_destroy(v_server);
+}
+
+static void test_early_server_shutdown_finishes_inflight_calls(
+    grpc_end2end_test_config config) {
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  grpc_call *c;
+  grpc_call *s;
+  grpc_status expect_status = {GRPC_STATUS_UNAVAILABLE, NULL};
+  gpr_timespec deadline = five_seconds_time();
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c, tag(4)));
+  cq_expect_finish_accepted(v_client, tag(4), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_accept(s, f.server_cq, tag(102), 0));
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_verify(v_client);
+
+  /* shutdown and destroy the server */
+  shutdown_server(&f);
+
+  cq_expect_finished(v_server, tag(102), NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(s);
+
+  cq_expect_finished_with_status(v_client, tag(3), expect_status, NULL);
+  cq_verify(v_client);
+
+  grpc_call_destroy(c);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+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;
+  grpc_call *c1;
+  grpc_call *c2;
+  grpc_call *s1;
+  grpc_call *s2;
+  gpr_timespec deadline;
+  grpc_status send_status = {GRPC_STATUS_UNIMPLEMENTED, "xyz"};
+  cq_verifier *v_client;
+  cq_verifier *v_server;
+
+  server_arg.key = GRPC_ARG_MAX_CONCURRENT_STREAMS;
+  server_arg.type = GRPC_ARG_INTEGER;
+  server_arg.value.integer = 1;
+
+  server_args.num_args = 1;
+  server_args.args = &server_arg;
+
+  f = begin_test(config, __FUNCTION__, NULL, &server_args);
+  v_client = cq_verifier_create(f.client_cq);
+  v_server = cq_verifier_create(f.server_cq);
+
+  /* perform a ping-pong to ensure that settings have had a chance to round
+     trip */
+  simple_request_body(f);
+  /* perform another one to make sure that the one stream case still works */
+  simple_request_body(f);
+
+  /* start two requests - ensuring that the second is not accepted until
+     the first completes */
+  deadline = five_seconds_time();
+  c1 = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c1);
+  c2 = grpc_channel_create_call(f.client, "/bar", "test.google.com", deadline);
+  GPR_ASSERT(c1);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_invoke(c1, f.client_cq, tag(300),
+                                                    tag(301), tag(302), 0));
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_invoke(c2, f.client_cq, tag(400),
+                                                    tag(401), tag(402), 0));
+  cq_expect_invoke_accepted(v_client, tag(300), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c1, tag(303)));
+  cq_expect_finish_accepted(v_client, tag(303), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  cq_expect_server_rpc_new(v_server, &s1, tag(100), "/foo", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_accept(s1, f.server_cq, tag(102), 0));
+  cq_expect_client_metadata_read(v_client, tag(301), NULL);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write_status(s1, send_status, tag(103)));
+  cq_expect_finish_accepted(v_server, tag(103), GRPC_OP_OK);
+  cq_expect_finished(v_server, tag(102), NULL);
+  cq_verify(v_server);
+
+  /* first request is finished, we should be able to start the second */
+  cq_expect_finished_with_status(v_client, tag(302), send_status, NULL);
+  cq_expect_invoke_accepted(v_client, tag(400), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c2, tag(403)));
+  cq_expect_finish_accepted(v_client, tag(403), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(200)));
+  cq_expect_server_rpc_new(v_server, &s2, tag(200), "/bar", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_accept(s2, f.server_cq, tag(202), 0));
+  cq_expect_client_metadata_read(v_client, tag(401), NULL);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write_status(s2, send_status, tag(203)));
+  cq_expect_finish_accepted(v_server, tag(203), GRPC_OP_OK);
+  cq_expect_finished(v_server, tag(202), NULL);
+  cq_verify(v_server);
+
+  cq_expect_finished_with_status(v_client, tag(402), send_status, NULL);
+  cq_verify(v_client);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+
+  grpc_call_destroy(c1);
+  grpc_call_destroy(s1);
+  grpc_call_destroy(c2);
+  grpc_call_destroy(s2);
+
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+static gpr_slice large_slice() {
+  gpr_slice slice = gpr_slice_malloc(1000000);
+  memset(GPR_SLICE_START_PTR(slice), 0xab, GPR_SLICE_LENGTH(slice));
+  return slice;
+}
+
+static void test_invoke_large_request(grpc_end2end_test_config config) {
+  grpc_call *c;
+  grpc_call *s;
+  grpc_status send_status = {GRPC_STATUS_UNIMPLEMENTED, "xyz"};
+  gpr_slice request_payload_slice = large_slice();
+  grpc_byte_buffer *request_payload =
+      grpc_byte_buffer_create(&request_payload_slice, 1);
+  gpr_timespec deadline = five_seconds_time();
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+
+  /* byte buffer holds the slice, we can unref it already */
+  gpr_slice_unref(request_payload_slice);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write(c, request_payload, tag(4), 0));
+  /* destroy byte buffer early to ensure async code keeps track of its contents
+     correctly */
+  grpc_byte_buffer_destroy(request_payload);
+  /* write should not be accepted until the server is willing to read the
+     request (as this request is very large) */
+  cq_verify_empty(v_client);
+
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+
+  grpc_call_accept(s, f.server_cq, tag(102), 0);
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read(s, tag(5)));
+  /* now the write can be accepted */
+  cq_expect_write_accepted(v_client, tag(4), GRPC_OP_OK);
+  cq_verify(v_client);
+  cq_expect_read(v_server, tag(5), large_slice());
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c, tag(8)));
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write_status(s, send_status, tag(9)));
+
+  cq_expect_finish_accepted(v_client, tag(8), GRPC_OP_OK);
+  cq_expect_finished_with_status(v_client, tag(3), send_status, NULL);
+  cq_verify(v_client);
+
+  cq_expect_finish_accepted(v_server, tag(9), GRPC_OP_OK);
+  cq_expect_finished(v_server, tag(102), NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+void grpc_end2end_tests(grpc_end2end_test_config config) {
+  int i;
+  canceller cancellers[2] = {grpc_call_cancel, wait_for_deadline};
+
+  test_no_op(config);
+  test_invoke_simple_request(config, "simple_request_body",
+                             simple_request_body);
+  test_invoke_simple_request(config, "simple_request_body2",
+                             simple_request_body2);
+  test_invoke_10_simple_requests(config);
+  if (config.feature_mask & FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION) {
+    test_simple_delayed_request_short(config);
+    test_simple_delayed_request_long(config);
+  }
+  test_invoke_request_with_payload(config);
+  test_request_response_with_metadata_and_payload(config);
+  test_request_with_large_metadata(config);
+  test_writes_done_hangs_with_pending_read(config);
+  test_invoke_request_response_with_payload(config);
+  test_invoke_10_request_response_with_payload(config);
+  test_early_server_shutdown_finishes_tags(config);
+  test_early_server_shutdown_finishes_inflight_calls(config);
+  test_max_concurrent_streams(config);
+  test_invoke_large_request(config);
+  for (i = 0; i < GPR_ARRAY_SIZE(cancellers); i++) {
+    test_cancel_in_a_vacuum(config, cancellers[i]);
+    test_cancel_after_invoke(config, cancellers[i]);
+    test_cancel_after_accept(config, cancellers[i]);
+    test_cancel_after_accept_and_writes_closed(config, cancellers[i]);
+  }
+  test_cancel_before_invoke(config);
+  for (i = 1; i < 10; i++) {
+    test_pingpong_streaming(config, i);
+  }
+}
diff --git a/test/core/end2end/end2end_tests.h b/test/core/end2end/end2end_tests.h
new file mode 100644
index 0000000..b509b1a
--- /dev/null
+++ b/test/core/end2end/end2end_tests.h
@@ -0,0 +1,66 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef __GRPC_TEST_END2END_END2END_TESTS_H__
+#define __GRPC_TEST_END2END_END2END_TESTS_H__
+
+#include <grpc/grpc.h>
+
+typedef struct grpc_end2end_test_fixture grpc_end2end_test_fixture;
+typedef struct grpc_end2end_test_config grpc_end2end_test_config;
+
+#define FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION 1
+
+struct grpc_end2end_test_fixture {
+  grpc_completion_queue *server_cq;
+  grpc_completion_queue *client_cq;
+  grpc_server *server;
+  grpc_channel *client;
+  void *fixture_data;
+};
+
+struct grpc_end2end_test_config {
+  const char *name;
+  gpr_uint32 feature_mask;
+  grpc_end2end_test_fixture (*create_fixture)(grpc_channel_args *client_args,
+                                              grpc_channel_args *server_args);
+  void (*init_client)(grpc_end2end_test_fixture *f,
+                      grpc_channel_args *client_args);
+  void (*init_server)(grpc_end2end_test_fixture *f,
+                      grpc_channel_args *server_args);
+  void (*tear_down_data)(grpc_end2end_test_fixture *f);
+};
+
+void grpc_end2end_tests(grpc_end2end_test_config config);
+
+#endif  /* __GRPC_TEST_END2END_END2END_TESTS_H__ */
diff --git a/test/core/end2end/fixtures/chttp2_fake_security.c b/test/core/end2end/fixtures/chttp2_fake_security.c
new file mode 100644
index 0000000..a1f29de
--- /dev/null
+++ b/test/core/end2end/fixtures/chttp2_fake_security.c
@@ -0,0 +1,139 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include "src/core/channel/channel_args.h"
+#include "src/core/eventmanager/em.h"
+#include "src/core/security/credentials.h"
+#include "src/core/security/security_context.h"
+#include <grpc/support/alloc.h>
+#include <grpc/support/host_port.h>
+#include <grpc/support/log.h>
+#include "test/core/util/test_config.h"
+#include "test/core/util/port.h"
+#include "test/core/end2end/data/ssl_test_data.h"
+
+
+static grpc_em em;
+
+typedef struct fullstack_secure_fixture_data {
+  char *localaddr;
+} fullstack_secure_fixture_data;
+
+static grpc_end2end_test_fixture chttp2_create_fixture_secure_fullstack(
+    grpc_channel_args *client_args, grpc_channel_args *server_args) {
+  grpc_end2end_test_fixture f;
+  int port = grpc_pick_unused_port_or_die();
+  fullstack_secure_fixture_data *ffd =
+      gpr_malloc(sizeof(fullstack_secure_fixture_data));
+
+  gpr_join_host_port(&ffd->localaddr, "localhost", port);
+
+  f.fixture_data = ffd;
+  f.client_cq = grpc_completion_queue_create();
+  f.server_cq = grpc_completion_queue_create();
+
+  return f;
+}
+
+static void chttp2_init_client_secure_fullstack(grpc_end2end_test_fixture *f,
+                                                grpc_channel_args *client_args,
+                                                grpc_credentials *creds) {
+  fullstack_secure_fixture_data *ffd = f->fixture_data;
+  f->client = grpc_secure_channel_create(creds, ffd->localaddr, client_args);
+  GPR_ASSERT(f->client != NULL);
+  grpc_credentials_release(creds);
+}
+
+static void chttp2_init_server_secure_fullstack(
+    grpc_end2end_test_fixture *f, grpc_channel_args *server_args,
+    grpc_server_credentials *server_creds) {
+  fullstack_secure_fixture_data *ffd = f->fixture_data;
+  f->server =
+      grpc_secure_server_create(server_creds, f->server_cq, server_args);
+  grpc_server_credentials_release(server_creds);
+  grpc_server_add_secure_http2_port(f->server, ffd->localaddr);
+  grpc_server_start(f->server);
+}
+
+void chttp2_tear_down_secure_fullstack(grpc_end2end_test_fixture *f) {
+  fullstack_secure_fixture_data *ffd = f->fixture_data;
+  gpr_free(ffd->localaddr);
+  gpr_free(ffd);
+}
+
+static void chttp2_init_client_fake_secure_fullstack(
+    grpc_end2end_test_fixture *f, grpc_channel_args *client_args) {
+  grpc_credentials *fake_ts_creds =
+      grpc_fake_transport_security_credentials_create();
+  chttp2_init_client_secure_fullstack(f, client_args, fake_ts_creds);
+}
+
+static void chttp2_init_server_fake_secure_fullstack(
+    grpc_end2end_test_fixture *f, grpc_channel_args *server_args) {
+  grpc_server_credentials *fake_ts_creds =
+      grpc_fake_transport_security_server_credentials_create();
+  chttp2_init_server_secure_fullstack(f, server_args, fake_ts_creds);
+}
+
+/* All test configurations */
+
+static grpc_end2end_test_config configs[] = {
+    {"chttp2/fake_secure_fullstack", FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION,
+     chttp2_create_fixture_secure_fullstack,
+     chttp2_init_client_fake_secure_fullstack,
+     chttp2_init_server_fake_secure_fullstack,
+     chttp2_tear_down_secure_fullstack},
+};
+
+int main(int argc, char **argv) {
+  size_t i;
+  grpc_test_init(argc, argv);
+
+
+  grpc_init();
+  grpc_em_init(&em);
+
+  for (i = 0; i < sizeof(configs) / sizeof(*configs); i++) {
+    grpc_end2end_tests(configs[i]);
+  }
+
+  GPR_ASSERT(grpc_em_destroy(&em) == GRPC_EM_OK);
+  grpc_shutdown();
+
+  return 0;
+}
diff --git a/test/core/end2end/fixtures/chttp2_fullstack.c b/test/core/end2end/fixtures/chttp2_fullstack.c
new file mode 100644
index 0000000..da75d61
--- /dev/null
+++ b/test/core/end2end/fixtures/chttp2_fullstack.c
@@ -0,0 +1,123 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "src/core/channel/client_channel.h"
+#include "src/core/channel/connected_channel.h"
+#include "src/core/channel/http_filter.h"
+#include "src/core/channel/http_server_filter.h"
+#include "src/core/eventmanager/em.h"
+#include "src/core/surface/channel.h"
+#include "src/core/surface/client.h"
+#include "src/core/surface/server.h"
+#include "src/core/surface/surface_em.h"
+#include "src/core/transport/chttp2_transport.h"
+#include <grpc/support/alloc.h>
+#include <grpc/support/host_port.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/thd.h>
+#include <grpc/support/useful.h>
+#include "test/core/util/port.h"
+#include "test/core/util/test_config.h"
+
+typedef struct fullstack_fixture_data {
+  char *localaddr;
+} fullstack_fixture_data;
+
+static grpc_end2end_test_fixture chttp2_create_fixture_fullstack(
+    grpc_channel_args *client_args, grpc_channel_args *server_args) {
+  grpc_end2end_test_fixture f;
+  int port = grpc_pick_unused_port_or_die();
+  fullstack_fixture_data *ffd = gpr_malloc(sizeof(fullstack_fixture_data));
+
+  gpr_join_host_port(&ffd->localaddr, "localhost", port);
+
+  f.fixture_data = ffd;
+  f.client_cq = grpc_completion_queue_create();
+  f.server_cq = grpc_completion_queue_create();
+
+  return f;
+}
+
+void chttp2_init_client_fullstack(grpc_end2end_test_fixture *f,
+                                  grpc_channel_args *client_args) {
+  fullstack_fixture_data *ffd = f->fixture_data;
+  f->client = grpc_channel_create(ffd->localaddr, client_args);
+}
+
+void chttp2_init_server_fullstack(grpc_end2end_test_fixture *f,
+                                  grpc_channel_args *server_args) {
+  fullstack_fixture_data *ffd = f->fixture_data;
+  f->server = grpc_server_create(f->server_cq, server_args);
+  grpc_server_add_http2_port(f->server, ffd->localaddr);
+  grpc_server_start(f->server);
+}
+
+void chttp2_tear_down_fullstack(grpc_end2end_test_fixture *f) {
+  fullstack_fixture_data *ffd = f->fixture_data;
+  gpr_free(ffd->localaddr);
+  gpr_free(ffd);
+}
+
+/* All test configurations */
+static grpc_end2end_test_config configs[] = {
+    {"chttp2/fullstack", FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION,
+     chttp2_create_fixture_fullstack, chttp2_init_client_fullstack,
+     chttp2_init_server_fullstack, chttp2_tear_down_fullstack},
+};
+
+int main(int argc, char **argv) {
+  size_t i;
+
+  grpc_test_init(argc, argv);
+  grpc_init();
+
+  for (i = 0; i < sizeof(configs) / sizeof(*configs); i++) {
+    grpc_end2end_tests(configs[i]);
+  }
+
+  grpc_shutdown();
+
+  return 0;
+}
diff --git a/test/core/end2end/fixtures/chttp2_simple_ssl_fullstack.c b/test/core/end2end/fixtures/chttp2_simple_ssl_fullstack.c
new file mode 100644
index 0000000..2dd3ce9
--- /dev/null
+++ b/test/core/end2end/fixtures/chttp2_simple_ssl_fullstack.c
@@ -0,0 +1,146 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include "src/core/channel/channel_args.h"
+#include "src/core/eventmanager/em.h"
+#include "src/core/security/credentials.h"
+#include "src/core/security/security_context.h"
+#include <grpc/support/alloc.h>
+#include <grpc/support/host_port.h>
+#include <grpc/support/log.h>
+#include "test/core/util/test_config.h"
+#include "test/core/util/port.h"
+#include "test/core/end2end/data/ssl_test_data.h"
+
+
+static grpc_em em;
+
+typedef struct fullstack_secure_fixture_data {
+  char *localaddr;
+} fullstack_secure_fixture_data;
+
+static grpc_end2end_test_fixture chttp2_create_fixture_secure_fullstack(
+    grpc_channel_args *client_args, grpc_channel_args *server_args) {
+  grpc_end2end_test_fixture f;
+  int port = grpc_pick_unused_port_or_die();
+  fullstack_secure_fixture_data *ffd =
+      gpr_malloc(sizeof(fullstack_secure_fixture_data));
+
+  gpr_join_host_port(&ffd->localaddr, "localhost", port);
+
+  f.fixture_data = ffd;
+  f.client_cq = grpc_completion_queue_create();
+  f.server_cq = grpc_completion_queue_create();
+
+  return f;
+}
+
+static void chttp2_init_client_secure_fullstack(grpc_end2end_test_fixture *f,
+                                                grpc_channel_args *client_args,
+                                                grpc_credentials *creds) {
+  fullstack_secure_fixture_data *ffd = f->fixture_data;
+  f->client = grpc_secure_channel_create(creds, ffd->localaddr, client_args);
+  GPR_ASSERT(f->client != NULL);
+  grpc_credentials_release(creds);
+}
+
+static void chttp2_init_server_secure_fullstack(
+    grpc_end2end_test_fixture *f, grpc_channel_args *server_args,
+    grpc_server_credentials *server_creds) {
+  fullstack_secure_fixture_data *ffd = f->fixture_data;
+  f->server =
+      grpc_secure_server_create(server_creds, f->server_cq, server_args);
+  grpc_server_credentials_release(server_creds);
+  grpc_server_add_secure_http2_port(f->server, ffd->localaddr);
+  grpc_server_start(f->server);
+}
+
+void chttp2_tear_down_secure_fullstack(grpc_end2end_test_fixture *f) {
+  fullstack_secure_fixture_data *ffd = f->fixture_data;
+  gpr_free(ffd->localaddr);
+  gpr_free(ffd);
+}
+
+static void chttp2_init_client_simple_ssl_secure_fullstack(
+    grpc_end2end_test_fixture *f, grpc_channel_args *client_args) {
+  grpc_credentials *ssl_creds = grpc_ssl_credentials_create(
+      test_ca_cert, test_ca_cert_size, NULL, 0, NULL, 0);
+  grpc_arg ssl_name_override = {GRPC_ARG_STRING,
+                                GRPC_SSL_TARGET_NAME_OVERRIDE_ARG,
+                                {"foo.test.google.com"}};
+  grpc_channel_args *new_client_args =
+      grpc_channel_args_copy_and_add(client_args, &ssl_name_override);
+  chttp2_init_client_secure_fullstack(f, new_client_args, ssl_creds);
+  grpc_channel_args_destroy(new_client_args);
+}
+
+static void chttp2_init_server_simple_ssl_secure_fullstack(
+    grpc_end2end_test_fixture *f, grpc_channel_args *server_args) {
+  grpc_server_credentials *ssl_creds = grpc_ssl_server_credentials_create(
+      NULL, 0, test_server1_key, test_server1_key_size, test_server1_cert,
+      test_server1_cert_size);
+  chttp2_init_server_secure_fullstack(f, server_args, ssl_creds);
+}
+
+/* All test configurations */
+
+static grpc_end2end_test_config configs[] = {
+    {"chttp2/simple_ssl_fullstack", FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION,
+     chttp2_create_fixture_secure_fullstack,
+     chttp2_init_client_simple_ssl_secure_fullstack,
+     chttp2_init_server_simple_ssl_secure_fullstack,
+     chttp2_tear_down_secure_fullstack},
+};
+
+int main(int argc, char **argv) {
+  size_t i;
+  grpc_test_init(argc, argv);
+
+
+  grpc_init();
+  grpc_em_init(&em);
+
+  for (i = 0; i < sizeof(configs) / sizeof(*configs); i++) {
+    grpc_end2end_tests(configs[i]);
+  }
+
+  GPR_ASSERT(grpc_em_destroy(&em) == GRPC_EM_OK);
+  grpc_shutdown();
+
+  return 0;
+}
diff --git a/test/core/end2end/fixtures/chttp2_simple_ssl_with_oauth2_fullstack.c b/test/core/end2end/fixtures/chttp2_simple_ssl_with_oauth2_fullstack.c
new file mode 100644
index 0000000..22720c5
--- /dev/null
+++ b/test/core/end2end/fixtures/chttp2_simple_ssl_with_oauth2_fullstack.c
@@ -0,0 +1,146 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include "src/core/channel/channel_args.h"
+#include "src/core/eventmanager/em.h"
+#include "src/core/security/credentials.h"
+#include "src/core/security/security_context.h"
+#include <grpc/support/alloc.h>
+#include <grpc/support/host_port.h>
+#include <grpc/support/log.h>
+#include "test/core/util/test_config.h"
+#include "test/core/util/port.h"
+#include "test/core/end2end/data/ssl_test_data.h"
+
+
+static grpc_em em;
+
+typedef struct fullstack_secure_fixture_data {
+  char *localaddr;
+} fullstack_secure_fixture_data;
+
+static grpc_end2end_test_fixture chttp2_create_fixture_secure_fullstack(
+    grpc_channel_args *client_args, grpc_channel_args *server_args) {
+  grpc_end2end_test_fixture f;
+  int port = grpc_pick_unused_port_or_die();
+  fullstack_secure_fixture_data *ffd =
+      gpr_malloc(sizeof(fullstack_secure_fixture_data));
+
+  gpr_join_host_port(&ffd->localaddr, "localhost", port);
+
+  f.fixture_data = ffd;
+  f.client_cq = grpc_completion_queue_create();
+  f.server_cq = grpc_completion_queue_create();
+
+  return f;
+}
+
+static void chttp2_init_server_secure_fullstack(
+    grpc_end2end_test_fixture *f, grpc_channel_args *server_args,
+    grpc_server_credentials *server_creds) {
+  fullstack_secure_fixture_data *ffd = f->fixture_data;
+  f->server =
+      grpc_secure_server_create(server_creds, f->server_cq, server_args);
+  grpc_server_credentials_release(server_creds);
+  grpc_server_add_secure_http2_port(f->server, ffd->localaddr);
+  grpc_server_start(f->server);
+}
+
+void chttp2_tear_down_secure_fullstack(grpc_end2end_test_fixture *f) {
+  fullstack_secure_fixture_data *ffd = f->fixture_data;
+  gpr_free(ffd->localaddr);
+  gpr_free(ffd);
+}
+
+static void chttp2_init_client_simple_ssl_with_oauth2_secure_fullstack(
+    grpc_end2end_test_fixture *f, grpc_channel_args *client_args) {
+  /* TODO(jboeuf): Replace with composite credentials when those are
+     implemented. */
+  grpc_channel_security_context *client_ctx = NULL;
+  fullstack_secure_fixture_data *ffd = f->fixture_data;
+  grpc_ssl_config config;
+  grpc_credentials *oauth2 =
+      grpc_fake_oauth2_credentials_create("Bearer aaslkfjs424535asdf", 1);
+  memset(&config, 0, sizeof(grpc_ssl_config));
+  config.pem_root_certs = test_ca_cert;
+  config.pem_root_certs_size = test_ca_cert_size;
+  GPR_ASSERT(grpc_ssl_channel_security_context_create(
+                 oauth2, &config, "foo.test.google.com", &client_ctx) ==
+             GRPC_SECURITY_OK);
+  f->client = grpc_secure_channel_create_internal(ffd->localaddr, client_args,
+                                                  client_ctx);
+  grpc_security_context_unref(&client_ctx->base);
+  grpc_credentials_unref(oauth2);
+}
+
+static void chttp2_init_server_simple_ssl_secure_fullstack(
+    grpc_end2end_test_fixture *f, grpc_channel_args *server_args) {
+  grpc_server_credentials *ssl_creds = grpc_ssl_server_credentials_create(
+      NULL, 0, test_server1_key, test_server1_key_size, test_server1_cert,
+      test_server1_cert_size);
+  chttp2_init_server_secure_fullstack(f, server_args, ssl_creds);
+}
+
+/* All test configurations */
+
+static grpc_end2end_test_config configs[] = {
+    {"chttp2/simple_ssl_with_oauth2_fullstack",
+     FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION,
+     chttp2_create_fixture_secure_fullstack,
+     chttp2_init_client_simple_ssl_with_oauth2_secure_fullstack,
+     chttp2_init_server_simple_ssl_secure_fullstack,
+     chttp2_tear_down_secure_fullstack},
+};
+
+int main(int argc, char **argv) {
+  size_t i;
+  grpc_test_init(argc, argv);
+
+
+  grpc_init();
+  grpc_em_init(&em);
+
+  for (i = 0; i < sizeof(configs) / sizeof(*configs); i++) {
+    grpc_end2end_tests(configs[i]);
+  }
+
+  GPR_ASSERT(grpc_em_destroy(&em) == GRPC_EM_OK);
+  grpc_shutdown();
+
+  return 0;
+}
diff --git a/test/core/end2end/fixtures/chttp2_socket_pair.c b/test/core/end2end/fixtures/chttp2_socket_pair.c
new file mode 100644
index 0000000..593ff78
--- /dev/null
+++ b/test/core/end2end/fixtures/chttp2_socket_pair.c
@@ -0,0 +1,169 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "src/core/channel/client_channel.h"
+#include "src/core/channel/connected_channel.h"
+#include "src/core/channel/http_filter.h"
+#include "src/core/channel/http_server_filter.h"
+#include "src/core/eventmanager/em.h"
+#include "src/core/surface/channel.h"
+#include "src/core/surface/client.h"
+#include "src/core/surface/server.h"
+#include "src/core/surface/surface_em.h"
+#include "src/core/transport/chttp2_transport.h"
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/thd.h>
+#include <grpc/support/useful.h>
+#include "test/core/util/port.h"
+#include "test/core/util/test_config.h"
+
+static void create_sockets(int sv[2]) {
+  int flags;
+  GPR_ASSERT(socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == 0);
+  flags = fcntl(sv[0], F_GETFL, 0);
+  GPR_ASSERT(fcntl(sv[0], F_SETFL, flags | O_NONBLOCK) == 0);
+  flags = fcntl(sv[1], F_GETFL, 0);
+  GPR_ASSERT(fcntl(sv[1], F_SETFL, flags | O_NONBLOCK) == 0);
+}
+
+/* chttp2 transport that is immediately available (used for testing
+   connected_channel without a client_channel */
+
+static grpc_transport_setup_result server_setup_transport(
+    void *ts, grpc_transport *transport, grpc_mdctx *mdctx) {
+  grpc_end2end_test_fixture *f = ts;
+  static grpc_channel_filter const *extra_filters[] = {&grpc_http_server_filter,
+                                                       &grpc_http_filter};
+  return grpc_server_setup_transport(f->server, transport, extra_filters,
+                                     GPR_ARRAY_SIZE(extra_filters), mdctx);
+}
+
+typedef struct {
+  grpc_end2end_test_fixture *f;
+  grpc_channel_args *client_args;
+} sp_client_setup;
+
+static grpc_transport_setup_result client_setup_transport(
+    void *ts, grpc_transport *transport, grpc_mdctx *mdctx) {
+  sp_client_setup *cs = ts;
+
+  const grpc_channel_filter *filters[] = {&grpc_client_surface_filter,
+                                          &grpc_connected_channel_filter};
+  size_t nfilters = sizeof(filters) / sizeof(*filters);
+  grpc_channel *channel = grpc_channel_create_from_filters(
+      filters, nfilters, cs->client_args, mdctx, 1);
+
+  cs->f->client = channel;
+
+  return grpc_connected_channel_bind_transport(
+      grpc_channel_get_channel_stack(channel), transport);
+}
+
+typedef struct socketpair_fixture_data { int sv[2]; } socketpair_fixture_data;
+
+static grpc_end2end_test_fixture chttp2_create_fixture_socketpair(
+    grpc_channel_args *client_args, grpc_channel_args *server_args) {
+  socketpair_fixture_data *sfd = gpr_malloc(sizeof(socketpair_fixture_data));
+
+  grpc_end2end_test_fixture f;
+  f.fixture_data = sfd;
+  f.client_cq = grpc_completion_queue_create();
+  f.server_cq = grpc_completion_queue_create();
+  f.server = grpc_server_create_from_filters(f.server_cq, NULL, 0, server_args);
+  f.client = NULL;
+
+  create_sockets(sfd->sv);
+
+  return f;
+}
+
+static void chttp2_init_client_socketpair(grpc_end2end_test_fixture *f,
+                                          grpc_channel_args *client_args) {
+  socketpair_fixture_data *sfd = f->fixture_data;
+  grpc_endpoint *cli_tcp;
+  sp_client_setup cs;
+  cs.client_args = client_args;
+  cs.f = f;
+  cli_tcp = grpc_tcp_create_dbg(sfd->sv[0], grpc_surface_em(), 65536);
+  grpc_create_chttp2_transport(client_setup_transport, &cs, client_args,
+                               cli_tcp, NULL, 0, grpc_mdctx_create(), 1);
+  GPR_ASSERT(f->client);
+}
+
+static void chttp2_init_server_socketpair(grpc_end2end_test_fixture *f,
+                                          grpc_channel_args *server_args) {
+  socketpair_fixture_data *sfd = f->fixture_data;
+  grpc_endpoint *svr_tcp;
+  svr_tcp = grpc_tcp_create_dbg(sfd->sv[1], grpc_surface_em(), 65536);
+  grpc_create_chttp2_transport(server_setup_transport, f, server_args, svr_tcp,
+                               NULL, 0, grpc_mdctx_create(), 0);
+}
+
+static void chttp2_tear_down_socketpair(grpc_end2end_test_fixture *f) {
+  gpr_free(f->fixture_data);
+}
+
+/* All test configurations */
+static grpc_end2end_test_config configs[] = {
+    {"chttp2/socketpair", 0, chttp2_create_fixture_socketpair,
+     chttp2_init_client_socketpair, chttp2_init_server_socketpair,
+     chttp2_tear_down_socketpair},
+};
+
+int main(int argc, char **argv) {
+  size_t i;
+
+  grpc_test_init(argc, argv);
+  grpc_init();
+
+  for (i = 0; i < sizeof(configs) / sizeof(*configs); i++) {
+    grpc_end2end_tests(configs[i]);
+  }
+
+  grpc_shutdown();
+
+  return 0;
+}
diff --git a/test/core/end2end/gen_build_json.py b/test/core/end2end/gen_build_json.py
new file mode 100755
index 0000000..0bcccbe
--- /dev/null
+++ b/test/core/end2end/gen_build_json.py
@@ -0,0 +1,82 @@
+import simplejson
+
+END2END_FIXTURES = [
+    'chttp2_fake_security',
+    'chttp2_fullstack',
+    'chttp2_simple_ssl_fullstack',
+    'chttp2_simple_ssl_with_oauth2_fullstack',
+    'chttp2_socket_pair',
+]
+
+
+END2END_TESTS = [
+    'cancel_after_accept',
+    'cancel_after_accept_and_writes_closed',
+    'cancel_after_invoke',
+    'cancel_before_invoke',
+    'cancel_in_a_vacuum',
+    'early_server_shutdown_finishes_inflight_calls',
+    'early_server_shutdown_finishes_tags',
+    'invoke_large_request',
+    'max_concurrent_streams',
+    'no_op',
+    'ping_pong_streaming',
+    'request_response_with_metadata_and_payload',
+    'request_response_with_payload',
+    'simple_delayed_request',
+    'simple_request',
+    'thread_stress_test',
+    'writes_done_hangs_with_pending_read',
+]
+
+
+def main():
+  json = {
+      '#': 'generated with test/end2end/gen_build_json.py',
+      'libs': [
+          {
+              'name': 'end2end_fixture_%s' % f,
+              'build': 'private',
+              'secure': True,
+              'src': ['test/core/end2end/fixtures/%s.c' % f]
+          }
+          for f in END2END_FIXTURES] + [
+          {
+              'name': 'end2end_test_%s' % t,
+              'build': 'private',
+              'secure': False,
+              'src': ['test/core/end2end/tests/%s.c' % t]
+          }
+          for t in END2END_TESTS] + [
+          {
+              'name': 'end2end_certs',
+              'build': 'private',
+              'src': [
+                  "test/core/end2end/data/ca_cert.c",
+                  "test/core/end2end/data/server1_cert.c",
+                  "test/core/end2end/data/server1_key.c"
+              ]
+          }
+          ],
+      'targets': [
+          {
+              'name': '%s_%s_test' % (f, t),
+              'build': 'test',
+              'src': [],
+              'deps': [
+                  'end2end_fixture_%s' % f,
+                  'end2end_test_%s' % t,
+                  'end2end_certs',
+                  'grpc_test_util',
+                  'grpc',
+                  'gpr'
+              ]
+          }
+      for f in END2END_FIXTURES
+      for t in END2END_TESTS]}
+  print simplejson.dumps(json, sort_keys=True, indent=2 * ' ')
+
+
+if __name__ == '__main__':
+  main()
+
diff --git a/test/core/end2end/no_server_test.c b/test/core/end2end/no_server_test.c
new file mode 100644
index 0000000..f081056
--- /dev/null
+++ b/test/core/end2end/no_server_test.c
@@ -0,0 +1,83 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <grpc/grpc.h>
+#include <grpc/support/log.h>
+#include "test/core/end2end/cq_verifier.h"
+#include "test/core/util/test_config.h"
+
+static void *tag(gpr_intptr i) { return (void *)i; }
+
+int main(int argc, char **argv) {
+  grpc_channel *chan;
+  grpc_call *call;
+  gpr_timespec timeout = gpr_time_from_micros(4000000);
+  gpr_timespec deadline = gpr_time_add(gpr_now(), timeout);
+  grpc_completion_queue *cq;
+  cq_verifier *cqv;
+  grpc_event *ev;
+  int done;
+  grpc_status expect_status = {GRPC_STATUS_CANCELLED, NULL};
+
+  grpc_test_init(argc, argv);
+  grpc_init();
+
+  cq = grpc_completion_queue_create();
+  cqv = cq_verifier_create(cq);
+
+  /* create a call, channel to a non existant server */
+  chan = grpc_channel_create("nonexistant:54321", NULL);
+  call = grpc_channel_create_call(chan, "/foo", "nonexistant", deadline);
+  GPR_ASSERT(grpc_call_start_invoke(call, cq, tag(1), tag(2), tag(3), 0) ==
+             GRPC_CALL_OK);
+  /* verify that all tags get completed */
+  cq_expect_invoke_accepted(cqv, tag(1), GRPC_OP_ERROR);
+  cq_expect_client_metadata_read(cqv, tag(2), NULL);
+  cq_expect_finished_with_status(cqv, tag(3), expect_status, NULL);
+  cq_verify(cqv);
+
+  grpc_completion_queue_shutdown(cq);
+  for (done = 0; !done;) {
+    ev = grpc_completion_queue_next(cq, gpr_inf_future);
+    done = ev->type == GRPC_QUEUE_SHUTDOWN;
+    grpc_event_finish(ev);
+  }
+  grpc_completion_queue_destroy(cq);
+  grpc_call_destroy(call);
+  grpc_channel_destroy(chan);
+  cq_verifier_destroy(cqv);
+
+  grpc_shutdown();
+
+  return 0;
+}
diff --git a/test/core/end2end/tests/cancel_after_accept.c b/test/core/end2end/tests/cancel_after_accept.c
new file mode 100644
index 0000000..c9c3a18
--- /dev/null
+++ b/test/core/end2end/tests/cancel_after_accept.c
@@ -0,0 +1,166 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <grpc/byte_buffer.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include <grpc/support/useful.h>
+#include "test/core/end2end/cq_verifier.h"
+
+/* allow cancellation by either grpc_call_cancel, or by wait_for_deadline (which
+ * does nothing) */
+typedef grpc_call_error (*canceller)(grpc_call *call);
+
+static grpc_call_error wait_for_deadline(grpc_call *call) {
+  return GRPC_CALL_OK;
+}
+
+enum { TIMEOUT = 200000 };
+
+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) {
+  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);
+  return f;
+}
+
+static gpr_timespec n_seconds_time(int n) {
+  return gpr_time_add(gpr_now(), gpr_time_from_micros(GPR_US_PER_SEC * n));
+}
+
+static gpr_timespec five_seconds_time() { return n_seconds_time(5); }
+
+static void drain_cq(grpc_completion_queue *cq) {
+  grpc_event *ev;
+  grpc_completion_type type;
+  do {
+    ev = grpc_completion_queue_next(cq, five_seconds_time());
+    GPR_ASSERT(ev);
+    type = ev->type;
+    grpc_event_finish(ev);
+  } while (type != GRPC_QUEUE_SHUTDOWN);
+}
+
+static void shutdown_server(grpc_end2end_test_fixture *f) {
+  if (!f->server) return;
+  grpc_server_shutdown(f->server);
+  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);
+  f->client = NULL;
+}
+
+static void end_test(grpc_end2end_test_fixture *f) {
+  shutdown_server(f);
+  shutdown_client(f);
+
+  grpc_completion_queue_shutdown(f->server_cq);
+  drain_cq(f->server_cq);
+  grpc_completion_queue_destroy(f->server_cq);
+  grpc_completion_queue_shutdown(f->client_cq);
+  drain_cq(f->client_cq);
+  grpc_completion_queue_destroy(f->client_cq);
+}
+
+/* Cancel after accept, no payload */
+static void test_cancel_after_accept(grpc_end2end_test_config config,
+                                     canceller call_cancel) {
+  grpc_call *c;
+  grpc_call *s;
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  gpr_timespec deadline = five_seconds_time();
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+  grpc_status chk_status = {GRPC_STATUS_CANCELLED, NULL};
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_accept(s, f.server_cq, tag(102), 0));
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == call_cancel(c));
+
+  cq_expect_finished_with_status(v_client, tag(3), chk_status, NULL);
+  cq_verify(v_client);
+
+  cq_expect_finished_with_status(v_server, tag(102), chk_status, NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+
+void grpc_end2end_tests(grpc_end2end_test_config config) {
+  int i;
+  canceller cancellers[2] = {grpc_call_cancel, wait_for_deadline};
+
+  for (i = 0; i < GPR_ARRAY_SIZE(cancellers); i++) {
+    test_cancel_after_accept(config, cancellers[i]);
+  }
+}
diff --git a/test/core/end2end/tests/cancel_after_accept_and_writes_closed.c b/test/core/end2end/tests/cancel_after_accept_and_writes_closed.c
new file mode 100644
index 0000000..904dabe
--- /dev/null
+++ b/test/core/end2end/tests/cancel_after_accept_and_writes_closed.c
@@ -0,0 +1,173 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <grpc/byte_buffer.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include <grpc/support/useful.h>
+#include "test/core/end2end/cq_verifier.h"
+
+/* allow cancellation by either grpc_call_cancel, or by wait_for_deadline (which
+ * does nothing) */
+typedef grpc_call_error (*canceller)(grpc_call *call);
+
+static grpc_call_error wait_for_deadline(grpc_call *call) {
+  return GRPC_CALL_OK;
+}
+
+enum { TIMEOUT = 200000 };
+
+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) {
+  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);
+  return f;
+}
+
+static gpr_timespec n_seconds_time(int n) {
+  return gpr_time_add(gpr_now(), gpr_time_from_micros(GPR_US_PER_SEC * n));
+}
+
+static gpr_timespec five_seconds_time() { return n_seconds_time(5); }
+
+static void drain_cq(grpc_completion_queue *cq) {
+  grpc_event *ev;
+  grpc_completion_type type;
+  do {
+    ev = grpc_completion_queue_next(cq, five_seconds_time());
+    GPR_ASSERT(ev);
+    type = ev->type;
+    grpc_event_finish(ev);
+  } while (type != GRPC_QUEUE_SHUTDOWN);
+}
+
+static void shutdown_server(grpc_end2end_test_fixture *f) {
+  if (!f->server) return;
+  grpc_server_shutdown(f->server);
+  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);
+  f->client = NULL;
+}
+
+static void end_test(grpc_end2end_test_fixture *f) {
+  shutdown_server(f);
+  shutdown_client(f);
+
+  grpc_completion_queue_shutdown(f->server_cq);
+  drain_cq(f->server_cq);
+  grpc_completion_queue_destroy(f->server_cq);
+  grpc_completion_queue_shutdown(f->client_cq);
+  drain_cq(f->client_cq);
+  grpc_completion_queue_destroy(f->client_cq);
+}
+
+/* Cancel after accept with a writes closed, no payload */
+static void test_cancel_after_accept_and_writes_closed(
+    grpc_end2end_test_config config, canceller call_cancel) {
+  grpc_call *c;
+  grpc_call *s;
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  gpr_timespec deadline = five_seconds_time();
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+  grpc_status chk_status = {GRPC_STATUS_CANCELLED, NULL};
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_accept(s, f.server_cq, tag(102), 0));
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c, tag(4)));
+  cq_expect_finish_accepted(v_client, tag(4), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read(s, tag(101)));
+  cq_expect_empty_read(v_server, tag(101));
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK == call_cancel(c));
+
+  cq_expect_finished_with_status(v_client, tag(3), chk_status, NULL);
+  cq_verify(v_client);
+
+  cq_expect_finished_with_status(v_server, tag(102), chk_status, NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+void grpc_end2end_tests(grpc_end2end_test_config config) {
+  int i;
+  canceller cancellers[2] = {grpc_call_cancel, wait_for_deadline};
+
+  for (i = 0; i < GPR_ARRAY_SIZE(cancellers); i++) {
+    test_cancel_after_accept_and_writes_closed(config, cancellers[i]);
+  }
+}
diff --git a/test/core/end2end/tests/cancel_after_invoke.c b/test/core/end2end/tests/cancel_after_invoke.c
new file mode 100644
index 0000000..5920813
--- /dev/null
+++ b/test/core/end2end/tests/cancel_after_invoke.c
@@ -0,0 +1,150 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <grpc/byte_buffer.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include <grpc/support/useful.h>
+#include "test/core/end2end/cq_verifier.h"
+
+/* allow cancellation by either grpc_call_cancel, or by wait_for_deadline (which
+ * does nothing) */
+typedef grpc_call_error (*canceller)(grpc_call *call);
+
+static grpc_call_error wait_for_deadline(grpc_call *call) {
+  return GRPC_CALL_OK;
+}
+
+enum { TIMEOUT = 200000 };
+
+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) {
+  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);
+  return f;
+}
+
+static gpr_timespec n_seconds_time(int n) {
+  return gpr_time_add(gpr_now(), gpr_time_from_micros(GPR_US_PER_SEC * n));
+}
+
+static gpr_timespec five_seconds_time() { return n_seconds_time(5); }
+
+static void drain_cq(grpc_completion_queue *cq) {
+  grpc_event *ev;
+  grpc_completion_type type;
+  do {
+    ev = grpc_completion_queue_next(cq, five_seconds_time());
+    GPR_ASSERT(ev);
+    type = ev->type;
+    grpc_event_finish(ev);
+  } while (type != GRPC_QUEUE_SHUTDOWN);
+}
+
+static void shutdown_server(grpc_end2end_test_fixture *f) {
+  if (!f->server) return;
+  grpc_server_shutdown(f->server);
+  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);
+  f->client = NULL;
+}
+
+static void end_test(grpc_end2end_test_fixture *f) {
+  shutdown_server(f);
+  shutdown_client(f);
+
+  grpc_completion_queue_shutdown(f->server_cq);
+  drain_cq(f->server_cq);
+  grpc_completion_queue_destroy(f->server_cq);
+  grpc_completion_queue_shutdown(f->client_cq);
+  drain_cq(f->client_cq);
+  grpc_completion_queue_destroy(f->client_cq);
+}
+
+/* Cancel after invoke, no payload */
+static void test_cancel_after_invoke(grpc_end2end_test_config config,
+                                     canceller call_cancel) {
+  grpc_call *c;
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  gpr_timespec deadline = five_seconds_time();
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  grpc_status chk_status = {GRPC_STATUS_CANCELLED, NULL};
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == call_cancel(c));
+
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_expect_finished_with_status(v_client, tag(3), chk_status, NULL);
+  cq_verify(v_client);
+
+  grpc_call_destroy(c);
+
+  cq_verifier_destroy(v_client);
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+void grpc_end2end_tests(grpc_end2end_test_config config) {
+  int i;
+  canceller cancellers[2] = {grpc_call_cancel, wait_for_deadline};
+
+  for (i = 0; i < GPR_ARRAY_SIZE(cancellers); i++) {
+    test_cancel_after_invoke(config, cancellers[i]);
+  }
+}
diff --git a/test/core/end2end/tests/cancel_before_invoke.c b/test/core/end2end/tests/cancel_before_invoke.c
new file mode 100644
index 0000000..afffc2f
--- /dev/null
+++ b/test/core/end2end/tests/cancel_before_invoke.c
@@ -0,0 +1,138 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <grpc/byte_buffer.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include <grpc/support/useful.h>
+#include "test/core/end2end/cq_verifier.h"
+
+/* allow cancellation by either grpc_call_cancel, or by wait_for_deadline (which
+ * does nothing) */
+typedef grpc_call_error (*canceller)(grpc_call *call);
+
+enum { TIMEOUT = 200000 };
+
+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) {
+  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);
+  return f;
+}
+
+static gpr_timespec n_seconds_time(int n) {
+  return gpr_time_add(gpr_now(), gpr_time_from_micros(GPR_US_PER_SEC * n));
+}
+
+static gpr_timespec five_seconds_time() { return n_seconds_time(5); }
+
+static void drain_cq(grpc_completion_queue *cq) {
+  grpc_event *ev;
+  grpc_completion_type type;
+  do {
+    ev = grpc_completion_queue_next(cq, five_seconds_time());
+    GPR_ASSERT(ev);
+    type = ev->type;
+    grpc_event_finish(ev);
+  } while (type != GRPC_QUEUE_SHUTDOWN);
+}
+
+static void shutdown_server(grpc_end2end_test_fixture *f) {
+  if (!f->server) return;
+  grpc_server_shutdown(f->server);
+  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);
+  f->client = NULL;
+}
+
+static void end_test(grpc_end2end_test_fixture *f) {
+  shutdown_server(f);
+  shutdown_client(f);
+
+  grpc_completion_queue_shutdown(f->server_cq);
+  drain_cq(f->server_cq);
+  grpc_completion_queue_destroy(f->server_cq);
+  grpc_completion_queue_shutdown(f->client_cq);
+  drain_cq(f->client_cq);
+  grpc_completion_queue_destroy(f->client_cq);
+}
+
+/* Cancel before invoke */
+static void test_cancel_before_invoke(grpc_end2end_test_config config) {
+  grpc_call *c;
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  gpr_timespec deadline = five_seconds_time();
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  grpc_status chk_status = {GRPC_STATUS_CANCELLED, NULL};
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_cancel(c));
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_ERROR);
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_expect_finished_with_status(v_client, tag(3), chk_status, NULL);
+  cq_verify(v_client);
+
+  grpc_call_destroy(c);
+
+  cq_verifier_destroy(v_client);
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+void grpc_end2end_tests(grpc_end2end_test_config config) {
+  test_cancel_before_invoke(config);
+}
diff --git a/test/core/end2end/tests/cancel_in_a_vacuum.c b/test/core/end2end/tests/cancel_in_a_vacuum.c
new file mode 100644
index 0000000..1a4dfa7
--- /dev/null
+++ b/test/core/end2end/tests/cancel_in_a_vacuum.c
@@ -0,0 +1,138 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <grpc/byte_buffer.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include <grpc/support/useful.h>
+#include "test/core/end2end/cq_verifier.h"
+
+/* allow cancellation by either grpc_call_cancel, or by wait_for_deadline (which
+ * does nothing) */
+typedef grpc_call_error (*canceller)(grpc_call *call);
+
+static grpc_call_error wait_for_deadline(grpc_call *call) {
+  return GRPC_CALL_OK;
+}
+
+enum { TIMEOUT = 200000 };
+
+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);
+  return f;
+}
+
+static gpr_timespec n_seconds_time(int n) {
+  return gpr_time_add(gpr_now(), gpr_time_from_micros(GPR_US_PER_SEC * n));
+}
+
+static gpr_timespec five_seconds_time() { return n_seconds_time(5); }
+
+static void drain_cq(grpc_completion_queue *cq) {
+  grpc_event *ev;
+  grpc_completion_type type;
+  do {
+    ev = grpc_completion_queue_next(cq, five_seconds_time());
+    GPR_ASSERT(ev);
+    type = ev->type;
+    grpc_event_finish(ev);
+  } while (type != GRPC_QUEUE_SHUTDOWN);
+}
+
+static void shutdown_server(grpc_end2end_test_fixture *f) {
+  if (!f->server) return;
+  grpc_server_shutdown(f->server);
+  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);
+  f->client = NULL;
+}
+
+static void end_test(grpc_end2end_test_fixture *f) {
+  shutdown_server(f);
+  shutdown_client(f);
+
+  grpc_completion_queue_shutdown(f->server_cq);
+  drain_cq(f->server_cq);
+  grpc_completion_queue_destroy(f->server_cq);
+  grpc_completion_queue_shutdown(f->client_cq);
+  drain_cq(f->client_cq);
+  grpc_completion_queue_destroy(f->client_cq);
+}
+
+/* Cancel and do nothing */
+static void test_cancel_in_a_vacuum(grpc_end2end_test_config config,
+                                    canceller call_cancel) {
+  grpc_call *c;
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  gpr_timespec deadline = five_seconds_time();
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK == call_cancel(c));
+
+  grpc_call_destroy(c);
+
+  cq_verifier_destroy(v_client);
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+void grpc_end2end_tests(grpc_end2end_test_config config) {
+  int i;
+  canceller cancellers[2] = {grpc_call_cancel, wait_for_deadline};
+
+  for (i = 0; i < GPR_ARRAY_SIZE(cancellers); i++) {
+    test_cancel_in_a_vacuum(config, cancellers[i]);
+  }
+}
diff --git a/test/core/end2end/tests/early_server_shutdown_finishes_inflight_calls.c b/test/core/end2end/tests/early_server_shutdown_finishes_inflight_calls.c
new file mode 100644
index 0000000..8d73e2c
--- /dev/null
+++ b/test/core/end2end/tests/early_server_shutdown_finishes_inflight_calls.c
@@ -0,0 +1,158 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <grpc/byte_buffer.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include <grpc/support/useful.h>
+#include "test/core/end2end/cq_verifier.h"
+
+enum { TIMEOUT = 200000 };
+
+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) {
+  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);
+  return f;
+}
+
+static gpr_timespec n_seconds_time(int n) {
+  return gpr_time_add(gpr_now(), gpr_time_from_micros(GPR_US_PER_SEC * n));
+}
+
+static gpr_timespec five_seconds_time() { return n_seconds_time(5); }
+
+static void drain_cq(grpc_completion_queue *cq) {
+  grpc_event *ev;
+  grpc_completion_type type;
+  do {
+    ev = grpc_completion_queue_next(cq, five_seconds_time());
+    GPR_ASSERT(ev);
+    type = ev->type;
+    grpc_event_finish(ev);
+  } while (type != GRPC_QUEUE_SHUTDOWN);
+}
+
+static void shutdown_server(grpc_end2end_test_fixture *f) {
+  if (!f->server) return;
+  grpc_server_shutdown(f->server);
+  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);
+  f->client = NULL;
+}
+
+static void end_test(grpc_end2end_test_fixture *f) {
+  shutdown_server(f);
+  shutdown_client(f);
+
+  grpc_completion_queue_shutdown(f->server_cq);
+  drain_cq(f->server_cq);
+  grpc_completion_queue_destroy(f->server_cq);
+  grpc_completion_queue_shutdown(f->client_cq);
+  drain_cq(f->client_cq);
+  grpc_completion_queue_destroy(f->client_cq);
+}
+
+static void test_early_server_shutdown_finishes_inflight_calls(
+    grpc_end2end_test_config config) {
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  grpc_call *c;
+  grpc_call *s;
+  grpc_status expect_status = {GRPC_STATUS_UNAVAILABLE, NULL};
+  gpr_timespec deadline = five_seconds_time();
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c, tag(4)));
+  cq_expect_finish_accepted(v_client, tag(4), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_accept(s, f.server_cq, tag(102), 0));
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_verify(v_client);
+
+  /* shutdown and destroy the server */
+  shutdown_server(&f);
+
+  cq_expect_finished(v_server, tag(102), NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(s);
+
+  cq_expect_finished_with_status(v_client, tag(3), expect_status, NULL);
+  cq_verify(v_client);
+
+  grpc_call_destroy(c);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+void grpc_end2end_tests(grpc_end2end_test_config config) {
+  test_early_server_shutdown_finishes_inflight_calls(config);
+}
diff --git a/test/core/end2end/tests/early_server_shutdown_finishes_tags.c b/test/core/end2end/tests/early_server_shutdown_finishes_tags.c
new file mode 100644
index 0000000..eb3eb7c
--- /dev/null
+++ b/test/core/end2end/tests/early_server_shutdown_finishes_tags.c
@@ -0,0 +1,127 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <grpc/byte_buffer.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include <grpc/support/useful.h>
+#include "test/core/end2end/cq_verifier.h"
+
+enum { TIMEOUT = 200000 };
+
+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) {
+  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);
+  return f;
+}
+
+static gpr_timespec n_seconds_time(int n) {
+  return gpr_time_add(gpr_now(), gpr_time_from_micros(GPR_US_PER_SEC * n));
+}
+
+static gpr_timespec five_seconds_time() { return n_seconds_time(5); }
+
+static void drain_cq(grpc_completion_queue *cq) {
+  grpc_event *ev;
+  grpc_completion_type type;
+  do {
+    ev = grpc_completion_queue_next(cq, five_seconds_time());
+    GPR_ASSERT(ev);
+    type = ev->type;
+    grpc_event_finish(ev);
+  } while (type != GRPC_QUEUE_SHUTDOWN);
+}
+
+static void shutdown_server(grpc_end2end_test_fixture *f) {
+  if (!f->server) return;
+  grpc_server_shutdown(f->server);
+  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);
+  f->client = NULL;
+}
+
+static void end_test(grpc_end2end_test_fixture *f) {
+  shutdown_server(f);
+  shutdown_client(f);
+
+  grpc_completion_queue_shutdown(f->server_cq);
+  drain_cq(f->server_cq);
+  grpc_completion_queue_destroy(f->server_cq);
+  grpc_completion_queue_shutdown(f->client_cq);
+  drain_cq(f->client_cq);
+  grpc_completion_queue_destroy(f->client_cq);
+}
+
+static void test_early_server_shutdown_finishes_tags(
+    grpc_end2end_test_config config) {
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+  grpc_call *s = (void *)1;
+
+  /* upon shutdown, the server should finish all requested calls indicating
+     no new call */
+  grpc_server_request_call(f.server, tag(1000));
+  grpc_server_shutdown(f.server);
+  cq_expect_server_rpc_new(v_server, &s, tag(1000), NULL, NULL, gpr_inf_past,
+                           NULL);
+  cq_verify(v_server);
+  GPR_ASSERT(s == NULL);
+
+  end_test(&f);
+  config.tear_down_data(&f);
+  cq_verifier_destroy(v_server);
+}
+
+void grpc_end2end_tests(grpc_end2end_test_config config) {
+  test_early_server_shutdown_finishes_tags(config);
+}
diff --git a/test/core/end2end/tests/invoke_large_request.c b/test/core/end2end/tests/invoke_large_request.c
new file mode 100644
index 0000000..7a3cab3
--- /dev/null
+++ b/test/core/end2end/tests/invoke_large_request.c
@@ -0,0 +1,184 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <grpc/byte_buffer.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include <grpc/support/useful.h>
+#include "test/core/end2end/cq_verifier.h"
+
+enum { TIMEOUT = 200000 };
+
+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) {
+  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);
+  return f;
+}
+
+static gpr_timespec n_seconds_time(int n) {
+  return gpr_time_add(gpr_now(), gpr_time_from_micros(GPR_US_PER_SEC * n));
+}
+
+static gpr_timespec five_seconds_time() { return n_seconds_time(5); }
+
+static void drain_cq(grpc_completion_queue *cq) {
+  grpc_event *ev;
+  grpc_completion_type type;
+  do {
+    ev = grpc_completion_queue_next(cq, five_seconds_time());
+    GPR_ASSERT(ev);
+    type = ev->type;
+    grpc_event_finish(ev);
+  } while (type != GRPC_QUEUE_SHUTDOWN);
+}
+
+static void shutdown_server(grpc_end2end_test_fixture *f) {
+  if (!f->server) return;
+  grpc_server_shutdown(f->server);
+  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);
+  f->client = NULL;
+}
+
+static void end_test(grpc_end2end_test_fixture *f) {
+  shutdown_server(f);
+  shutdown_client(f);
+
+  grpc_completion_queue_shutdown(f->server_cq);
+  drain_cq(f->server_cq);
+  grpc_completion_queue_destroy(f->server_cq);
+  grpc_completion_queue_shutdown(f->client_cq);
+  drain_cq(f->client_cq);
+  grpc_completion_queue_destroy(f->client_cq);
+}
+
+static gpr_slice large_slice() {
+  gpr_slice slice = gpr_slice_malloc(1000000);
+  memset(GPR_SLICE_START_PTR(slice), 0xab, GPR_SLICE_LENGTH(slice));
+  return slice;
+}
+
+static void test_invoke_large_request(grpc_end2end_test_config config) {
+  grpc_call *c;
+  grpc_call *s;
+  grpc_status send_status = {GRPC_STATUS_UNIMPLEMENTED, "xyz"};
+  gpr_slice request_payload_slice = large_slice();
+  grpc_byte_buffer *request_payload =
+      grpc_byte_buffer_create(&request_payload_slice, 1);
+  gpr_timespec deadline = five_seconds_time();
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+
+  /* byte buffer holds the slice, we can unref it already */
+  gpr_slice_unref(request_payload_slice);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write(c, request_payload, tag(4), 0));
+  /* destroy byte buffer early to ensure async code keeps track of its contents
+     correctly */
+  grpc_byte_buffer_destroy(request_payload);
+  /* write should not be accepted until the server is willing to read the
+     request (as this request is very large) */
+  cq_verify_empty(v_client);
+
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+
+  grpc_call_accept(s, f.server_cq, tag(102), 0);
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read(s, tag(5)));
+  /* now the write can be accepted */
+  cq_expect_write_accepted(v_client, tag(4), GRPC_OP_OK);
+  cq_verify(v_client);
+  cq_expect_read(v_server, tag(5), large_slice());
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c, tag(8)));
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write_status(s, send_status, tag(9)));
+
+  cq_expect_finish_accepted(v_client, tag(8), GRPC_OP_OK);
+  cq_expect_finished_with_status(v_client, tag(3), send_status, NULL);
+  cq_verify(v_client);
+
+  cq_expect_finish_accepted(v_server, tag(9), GRPC_OP_OK);
+  cq_expect_finished(v_server, tag(102), NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+void grpc_end2end_tests(grpc_end2end_test_config config) {
+  test_invoke_large_request(config);
+}
diff --git a/test/core/end2end/tests/max_concurrent_streams.c b/test/core/end2end/tests/max_concurrent_streams.c
new file mode 100644
index 0000000..6b331a5
--- /dev/null
+++ b/test/core/end2end/tests/max_concurrent_streams.c
@@ -0,0 +1,257 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <grpc/byte_buffer.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include <grpc/support/useful.h>
+#include "test/core/end2end/cq_verifier.h"
+
+enum { TIMEOUT = 200000 };
+
+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) {
+  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);
+  return f;
+}
+
+static gpr_timespec n_seconds_time(int n) {
+  return gpr_time_add(gpr_now(), gpr_time_from_micros(GPR_US_PER_SEC * n));
+}
+
+static gpr_timespec five_seconds_time() { return n_seconds_time(5); }
+
+static void drain_cq(grpc_completion_queue *cq) {
+  grpc_event *ev;
+  grpc_completion_type type;
+  do {
+    ev = grpc_completion_queue_next(cq, five_seconds_time());
+    GPR_ASSERT(ev);
+    type = ev->type;
+    grpc_event_finish(ev);
+  } while (type != GRPC_QUEUE_SHUTDOWN);
+}
+
+static void shutdown_server(grpc_end2end_test_fixture *f) {
+  if (!f->server) return;
+  grpc_server_shutdown(f->server);
+  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);
+  f->client = NULL;
+}
+
+static void end_test(grpc_end2end_test_fixture *f) {
+  shutdown_server(f);
+  shutdown_client(f);
+
+  grpc_completion_queue_shutdown(f->server_cq);
+  drain_cq(f->server_cq);
+  grpc_completion_queue_destroy(f->server_cq);
+  grpc_completion_queue_shutdown(f->client_cq);
+  drain_cq(f->client_cq);
+  grpc_completion_queue_destroy(f->client_cq);
+}
+
+static void simple_request_body(grpc_end2end_test_fixture f) {
+  grpc_call *c;
+  grpc_call *s;
+  grpc_status send_status = {GRPC_STATUS_UNIMPLEMENTED, "xyz"};
+  gpr_timespec deadline = five_seconds_time();
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c, tag(4)));
+  cq_expect_finish_accepted(v_client, tag(4), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_accept(s, f.server_cq, tag(102), 0));
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write_status(s, send_status, tag(5)));
+  cq_expect_finished_with_status(v_client, tag(3), send_status, NULL);
+  cq_verify(v_client);
+
+  cq_expect_finish_accepted(v_server, tag(5), GRPC_OP_OK);
+  cq_verify(v_server);
+  cq_expect_finished(v_server, tag(102), NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+}
+
+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;
+  grpc_call *c1;
+  grpc_call *c2;
+  grpc_call *s1;
+  grpc_call *s2;
+  gpr_timespec deadline;
+  grpc_status send_status = {GRPC_STATUS_UNIMPLEMENTED, "xyz"};
+  cq_verifier *v_client;
+  cq_verifier *v_server;
+
+  server_arg.key = GRPC_ARG_MAX_CONCURRENT_STREAMS;
+  server_arg.type = GRPC_ARG_INTEGER;
+  server_arg.value.integer = 1;
+
+  server_args.num_args = 1;
+  server_args.args = &server_arg;
+
+  f = begin_test(config, __FUNCTION__, NULL, &server_args);
+  v_client = cq_verifier_create(f.client_cq);
+  v_server = cq_verifier_create(f.server_cq);
+
+  /* perform a ping-pong to ensure that settings have had a chance to round
+     trip */
+  simple_request_body(f);
+  /* perform another one to make sure that the one stream case still works */
+  simple_request_body(f);
+
+  /* start two requests - ensuring that the second is not accepted until
+     the first completes */
+  deadline = five_seconds_time();
+  c1 = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c1);
+  c2 = grpc_channel_create_call(f.client, "/bar", "test.google.com", deadline);
+  GPR_ASSERT(c1);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_invoke(c1, f.client_cq, tag(300),
+                                                    tag(301), tag(302), 0));
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_invoke(c2, f.client_cq, tag(400),
+                                                    tag(401), tag(402), 0));
+  cq_expect_invoke_accepted(v_client, tag(300), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c1, tag(303)));
+  cq_expect_finish_accepted(v_client, tag(303), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  cq_expect_server_rpc_new(v_server, &s1, tag(100), "/foo", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_accept(s1, f.server_cq, tag(102), 0));
+  cq_expect_client_metadata_read(v_client, tag(301), NULL);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write_status(s1, send_status, tag(103)));
+  cq_expect_finish_accepted(v_server, tag(103), GRPC_OP_OK);
+  cq_expect_finished(v_server, tag(102), NULL);
+  cq_verify(v_server);
+
+  /* first request is finished, we should be able to start the second */
+  cq_expect_finished_with_status(v_client, tag(302), send_status, NULL);
+  cq_expect_invoke_accepted(v_client, tag(400), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c2, tag(403)));
+  cq_expect_finish_accepted(v_client, tag(403), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(200)));
+  cq_expect_server_rpc_new(v_server, &s2, tag(200), "/bar", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_accept(s2, f.server_cq, tag(202), 0));
+  cq_expect_client_metadata_read(v_client, tag(401), NULL);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write_status(s2, send_status, tag(203)));
+  cq_expect_finish_accepted(v_server, tag(203), GRPC_OP_OK);
+  cq_expect_finished(v_server, tag(202), NULL);
+  cq_verify(v_server);
+
+  cq_expect_finished_with_status(v_client, tag(402), send_status, NULL);
+  cq_verify(v_client);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+
+  grpc_call_destroy(c1);
+  grpc_call_destroy(s1);
+  grpc_call_destroy(c2);
+  grpc_call_destroy(s2);
+
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+void grpc_end2end_tests(grpc_end2end_test_config config) {
+  test_max_concurrent_streams(config);
+}
diff --git a/test/core/end2end/tests/no_op.c b/test/core/end2end/tests/no_op.c
new file mode 100644
index 0000000..ca03103
--- /dev/null
+++ b/test/core/end2end/tests/no_op.c
@@ -0,0 +1,112 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <grpc/byte_buffer.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include <grpc/support/useful.h>
+#include "test/core/end2end/cq_verifier.h"
+
+enum { TIMEOUT = 200000 };
+
+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);
+  return f;
+}
+
+static gpr_timespec n_seconds_time(int n) {
+  return gpr_time_add(gpr_now(), gpr_time_from_micros(GPR_US_PER_SEC * n));
+}
+
+static gpr_timespec five_seconds_time() { return n_seconds_time(5); }
+
+static void drain_cq(grpc_completion_queue *cq) {
+  grpc_event *ev;
+  grpc_completion_type type;
+  do {
+    ev = grpc_completion_queue_next(cq, five_seconds_time());
+    GPR_ASSERT(ev);
+    type = ev->type;
+    grpc_event_finish(ev);
+  } while (type != GRPC_QUEUE_SHUTDOWN);
+}
+
+static void shutdown_server(grpc_end2end_test_fixture *f) {
+  if (!f->server) return;
+  grpc_server_shutdown(f->server);
+  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);
+  f->client = NULL;
+}
+
+static void end_test(grpc_end2end_test_fixture *f) {
+  shutdown_server(f);
+  shutdown_client(f);
+
+  grpc_completion_queue_shutdown(f->server_cq);
+  drain_cq(f->server_cq);
+  grpc_completion_queue_destroy(f->server_cq);
+  grpc_completion_queue_shutdown(f->client_cq);
+  drain_cq(f->client_cq);
+  grpc_completion_queue_destroy(f->client_cq);
+}
+
+static void test_no_op(grpc_end2end_test_config config) {
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+
+void grpc_end2end_tests(grpc_end2end_test_config config) {
+  test_no_op(config);
+}
diff --git a/test/core/end2end/tests/ping_pong_streaming.c b/test/core/end2end/tests/ping_pong_streaming.c
new file mode 100644
index 0000000..84e7bb4
--- /dev/null
+++ b/test/core/end2end/tests/ping_pong_streaming.c
@@ -0,0 +1,201 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <grpc/byte_buffer.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include <grpc/support/useful.h>
+#include "test/core/end2end/cq_verifier.h"
+
+enum { TIMEOUT = 200000 };
+
+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) {
+  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);
+  return f;
+}
+
+static gpr_timespec n_seconds_time(int n) {
+  return gpr_time_add(gpr_now(), gpr_time_from_micros(GPR_US_PER_SEC * n));
+}
+
+static gpr_timespec five_seconds_time() { return n_seconds_time(5); }
+
+static void drain_cq(grpc_completion_queue *cq) {
+  grpc_event *ev;
+  grpc_completion_type type;
+  do {
+    ev = grpc_completion_queue_next(cq, five_seconds_time());
+    GPR_ASSERT(ev);
+    type = ev->type;
+    grpc_event_finish(ev);
+  } while (type != GRPC_QUEUE_SHUTDOWN);
+}
+
+static void shutdown_server(grpc_end2end_test_fixture *f) {
+  if (!f->server) return;
+  grpc_server_shutdown(f->server);
+  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);
+  f->client = NULL;
+}
+
+static void end_test(grpc_end2end_test_fixture *f) {
+  shutdown_server(f);
+  shutdown_client(f);
+
+  grpc_completion_queue_shutdown(f->server_cq);
+  drain_cq(f->server_cq);
+  grpc_completion_queue_destroy(f->server_cq);
+  grpc_completion_queue_shutdown(f->client_cq);
+  drain_cq(f->client_cq);
+  grpc_completion_queue_destroy(f->client_cq);
+}
+
+/* Client pings and server pongs. Repeat messages rounds before finishing. */
+static void test_pingpong_streaming(grpc_end2end_test_config config,
+                                    int messages) {
+  int i;
+  grpc_call *c;
+  grpc_call *s = NULL;
+  grpc_status send_status = {GRPC_STATUS_UNIMPLEMENTED, "xyz"};
+  gpr_slice request_payload_slice = gpr_slice_from_copied_string("hello world");
+  gpr_slice response_payload_slice = gpr_slice_from_copied_string("hello you");
+  grpc_byte_buffer *request_payload = NULL;
+  grpc_byte_buffer *response_payload = NULL;
+  gpr_timespec deadline = n_seconds_time(messages * 5);
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+
+  gpr_log(GPR_INFO, "testing with %d message pairs.", messages);
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+  grpc_call_accept(s, f.server_cq, tag(102), 0);
+
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_verify(v_client);
+
+  for (i = 0; i < messages; i++) {
+    request_payload = grpc_byte_buffer_create(&request_payload_slice, 1);
+    GPR_ASSERT(GRPC_CALL_OK ==
+               grpc_call_start_write(c, request_payload, tag(2), 0));
+    /* destroy byte buffer early to ensure async code keeps track of its
+       contents
+       correctly */
+    grpc_byte_buffer_destroy(request_payload);
+    cq_expect_write_accepted(v_client, tag(2), GRPC_OP_OK);
+    cq_verify(v_client);
+
+    GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read(s, tag(3)));
+    cq_expect_read(v_server, tag(3),
+                   gpr_slice_from_copied_string("hello world"));
+    cq_verify(v_server);
+
+    response_payload = grpc_byte_buffer_create(&response_payload_slice, 1);
+    GPR_ASSERT(GRPC_CALL_OK ==
+               grpc_call_start_write(s, response_payload, tag(4), 0));
+    /* destroy byte buffer early to ensure async code keeps track of its
+       contents
+       correctly */
+    grpc_byte_buffer_destroy(response_payload);
+    cq_expect_write_accepted(v_server, tag(4), GRPC_OP_OK);
+    cq_verify(v_server);
+
+    GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read(c, tag(5)));
+    cq_expect_read(v_client, tag(5), gpr_slice_from_copied_string("hello you"));
+    cq_verify(v_client);
+  }
+
+  gpr_slice_unref(request_payload_slice);
+  gpr_slice_unref(response_payload_slice);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c, tag(6)));
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write_status(s, send_status, tag(7)));
+
+  cq_expect_finish_accepted(v_client, tag(6), GRPC_OP_OK);
+  cq_expect_finished_with_status(v_client, tag(3), send_status, NULL);
+  cq_verify(v_client);
+
+  cq_expect_finish_accepted(v_server, tag(7), GRPC_OP_OK);
+  cq_expect_finished(v_server, tag(102), NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
+
+  end_test(&f);
+  config.tear_down_data(&f);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+}
+
+void grpc_end2end_tests(grpc_end2end_test_config config) {
+  int i;
+
+  for (i = 1; i < 10; i++) {
+    test_pingpong_streaming(config, i);
+  }
+}
diff --git a/test/core/end2end/tests/request_response_with_metadata_and_payload.c b/test/core/end2end/tests/request_response_with_metadata_and_payload.c
new file mode 100644
index 0000000..4cb5679
--- /dev/null
+++ b/test/core/end2end/tests/request_response_with_metadata_and_payload.c
@@ -0,0 +1,208 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <grpc/byte_buffer.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include <grpc/support/useful.h>
+#include "test/core/end2end/cq_verifier.h"
+
+enum { TIMEOUT = 200000 };
+
+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) {
+  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);
+  return f;
+}
+
+static gpr_timespec n_seconds_time(int n) {
+  return gpr_time_add(gpr_now(), gpr_time_from_micros(GPR_US_PER_SEC * n));
+}
+
+static gpr_timespec five_seconds_time() { return n_seconds_time(5); }
+
+static void drain_cq(grpc_completion_queue *cq) {
+  grpc_event *ev;
+  grpc_completion_type type;
+  do {
+    ev = grpc_completion_queue_next(cq, five_seconds_time());
+    GPR_ASSERT(ev);
+    type = ev->type;
+    grpc_event_finish(ev);
+  } while (type != GRPC_QUEUE_SHUTDOWN);
+}
+
+static void shutdown_server(grpc_end2end_test_fixture *f) {
+  if (!f->server) return;
+  grpc_server_shutdown(f->server);
+  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);
+  f->client = NULL;
+}
+
+static void end_test(grpc_end2end_test_fixture *f) {
+  shutdown_server(f);
+  shutdown_client(f);
+
+  grpc_completion_queue_shutdown(f->server_cq);
+  drain_cq(f->server_cq);
+  grpc_completion_queue_destroy(f->server_cq);
+  grpc_completion_queue_shutdown(f->client_cq);
+  drain_cq(f->client_cq);
+  grpc_completion_queue_destroy(f->client_cq);
+}
+
+/* Request/response with metadata and payload.*/
+static void test_request_response_with_metadata_and_payload(
+    grpc_end2end_test_config config) {
+  grpc_call *c;
+  grpc_call *s;
+  grpc_status send_status = {GRPC_STATUS_UNIMPLEMENTED, "xyz"};
+  gpr_slice request_payload_slice = gpr_slice_from_copied_string("hello world");
+  gpr_slice response_payload_slice = gpr_slice_from_copied_string("hello you");
+  grpc_byte_buffer *request_payload =
+      grpc_byte_buffer_create(&request_payload_slice, 1);
+  grpc_byte_buffer *response_payload =
+      grpc_byte_buffer_create(&response_payload_slice, 1);
+  gpr_timespec deadline = five_seconds_time();
+  grpc_metadata meta1 = {"key1", "val1", 4};
+  grpc_metadata meta2 = {"key2", "val2", 4};
+  grpc_metadata meta3 = {"key3", "val3", 4};
+  grpc_metadata meta4 = {"key4", "val4", 4};
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+
+  /* byte buffer holds the slice, we can unref it already */
+  gpr_slice_unref(request_payload_slice);
+  gpr_slice_unref(response_payload_slice);
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  /* add multiple metadata */
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata(c, &meta1, 0));
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata(c, &meta2, 0));
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write(c, request_payload, tag(4), 0));
+  /* destroy byte buffer early to ensure async code keeps track of its contents
+     correctly */
+  grpc_byte_buffer_destroy(request_payload);
+  cq_expect_write_accepted(v_client, tag(4), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, "key1", "val1", "key2", "val2", NULL);
+  cq_verify(v_server);
+
+  /* add multiple metadata */
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata(s, &meta3, 0));
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata(s, &meta4, 0));
+
+  grpc_call_accept(s, f.server_cq, tag(102), 0);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read(s, tag(5)));
+  cq_expect_read(v_server, tag(5), gpr_slice_from_copied_string("hello world"));
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write(s, response_payload, tag(6), 0));
+  /* destroy byte buffer early to ensure async code keeps track of its contents
+     correctly */
+  grpc_byte_buffer_destroy(response_payload);
+  cq_expect_write_accepted(v_server, tag(6), GRPC_OP_OK);
+  cq_verify(v_server);
+
+  /* fetch metadata.. */
+  cq_expect_client_metadata_read(v_client, tag(2), "key3", "val3", "key4",
+                                 "val4", NULL);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read(c, tag(7)));
+  cq_expect_read(v_client, tag(7), gpr_slice_from_copied_string("hello you"));
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c, tag(8)));
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write_status(s, send_status, tag(9)));
+
+  cq_expect_finish_accepted(v_client, tag(8), GRPC_OP_OK);
+  cq_expect_finished_with_status(v_client, tag(3), send_status, NULL);
+  cq_verify(v_client);
+
+  cq_expect_finish_accepted(v_server, tag(9), GRPC_OP_OK);
+  cq_expect_finished(v_server, tag(102), NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
+
+  end_test(&f);
+  config.tear_down_data(&f);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+}
+
+
+void grpc_end2end_tests(grpc_end2end_test_config config) {
+  test_request_response_with_metadata_and_payload(config);
+}
diff --git a/test/core/end2end/tests/request_response_with_payload.c b/test/core/end2end/tests/request_response_with_payload.c
new file mode 100644
index 0000000..fb9b59a
--- /dev/null
+++ b/test/core/end2end/tests/request_response_with_payload.c
@@ -0,0 +1,207 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <grpc/byte_buffer.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include <grpc/support/useful.h>
+#include "test/core/end2end/cq_verifier.h"
+
+enum { TIMEOUT = 200000 };
+
+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) {
+  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);
+  return f;
+}
+
+static gpr_timespec n_seconds_time(int n) {
+  return gpr_time_add(gpr_now(), gpr_time_from_micros(GPR_US_PER_SEC * n));
+}
+
+static gpr_timespec five_seconds_time() { return n_seconds_time(5); }
+
+static void drain_cq(grpc_completion_queue *cq) {
+  grpc_event *ev;
+  grpc_completion_type type;
+  do {
+    ev = grpc_completion_queue_next(cq, five_seconds_time());
+    GPR_ASSERT(ev);
+    type = ev->type;
+    grpc_event_finish(ev);
+  } while (type != GRPC_QUEUE_SHUTDOWN);
+}
+
+static void shutdown_server(grpc_end2end_test_fixture *f) {
+  if (!f->server) return;
+  grpc_server_shutdown(f->server);
+  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);
+  f->client = NULL;
+}
+
+static void end_test(grpc_end2end_test_fixture *f) {
+  shutdown_server(f);
+  shutdown_client(f);
+
+  grpc_completion_queue_shutdown(f->server_cq);
+  drain_cq(f->server_cq);
+  grpc_completion_queue_destroy(f->server_cq);
+  grpc_completion_queue_shutdown(f->client_cq);
+  drain_cq(f->client_cq);
+  grpc_completion_queue_destroy(f->client_cq);
+}
+
+static void request_response_with_payload(grpc_end2end_test_fixture f) {
+  grpc_call *c;
+  grpc_call *s;
+  grpc_status send_status = {GRPC_STATUS_UNIMPLEMENTED, "xyz"};
+  gpr_slice request_payload_slice = gpr_slice_from_copied_string("hello world");
+  gpr_slice response_payload_slice = gpr_slice_from_copied_string("hello you");
+  grpc_byte_buffer *request_payload =
+      grpc_byte_buffer_create(&request_payload_slice, 1);
+  grpc_byte_buffer *response_payload =
+      grpc_byte_buffer_create(&response_payload_slice, 1);
+  gpr_timespec deadline = five_seconds_time();
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+
+  /* byte buffer holds the slice, we can unref it already */
+  gpr_slice_unref(request_payload_slice);
+  gpr_slice_unref(response_payload_slice);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write(c, request_payload, tag(4), 0));
+  /* destroy byte buffer early to ensure async code keeps track of its contents
+     correctly */
+  grpc_byte_buffer_destroy(request_payload);
+  cq_expect_write_accepted(v_client, tag(4), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+
+  grpc_call_accept(s, f.server_cq, tag(102), 0);
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read(s, tag(5)));
+  cq_expect_read(v_server, tag(5), gpr_slice_from_copied_string("hello world"));
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write(s, response_payload, tag(6), 0));
+  /* destroy byte buffer early to ensure async code keeps track of its contents
+     correctly */
+  grpc_byte_buffer_destroy(response_payload);
+  cq_expect_write_accepted(v_server, tag(6), GRPC_OP_OK);
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read(c, tag(7)));
+  cq_expect_read(v_client, tag(7), gpr_slice_from_copied_string("hello you"));
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c, tag(8)));
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write_status(s, send_status, tag(9)));
+
+  cq_expect_finish_accepted(v_client, tag(8), GRPC_OP_OK);
+  cq_expect_finished_with_status(v_client, tag(3), send_status, NULL);
+  cq_verify(v_client);
+
+  cq_expect_finish_accepted(v_server, tag(9), GRPC_OP_OK);
+  cq_expect_finished(v_server, tag(102), NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+}
+
+/* Client sends a request with payload, server reads then returns a response
+   payload and status. */
+static void test_invoke_request_response_with_payload(
+    grpc_end2end_test_config config) {
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  request_response_with_payload(f);
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+static void test_invoke_10_request_response_with_payload(
+    grpc_end2end_test_config config) {
+  int i;
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  for (i = 0; i < 10; i++) {
+    request_response_with_payload(f);
+  }
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+void grpc_end2end_tests(grpc_end2end_test_config config) {
+  test_invoke_request_response_with_payload(config);
+  test_invoke_10_request_response_with_payload(config);
+}
diff --git a/test/core/end2end/tests/request_with_large_metadata.c b/test/core/end2end/tests/request_with_large_metadata.c
new file mode 100644
index 0000000..ccdee40
--- /dev/null
+++ b/test/core/end2end/tests/request_with_large_metadata.c
@@ -0,0 +1,172 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <grpc/byte_buffer.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include <grpc/support/useful.h>
+#include "test/core/end2end/cq_verifier.h"
+
+enum { TIMEOUT = 200000 };
+
+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) {
+  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);
+  return f;
+}
+
+static gpr_timespec n_seconds_time(int n) {
+  return gpr_time_add(gpr_now(), gpr_time_from_micros(GPR_US_PER_SEC * n));
+}
+
+static gpr_timespec five_seconds_time() { return n_seconds_time(5); }
+
+static void drain_cq(grpc_completion_queue *cq) {
+  grpc_event *ev;
+  grpc_completion_type type;
+  do {
+    ev = grpc_completion_queue_next(cq, five_seconds_time());
+    GPR_ASSERT(ev);
+    type = ev->type;
+    grpc_event_finish(ev);
+  } while (type != GRPC_QUEUE_SHUTDOWN);
+}
+
+static void shutdown_server(grpc_end2end_test_fixture *f) {
+  if (!f->server) return;
+  grpc_server_shutdown(f->server);
+  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);
+  f->client = NULL;
+}
+
+static void end_test(grpc_end2end_test_fixture *f) {
+  shutdown_server(f);
+  shutdown_client(f);
+
+  grpc_completion_queue_shutdown(f->server_cq);
+  drain_cq(f->server_cq);
+  grpc_completion_queue_destroy(f->server_cq);
+  grpc_completion_queue_shutdown(f->client_cq);
+  drain_cq(f->client_cq);
+  grpc_completion_queue_destroy(f->client_cq);
+}
+
+/* Request with a large amount of metadata.*/
+static void test_request_with_large_metadata(grpc_end2end_test_config config) {
+  grpc_call *c;
+  grpc_call *s;
+  grpc_status send_status = {GRPC_STATUS_OK, NULL};
+  gpr_timespec deadline = five_seconds_time();
+  grpc_metadata meta;
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+  const int large_size = 64 * 1024;
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+
+  meta.key = "key";
+  meta.value = gpr_malloc(large_size + 1);
+  memset(meta.value, 'a', large_size);
+  meta.value[large_size] = 0;
+  meta.value_length = large_size;
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  /* add the metadata */
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata(c, &meta, 0));
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, "key", meta.value, NULL);
+  cq_verify(v_server);
+
+  grpc_call_accept(s, f.server_cq, tag(102), 0);
+
+  /* fetch metadata.. */
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c, tag(8)));
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write_status(s, send_status, tag(9)));
+
+  cq_expect_finish_accepted(v_client, tag(8), GRPC_OP_OK);
+  cq_expect_finished_with_status(v_client, tag(3), send_status, NULL);
+  cq_verify(v_client);
+
+  cq_expect_finish_accepted(v_server, tag(9), GRPC_OP_OK);
+  cq_expect_finished(v_server, tag(102), NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
+
+  end_test(&f);
+  config.tear_down_data(&f);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+
+  gpr_free(meta.value);
+}
+
+void grpc_end2end_tests(grpc_end2end_test_config config) {
+  test_request_with_large_metadata(config);
+}
diff --git a/test/core/end2end/tests/request_with_payload.c b/test/core/end2end/tests/request_with_payload.c
new file mode 100644
index 0000000..38a29e3
--- /dev/null
+++ b/test/core/end2end/tests/request_with_payload.c
@@ -0,0 +1,171 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <grpc/byte_buffer.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include <grpc/support/useful.h>
+#include "test/core/end2end/cq_verifier.h"
+
+enum { TIMEOUT = 200000 };
+
+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) {
+  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);
+  return f;
+}
+
+static gpr_timespec n_seconds_time(int n) {
+  return gpr_time_add(gpr_now(), gpr_time_from_micros(GPR_US_PER_SEC * n));
+}
+
+static gpr_timespec five_seconds_time() { return n_seconds_time(5); }
+
+static void drain_cq(grpc_completion_queue *cq) {
+  grpc_event *ev;
+  grpc_completion_type type;
+  do {
+    ev = grpc_completion_queue_next(cq, five_seconds_time());
+    GPR_ASSERT(ev);
+    type = ev->type;
+    grpc_event_finish(ev);
+  } while (type != GRPC_QUEUE_SHUTDOWN);
+}
+
+static void shutdown_server(grpc_end2end_test_fixture *f) {
+  if (!f->server) return;
+  grpc_server_shutdown(f->server);
+  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);
+  f->client = NULL;
+}
+
+static void end_test(grpc_end2end_test_fixture *f) {
+  shutdown_server(f);
+  shutdown_client(f);
+
+  grpc_completion_queue_shutdown(f->server_cq);
+  drain_cq(f->server_cq);
+  grpc_completion_queue_destroy(f->server_cq);
+  grpc_completion_queue_shutdown(f->client_cq);
+  drain_cq(f->client_cq);
+  grpc_completion_queue_destroy(f->client_cq);
+}
+
+/* Client sends a request with payload, server reads then returns status. */
+static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
+  grpc_call *c;
+  grpc_call *s;
+  grpc_status send_status = {GRPC_STATUS_UNIMPLEMENTED, "xyz"};
+  gpr_slice payload_slice = gpr_slice_from_copied_string("hello world");
+  grpc_byte_buffer *payload = grpc_byte_buffer_create(&payload_slice, 1);
+  gpr_timespec deadline = five_seconds_time();
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+
+  /* byte buffer holds the slice, we can unref it already */
+  gpr_slice_unref(payload_slice);
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_write(c, payload, tag(4), 0));
+  /* destroy byte buffer early to ensure async code keeps track of its contents
+     correctly */
+  grpc_byte_buffer_destroy(payload);
+  cq_expect_write_accepted(v_client, tag(4), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+
+  grpc_call_accept(s, f.server_cq, tag(102), 0);
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read(s, tag(4)));
+  cq_expect_read(v_server, tag(4), gpr_slice_from_copied_string("hello world"));
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c, tag(5)));
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write_status(s, send_status, tag(6)));
+  cq_expect_finish_accepted(v_client, tag(5), GRPC_OP_OK);
+  cq_expect_finished_with_status(v_client, tag(3), send_status, NULL);
+  cq_verify(v_client);
+
+  cq_expect_finish_accepted(v_server, tag(6), GRPC_OP_OK);
+  cq_expect_finished(v_server, tag(102), NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
+
+  end_test(&f);
+  config.tear_down_data(&f);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+}
+
+void grpc_end2end_tests(grpc_end2end_test_config config) {
+  test_invoke_request_with_payload(config);
+}
diff --git a/test/core/end2end/tests/simple_delayed_request.c b/test/core/end2end/tests/simple_delayed_request.c
new file mode 100644
index 0000000..dde6eb6
--- /dev/null
+++ b/test/core/end2end/tests/simple_delayed_request.c
@@ -0,0 +1,174 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <grpc/byte_buffer.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include <grpc/support/useful.h>
+#include "test/core/end2end/cq_verifier.h"
+
+enum { TIMEOUT = 200000 };
+
+static void *tag(gpr_intptr t) { return (void *)t; }
+
+static gpr_timespec n_seconds_time(int n) {
+  return gpr_time_add(gpr_now(), gpr_time_from_micros(GPR_US_PER_SEC * n));
+}
+
+static gpr_timespec five_seconds_time() { return n_seconds_time(5); }
+
+static void drain_cq(grpc_completion_queue *cq) {
+  grpc_event *ev;
+  grpc_completion_type type;
+  do {
+    ev = grpc_completion_queue_next(cq, five_seconds_time());
+    GPR_ASSERT(ev);
+    type = ev->type;
+    grpc_event_finish(ev);
+  } while (type != GRPC_QUEUE_SHUTDOWN);
+}
+
+static void shutdown_server(grpc_end2end_test_fixture *f) {
+  if (!f->server) return;
+  grpc_server_shutdown(f->server);
+  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);
+  f->client = NULL;
+}
+
+static void end_test(grpc_end2end_test_fixture *f) {
+  shutdown_server(f);
+  shutdown_client(f);
+
+  grpc_completion_queue_shutdown(f->server_cq);
+  drain_cq(f->server_cq);
+  grpc_completion_queue_destroy(f->server_cq);
+  grpc_completion_queue_shutdown(f->client_cq);
+  drain_cq(f->client_cq);
+  grpc_completion_queue_destroy(f->client_cq);
+}
+
+static void simple_delayed_request_body(grpc_end2end_test_config config,
+                                        grpc_end2end_test_fixture *f,
+                                        grpc_channel_args *client_args,
+                                        grpc_channel_args *server_args,
+                                        long delay_us) {
+  grpc_call *c;
+  grpc_call *s;
+  grpc_status send_status = {GRPC_STATUS_UNIMPLEMENTED, "xyz"};
+  gpr_timespec deadline = five_seconds_time();
+  cq_verifier *v_client = cq_verifier_create(f->client_cq);
+  cq_verifier *v_server = cq_verifier_create(f->server_cq);
+
+  config.init_client(f, client_args);
+
+  c = grpc_channel_create_call(f->client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_invoke(c, f->client_cq, tag(1),
+                                                    tag(2), tag(3), 0));
+  gpr_sleep_until(gpr_time_add(gpr_now(), gpr_time_from_micros(delay_us)));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+
+  config.init_server(f, server_args);
+
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c, tag(4)));
+  cq_expect_finish_accepted(v_client, tag(4), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f->server, tag(100)));
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_accept(s, f->server_cq, tag(102), 0));
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write_status(s, send_status, tag(5)));
+  cq_expect_finished_with_status(v_client, tag(3), send_status, NULL);
+  cq_verify(v_client);
+
+  cq_expect_finish_accepted(v_server, tag(5), GRPC_OP_OK);
+  cq_expect_finished(v_server, tag(102), NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+}
+
+static void test_simple_delayed_request_short(grpc_end2end_test_config config) {
+  grpc_end2end_test_fixture f;
+
+  gpr_log(GPR_INFO, "%s/%s", __FUNCTION__, config.name);
+  f = config.create_fixture(NULL, NULL);
+  simple_delayed_request_body(config, &f, NULL, NULL, 100000);
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+static void test_simple_delayed_request_long(grpc_end2end_test_config config) {
+  grpc_end2end_test_fixture f;
+
+  gpr_log(GPR_INFO, "%s/%s", __FUNCTION__, config.name);
+  f = config.create_fixture(NULL, NULL);
+  /* This timeout should be longer than a single retry */
+  simple_delayed_request_body(config, &f, NULL, NULL, 1500000);
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+void grpc_end2end_tests(grpc_end2end_test_config config) {
+  if (config.feature_mask & FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION) {
+    test_simple_delayed_request_short(config);
+    test_simple_delayed_request_long(config);
+  }
+}
diff --git a/test/core/end2end/tests/simple_request.c b/test/core/end2end/tests/simple_request.c
new file mode 100644
index 0000000..15214ff
--- /dev/null
+++ b/test/core/end2end/tests/simple_request.c
@@ -0,0 +1,231 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <grpc/byte_buffer.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include <grpc/support/useful.h>
+#include "test/core/end2end/cq_verifier.h"
+
+enum { TIMEOUT = 200000 };
+
+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) {
+  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);
+  return f;
+}
+
+static gpr_timespec n_seconds_time(int n) {
+  return gpr_time_add(gpr_now(), gpr_time_from_micros(GPR_US_PER_SEC * n));
+}
+
+static gpr_timespec five_seconds_time() { return n_seconds_time(5); }
+
+static void drain_cq(grpc_completion_queue *cq) {
+  grpc_event *ev;
+  grpc_completion_type type;
+  do {
+    ev = grpc_completion_queue_next(cq, five_seconds_time());
+    GPR_ASSERT(ev);
+    type = ev->type;
+    grpc_event_finish(ev);
+  } while (type != GRPC_QUEUE_SHUTDOWN);
+}
+
+static void shutdown_server(grpc_end2end_test_fixture *f) {
+  if (!f->server) return;
+  grpc_server_shutdown(f->server);
+  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);
+  f->client = NULL;
+}
+
+static void end_test(grpc_end2end_test_fixture *f) {
+  shutdown_server(f);
+  shutdown_client(f);
+
+  grpc_completion_queue_shutdown(f->server_cq);
+  drain_cq(f->server_cq);
+  grpc_completion_queue_destroy(f->server_cq);
+  grpc_completion_queue_shutdown(f->client_cq);
+  drain_cq(f->client_cq);
+  grpc_completion_queue_destroy(f->client_cq);
+}
+
+static void simple_request_body(grpc_end2end_test_fixture f) {
+  grpc_call *c;
+  grpc_call *s;
+  grpc_status send_status = {GRPC_STATUS_UNIMPLEMENTED, "xyz"};
+  gpr_timespec deadline = five_seconds_time();
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c, tag(4)));
+  cq_expect_finish_accepted(v_client, tag(4), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_accept(s, f.server_cq, tag(102), 0));
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write_status(s, send_status, tag(5)));
+  cq_expect_finished_with_status(v_client, tag(3), send_status, NULL);
+  cq_verify(v_client);
+
+  cq_expect_finish_accepted(v_server, tag(5), GRPC_OP_OK);
+  cq_verify(v_server);
+  cq_expect_finished(v_server, tag(102), NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+}
+
+/* an alternative ordering of the simple request body */
+static void simple_request_body2(grpc_end2end_test_fixture f) {
+  grpc_call *c;
+  grpc_call *s;
+  grpc_status send_status = {GRPC_STATUS_UNIMPLEMENTED, "xyz"};
+  gpr_timespec deadline = five_seconds_time();
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c, tag(4)));
+  cq_expect_finish_accepted(v_client, tag(4), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_accept(s, f.server_cq, tag(102), 0));
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write_status(s, send_status, tag(5)));
+  cq_expect_finish_accepted(v_server, tag(5), GRPC_OP_OK);
+  cq_verify(v_server);
+
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_verify(v_client);
+
+  cq_expect_finished_with_status(v_client, tag(3), send_status, NULL);
+  cq_verify(v_client);
+
+  cq_expect_finished(v_server, tag(102), NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+}
+
+static void test_invoke_simple_request(
+    grpc_end2end_test_config config, const char *name,
+    void (*body)(grpc_end2end_test_fixture f)) {
+  char fullname[64];
+  grpc_end2end_test_fixture f;
+
+  sprintf(fullname, "%s/%s", __FUNCTION__, name);
+
+  f = begin_test(config, fullname, NULL, NULL);
+  body(f);
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+static void test_invoke_10_simple_requests(grpc_end2end_test_config config) {
+  int i;
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  for (i = 0; i < 10; i++) {
+    simple_request_body(f);
+    gpr_log(GPR_INFO, "Passed simple request %d", i);
+  }
+  end_test(&f);
+  config.tear_down_data(&f);
+}
+
+void grpc_end2end_tests(grpc_end2end_test_config config) {
+  test_invoke_simple_request(config, "simple_request_body",
+                             simple_request_body);
+  test_invoke_simple_request(config, "simple_request_body2",
+                             simple_request_body2);
+  test_invoke_10_simple_requests(config);
+}
diff --git a/test/core/end2end/tests/thread_stress_test.c b/test/core/end2end/tests/thread_stress_test.c
new file mode 100644
index 0000000..44b250f
--- /dev/null
+++ b/test/core/end2end/tests/thread_stress_test.c
@@ -0,0 +1,325 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <string.h>
+
+#include "src/core/surface/event_string.h"
+#include "src/core/surface/completion_queue.h"
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include <grpc/support/thd.h>
+
+#define SERVER_THREADS 16
+#define CLIENT_THREADS 16
+
+static grpc_end2end_test_fixture g_fixture;
+static gpr_timespec g_test_end_time;
+static gpr_event g_client_done[CLIENT_THREADS];
+static gpr_event g_server_done[SERVER_THREADS];
+static gpr_mu g_mu;
+static int g_active_requests;
+
+static gpr_timespec n_seconds_time(int n) {
+  return gpr_time_add(gpr_now(), gpr_time_from_micros(GPR_US_PER_SEC * n));
+}
+
+static gpr_timespec five_seconds_time() { return n_seconds_time(5); }
+
+/* Drain pending events on a completion queue until it's ready to destroy.
+   Does some post-processing to safely release memory on some of the events. */
+static void drain_cq(int client, grpc_completion_queue *cq) {
+  grpc_event *ev;
+  grpc_completion_type type;
+  char *evstr;
+  int done = 0;
+  char *name = client ? "client" : "server";
+  while (!done) {
+    ev = grpc_completion_queue_next(cq, five_seconds_time());
+    if (!ev) {
+      gpr_log(GPR_ERROR, "waiting for %s cq to drain", name);
+      grpc_cq_dump_pending_ops(cq);
+      continue;
+    }
+
+    evstr = grpc_event_string(ev);
+    gpr_log(GPR_INFO, "got late %s event: %s", name, evstr);
+    gpr_free(evstr);
+
+    type = ev->type;
+    switch (type) {
+      case GRPC_SERVER_RPC_NEW:
+        gpr_free(ev->tag);
+        if (ev->call) {
+          grpc_call_destroy(ev->call);
+        }
+        break;
+      case GRPC_FINISHED:
+        grpc_call_destroy(ev->call);
+        break;
+      case GRPC_QUEUE_SHUTDOWN:
+        done = 1;
+        break;
+      case GRPC_READ:
+      case GRPC_WRITE_ACCEPTED:
+        if (!client && gpr_unref(ev->tag)) {
+          gpr_free(ev->tag);
+        }
+      default:
+        break;
+    }
+    grpc_event_finish(ev);
+  }
+}
+
+/* Kick off a new request - assumes g_mu taken */
+static void start_request() {
+  grpc_call *call = grpc_channel_create_call(
+      g_fixture.client, "/Foo", "test.google.com", g_test_end_time);
+  g_active_requests++;
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_invoke(call, g_fixture.client_cq,
+                                                    NULL, NULL, NULL, 0));
+}
+
+/* Async client: handle sending requests, reading responses, and starting
+   new requests when old ones finish */
+static void client_thread(void *p) {
+  int id = (gpr_intptr)p;
+  grpc_event *ev;
+  gpr_slice slice = gpr_slice_malloc(100);
+  grpc_byte_buffer *buf;
+  char *estr;
+  memset(GPR_SLICE_START_PTR(slice), id, GPR_SLICE_LENGTH(slice));
+
+  buf = grpc_byte_buffer_create(&slice, 1);
+  gpr_slice_unref(slice);
+
+  for (;;) {
+    ev = grpc_completion_queue_next(g_fixture.client_cq, n_seconds_time(1));
+    if (ev) {
+      switch (ev->type) {
+        default:
+          estr = grpc_event_string(ev);
+          gpr_log(GPR_ERROR, "unexpected event: %s", estr);
+          gpr_free(estr);
+          break;
+        case GRPC_INVOKE_ACCEPTED:
+          /* better not keep going if the invoke failed */
+          if (ev->data.invoke_accepted == GRPC_OP_OK) {
+            GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read(ev->call, NULL));
+            GPR_ASSERT(GRPC_CALL_OK ==
+                       grpc_call_start_write(ev->call, buf, NULL, 0));
+          }
+          break;
+        case GRPC_READ:
+          break;
+        case GRPC_WRITE_ACCEPTED:
+          GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(ev->call, NULL));
+          break;
+        case GRPC_FINISH_ACCEPTED:
+          break;
+        case GRPC_CLIENT_METADATA_READ:
+          break;
+        case GRPC_FINISHED:
+          /* kick off a new request if the test should still be running */
+          gpr_mu_lock(&g_mu);
+          g_active_requests--;
+          if (gpr_time_cmp(gpr_now(), g_test_end_time) < 0) {
+            start_request();
+          }
+          gpr_mu_unlock(&g_mu);
+          grpc_call_destroy(ev->call);
+          break;
+      }
+      grpc_event_finish(ev);
+    }
+    gpr_mu_lock(&g_mu);
+    if (g_active_requests == 0) {
+      gpr_mu_unlock(&g_mu);
+      break;
+    }
+    gpr_mu_unlock(&g_mu);
+  }
+
+  grpc_byte_buffer_destroy(buf);
+  gpr_event_set(&g_client_done[id], (void *)1);
+}
+
+/* Request a new server call. We tag them with a ref-count that starts at two,
+   and decrements after each of: a read completes and a write completes.
+   When it drops to zero, we write status */
+static void request_server_call() {
+  gpr_refcount *rc = gpr_malloc(sizeof(gpr_refcount));
+  gpr_ref_init(rc, 2);
+  grpc_server_request_call(g_fixture.server, rc);
+}
+
+static void maybe_end_server_call(grpc_call *call, gpr_refcount *rc) {
+  grpc_status ok_status = {GRPC_STATUS_OK, NULL};
+  if (gpr_unref(rc)) {
+    GPR_ASSERT(GRPC_CALL_OK ==
+               grpc_call_start_write_status(call, ok_status, NULL));
+    gpr_free(rc);
+  }
+}
+
+static void server_thread(void *p) {
+  int id = (gpr_intptr)p;
+  grpc_event *ev;
+  gpr_slice slice = gpr_slice_malloc(100);
+  grpc_byte_buffer *buf;
+  char *estr;
+  memset(GPR_SLICE_START_PTR(slice), id, GPR_SLICE_LENGTH(slice));
+
+  request_server_call();
+
+  buf = grpc_byte_buffer_create(&slice, 1);
+  gpr_slice_unref(slice);
+
+  for (;;) {
+    ev = grpc_completion_queue_next(g_fixture.server_cq, n_seconds_time(1));
+    if (ev) {
+      switch (ev->type) {
+        default:
+          estr = grpc_event_string(ev);
+          gpr_log(GPR_ERROR, "unexpected event: %s", estr);
+          gpr_free(estr);
+          break;
+        case GRPC_SERVER_RPC_NEW:
+          if (ev->call) {
+            GPR_ASSERT(GRPC_CALL_OK == grpc_call_accept(ev->call,
+                                                        g_fixture.server_cq,
+                                                        ev->tag, 0));
+            GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read(ev->call, ev->tag));
+            GPR_ASSERT(GRPC_CALL_OK ==
+                       grpc_call_start_write(ev->call, buf, ev->tag, 0));
+          } else {
+            gpr_free(ev->tag);
+          }
+          break;
+        case GRPC_READ:
+          if (ev->data.read) {
+            GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read(ev->call, ev->tag));
+          } else {
+            maybe_end_server_call(ev->call, ev->tag);
+          }
+          break;
+        case GRPC_WRITE_ACCEPTED:
+          maybe_end_server_call(ev->call, ev->tag);
+          break;
+        case GRPC_FINISH_ACCEPTED:
+          break;
+        case GRPC_FINISHED:
+          grpc_call_destroy(ev->call);
+          request_server_call();
+          break;
+      }
+      grpc_event_finish(ev);
+    }
+    gpr_mu_lock(&g_mu);
+    if (g_active_requests == 0) {
+      gpr_mu_unlock(&g_mu);
+      break;
+    }
+    gpr_mu_unlock(&g_mu);
+  }
+
+  grpc_byte_buffer_destroy(buf);
+  gpr_event_set(&g_server_done[id], (void *)1);
+}
+
+static void run_test(grpc_end2end_test_config config, int requests_in_flight) {
+  int i;
+  gpr_thd_id thd_id;
+
+  gpr_log(GPR_INFO, "thread_test/%s @ %d requests", config.name,
+          requests_in_flight);
+
+  /* setup client, server */
+  g_fixture = config.create_fixture(NULL, NULL);
+  config.init_client(&g_fixture, NULL);
+  config.init_server(&g_fixture, NULL);
+
+  /* schedule end time */
+  g_test_end_time = n_seconds_time(5);
+
+  g_active_requests = 0;
+  gpr_mu_init(&g_mu);
+
+  /* kick off threads */
+  for (i = 0; i < CLIENT_THREADS; i++) {
+    gpr_event_init(&g_client_done[i]);
+    gpr_thd_new(&thd_id, client_thread, (void *)(gpr_intptr)i, NULL);
+  }
+  for (i = 0; i < SERVER_THREADS; i++) {
+    gpr_event_init(&g_server_done[i]);
+    gpr_thd_new(&thd_id, server_thread, (void *)(gpr_intptr)i, NULL);
+  }
+
+  /* start requests */
+  gpr_mu_lock(&g_mu);
+  for (i = 0; i < requests_in_flight; i++) {
+    start_request();
+  }
+  gpr_mu_unlock(&g_mu);
+
+  /* await completion */
+  for (i = 0; i < CLIENT_THREADS; i++) {
+    gpr_event_wait(&g_client_done[i], gpr_inf_future);
+  }
+  for (i = 0; i < SERVER_THREADS; i++) {
+    gpr_event_wait(&g_server_done[i], gpr_inf_future);
+  }
+
+  /* shutdown the things */
+  grpc_server_shutdown(g_fixture.server);
+  grpc_server_destroy(g_fixture.server);
+  grpc_channel_destroy(g_fixture.client);
+
+  grpc_completion_queue_shutdown(g_fixture.server_cq);
+  drain_cq(0, g_fixture.server_cq);
+  grpc_completion_queue_destroy(g_fixture.server_cq);
+  grpc_completion_queue_shutdown(g_fixture.client_cq);
+  drain_cq(1, g_fixture.client_cq);
+  grpc_completion_queue_destroy(g_fixture.client_cq);
+
+  config.tear_down_data(&g_fixture);
+
+  gpr_mu_destroy(&g_mu);
+}
+
+void grpc_end2end_tests(grpc_end2end_test_config config) {
+  run_test(config, 1000);
+}
diff --git a/test/core/end2end/tests/writes_done_hangs_with_pending_read.c b/test/core/end2end/tests/writes_done_hangs_with_pending_read.c
new file mode 100644
index 0000000..555d7b9
--- /dev/null
+++ b/test/core/end2end/tests/writes_done_hangs_with_pending_read.c
@@ -0,0 +1,198 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <grpc/byte_buffer.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include <grpc/support/useful.h>
+#include "test/core/end2end/cq_verifier.h"
+
+enum { TIMEOUT = 200000 };
+
+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) {
+  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);
+  return f;
+}
+
+static gpr_timespec n_seconds_time(int n) {
+  return gpr_time_add(gpr_now(), gpr_time_from_micros(GPR_US_PER_SEC * n));
+}
+
+static gpr_timespec five_seconds_time() { return n_seconds_time(5); }
+
+static void drain_cq(grpc_completion_queue *cq) {
+  grpc_event *ev;
+  grpc_completion_type type;
+  do {
+    ev = grpc_completion_queue_next(cq, five_seconds_time());
+    GPR_ASSERT(ev);
+    type = ev->type;
+    grpc_event_finish(ev);
+  } while (type != GRPC_QUEUE_SHUTDOWN);
+}
+
+static void shutdown_server(grpc_end2end_test_fixture *f) {
+  if (!f->server) return;
+  grpc_server_shutdown(f->server);
+  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);
+  f->client = NULL;
+}
+
+static void end_test(grpc_end2end_test_fixture *f) {
+  shutdown_server(f);
+  shutdown_client(f);
+
+  grpc_completion_queue_shutdown(f->server_cq);
+  drain_cq(f->server_cq);
+  grpc_completion_queue_destroy(f->server_cq);
+  grpc_completion_queue_shutdown(f->client_cq);
+  drain_cq(f->client_cq);
+  grpc_completion_queue_destroy(f->client_cq);
+}
+
+/* test the case when there is a pending message at the client side,
+   writes_done should not return a status without a start_read.
+   Note: this test will last for 3s. Do not run in a loop. */
+static void test_writes_done_hangs_with_pending_read(
+    grpc_end2end_test_config config) {
+  grpc_call *c;
+  grpc_call *s;
+  grpc_status send_status = {GRPC_STATUS_UNIMPLEMENTED, "xyz"};
+  gpr_slice request_payload_slice = gpr_slice_from_copied_string("hello world");
+  gpr_slice response_payload_slice = gpr_slice_from_copied_string("hello you");
+  grpc_byte_buffer *request_payload =
+      grpc_byte_buffer_create(&request_payload_slice, 1);
+  grpc_byte_buffer *response_payload =
+      grpc_byte_buffer_create(&response_payload_slice, 1);
+  gpr_timespec deadline = five_seconds_time();
+  grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
+  cq_verifier *v_client = cq_verifier_create(f.client_cq);
+  cq_verifier *v_server = cq_verifier_create(f.server_cq);
+
+  /* byte buffer holds the slice, we can unref it already */
+  gpr_slice_unref(request_payload_slice);
+  gpr_slice_unref(response_payload_slice);
+
+  c = grpc_channel_create_call(f.client, "/foo", "test.google.com", deadline);
+  GPR_ASSERT(c);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(c, f.client_cq, tag(1), tag(2), tag(3), 0));
+  cq_expect_invoke_accepted(v_client, tag(1), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write(c, request_payload, tag(4), 0));
+  /* destroy byte buffer early to ensure async code keeps track of its contents
+     correctly */
+  grpc_byte_buffer_destroy(request_payload);
+  cq_expect_write_accepted(v_client, tag(4), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, tag(100)));
+  cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "test.google.com",
+                           deadline, NULL);
+  cq_verify(v_server);
+
+  grpc_call_accept(s, f.server_cq, tag(102), 0);
+  cq_expect_client_metadata_read(v_client, tag(2), NULL);
+  cq_verify(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read(s, tag(5)));
+  cq_expect_read(v_server, tag(5), gpr_slice_from_copied_string("hello world"));
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write(s, response_payload, tag(6), 0));
+  /* destroy byte buffer early to ensure async code keeps track of its contents
+     correctly */
+  grpc_byte_buffer_destroy(response_payload);
+  cq_expect_write_accepted(v_server, tag(6), GRPC_OP_OK);
+  cq_verify(v_server);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done(c, tag(6)));
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_write_status(s, send_status, tag(7)));
+
+  cq_expect_finish_accepted(v_client, tag(6), GRPC_OP_OK);
+  cq_verify(v_client);
+
+  /* does not return status because there is a pending message to be read */
+  cq_verify_empty(v_client);
+
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read(c, tag(8)));
+  cq_expect_read(v_client, tag(8), gpr_slice_from_copied_string("hello you"));
+  cq_verify(v_client);
+
+  cq_expect_finished_with_status(v_client, tag(3), send_status, NULL);
+  cq_verify(v_client);
+
+  cq_expect_finish_accepted(v_server, tag(7), GRPC_OP_OK);
+  cq_expect_finished(v_server, tag(102), NULL);
+  cq_verify(v_server);
+
+  grpc_call_destroy(c);
+  grpc_call_destroy(s);
+
+  end_test(&f);
+  config.tear_down_data(&f);
+
+  cq_verifier_destroy(v_client);
+  cq_verifier_destroy(v_server);
+}
+
+void grpc_end2end_tests(grpc_end2end_test_config config) {
+  test_writes_done_hangs_with_pending_read(config);
+}
diff --git a/test/core/endpoint/endpoint_tests.c b/test/core/endpoint/endpoint_tests.c
new file mode 100644
index 0000000..9cc0eaa
--- /dev/null
+++ b/test/core/endpoint/endpoint_tests.c
@@ -0,0 +1,433 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/endpoint/endpoint_tests.h"
+
+#include <sys/types.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/slice.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+
+/*
+   General test notes:
+
+   All tests which write data into an endpoint write i%256 into byte i, which
+   is verified by readers.
+
+   In general there are a few interesting things to vary which may lead to
+   exercising different codepaths in an implementation:
+   1. Total amount of data written to the endpoint
+   2. Size of slice allocations
+   3. Amount of data we read from or write to the endpoint at once
+
+   The tests here tend to parameterize these where applicable.
+
+*/
+
+ssize_t count_and_unref_slices(gpr_slice *slices, size_t nslices,
+                               int *current_data) {
+  ssize_t num_bytes = 0;
+  int i;
+  int j;
+  unsigned char *buf;
+  for (i = 0; i < nslices; ++i) {
+    buf = GPR_SLICE_START_PTR(slices[i]);
+    for (j = 0; j < GPR_SLICE_LENGTH(slices[i]); ++j) {
+      GPR_ASSERT(buf[j] == *current_data);
+      *current_data = (*current_data + 1) % 256;
+    }
+    num_bytes += GPR_SLICE_LENGTH(slices[i]);
+    gpr_slice_unref(slices[i]);
+  }
+  return num_bytes;
+}
+
+static grpc_endpoint_test_fixture begin_test(grpc_endpoint_test_config config,
+                                             const char *test_name,
+                                             ssize_t slice_size) {
+  gpr_log(GPR_INFO, "%s/%s", test_name, config.name);
+  return config.create_fixture(slice_size);
+}
+
+static void end_test(grpc_endpoint_test_config config) { config.clean_up(); }
+
+static gpr_slice *allocate_blocks(ssize_t num_bytes, ssize_t slice_size,
+                                  size_t *num_blocks, int *current_data) {
+  ssize_t nslices = num_bytes / slice_size + (num_bytes % slice_size ? 1 : 0);
+  gpr_slice *slices = malloc(sizeof(gpr_slice) * nslices);
+  ssize_t num_bytes_left = num_bytes;
+  int i;
+  int j;
+  unsigned char *buf;
+  *num_blocks = nslices;
+
+  for (i = 0; i < nslices; ++i) {
+    slices[i] = gpr_slice_malloc(slice_size > num_bytes_left ? num_bytes_left
+                                                             : slice_size);
+    num_bytes_left -= GPR_SLICE_LENGTH(slices[i]);
+    buf = GPR_SLICE_START_PTR(slices[i]);
+    for (j = 0; j < GPR_SLICE_LENGTH(slices[i]); ++j) {
+      buf[j] = *current_data;
+      *current_data = (*current_data + 1) % 256;
+    }
+  }
+  GPR_ASSERT(num_bytes_left == 0);
+  return slices;
+}
+
+struct read_and_write_test_state {
+  grpc_endpoint *read_ep;
+  grpc_endpoint *write_ep;
+  gpr_mu mu;
+  gpr_cv cv;
+  ssize_t target_bytes;
+  ssize_t bytes_read;
+  ssize_t current_write_size;
+  ssize_t bytes_written;
+  int current_read_data;
+  int current_write_data;
+  int read_done;
+  int write_done;
+};
+
+static void read_and_write_test_read_handler(void *data, gpr_slice *slices,
+                                             size_t nslices,
+                                             grpc_endpoint_cb_status error) {
+  struct read_and_write_test_state *state = data;
+  GPR_ASSERT(error != GRPC_ENDPOINT_CB_ERROR);
+  if (error == GRPC_ENDPOINT_CB_SHUTDOWN) {
+    gpr_log(GPR_INFO, "Read handler shutdown");
+    gpr_mu_lock(&state->mu);
+    state->read_done = 1;
+    gpr_cv_signal(&state->cv);
+    gpr_mu_unlock(&state->mu);
+    return;
+  }
+
+  state->bytes_read +=
+      count_and_unref_slices(slices, nslices, &state->current_read_data);
+  if (state->bytes_read == state->target_bytes) {
+    gpr_log(GPR_INFO, "Read handler done");
+    gpr_mu_lock(&state->mu);
+    state->read_done = 1;
+    gpr_cv_signal(&state->cv);
+    gpr_mu_unlock(&state->mu);
+  } else {
+    grpc_endpoint_notify_on_read(
+        state->read_ep, read_and_write_test_read_handler, data, gpr_inf_future);
+  }
+}
+
+static void read_and_write_test_write_handler(void *data,
+                                              grpc_endpoint_cb_status error) {
+  struct read_and_write_test_state *state = data;
+  gpr_slice *slices = NULL;
+  size_t nslices;
+  grpc_endpoint_write_status write_status;
+
+  GPR_ASSERT(error != GRPC_ENDPOINT_CB_ERROR);
+
+  if (error == GRPC_ENDPOINT_CB_SHUTDOWN) {
+    gpr_log(GPR_INFO, "Write handler shutdown");
+    gpr_mu_lock(&state->mu);
+    state->write_done = 1;
+    gpr_cv_signal(&state->cv);
+    gpr_mu_unlock(&state->mu);
+    return;
+  }
+
+  for (;;) {
+    /* Need to do inline writes until they don't succeed synchronously or we
+       finish writing */
+    state->bytes_written += state->current_write_size;
+    if (state->target_bytes - state->bytes_written <
+        state->current_write_size) {
+      state->current_write_size = state->target_bytes - state->bytes_written;
+    }
+    if (state->current_write_size == 0) {
+      break;
+    }
+
+    slices = allocate_blocks(state->current_write_size, 8192, &nslices,
+                             &state->current_write_data);
+    write_status = grpc_endpoint_write(state->write_ep, slices, nslices,
+                                       read_and_write_test_write_handler, state,
+                                       gpr_inf_future);
+    GPR_ASSERT(write_status != GRPC_ENDPOINT_WRITE_ERROR);
+    free(slices);
+    if (write_status == GRPC_ENDPOINT_WRITE_PENDING) {
+      return;
+    }
+  }
+  GPR_ASSERT(state->bytes_written == state->target_bytes);
+
+  gpr_log(GPR_INFO, "Write handler done");
+  gpr_mu_lock(&state->mu);
+  state->write_done = 1;
+  gpr_cv_signal(&state->cv);
+  gpr_mu_unlock(&state->mu);
+}
+
+/* Do both reading and writing using the grpc_endpoint API.
+
+   This also includes a test of the shutdown behavior.
+ */
+static void read_and_write_test(grpc_endpoint_test_config config,
+                                ssize_t num_bytes, ssize_t write_size,
+                                ssize_t slice_size, int shutdown) {
+  struct read_and_write_test_state state;
+  gpr_timespec rel_deadline = {20, 0};
+  gpr_timespec deadline = gpr_time_add(gpr_now(), rel_deadline);
+  grpc_endpoint_test_fixture f = begin_test(config, __FUNCTION__, slice_size);
+
+  if (shutdown) {
+    gpr_log(GPR_INFO, "Start read and write shutdown test");
+  } else {
+    gpr_log(GPR_INFO, "Start read and write test with %d bytes, slice size %d",
+            num_bytes, slice_size);
+  }
+
+  gpr_mu_init(&state.mu);
+  gpr_cv_init(&state.cv);
+
+  state.read_ep = f.client_ep;
+  state.write_ep = f.server_ep;
+  state.target_bytes = num_bytes;
+  state.bytes_read = 0;
+  state.current_write_size = write_size;
+  state.bytes_written = 0;
+  state.read_done = 0;
+  state.write_done = 0;
+  state.current_read_data = 0;
+  state.current_write_data = 0;
+
+  /* Get started by pretending an initial write completed */
+  state.bytes_written -= state.current_write_size;
+  read_and_write_test_write_handler(&state, GRPC_ENDPOINT_CB_OK);
+
+  grpc_endpoint_notify_on_read(state.read_ep, read_and_write_test_read_handler,
+                               &state, gpr_inf_future);
+
+  if (shutdown) {
+    grpc_endpoint_shutdown(state.read_ep);
+    grpc_endpoint_shutdown(state.write_ep);
+  }
+
+  gpr_mu_lock(&state.mu);
+  while (!state.read_done || !state.write_done) {
+    GPR_ASSERT(gpr_cv_wait(&state.cv, &state.mu, deadline) == 0);
+  }
+  gpr_mu_unlock(&state.mu);
+
+  grpc_endpoint_destroy(state.read_ep);
+  grpc_endpoint_destroy(state.write_ep);
+  gpr_mu_destroy(&state.mu);
+  gpr_cv_destroy(&state.cv);
+  end_test(config);
+}
+
+struct timeout_test_state {
+  gpr_event io_done;
+};
+
+static void read_timeout_test_read_handler(void *data, gpr_slice *slices,
+                                           size_t nslices,
+                                           grpc_endpoint_cb_status error) {
+  struct timeout_test_state *state = data;
+  GPR_ASSERT(error == GRPC_ENDPOINT_CB_TIMED_OUT);
+  gpr_event_set(&state->io_done, (void *)1);
+}
+
+static void read_timeout_test(grpc_endpoint_test_config config,
+                              ssize_t slice_size) {
+  gpr_timespec timeout = gpr_time_from_micros(10000);
+  gpr_timespec read_deadline = gpr_time_add(gpr_now(), timeout);
+  gpr_timespec test_deadline =
+      gpr_time_add(gpr_now(), gpr_time_from_micros(2000000));
+  struct timeout_test_state state;
+  grpc_endpoint_test_fixture f = begin_test(config, __FUNCTION__, slice_size);
+
+  gpr_event_init(&state.io_done);
+
+  grpc_endpoint_notify_on_read(f.client_ep, read_timeout_test_read_handler,
+                               &state, read_deadline);
+  GPR_ASSERT(gpr_event_wait(&state.io_done, test_deadline));
+  grpc_endpoint_destroy(f.client_ep);
+  grpc_endpoint_destroy(f.server_ep);
+  end_test(config);
+}
+
+static void write_timeout_test_write_handler(void *data,
+                                             grpc_endpoint_cb_status error) {
+  struct timeout_test_state *state = data;
+  GPR_ASSERT(error == GRPC_ENDPOINT_CB_TIMED_OUT);
+  gpr_event_set(&state->io_done, (void *)1);
+}
+
+static void write_timeout_test(grpc_endpoint_test_config config,
+                               ssize_t slice_size) {
+  gpr_timespec timeout = gpr_time_from_micros(10000);
+  gpr_timespec write_deadline = gpr_time_add(gpr_now(), timeout);
+  gpr_timespec test_deadline =
+      gpr_time_add(gpr_now(), gpr_time_from_micros(2000000));
+  struct timeout_test_state state;
+  int current_data = 1;
+  gpr_slice *slices;
+  size_t nblocks;
+  size_t size;
+  grpc_endpoint_test_fixture f = begin_test(config, __FUNCTION__, slice_size);
+
+  gpr_event_init(&state.io_done);
+
+  /* TODO(klempner): Factor this out with the equivalent code in tcp_test.c */
+  for (size = 1;; size *= 2) {
+    slices = allocate_blocks(size, 1, &nblocks, &current_data);
+    switch (grpc_endpoint_write(f.client_ep, slices, nblocks,
+                                write_timeout_test_write_handler, &state,
+                                write_deadline)) {
+      case GRPC_ENDPOINT_WRITE_DONE:
+        break;
+      case GRPC_ENDPOINT_WRITE_ERROR:
+        gpr_log(GPR_ERROR, "error writing");
+        abort();
+      case GRPC_ENDPOINT_WRITE_PENDING:
+        GPR_ASSERT(gpr_event_wait(&state.io_done, test_deadline));
+        gpr_free(slices);
+        goto exit;
+    }
+    gpr_free(slices);
+  }
+exit:
+  grpc_endpoint_destroy(f.client_ep);
+  grpc_endpoint_destroy(f.server_ep);
+  end_test(config);
+}
+
+typedef struct {
+  gpr_event ev;
+  grpc_endpoint *ep;
+} shutdown_during_write_test_state;
+
+static void shutdown_during_write_test_read_handler(
+    void *user_data, gpr_slice *slices, size_t nslices,
+    grpc_endpoint_cb_status error) {
+  size_t i;
+  shutdown_during_write_test_state *st = user_data;
+
+  for (i = 0; i < nslices; i++) {
+    gpr_slice_unref(slices[i]);
+  }
+
+  if (error != GRPC_ENDPOINT_CB_OK) {
+    grpc_endpoint_destroy(st->ep);
+    gpr_event_set(&st->ev, (void *)(gpr_intptr)error);
+  } else {
+    grpc_endpoint_notify_on_read(st->ep,
+                                 shutdown_during_write_test_read_handler,
+                                 user_data, gpr_inf_future);
+  }
+}
+
+static void shutdown_during_write_test_write_handler(
+    void *user_data, grpc_endpoint_cb_status error) {
+  shutdown_during_write_test_state *st = user_data;
+  gpr_log(GPR_INFO, "shutdown_during_write_test_write_handler: error = %d",
+          error);
+  grpc_endpoint_destroy(st->ep);
+  gpr_event_set(&st->ev, (void *)(gpr_intptr)error);
+}
+
+static void shutdown_during_write_test(grpc_endpoint_test_config config,
+                                       ssize_t slice_size) {
+  /* test that shutdown with a pending write creates no leaks */
+  gpr_timespec deadline;
+  size_t size;
+  size_t nblocks;
+  int current_data = 1;
+  shutdown_during_write_test_state read_st;
+  shutdown_during_write_test_state write_st;
+  gpr_slice *slices;
+  grpc_endpoint_test_fixture f = begin_test(config, __FUNCTION__, slice_size);
+
+  gpr_log(GPR_INFO, "testing shutdown during a write");
+
+  read_st.ep = f.client_ep;
+  write_st.ep = f.server_ep;
+  gpr_event_init(&read_st.ev);
+  gpr_event_init(&write_st.ev);
+
+#if 0
+  read_st.ep = grpc_tcp_create(sv[1], &em);
+  write_st.ep = grpc_tcp_create(sv[0], &em);
+#endif
+
+  grpc_endpoint_notify_on_read(read_st.ep,
+                               shutdown_during_write_test_read_handler,
+                               &read_st, gpr_inf_future);
+  for (size = 1;; size *= 2) {
+    slices = allocate_blocks(size, 1, &nblocks, &current_data);
+    switch (grpc_endpoint_write(write_st.ep, slices, nblocks,
+                                shutdown_during_write_test_write_handler,
+                                &write_st, gpr_inf_future)) {
+      case GRPC_ENDPOINT_WRITE_DONE:
+        break;
+      case GRPC_ENDPOINT_WRITE_ERROR:
+        gpr_log(GPR_ERROR, "error writing");
+        abort();
+      case GRPC_ENDPOINT_WRITE_PENDING:
+        grpc_endpoint_shutdown(write_st.ep);
+        deadline =
+            gpr_time_add(gpr_now(), gpr_time_from_micros(10 * GPR_US_PER_SEC));
+        GPR_ASSERT(gpr_event_wait(&write_st.ev, deadline));
+        GPR_ASSERT(gpr_event_wait(&read_st.ev, deadline));
+        gpr_free(slices);
+        end_test(config);
+        return;
+    }
+    gpr_free(slices);
+  }
+
+  gpr_log(GPR_ERROR, "should never reach here");
+  abort();
+}
+
+void grpc_endpoint_tests(grpc_endpoint_test_config config) {
+  read_and_write_test(config, 10000000, 100000, 8192, 0);
+  read_and_write_test(config, 1000000, 100000, 1, 0);
+  read_and_write_test(config, 100000000, 100000, 1, 1);
+  read_timeout_test(config, 1000);
+  write_timeout_test(config, 1000);
+  shutdown_during_write_test(config, 1000);
+}
diff --git a/test/core/endpoint/endpoint_tests.h b/test/core/endpoint/endpoint_tests.h
new file mode 100644
index 0000000..79ee759
--- /dev/null
+++ b/test/core/endpoint/endpoint_tests.h
@@ -0,0 +1,57 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef __GRPC_TEST_ENDPOINT_ENDPOINT_TESTS_H__
+#define __GRPC_TEST_ENDPOINT_ENDPOINT_TESTS_H__
+
+#include <sys/types.h>
+
+#include "src/core/endpoint/endpoint.h"
+
+typedef struct grpc_endpoint_test_config grpc_endpoint_test_config;
+typedef struct grpc_endpoint_test_fixture grpc_endpoint_test_fixture;
+
+struct grpc_endpoint_test_fixture {
+  grpc_endpoint *client_ep;
+  grpc_endpoint *server_ep;
+};
+
+struct grpc_endpoint_test_config {
+  const char *name;
+  grpc_endpoint_test_fixture (*create_fixture)(ssize_t slice_size);
+  void (*clean_up)();
+};
+
+void grpc_endpoint_tests(grpc_endpoint_test_config config);
+
+#endif  /* __GRPC_TEST_ENDPOINT_ENDPOINT_TESTS_H__ */
diff --git a/test/core/endpoint/resolve_address_test.c b/test/core/endpoint/resolve_address_test.c
new file mode 100644
index 0000000..1e208d3
--- /dev/null
+++ b/test/core/endpoint/resolve_address_test.c
@@ -0,0 +1,135 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/endpoint/resolve_address.h"
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/time.h>
+#include "test/core/util/test_config.h"
+
+static gpr_timespec test_deadline() {
+  return gpr_time_add(gpr_now(), gpr_time_from_micros(100000000));
+}
+
+static void must_succeed(void* evp, grpc_resolved_addresses* p) {
+  GPR_ASSERT(p);
+  GPR_ASSERT(p->naddrs >= 1);
+  grpc_resolved_addresses_destroy(p);
+  gpr_event_set(evp, (void*)1);
+}
+
+static void must_fail(void* evp, grpc_resolved_addresses* p) {
+  GPR_ASSERT(!p);
+  gpr_event_set(evp, (void*)1);
+}
+
+static void test_localhost() {
+  gpr_event ev;
+  gpr_event_init(&ev);
+  grpc_resolve_address("localhost:1", NULL, must_succeed, &ev);
+  GPR_ASSERT(gpr_event_wait(&ev, test_deadline()));
+}
+
+static void test_default_port() {
+  gpr_event ev;
+  gpr_event_init(&ev);
+  grpc_resolve_address("localhost", "1", must_succeed, &ev);
+  GPR_ASSERT(gpr_event_wait(&ev, test_deadline()));
+}
+
+static void test_missing_default_port() {
+  gpr_event ev;
+  gpr_event_init(&ev);
+  grpc_resolve_address("localhost", NULL, must_fail, &ev);
+  GPR_ASSERT(gpr_event_wait(&ev, test_deadline()));
+}
+
+static void test_ipv6_with_port() {
+  gpr_event ev;
+  gpr_event_init(&ev);
+  grpc_resolve_address("[2001:db8::1]:1", NULL, must_succeed, &ev);
+  GPR_ASSERT(gpr_event_wait(&ev, test_deadline()));
+}
+
+static void test_ipv6_without_port() {
+  const char* const kCases[] = {
+      "2001:db8::1", "2001:db8::1.2.3.4", "[2001:db8::1]",
+  };
+  int i;
+  for (i = 0; i < sizeof(kCases) / sizeof(*kCases); i++) {
+    gpr_event ev;
+    gpr_event_init(&ev);
+    grpc_resolve_address(kCases[i], "80", must_succeed, &ev);
+    GPR_ASSERT(gpr_event_wait(&ev, test_deadline()));
+  }
+}
+
+static void test_invalid_ip_addresses() {
+  const char* const kCases[] = {
+      "293.283.1238.3:1", "[2001:db8::11111]:1",
+  };
+  int i;
+  for (i = 0; i < sizeof(kCases) / sizeof(*kCases); i++) {
+    gpr_event ev;
+    gpr_event_init(&ev);
+    grpc_resolve_address(kCases[i], NULL, must_fail, &ev);
+    GPR_ASSERT(gpr_event_wait(&ev, test_deadline()));
+  }
+}
+
+static void test_unparseable_hostports() {
+  const char* const kCases[] = {
+      "[", "[::1", "[::1]bad", "[1.2.3.4]", "[localhost]", "[localhost]:1",
+  };
+  int i;
+  for (i = 0; i < sizeof(kCases) / sizeof(*kCases); i++) {
+    gpr_event ev;
+    gpr_event_init(&ev);
+    grpc_resolve_address(kCases[i], "1", must_fail, &ev);
+    GPR_ASSERT(gpr_event_wait(&ev, test_deadline()));
+  }
+}
+
+int main(int argc, char** argv) {
+  grpc_test_init(argc, argv);
+
+  test_localhost();
+  test_default_port();
+  test_missing_default_port();
+  test_ipv6_with_port();
+  test_ipv6_without_port();
+  test_invalid_ip_addresses();
+  test_unparseable_hostports();
+
+  return 0;
+}
diff --git a/test/core/endpoint/secure_endpoint_test.c b/test/core/endpoint/secure_endpoint_test.c
new file mode 100644
index 0000000..9fc2511
--- /dev/null
+++ b/test/core/endpoint/secure_endpoint_test.c
@@ -0,0 +1,222 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "endpoint_tests.h"
+
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include "src/core/endpoint/secure_endpoint.h"
+#include "src/core/endpoint/tcp.h"
+#include "src/core/eventmanager/em.h"
+#include "src/core/tsi/fake_transport_security.h"
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include "test/core/util/test_config.h"
+
+grpc_em g_em;
+
+static void create_sockets(int sv[2]) {
+  int flags;
+  GPR_ASSERT(socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == 0);
+  flags = fcntl(sv[0], F_GETFL, 0);
+  GPR_ASSERT(fcntl(sv[0], F_SETFL, flags | O_NONBLOCK) == 0);
+  flags = fcntl(sv[1], F_GETFL, 0);
+  GPR_ASSERT(fcntl(sv[1], F_SETFL, flags | O_NONBLOCK) == 0);
+}
+
+static grpc_endpoint_test_fixture secure_endpoint_create_fixture_tcp_socketpair(
+    ssize_t slice_size, gpr_slice *leftover_slices, size_t leftover_nslices) {
+  int sv[2];
+  tsi_frame_protector *fake_read_protector = tsi_create_fake_protector(NULL);
+  tsi_frame_protector *fake_write_protector = tsi_create_fake_protector(NULL);
+  grpc_endpoint_test_fixture f;
+  grpc_endpoint *tcp_read;
+  grpc_endpoint *tcp_write;
+
+  create_sockets(sv);
+  grpc_em_init(&g_em);
+  tcp_read = grpc_tcp_create_dbg(sv[0], &g_em, slice_size);
+  tcp_write = grpc_tcp_create(sv[1], &g_em);
+
+  if (leftover_nslices == 0) {
+    f.client_ep =
+        grpc_secure_endpoint_create(fake_read_protector, tcp_read, NULL, 0);
+  } else {
+    int i;
+    tsi_result result;
+    gpr_uint32 still_pending_size;
+    size_t total_buffer_size = 8192;
+    size_t buffer_size = total_buffer_size;
+    gpr_uint8 *encrypted_buffer = gpr_malloc(buffer_size);
+    gpr_uint8 *cur = encrypted_buffer;
+    gpr_slice encrypted_leftover;
+    for (i = 0; i < leftover_nslices; i++) {
+      gpr_slice plain = leftover_slices[i];
+      gpr_uint8 *message_bytes = GPR_SLICE_START_PTR(plain);
+      size_t message_size = GPR_SLICE_LENGTH(plain);
+      while (message_size > 0) {
+        gpr_uint32 protected_buffer_size_to_send = buffer_size;
+        gpr_uint32 processed_message_size = message_size;
+        result = tsi_frame_protector_protect(
+            fake_write_protector, message_bytes, &processed_message_size, cur,
+            &protected_buffer_size_to_send);
+        GPR_ASSERT(result == TSI_OK);
+        message_bytes += processed_message_size;
+        message_size -= processed_message_size;
+        cur += protected_buffer_size_to_send;
+        buffer_size -= protected_buffer_size_to_send;
+
+        GPR_ASSERT(buffer_size >= 0);
+      }
+      gpr_slice_unref(plain);
+    }
+    do {
+      gpr_uint32 protected_buffer_size_to_send = buffer_size;
+      result = tsi_frame_protector_protect_flush(fake_write_protector, cur,
+                                                 &protected_buffer_size_to_send,
+                                                 &still_pending_size);
+      GPR_ASSERT(result == TSI_OK);
+      cur += protected_buffer_size_to_send;
+      buffer_size -= protected_buffer_size_to_send;
+      GPR_ASSERT(buffer_size >= 0);
+    } while (still_pending_size > 0);
+    encrypted_leftover = gpr_slice_from_copied_buffer(
+        (const char *)encrypted_buffer, total_buffer_size - buffer_size);
+    f.client_ep = grpc_secure_endpoint_create(fake_read_protector, tcp_read,
+                                              &encrypted_leftover, 1);
+    gpr_slice_unref(encrypted_leftover);
+    gpr_free(encrypted_buffer);
+  }
+
+  f.server_ep =
+      grpc_secure_endpoint_create(fake_write_protector, tcp_write, NULL, 0);
+  return f;
+}
+
+static grpc_endpoint_test_fixture
+secure_endpoint_create_fixture_tcp_socketpair_noleftover(ssize_t slice_size) {
+  return secure_endpoint_create_fixture_tcp_socketpair(slice_size, NULL, 0);
+}
+
+static grpc_endpoint_test_fixture
+secure_endpoint_create_fixture_tcp_socketpair_leftover(ssize_t slice_size) {
+  gpr_slice s =
+      gpr_slice_from_copied_string("hello world 12345678900987654321");
+  grpc_endpoint_test_fixture f;
+
+  f = secure_endpoint_create_fixture_tcp_socketpair(slice_size, &s, 1);
+  return f;
+}
+
+static void clean_up() { grpc_em_destroy(&g_em); }
+
+static grpc_endpoint_test_config configs[] = {
+    {"secure_ep/tcp_socketpair",
+     secure_endpoint_create_fixture_tcp_socketpair_noleftover, clean_up},
+    {"secure_ep/tcp_socketpair_leftover",
+     secure_endpoint_create_fixture_tcp_socketpair_leftover, clean_up},
+};
+
+static void verify_leftover(void *user_data, gpr_slice *slices, size_t nslices,
+                            grpc_endpoint_cb_status error) {
+  gpr_slice s =
+      gpr_slice_from_copied_string("hello world 12345678900987654321");
+
+  GPR_ASSERT(error == GRPC_ENDPOINT_CB_OK);
+  GPR_ASSERT(nslices == 1);
+
+  GPR_ASSERT(0 == gpr_slice_cmp(s, slices[0]));
+  gpr_slice_unref(slices[0]);
+  gpr_slice_unref(s);
+  *(int *)user_data = 1;
+}
+
+static void test_leftover(grpc_endpoint_test_config config,
+                          ssize_t slice_size) {
+  grpc_endpoint_test_fixture f = config.create_fixture(slice_size);
+  int verified = 0;
+  gpr_log(GPR_INFO, "Start test left over");
+
+  grpc_endpoint_notify_on_read(f.client_ep, verify_leftover, &verified,
+                               gpr_inf_future);
+  GPR_ASSERT(verified == 1);
+
+  grpc_endpoint_shutdown(f.client_ep);
+  grpc_endpoint_shutdown(f.server_ep);
+  grpc_endpoint_destroy(f.client_ep);
+  grpc_endpoint_destroy(f.server_ep);
+  clean_up();
+}
+
+static void destroy_early(void *user_data, gpr_slice *slices, size_t nslices,
+                          grpc_endpoint_cb_status error) {
+  grpc_endpoint_test_fixture *f = user_data;
+  gpr_slice s =
+      gpr_slice_from_copied_string("hello world 12345678900987654321");
+
+  GPR_ASSERT(error == GRPC_ENDPOINT_CB_OK);
+  GPR_ASSERT(nslices == 1);
+
+  grpc_endpoint_shutdown(f->client_ep);
+  grpc_endpoint_destroy(f->client_ep);
+
+  GPR_ASSERT(0 == gpr_slice_cmp(s, slices[0]));
+  gpr_slice_unref(slices[0]);
+  gpr_slice_unref(s);
+}
+
+/* test which destroys the ep before finishing reading */
+static void test_destroy_ep_early(grpc_endpoint_test_config config,
+                                  ssize_t slice_size) {
+  grpc_endpoint_test_fixture f = config.create_fixture(slice_size);
+  gpr_log(GPR_INFO, "Start test destroy early");
+
+  grpc_endpoint_notify_on_read(f.client_ep, destroy_early, &f, gpr_inf_future);
+
+  grpc_endpoint_shutdown(f.server_ep);
+  grpc_endpoint_destroy(f.server_ep);
+  clean_up();
+}
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+
+  grpc_endpoint_tests(configs[0]);
+  test_leftover(configs[1], 1);
+  test_destroy_ep_early(configs[1], 1);
+
+  return 0;
+}
diff --git a/test/core/endpoint/tcp_client_test.c b/test/core/endpoint/tcp_client_test.c
new file mode 100644
index 0000000..10138e6
--- /dev/null
+++ b/test/core/endpoint/tcp_client_test.c
@@ -0,0 +1,177 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/endpoint/tcp_client.h"
+
+#include <errno.h>
+#include <netinet/in.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include "src/core/eventmanager/em.h"
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+
+static grpc_em em;
+
+static gpr_timespec test_deadline() {
+  return gpr_time_add(gpr_now(), gpr_time_from_micros(1000000));
+}
+
+static void must_succeed(void *arg, grpc_endpoint *tcp) {
+  GPR_ASSERT(tcp);
+  grpc_endpoint_shutdown(tcp);
+  grpc_endpoint_destroy(tcp);
+  gpr_event_set(arg, (void *)1);
+}
+
+static void must_fail(void *arg, grpc_endpoint *tcp) {
+  GPR_ASSERT(!tcp);
+  gpr_event_set(arg, (void *)1);
+}
+
+void test_succeeds() {
+  struct sockaddr_in addr;
+  socklen_t addr_len = sizeof(addr);
+  int svr_fd;
+  int r;
+  gpr_event ev;
+
+  gpr_event_init(&ev);
+
+  memset(&addr, 0, sizeof(addr));
+  addr.sin_family = AF_INET;
+
+  /* create a dummy server */
+  svr_fd = socket(AF_INET, SOCK_STREAM, 0);
+  GPR_ASSERT(svr_fd >= 0);
+  GPR_ASSERT(0 == bind(svr_fd, (struct sockaddr *)&addr, addr_len));
+  GPR_ASSERT(0 == listen(svr_fd, 1));
+
+  /* connect to it */
+  GPR_ASSERT(getsockname(svr_fd, (struct sockaddr *)&addr, &addr_len) == 0);
+  grpc_tcp_client_connect(must_succeed, &ev, &em, (struct sockaddr *)&addr,
+                          addr_len, gpr_inf_future);
+
+  /* await the connection */
+  do {
+    addr_len = sizeof(addr);
+    r = accept(svr_fd, (struct sockaddr *)&addr, &addr_len);
+  } while (r == -1 && errno == EINTR);
+  GPR_ASSERT(r >= 0);
+  close(r);
+
+  /* wait for the connection callback to finish */
+  GPR_ASSERT(gpr_event_wait(&ev, test_deadline()));
+}
+
+void test_fails() {
+  struct sockaddr_in addr;
+  socklen_t addr_len = sizeof(addr);
+  gpr_event ev;
+
+  gpr_event_init(&ev);
+
+  memset(&addr, 0, sizeof(addr));
+  addr.sin_family = AF_INET;
+
+  /* connect to a broken address */
+  grpc_tcp_client_connect(must_fail, &ev, &em, (struct sockaddr *)&addr,
+                          addr_len, gpr_inf_future);
+
+  /* wait for the connection callback to finish */
+  GPR_ASSERT(gpr_event_wait(&ev, test_deadline()));
+}
+
+void test_times_out() {
+  struct sockaddr_in addr;
+  socklen_t addr_len = sizeof(addr);
+  int svr_fd;
+#define NUM_CLIENT_CONNECTS 10
+  int client_fd[NUM_CLIENT_CONNECTS];
+  int i;
+  int r;
+  gpr_event ev;
+  gpr_timespec connect_deadline;
+
+  gpr_event_init(&ev);
+
+  memset(&addr, 0, sizeof(addr));
+  addr.sin_family = AF_INET;
+
+  /* create a dummy server */
+  svr_fd = socket(AF_INET, SOCK_STREAM, 0);
+  GPR_ASSERT(svr_fd >= 0);
+  GPR_ASSERT(0 == bind(svr_fd, (struct sockaddr *)&addr, addr_len));
+  GPR_ASSERT(0 == listen(svr_fd, 1));
+  /* Get its address */
+  GPR_ASSERT(getsockname(svr_fd, (struct sockaddr *)&addr, &addr_len) == 0);
+
+  /* tie up the listen buffer, which is somewhat arbitrarily sized. */
+  for (i = 0; i < NUM_CLIENT_CONNECTS; ++i) {
+    client_fd[i] = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);
+    do {
+      r = connect(client_fd[i], (struct sockaddr *)&addr, addr_len);
+    } while (r == -1 && errno == EINTR);
+    GPR_ASSERT(r < 0);
+    GPR_ASSERT(errno == EWOULDBLOCK || errno == EINPROGRESS);
+  }
+
+  /* connect to dummy server address */
+
+  connect_deadline = gpr_time_add(gpr_now(), gpr_time_from_micros(1000000));
+
+  grpc_tcp_client_connect(must_fail, &ev, &em, (struct sockaddr *)&addr,
+                          addr_len, connect_deadline);
+  /* Make sure the event doesn't trigger early */
+  GPR_ASSERT(!gpr_event_wait(
+                 &ev, gpr_time_add(gpr_now(), gpr_time_from_micros(500000))));
+  /* Now wait until it should have triggered */
+  sleep(1);
+
+  /* wait for the connection callback to finish */
+  GPR_ASSERT(gpr_event_wait(&ev, test_deadline()));
+  close(svr_fd);
+  for (i = 0; i < NUM_CLIENT_CONNECTS; ++i) {
+    close(client_fd[i]);
+  }
+}
+
+int main(void) {
+  grpc_em_init(&em);
+  test_succeeds();
+  test_fails();
+  test_times_out();
+  return 0;
+}
diff --git a/test/core/endpoint/tcp_server_test.c b/test/core/endpoint/tcp_server_test.c
new file mode 100644
index 0000000..10e2c36
--- /dev/null
+++ b/test/core/endpoint/tcp_server_test.c
@@ -0,0 +1,168 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/endpoint/tcp_server.h"
+#include "src/core/eventmanager/em.h"
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/time.h>
+#include "test/core/util/test_config.h"
+
+#include <netinet/in.h>
+#include <string.h>
+#include <unistd.h>
+
+#define LOG_TEST() gpr_log(GPR_INFO, "%s", __FUNCTION__)
+
+static grpc_em em;
+
+static gpr_mu mu;
+static gpr_cv cv;
+static int nconnects = 0;
+
+static void on_connect(void *arg, grpc_endpoint *tcp) {
+  grpc_endpoint_shutdown(tcp);
+  grpc_endpoint_destroy(tcp);
+
+  gpr_mu_lock(&mu);
+  nconnects++;
+  gpr_cv_broadcast(&cv);
+  gpr_mu_unlock(&mu);
+}
+
+static void test_no_op() {
+  grpc_tcp_server *s = grpc_tcp_server_create(&em);
+  grpc_tcp_server_destroy(s);
+}
+
+static void test_no_op_with_start() {
+  grpc_tcp_server *s = grpc_tcp_server_create(&em);
+  LOG_TEST();
+  grpc_tcp_server_start(s, on_connect, NULL);
+  grpc_tcp_server_destroy(s);
+}
+
+static void test_no_op_with_port() {
+  struct sockaddr_in addr;
+  grpc_tcp_server *s = grpc_tcp_server_create(&em);
+  LOG_TEST();
+
+  memset(&addr, 0, sizeof(addr));
+  addr.sin_family = AF_INET;
+  GPR_ASSERT(
+      grpc_tcp_server_add_port(s, (struct sockaddr *)&addr, sizeof(addr)) >= 0);
+
+  grpc_tcp_server_destroy(s);
+}
+
+static void test_no_op_with_port_and_start() {
+  struct sockaddr_in addr;
+  grpc_tcp_server *s = grpc_tcp_server_create(&em);
+  LOG_TEST();
+
+  memset(&addr, 0, sizeof(addr));
+  addr.sin_family = AF_INET;
+  GPR_ASSERT(
+      grpc_tcp_server_add_port(s, (struct sockaddr *)&addr, sizeof(addr)) >= 0);
+
+  grpc_tcp_server_start(s, on_connect, NULL);
+
+  grpc_tcp_server_destroy(s);
+}
+
+static void test_connect(int n) {
+  struct sockaddr_in addr;
+  socklen_t addr_len = sizeof(addr);
+  int svrfd, clifd;
+  grpc_tcp_server *s = grpc_tcp_server_create(&em);
+  int nconnects_before;
+  gpr_timespec deadline;
+  int i;
+  LOG_TEST();
+  gpr_log(GPR_INFO, "clients=%d", n);
+
+  gpr_mu_lock(&mu);
+
+  memset(&addr, 0, sizeof(addr));
+  addr.sin_family = AF_INET;
+  svrfd = grpc_tcp_server_add_port(s, (struct sockaddr *)&addr, addr_len);
+  GPR_ASSERT(svrfd >= 0);
+
+  GPR_ASSERT(getsockname(svrfd, (struct sockaddr *)&addr, &addr_len) == 0);
+  GPR_ASSERT(addr_len == sizeof(addr));
+
+  grpc_tcp_server_start(s, on_connect, NULL);
+
+  for (i = 0; i < n; i++) {
+    deadline = gpr_time_add(gpr_now(), gpr_time_from_micros(10000000));
+
+    nconnects_before = nconnects;
+    clifd = socket(AF_INET, SOCK_STREAM, 0);
+    GPR_ASSERT(clifd >= 0);
+    GPR_ASSERT(connect(clifd, (struct sockaddr *)&addr, addr_len) == 0);
+
+    while (nconnects == nconnects_before) {
+      GPR_ASSERT(gpr_cv_wait(&cv, &mu, deadline) == 0);
+    }
+
+    GPR_ASSERT(nconnects == nconnects_before + 1);
+    close(clifd);
+
+    if (i != n - 1) {
+      sleep(1);
+    }
+  }
+
+  gpr_mu_unlock(&mu);
+
+  grpc_tcp_server_destroy(s);
+}
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  grpc_em_init(&em);
+  gpr_mu_init(&mu);
+  gpr_cv_init(&cv);
+
+  test_no_op();
+  test_no_op_with_start();
+  test_no_op_with_port();
+  test_no_op_with_port_and_start();
+  test_connect(1);
+  test_connect(10);
+
+  grpc_em_destroy(&em);
+  gpr_mu_destroy(&mu);
+  gpr_cv_destroy(&cv);
+  return 0;
+}
diff --git a/test/core/endpoint/tcp_test.c b/test/core/endpoint/tcp_test.c
new file mode 100644
index 0000000..7dbc278
--- /dev/null
+++ b/test/core/endpoint/tcp_test.c
@@ -0,0 +1,517 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/endpoint/tcp.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include "src/core/eventmanager/em.h"
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include <grpc/support/useful.h>
+#include "test/core/util/test_config.h"
+#include "test/core/endpoint/endpoint_tests.h"
+
+/*
+   General test notes:
+
+   All tests which write data into a socket write i%256 into byte i, which is
+   verified by readers.
+
+   In general there are a few interesting things to vary which may lead to
+   exercising different codepaths in an implementation:
+   1. Total amount of data written to the socket
+   2. Size of slice allocations
+   3. Amount of data we read from or write to the socket at once
+
+   The tests here tend to parameterize these where applicable.
+
+ */
+
+grpc_em g_em;
+
+static void create_sockets(int sv[2]) {
+  int flags;
+  GPR_ASSERT(socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == 0);
+  flags = fcntl(sv[0], F_GETFL, 0);
+  GPR_ASSERT(fcntl(sv[0], F_SETFL, flags | O_NONBLOCK) == 0);
+  flags = fcntl(sv[1], F_GETFL, 0);
+  GPR_ASSERT(fcntl(sv[1], F_SETFL, flags | O_NONBLOCK) == 0);
+}
+
+static ssize_t fill_socket(int fd) {
+  ssize_t write_bytes;
+  ssize_t total_bytes = 0;
+  int i;
+  unsigned char buf[256];
+  for (i = 0; i < 256; ++i) {
+    buf[i] = i;
+  }
+  do {
+    write_bytes = write(fd, buf, 256);
+    if (write_bytes > 0) {
+      total_bytes += write_bytes;
+    }
+  } while (write_bytes >= 0 || errno == EINTR);
+  GPR_ASSERT(errno == EAGAIN);
+  return total_bytes;
+}
+
+static size_t fill_socket_partial(int fd, size_t bytes) {
+  ssize_t write_bytes;
+  size_t total_bytes = 0;
+  unsigned char *buf = malloc(bytes);
+  int i;
+  for (i = 0; i < bytes; ++i) {
+    buf[i] = i % 256;
+  }
+
+  do {
+    write_bytes = write(fd, buf, bytes - total_bytes);
+    if (write_bytes > 0) {
+      total_bytes += write_bytes;
+    }
+  } while ((write_bytes >= 0 || errno == EINTR) && bytes > total_bytes);
+
+  gpr_free(buf);
+
+  return total_bytes;
+}
+
+struct read_socket_state {
+  grpc_endpoint *ep;
+  gpr_mu mu;
+  gpr_cv cv;
+  size_t read_bytes;
+  ssize_t target_read_bytes;
+};
+
+static ssize_t count_and_unref_slices(gpr_slice *slices, size_t nslices,
+                                      int *current_data) {
+  ssize_t num_bytes = 0;
+  int i;
+  int j;
+  unsigned char *buf;
+  for (i = 0; i < nslices; ++i) {
+    buf = GPR_SLICE_START_PTR(slices[i]);
+    for (j = 0; j < GPR_SLICE_LENGTH(slices[i]); ++j) {
+      GPR_ASSERT(buf[j] == *current_data);
+      *current_data = (*current_data + 1) % 256;
+    }
+    num_bytes += GPR_SLICE_LENGTH(slices[i]);
+    gpr_slice_unref(slices[i]);
+  }
+  return num_bytes;
+}
+
+static void read_cb(void *user_data, gpr_slice *slices, size_t nslices,
+                    grpc_endpoint_cb_status error) {
+  struct read_socket_state *state = (struct read_socket_state *)user_data;
+  ssize_t read_bytes;
+  int current_data = 0;
+
+  GPR_ASSERT(error == GRPC_ENDPOINT_CB_OK);
+
+  gpr_mu_lock(&state->mu);
+  read_bytes = count_and_unref_slices(slices, nslices, &current_data);
+  state->read_bytes += read_bytes;
+  gpr_log(GPR_INFO, "Read %d bytes of %d", read_bytes,
+          state->target_read_bytes);
+  if (state->read_bytes >= state->target_read_bytes) {
+    gpr_cv_signal(&state->cv);
+  } else {
+    grpc_endpoint_notify_on_read(state->ep, read_cb, state, gpr_inf_future);
+  }
+  gpr_mu_unlock(&state->mu);
+}
+
+/* Write to a socket, then read from it using the grpc_tcp API. */
+static void read_test(ssize_t num_bytes, ssize_t slice_size) {
+  int sv[2];
+  grpc_em em;
+  grpc_endpoint *ep;
+  struct read_socket_state state;
+  ssize_t written_bytes;
+  gpr_timespec rel_deadline = {20, 0};
+  gpr_timespec deadline = gpr_time_add(gpr_now(), rel_deadline);
+
+  gpr_log(GPR_INFO, "Read test of size %d, slice size %d", num_bytes,
+          slice_size);
+
+  create_sockets(sv);
+  grpc_em_init(&em);
+
+  ep = grpc_tcp_create_dbg(sv[1], &em, slice_size);
+  written_bytes = fill_socket_partial(sv[0], num_bytes);
+  gpr_log(GPR_INFO, "Wrote %d bytes", written_bytes);
+
+  gpr_mu_init(&state.mu);
+  gpr_cv_init(&state.cv);
+  state.ep = ep;
+  state.read_bytes = 0;
+  state.target_read_bytes = written_bytes;
+
+  grpc_endpoint_notify_on_read(ep, read_cb, &state, gpr_inf_future);
+
+  gpr_mu_lock(&state.mu);
+  for (;;) {
+    GPR_ASSERT(gpr_cv_wait(&state.cv, &state.mu, deadline) == 0);
+    if (state.read_bytes >= state.target_read_bytes) {
+      break;
+    }
+  }
+  GPR_ASSERT(state.read_bytes == state.target_read_bytes);
+  gpr_mu_unlock(&state.mu);
+
+  grpc_endpoint_destroy(ep);
+
+  grpc_em_destroy(&em);
+  gpr_mu_destroy(&state.mu);
+  gpr_cv_destroy(&state.cv);
+}
+
+/* Write to a socket until it fills up, then read from it using the grpc_tcp
+   API. */
+static void large_read_test(ssize_t slice_size) {
+  int sv[2];
+  grpc_em em;
+  grpc_endpoint *ep;
+  struct read_socket_state state;
+  ssize_t written_bytes;
+  gpr_timespec rel_deadline = {20, 0};
+  gpr_timespec deadline = gpr_time_add(gpr_now(), rel_deadline);
+
+  gpr_log(GPR_INFO, "Start large read test, slice size %d", slice_size);
+
+  create_sockets(sv);
+  grpc_em_init(&em);
+
+  ep = grpc_tcp_create_dbg(sv[1], &em, slice_size);
+  written_bytes = fill_socket(sv[0]);
+  gpr_log(GPR_INFO, "Wrote %d bytes", written_bytes);
+
+  gpr_mu_init(&state.mu);
+  gpr_cv_init(&state.cv);
+  state.ep = ep;
+  state.read_bytes = 0;
+  state.target_read_bytes = written_bytes;
+
+  grpc_endpoint_notify_on_read(ep, read_cb, &state, gpr_inf_future);
+
+  gpr_mu_lock(&state.mu);
+  for (;;) {
+    GPR_ASSERT(gpr_cv_wait(&state.cv, &state.mu, deadline) == 0);
+    if (state.read_bytes >= state.target_read_bytes) {
+      break;
+    }
+  }
+  GPR_ASSERT(state.read_bytes == state.target_read_bytes);
+  gpr_mu_unlock(&state.mu);
+
+  grpc_endpoint_destroy(ep);
+
+  grpc_em_destroy(&em);
+  gpr_mu_destroy(&state.mu);
+  gpr_cv_destroy(&state.cv);
+}
+
+struct write_socket_state {
+  grpc_endpoint *ep;
+  gpr_mu mu;
+  gpr_cv cv;
+  int write_done;
+};
+
+static gpr_slice *allocate_blocks(ssize_t num_bytes, ssize_t slice_size,
+                                  size_t *num_blocks, int *current_data) {
+  ssize_t nslices = num_bytes / slice_size + (num_bytes % slice_size ? 1 : 0);
+  gpr_slice *slices = gpr_malloc(sizeof(gpr_slice) * nslices);
+  ssize_t num_bytes_left = num_bytes;
+  int i;
+  int j;
+  unsigned char *buf;
+  *num_blocks = nslices;
+
+  for (i = 0; i < nslices; ++i) {
+    slices[i] = gpr_slice_malloc(slice_size > num_bytes_left ? num_bytes_left
+                                                             : slice_size);
+    num_bytes_left -= GPR_SLICE_LENGTH(slices[i]);
+    buf = GPR_SLICE_START_PTR(slices[i]);
+    for (j = 0; j < GPR_SLICE_LENGTH(slices[i]); ++j) {
+      buf[j] = *current_data;
+      *current_data = (*current_data + 1) % 256;
+    }
+  }
+  GPR_ASSERT(num_bytes_left == 0);
+  return slices;
+}
+
+static void write_done(void *user_data /* write_socket_state */,
+                       grpc_endpoint_cb_status error) {
+  struct write_socket_state *state = (struct write_socket_state *)user_data;
+  gpr_log(GPR_INFO, "Write done callback called");
+  gpr_mu_lock(&state->mu);
+  gpr_log(GPR_INFO, "Signalling write done");
+  state->write_done = 1;
+  gpr_cv_signal(&state->cv);
+  gpr_mu_unlock(&state->mu);
+}
+
+void drain_socket_blocking(int fd, size_t num_bytes, size_t read_size) {
+  unsigned char *buf = malloc(read_size);
+  ssize_t bytes_read;
+  size_t bytes_left = num_bytes;
+  int flags;
+  int current = 0;
+  int i;
+
+  flags = fcntl(fd, F_GETFL, 0);
+  GPR_ASSERT(fcntl(fd, F_SETFL, flags & ~O_NONBLOCK) == 0);
+
+  for (;;) {
+    do {
+      bytes_read =
+          read(fd, buf, bytes_left > read_size ? read_size : bytes_left);
+    } while (bytes_read < 0 && errno == EINTR);
+    GPR_ASSERT(bytes_read >= 0);
+    for (i = 0; i < bytes_read; ++i) {
+      GPR_ASSERT(buf[i] == current);
+      current = (current + 1) % 256;
+    }
+    bytes_left -= bytes_read;
+    if (bytes_left == 0) break;
+  }
+  flags = fcntl(fd, F_GETFL, 0);
+  GPR_ASSERT(fcntl(fd, F_SETFL, flags | O_NONBLOCK) == 0);
+
+  gpr_free(buf);
+}
+
+static ssize_t drain_socket(int fd) {
+  ssize_t read_bytes;
+  ssize_t total_bytes = 0;
+  unsigned char buf[256];
+  int current = 0;
+  int i;
+  do {
+    read_bytes = read(fd, buf, 256);
+    if (read_bytes > 0) {
+      total_bytes += read_bytes;
+      for (i = 0; i < read_bytes; ++i) {
+        GPR_ASSERT(buf[i] == current);
+        current = (current + 1) % 256;
+      }
+    }
+  } while (read_bytes >= 0 || errno == EINTR);
+  GPR_ASSERT(errno == EAGAIN);
+  return total_bytes;
+}
+
+/* Write to a socket using the grpc_tcp API, then drain it directly.
+   Note that if the write does not complete immediately we need to drain the
+   socket in parallel with the read. */
+static void write_test(ssize_t num_bytes, ssize_t slice_size) {
+  int sv[2];
+  grpc_em em;
+  grpc_endpoint *ep;
+  struct write_socket_state state;
+  ssize_t read_bytes;
+  size_t num_blocks;
+  gpr_slice *slices;
+  int current_data = 0;
+  gpr_timespec rel_deadline = {20, 0};
+  gpr_timespec deadline = gpr_time_add(gpr_now(), rel_deadline);
+
+  gpr_log(GPR_INFO, "Start write test with %d bytes, slice size %d", num_bytes,
+          slice_size);
+
+  create_sockets(sv);
+  grpc_em_init(&em);
+
+  ep = grpc_tcp_create(sv[1], &em);
+
+  gpr_mu_init(&state.mu);
+  gpr_cv_init(&state.cv);
+  state.ep = ep;
+  state.write_done = 0;
+
+  slices = allocate_blocks(num_bytes, slice_size, &num_blocks, &current_data);
+
+  if (grpc_endpoint_write(ep, slices, num_blocks, write_done, &state,
+                          gpr_inf_future) == GRPC_ENDPOINT_WRITE_DONE) {
+    /* Write completed immediately */
+    read_bytes = drain_socket(sv[0]);
+    GPR_ASSERT(read_bytes == num_bytes);
+  } else {
+    drain_socket_blocking(sv[0], num_bytes, num_bytes);
+    gpr_mu_lock(&state.mu);
+    for (;;) {
+      if (state.write_done) {
+        break;
+      }
+      GPR_ASSERT(gpr_cv_wait(&state.cv, &state.mu, deadline) == 0);
+    }
+    gpr_mu_unlock(&state.mu);
+  }
+
+  grpc_endpoint_destroy(ep);
+  grpc_em_destroy(&em);
+  gpr_mu_destroy(&state.mu);
+  gpr_cv_destroy(&state.cv);
+  gpr_free(slices);
+}
+
+static void read_done_for_write_error(void *ud, gpr_slice *slices,
+                                      size_t nslices,
+                                      grpc_endpoint_cb_status error) {
+  GPR_ASSERT(error != GRPC_ENDPOINT_CB_OK);
+  GPR_ASSERT(nslices == 0);
+}
+
+/* Write to a socket using the grpc_tcp API, then drain it directly.
+   Note that if the write does not complete immediately we need to drain the
+   socket in parallel with the read. */
+static void write_error_test(ssize_t num_bytes, ssize_t slice_size) {
+  int sv[2];
+  grpc_em em;
+  grpc_endpoint *ep;
+  struct write_socket_state state;
+  size_t num_blocks;
+  gpr_slice *slices;
+  int current_data = 0;
+  gpr_timespec rel_deadline = {20, 0};
+  gpr_timespec deadline = gpr_time_add(gpr_now(), rel_deadline);
+
+  gpr_log(GPR_INFO, "Start write error test with %d bytes, slice size %d",
+          num_bytes, slice_size);
+
+  create_sockets(sv);
+  grpc_em_init(&em);
+
+  ep = grpc_tcp_create(sv[1], &em);
+  close(sv[0]);
+
+  gpr_mu_init(&state.mu);
+  gpr_cv_init(&state.cv);
+  state.ep = ep;
+  state.write_done = 0;
+
+  slices = allocate_blocks(num_bytes, slice_size, &num_blocks, &current_data);
+
+  switch (grpc_endpoint_write(ep, slices, num_blocks, write_done, &state,
+                              gpr_inf_future)) {
+    case GRPC_ENDPOINT_WRITE_DONE:
+    case GRPC_ENDPOINT_WRITE_ERROR:
+      /* Write completed immediately */
+      break;
+    case GRPC_ENDPOINT_WRITE_PENDING:
+      grpc_endpoint_notify_on_read(ep, read_done_for_write_error, NULL,
+                                   gpr_inf_future);
+      gpr_mu_lock(&state.mu);
+      for (;;) {
+        if (state.write_done) {
+          break;
+        }
+        GPR_ASSERT(gpr_cv_wait(&state.cv, &state.mu, deadline) == 0);
+      }
+      gpr_mu_unlock(&state.mu);
+      break;
+  }
+
+  grpc_endpoint_destroy(ep);
+  grpc_em_destroy(&em);
+  gpr_mu_destroy(&state.mu);
+  gpr_cv_destroy(&state.cv);
+  free(slices);
+}
+
+void run_tests() {
+  int i = 0;
+
+  read_test(100, 8192);
+  read_test(10000, 8192);
+  read_test(10000, 137);
+  read_test(10000, 1);
+  large_read_test(8192);
+  large_read_test(1);
+
+  write_test(100, 8192);
+  write_test(100, 1);
+  write_test(100000, 8192);
+  write_test(100000, 1);
+  write_test(100000, 137);
+
+  for (i = 1; i < 1000; i = GPR_MAX(i + 1, i * 5 / 4)) {
+    write_error_test(40320, i);
+  }
+
+  for (i = 1; i < 1000; i = GPR_MAX(i + 1, i * 5 / 4)) {
+    write_test(40320, i);
+  }
+}
+
+static void clean_up() { grpc_em_destroy(&g_em); }
+
+static grpc_endpoint_test_fixture create_fixture_tcp_socketpair(
+    ssize_t slice_size) {
+  int sv[2];
+  grpc_endpoint_test_fixture f;
+
+  create_sockets(sv);
+  grpc_em_init(&g_em);
+  f.client_ep = grpc_tcp_create_dbg(sv[0], &g_em, slice_size);
+  f.server_ep = grpc_tcp_create(sv[1], &g_em);
+
+  return f;
+}
+
+static grpc_endpoint_test_config configs[] = {
+    {"tcp/tcp_socketpair", create_fixture_tcp_socketpair, clean_up},
+};
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  /* disable SIGPIPE */
+  signal(SIGPIPE, SIG_IGN);
+  run_tests();
+  grpc_endpoint_tests(configs[0]);
+
+  return 0;
+}
diff --git a/test/core/eventmanager/em_pipe_test.c b/test/core/eventmanager/em_pipe_test.c
new file mode 100644
index 0000000..5411142
--- /dev/null
+++ b/test/core/eventmanager/em_pipe_test.c
@@ -0,0 +1,200 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/* Test grpc_em_fd with pipe. The test creates a pipe with non-blocking mode,
+   sends a stream of bytes through the pipe, and verifies that all bytes are
+   received. */
+#include "src/core/eventmanager/em.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#include <grpc/support/log.h>
+#include "test/core/util/test_config.h"
+
+/* Operation for fcntl() to set pipe buffer size. */
+#ifndef F_SETPIPE_SZ
+#define F_SETPIPE_SZ (1024 + 7)
+#endif
+
+#define TOTAL_WRITE 3 /* total number of times that the write buffer is full. \
+                         */
+#define BUF_SIZE 1024
+char read_buf[BUF_SIZE];
+char write_buf[BUF_SIZE];
+
+typedef struct {
+  int fd[2];
+  grpc_em em;
+  grpc_em_fd read_em_fd;
+  grpc_em_fd write_em_fd;
+  int num_write; /* number of times that the write buffer is full*/
+  ssize_t bytes_written_total; /* total number of bytes written to the pipe */
+  ssize_t bytes_read_total;    /* total number of bytes read from the pipe */
+  pthread_mutex_t mu;          /* protect cv and done */
+  pthread_cond_t cv;           /* signaled when read finished */
+  int done;                    /* set to 1 when read finished */
+} async_pipe;
+
+void write_shutdown_cb(void *arg, /*async_pipe*/
+                       enum grpc_em_cb_status status) {
+  async_pipe *ap = arg;
+  close(ap->fd[1]);
+  grpc_em_fd_destroy(&ap->write_em_fd);
+}
+
+void write_cb(void *arg, /*async_pipe*/ enum grpc_em_cb_status status) {
+  async_pipe *ap = arg;
+  ssize_t bytes_written = 0;
+
+  if (status == GRPC_CALLBACK_CANCELLED) {
+    write_shutdown_cb(arg, GRPC_CALLBACK_SUCCESS);
+    return;
+  }
+
+  do {
+    bytes_written = write(ap->fd[1], write_buf, BUF_SIZE);
+    if (bytes_written > 0) ap->bytes_written_total += bytes_written;
+  } while (bytes_written > 0);
+
+  if (errno == EAGAIN) {
+    if (ap->num_write < TOTAL_WRITE) {
+      ap->num_write++;
+      grpc_em_fd_notify_on_write(&ap->write_em_fd, write_cb, ap,
+                                 gpr_inf_future);
+    } else {
+      /* Note that this could just shut down directly; doing a trip through the
+         shutdown path serves only a demonstration of the API. */
+      grpc_em_fd_shutdown(&ap->write_em_fd);
+      grpc_em_fd_notify_on_write(&ap->write_em_fd, write_cb, ap,
+                                 gpr_inf_future);
+    }
+  } else {
+    GPR_ASSERT(0 && strcat("unknown errno: ", strerror(errno)));
+  }
+}
+
+void read_shutdown_cb(void *arg, /*async_pipe*/ enum grpc_em_cb_status status) {
+  async_pipe *ap = arg;
+  close(ap->fd[0]);
+  grpc_em_fd_destroy(&ap->read_em_fd);
+  pthread_mutex_lock(&ap->mu);
+  if (ap->done == 0) {
+    ap->done = 1;
+    pthread_cond_signal(&ap->cv);
+  }
+  pthread_mutex_unlock(&ap->mu);
+}
+
+void read_cb(void *arg, /*async_pipe*/ enum grpc_em_cb_status status) {
+  async_pipe *ap = arg;
+  ssize_t bytes_read = 0;
+
+  if (status == GRPC_CALLBACK_CANCELLED) {
+    read_shutdown_cb(arg, GRPC_CALLBACK_SUCCESS);
+    return;
+  }
+
+  do {
+    bytes_read = read(ap->fd[0], read_buf, BUF_SIZE);
+    if (bytes_read > 0) ap->bytes_read_total += bytes_read;
+  } while (bytes_read > 0);
+
+  if (bytes_read == 0) {
+    /* Note that this could just shut down directly; doing a trip through the
+       shutdown path serves only a demonstration of the API. */
+    grpc_em_fd_shutdown(&ap->read_em_fd);
+    grpc_em_fd_notify_on_read(&ap->read_em_fd, read_cb, ap, gpr_inf_future);
+  } else if (bytes_read == -1) {
+    if (errno == EAGAIN) {
+      grpc_em_fd_notify_on_read(&ap->read_em_fd, read_cb, ap, gpr_inf_future);
+    } else {
+      GPR_ASSERT(0 && strcat("unknown errno: ", strerror(errno)));
+    }
+  }
+}
+
+void dummy_cb(void *arg, /*async_pipe*/ enum grpc_em_cb_status status) {}
+
+void async_pipe_init(async_pipe *ap) {
+  int i;
+
+  ap->num_write = 0;
+  ap->bytes_written_total = 0;
+  ap->bytes_read_total = 0;
+
+  pthread_mutex_init(&ap->mu, NULL);
+  pthread_cond_init(&ap->cv, NULL);
+  ap->done = 0;
+
+  GPR_ASSERT(0 == pipe(ap->fd));
+  for (i = 0; i < 2; i++) {
+    int flags = fcntl(ap->fd[i], F_GETFL, 0);
+    GPR_ASSERT(fcntl(ap->fd[i], F_SETFL, flags | O_NONBLOCK) == 0);
+    GPR_ASSERT(fcntl(ap->fd[i], F_SETPIPE_SZ, 4096) == 4096);
+  }
+
+  grpc_em_init(&ap->em);
+  grpc_em_fd_init(&ap->read_em_fd, &ap->em, ap->fd[0]);
+  grpc_em_fd_init(&ap->write_em_fd, &ap->em, ap->fd[1]);
+}
+
+static void async_pipe_start(async_pipe *ap) {
+  grpc_em_fd_notify_on_read(&ap->read_em_fd, read_cb, ap, gpr_inf_future);
+  grpc_em_fd_notify_on_write(&ap->write_em_fd, write_cb, ap, gpr_inf_future);
+}
+
+static void async_pipe_wait_destroy(async_pipe *ap) {
+  pthread_mutex_lock(&ap->mu);
+  while (!ap->done) pthread_cond_wait(&ap->cv, &ap->mu);
+  pthread_mutex_unlock(&ap->mu);
+  pthread_mutex_destroy(&ap->mu);
+  pthread_cond_destroy(&ap->cv);
+
+  grpc_em_destroy(&ap->em);
+}
+
+int main(int argc, char **argv) {
+  async_pipe ap;
+  grpc_test_init(argc, argv);
+  async_pipe_init(&ap);
+  async_pipe_start(&ap);
+  async_pipe_wait_destroy(&ap);
+  GPR_ASSERT(ap.bytes_read_total == ap.bytes_written_total);
+  gpr_log(GPR_INFO, "read total bytes %d", ap.bytes_read_total);
+  return 0;
+}
diff --git a/test/core/eventmanager/em_test.c b/test/core/eventmanager/em_test.c
new file mode 100644
index 0000000..2bcfe86
--- /dev/null
+++ b/test/core/eventmanager/em_test.c
@@ -0,0 +1,725 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/* Test gRPC event manager with a simple TCP upload server and client. */
+#include "src/core/eventmanager/em.h"
+
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <netinet/in.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/time.h>
+#include "test/core/util/test_config.h"
+
+/* buffer size used to send and receive data.
+   1024 is the minimal value to set TCP send and receive buffer. */
+#define BUF_SIZE 1024
+
+/* Create a test socket with the right properties for testing.
+   port is the TCP port to listen or connect to.
+   Return a socket FD and sockaddr_in. */
+static void create_test_socket(int port, int *socket_fd,
+                               struct sockaddr_in *sin) {
+  int fd;
+  int one = 1;
+  int buf_size = BUF_SIZE;
+  int flags;
+
+  fd = socket(AF_INET, SOCK_STREAM, 0);
+  setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
+  /* Reset the size of socket send buffer to the minimal value to facilitate
+     buffer filling up and triggering notify_on_write  */
+  GPR_ASSERT(
+      setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &buf_size, sizeof(buf_size)) != -1);
+  GPR_ASSERT(
+      setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &buf_size, sizeof(buf_size)) != -1);
+  /* Make fd non-blocking */
+  flags = fcntl(fd, F_GETFL, 0);
+  GPR_ASSERT(fcntl(fd, F_SETFL, flags | O_NONBLOCK) == 0);
+  *socket_fd = fd;
+
+  /* Use local address for test */
+  sin->sin_family = AF_INET;
+  sin->sin_addr.s_addr = 0;
+  sin->sin_port = htons(port);
+}
+
+/* Dummy gRPC callback */
+void no_op_cb(void *arg, enum grpc_em_cb_status status) {}
+
+/* =======An upload server to test notify_on_read===========
+   The server simply reads and counts a stream of bytes. */
+
+/* An upload server. */
+typedef struct {
+  grpc_em em;               /* event manger used by the sever */
+  grpc_em_fd em_fd;         /* listening fd */
+  ssize_t read_bytes_total; /* total number of received bytes */
+  gpr_mu mu;                /* protect done and done_cv */
+  gpr_cv done_cv;           /* signaled when a server finishes serving */
+  int done;                 /* set to 1 when a server finishes serving */
+} server;
+
+static void server_init(server *sv) {
+  GPR_ASSERT(grpc_em_init(&sv->em) == GRPC_EM_OK);
+  sv->read_bytes_total = 0;
+  gpr_mu_init(&sv->mu);
+  gpr_cv_init(&sv->done_cv);
+  sv->done = 0;
+}
+
+/* An upload session.
+   Created when a new upload request arrives in the server. */
+typedef struct {
+  server *sv;              /* not owned by a single session */
+  grpc_em_fd em_fd;        /* fd to read upload bytes */
+  char read_buf[BUF_SIZE]; /* buffer to store upload bytes */
+} session;
+
+/* Called when an upload session can be safely shutdown.
+   Close session FD and start to shutdown listen FD. */
+static void session_shutdown_cb(void *arg, /*session*/
+                                enum grpc_em_cb_status status) {
+  session *se = arg;
+  server *sv = se->sv;
+  grpc_em_fd_destroy(&se->em_fd);
+  gpr_free(se);
+  /* Start to shutdown listen fd. */
+  grpc_em_fd_shutdown(&sv->em_fd);
+}
+
+/* Called when data become readable in a session. */
+static void session_read_cb(void *arg, /*session*/
+                            enum grpc_em_cb_status status) {
+  session *se = arg;
+  int fd = grpc_em_fd_get(&se->em_fd);
+
+  ssize_t read_once = 0;
+  ssize_t read_total = 0;
+
+  if (status == GRPC_CALLBACK_CANCELLED) {
+    close(fd);
+    session_shutdown_cb(arg, GRPC_CALLBACK_SUCCESS);
+    return;
+  }
+
+  do {
+    read_once = read(fd, se->read_buf, BUF_SIZE);
+    if (read_once > 0) read_total += read_once;
+  } while (read_once > 0);
+  se->sv->read_bytes_total += read_total;
+
+  /* read() returns 0 to indicate the TCP connection was closed by the client.
+     read(fd, read_buf, 0) also returns 0 which should never be called as such.
+     It is possible to read nothing due to spurious edge event or data has
+     been drained, In such a case, read() returns -1 and set errno to EAGAIN. */
+  if (read_once == 0) {
+    grpc_em_fd_shutdown(&se->em_fd);
+    grpc_em_fd_notify_on_read(&se->em_fd, session_read_cb, se, gpr_inf_future);
+  } else if (read_once == -1) {
+    if (errno == EAGAIN) {
+      /* An edge triggered event is cached in the kernel until next poll.
+         In the current single thread implementation, session_read_cb is called
+         in the polling thread, such that polling only happens after this
+         callback, and will catch read edge event if data is available again
+         before notify_on_read.
+         TODO(chenw): in multi-threaded version, callback and polling can be
+         run in different threads. polling may catch a persist read edge event
+         before notify_on_read is called.  */
+      GPR_ASSERT(grpc_em_fd_notify_on_read(&se->em_fd, session_read_cb, se,
+                                           gpr_inf_future) == GRPC_EM_OK);
+    } else {
+      gpr_log(GPR_ERROR, "Unhandled read error %s", strerror(errno));
+      GPR_ASSERT(0);
+    }
+  }
+}
+
+/* Called when the listen FD can be safely shutdown.
+   Close listen FD and signal that server can be shutdown. */
+static void listen_shutdown_cb(void *arg /*server*/,
+                               enum grpc_em_cb_status status) {
+  server *sv = arg;
+
+  close(grpc_em_fd_get(&sv->em_fd));
+  grpc_em_fd_destroy(&sv->em_fd);
+
+  gpr_mu_lock(&sv->mu);
+  sv->done = 1;
+  gpr_cv_signal(&sv->done_cv);
+  gpr_mu_unlock(&sv->mu);
+}
+
+/* Called when a new TCP connection request arrives in the listening port. */
+static void listen_cb(void *arg, /*=sv_arg*/
+                      enum grpc_em_cb_status status) {
+  server *sv = arg;
+  int fd;
+  int flags;
+  session *se;
+  struct sockaddr_storage ss;
+  socklen_t slen = sizeof(ss);
+  struct grpc_em_fd *listen_em_fd = &sv->em_fd;
+
+  if (status == GRPC_CALLBACK_CANCELLED) {
+    listen_shutdown_cb(arg, GRPC_CALLBACK_SUCCESS);
+    return;
+  }
+
+  fd = accept(grpc_em_fd_get(listen_em_fd), (struct sockaddr *)&ss, &slen);
+  GPR_ASSERT(fd >= 0);
+  GPR_ASSERT(fd < FD_SETSIZE);
+  flags = fcntl(fd, F_GETFL, 0);
+  fcntl(fd, F_SETFL, flags | O_NONBLOCK);
+  se = gpr_malloc(sizeof(*se));
+  se->sv = sv;
+  GPR_ASSERT(grpc_em_fd_init(&se->em_fd, &sv->em, fd) == GRPC_EM_OK);
+  GPR_ASSERT(grpc_em_fd_notify_on_read(&se->em_fd, session_read_cb, se,
+                                       gpr_inf_future) == GRPC_EM_OK);
+
+  GPR_ASSERT(grpc_em_fd_notify_on_read(listen_em_fd, listen_cb, sv,
+                                       gpr_inf_future) == GRPC_EM_OK);
+}
+
+/* Max number of connections pending to be accepted by listen(). */
+#define MAX_NUM_FD 1024
+
+/* Start a test server, return the TCP listening port bound to listen_fd.
+   listen_cb() is registered to be interested in reading from listen_fd.
+   When connection request arrives, listen_cb() is called to accept the
+   connection request. */
+static int server_start(server *sv) {
+  int port = 0;
+  int fd;
+  struct sockaddr_in sin;
+  socklen_t addr_len;
+
+  create_test_socket(port, &fd, &sin);
+  addr_len = sizeof(sin);
+  GPR_ASSERT(bind(fd, (struct sockaddr *)&sin, addr_len) == 0);
+  GPR_ASSERT(getsockname(fd, (struct sockaddr *)&sin, &addr_len) == GRPC_EM_OK);
+  port = ntohs(sin.sin_port);
+  GPR_ASSERT(listen(fd, MAX_NUM_FD) == 0);
+
+  GPR_ASSERT(grpc_em_fd_init(&sv->em_fd, &sv->em, fd) == GRPC_EM_OK);
+  /* Register to be interested in reading from listen_fd. */
+  GPR_ASSERT(grpc_em_fd_notify_on_read(&sv->em_fd, listen_cb, sv,
+                                       gpr_inf_future) == GRPC_EM_OK);
+
+  return port;
+}
+
+/* Wait and shutdown a sever. */
+static void server_wait_and_shutdown(server *sv) {
+  gpr_mu_lock(&sv->mu);
+  while (!sv->done) gpr_cv_wait(&sv->done_cv, &sv->mu, gpr_inf_future);
+  gpr_mu_unlock(&sv->mu);
+
+  gpr_mu_destroy(&sv->mu);
+  gpr_cv_destroy(&sv->done_cv);
+
+  GPR_ASSERT(grpc_em_destroy(&sv->em) == GRPC_EM_OK);
+}
+
+/* ===An upload client to test notify_on_write=== */
+
+/* Client write buffer size */
+#define CLIENT_WRITE_BUF_SIZE 10
+/* Total number of times that the client fills up the write buffer */
+#define CLIENT_TOTAL_WRITE_CNT 3
+
+/* An upload client. */
+typedef struct {
+  grpc_em em;
+  grpc_em_fd em_fd;
+  char write_buf[CLIENT_WRITE_BUF_SIZE];
+  ssize_t write_bytes_total;
+  /* Number of times that the client fills up the write buffer and calls
+     notify_on_write to schedule another write. */
+  int client_write_cnt;
+
+  gpr_mu mu;      /* protect done and done_cv */
+  gpr_cv done_cv; /* signaled when a client finishes sending */
+  int done;       /* set to 1 when a client finishes sending */
+} client;
+
+static void client_init(client *cl) {
+  GPR_ASSERT(grpc_em_init(&cl->em) == GRPC_EM_OK);
+  memset(cl->write_buf, 0, sizeof(cl->write_buf));
+  cl->write_bytes_total = 0;
+  cl->client_write_cnt = 0;
+  gpr_mu_init(&cl->mu);
+  gpr_cv_init(&cl->done_cv);
+  cl->done = 0;
+}
+
+/* Called when a client upload session is ready to shutdown. */
+static void client_session_shutdown_cb(void *arg /*client*/,
+                                       enum grpc_em_cb_status status) {
+  client *cl = arg;
+  grpc_em_fd_destroy(&cl->em_fd);
+  gpr_mu_lock(&cl->mu);
+  cl->done = 1;
+  gpr_cv_signal(&cl->done_cv);
+  gpr_mu_unlock(&cl->mu);
+}
+
+/* Write as much as possible, then register notify_on_write. */
+static void client_session_write(void *arg, /*client*/
+                                 enum grpc_em_cb_status status) {
+  client *cl = arg;
+  int fd = grpc_em_fd_get(&cl->em_fd);
+  ssize_t write_once = 0;
+
+  if (status == GRPC_CALLBACK_CANCELLED) {
+    client_session_shutdown_cb(arg, GRPC_CALLBACK_SUCCESS);
+    return;
+  }
+
+  do {
+    write_once = write(fd, cl->write_buf, CLIENT_WRITE_BUF_SIZE);
+    if (write_once > 0) cl->write_bytes_total += write_once;
+  } while (write_once > 0);
+
+  if (errno == EAGAIN) {
+    gpr_mu_lock(&cl->mu);
+    if (cl->client_write_cnt < CLIENT_TOTAL_WRITE_CNT) {
+      GPR_ASSERT(grpc_em_fd_notify_on_write(&cl->em_fd, client_session_write,
+                                            cl, gpr_inf_future) == GRPC_EM_OK);
+      cl->client_write_cnt++;
+    } else {
+      close(fd);
+      grpc_em_fd_shutdown(&cl->em_fd);
+      grpc_em_fd_notify_on_write(&cl->em_fd, client_session_write, cl,
+                                 gpr_inf_future);
+    }
+    gpr_mu_unlock(&cl->mu);
+  } else {
+    gpr_log(GPR_ERROR, "unknown errno %s", strerror(errno));
+    GPR_ASSERT(0);
+  }
+}
+
+/* Start a client to send a stream of bytes. */
+static void client_start(client *cl, int port) {
+  int fd;
+  struct sockaddr_in sin;
+  create_test_socket(port, &fd, &sin);
+  if (connect(fd, (struct sockaddr *)&sin, sizeof(sin)) == -1 &&
+      errno != EINPROGRESS) {
+    gpr_log(GPR_ERROR, "Failed to connect to the server");
+    GPR_ASSERT(0);
+  }
+
+  GPR_ASSERT(grpc_em_fd_init(&cl->em_fd, &cl->em, fd) == GRPC_EM_OK);
+
+  client_session_write(cl, GRPC_CALLBACK_SUCCESS);
+}
+
+/* Wait for the signal to shutdown a client. */
+static void client_wait_and_shutdown(client *cl) {
+  gpr_mu_lock(&cl->mu);
+  while (!cl->done) gpr_cv_wait(&cl->done_cv, &cl->mu, gpr_inf_future);
+  gpr_mu_unlock(&cl->mu);
+
+  gpr_mu_destroy(&cl->mu);
+  gpr_cv_destroy(&cl->done_cv);
+
+  GPR_ASSERT(grpc_em_destroy(&cl->em) == GRPC_EM_OK);
+}
+
+/* Test grpc_em_fd. Start an upload server and client, upload a stream of
+   bytes from the client to the server, and verify that the total number of
+   sent bytes is equal to the total number of received bytes. */
+static void test_grpc_em_fd() {
+  server sv;
+  client cl;
+  int port;
+
+  server_init(&sv);
+  port = server_start(&sv);
+  client_init(&cl);
+  client_start(&cl, port);
+  client_wait_and_shutdown(&cl);
+  server_wait_and_shutdown(&sv);
+  GPR_ASSERT(sv.read_bytes_total == cl.write_bytes_total);
+  gpr_log(GPR_INFO, "Total read bytes %d", sv.read_bytes_total);
+}
+
+typedef struct fd_change_data {
+  gpr_mu mu;
+  gpr_cv cv;
+  void (*cb_that_ran)(void *, enum grpc_em_cb_status);
+} fd_change_data;
+
+void init_change_data(fd_change_data *fdc) {
+  gpr_mu_init(&fdc->mu);
+  gpr_cv_init(&fdc->cv);
+  fdc->cb_that_ran = NULL;
+}
+
+void destroy_change_data(fd_change_data *fdc) {
+  gpr_mu_destroy(&fdc->mu);
+  gpr_cv_destroy(&fdc->cv);
+}
+
+static void first_read_callback(void *arg /* fd_change_data */,
+                                enum grpc_em_cb_status status) {
+  fd_change_data *fdc = arg;
+
+  gpr_mu_lock(&fdc->mu);
+  fdc->cb_that_ran = first_read_callback;
+  gpr_cv_signal(&fdc->cv);
+  gpr_mu_unlock(&fdc->mu);
+}
+
+static void second_read_callback(void *arg /* fd_change_data */,
+                                 enum grpc_em_cb_status status) {
+  fd_change_data *fdc = arg;
+
+  gpr_mu_lock(&fdc->mu);
+  fdc->cb_that_ran = second_read_callback;
+  gpr_cv_signal(&fdc->cv);
+  gpr_mu_unlock(&fdc->mu);
+}
+
+/* Test that changing the callback we use for notify_on_read actually works.
+   Note that we have two different but almost identical callbacks above -- the
+   point is to have two different function pointers and two different data
+   pointers and make sure that changing both really works. */
+static void test_grpc_em_fd_change() {
+  grpc_em em;
+  grpc_em_fd em_fd;
+  fd_change_data a, b;
+  int flags;
+  int sv[2];
+  char data;
+  int result;
+
+  init_change_data(&a);
+  init_change_data(&b);
+
+  GPR_ASSERT(socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == 0);
+  flags = fcntl(sv[0], F_GETFL, 0);
+  GPR_ASSERT(fcntl(sv[0], F_SETFL, flags | O_NONBLOCK) == 0);
+  flags = fcntl(sv[1], F_GETFL, 0);
+  GPR_ASSERT(fcntl(sv[1], F_SETFL, flags | O_NONBLOCK) == 0);
+
+  grpc_em_init(&em);
+  grpc_em_fd_init(&em_fd, &em, sv[0]);
+
+  /* Register the first callback, then make its FD readable */
+  grpc_em_fd_notify_on_read(&em_fd, first_read_callback, &a, gpr_inf_future);
+  data = 0;
+  result = write(sv[1], &data, 1);
+  GPR_ASSERT(result == 1);
+
+  /* And now wait for it to run. */
+  gpr_mu_lock(&a.mu);
+  while (a.cb_that_ran == NULL) {
+    gpr_cv_wait(&a.cv, &a.mu, gpr_inf_future);
+  }
+  GPR_ASSERT(a.cb_that_ran == first_read_callback);
+  gpr_mu_unlock(&a.mu);
+
+  /* And drain the socket so we can generate a new read edge */
+  result = read(sv[0], &data, 1);
+  GPR_ASSERT(result == 1);
+
+  /* Now register a second callback with distinct change data, and do the same
+     thing again. */
+  grpc_em_fd_notify_on_read(&em_fd, second_read_callback, &b, gpr_inf_future);
+  data = 0;
+  result = write(sv[1], &data, 1);
+  GPR_ASSERT(result == 1);
+
+  gpr_mu_lock(&b.mu);
+  while (b.cb_that_ran == NULL) {
+    gpr_cv_wait(&b.cv, &b.mu, gpr_inf_future);
+  }
+  /* Except now we verify that second_read_callback ran instead */
+  GPR_ASSERT(b.cb_that_ran == second_read_callback);
+  gpr_mu_unlock(&b.mu);
+
+  grpc_em_fd_destroy(&em_fd);
+  grpc_em_destroy(&em);
+  destroy_change_data(&a);
+  destroy_change_data(&b);
+  close(sv[0]);
+  close(sv[1]);
+}
+
+void timeout_callback(void *arg, enum grpc_em_cb_status status) {
+  if (status == GRPC_CALLBACK_TIMED_OUT) {
+    gpr_event_set(arg, (void *)1);
+  } else {
+    gpr_event_set(arg, (void *)2);
+  }
+}
+
+void test_grpc_em_fd_notify_timeout() {
+  grpc_em em;
+  grpc_em_fd em_fd;
+  gpr_event ev;
+  int flags;
+  int sv[2];
+  gpr_timespec timeout;
+  gpr_timespec deadline;
+
+  gpr_event_init(&ev);
+
+  GPR_ASSERT(socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == 0);
+  flags = fcntl(sv[0], F_GETFL, 0);
+  GPR_ASSERT(fcntl(sv[0], F_SETFL, flags | O_NONBLOCK) == 0);
+  flags = fcntl(sv[1], F_GETFL, 0);
+  GPR_ASSERT(fcntl(sv[1], F_SETFL, flags | O_NONBLOCK) == 0);
+
+  grpc_em_init(&em);
+  grpc_em_fd_init(&em_fd, &em, sv[0]);
+
+  timeout = gpr_time_from_micros(1000000);
+  deadline = gpr_time_add(gpr_now(), timeout);
+
+  grpc_em_fd_notify_on_read(&em_fd, timeout_callback, &ev, deadline);
+
+  GPR_ASSERT(gpr_event_wait(&ev, gpr_time_add(deadline, timeout)));
+
+  GPR_ASSERT(gpr_event_get(&ev) == (void *)1);
+  grpc_em_fd_destroy(&em_fd);
+  grpc_em_destroy(&em);
+  close(sv[0]);
+  close(sv[1]);
+}
+
+typedef struct {
+  grpc_em *em;
+  gpr_cv cv;
+  gpr_mu mu;
+  int counter;
+  int done_success_ctr;
+  int done_cancel_ctr;
+  int done;
+  gpr_event fcb_arg;
+  grpc_em_cb_status status;
+} alarm_arg;
+
+static void followup_cb(void *arg, grpc_em_cb_status status) {
+  gpr_event_set((gpr_event *)arg, arg);
+}
+
+/* Called when an alarm expires. */
+static void alarm_cb(void *arg /* alarm_arg */, grpc_em_cb_status status) {
+  alarm_arg *a = arg;
+  gpr_mu_lock(&a->mu);
+  if (status == GRPC_CALLBACK_SUCCESS) {
+    a->counter++;
+    a->done_success_ctr++;
+  } else if (status == GRPC_CALLBACK_CANCELLED) {
+    a->done_cancel_ctr++;
+  } else {
+    GPR_ASSERT(0);
+  }
+  a->done = 1;
+  a->status = status;
+  gpr_cv_signal(&a->cv);
+  gpr_mu_unlock(&a->mu);
+  grpc_em_add_callback(a->em, followup_cb, &a->fcb_arg);
+}
+
+/* Test grpc_em_alarm add and cancel. */
+static void test_grpc_em_alarm() {
+  struct grpc_em em;
+  struct grpc_em_alarm alarm;
+  struct grpc_em_alarm alarm_to_cancel;
+  gpr_timespec tv0 = {0, 1};
+  /* Timeout on the alarm cond. var, so make big enough to absorb time
+     deviations. Otherwise, operations after wait will not be properly ordered
+   */
+  gpr_timespec tv1 = gpr_time_from_micros(200000);
+  gpr_timespec tv2 = {0, 1};
+  gpr_timespec alarm_deadline;
+  gpr_timespec followup_deadline;
+
+  alarm_arg *cancel_arg = NULL;
+  alarm_arg arg;
+  alarm_arg arg2;
+  void *fdone;
+
+  GPR_ASSERT(grpc_em_init(&em) == GRPC_EM_OK);
+
+  arg.em = &em;
+  arg.counter = 0;
+  arg.status = GRPC_CALLBACK_DO_NOT_USE;
+  arg.done_success_ctr = 0;
+  arg.done_cancel_ctr = 0;
+  arg.done = 0;
+  gpr_mu_init(&arg.mu);
+  gpr_cv_init(&arg.cv);
+  gpr_event_init(&arg.fcb_arg);
+
+  GPR_ASSERT(grpc_em_alarm_init(&alarm, &em, alarm_cb, &arg) == GRPC_EM_OK);
+  GPR_ASSERT(grpc_em_alarm_add(&alarm, gpr_time_add(tv0, gpr_now())) ==
+             GRPC_EM_OK);
+
+  alarm_deadline = gpr_time_add(gpr_now(), tv1);
+  gpr_mu_lock(&arg.mu);
+  while (arg.done == 0) {
+    gpr_cv_wait(&arg.cv, &arg.mu, alarm_deadline);
+  }
+  gpr_mu_unlock(&arg.mu);
+
+  followup_deadline = gpr_time_add(gpr_now(), tv1);
+  fdone = gpr_event_wait(&arg.fcb_arg, followup_deadline);
+
+  if (arg.counter != 1) {
+    gpr_log(GPR_ERROR, "Alarm callback not called");
+    GPR_ASSERT(0);
+  } else if (arg.done_success_ctr != 1) {
+    gpr_log(GPR_ERROR, "Alarm done callback not called with success");
+    GPR_ASSERT(0);
+  } else if (arg.done_cancel_ctr != 0) {
+    gpr_log(GPR_ERROR, "Alarm done callback called with cancel");
+    GPR_ASSERT(0);
+  } else if (arg.status == GRPC_CALLBACK_DO_NOT_USE) {
+    gpr_log(GPR_ERROR, "Alarm callback without status");
+    GPR_ASSERT(0);
+  } else {
+    gpr_log(GPR_INFO, "Alarm callback called successfully");
+  }
+
+  if (fdone != (void *)&arg.fcb_arg) {
+    gpr_log(GPR_ERROR, "Followup callback #1 not invoked properly %p %p", fdone,
+            &arg.fcb_arg);
+    GPR_ASSERT(0);
+  }
+  gpr_cv_destroy(&arg.cv);
+  gpr_mu_destroy(&arg.mu);
+
+  arg2.em = &em;
+  arg2.counter = 0;
+  arg2.status = GRPC_CALLBACK_DO_NOT_USE;
+  arg2.done_success_ctr = 0;
+  arg2.done_cancel_ctr = 0;
+  arg2.done = 0;
+  gpr_mu_init(&arg2.mu);
+  gpr_cv_init(&arg2.cv);
+  gpr_event_init(&arg2.fcb_arg);
+
+  GPR_ASSERT(grpc_em_alarm_init(&alarm_to_cancel, &em, alarm_cb, &arg2) ==
+             GRPC_EM_OK);
+  GPR_ASSERT(grpc_em_alarm_add(&alarm_to_cancel,
+                               gpr_time_add(tv2, gpr_now())) == GRPC_EM_OK);
+  switch (grpc_em_alarm_cancel(&alarm_to_cancel, (void **)&cancel_arg)) {
+    case GRPC_EM_OK:
+      gpr_log(GPR_INFO, "Alarm cancel succeeded");
+      break;
+    case GRPC_EM_ERROR:
+      gpr_log(GPR_ERROR, "Alarm cancel failed");
+      GPR_ASSERT(0);
+      break;
+    case GRPC_EM_INVALID_ARGUMENTS:
+      gpr_log(GPR_ERROR, "Alarm cancel failed with bad response code");
+      gpr_log(GPR_ERROR, "Current value of triggered is %d\n",
+              (int)alarm_to_cancel.triggered);
+      GPR_ASSERT(0);
+      break;
+  }
+
+  alarm_deadline = gpr_time_add(gpr_now(), tv1);
+  gpr_mu_lock(&arg2.mu);
+  while (arg2.done == 0) {
+    gpr_cv_wait(&arg2.cv, &arg2.mu, alarm_deadline);
+  }
+  gpr_mu_unlock(&arg2.mu);
+
+  followup_deadline = gpr_time_add(gpr_now(), tv1);
+  fdone = gpr_event_wait(&arg2.fcb_arg, followup_deadline);
+
+  if (arg2.counter != arg2.done_success_ctr) {
+    gpr_log(GPR_ERROR, "Alarm callback called but didn't lead to done success");
+    GPR_ASSERT(0);
+  } else if (arg2.done_success_ctr && arg2.done_cancel_ctr) {
+    gpr_log(GPR_ERROR, "Alarm done callback called with success and cancel");
+    GPR_ASSERT(0);
+  } else if (arg2.done_cancel_ctr + arg2.done_success_ctr != 1) {
+    gpr_log(GPR_ERROR, "Alarm done callback called incorrect number of times");
+    GPR_ASSERT(0);
+  } else if (arg2.status == GRPC_CALLBACK_DO_NOT_USE) {
+    gpr_log(GPR_ERROR, "Alarm callback without status");
+    GPR_ASSERT(0);
+  } else if (arg2.done_success_ctr) {
+    gpr_log(GPR_INFO, "Alarm callback executed before cancel");
+    gpr_log(GPR_INFO, "Current value of triggered is %d\n",
+            (int)alarm_to_cancel.triggered);
+  } else if (arg2.done_cancel_ctr) {
+    gpr_log(GPR_INFO, "Alarm callback canceled");
+    gpr_log(GPR_INFO, "Current value of triggered is %d\n",
+            (int)alarm_to_cancel.triggered);
+  } else {
+    gpr_log(GPR_ERROR, "Alarm cancel test should not be here");
+    GPR_ASSERT(0);
+  }
+
+  if (cancel_arg != &arg2) {
+    gpr_log(GPR_ERROR, "Alarm cancel arg address wrong");
+    GPR_ASSERT(0);
+  }
+  if (fdone != (void *)&arg2.fcb_arg) {
+    gpr_log(GPR_ERROR, "Followup callback #2 not invoked properly %p %p", fdone,
+            &arg2.fcb_arg);
+    GPR_ASSERT(0);
+  }
+  gpr_cv_destroy(&arg2.cv);
+  gpr_mu_destroy(&arg2.mu);
+
+  GPR_ASSERT(grpc_em_destroy(&em) == GRPC_EM_OK);
+}
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  test_grpc_em_alarm();
+  test_grpc_em_fd();
+  test_grpc_em_fd_change();
+  test_grpc_em_fd_notify_timeout();
+  return 0;
+}
diff --git a/test/core/fling/client.c b/test/core/fling/client.c
new file mode 100644
index 0000000..cc661c3
--- /dev/null
+++ b/test/core/fling/client.c
@@ -0,0 +1,196 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <grpc/grpc.h>
+
+#include <stdio.h>
+#include <string.h>
+
+#include <grpc/support/cmdline.h>
+#include <grpc/support/histogram.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include <grpc/support/useful.h>
+#include "test/core/util/grpc_profiler.h"
+#include "test/core/util/test_config.h"
+
+static gpr_histogram *histogram;
+static grpc_byte_buffer *the_buffer;
+static grpc_channel *channel;
+static grpc_completion_queue *cq;
+static grpc_call *call;
+
+static void init_ping_pong_request() {}
+
+static void step_ping_pong_request() {
+  call = grpc_channel_create_call(channel, "/Reflector/reflectUnary",
+                                  "localhost", gpr_inf_future);
+  GPR_ASSERT(grpc_call_start_invoke(call, cq, (void *)1, (void *)1, (void *)1,
+                                    GRPC_WRITE_BUFFER_HINT) == GRPC_CALL_OK);
+  grpc_event_finish(grpc_completion_queue_next(cq, gpr_inf_future));
+  GPR_ASSERT(grpc_call_start_write(call, the_buffer, (void *)1,
+                                   GRPC_WRITE_BUFFER_HINT) == GRPC_CALL_OK);
+  grpc_event_finish(grpc_completion_queue_next(cq, gpr_inf_future));
+  GPR_ASSERT(grpc_call_start_read(call, (void *)1) == GRPC_CALL_OK);
+  GPR_ASSERT(grpc_call_writes_done(call, (void *)1) == GRPC_CALL_OK);
+  grpc_event_finish(grpc_completion_queue_next(cq, gpr_inf_future));
+  grpc_event_finish(grpc_completion_queue_next(cq, gpr_inf_future));
+  grpc_event_finish(grpc_completion_queue_next(cq, gpr_inf_future));
+  grpc_event_finish(grpc_completion_queue_next(cq, gpr_inf_future));
+  grpc_call_destroy(call);
+  call = NULL;
+}
+
+static void init_ping_pong_stream() {
+  call = grpc_channel_create_call(channel, "/Reflector/reflectStream",
+                                  "localhost", gpr_inf_future);
+  GPR_ASSERT(grpc_call_start_invoke(call, cq, (void *)1, (void *)1, (void *)1,
+                                    0) == GRPC_CALL_OK);
+  grpc_event_finish(grpc_completion_queue_next(cq, gpr_inf_future));
+  grpc_event_finish(grpc_completion_queue_next(cq, gpr_inf_future));
+}
+
+static void step_ping_pong_stream() {
+  GPR_ASSERT(grpc_call_start_write(call, the_buffer, (void *)1, 0) ==
+             GRPC_CALL_OK);
+  GPR_ASSERT(grpc_call_start_read(call, (void *)1) == GRPC_CALL_OK);
+  grpc_event_finish(grpc_completion_queue_next(cq, gpr_inf_future));
+  grpc_event_finish(grpc_completion_queue_next(cq, gpr_inf_future));
+}
+
+static double now() {
+  gpr_timespec tv = gpr_now();
+  return 1e9 * tv.tv_sec + tv.tv_nsec;
+}
+
+typedef struct {
+  const char *name;
+  void (*init)();
+  void (*do_one_step)();
+} scenario;
+
+static const scenario scenarios[] = {
+    {"ping-pong-request", init_ping_pong_request, step_ping_pong_request},
+    {"ping-pong-stream", init_ping_pong_stream, step_ping_pong_stream},
+};
+
+int main(int argc, char **argv) {
+  gpr_slice slice = gpr_slice_from_copied_string("x");
+  double start, stop;
+  int i;
+
+  char *fake_argv[1];
+
+  int payload_size = 1;
+  int done;
+  int secure = 0;
+  char *target = "localhost:443";
+  gpr_cmdline *cl;
+  char *scenario_name = "ping-pong-request";
+  scenario sc = {NULL};
+
+  GPR_ASSERT(argc >= 1);
+  fake_argv[0] = argv[0];
+  grpc_test_init(1, fake_argv);
+
+  grpc_init();
+
+  cl = gpr_cmdline_create("fling client");
+  gpr_cmdline_add_int(cl, "payload_size", "Size of the payload to send",
+                      &payload_size);
+  gpr_cmdline_add_string(cl, "target", "Target host:port", &target);
+  gpr_cmdline_add_flag(cl, "secure", "Run with security?", &secure);
+  gpr_cmdline_add_string(cl, "scenario", "Scenario", &scenario_name);
+  gpr_cmdline_parse(cl, argc, argv);
+  gpr_cmdline_destroy(cl);
+
+  for (i = 0; i < GPR_ARRAY_SIZE(scenarios); i++) {
+    if (0 == strcmp(scenarios[i].name, scenario_name)) {
+      sc = scenarios[i];
+    }
+  }
+  if (!sc.name) {
+    fprintf(stderr, "unsupported scenario '%s'. Valid are:", scenario_name);
+    for (i = 0; i < GPR_ARRAY_SIZE(scenarios); i++) {
+      fprintf(stderr, " %s", scenarios[i].name);
+    }
+    return 1;
+  }
+
+  channel = grpc_channel_create(target, NULL);
+  cq = grpc_completion_queue_create();
+  the_buffer = grpc_byte_buffer_create(&slice, payload_size);
+  histogram = gpr_histogram_create(0.01, 60e9);
+  sc.init();
+
+  for (i = 0; i < 1000; i++) {
+    sc.do_one_step();
+  }
+
+  gpr_log(GPR_INFO, "start profiling");
+  grpc_profiler_start("client.prof");
+  for (i = 0; i < 100000; i++) {
+    start = now();
+    sc.do_one_step();
+    stop = now();
+    gpr_histogram_add(histogram, stop - start);
+  }
+  grpc_profiler_stop();
+
+  if (call) {
+    grpc_call_destroy(call);
+  }
+
+  grpc_channel_destroy(channel);
+  grpc_completion_queue_shutdown(cq);
+  done = 0;
+  while (!done) {
+    grpc_event *ev = grpc_completion_queue_next(cq, gpr_inf_future);
+    done = (ev->type == GRPC_QUEUE_SHUTDOWN);
+    grpc_event_finish(ev);
+  }
+  grpc_completion_queue_destroy(cq);
+  grpc_byte_buffer_destroy(the_buffer);
+  gpr_slice_unref(slice);
+
+  gpr_log(GPR_INFO, "latency (50/95/99/99.9): %f/%f/%f/%f",
+          gpr_histogram_percentile(histogram, 50),
+          gpr_histogram_percentile(histogram, 95),
+          gpr_histogram_percentile(histogram, 99),
+          gpr_histogram_percentile(histogram, 99.9));
+  gpr_histogram_destroy(histogram);
+
+  grpc_shutdown();
+
+  return 0;
+}
diff --git a/test/core/fling/fling_stream_test.c b/test/core/fling/fling_stream_test.c
new file mode 100644
index 0000000..14a31eb
--- /dev/null
+++ b/test/core/fling/fling_stream_test.c
@@ -0,0 +1,103 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#define _POSIX_SOURCE
+#include <unistd.h>
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/host_port.h>
+#include <grpc/support/string.h>
+#include "test/core/util/port.h"
+
+int main(int argc, char **argv) {
+  char *me = argv[0];
+  char *lslash = strrchr(me, '/');
+  char root[1024];
+  int port = grpc_pick_unused_port_or_die();
+  char *args[10];
+  int status;
+  pid_t svr, cli;
+  /* figure out where we are */
+  if (lslash) {
+    memcpy(root, me, lslash - me);
+    root[lslash - me] = 0;
+  } else {
+    strcpy(root, ".");
+  }
+  /* start the server */
+  svr = fork();
+  if (svr == 0) {
+    gpr_asprintf(&args[0], "%s/fling_server", root);
+    args[1] = "--bind";
+    gpr_join_host_port(&args[2], "::", port);
+    args[3] = "--no-secure";
+    args[4] = 0;
+    execv(args[0], args);
+
+    gpr_free(args[0]);
+    gpr_free(args[2]);
+    return 1;
+  }
+  /* wait a little */
+  sleep(2);
+  /* start the client */
+  cli = fork();
+  if (cli == 0) {
+    gpr_asprintf(&args[0], "%s/fling_client", root);
+    args[1] = "--target";
+    gpr_join_host_port(&args[2], "127.0.0.1", port);
+    args[3] = "--scenario=ping-pong-stream";
+    args[4] = "--no-secure";
+    args[5] = 0;
+    execv(args[0], args);
+
+    gpr_free(args[0]);
+    gpr_free(args[2]);
+    return 1;
+  }
+  /* wait for completion */
+  printf("waiting for client\n");
+  if (waitpid(cli, &status, 0) == -1) return 2;
+  if (!WIFEXITED(status)) return 4;
+  if (WEXITSTATUS(status)) return WEXITSTATUS(status);
+  printf("checking server\n");
+  if (waitpid(svr, &status, WNOHANG) != 0) return 2;
+  kill(svr, SIGKILL);
+  return 0;
+}
diff --git a/test/core/fling/fling_test.c b/test/core/fling/fling_test.c
new file mode 100644
index 0000000..e5e63f9
--- /dev/null
+++ b/test/core/fling/fling_test.c
@@ -0,0 +1,103 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#define _POSIX_SOURCE
+#include <unistd.h>
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/host_port.h>
+#include <grpc/support/string.h>
+#include "test/core/util/port.h"
+
+int main(int argc, char **argv) {
+  char *me = argv[0];
+  char *lslash = strrchr(me, '/');
+  char root[1024];
+  int port = grpc_pick_unused_port_or_die();
+  char *args[10];
+  int status;
+  pid_t svr, cli;
+  /* figure out where we are */
+  if (lslash) {
+    memcpy(root, me, lslash - me);
+    root[lslash - me] = 0;
+  } else {
+    strcpy(root, ".");
+  }
+  /* start the server */
+  svr = fork();
+  if (svr == 0) {
+    gpr_asprintf(&args[0], "%s/fling_server", root);
+    args[1] = "--bind";
+    gpr_join_host_port(&args[2], "::", port);
+    args[3] = "--no-secure";
+    args[4] = 0;
+    execv(args[0], args);
+
+    gpr_free(args[0]);
+    gpr_free(args[2]);
+    return 1;
+  }
+  /* wait a little */
+  sleep(2);
+  /* start the client */
+  cli = fork();
+  if (cli == 0) {
+    gpr_asprintf(&args[0], "%s/fling_client", root);
+    args[1] = "--target";
+    gpr_join_host_port(&args[2], "127.0.0.1", port);
+    args[3] = "--scenario=ping-pong-request";
+    args[4] = "--no-secure";
+    args[5] = 0;
+    execv(args[0], args);
+
+    gpr_free(args[0]);
+    gpr_free(args[2]);
+    return 1;
+  }
+  /* wait for completion */
+  printf("waiting for client\n");
+  if (waitpid(cli, &status, 0) == -1) return 2;
+  if (!WIFEXITED(status)) return 4;
+  if (WEXITSTATUS(status)) return WEXITSTATUS(status);
+  printf("checking server\n");
+  if (waitpid(svr, &status, WNOHANG) != 0) return 2;
+  kill(svr, SIGKILL);
+  return 0;
+}
diff --git a/test/core/fling/server.c b/test/core/fling/server.c
new file mode 100644
index 0000000..7a5d895
--- /dev/null
+++ b/test/core/fling/server.c
@@ -0,0 +1,159 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <grpc/grpc.h>
+
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include "test/core/util/grpc_profiler.h"
+#include "test/core/util/test_config.h"
+#include <grpc/support/alloc.h>
+#include <grpc/support/cmdline.h>
+#include <grpc/support/host_port.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include "test/core/util/port.h"
+
+static grpc_completion_queue *cq;
+static grpc_server *server;
+static int done = 0;
+
+static const grpc_status status_ok = {GRPC_STATUS_OK, NULL};
+
+typedef struct {
+  gpr_refcount pending_ops;
+  gpr_uint32 flags;
+} call_state;
+
+static void request_call() {
+  call_state *s = gpr_malloc(sizeof(call_state));
+  gpr_ref_init(&s->pending_ops, 2);
+  grpc_server_request_call(server, s);
+}
+
+static void sigint_handler(int x) { done = 1; }
+
+int main(int argc, char **argv) {
+  grpc_event *ev;
+  call_state *s;
+  char *addr_buf = NULL;
+  gpr_cmdline *cl;
+
+  int secure = 0;
+  char *addr = NULL;
+
+  char *fake_argv[1];
+
+  GPR_ASSERT(argc >= 1);
+  fake_argv[0] = argv[0];
+  grpc_test_init(1, fake_argv);
+
+  grpc_init();
+  srand(clock());
+
+  cl = gpr_cmdline_create("fling server");
+  gpr_cmdline_add_string(cl, "bind", "Bind host:port", &addr);
+  gpr_cmdline_add_flag(cl, "secure", "Run with security?", &secure);
+  gpr_cmdline_parse(cl, argc, argv);
+  gpr_cmdline_destroy(cl);
+
+  if (addr == NULL) {
+    gpr_join_host_port(&addr_buf, "::", grpc_pick_unused_port_or_die());
+    addr = addr_buf;
+  }
+  gpr_log(GPR_INFO, "creating server on: %s", addr);
+
+  cq = grpc_completion_queue_create();
+  server = grpc_server_create(cq, NULL);
+  GPR_ASSERT(grpc_server_add_http2_port(server, addr));
+  grpc_server_start(server);
+
+  gpr_free(addr_buf);
+  addr = addr_buf = NULL;
+
+  request_call();
+
+  grpc_profiler_start("server.prof");
+  signal(SIGINT, sigint_handler);
+  while (!done) {
+    ev = grpc_completion_queue_next(
+        cq, gpr_time_add(gpr_now(), gpr_time_from_micros(1000000)));
+    if (!ev) continue;
+    s = ev->tag;
+    switch (ev->type) {
+      case GRPC_SERVER_RPC_NEW:
+        /* initial ops are already started in request_call */
+        if (0 == strcmp(ev->data.server_rpc_new.method,
+                        "/Reflector/reflectStream")) {
+          s->flags = 0;
+        } else {
+          s->flags = GRPC_WRITE_BUFFER_HINT;
+        }
+        grpc_call_accept(ev->call, cq, s, s->flags);
+        GPR_ASSERT(grpc_call_start_read(ev->call, s) == GRPC_CALL_OK);
+        request_call();
+        break;
+      case GRPC_WRITE_ACCEPTED:
+        GPR_ASSERT(ev->data.write_accepted == GRPC_OP_OK);
+        GPR_ASSERT(grpc_call_start_read(ev->call, s) == GRPC_CALL_OK);
+        break;
+      case GRPC_READ:
+        if (ev->data.read) {
+          GPR_ASSERT(grpc_call_start_write(ev->call, ev->data.read, s,
+                                           s->flags) == GRPC_CALL_OK);
+        } else {
+          GPR_ASSERT(grpc_call_start_write_status(ev->call, status_ok, s) ==
+                     GRPC_CALL_OK);
+        }
+        break;
+      case GRPC_FINISH_ACCEPTED:
+      case GRPC_FINISHED:
+        if (gpr_unref(&s->pending_ops)) {
+          grpc_call_destroy(ev->call);
+          gpr_free(s);
+        }
+        break;
+      default:
+        abort();
+    }
+    grpc_event_finish(ev);
+  }
+  grpc_profiler_stop();
+
+  grpc_shutdown();
+  return 0;
+}
diff --git a/test/core/httpcli/format_request_test.c b/test/core/httpcli/format_request_test.c
new file mode 100644
index 0000000..12ea7fd
--- /dev/null
+++ b/test/core/httpcli/format_request_test.c
@@ -0,0 +1,166 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/httpcli/format_request.h"
+
+#include <string.h>
+
+#include <grpc/support/log.h>
+#include "test/core/util/test_config.h"
+
+static void test_format_get_request() {
+  grpc_httpcli_header hdr = {"x-yz", "abc"};
+  grpc_httpcli_request req;
+  gpr_slice slice;
+
+
+  memset(&req, 0, sizeof(req));
+  req.host = "example.com";
+  req.path = "/index.html";
+  req.hdr_count = 1;
+  req.hdrs = &hdr;
+
+  slice = grpc_httpcli_format_get_request(&req);
+
+  GPR_ASSERT(0 == gpr_slice_str_cmp(slice,
+                                    "GET /index.html HTTP/1.0\r\n"
+                                    "Host: example.com\r\n"
+                                    "Connection: close\r\n"
+                                    "User-Agent: " GRPC_HTTPCLI_USER_AGENT
+                                    "\r\n"
+                                    "x-yz: abc\r\n"
+                                    "\r\n"));
+
+  gpr_slice_unref(slice);
+}
+
+static void test_format_post_request() {
+  grpc_httpcli_header hdr = {"x-yz", "abc"};
+  grpc_httpcli_request req;
+  gpr_slice slice;
+  char body_bytes[] = "fake body";
+  size_t body_len = 9;
+
+  memset(&req, 0, sizeof(req));
+  req.host = "example.com";
+  req.path = "/index.html";
+  req.hdr_count = 1;
+  req.hdrs = &hdr;
+
+  slice = grpc_httpcli_format_post_request(&req, body_bytes, body_len);
+
+  GPR_ASSERT(0 == gpr_slice_str_cmp(slice,
+                                    "POST /index.html HTTP/1.0\r\n"
+                                    "Host: example.com\r\n"
+                                    "Connection: close\r\n"
+                                    "User-Agent: " GRPC_HTTPCLI_USER_AGENT
+                                    "\r\n"
+                                    "x-yz: abc\r\n"
+                                    "Content-Type: text/plain\r\n"
+                                    "Content-Length: 9\r\n"
+                                    "\r\n"
+                                    "fake body"));
+
+  gpr_slice_unref(slice);
+}
+
+static void test_format_post_request_no_body() {
+  grpc_httpcli_header hdr = {"x-yz", "abc"};
+  grpc_httpcli_request req;
+  gpr_slice slice;
+
+  memset(&req, 0, sizeof(req));
+  req.host = "example.com";
+  req.path = "/index.html";
+  req.hdr_count = 1;
+  req.hdrs = &hdr;
+
+  slice = grpc_httpcli_format_post_request(&req, NULL, 0);
+
+  GPR_ASSERT(0 == gpr_slice_str_cmp(slice,
+                                    "POST /index.html HTTP/1.0\r\n"
+                                    "Host: example.com\r\n"
+                                    "Connection: close\r\n"
+                                    "User-Agent: " GRPC_HTTPCLI_USER_AGENT
+                                    "\r\n"
+                                    "x-yz: abc\r\n"
+                                    "\r\n"));
+
+  gpr_slice_unref(slice);
+}
+
+static void test_format_post_request_content_type_override() {
+  grpc_httpcli_header hdrs[2];
+  grpc_httpcli_request req;
+  gpr_slice slice;
+  char body_bytes[] = "fake%20body";
+  size_t body_len = 11;
+
+  hdrs[0].key = "x-yz";
+  hdrs[0].value = "abc";
+  hdrs[1].key = "Content-Type";
+  hdrs[1].value = "application/x-www-form-urlencoded";
+  memset(&req, 0, sizeof(req));
+  req.host = "example.com";
+  req.path = "/index.html";
+  req.hdr_count = 2;
+  req.hdrs = hdrs;
+
+  slice = grpc_httpcli_format_post_request(&req, body_bytes, body_len);
+
+  GPR_ASSERT(0 == gpr_slice_str_cmp(
+                      slice,
+                      "POST /index.html HTTP/1.0\r\n"
+                      "Host: example.com\r\n"
+                      "Connection: close\r\n"
+                      "User-Agent: " GRPC_HTTPCLI_USER_AGENT
+                      "\r\n"
+                      "x-yz: abc\r\n"
+                      "Content-Type: application/x-www-form-urlencoded\r\n"
+                      "Content-Length: 11\r\n"
+                      "\r\n"
+                      "fake%20body"));
+
+  gpr_slice_unref(slice);
+}
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+
+  test_format_get_request();
+  test_format_post_request();
+  test_format_post_request_no_body();
+  test_format_post_request_content_type_override();
+
+  return 0;
+}
diff --git a/test/core/httpcli/httpcli_test.c b/test/core/httpcli/httpcli_test.c
new file mode 100644
index 0000000..5c0d87c
--- /dev/null
+++ b/test/core/httpcli/httpcli_test.c
@@ -0,0 +1,101 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/httpcli/httpcli.h"
+
+#include <string.h>
+
+#include <grpc/support/log.h>
+#include "test/core/util/test_config.h"
+
+static gpr_event g_done;
+static grpc_em g_em;
+
+static gpr_timespec n_seconds_time(int seconds) {
+  return gpr_time_add(gpr_now(), gpr_time_from_micros(seconds * 1000000));
+}
+
+static void on_finish(void *arg, const grpc_httpcli_response *response) {
+  GPR_ASSERT(arg == (void *)42);
+  GPR_ASSERT(response);
+  GPR_ASSERT(response->status == 200);
+  gpr_event_set(&g_done, (void *)1);
+}
+
+static void test_get(int use_ssl) {
+  grpc_httpcli_request req;
+
+  gpr_log(GPR_INFO, "running %s with use_ssl=%d.", __FUNCTION__, (int)use_ssl);
+
+  gpr_event_init(&g_done);
+  memset(&req, 0, sizeof(req));
+  req.host = "www.google.com";
+  req.path = "/";
+  req.use_ssl = use_ssl;
+
+  grpc_httpcli_get(&req, n_seconds_time(15), &g_em, on_finish, (void *)42);
+  GPR_ASSERT(gpr_event_wait(&g_done, n_seconds_time(20)));
+}
+
+/*
+static void test_post(int use_ssl) {
+  grpc_httpcli_request req;
+
+  gpr_log(GPR_INFO, "running %s with use_ssl=%d.", __FUNCTION__, (int)use_ssl);
+
+  gpr_event_init(&g_done);
+  memset(&req, 0, sizeof(req));
+  req.host = "requestb.in";
+  req.path = "/1eamwr21";
+  req.use_ssl = use_ssl;
+
+  grpc_httpcli_post(&req, NULL, 0, n_seconds_time(15), &g_em, on_finish,
+                    (void *)42);
+  GPR_ASSERT(gpr_event_wait(&g_done, n_seconds_time(20)));
+}
+*/
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  grpc_em_init(&g_em);
+
+  test_get(0);
+  test_get(1);
+
+  /* test_post(0); */
+  /* test_post(1); */
+
+  grpc_em_destroy(&g_em);
+
+  return 0;
+}
diff --git a/test/core/httpcli/parser_test.c b/test/core/httpcli/parser_test.c
new file mode 100644
index 0000000..455f6a6
--- /dev/null
+++ b/test/core/httpcli/parser_test.c
@@ -0,0 +1,155 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/httpcli/parser.h"
+
+#include <stdarg.h>
+#include <string.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/useful.h>
+#include "test/core/util/slice_splitter.h"
+#include "test/core/util/test_config.h"
+
+static void test_succeeds(grpc_slice_split_mode split_mode, char *response,
+                          int expect_status, char *expect_body, ...) {
+  grpc_httpcli_parser parser;
+  gpr_slice input_slice = gpr_slice_from_copied_string(response);
+  size_t num_slices;
+  size_t i;
+  gpr_slice *slices;
+  va_list args;
+
+  grpc_split_slices(split_mode, &input_slice, 1, &slices, &num_slices);
+  gpr_slice_unref(input_slice);
+
+  grpc_httpcli_parser_init(&parser);
+
+  for (i = 0; i < num_slices; i++) {
+    GPR_ASSERT(grpc_httpcli_parser_parse(&parser, slices[i]));
+    gpr_slice_unref(slices[i]);
+  }
+  GPR_ASSERT(grpc_httpcli_parser_eof(&parser));
+
+  GPR_ASSERT(expect_status == parser.r.status);
+  if (expect_body != NULL) {
+    GPR_ASSERT(strlen(expect_body) == parser.r.body_length);
+    GPR_ASSERT(0 == memcmp(expect_body, parser.r.body, parser.r.body_length));
+  } else {
+    GPR_ASSERT(parser.r.body_length == 0);
+  }
+
+  va_start(args, expect_body);
+  i = 0;
+  for (;;) {
+    char *expect_key;
+    char *expect_value;
+    expect_key = va_arg(args, char *);
+    if (!expect_key) break;
+    GPR_ASSERT(i < parser.r.hdr_count);
+    expect_value = va_arg(args, char *);
+    GPR_ASSERT(expect_value);
+    GPR_ASSERT(0 == strcmp(expect_key, parser.r.hdrs[i].key));
+    GPR_ASSERT(0 == strcmp(expect_value, parser.r.hdrs[i].value));
+    i++;
+  }
+  va_end(args);
+  GPR_ASSERT(i == parser.r.hdr_count);
+
+  grpc_httpcli_parser_destroy(&parser);
+  gpr_free(slices);
+}
+
+static void test_fails(grpc_slice_split_mode split_mode, char *response) {
+  grpc_httpcli_parser parser;
+  gpr_slice input_slice = gpr_slice_from_copied_string(response);
+  size_t num_slices;
+  size_t i;
+  gpr_slice *slices;
+  int done = 0;
+
+  grpc_split_slices(split_mode, &input_slice, 1, &slices, &num_slices);
+  gpr_slice_unref(input_slice);
+
+  grpc_httpcli_parser_init(&parser);
+
+  for (i = 0; i < num_slices; i++) {
+    if (!done && !grpc_httpcli_parser_parse(&parser, slices[i])) {
+      done = 1;
+    }
+    gpr_slice_unref(slices[i]);
+  }
+  if (!done && !grpc_httpcli_parser_eof(&parser)) {
+    done = 1;
+  }
+  GPR_ASSERT(done);
+
+  grpc_httpcli_parser_destroy(&parser);
+  gpr_free(slices);
+}
+
+int main(int argc, char **argv) {
+  size_t i;
+  const grpc_slice_split_mode split_modes[] = {GRPC_SLICE_SPLIT_IDENTITY,
+                                               GRPC_SLICE_SPLIT_ONE_BYTE};
+
+  grpc_test_init(argc, argv);
+
+  for (i = 0; i < GPR_ARRAY_SIZE(split_modes); i++) {
+    test_succeeds(split_modes[i],
+                  "HTTP/1.0 200 OK\r\n"
+                  "xyz: abc\r\n"
+                  "\r\n"
+                  "hello world!",
+                  200, "hello world!", "xyz", "abc", NULL);
+    test_succeeds(split_modes[i],
+                  "HTTP/1.0 404 Not Found\r\n"
+                  "\r\n",
+                  404, NULL, NULL);
+    test_succeeds(split_modes[i],
+                  "HTTP/1.1 200 OK\r\n"
+                  "xyz: abc\r\n"
+                  "\r\n"
+                  "hello world!",
+                  200, "hello world!", "xyz", "abc", NULL);
+    test_fails(split_modes[i], "HTTP/1.0\r\n");
+    test_fails(split_modes[i], "HTTP/1.2\r\n");
+    test_fails(split_modes[i], "HTTP/1.0 000 XYX\r\n");
+    test_fails(split_modes[i], "HTTP/1.0 200 OK\n");
+    test_fails(split_modes[i], "HTTP/1.0 200 OK\r\n");
+    test_fails(split_modes[i], "HTTP/1.0 200 OK\r\nFoo x\r\n");
+  }
+
+  return 0;
+}
diff --git a/test/core/network_benchmarks/low_level_ping_pong.c b/test/core/network_benchmarks/low_level_ping_pong.c
new file mode 100644
index 0000000..93c66a9
--- /dev/null
+++ b/test/core/network_benchmarks/low_level_ping_pong.c
@@ -0,0 +1,626 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/*
+   Basic I/O ping-pong benchmarks.
+
+   The goal here is to establish lower bounds on how fast the stack could get by
+   measuring the cost of using various I/O strategies to do a basic
+   request-response loop.
+ */
+
+#include <errno.h>
+#include <netinet/ip.h>
+#include <poll.h>
+#include <stdio.h>
+#include <string.h>
+#ifdef __linux__
+#include <sys/epoll.h>
+#endif
+#include <sys/socket.h>
+
+#include "src/core/endpoint/socket_utils.h"
+#include <grpc/support/cmdline.h>
+#include <grpc/support/histogram.h>
+#include <grpc/support/log.h>
+#include <grpc/support/thd.h>
+#include <grpc/support/time.h>
+
+typedef struct fd_pair {
+  int read_fd;
+  int write_fd;
+} fd_pair;
+
+typedef struct thread_args {
+  fd_pair fds;
+  size_t msg_size;
+  int (*read_bytes)(struct thread_args *args, char *buf);
+  int (*write_bytes)(struct thread_args *args, char *buf);
+  int (*setup)(struct thread_args *args);
+  int epoll_fd;
+} thread_args;
+
+/*
+   Read strategies
+
+   There are a number of read strategies, each of which has a blocking and
+   non-blocking version.
+ */
+
+/* Basic call to read() */
+static int read_bytes(int fd, char *buf, size_t read_size, int spin) {
+  int bytes_read = 0;
+  int err;
+  do {
+    err = read(fd, buf + bytes_read, read_size - bytes_read);
+    if (err < 0) {
+      if (errno == EINTR) {
+        continue;
+      } else {
+        if (errno == EAGAIN && spin == 1) {
+          continue;
+        }
+        gpr_log(GPR_ERROR, "Read failed: %s", strerror(errno));
+        return -1;
+      }
+    } else {
+      bytes_read += err;
+    }
+  } while (bytes_read < read_size);
+  return 0;
+}
+
+static int blocking_read_bytes(thread_args *args, char *buf) {
+  return read_bytes(args->fds.read_fd, buf, args->msg_size, 0);
+}
+
+static int spin_read_bytes(thread_args *args, char *buf) {
+  return read_bytes(args->fds.read_fd, buf, args->msg_size, 1);
+}
+
+/* Call poll() to monitor a non-blocking fd */
+static int poll_read_bytes(int fd, char *buf, size_t read_size, int spin) {
+  struct pollfd pfd;
+  size_t bytes_read = 0;
+  int err;
+
+  pfd.fd = fd;
+  pfd.events = POLLIN;
+  do {
+    err = poll(&pfd, 1, spin ? 0 : -1);
+    if (err < 0) {
+      if (errno == EINTR) {
+        continue;
+      } else {
+        gpr_log(GPR_ERROR, "Poll failed: %s", strerror(errno));
+        return -1;
+      }
+    }
+    if (err == 0 && spin) continue;
+    GPR_ASSERT(err == 1);
+    GPR_ASSERT(pfd.revents == POLLIN);
+    do {
+      err = read(fd, buf + bytes_read, read_size - bytes_read);
+    } while (err < 0 && errno == EINTR);
+    if (err < 0 && errno != EAGAIN) {
+      gpr_log(GPR_ERROR, "Read failed: %s", strerror(errno));
+      return -1;
+    }
+    bytes_read += err;
+  } while (bytes_read < read_size);
+  return 0;
+}
+
+static int poll_read_bytes_blocking(struct thread_args *args, char *buf) {
+  return poll_read_bytes(args->fds.read_fd, buf, args->msg_size, 0);
+}
+
+static int poll_read_bytes_spin(struct thread_args *args, char *buf) {
+  return poll_read_bytes(args->fds.read_fd, buf, args->msg_size, 1);
+}
+
+#ifdef __linux__
+/* Call epoll_wait() to monitor a non-blocking fd */
+static int epoll_read_bytes(struct thread_args *args, char *buf, int spin) {
+  struct epoll_event ev;
+  size_t bytes_read = 0;
+  int err;
+  size_t read_size = args->msg_size;
+
+  do {
+    err = epoll_wait(args->epoll_fd, &ev, 1, spin ? 0 : -1);
+    if (err < 0) {
+      if (errno == EINTR) continue;
+      gpr_log(GPR_ERROR, "epoll_wait failed: %s", strerror(errno));
+      return -1;
+    }
+    if (err == 0 && spin) continue;
+    GPR_ASSERT(err == 1);
+    GPR_ASSERT(ev.events & EPOLLIN);
+    GPR_ASSERT(ev.data.fd == args->fds.read_fd);
+    do {
+      do {
+        err = read(args->fds.read_fd, buf + bytes_read, read_size - bytes_read);
+      } while (err < 0 && errno == EINTR);
+      if (errno == EAGAIN) break;
+      bytes_read += err;
+      /* TODO(klempner): This should really be doing an extra call after we are
+         done to ensure we see an EAGAIN */
+    } while (bytes_read < read_size);
+  } while (bytes_read < read_size);
+  GPR_ASSERT(bytes_read == read_size);
+  return 0;
+}
+
+static int epoll_read_bytes_blocking(struct thread_args *args, char *buf) {
+  return epoll_read_bytes(args, buf, 0);
+}
+
+static int epoll_read_bytes_spin(struct thread_args *args, char *buf) {
+  return epoll_read_bytes(args, buf, 1);
+}
+#endif /* __linux__ */
+
+/* Write out bytes.
+   At this point we only have one strategy, since in the common case these
+   writes go directly out to the kernel.
+ */
+static int blocking_write_bytes(struct thread_args *args, char *buf) {
+  int bytes_written = 0;
+  int err;
+  size_t write_size = args->msg_size;
+  do {
+    err = write(args->fds.write_fd, buf + bytes_written,
+                write_size - bytes_written);
+    if (err < 0) {
+      if (errno == EINTR) {
+        continue;
+      } else {
+        gpr_log(GPR_ERROR, "Read failed: %s", strerror(errno));
+        return -1;
+      }
+    } else {
+      bytes_written += err;
+    }
+  } while (bytes_written < write_size);
+  return 0;
+}
+
+/*
+   Initialization code
+
+   These are called at the beginning of the client and server thread, depending
+   on the scenario we're using.
+ */
+static int set_socket_nonblocking(thread_args *args) {
+  if (!grpc_set_socket_nonblocking(args->fds.read_fd, 1)) {
+    gpr_log(GPR_ERROR, "Unable to set socket nonblocking: %s", strerror(errno));
+    return -1;
+  }
+  if (!grpc_set_socket_nonblocking(args->fds.write_fd, 1)) {
+    gpr_log(GPR_ERROR, "Unable to set socket nonblocking: %s", strerror(errno));
+    return -1;
+  }
+  return 0;
+}
+
+static int do_nothing(thread_args *args) { return 0; }
+
+/* Special case for epoll, where we need to create the fd ahead of time. */
+static int epoll_setup(thread_args *args) {
+  int epoll_fd;
+  struct epoll_event ev;
+  set_socket_nonblocking(args);
+  epoll_fd = epoll_create(1);
+  if (epoll_fd < 0) {
+    gpr_log(GPR_ERROR, "epoll_create: %s", strerror(errno));
+    return -1;
+  }
+
+  args->epoll_fd = epoll_fd;
+
+  ev.events = EPOLLIN | EPOLLET;
+  ev.data.fd = args->fds.read_fd;
+  if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, args->fds.read_fd, &ev) < 0) {
+    gpr_log(GPR_ERROR, "epoll_ctl: %s", strerror(errno));
+  }
+  return 0;
+}
+
+static void server_thread(thread_args *args) {
+  char *buf = malloc(args->msg_size);
+  if (args->setup(args) < 0) {
+    gpr_log(GPR_ERROR, "Setup failed");
+  }
+  for (;;) {
+    if (args->read_bytes(args, buf) < 0) {
+      gpr_log(GPR_ERROR, "Server read failed");
+      free(buf);
+      return;
+    }
+    if (args->write_bytes(args, buf) < 0) {
+      gpr_log(GPR_ERROR, "Server write failed");
+      free(buf);
+      return;
+    }
+  }
+}
+
+static void server_thread_wrap(void *arg) {
+  thread_args *args = arg;
+  server_thread(args);
+}
+
+static void print_histogram(gpr_histogram *histogram) {
+  /* TODO(klempner): Print more detailed information, such as detailed histogram
+     buckets */
+  gpr_log(GPR_INFO, "latency (50/95/99/99.9): %f/%f/%f/%f",
+          gpr_histogram_percentile(histogram, 50),
+          gpr_histogram_percentile(histogram, 95),
+          gpr_histogram_percentile(histogram, 99),
+          gpr_histogram_percentile(histogram, 99.9));
+}
+
+static double now() {
+  gpr_timespec tv = gpr_now();
+  return 1e9 * tv.tv_sec + tv.tv_nsec;
+}
+
+static void client_thread(thread_args *args) {
+  char *buf = calloc(args->msg_size, sizeof(char));
+  gpr_histogram *histogram = gpr_histogram_create(0.01, 60e9);
+  double start_time;
+  double end_time;
+  double interval;
+  const int kNumIters = 100000;
+  int i;
+
+  if (args->setup(args) < 0) {
+    gpr_log(GPR_ERROR, "Setup failed");
+  }
+  for (i = 0; i < kNumIters; ++i) {
+    start_time = now();
+    if (args->write_bytes(args, buf) < 0) {
+      gpr_log(GPR_ERROR, "Client write failed");
+      goto error;
+    }
+    if (args->read_bytes(args, buf) < 0) {
+      gpr_log(GPR_ERROR, "Client read failed");
+      goto error;
+    }
+    end_time = now();
+    if (i > kNumIters / 2) {
+      interval = end_time - start_time;
+      gpr_histogram_add(histogram, interval);
+    }
+  }
+  print_histogram(histogram);
+error:
+  free(buf);
+  gpr_histogram_destroy(histogram);
+}
+
+/* This roughly matches tcp_server's create_listening_socket */
+static int create_listening_socket(struct sockaddr *port, socklen_t len) {
+  int fd = socket(port->sa_family, SOCK_STREAM, 0);
+  if (fd < 0) {
+    gpr_log(GPR_ERROR, "Unable to create socket: %s", strerror(errno));
+    goto error;
+  }
+
+  if (!grpc_set_socket_cloexec(fd, 1) || !grpc_set_socket_low_latency(fd, 1) ||
+      !grpc_set_socket_reuse_addr(fd, 1)) {
+    gpr_log(GPR_ERROR, "Unable to configure socket %d: %s", fd,
+            strerror(errno));
+    goto error;
+  }
+
+  if (bind(fd, port, len) < 0) {
+    gpr_log(GPR_ERROR, "bind: %s", strerror(errno));
+    goto error;
+  }
+
+  if (listen(fd, 1) < 0) {
+    gpr_log(GPR_ERROR, "listen: %s", strerror(errno));
+    goto error;
+  }
+
+  if (getsockname(fd, port, &len) < 0) {
+    gpr_log(GPR_ERROR, "getsockname: %s", strerror(errno));
+    goto error;
+  }
+
+  return fd;
+
+error:
+  if (fd >= 0) {
+    close(fd);
+  }
+  return -1;
+}
+
+static int connect_client(struct sockaddr *addr, int len) {
+  int fd = socket(addr->sa_family, SOCK_STREAM, 0);
+  int err;
+  if (fd < 0) {
+    gpr_log(GPR_ERROR, "Unable to create socket: %s", strerror(errno));
+    goto error;
+  }
+
+  if (!grpc_set_socket_cloexec(fd, 1) || !grpc_set_socket_low_latency(fd, 1)) {
+    gpr_log(GPR_ERROR, "Failed to configure socket");
+    goto error;
+  }
+
+  do {
+    err = connect(fd, addr, len);
+  } while (err < 0 && errno == EINTR);
+
+  if (err < 0) {
+    gpr_log(GPR_ERROR, "connect error: %s", strerror(errno));
+    goto error;
+  }
+  return fd;
+
+error:
+  if (fd >= 0) {
+    close(fd);
+  }
+  return -1;
+}
+
+static int accept_server(int listen_fd) {
+  int fd = accept(listen_fd, NULL, NULL);
+  if (fd < 0) {
+    gpr_log(GPR_ERROR, "Accept failed: %s", strerror(errno));
+    return -1;
+  }
+  return fd;
+}
+
+static int create_sockets_tcp(fd_pair *client_fds, fd_pair *server_fds) {
+  int listen_fd = -1;
+  int client_fd = -1;
+  int server_fd = -1;
+
+  struct sockaddr_in port;
+  struct sockaddr *sa_port = (struct sockaddr *)&port;
+
+  port.sin_family = AF_INET;
+  port.sin_port = 0;
+  port.sin_addr.s_addr = INADDR_ANY;
+
+  listen_fd = create_listening_socket(sa_port, sizeof(port));
+  if (listen_fd == -1) {
+    gpr_log(GPR_ERROR, "Listen failed");
+    goto error;
+  }
+
+  client_fd = connect_client(sa_port, sizeof(port));
+  if (client_fd == -1) {
+    gpr_log(GPR_ERROR, "Connect failed");
+    goto error;
+  }
+
+  server_fd = accept_server(listen_fd);
+  if (server_fd == -1) {
+    gpr_log(GPR_ERROR, "Accept failed");
+    goto error;
+  }
+
+  client_fds->read_fd = client_fd;
+  client_fds->write_fd = client_fd;
+  server_fds->read_fd = server_fd;
+  server_fds->write_fd = server_fd;
+  close(listen_fd);
+  return 0;
+
+error:
+  if (listen_fd != -1) {
+    close(listen_fd);
+  }
+  if (client_fd != -1) {
+    close(client_fd);
+  }
+  if (server_fd != -1) {
+    close(server_fd);
+  }
+  return -1;
+}
+
+static int create_sockets_socketpair(fd_pair *client_fds, fd_pair *server_fds) {
+  int fds[2];
+  if (socketpair(AF_UNIX, SOCK_STREAM, 0, fds) < 0) {
+    gpr_log(GPR_ERROR, "socketpair: %s", strerror(errno));
+    return -1;
+  }
+
+  client_fds->read_fd = fds[0];
+  client_fds->write_fd = fds[0];
+  server_fds->read_fd = fds[1];
+  server_fds->write_fd = fds[1];
+  return 0;
+}
+
+static int create_sockets_pipe(fd_pair *client_fds, fd_pair *server_fds) {
+  int cfds[2];
+  int sfds[2];
+  if (pipe(cfds) < 0) {
+    gpr_log(GPR_ERROR, "pipe: %s", strerror(errno));
+    return -1;
+  }
+
+  if (pipe(sfds) < 0) {
+    gpr_log(GPR_ERROR, "pipe: %s", strerror(errno));
+    return -1;
+  }
+
+  client_fds->read_fd = cfds[0];
+  client_fds->write_fd = cfds[1];
+  server_fds->read_fd = sfds[0];
+  server_fds->write_fd = sfds[1];
+  return 0;
+}
+
+static const char *read_strategy_usage =
+    "Strategy for doing reads, which is one of:\n"
+    "  blocking: blocking read calls\n"
+    "  same_thread_poll: poll() call on same thread \n"
+#ifdef __linux__
+    "  same_thread_epoll: epoll_wait() on same thread \n"
+#endif
+    "  spin_read: spinning non-blocking read() calls \n"
+    "  spin_poll: spinning 0 timeout poll() calls \n"
+#ifdef __linux__
+    "  spin_epoll: spinning 0 timeout epoll_wait() calls \n"
+#endif
+    "";
+
+static const char *socket_type_usage =
+    "Type of socket used, one of:\n"
+    "  tcp: fds are endpoints of a TCP connection\n"
+    "  socketpair: fds come from socketpair()\n"
+    "  pipe: fds come from pipe()\n";
+
+void print_usage(char *argv0) {
+  fprintf(stderr, "%s usage:\n\n", argv0);
+  fprintf(stderr, "%s read_strategy socket_type msg_size\n\n", argv0);
+  fprintf(stderr, "where read_strategy is one of:\n");
+  fprintf(stderr, "  blocking: blocking read calls\n");
+  fprintf(stderr, "  same_thread_poll: poll() call on same thread \n");
+#ifdef __linux__
+  fprintf(stderr, "  same_thread_epoll: epoll_wait() on same thread \n");
+#endif
+  fprintf(stderr, "  spin_read: spinning non-blocking read() calls \n");
+  fprintf(stderr, "  spin_poll: spinning 0 timeout poll() calls \n");
+#ifdef __linux__
+  fprintf(stderr, "  spin_epoll: spinning 0 timeout epoll_wait() calls \n");
+#endif
+  fprintf(stderr, "and socket_type is one of:\n");
+  fprintf(stderr, "  tcp: fds are endpoints of a TCP connection\n");
+  fprintf(stderr, "  socketpair: fds come from socketpair()\n");
+  fprintf(stderr, "  pipe: fds come from pipe()\n");
+}
+
+typedef struct test_strategy {
+  char *name;
+  int (*read_strategy)(struct thread_args *args, char *buf);
+  int (*setup)(struct thread_args *args);
+} test_strategy;
+
+static test_strategy test_strategies[] = {
+    {"blocking", blocking_read_bytes, do_nothing},
+    {"same_thread_poll", poll_read_bytes_blocking, set_socket_nonblocking},
+#ifdef __linux__
+    {"same_thread_epoll", epoll_read_bytes_blocking, epoll_setup},
+    {"spin_epoll", epoll_read_bytes_spin, epoll_setup},
+#endif /* __linux__ */
+    {"spin_read", spin_read_bytes, set_socket_nonblocking},
+    {"spin_poll", poll_read_bytes_spin, set_socket_nonblocking}};
+
+int main(int argc, char **argv) {
+  gpr_thd_id tid;
+  thread_args *client_args = malloc(sizeof(thread_args));
+  thread_args *server_args = malloc(sizeof(thread_args));
+  int msg_size = -1;
+  char *read_strategy = NULL;
+  char *socket_type = NULL;
+  int i;
+  const test_strategy *test_strategy = NULL;
+
+  gpr_cmdline *cmdline =
+      gpr_cmdline_create("low_level_ping_pong network benchmarking tool");
+
+  gpr_cmdline_add_int(cmdline, "msg_size", "Size of sent messages", &msg_size);
+  gpr_cmdline_add_string(cmdline, "read_strategy", read_strategy_usage,
+                         &read_strategy);
+  gpr_cmdline_add_string(cmdline, "socket_type", socket_type_usage,
+                         &socket_type);
+
+  gpr_cmdline_parse(cmdline, argc, argv);
+
+  if (read_strategy == NULL) {
+    read_strategy = "blocking";
+  }
+  if (socket_type == NULL) {
+    socket_type = "tcp";
+  }
+  if (msg_size == -1) {
+    msg_size = 50;
+  }
+
+  for (i = 0; i < sizeof(test_strategies) / sizeof(struct test_strategy); ++i) {
+    if (!strcmp(test_strategies[i].name, read_strategy)) {
+      test_strategy = &test_strategies[i];
+    }
+  }
+  if (test_strategy == NULL) {
+    fprintf(stderr, "Invalid read strategy %s\n", read_strategy);
+    return -1;
+  }
+
+  client_args->read_bytes = test_strategy->read_strategy;
+  client_args->write_bytes = blocking_write_bytes;
+  client_args->setup = test_strategy->setup;
+  server_args->read_bytes = test_strategy->read_strategy;
+  server_args->write_bytes = blocking_write_bytes;
+  server_args->setup = test_strategy->setup;
+
+  if (strcmp(socket_type, "tcp") == 0) {
+    create_sockets_tcp(&client_args->fds, &server_args->fds);
+  } else if (strcmp(socket_type, "socketpair") == 0) {
+    create_sockets_socketpair(&client_args->fds, &server_args->fds);
+  } else if (strcmp(socket_type, "pipe") == 0) {
+    create_sockets_pipe(&client_args->fds, &server_args->fds);
+  } else {
+    fprintf(stderr, "Invalid socket type %s\n", socket_type);
+    return -1;
+  }
+
+  if (msg_size <= 0) {
+    fprintf(stderr, "msg_size must be > 0\n");
+    print_usage(argv[0]);
+    return -1;
+  }
+
+  server_args->msg_size = msg_size;
+  client_args->msg_size = msg_size;
+
+  gpr_log(GPR_INFO, "Starting test %s %s %d", read_strategy, socket_type,
+          msg_size);
+
+  gpr_thd_new(&tid, server_thread_wrap, server_args, NULL);
+  client_thread(client_args);
+  gpr_cmdline_destroy(cmdline);
+  return 0;
+}
diff --git a/test/core/security/credentials_test.c b/test/core/security/credentials_test.c
new file mode 100644
index 0000000..260b39b
--- /dev/null
+++ b/test/core/security/credentials_test.c
@@ -0,0 +1,167 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/security/credentials.h"
+
+#include "src/core/httpcli/httpcli.h"
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include "test/core/util/test_config.h"
+
+#include <string.h>
+
+static grpc_httpcli_response http_response(int status, char *body) {
+  grpc_httpcli_response response;
+  memset(&response, 0, sizeof(grpc_httpcli_response));
+  response.status = status;
+  response.body = body;
+  response.body_length = strlen(body);
+  return response;
+}
+
+static void test_compute_engine_creds_parsing_ok(void) {
+  grpc_mdctx *ctx = grpc_mdctx_create();
+  grpc_mdelem *token_elem = NULL;
+  gpr_timespec token_lifetime;
+  grpc_httpcli_response response =
+      http_response(200,
+                    "{\"access_token\":\"ya29.AHES6ZRN3-HlhAPya30GnW_bHSb_\","
+                    " \"expires_in\":3599, "
+                    " \"token_type\":\"Bearer\"}");
+  GPR_ASSERT(grpc_compute_engine_credentials_parse_server_response(
+                 &response, ctx, &token_elem, &token_lifetime) ==
+             GRPC_CREDENTIALS_OK);
+  GPR_ASSERT(token_lifetime.tv_sec == 3599);
+  GPR_ASSERT(token_lifetime.tv_nsec == 0);
+  GPR_ASSERT(!strcmp(grpc_mdstr_as_c_string(token_elem->key), "Authorization"));
+  GPR_ASSERT(!strcmp(grpc_mdstr_as_c_string(token_elem->value),
+                     "Bearer ya29.AHES6ZRN3-HlhAPya30GnW_bHSb_"));
+  grpc_mdelem_unref(token_elem);
+  grpc_mdctx_orphan(ctx);
+}
+
+static void test_compute_engine_creds_parsing_bad_http_status(void) {
+  grpc_mdctx *ctx = grpc_mdctx_create();
+  grpc_mdelem *token_elem = NULL;
+  gpr_timespec token_lifetime;
+  grpc_httpcli_response response =
+      http_response(401,
+                    "{\"access_token\":\"ya29.AHES6ZRN3-HlhAPya30GnW_bHSb_\","
+                    " \"expires_in\":3599, "
+                    " \"token_type\":\"Bearer\"}");
+  GPR_ASSERT(grpc_compute_engine_credentials_parse_server_response(
+                 &response, ctx, &token_elem, &token_lifetime) ==
+             GRPC_CREDENTIALS_ERROR);
+  grpc_mdctx_orphan(ctx);
+}
+
+static void test_compute_engine_creds_parsing_empty_http_body(void) {
+  grpc_mdctx *ctx = grpc_mdctx_create();
+  grpc_mdelem *token_elem = NULL;
+  gpr_timespec token_lifetime;
+  grpc_httpcli_response response = http_response(200, "");
+  GPR_ASSERT(grpc_compute_engine_credentials_parse_server_response(
+                 &response, ctx, &token_elem, &token_lifetime) ==
+             GRPC_CREDENTIALS_ERROR);
+  grpc_mdctx_orphan(ctx);
+}
+
+static void test_compute_engine_creds_parsing_invalid_json(void) {
+  grpc_mdctx *ctx = grpc_mdctx_create();
+  grpc_mdelem *token_elem = NULL;
+  gpr_timespec token_lifetime;
+  grpc_httpcli_response response =
+      http_response(200,
+                    "{\"access_token\":\"ya29.AHES6ZRN3-HlhAPya30GnW_bHSb_\","
+                    " \"expires_in\":3599, "
+                    " \"token_type\":\"Bearer\"");
+  GPR_ASSERT(grpc_compute_engine_credentials_parse_server_response(
+                 &response, ctx, &token_elem, &token_lifetime) ==
+             GRPC_CREDENTIALS_ERROR);
+  grpc_mdctx_orphan(ctx);
+}
+
+static void test_compute_engine_creds_parsing_missing_token(void) {
+  grpc_mdctx *ctx = grpc_mdctx_create();
+  grpc_mdelem *token_elem = NULL;
+  gpr_timespec token_lifetime;
+  grpc_httpcli_response response = http_response(200,
+                                                 "{"
+                                                 " \"expires_in\":3599, "
+                                                 " \"token_type\":\"Bearer\"}");
+  GPR_ASSERT(grpc_compute_engine_credentials_parse_server_response(
+                 &response, ctx, &token_elem, &token_lifetime) ==
+             GRPC_CREDENTIALS_ERROR);
+  grpc_mdctx_orphan(ctx);
+}
+
+static void test_compute_engine_creds_parsing_missing_token_type(void) {
+  grpc_mdctx *ctx = grpc_mdctx_create();
+  grpc_mdelem *token_elem = NULL;
+  gpr_timespec token_lifetime;
+  grpc_httpcli_response response =
+      http_response(200,
+                    "{\"access_token\":\"ya29.AHES6ZRN3-HlhAPya30GnW_bHSb_\","
+                    " \"expires_in\":3599, "
+                    "}");
+  GPR_ASSERT(grpc_compute_engine_credentials_parse_server_response(
+                 &response, ctx, &token_elem, &token_lifetime) ==
+             GRPC_CREDENTIALS_ERROR);
+  grpc_mdctx_orphan(ctx);
+}
+
+static void test_compute_engine_creds_parsing_missing_token_lifetime(void) {
+  grpc_mdctx *ctx = grpc_mdctx_create();
+  grpc_mdelem *token_elem = NULL;
+  gpr_timespec token_lifetime;
+  grpc_httpcli_response response =
+      http_response(200,
+                    "{\"access_token\":\"ya29.AHES6ZRN3-HlhAPya30GnW_bHSb_\","
+                    " \"token_type\":\"Bearer\"}");
+  GPR_ASSERT(grpc_compute_engine_credentials_parse_server_response(
+                 &response, ctx, &token_elem, &token_lifetime) ==
+             GRPC_CREDENTIALS_ERROR);
+  grpc_mdctx_orphan(ctx);
+}
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  test_compute_engine_creds_parsing_ok();
+  test_compute_engine_creds_parsing_bad_http_status();
+  test_compute_engine_creds_parsing_empty_http_body();
+  test_compute_engine_creds_parsing_invalid_json();
+  test_compute_engine_creds_parsing_missing_token();
+  test_compute_engine_creds_parsing_missing_token_type();
+  test_compute_engine_creds_parsing_missing_token_lifetime();
+  return 0;
+}
diff --git a/test/core/statistics/census_stub_test.c b/test/core/statistics/census_stub_test.c
new file mode 100644
index 0000000..7d85550
--- /dev/null
+++ b/test/core/statistics/census_stub_test.c
@@ -0,0 +1,75 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "src/core/statistics/census_interface.h"
+#include "src/core/statistics/census_rpc_stats.h"
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include "test/core/util/test_config.h"
+
+/* Tests census noop stubs in a simulated rpc flow */
+void test_census_stubs() {
+  census_op_id op_id;
+  census_rpc_stats* stats = census_rpc_stats_create_empty();
+  census_aggregated_rpc_stats data_map;
+  /* Initializes census library at server start up time. */
+  census_init();
+  /* Starts tracing at the beginning of a rpc. */
+  op_id = census_tracing_start_op();
+  /* Appends custom annotations on a trace object. */
+  census_tracing_print(op_id, "annotation foo");
+  census_tracing_print(op_id, "annotation bar");
+  /* Appends method tag on the trace object. */
+  census_add_method_tag(op_id, "service_foo/method.bar");
+  /* Either record client side stats or server side stats associated with the
+     op_id. Here for testing purpose, we record both. */
+  census_record_rpc_client_stats(op_id, stats);
+  census_record_rpc_server_stats(op_id, stats);
+  /* Ends a tracing. */
+  census_tracing_end_op(op_id);
+  /* In process stats queries. */
+  census_get_server_stats(&data_map);
+  census_get_client_stats(&data_map);
+  census_aggregated_rpc_stats_destroy(&data_map);
+  gpr_free(stats);
+  census_shutdown();
+}
+
+int main(int argc, char** argv) {
+  grpc_test_init(argc, argv);
+  test_census_stubs();
+  return 0;
+}
diff --git a/test/core/statistics/hash_table_test.c b/test/core/statistics/hash_table_test.c
new file mode 100644
index 0000000..fb75de5
--- /dev/null
+++ b/test/core/statistics/hash_table_test.c
@@ -0,0 +1,288 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "src/core/statistics/hash_table.h"
+
+#include "src/core/support/murmur_hash.h"
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include "test/core/util/test_config.h"
+
+static gpr_uint64 hash64(const void* k) {
+  size_t len = strlen(k);
+  gpr_uint64 higher = gpr_murmur_hash3((const char*)k, len / 2, 0);
+  return higher << 32 |
+         gpr_murmur_hash3((const char*)(k) + len / 2, len - len / 2, 0);
+}
+
+static int cmp_str_keys(const void* k1, const void* k2) {
+  return strcmp((const char*)k1, (const char*)k2);
+}
+
+static gpr_uint64 force_collision(const void* k) {
+  return (1997 + hash64(k) % 3);
+}
+
+static void free_data(void* data) { gpr_free(data); }
+
+/* Basic tests that empty hash table can be created and destroyed. */
+static void test_create_table() {
+  /* Create table with uint64 key type */
+  census_ht* ht = NULL;
+  census_ht_option ht_options = {CENSUS_HT_UINT64, 1999, NULL, NULL, NULL,
+                                 NULL};
+  ht = census_ht_create(&ht_options);
+  GPR_ASSERT(ht != NULL);
+  GPR_ASSERT(census_ht_get_size(ht) == 0);
+  census_ht_destroy(ht);
+  /* Create table with pointer key type */
+  ht = NULL;
+  ht_options.key_type = CENSUS_HT_POINTER;
+  ht_options.hash = &hash64;
+  ht_options.compare_keys = &cmp_str_keys;
+  ht = census_ht_create(&ht_options);
+  GPR_ASSERT(ht != NULL);
+  GPR_ASSERT(census_ht_get_size(ht) == 0);
+  census_ht_destroy(ht);
+}
+
+static void test_table_with_int_key() {
+  census_ht_option opt = {CENSUS_HT_UINT64, 7, NULL, NULL, NULL, NULL};
+  census_ht* ht = census_ht_create(&opt);
+  gpr_uint64 i = 0;
+  gpr_uint64 sum_of_keys = 0;
+  size_t num_elements;
+  census_ht_kv* elements = NULL;
+  GPR_ASSERT(ht != NULL);
+  GPR_ASSERT(census_ht_get_size(ht) == 0);
+  elements = census_ht_get_all_elements(ht, &num_elements);
+  GPR_ASSERT(num_elements == 0);
+  GPR_ASSERT(elements == NULL);
+  for (i = 0; i < 20; ++i) {
+    census_ht_key key;
+    key.val = i;
+    census_ht_insert(ht, key, (void*)i);
+    GPR_ASSERT(census_ht_get_size(ht) == i + 1);
+  }
+  for (i = 0; i < 20; i++) {
+    gpr_uint64* val = NULL;
+    census_ht_key key;
+    key.val = i;
+    val = census_ht_find(ht, key);
+    GPR_ASSERT(val == (void*)i);
+  }
+  elements = census_ht_get_all_elements(ht, &num_elements);
+  GPR_ASSERT(elements != NULL);
+  GPR_ASSERT(num_elements == 20);
+  for (i = 0; i < num_elements; i++) {
+    sum_of_keys += elements[i].k.val;
+  }
+  GPR_ASSERT(sum_of_keys == 190);
+  gpr_free(elements);
+  census_ht_destroy(ht);
+}
+
+/* Test that there is no memory leak when keys and values are owned by table. */
+static void test_value_and_key_deleter() {
+  census_ht_option opt = {CENSUS_HT_POINTER, 7, &hash64, &cmp_str_keys,
+                          &free_data, &free_data};
+  census_ht* ht = census_ht_create(&opt);
+  census_ht_key key;
+  char* val;
+  key.ptr = gpr_malloc(100);
+  val = gpr_malloc(10);
+  strcpy(val, "value");
+  strcpy(key.ptr, "some string as a key");
+  GPR_ASSERT(ht != NULL);
+  GPR_ASSERT(census_ht_get_size(ht) == 0);
+  census_ht_insert(ht, key, val);
+  GPR_ASSERT(census_ht_get_size(ht) == 1);
+  census_ht_destroy(ht);
+}
+
+/* Test simple insert and erase operations. */
+static void test_simple_add_and_erase() {
+  census_ht_option opt = {CENSUS_HT_UINT64, 7, NULL, NULL, NULL, NULL};
+  census_ht* ht = census_ht_create(&opt);
+  GPR_ASSERT(ht != NULL);
+  GPR_ASSERT(census_ht_get_size(ht) == 0);
+  {
+    census_ht_key key;
+    int val = 3;
+    key.val = 2;
+    census_ht_insert(ht, key, (void*)&val);
+    GPR_ASSERT(census_ht_get_size(ht) == 1);
+    census_ht_erase(ht, key);
+    GPR_ASSERT(census_ht_get_size(ht) == 0);
+    /* Erasing a key from an empty table should be noop. */
+    census_ht_erase(ht, key);
+    GPR_ASSERT(census_ht_get_size(ht) == 0);
+    /* Erasing a non-existant key from a table should be noop. */
+    census_ht_insert(ht, key, (void*)&val);
+    key.val = 3;
+    census_ht_insert(ht, key, (void*)&val);
+    key.val = 9;
+    census_ht_insert(ht, key, (void*)&val);
+    GPR_ASSERT(census_ht_get_size(ht) == 3);
+    key.val = 1;
+    census_ht_erase(ht, key);
+    /* size unchanged after deleting non-existant key. */
+    GPR_ASSERT(census_ht_get_size(ht) == 3);
+    /* size decrease by 1 after deleting an existant key. */
+    key.val = 2;
+    census_ht_erase(ht, key);
+    GPR_ASSERT(census_ht_get_size(ht) == 2);
+  }
+  census_ht_destroy(ht);
+}
+
+static void test_insertion_and_deletion_with_high_collision_rate() {
+  census_ht_option opt = {CENSUS_HT_POINTER, 13, &force_collision,
+                          &cmp_str_keys, NULL, NULL};
+  census_ht* ht = census_ht_create(&opt);
+  char key_str[1000][10];
+  gpr_uint64 val = 0;
+  int i = 0;
+  for (i = 0; i < 1000; i++) {
+    census_ht_key key;
+    key.ptr = key_str[i];
+    sprintf(key_str[i], "%d", i);
+    census_ht_insert(ht, key, (void*)(&val));
+    printf("%d\n", i);
+    GPR_ASSERT(census_ht_get_size(ht) == (i + 1));
+  }
+  for (i = 0; i < 1000; i++) {
+    census_ht_key key;
+    key.ptr = key_str[i];
+    census_ht_erase(ht, key);
+    GPR_ASSERT(census_ht_get_size(ht) == (999 - i));
+  }
+  census_ht_destroy(ht);
+}
+
+static void test_table_with_string_key() {
+  census_ht_option opt = {CENSUS_HT_POINTER, 7, &hash64, &cmp_str_keys, NULL,
+                          NULL};
+  census_ht* ht = census_ht_create(&opt);
+  const char* keys[] = {"k1", "a", "000", "apple",
+                        "banana_a_long_long_long_banana", "%$", "111", "foo",
+                        "b"};
+  const int vals[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
+  int i = 0;
+  GPR_ASSERT(ht != NULL);
+  GPR_ASSERT(census_ht_get_size(ht) == 0);
+  for (i = 0; i < 9; i++) {
+    census_ht_key key;
+    key.ptr = (void*)(keys[i]);
+    census_ht_insert(ht, key, (void*)(vals + i));
+  }
+  GPR_ASSERT(census_ht_get_size(ht) == 9);
+  for (i = 0; i < 9; i++) {
+    census_ht_key key;
+    int* val_ptr;
+    key.ptr = (void*)(keys[i]);
+    val_ptr = census_ht_find(ht, key);
+    GPR_ASSERT(*val_ptr == vals[i]);
+  }
+  {
+    /* inserts duplicate keys */
+    census_ht_key key;
+    int* val_ptr = NULL;
+    key.ptr = (void*)(keys[2]);
+    census_ht_insert(ht, key, (void*)(vals + 8));
+    /* expect value to be over written by new insertion */
+    GPR_ASSERT(census_ht_get_size(ht) == 9);
+    val_ptr = census_ht_find(ht, key);
+    GPR_ASSERT(*val_ptr == vals[8]);
+  }
+  for (i = 0; i < 9; i++) {
+    census_ht_key key;
+    int* val_ptr;
+    gpr_uint32 expected_tbl_sz = 9 - i;
+    GPR_ASSERT(census_ht_get_size(ht) == expected_tbl_sz);
+    key.ptr = (void*)(keys[i]);
+    val_ptr = census_ht_find(ht, key);
+    GPR_ASSERT(val_ptr != NULL);
+    census_ht_erase(ht, key);
+    GPR_ASSERT(census_ht_get_size(ht) == expected_tbl_sz - 1);
+    val_ptr = census_ht_find(ht, key);
+    GPR_ASSERT(val_ptr == NULL);
+  }
+  census_ht_destroy(ht);
+}
+
+static void test_insertion_with_same_key() {
+  census_ht_option opt = {CENSUS_HT_UINT64, 11, NULL, NULL, NULL, NULL};
+  census_ht* ht = census_ht_create(&opt);
+  census_ht_key key;
+  const char vals[] = {'a', 'b', 'c'};
+  char* val_ptr;
+  key.val = 3;
+  census_ht_insert(ht, key, (void*)&(vals[0]));
+  GPR_ASSERT(census_ht_get_size(ht) == 1);
+  val_ptr = (char*)census_ht_find(ht, key);
+  GPR_ASSERT(val_ptr != NULL);
+  GPR_ASSERT(*val_ptr == 'a');
+  key.val = 4;
+  val_ptr = (char*)census_ht_find(ht, key);
+  GPR_ASSERT(val_ptr == NULL);
+  key.val = 3;
+  census_ht_insert(ht, key, (void*)&(vals[1]));
+  GPR_ASSERT(census_ht_get_size(ht) == 1);
+  val_ptr = (char*)census_ht_find(ht, key);
+  GPR_ASSERT(val_ptr != NULL);
+  GPR_ASSERT(*val_ptr == 'b');
+  census_ht_insert(ht, key, (void*)&(vals[2]));
+  GPR_ASSERT(census_ht_get_size(ht) == 1);
+  val_ptr = (char*)census_ht_find(ht, key);
+  GPR_ASSERT(val_ptr != NULL);
+  GPR_ASSERT(*val_ptr == 'c');
+  census_ht_destroy(ht);
+}
+
+int main(int argc, char** argv) {
+  grpc_test_init(argc, argv);
+  test_create_table();
+  test_simple_add_and_erase();
+  test_table_with_int_key();
+  test_table_with_string_key();
+  test_value_and_key_deleter();
+  test_insertion_with_same_key();
+  test_insertion_and_deletion_with_high_collision_rate();
+  return 0;
+}
diff --git a/test/core/statistics/log_tests.c b/test/core/statistics/log_tests.c
new file mode 100644
index 0000000..f0cbdbd
--- /dev/null
+++ b/test/core/statistics/log_tests.c
@@ -0,0 +1,568 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/statistics/log.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "src/core/support/cpu.h"
+#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/thd.h>
+#include <grpc/support/time.h>
+
+/* Fills in 'record' of size 'size'. Each byte in record is filled in with the
+   same value. The value is extracted from 'record' pointer. */
+static void write_record(char* record, size_t size) {
+  char data = (gpr_uintptr)record % 255;
+  memset(record, data, size);
+}
+
+/* Reads fixed size records. Returns the number of records read in
+   'num_records'. */
+static void read_records(size_t record_size, const char* buffer,
+                         size_t buffer_size, gpr_int32* num_records) {
+  gpr_int32 ix;
+  GPR_ASSERT(buffer_size >= record_size);
+  GPR_ASSERT(buffer_size % record_size == 0);
+  *num_records = buffer_size / record_size;
+  for (ix = 0; ix < *num_records; ++ix) {
+    gpr_int32 jx;
+    const char* record = buffer + (record_size * ix);
+    char data = (gpr_uintptr)record % 255;
+    for (jx = 0; jx < record_size; ++jx) {
+      GPR_ASSERT(data == record[jx]);
+    }
+  }
+}
+
+/* Tries to write the specified number of records. Stops when the log gets
+   full. Returns the number of records written. Spins for random
+   number of times, up to 'max_spin_count', between writes. */
+static size_t write_records_to_log(int writer_id, gpr_int32 record_size,
+                                   gpr_int32 num_records,
+                                   gpr_int32 max_spin_count) {
+  gpr_int32 ix;
+  int counter = 0;
+  for (ix = 0; ix < num_records; ++ix) {
+    gpr_int32 jx;
+    gpr_int32 spin_count = max_spin_count ? rand() % max_spin_count : 0;
+    char* record;
+    if (counter++ == num_records / 10) {
+      printf("   Writer %d: %d out of %d written\n", writer_id, ix,
+             num_records);
+      counter = 0;
+    }
+    record = (char*)(census_log_start_write(record_size));
+    if (record == NULL) {
+      return ix;
+    }
+    write_record(record, record_size);
+    census_log_end_write(record, record_size);
+    for (jx = 0; jx < spin_count; ++jx) {
+      GPR_ASSERT(jx >= 0);
+    }
+  }
+  return num_records;
+}
+
+/* Performs a single read iteration. Returns the number of records read. */
+static size_t perform_read_iteration(size_t record_size) {
+  const void* read_buffer = NULL;
+  size_t bytes_available;
+  size_t records_read = 0;
+  census_log_init_reader();
+  while ((read_buffer = census_log_read_next(&bytes_available))) {
+    gpr_int32 num_records = 0;
+    read_records(record_size, (const char*)read_buffer, bytes_available,
+                 &num_records);
+    records_read += num_records;
+  }
+  return records_read;
+}
+
+/* Asserts that the log is empty. */
+static void assert_log_empty() {
+  size_t bytes_available;
+  census_log_init_reader();
+  GPR_ASSERT(census_log_read_next(&bytes_available) == NULL);
+}
+
+/* Given log size and record size, computes the minimum usable space. */
+static size_t min_usable_space(size_t log_size, size_t record_size) {
+  gpr_int32 num_blocks = log_size / CENSUS_LOG_MAX_RECORD_SIZE;
+  gpr_int32 waste_per_block = CENSUS_LOG_MAX_RECORD_SIZE % record_size;
+  /* In the worst case, all except one core-local block is empty. */
+  return (log_size - ((gpr_cpu_num_cores() - 1) * CENSUS_LOG_MAX_RECORD_SIZE) -
+          ((num_blocks - gpr_cpu_num_cores() - 1) * waste_per_block));
+}
+
+/* Fills the log and verifies data. If 'no fragmentation' is true, records
+   are sized such that CENSUS_LOG_2_MAX_RECORD_SIZE is a multiple of record
+   size. If not a circular log, verifies that the number of records written
+   match the number of records read. */
+static void fill_log(size_t log_size, int no_fragmentation, int circular_log) {
+  int size;
+  gpr_int32 records_written;
+  gpr_int32 usable_space;
+  gpr_int32 records_read;
+  if (no_fragmentation) {
+    int log2size = rand() % (CENSUS_LOG_2_MAX_RECORD_SIZE + 1);
+    size = (1 << log2size);
+  } else {
+    while (1) {
+      size = 1 + (rand() % CENSUS_LOG_MAX_RECORD_SIZE);
+      if (CENSUS_LOG_MAX_RECORD_SIZE % size) {
+        break;
+      }
+    }
+  }
+  printf("   Fill record size: %d\n", size);
+  records_written = write_records_to_log(
+      0 /* writer id */, size, (log_size / size) * 2, 0 /* spin count */);
+  usable_space = min_usable_space(log_size, size);
+  GPR_ASSERT(usable_space > 0);
+  GPR_ASSERT(records_written * size >= usable_space);
+  records_read = perform_read_iteration(size);
+  if (!circular_log) {
+    GPR_ASSERT(records_written == records_read);
+  }
+  assert_log_empty();
+}
+
+/* Structure to pass args to writer_thread */
+typedef struct writer_thread_args {
+  /* Index of this thread in the writers vector. */
+  int index;
+  /* Record size. */
+  size_t record_size;
+  /* Number of records to write. */
+  gpr_int32 num_records;
+  /* Used to signal when writer is complete */
+  gpr_cv* done;
+  gpr_mu* mu;
+  int* count;
+} writer_thread_args;
+
+/* Writes the given number of records of random size (up to kMaxRecordSize) and
+   random data to the specified log. */
+static void writer_thread(void* arg) {
+  writer_thread_args* args = (writer_thread_args*)arg;
+  /* Maximum number of times to spin between writes. */
+  static const gpr_int32 MAX_SPIN_COUNT = 50;
+  int records_written = 0;
+  printf("   Writer: %d\n", args->index);
+  while (records_written < args->num_records) {
+    records_written += write_records_to_log(args->index, args->record_size,
+                                            args->num_records - records_written,
+                                            MAX_SPIN_COUNT);
+    if (records_written < args->num_records) {
+      /* Ran out of log space. Sleep for a bit and let the reader catch up.
+         This should never happen for circular logs. */
+      printf("   Writer stalled due to out-of-space: %d out of %d written\n",
+             records_written, args->num_records);
+      gpr_sleep_until(gpr_time_add(gpr_now(), gpr_time_from_micros(10000)));
+    }
+  }
+  /* Done. Decrement count and signal. */
+  gpr_mu_lock(args->mu);
+  (*args->count)--;
+  gpr_cv_broadcast(args->done);
+  printf("   Writer done: %d\n", args->index);
+  gpr_mu_unlock(args->mu);
+}
+
+/* struct to pass args to reader_thread */
+typedef struct reader_thread_args {
+  /* Record size. */
+  size_t record_size;
+  /* Interval between read iterations. */
+  gpr_int32 read_iteration_interval_in_msec;
+  /* Total number of records. */
+  gpr_int32 total_records;
+  /* Signalled when reader should stop. */
+  gpr_cv stop;
+  int stop_flag;
+  /* Used to signal when reader has finished */
+  gpr_cv* done;
+  gpr_mu* mu;
+  int running;
+} reader_thread_args;
+
+/* Reads and verifies the specified number of records. Reader can also be
+   stopped via gpr_cv_signal(&args->stop). Sleeps for 'read_interval_in_msec'
+   between read iterations. */
+static void reader_thread(void* arg) {
+  gpr_int32 records_read = 0;
+  reader_thread_args* args = (reader_thread_args*)arg;
+  gpr_int32 num_iterations = 0;
+  gpr_timespec interval;
+  int counter = 0;
+  printf("   Reader starting\n");
+  interval = gpr_time_from_micros(args->read_iteration_interval_in_msec * 1000);
+  gpr_mu_lock(args->mu);
+  while (!args->stop_flag && records_read < args->total_records) {
+    gpr_cv_wait(&args->stop, args->mu, interval);
+    if (!args->stop_flag) {
+      records_read += perform_read_iteration(args->record_size);
+      GPR_ASSERT(records_read <= args->total_records);
+      if (counter++ == 100000) {
+        printf("   Reader: %d out of %d read\n", records_read,
+               args->total_records);
+        counter = 0;
+      }
+      ++num_iterations;
+    }
+  }
+  /* Done */
+  args->running = 0;
+  gpr_cv_broadcast(args->done);
+  printf("   Reader: records: %d, iterations: %d\n", records_read,
+         num_iterations);
+  gpr_mu_unlock(args->mu);
+}
+
+/* Creates NUM_WRITERS writers where each writer writes NUM_RECORDS_PER_WRITER
+   records. Also, starts a reader that iterates over and reads blocks every
+   READ_ITERATION_INTERVAL_IN_MSEC. */
+/* Number of writers. */
+#define NUM_WRITERS 5
+static void multiple_writers_single_reader(int circular_log) {
+  /* Sleep interval between read iterations. */
+  static const gpr_int32 READ_ITERATION_INTERVAL_IN_MSEC = 10;
+  /* Number of records written by each writer. */
+  static const gpr_int32 NUM_RECORDS_PER_WRITER = 10 * 1024 * 1024;
+  /* Maximum record size. */
+  static const size_t MAX_RECORD_SIZE = 10;
+  int ix;
+  gpr_thd_id id;
+  gpr_cv writers_done;
+  int writers_count = NUM_WRITERS;
+  gpr_mu writers_mu; /* protects writers_done and writers_count */
+  writer_thread_args writers[NUM_WRITERS];
+  gpr_cv reader_done;
+  gpr_mu reader_mu; /* protects reader_done and reader.running */
+  reader_thread_args reader;
+  gpr_int32 record_size = 1 + rand() % MAX_RECORD_SIZE;
+  printf("   Record size: %d\n", record_size);
+  /* Create and start writers. */
+  gpr_cv_init(&writers_done);
+  gpr_mu_init(&writers_mu);
+  for (ix = 0; ix < NUM_WRITERS; ++ix) {
+    writers[ix].index = ix;
+    writers[ix].record_size = record_size;
+    writers[ix].num_records = NUM_RECORDS_PER_WRITER;
+    writers[ix].done = &writers_done;
+    writers[ix].count = &writers_count;
+    writers[ix].mu = &writers_mu;
+    gpr_thd_new(&id, &writer_thread, &writers[ix], NULL);
+  }
+  /* Start reader. */
+  reader.record_size = record_size;
+  reader.read_iteration_interval_in_msec = READ_ITERATION_INTERVAL_IN_MSEC;
+  reader.total_records = NUM_WRITERS * NUM_RECORDS_PER_WRITER;
+  reader.stop_flag = 0;
+  gpr_cv_init(&reader.stop);
+  gpr_cv_init(&reader_done);
+  reader.done = &reader_done;
+  gpr_mu_init(&reader_mu);
+  reader.mu = &reader_mu;
+  reader.running = 1;
+  gpr_thd_new(&id, &reader_thread, &reader, NULL);
+  /* Wait for writers to finish. */
+  gpr_mu_lock(&writers_mu);
+  while (writers_count != 0) {
+    gpr_cv_wait(&writers_done, &writers_mu, gpr_inf_future);
+  }
+  gpr_mu_unlock(&writers_mu);
+  gpr_mu_destroy(&writers_mu);
+  gpr_cv_destroy(&writers_done);
+  gpr_mu_lock(&reader_mu);
+  if (circular_log) {
+    /* Stop reader. */
+    reader.stop_flag = 1;
+    gpr_cv_signal(&reader.stop);
+  }
+  /* wait for reader to finish */
+  while (reader.running) {
+    gpr_cv_wait(&reader_done, &reader_mu, gpr_inf_future);
+  }
+  if (circular_log) {
+    /* Assert that there were no out-of-space errors. */
+    GPR_ASSERT(0 == census_log_out_of_space_count());
+  }
+  gpr_mu_unlock(&reader_mu);
+  gpr_mu_destroy(&reader_mu);
+  gpr_cv_destroy(&reader_done);
+  printf("   Reader: finished\n");
+}
+
+/* Log sizes to use for all tests. */
+#define LOG_SIZE_IN_MB 1
+#define LOG_SIZE_IN_BYTES (LOG_SIZE_IN_MB << 20)
+
+static void setup_test(int circular_log) {
+  census_log_initialize(LOG_SIZE_IN_MB, circular_log);
+  GPR_ASSERT(census_log_remaining_space() == LOG_SIZE_IN_BYTES);
+}
+
+/* Attempts to create a record of invalid size (size >
+   CENSUS_LOG_MAX_RECORD_SIZE). */
+void test_invalid_record_size() {
+  static const size_t INVALID_SIZE = CENSUS_LOG_MAX_RECORD_SIZE + 1;
+  static const size_t VALID_SIZE = 1;
+  void* record;
+  printf("Starting test: invalid record size\n");
+  setup_test(0);
+  record = census_log_start_write(INVALID_SIZE);
+  GPR_ASSERT(record == NULL);
+  /* Now try writing a valid record. */
+  record = census_log_start_write(VALID_SIZE);
+  GPR_ASSERT(record != NULL);
+  census_log_end_write(record, VALID_SIZE);
+  /* Verifies that available space went down by one block. In theory, this
+     check can fail if the thread is context switched to a new CPU during the
+     start_write execution (multiple blocks get allocated), but this has not
+     been observed in practice. */
+  GPR_ASSERT(LOG_SIZE_IN_BYTES - CENSUS_LOG_MAX_RECORD_SIZE ==
+             census_log_remaining_space());
+  census_log_shutdown();
+}
+
+/* Tests end_write() with a different size than what was specified in
+   start_write(). */
+void test_end_write_with_different_size() {
+  static const size_t START_WRITE_SIZE = 10;
+  static const size_t END_WRITE_SIZE = 7;
+  void* record_written;
+  const void* record_read;
+  size_t bytes_available;
+  printf("Starting test: end write with different size\n");
+  setup_test(0);
+  record_written = census_log_start_write(START_WRITE_SIZE);
+  GPR_ASSERT(record_written != NULL);
+  census_log_end_write(record_written, END_WRITE_SIZE);
+  census_log_init_reader();
+  record_read = census_log_read_next(&bytes_available);
+  GPR_ASSERT(record_written == record_read);
+  GPR_ASSERT(END_WRITE_SIZE == bytes_available);
+  assert_log_empty();
+  census_log_shutdown();
+}
+
+/* Verifies that pending records are not available via read_next(). */
+void test_read_pending_record() {
+  static const size_t PR_RECORD_SIZE = 1024;
+  size_t bytes_available;
+  const void* record_read;
+  void* record_written;
+  printf("Starting test: read pending record\n");
+  setup_test(0);
+  /* Start a write. */
+  record_written = census_log_start_write(PR_RECORD_SIZE);
+  GPR_ASSERT(record_written != NULL);
+  /* As write is pending, read should fail. */
+  census_log_init_reader();
+  record_read = census_log_read_next(&bytes_available);
+  GPR_ASSERT(record_read == NULL);
+  /* A read followed by end_write() should succeed. */
+  census_log_end_write(record_written, PR_RECORD_SIZE);
+  census_log_init_reader();
+  record_read = census_log_read_next(&bytes_available);
+  GPR_ASSERT(record_written == record_read);
+  GPR_ASSERT(PR_RECORD_SIZE == bytes_available);
+  assert_log_empty();
+  census_log_shutdown();
+}
+
+/* Tries reading beyond pending write. */
+void test_read_beyond_pending_record() {
+  /* Start a write. */
+  gpr_int32 incomplete_record_size = 10;
+  gpr_int32 complete_record_size = 20;
+  size_t bytes_available;
+  void* complete_record;
+  const void* record_read;
+  void* incomplete_record;
+  printf("Starting test: read beyond pending record\n");
+  setup_test(0);
+  incomplete_record = census_log_start_write(incomplete_record_size);
+  GPR_ASSERT(incomplete_record != NULL);
+  complete_record = census_log_start_write(complete_record_size);
+  GPR_ASSERT(complete_record != NULL);
+  GPR_ASSERT(complete_record != incomplete_record);
+  census_log_end_write(complete_record, complete_record_size);
+  /* Now iterate over blocks to read completed records. */
+  census_log_init_reader();
+  record_read = census_log_read_next(&bytes_available);
+  GPR_ASSERT(complete_record == record_read);
+  GPR_ASSERT(complete_record_size == bytes_available);
+  /* Complete first record. */
+  census_log_end_write(incomplete_record, incomplete_record_size);
+  /* Have read past the incomplete record, so read_next() should return NULL. */
+  /* NB: this test also assumes our thread did not get switched to a different
+     CPU between the two start_write calls */
+  record_read = census_log_read_next(&bytes_available);
+  GPR_ASSERT(record_read == NULL);
+  /* Reset reader to get the newly completed record. */
+  census_log_init_reader();
+  record_read = census_log_read_next(&bytes_available);
+  GPR_ASSERT(incomplete_record == record_read);
+  GPR_ASSERT(incomplete_record_size == bytes_available);
+  assert_log_empty();
+  census_log_shutdown();
+}
+
+/* Tests scenario where block being read is detached from a core and put on the
+   dirty list. */
+void test_detached_while_reading() {
+  static const size_t DWR_RECORD_SIZE = 10;
+  size_t bytes_available;
+  const void* record_read;
+  void* record_written;
+  gpr_int32 block_read = 0;
+  printf("Starting test: detached while reading\n");
+  setup_test(0);
+  /* Start a write. */
+  record_written = census_log_start_write(DWR_RECORD_SIZE);
+  GPR_ASSERT(record_written != NULL);
+  census_log_end_write(record_written, DWR_RECORD_SIZE);
+  /* Read this record. */
+  census_log_init_reader();
+  record_read = census_log_read_next(&bytes_available);
+  GPR_ASSERT(record_read != NULL);
+  GPR_ASSERT(DWR_RECORD_SIZE == bytes_available);
+  /* Now fill the log. This will move the block being read from core-local
+     array to the dirty list. */
+  while ((record_written = census_log_start_write(DWR_RECORD_SIZE))) {
+    census_log_end_write(record_written, DWR_RECORD_SIZE);
+  }
+
+  /* In this iteration, read_next() should only traverse blocks in the
+     core-local array. Therefore, we expect at most gpr_cpu_num_cores() more
+     blocks. As log is full, if read_next() is traversing the dirty list, we
+     will get more than gpr_cpu_num_cores() blocks. */
+  while ((record_read = census_log_read_next(&bytes_available))) {
+    ++block_read;
+    GPR_ASSERT(block_read <= gpr_cpu_num_cores());
+  }
+  census_log_shutdown();
+}
+
+/* Fills non-circular log with records sized such that size is a multiple of
+   CENSUS_LOG_MAX_RECORD_SIZE (no per-block fragmentation). */
+void test_fill_log_no_fragmentation() {
+  const int circular = 0;
+  printf("Starting test: fill log no fragmentation\n");
+  setup_test(circular);
+  fill_log(LOG_SIZE_IN_BYTES, 1 /* no fragmentation */, circular);
+  census_log_shutdown();
+}
+
+/* Fills circular log with records sized such that size is a multiple of
+   CENSUS_LOG_MAX_RECORD_SIZE (no per-block fragmentation). */
+void test_fill_circular_log_no_fragmentation() {
+  const int circular = 1;
+  printf("Starting test: fill circular log no fragmentation\n");
+  setup_test(circular);
+  fill_log(LOG_SIZE_IN_BYTES, 1 /* no fragmentation */, circular);
+  census_log_shutdown();
+}
+
+/* Fills non-circular log with records that may straddle end of a block. */
+void test_fill_log_with_straddling_records() {
+  const int circular = 0;
+  printf("Starting test: fill log with straddling records\n");
+  setup_test(circular);
+  fill_log(LOG_SIZE_IN_BYTES, 0 /* block straddling records */, circular);
+  census_log_shutdown();
+}
+
+/* Fills circular log with records that may straddle end of a block. */
+void test_fill_circular_log_with_straddling_records() {
+  const int circular = 1;
+  printf("Starting test: fill circular log with straddling records\n");
+  setup_test(circular);
+  fill_log(LOG_SIZE_IN_BYTES, 0 /* block straddling records */, circular);
+  census_log_shutdown();
+}
+
+/* Tests scenario where multiple writers and a single reader are using a log
+   that is configured to discard old records. */
+void test_multiple_writers_circular_log() {
+  const int circular = 1;
+  printf("Starting test: multiple writers circular log\n");
+  setup_test(circular);
+  multiple_writers_single_reader(circular);
+  census_log_shutdown();
+}
+
+/* Tests scenario where multiple writers and a single reader are using a log
+   that is configured to discard old records. */
+void test_multiple_writers() {
+  const int circular = 0;
+  printf("Starting test: multiple writers\n");
+  setup_test(circular);
+  multiple_writers_single_reader(circular);
+  census_log_shutdown();
+}
+
+void test_performance() {
+  int write_size = 1;
+  for (; write_size < CENSUS_LOG_MAX_RECORD_SIZE; write_size *= 2) {
+    gpr_timespec write_time;
+    gpr_timespec start_time;
+    double write_time_micro = 0.0;
+    int nrecords = 0;
+    setup_test(0);
+    start_time = gpr_now();
+    while (1) {
+      void* record = census_log_start_write(write_size);
+      if (record == NULL) {
+        break;
+      }
+      census_log_end_write(record, write_size);
+      nrecords++;
+    }
+    write_time = gpr_time_sub(gpr_now(), start_time);
+    write_time_micro = write_time.tv_sec * 1000000 + write_time.tv_nsec / 1000;
+    census_log_shutdown();
+    printf(
+        "Wrote %d %d byte records in %.3g microseconds: %g records/us "
+        "(%g ns/record), %g gigabytes/s\n",
+        nrecords, write_size, write_time_micro, nrecords / write_time_micro,
+        1000 * write_time_micro / nrecords,
+        (write_size * nrecords) / write_time_micro / 1000);
+  }
+}
diff --git a/test/core/statistics/log_tests.h b/test/core/statistics/log_tests.h
new file mode 100644
index 0000000..10993ac
--- /dev/null
+++ b/test/core/statistics/log_tests.h
@@ -0,0 +1,50 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef __GRPC_TEST_STATISTICS_LOG_TESTS_H__
+#define __GRPC_TEST_STATISTICS_LOG_TESTS_H__
+
+void test_invalid_record_size();
+void test_end_write_with_different_size();
+void test_read_pending_record();
+void test_read_beyond_pending_record();
+void test_detached_while_reading();
+void test_fill_log_no_fragmentation();
+void test_fill_circular_log_no_fragmentation();
+void test_fill_log_with_straddling_records();
+void test_fill_circular_log_with_straddling_records();
+void test_multiple_writers_circular_log();
+void test_multiple_writers();
+void test_performance();
+
+#endif  /* __GRPC_TEST_STATISTICS_LOG_TESTS_H__ */
diff --git a/test/core/statistics/multiple_writers_circular_buffer_test.c b/test/core/statistics/multiple_writers_circular_buffer_test.c
new file mode 100644
index 0000000..0cd0d78
--- /dev/null
+++ b/test/core/statistics/multiple_writers_circular_buffer_test.c
@@ -0,0 +1,46 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/statistics/log_tests.h"
+
+#include <stdlib.h>
+
+#include <grpc/support/time.h>
+#include "test/core/util/test_config.h"
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  srand(gpr_now().tv_nsec);
+  test_multiple_writers_circular_log();
+  return 0;
+}
diff --git a/test/core/statistics/multiple_writers_test.c b/test/core/statistics/multiple_writers_test.c
new file mode 100644
index 0000000..b1f3be4
--- /dev/null
+++ b/test/core/statistics/multiple_writers_test.c
@@ -0,0 +1,46 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/statistics/log_tests.h"
+
+#include <stdlib.h>
+
+#include <grpc/support/time.h>
+#include "test/core/util/test_config.h"
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  srand(gpr_now().tv_nsec);
+  test_multiple_writers();
+  return 0;
+}
diff --git a/test/core/statistics/performance_test.c b/test/core/statistics/performance_test.c
new file mode 100644
index 0000000..9197dd5
--- /dev/null
+++ b/test/core/statistics/performance_test.c
@@ -0,0 +1,46 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "log_tests.h"
+
+#include <stdlib.h>
+
+#include <grpc/support/time.h>
+#include "test/core/util/test_config.h"
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  srand(gpr_now().tv_nsec);
+  test_performance();
+  return 0;
+}
diff --git a/test/core/statistics/quick_test.c b/test/core/statistics/quick_test.c
new file mode 100644
index 0000000..fe2b89a
--- /dev/null
+++ b/test/core/statistics/quick_test.c
@@ -0,0 +1,54 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "log_tests.h"
+
+#include <stdlib.h>
+
+#include <grpc/support/time.h>
+#include "test/core/util/test_config.h"
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  srand(gpr_now().tv_nsec);
+  test_invalid_record_size();
+  test_end_write_with_different_size();
+  test_read_pending_record();
+  test_read_beyond_pending_record();
+  test_detached_while_reading();
+  test_fill_log_no_fragmentation();
+  test_fill_circular_log_no_fragmentation();
+  test_fill_log_with_straddling_records();
+  test_fill_circular_log_with_straddling_records();
+  return 0;
+}
diff --git a/test/core/statistics/window_stats_test.c b/test/core/statistics/window_stats_test.c
new file mode 100644
index 0000000..2bf93d8
--- /dev/null
+++ b/test/core/statistics/window_stats_test.c
@@ -0,0 +1,317 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/statistics/window_stats.h"
+#include <stdlib.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+#include "test/core/util/test_config.h"
+
+typedef struct test_stat {
+  double value1;
+  int value2;
+} test_stat;
+
+void add_test_stat(void* base, const void* addme) {
+  test_stat* b = (test_stat*)base;
+  const test_stat* a = (const test_stat*)addme;
+  b->value1 += a->value1;
+  b->value2 += a->value2;
+}
+
+void add_proportion_test_stat(double p, void* base, const void* addme) {
+  test_stat* b = (test_stat*)base;
+  const test_stat* a = (const test_stat*)addme;
+  b->value1 += p * a->value1;
+  b->value2 += p * a->value2 + 0.5; /* +0.5 is poor mans (no c99) round() */
+}
+
+const struct census_window_stats_stat_info kMyStatInfo = {
+    sizeof(test_stat), NULL, add_test_stat, add_proportion_test_stat};
+
+const gpr_timespec kMilliSecInterval = {0, 1000000};
+const gpr_timespec kSecInterval = {1, 0};
+const gpr_timespec kMinInterval = {60, 0};
+const gpr_timespec kHourInterval = {3600, 0};
+const gpr_timespec kPrimeInterval = {0, 101};
+
+static int compare_double(double a, double b, double epsilon) {
+  if (a >= b) {
+    return (a > b + epsilon) ? 1 : 0;
+  } else {
+    return (b > a + epsilon) ? -1 : 0;
+  }
+}
+
+void empty_test() {
+  census_window_stats_sums result;
+  const gpr_timespec zero = {0, 0};
+  test_stat sum;
+  struct census_window_stats* stats =
+      census_window_stats_create(1, &kMinInterval, 5, &kMyStatInfo);
+  GPR_ASSERT(stats != NULL);
+  result.statistic = &sum;
+  census_window_stats_get_sums(stats, zero, &result);
+  GPR_ASSERT(result.count == 0 && sum.value1 == 0 && sum.value2 == 0);
+  census_window_stats_get_sums(stats, gpr_now(), &result);
+  GPR_ASSERT(result.count == 0 && sum.value1 == 0 && sum.value2 == 0);
+  census_window_stats_destroy(stats);
+}
+
+void one_interval_test() {
+  const test_stat value = {0.1, 4};
+  const double epsilon = 1e10 - 11;
+  gpr_timespec when = {0, 0};
+  census_window_stats_sums result;
+  test_stat sum;
+  /* granularity == 5 so width of internal windows should be 12s */
+  struct census_window_stats* stats =
+      census_window_stats_create(1, &kMinInterval, 5, &kMyStatInfo);
+  GPR_ASSERT(stats != NULL);
+  /* phase 1: insert a single value at t=0s, and check that various measurement
+     times result in expected output values */
+  census_window_stats_add(stats, when, &value);
+  result.statistic = &sum;
+  /* when = 0s, values extracted should be everything */
+  census_window_stats_get_sums(stats, when, &result);
+  GPR_ASSERT(compare_double(result.count, 1, epsilon) == 0 &&
+             compare_double(sum.value1, value.value1, epsilon) == 0 &&
+             sum.value2 == value.value2);
+  /* when = 6,30,60s, should be all of the data */
+  when.tv_sec = 6;
+  census_window_stats_get_sums(stats, when, &result);
+  GPR_ASSERT(compare_double(result.count, 1.0, epsilon) == 0 &&
+             compare_double(sum.value1, value.value1, epsilon) == 0 &&
+             sum.value2 == value.value2);
+  /* when == 30s,60s, should be all of the data */
+  when.tv_sec = 30;
+  census_window_stats_get_sums(stats, when, &result);
+  GPR_ASSERT(compare_double(result.count, 1.0, epsilon) == 0 &&
+             compare_double(sum.value1, value.value1, epsilon) == 0 &&
+             sum.value2 == value.value2);
+  when.tv_sec = 60;
+  census_window_stats_get_sums(stats, when, &result);
+  GPR_ASSERT(compare_double(result.count, 1.0, epsilon) == 0 &&
+             compare_double(sum.value1, value.value1, epsilon) == 0 &&
+             sum.value2 == value.value2);
+  /* when = 66s, should be half (only take half of bottom bucket) */
+  when.tv_sec = 66;
+  census_window_stats_get_sums(stats, when, &result);
+  GPR_ASSERT(compare_double(result.count, 0.5, epsilon) == 0 &&
+             compare_double(sum.value1, value.value1 / 2, epsilon) == 0 &&
+             sum.value2 == value.value2 / 2);
+  /* when = 72s, should be completely out of window */
+  when.tv_sec = 72;
+  census_window_stats_get_sums(stats, when, &result);
+  GPR_ASSERT(compare_double(result.count, 0, epsilon) == 0 &&
+             compare_double(sum.value1, 0, epsilon) == 0 && sum.value2 == 0);
+
+  /* phase 2: tear down and do as before, but inserting two values */
+  census_window_stats_destroy(stats);
+  stats = census_window_stats_create(1, &kMinInterval, 5, &kMyStatInfo);
+  GPR_ASSERT(stats != NULL);
+  when.tv_sec = 0;
+  when.tv_nsec = 17;
+  census_window_stats_add(stats, when, &value);
+  when.tv_sec = 1;
+  census_window_stats_add(stats, when, &value);
+  when.tv_sec = 0;
+  census_window_stats_get_sums(stats, when, &result);
+  GPR_ASSERT(compare_double(result.count, 0, epsilon) == 0 &&
+             compare_double(sum.value1, 0, epsilon) == 0 && sum.value2 == 0);
+  /* time = 3s, 30s, should get all data */
+  when.tv_sec = 3;
+  census_window_stats_get_sums(stats, when, &result);
+  GPR_ASSERT(compare_double(result.count, 2, epsilon) == 0 &&
+             compare_double(sum.value1, 2 * value.value1, epsilon) == 0 &&
+             sum.value2 == 2 * value.value2);
+  when.tv_sec = 30;
+  census_window_stats_get_sums(stats, when, &result);
+  GPR_ASSERT(compare_double(result.count, 2, epsilon) == 0 &&
+             compare_double(sum.value1, 2 * value.value1, epsilon) == 0 &&
+             sum.value2 == 2 * value.value2);
+
+  /* phase 3: insert into "middle" bucket, and force a shift, pushing out
+     the two values in bottom bucket */
+  when.tv_sec = 30;
+  census_window_stats_add(stats, when, &value);
+  when.tv_sec = 76;
+  census_window_stats_add(stats, when, &value);
+  when.tv_sec = 0;
+  census_window_stats_get_sums(stats, when, &result);
+  GPR_ASSERT(result.count == 0 && sum.value1 == 0 && sum.value2 == 0);
+  when.tv_sec = 30;
+  census_window_stats_get_sums(stats, when, &result);
+  /* half of the single value in the 30 second bucket */
+  GPR_ASSERT(compare_double(result.count, 0.5, epsilon) == 0 &&
+             compare_double(sum.value1, value.value1 / 2, epsilon) == 0 &&
+             sum.value2 == value.value2 / 2);
+  when.tv_sec = 74;
+  census_window_stats_get_sums(stats, when, &result);
+  /* half of the 76 second bucket, all of the 30 second bucket */
+  GPR_ASSERT(compare_double(result.count, 1.5, epsilon) == 0 &&
+             compare_double(sum.value1, value.value1 * 1.5, epsilon) == 0 &&
+             sum.value2 == value.value2 / 2 * 3);
+  when.tv_sec = 76;
+  census_window_stats_get_sums(stats, when, &result);
+  /* >=76s, get all of the 76 second bucket, all of the 30 second bucket */
+  GPR_ASSERT(compare_double(result.count, 2, epsilon) == 0 &&
+             compare_double(sum.value1, value.value1 * 2, epsilon) == 0 &&
+             sum.value2 == value.value2 * 2);
+  when.tv_sec = 78;
+  census_window_stats_get_sums(stats, when, &result);
+  /* half of the 76 second bucket, all of the 30 second bucket */
+  GPR_ASSERT(compare_double(result.count, 2, epsilon) == 0 &&
+             compare_double(sum.value1, value.value1 * 2, epsilon) == 0 &&
+             sum.value2 == value.value2 * 2);
+  census_window_stats_destroy(stats);
+}
+
+void many_interval_test() {
+  gpr_timespec intervals[4];
+  const test_stat value = {123.45, 8};
+  const double epsilon = 1e10 - 11;
+  gpr_timespec when = {3600, 0}; /* one hour */
+  census_window_stats_sums result[4];
+  test_stat sums[4];
+  int i;
+  struct census_window_stats* stats;
+  intervals[0] = kMilliSecInterval;
+  intervals[1] = kSecInterval;
+  intervals[2] = kMinInterval;
+  intervals[3] = kHourInterval;
+  for (i = 0; i < 4; i++) {
+    result[i].statistic = &sums[i];
+  }
+  stats = census_window_stats_create(4, intervals, 100, &kMyStatInfo);
+  GPR_ASSERT(stats != NULL);
+  /* add 10 stats within half of each time range */
+  for (i = 0; i < 10; i++) {
+    when.tv_sec += 180; /* covers 30 min of one hour range */
+    census_window_stats_add(stats, when, &value);
+  }
+  when.tv_sec += 120;
+  for (i = 0; i < 10; i++) {
+    when.tv_sec += 3; /* covers 30 sec of one minute range */
+    census_window_stats_add(stats, when, &value);
+  }
+  when.tv_sec += 2;
+  for (i = 0; i < 10; i++) {
+    when.tv_nsec += 50000000; /* covers 0.5s of 1s range */
+    census_window_stats_add(stats, when, &value);
+  }
+  when.tv_nsec += 2000000;
+  for (i = 0; i < 10; i++) {
+    when.tv_nsec += 50000; /* covers 0.5 ms of 1 ms range */
+    census_window_stats_add(stats, when, &value);
+  }
+  when.tv_nsec += 20000;
+  census_window_stats_get_sums(stats, when, result);
+  GPR_ASSERT(compare_double(result[0].count, 10, epsilon) == 0 &&
+             compare_double(sums[0].value1, value.value1 * 10, epsilon) == 0 &&
+             sums[0].value2 == value.value2 * 10);
+  when.tv_nsec += 20000000;
+  census_window_stats_get_sums(stats, when, result);
+  GPR_ASSERT(compare_double(result[1].count, 20, epsilon) == 0 &&
+             compare_double(sums[1].value1, value.value1 * 20, epsilon) == 0 &&
+             sums[1].value2 == value.value2 * 20);
+  when.tv_sec += 2;
+  census_window_stats_get_sums(stats, when, result);
+  GPR_ASSERT(compare_double(result[2].count, 30, epsilon) == 0 &&
+             compare_double(sums[2].value1, value.value1 * 30, epsilon) == 0 &&
+             sums[2].value2 == value.value2 * 30);
+  when.tv_sec += 72;
+  census_window_stats_get_sums(stats, when, result);
+  GPR_ASSERT(compare_double(result[3].count, 40, epsilon) == 0 &&
+             compare_double(sums[3].value1, value.value1 * 40, epsilon) == 0 &&
+             sums[3].value2 == value.value2 * 40);
+  census_window_stats_destroy(stats);
+}
+
+void rolling_time_test() {
+  const test_stat value = {0.1, 4};
+  gpr_timespec when = {0, 0};
+  census_window_stats_sums result;
+  test_stat sum;
+  int i;
+  gpr_timespec increment = {0, 0};
+  struct census_window_stats* stats =
+      census_window_stats_create(1, &kMinInterval, 7, &kMyStatInfo);
+  GPR_ASSERT(stats != NULL);
+  srand(gpr_now().tv_nsec);
+  for (i = 0; i < 100000; i++) {
+    increment.tv_nsec = rand() % 100000000; /* up to 1/10th second */
+    when = gpr_time_add(when, increment);
+    census_window_stats_add(stats, when, &value);
+  }
+  result.statistic = &sum;
+  census_window_stats_get_sums(stats, when, &result);
+  /* With 1/20th second average between samples, we expect 20*60 = 1200
+     samples on average. Make sure we are within 100 of that. */
+  GPR_ASSERT(compare_double(result.count, 1200, 100) == 0);
+  census_window_stats_destroy(stats);
+}
+#include <stdio.h>
+void infinite_interval_test() {
+  const test_stat value = {0.1, 4};
+  gpr_timespec when = {0, 0};
+  census_window_stats_sums result;
+  test_stat sum;
+  int i;
+  const int count = 100000;
+  gpr_timespec increment = {0, 0};
+  struct census_window_stats* stats =
+      census_window_stats_create(1, &gpr_inf_future, 10, &kMyStatInfo);
+  srand(gpr_now().tv_nsec);
+  for (i = 0; i < count; i++) {
+    increment.tv_sec = rand() % 21600; /* 6 hours */
+    when = gpr_time_add(when, increment);
+    census_window_stats_add(stats, when, &value);
+  }
+  result.statistic = &sum;
+  census_window_stats_get_sums(stats, when, &result);
+  /* The only thing it makes sense to compare for "infinite" periods is the
+     total counts */
+  GPR_ASSERT(result.count == count);
+  census_window_stats_destroy(stats);
+}
+
+int main(int argc, char* argv[]) {
+  grpc_test_init(argc, argv);
+  empty_test();
+  one_interval_test();
+  many_interval_test();
+  rolling_time_test();
+  infinite_interval_test();
+  return 0;
+}
diff --git a/test/core/support/cancellable_test.c b/test/core/support/cancellable_test.c
new file mode 100644
index 0000000..e90c999
--- /dev/null
+++ b/test/core/support/cancellable_test.c
@@ -0,0 +1,160 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/* Test of gpr_cancellable. */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/thd.h>
+#include <grpc/support/time.h>
+#include "test/core/util/test_config.h"
+
+struct test {
+  gpr_mu mu;
+  gpr_cv cv;
+  gpr_event ev;
+  gpr_event done;
+  gpr_cancellable cancel;
+  int n;
+};
+
+/* A thread body.   Wait until t->cancel is cancelledm then
+   decrement t->n.  If t->n becomes 0, set t->done.  */
+static void thd_body(void *v) {
+  struct test *t = v;
+  gpr_mu_lock(&t->mu);
+  while (!gpr_cv_cancellable_wait(&t->cv, &t->mu, gpr_inf_future, &t->cancel)) {
+  }
+  t->n--;
+  if (t->n == 0) {
+    gpr_event_set(&t->done, (void *)1);
+  }
+  gpr_mu_unlock(&t->mu);
+}
+
+static void test(void) {
+  int i;
+  gpr_thd_id thd;
+  struct test t;
+  int n = 1;
+  gpr_timespec interval;
+
+  gpr_mu_init(&t.mu);
+  gpr_cv_init(&t.cv);
+  gpr_event_init(&t.ev);
+  gpr_event_init(&t.done);
+  gpr_cancellable_init(&t.cancel);
+
+  /* A gpr_cancellable starts not cancelled. */
+  GPR_ASSERT(!gpr_cancellable_is_cancelled(&t.cancel));
+
+  /* Test timeout on event wait for uncancelled gpr_cancellable */
+  interval = gpr_now();
+  gpr_event_cancellable_wait(
+      &t.ev, gpr_time_add(gpr_now(), gpr_time_from_micros(1000000)), &t.cancel);
+  interval = gpr_time_sub(gpr_now(), interval);
+  GPR_ASSERT(gpr_time_cmp(interval, gpr_time_from_micros(500000)) >= 0);
+  GPR_ASSERT(gpr_time_cmp(gpr_time_from_micros(2000000), interval) >= 0);
+
+  /* Test timeout on cv wait for uncancelled gpr_cancellable */
+  gpr_mu_lock(&t.mu);
+  interval = gpr_now();
+  while (!gpr_cv_cancellable_wait(
+             &t.cv, &t.mu,
+             gpr_time_add(gpr_now(), gpr_time_from_micros(1000000)),
+             &t.cancel)) {
+  }
+  interval = gpr_time_sub(gpr_now(), interval);
+  GPR_ASSERT(gpr_time_cmp(interval, gpr_time_from_micros(500000)) >= 0);
+  GPR_ASSERT(gpr_time_cmp(gpr_time_from_micros(2000000), interval) >= 0);
+  gpr_mu_unlock(&t.mu);
+
+  /* Create some threads.  They all wait until cancelled; the last to finish
+     sets t.done.  */
+  t.n = n;
+  for (i = 0; i != n; i++) {
+    GPR_ASSERT(gpr_thd_new(&thd, &thd_body, &t, NULL));
+  }
+  /* Check that t.cancel still is not cancelled. */
+  GPR_ASSERT(!gpr_cancellable_is_cancelled(&t.cancel));
+
+  /* Wait a second, and check that no threads have finished waiting. */
+  gpr_mu_lock(&t.mu);
+  gpr_cv_wait(&t.cv, &t.mu,
+              gpr_time_add(gpr_now(), gpr_time_from_micros(1000000)));
+  GPR_ASSERT(t.n == n);
+  gpr_mu_unlock(&t.mu);
+
+  /* Check that t.cancel still is not cancelled, but when
+     cancelled it retports that it is cacncelled. */
+  GPR_ASSERT(!gpr_cancellable_is_cancelled(&t.cancel));
+  gpr_cancellable_cancel(&t.cancel);
+  GPR_ASSERT(gpr_cancellable_is_cancelled(&t.cancel));
+
+  /* Wait for threads to finish. */
+  gpr_event_wait(&t.done, gpr_inf_future);
+  GPR_ASSERT(t.n == 0);
+
+  /* Test timeout on cv wait for cancelled gpr_cancellable */
+  gpr_mu_lock(&t.mu);
+  interval = gpr_now();
+  while (!gpr_cv_cancellable_wait(
+             &t.cv, &t.mu,
+             gpr_time_add(gpr_now(), gpr_time_from_micros(1000000)),
+             &t.cancel)) {
+  }
+  interval = gpr_time_sub(gpr_now(), interval);
+  GPR_ASSERT(gpr_time_cmp(gpr_time_from_micros(100000), interval) >= 0);
+  gpr_mu_unlock(&t.mu);
+
+  /* Test timeout on event wait for cancelled gpr_cancellable */
+  interval = gpr_now();
+  gpr_event_cancellable_wait(
+      &t.ev, gpr_time_add(gpr_now(), gpr_time_from_micros(1000000)), &t.cancel);
+  interval = gpr_time_sub(gpr_now(), interval);
+  GPR_ASSERT(gpr_time_cmp(gpr_time_from_micros(100000), interval) >= 0);
+
+  gpr_mu_destroy(&t.mu);
+  gpr_cv_destroy(&t.cv);
+  gpr_cancellable_destroy(&t.cancel);
+}
+
+/* ------------------------------------------------- */
+
+int main(int argc, char *argv[]) {
+  grpc_test_init(argc, argv);
+  test();
+  return 0;
+}
diff --git a/test/core/support/cmdline_test.c b/test/core/support/cmdline_test.c
new file mode 100644
index 0000000..91035a6
--- /dev/null
+++ b/test/core/support/cmdline_test.c
@@ -0,0 +1,293 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <grpc/support/cmdline.h>
+
+#include <string.h>
+
+#include <grpc/support/log.h>
+#include <grpc/support/useful.h>
+#include "test/core/util/test_config.h"
+
+#define LOG_TEST() gpr_log(GPR_INFO, "%s", __FUNCTION__)
+
+static void test_simple_int() {
+  int x = 1;
+  gpr_cmdline *cl;
+  char *args[] = {(char *)__FUNCTION__, "-foo", "3"};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(NULL);
+  gpr_cmdline_add_int(cl, "foo", NULL, &x);
+  GPR_ASSERT(x == 1);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(x == 3);
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_eq_int() {
+  int x = 1;
+  gpr_cmdline *cl;
+  char *args[] = {(char *)__FUNCTION__, "-foo=3"};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(NULL);
+  gpr_cmdline_add_int(cl, "foo", NULL, &x);
+  GPR_ASSERT(x == 1);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(x == 3);
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_2dash_int() {
+  int x = 1;
+  gpr_cmdline *cl;
+  char *args[] = {(char *)__FUNCTION__, "--foo", "3"};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(NULL);
+  gpr_cmdline_add_int(cl, "foo", NULL, &x);
+  GPR_ASSERT(x == 1);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(x == 3);
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_2dash_eq_int() {
+  int x = 1;
+  gpr_cmdline *cl;
+  char *args[] = {(char *)__FUNCTION__, "--foo=3"};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(NULL);
+  gpr_cmdline_add_int(cl, "foo", NULL, &x);
+  GPR_ASSERT(x == 1);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(x == 3);
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_simple_string() {
+  char *x = NULL;
+  gpr_cmdline *cl;
+  char *args[] = {(char *)__FUNCTION__, "-foo", "3"};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(NULL);
+  gpr_cmdline_add_string(cl, "foo", NULL, &x);
+  GPR_ASSERT(x == NULL);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(0 == strcmp(x, "3"));
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_eq_string() {
+  char *x = NULL;
+  gpr_cmdline *cl;
+  char *args[] = {(char *)__FUNCTION__, "-foo=3"};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(NULL);
+  gpr_cmdline_add_string(cl, "foo", NULL, &x);
+  GPR_ASSERT(x == NULL);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(0 == strcmp(x, "3"));
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_2dash_string() {
+  char *x = NULL;
+  gpr_cmdline *cl;
+  char *args[] = {(char *)__FUNCTION__, "--foo", "3"};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(NULL);
+  gpr_cmdline_add_string(cl, "foo", NULL, &x);
+  GPR_ASSERT(x == NULL);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(0 == strcmp(x, "3"));
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_2dash_eq_string() {
+  char *x = NULL;
+  gpr_cmdline *cl;
+  char *args[] = {(char *)__FUNCTION__, "--foo=3"};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(NULL);
+  gpr_cmdline_add_string(cl, "foo", NULL, &x);
+  GPR_ASSERT(x == NULL);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(0 == strcmp(x, "3"));
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_flag_on() {
+  int x = 2;
+  gpr_cmdline *cl;
+  char *args[] = {(char *)__FUNCTION__, "--foo"};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(NULL);
+  gpr_cmdline_add_flag(cl, "foo", NULL, &x);
+  GPR_ASSERT(x == 2);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(x == 1);
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_flag_no() {
+  int x = 2;
+  gpr_cmdline *cl;
+  char *args[] = {(char *)__FUNCTION__, "--no-foo"};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(NULL);
+  gpr_cmdline_add_flag(cl, "foo", NULL, &x);
+  GPR_ASSERT(x == 2);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(x == 0);
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_flag_val_1() {
+  int x = 2;
+  gpr_cmdline *cl;
+  char *args[] = {(char *)__FUNCTION__, "--foo=1"};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(NULL);
+  gpr_cmdline_add_flag(cl, "foo", NULL, &x);
+  GPR_ASSERT(x == 2);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(x == 1);
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_flag_val_0() {
+  int x = 2;
+  gpr_cmdline *cl;
+  char *args[] = {(char *)__FUNCTION__, "--foo=0"};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(NULL);
+  gpr_cmdline_add_flag(cl, "foo", NULL, &x);
+  GPR_ASSERT(x == 2);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(x == 0);
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_flag_val_true() {
+  int x = 2;
+  gpr_cmdline *cl;
+  char *args[] = {(char *)__FUNCTION__, "--foo=true"};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(NULL);
+  gpr_cmdline_add_flag(cl, "foo", NULL, &x);
+  GPR_ASSERT(x == 2);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(x == 1);
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_flag_val_false() {
+  int x = 2;
+  gpr_cmdline *cl;
+  char *args[] = {(char *)__FUNCTION__, "--foo=false"};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(NULL);
+  gpr_cmdline_add_flag(cl, "foo", NULL, &x);
+  GPR_ASSERT(x == 2);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(x == 0);
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_many() {
+  char *str = NULL;
+  int x = 0;
+  int flag = 2;
+  gpr_cmdline *cl;
+
+  char *args[] = {(char *)__FUNCTION__, "--str", "hello", "-x=4", "-no-flag"};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(NULL);
+  gpr_cmdline_add_string(cl, "str", NULL, &str);
+  gpr_cmdline_add_int(cl, "x", NULL, &x);
+  gpr_cmdline_add_flag(cl, "flag", NULL, &flag);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(x == 4);
+  GPR_ASSERT(0 == strcmp(str, "hello"));
+  GPR_ASSERT(flag == 0);
+  gpr_cmdline_destroy(cl);
+}
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  test_simple_int();
+  test_eq_int();
+  test_2dash_int();
+  test_2dash_eq_int();
+  test_simple_string();
+  test_eq_string();
+  test_2dash_string();
+  test_2dash_eq_string();
+  test_flag_on();
+  test_flag_no();
+  test_flag_val_1();
+  test_flag_val_0();
+  test_flag_val_true();
+  test_flag_val_false();
+  test_many();
+  return 0;
+}
diff --git a/test/core/support/histogram_test.c b/test/core/support/histogram_test.c
new file mode 100644
index 0000000..3b5fd73
--- /dev/null
+++ b/test/core/support/histogram_test.c
@@ -0,0 +1,178 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <grpc/support/histogram.h>
+#include <grpc/support/log.h>
+
+#define LOG_TEST() gpr_log(GPR_INFO, "%s", __FUNCTION__);
+
+static void test_no_op() {
+  gpr_histogram_destroy(gpr_histogram_create(0.01, 60e9));
+}
+
+static void expect_percentile(gpr_histogram *h, double percentile,
+                              double min_expect, double max_expect) {
+  double got = gpr_histogram_percentile(h, percentile);
+  gpr_log(GPR_INFO, "@%f%%, expect %f <= %f <= %f", percentile, min_expect, got,
+          max_expect);
+  GPR_ASSERT(min_expect <= got);
+  GPR_ASSERT(got <= max_expect);
+}
+
+static void test_simple() {
+  gpr_histogram *h;
+
+  LOG_TEST();
+
+  h = gpr_histogram_create(0.01, 60e9);
+  gpr_histogram_add(h, 10000);
+  gpr_histogram_add(h, 10000);
+  gpr_histogram_add(h, 11000);
+  gpr_histogram_add(h, 11000);
+
+  expect_percentile(h, 50, 10001, 10999);
+  GPR_ASSERT(gpr_histogram_mean(h) == 10500);
+
+  gpr_histogram_destroy(h);
+}
+
+static void test_percentile() {
+  gpr_histogram *h;
+  double last;
+  double i;
+  double cur;
+
+  LOG_TEST();
+
+  h = gpr_histogram_create(0.05, 1e9);
+  gpr_histogram_add(h, 2.5);
+  gpr_histogram_add(h, 2.5);
+  gpr_histogram_add(h, 8);
+  gpr_histogram_add(h, 4);
+
+  GPR_ASSERT(gpr_histogram_count(h) == 4);
+  GPR_ASSERT(gpr_histogram_minimum(h) == 2.5);
+  GPR_ASSERT(gpr_histogram_maximum(h) == 8);
+  GPR_ASSERT(gpr_histogram_sum(h) == 17);
+  GPR_ASSERT(gpr_histogram_sum_of_squares(h) == 92.5);
+  GPR_ASSERT(gpr_histogram_mean(h) == 4.25);
+  GPR_ASSERT(gpr_histogram_variance(h) == 5.0625);
+  GPR_ASSERT(gpr_histogram_stddev(h) == 2.25);
+
+  expect_percentile(h, -10, 2.5, 2.5);
+  expect_percentile(h, 0, 2.5, 2.5);
+  expect_percentile(h, 12.5, 2.5, 2.5);
+  expect_percentile(h, 25, 2.5, 2.5);
+  expect_percentile(h, 37.5, 2.5, 2.8);
+  expect_percentile(h, 50, 3.0, 3.5);
+  expect_percentile(h, 62.5, 3.5, 4.5);
+  expect_percentile(h, 75, 5, 7.9);
+  expect_percentile(h, 100, 8, 8);
+  expect_percentile(h, 110, 8, 8);
+
+  /* test monotonicity */
+  last = 0.0;
+  for (i = 0; i < 100.0; i += 0.01) {
+    cur = gpr_histogram_percentile(h, i);
+    GPR_ASSERT(cur >= last);
+    last = cur;
+  }
+
+  gpr_histogram_destroy(h);
+}
+
+static void test_merge() {
+  gpr_histogram *h1, *h2;
+  double last;
+  double i;
+  double cur;
+
+  LOG_TEST();
+
+  h1 = gpr_histogram_create(0.05, 1e9);
+  gpr_histogram_add(h1, 2.5);
+  gpr_histogram_add(h1, 2.5);
+  gpr_histogram_add(h1, 8);
+  gpr_histogram_add(h1, 4);
+
+  h2 = gpr_histogram_create(0.01, 1e9);
+  GPR_ASSERT(gpr_histogram_merge(h1, h2) == 0);
+  gpr_histogram_destroy(h2);
+
+  h2 = gpr_histogram_create(0.05, 1e10);
+  GPR_ASSERT(gpr_histogram_merge(h1, h2) == 0);
+  gpr_histogram_destroy(h2);
+
+  h2 = gpr_histogram_create(0.05, 1e9);
+  GPR_ASSERT(gpr_histogram_merge(h1, h2) == 1);
+  GPR_ASSERT(gpr_histogram_count(h1) == 4);
+  GPR_ASSERT(gpr_histogram_minimum(h1) == 2.5);
+  GPR_ASSERT(gpr_histogram_maximum(h1) == 8);
+  GPR_ASSERT(gpr_histogram_sum(h1) == 17);
+  GPR_ASSERT(gpr_histogram_sum_of_squares(h1) == 92.5);
+  GPR_ASSERT(gpr_histogram_mean(h1) == 4.25);
+  GPR_ASSERT(gpr_histogram_variance(h1) == 5.0625);
+  GPR_ASSERT(gpr_histogram_stddev(h1) == 2.25);
+  gpr_histogram_destroy(h2);
+
+  h2 = gpr_histogram_create(0.05, 1e9);
+  gpr_histogram_add(h2, 7.0);
+  gpr_histogram_add(h2, 17.0);
+  gpr_histogram_add(h2, 1.0);
+  GPR_ASSERT(gpr_histogram_merge(h1, h2) == 1);
+  GPR_ASSERT(gpr_histogram_count(h1) == 7);
+  GPR_ASSERT(gpr_histogram_minimum(h1) == 1.0);
+  GPR_ASSERT(gpr_histogram_maximum(h1) == 17.0);
+  GPR_ASSERT(gpr_histogram_sum(h1) == 42.0);
+  GPR_ASSERT(gpr_histogram_sum_of_squares(h1) == 431.5);
+  GPR_ASSERT(gpr_histogram_mean(h1) == 6.0);
+
+  /* test monotonicity */
+  last = 0.0;
+  for (i = 0; i < 100.0; i += 0.01) {
+    cur = gpr_histogram_percentile(h1, i);
+    GPR_ASSERT(cur >= last);
+    last = cur;
+  }
+
+  gpr_histogram_destroy(h1);
+  gpr_histogram_destroy(h2);
+}
+
+int main(void) {
+  test_no_op();
+  test_simple();
+  test_percentile();
+  test_merge();
+  return 0;
+}
diff --git a/test/core/support/host_port_test.c b/test/core/support/host_port_test.c
new file mode 100644
index 0000000..d1553c5
--- /dev/null
+++ b/test/core/support/host_port_test.c
@@ -0,0 +1,72 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <string.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/host_port.h>
+#include <grpc/support/log.h>
+#include "test/core/util/test_config.h"
+
+static void join_host_port_expect(const char *host, int port,
+                                  const char *expected) {
+  char *buf;
+  int len;
+  len = gpr_join_host_port(&buf, host, port);
+  GPR_ASSERT(strlen(expected) == len);
+  GPR_ASSERT(strcmp(expected, buf) == 0);
+  gpr_free(buf);
+}
+
+static void test_join_host_port() {
+  join_host_port_expect("foo", 101, "foo:101");
+  join_host_port_expect("", 102, ":102");
+  join_host_port_expect("1::2", 103, "[1::2]:103");
+  join_host_port_expect("[::1]", 104, "[::1]:104");
+}
+
+/* Garbage in, garbage out. */
+static void test_join_host_port_garbage() {
+  join_host_port_expect("[foo]", 105, "[foo]:105");
+  join_host_port_expect("[::", 106, "[:::106");
+  join_host_port_expect("::]", 107, "[::]]:107");
+}
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+
+  test_join_host_port();
+  test_join_host_port_garbage();
+
+  return 0;
+}
diff --git a/test/core/support/log_test.c b/test/core/support/log_test.c
new file mode 100644
index 0000000..fbb7c21
--- /dev/null
+++ b/test/core/support/log_test.c
@@ -0,0 +1,47 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <grpc/support/log.h>
+#include "test/core/util/test_config.h"
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  /* test logging at various verbosity levels */
+  gpr_log(GPR_DEBUG, "%s", "hello world");
+  gpr_log(GPR_INFO, "%s", "hello world");
+  gpr_log(GPR_ERROR, "%s", "hello world");
+  /* should succeed */
+  GPR_ASSERT(1);
+  /* TODO(ctiller): should we add a GPR_ASSERT failure test here */
+  return 0;
+}
diff --git a/test/core/support/murmur_hash_test.c b/test/core/support/murmur_hash_test.c
new file mode 100644
index 0000000..366bcb2
--- /dev/null
+++ b/test/core/support/murmur_hash_test.c
@@ -0,0 +1,87 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/support/murmur_hash.h"
+#include <grpc/support/log.h>
+#include "test/core/util/test_config.h"
+
+#include <string.h>
+
+typedef gpr_uint32 (*hash_func)(const void *key, size_t len, gpr_uint32 seed);
+
+/* From smhasher:
+   This should hopefully be a thorough and uambiguous test of whether a hash
+   is correctly implemented on a given platform */
+
+static void verification_test(hash_func hash, gpr_uint32 expected) {
+  gpr_uint8 key[256];
+  gpr_uint32 hashes[256];
+  gpr_uint32 final = 0;
+  int i;
+
+  memset(key, 0, sizeof(key));
+  memset(hashes, 0, sizeof(hashes));
+
+  /* Hash keys of the form {0}, {0,1}, {0,1,2}... up to N=255,using 256-N as
+     the seed */
+
+  for (i = 0; i < 256; i++) {
+    key[i] = (uint8_t)i;
+    hashes[i] = hash(key, i, 256 - i);
+  }
+
+  /* Then hash the result array */
+
+  final = hash(hashes, sizeof(hashes), 0);
+
+  /* The first four bytes of that hash, interpreted as a little-endian integer,
+     is our
+     verification value */
+
+  if (expected != final) {
+    gpr_log(GPR_INFO, "Verification value 0x%08X : Failed! (Expected 0x%08x)",
+            final, expected);
+    abort();
+  } else {
+    gpr_log(GPR_INFO, "Verification value 0x%08X : Passed!", final);
+  }
+}
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  /* basic tests to verify that things don't crash */
+  gpr_murmur_hash3("", 0, 0);
+  gpr_murmur_hash3("xyz", 3, 0);
+  verification_test(gpr_murmur_hash3, 0xB0F57EE3);
+  return 0;
+}
diff --git a/test/core/support/slice_buffer_test.c b/test/core/support/slice_buffer_test.c
new file mode 100644
index 0000000..030d1d4
--- /dev/null
+++ b/test/core/support/slice_buffer_test.c
@@ -0,0 +1,70 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <grpc/support/log.h>
+#include <grpc/support/slice_buffer.h>
+#include "test/core/util/test_config.h"
+
+int main(int argc, char **argv) {
+  gpr_slice_buffer buf;
+  gpr_slice aaa = gpr_slice_from_copied_string("aaa");
+  gpr_slice bb = gpr_slice_from_copied_string("bb");
+  size_t i;
+
+  grpc_test_init(argc, argv);
+  gpr_slice_buffer_init(&buf);
+  for (i = 0; i < 10; i++) {
+    gpr_slice_ref(aaa);
+    gpr_slice_ref(bb);
+    gpr_slice_buffer_add(&buf, aaa);
+    gpr_slice_buffer_add(&buf, bb);
+  }
+  GPR_ASSERT(buf.count > 0);
+  GPR_ASSERT(buf.length == 50);
+  gpr_slice_buffer_reset_and_unref(&buf);
+  GPR_ASSERT(buf.count == 0);
+  GPR_ASSERT(buf.length == 0);
+  for (i = 0; i < 10; i++) {
+    gpr_slice_ref(aaa);
+    gpr_slice_ref(bb);
+    gpr_slice_buffer_add(&buf, aaa);
+    gpr_slice_buffer_add(&buf, bb);
+  }
+  GPR_ASSERT(buf.count > 0);
+  GPR_ASSERT(buf.length == 50);
+  gpr_slice_unref(aaa);
+  gpr_slice_unref(bb);
+  gpr_slice_buffer_destroy(&buf);
+
+  return 0;
+}
diff --git a/test/core/support/slice_test.c b/test/core/support/slice_test.c
new file mode 100644
index 0000000..4044034
--- /dev/null
+++ b/test/core/support/slice_test.c
@@ -0,0 +1,227 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <grpc/support/slice.h>
+
+#include <string.h>
+
+#include <grpc/support/log.h>
+#include "test/core/util/test_config.h"
+
+#define LOG_TEST_NAME() gpr_log(GPR_INFO, "%s", __FUNCTION__);
+
+static void test_slice_malloc_returns_something_sensible() {
+  /* Calls gpr_slice_create for various lengths and verifies the internals for
+     consistency. */
+  size_t length;
+  size_t i;
+  gpr_slice slice;
+
+  LOG_TEST_NAME();
+
+  for (length = 0; length <= 1024; length++) {
+    slice = gpr_slice_malloc(length);
+    /* If there is a length, slice.data must be non-NULL. If length is zero
+       we don't care. */
+    if (length) {
+      GPR_ASSERT(GPR_SLICE_START_PTR(slice));
+    }
+    /* Returned slice length must be what was requested. */
+    GPR_ASSERT(GPR_SLICE_LENGTH(slice) == length);
+    /* If the slice has a refcount, it must be destroyable. */
+    if (slice.refcount) {
+      GPR_ASSERT(slice.refcount->ref != NULL);
+      GPR_ASSERT(slice.refcount->unref != NULL);
+    }
+    /* We must be able to write to every byte of the data */
+    for (i = 0; i < length; i++) {
+      GPR_SLICE_START_PTR(slice)[i] = (char)i;
+    }
+    /* And finally we must succeed in destroying the slice */
+    gpr_slice_unref(slice);
+  }
+}
+
+static void do_nothing(void *ignored) {}
+
+static void test_slice_new_returns_something_sensible() {
+  gpr_uint8 x;
+
+  gpr_slice slice = gpr_slice_new(&x, 1, do_nothing);
+  GPR_ASSERT(slice.refcount);
+  GPR_ASSERT(slice.data.refcounted.bytes == &x);
+  GPR_ASSERT(slice.data.refcounted.length == 1);
+  gpr_slice_unref(slice);
+}
+
+static int do_nothing_with_len_1_calls = 0;
+
+static void do_nothing_with_len_1(void *ignored, size_t len) {
+  GPR_ASSERT(len == 1);
+  do_nothing_with_len_1_calls++;
+}
+
+static void test_slice_new_with_len_returns_something_sensible() {
+  gpr_uint8 x;
+
+  gpr_slice slice = gpr_slice_new_with_len(&x, 1, do_nothing_with_len_1);
+  GPR_ASSERT(slice.refcount);
+  GPR_ASSERT(slice.data.refcounted.bytes == &x);
+  GPR_ASSERT(slice.data.refcounted.length == 1);
+  GPR_ASSERT(do_nothing_with_len_1_calls == 0);
+  gpr_slice_unref(slice);
+  GPR_ASSERT(do_nothing_with_len_1_calls == 1);
+}
+
+static void test_slice_sub_works(int length) {
+  gpr_slice slice;
+  gpr_slice sub;
+  int i, j, k;
+
+  LOG_TEST_NAME();
+  gpr_log(GPR_INFO, "length=%d", length);
+
+  /* Create a slice in which each byte is equal to the distance from it to the
+     beginning of the slice. */
+  slice = gpr_slice_malloc(length);
+  for (i = 0; i < length; i++) {
+    GPR_SLICE_START_PTR(slice)[i] = i;
+  }
+
+  /* Ensure that for all subsets length is correct and that we start on the
+     correct byte. Additionally check that no copies were made. */
+  for (i = 0; i < length; i++) {
+    for (j = i; j < length; j++) {
+      sub = gpr_slice_sub(slice, i, j);
+      GPR_ASSERT(GPR_SLICE_LENGTH(sub) == j - i);
+      for (k = 0; k < j - i; k++) {
+        GPR_ASSERT(GPR_SLICE_START_PTR(sub)[k] == (gpr_uint8)(i + k));
+      }
+      gpr_slice_unref(sub);
+    }
+  }
+  gpr_slice_unref(slice);
+}
+
+static void check_head_tail(gpr_slice slice, gpr_slice head, gpr_slice tail) {
+  GPR_ASSERT(GPR_SLICE_LENGTH(slice) ==
+             GPR_SLICE_LENGTH(head) + GPR_SLICE_LENGTH(tail));
+  GPR_ASSERT(0 == memcmp(GPR_SLICE_START_PTR(slice), GPR_SLICE_START_PTR(head),
+                         GPR_SLICE_LENGTH(head)));
+  GPR_ASSERT(0 == memcmp(GPR_SLICE_START_PTR(slice) + GPR_SLICE_LENGTH(head),
+                         GPR_SLICE_START_PTR(tail), GPR_SLICE_LENGTH(tail)));
+}
+
+static void test_slice_split_head_works(int length) {
+  gpr_slice slice;
+  gpr_slice head, tail;
+  int i;
+
+  LOG_TEST_NAME();
+  gpr_log(GPR_INFO, "length=%d", length);
+
+  /* Create a slice in which each byte is equal to the distance from it to the
+     beginning of the slice. */
+  slice = gpr_slice_malloc(length);
+  for (i = 0; i < length; i++) {
+    GPR_SLICE_START_PTR(slice)[i] = i;
+  }
+
+  /* Ensure that for all subsets length is correct and that we start on the
+     correct byte. Additionally check that no copies were made. */
+  for (i = 0; i < length; i++) {
+    tail = gpr_slice_ref(slice);
+    head = gpr_slice_split_head(&tail, i);
+    check_head_tail(slice, head, tail);
+    gpr_slice_unref(tail);
+    gpr_slice_unref(head);
+  }
+
+  gpr_slice_unref(slice);
+}
+
+static void test_slice_split_tail_works(int length) {
+  gpr_slice slice;
+  gpr_slice head, tail;
+  int i;
+
+  LOG_TEST_NAME();
+  gpr_log(GPR_INFO, "length=%d", length);
+
+  /* Create a slice in which each byte is equal to the distance from it to the
+     beginning of the slice. */
+  slice = gpr_slice_malloc(length);
+  for (i = 0; i < length; i++) {
+    GPR_SLICE_START_PTR(slice)[i] = i;
+  }
+
+  /* Ensure that for all subsets length is correct and that we start on the
+     correct byte. Additionally check that no copies were made. */
+  for (i = 0; i < length; i++) {
+    head = gpr_slice_ref(slice);
+    tail = gpr_slice_split_tail(&head, i);
+    check_head_tail(slice, head, tail);
+    gpr_slice_unref(tail);
+    gpr_slice_unref(head);
+  }
+
+  gpr_slice_unref(slice);
+}
+
+static void test_slice_from_copied_string_works() {
+  static const char *text = "HELLO WORLD!";
+  gpr_slice slice;
+
+  LOG_TEST_NAME();
+
+  slice = gpr_slice_from_copied_string(text);
+  GPR_ASSERT(strlen(text) == GPR_SLICE_LENGTH(slice));
+  GPR_ASSERT(0 ==
+             memcmp(text, GPR_SLICE_START_PTR(slice), GPR_SLICE_LENGTH(slice)));
+  gpr_slice_unref(slice);
+}
+
+int main(int argc, char **argv) {
+  int length;
+  grpc_test_init(argc, argv);
+  test_slice_malloc_returns_something_sensible();
+  test_slice_new_returns_something_sensible();
+  test_slice_new_with_len_returns_something_sensible();
+  for (length = 0; length < 128; length++) {
+    test_slice_sub_works(length);
+    test_slice_split_head_works(length);
+    test_slice_split_tail_works(length);
+  }
+  test_slice_from_copied_string_works();
+  return 0;
+}
diff --git a/test/core/support/string_test.c b/test/core/support/string_test.c
new file mode 100644
index 0000000..1e8039b
--- /dev/null
+++ b/test/core/support/string_test.c
@@ -0,0 +1,158 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <grpc/support/string.h>
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/useful.h>
+#include "test/core/util/test_config.h"
+
+#define LOG_TEST_NAME() gpr_log(GPR_INFO, "%s", __FUNCTION__)
+
+static void test_strdup() {
+  static const char *src1 = "hello world";
+  char *dst1;
+
+  LOG_TEST_NAME();
+
+  dst1 = gpr_strdup(src1);
+  GPR_ASSERT(0 == strcmp(src1, dst1));
+  gpr_free(dst1);
+
+  GPR_ASSERT(NULL == gpr_strdup(NULL));
+}
+
+static void expect_hexdump(const char *buf, size_t len, gpr_uint32 flags,
+                           const char *result) {
+  char *got = gpr_hexdump(buf, len, flags);
+  GPR_ASSERT(0 == strcmp(got, result));
+  gpr_free(got);
+}
+
+static void test_hexdump() {
+  LOG_TEST_NAME();
+  expect_hexdump("\x01", 1, 0, "01");
+  expect_hexdump("\x01", 1, GPR_HEXDUMP_PLAINTEXT, "01 '.'");
+  expect_hexdump("\x01\x02", 2, 0, "01 02");
+  expect_hexdump("\x01\x23\x45\x67\x89\xab\xcd\xef", 8, 0,
+                 "01 23 45 67 89 ab cd ef");
+  expect_hexdump("ab", 2, GPR_HEXDUMP_PLAINTEXT, "61 62 'ab'");
+}
+
+static void test_pu32_fail(const char *s) {
+  gpr_uint32 out;
+  GPR_ASSERT(!gpr_parse_bytes_to_uint32(s, strlen(s), &out));
+}
+
+static void test_pu32_succeed(const char *s, gpr_uint32 want) {
+  gpr_uint32 out;
+  GPR_ASSERT(gpr_parse_bytes_to_uint32(s, strlen(s), &out));
+  GPR_ASSERT(out == want);
+}
+
+static void test_parse_uint32() {
+  LOG_TEST_NAME();
+
+  test_pu32_fail("-1");
+  test_pu32_fail("a");
+  test_pu32_fail("");
+  test_pu32_succeed("0", 0);
+  test_pu32_succeed("1", 1);
+  test_pu32_succeed("2", 2);
+  test_pu32_succeed("3", 3);
+  test_pu32_succeed("4", 4);
+  test_pu32_succeed("5", 5);
+  test_pu32_succeed("6", 6);
+  test_pu32_succeed("7", 7);
+  test_pu32_succeed("8", 8);
+  test_pu32_succeed("9", 9);
+  test_pu32_succeed("10", 10);
+  test_pu32_succeed("11", 11);
+  test_pu32_succeed("12", 12);
+  test_pu32_succeed("13", 13);
+  test_pu32_succeed("14", 14);
+  test_pu32_succeed("15", 15);
+  test_pu32_succeed("16", 16);
+  test_pu32_succeed("17", 17);
+  test_pu32_succeed("18", 18);
+  test_pu32_succeed("19", 19);
+  test_pu32_succeed("1234567890", 1234567890);
+  test_pu32_succeed("4294967295", 4294967295u);
+  test_pu32_fail("4294967296");
+  test_pu32_fail("4294967297");
+  test_pu32_fail("4294967298");
+  test_pu32_fail("4294967299");
+}
+
+static void test_asprintf() {
+  char *buf;
+  int i, j;
+
+  LOG_TEST_NAME();
+
+  /* Print an empty string. */
+  GPR_ASSERT(gpr_asprintf(&buf, "") == 0);
+  GPR_ASSERT(buf[0] == '\0');
+  gpr_free(buf);
+
+  /* Print an invalid format. */
+  GPR_ASSERT(gpr_asprintf(&buf, "%") == -1);
+  GPR_ASSERT(buf == NULL);
+
+  /* Print strings of various lengths. */
+  for (i = 1; i < 100; i++) {
+    GPR_ASSERT(gpr_asprintf(&buf, "%0*d", i, 1) == i);
+
+    /* The buffer should resemble "000001\0". */
+    for (j = 0; j < i - 2; j++) {
+      GPR_ASSERT(buf[j] == '0');
+    }
+    GPR_ASSERT(buf[i - 1] == '1');
+    GPR_ASSERT(buf[i] == '\0');
+    gpr_free(buf);
+  }
+}
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  test_strdup();
+  test_hexdump();
+  test_parse_uint32();
+  test_asprintf();
+  return 0;
+}
diff --git a/test/core/support/sync_test.c b/test/core/support/sync_test.c
new file mode 100644
index 0000000..93f9c4c
--- /dev/null
+++ b/test/core/support/sync_test.c
@@ -0,0 +1,451 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/* Test of gpr synchronization support. */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/thd.h>
+#include <grpc/support/time.h>
+#include "test/core/util/test_config.h"
+
+/* ==================Example use of interface===================
+
+   A producer-consumer queue of up to N integers,
+   illustrating the use of the calls in this interface.  */
+
+#define N 4
+
+typedef struct queue {
+  gpr_cv non_empty; /* Signalled when length becomes non-zero. */
+  gpr_cv non_full;  /* Signalled when length becomes non-N. */
+  gpr_mu mu;        /* Protects all fields below.
+                        (That is, except during initialization or
+                        destruction, the fields below should be accessed
+                        only by a thread that holds mu.) */
+  int head;         /* Index of head of queue 0..N-1. */
+  int length;       /* Number of valid elements in queue 0..N. */
+  int elem[N];      /* elem[head .. head+length-1] are queue elements. */
+} queue;
+
+/* Initialize *q. */
+void queue_init(queue *q) {
+  gpr_mu_init(&q->mu);
+  gpr_cv_init(&q->non_empty);
+  gpr_cv_init(&q->non_full);
+  q->head = 0;
+  q->length = 0;
+}
+
+/* Free storage associated with *q. */
+void queue_destroy(queue *q) {
+  gpr_mu_destroy(&q->mu);
+  gpr_cv_destroy(&q->non_empty);
+  gpr_cv_destroy(&q->non_full);
+}
+
+/* Wait until there is room in *q, then append x to *q. */
+void queue_append(queue *q, int x) {
+  gpr_mu_lock(&q->mu);
+  /* To wait for a predicate without a deadline, loop on the negation of the
+     predicate, and use gpr_cv_wait(..., gpr_inf_future) inside the loop
+     to release the lock, wait, and reacquire on each iteration.  Code that
+     makes the condition true should use gpr_cv_broadcast() on the
+     corresponding condition variable.  The predicate must be on state
+     protected by the lock.  */
+  while (q->length == N) {
+    gpr_cv_wait(&q->non_full, &q->mu, gpr_inf_future);
+  }
+  if (q->length == 0) { /* Wake threads blocked in queue_remove(). */
+    /* It's normal to use gpr_cv_broadcast() or gpr_signal() while
+       holding the lock. */
+    gpr_cv_broadcast(&q->non_empty);
+  }
+  q->elem[(q->head + q->length) % N] = x;
+  q->length++;
+  gpr_mu_unlock(&q->mu);
+}
+
+/* If it can be done without blocking, append x to *q and return non-zero.
+   Otherwise return 0. */
+int queue_try_append(queue *q, int x) {
+  int result = 0;
+  if (gpr_mu_trylock(&q->mu)) {
+    if (q->length != N) {
+      if (q->length == 0) { /* Wake threads blocked in queue_remove(). */
+        gpr_cv_broadcast(&q->non_empty);
+      }
+      q->elem[(q->head + q->length) % N] = x;
+      q->length++;
+      result = 1;
+    }
+    gpr_mu_unlock(&q->mu);
+  }
+  return result;
+}
+
+/* Wait until the *q is non-empty or deadline abs_deadline passes.  If the
+   queue is non-empty, remove its head entry, place it in *head, and return
+   non-zero.  Otherwise return 0.  */
+int queue_remove(queue *q, int *head, gpr_timespec abs_deadline) {
+  int result = 0;
+  gpr_mu_lock(&q->mu);
+  /* To wait for a predicate with a deadline, loop on the negation of the
+     predicate or until gpr_cv_wait() returns true.  Code that makes
+     the condition true should use gpr_cv_broadcast() on the corresponding
+     condition variable.  The predicate must be on state protected by the
+     lock. */
+  while (q->length == 0 && !gpr_cv_wait(&q->non_empty, &q->mu, abs_deadline)) {
+  }
+  if (q->length != 0) { /* Queue is non-empty. */
+    result = 1;
+    if (q->length == N) { /* Wake threads blocked in queue_append(). */
+      gpr_cv_broadcast(&q->non_full);
+    }
+    *head = q->elem[q->head];
+    q->head = (q->head + 1) % N;
+    q->length--;
+  } /* else deadline exceeded */
+  gpr_mu_unlock(&q->mu);
+  return result;
+}
+
+/* ------------------------------------------------- */
+/* Tests for gpr_mu and gpr_cv, and the queue example. */
+struct test {
+  int threads; /* number of threads */
+
+  gpr_int64 iterations; /* number of iterations per thread */
+  gpr_int64 counter;
+  int thread_count; /* used to allocate thread ids */
+  int done;         /* threads not yet completed */
+
+  gpr_mu mu; /* protects iterations, counter, thread_count, done */
+
+  gpr_cv cv; /* signalling depends on test */
+
+  gpr_cv done_cv; /* signalled when done == 0 */
+
+  queue q;
+
+  gpr_stats_counter stats_counter;
+
+  gpr_refcount refcount;
+  gpr_refcount thread_refcount;
+  gpr_event event;
+};
+
+/* Return pointer to a new struct test. */
+static struct test *test_new(int threads, gpr_int64 iterations) {
+  struct test *m = gpr_malloc(sizeof(*m));
+  m->threads = threads;
+  m->iterations = iterations;
+  m->counter = 0;
+  m->thread_count = 0;
+  m->done = threads;
+  gpr_mu_init(&m->mu);
+  gpr_cv_init(&m->cv);
+  gpr_cv_init(&m->done_cv);
+  queue_init(&m->q);
+  gpr_stats_init(&m->stats_counter, 0);
+  gpr_ref_init(&m->refcount, 0);
+  gpr_ref_init(&m->thread_refcount, threads);
+  gpr_event_init(&m->event);
+  return m;
+}
+
+/* Return pointer to a new struct test. */
+static void test_destroy(struct test *m) {
+  gpr_mu_destroy(&m->mu);
+  gpr_cv_destroy(&m->cv);
+  gpr_cv_destroy(&m->done_cv);
+  queue_destroy(&m->q);
+  gpr_free(m);
+}
+
+/* Create m->threads threads, each running (*body)(m) */
+static void test_create_threads(struct test *m, void (*body)(void *arg)) {
+  gpr_thd_id id;
+  int i;
+  for (i = 0; i != m->threads; i++) {
+    GPR_ASSERT(gpr_thd_new(&id, body, m, NULL));
+  }
+}
+
+/* Wait until all threads report done. */
+static void test_wait(struct test *m) {
+  gpr_mu_lock(&m->mu);
+  while (m->done != 0) {
+    gpr_cv_wait(&m->done_cv, &m->mu, gpr_inf_future);
+  }
+  gpr_mu_unlock(&m->mu);
+}
+
+/* Get an integer thread id in the raneg 0..threads-1 */
+static int thread_id(struct test *m) {
+  int id;
+  gpr_mu_lock(&m->mu);
+  id = m->thread_count++;
+  gpr_mu_unlock(&m->mu);
+  return id;
+}
+
+/* Indicate that a thread is done, by decrementing m->done
+   and signalling done_cv if m->done==0. */
+static void mark_thread_done(struct test *m) {
+  gpr_mu_lock(&m->mu);
+  GPR_ASSERT(m->done != 0);
+  m->done--;
+  if (m->done == 0) {
+    gpr_cv_signal(&m->done_cv);
+  }
+  gpr_mu_unlock(&m->mu);
+}
+
+/* Test several threads running (*body)(struct test *m) for increasing settings
+   of m->iterations, until about timeout_s to 2*timeout_s seconds have elapsed.
+   If extra!=NULL, run (*extra)(m) in an additional thread.  */
+static void test(const char *name, void (*body)(void *m),
+                 void (*extra)(void *m), int timeout_s) {
+  gpr_int64 iterations = 1024;
+  struct test *m;
+  gpr_timespec start = gpr_now();
+  gpr_timespec time_taken;
+  gpr_timespec deadline =
+      gpr_time_add(start, gpr_time_from_micros(timeout_s * 1000000));
+  fprintf(stderr, "%s:", name);
+  while (gpr_time_cmp(gpr_now(), deadline) < 0) {
+    iterations <<= 1;
+    fprintf(stderr, " %ld", (long)iterations);
+    m = test_new(10, iterations);
+    if (extra != NULL) {
+      gpr_thd_id id;
+      GPR_ASSERT(gpr_thd_new(&id, extra, m, NULL));
+      m->done++; /* one more thread to wait for */
+    }
+    test_create_threads(m, body);
+    test_wait(m);
+    if (m->counter != m->threads * m->iterations) {
+      fprintf(stderr, "counter %ld  threads %d  iterations %ld\n",
+              (long)m->counter, m->threads, (long)m->iterations);
+      GPR_ASSERT(0);
+    }
+    test_destroy(m);
+  }
+  time_taken = gpr_time_sub(gpr_now(), start);
+  fprintf(stderr, " done %ld.%09d s\n", (long)time_taken.tv_sec,
+          (int)time_taken.tv_nsec);
+}
+
+/* Increment m->counter on each iteration; then mark thread as done.  */
+static void inc(void *v /*=m*/) {
+  struct test *m = v;
+  gpr_int64 i;
+  for (i = 0; i != m->iterations; i++) {
+    gpr_mu_lock(&m->mu);
+    m->counter++;
+    gpr_mu_unlock(&m->mu);
+  }
+  mark_thread_done(m);
+}
+
+/* Increment m->counter under lock acquired with trylock, m->iterations times;
+   then mark thread as done.  */
+static void inctry(void *v /*=m*/) {
+  struct test *m = v;
+  gpr_int64 i;
+  for (i = 0; i != m->iterations;) {
+    if (gpr_mu_trylock(&m->mu)) {
+      m->counter++;
+      gpr_mu_unlock(&m->mu);
+      i++;
+    }
+  }
+  mark_thread_done(m);
+}
+
+/* Increment counter only when (m->counter%m->threads)==m->thread_id; then mark
+   thread as done.  */
+static void inc_by_turns(void *v /*=m*/) {
+  struct test *m = v;
+  gpr_int64 i;
+  int id = thread_id(m);
+  for (i = 0; i != m->iterations; i++) {
+    gpr_mu_lock(&m->mu);
+    while ((m->counter % m->threads) != id) {
+      gpr_cv_wait(&m->cv, &m->mu, gpr_inf_future);
+    }
+    m->counter++;
+    gpr_cv_broadcast(&m->cv);
+    gpr_mu_unlock(&m->mu);
+  }
+  mark_thread_done(m);
+}
+
+/* Wait a millisecond and increment counter on each iteration;
+   then mark thread as done. */
+static void inc_with_1ms_delay(void *v /*=m*/) {
+  struct test *m = v;
+  gpr_int64 i;
+  for (i = 0; i != m->iterations; i++) {
+    gpr_timespec deadline;
+    gpr_mu_lock(&m->mu);
+    deadline = gpr_time_add(gpr_now(), gpr_time_from_micros(1000));
+    while (!gpr_cv_wait(&m->cv, &m->mu, deadline)) {
+    }
+    m->counter++;
+    gpr_mu_unlock(&m->mu);
+  }
+  mark_thread_done(m);
+}
+
+/* Wait a millisecond and increment counter on each iteration, using an event
+   for timing; then mark thread as done. */
+static void inc_with_1ms_delay_event(void *v /*=m*/) {
+  struct test *m = v;
+  gpr_int64 i;
+  for (i = 0; i != m->iterations; i++) {
+    gpr_timespec deadline;
+    deadline = gpr_time_add(gpr_now(), gpr_time_from_micros(1000));
+    GPR_ASSERT(gpr_event_wait(&m->event, deadline) == NULL);
+    gpr_mu_lock(&m->mu);
+    m->counter++;
+    gpr_mu_unlock(&m->mu);
+  }
+  mark_thread_done(m);
+}
+
+/* Produce m->iterations elements on queue m->q, then mark thread as done.
+   Even threads use queue_append(), and odd threads use queue_try_append()
+   until it succeeds. */
+static void many_producers(void *v /*=m*/) {
+  struct test *m = v;
+  gpr_int64 i;
+  int x = thread_id(m);
+  if ((x & 1) == 0) {
+    for (i = 0; i != m->iterations; i++) {
+      queue_append(&m->q, 1);
+    }
+  } else {
+    for (i = 0; i != m->iterations; i++) {
+      while (!queue_try_append(&m->q, 1)) {
+      }
+    }
+  }
+  mark_thread_done(m);
+}
+
+/* Consume elements from m->q until m->threads*m->iterations are seen,
+   wait an extra second to confirm that no more elements are arriving,
+   then mark thread as done. */
+static void consumer(void *v /*=m*/) {
+  struct test *m = v;
+  gpr_int64 n = m->iterations * m->threads;
+  gpr_int64 i;
+  int value;
+  for (i = 0; i != n; i++) {
+    queue_remove(&m->q, &value, gpr_inf_future);
+  }
+  gpr_mu_lock(&m->mu);
+  m->counter = n;
+  gpr_mu_unlock(&m->mu);
+  GPR_ASSERT(
+      !queue_remove(&m->q, &value,
+                    gpr_time_add(gpr_now(), gpr_time_from_micros(1000000))));
+  mark_thread_done(m);
+}
+
+/* Increment m->stats_counter m->iterations times, transfer counter value to
+   m->counter, then mark thread as done.  */
+static void statsinc(void *v /*=m*/) {
+  struct test *m = v;
+  gpr_int64 i;
+  for (i = 0; i != m->iterations; i++) {
+    gpr_stats_inc(&m->stats_counter, 1);
+  }
+  gpr_mu_lock(&m->mu);
+  m->counter = gpr_stats_read(&m->stats_counter);
+  gpr_mu_unlock(&m->mu);
+  mark_thread_done(m);
+}
+
+/* Increment m->refcount m->iterations times, decrement m->thread_refcount
+   once, and if it reaches zero, set m->event to (void*)1; then mark thread as
+   done.  */
+static void refinc(void *v /*=m*/) {
+  struct test *m = v;
+  gpr_int64 i;
+  for (i = 0; i != m->iterations; i++) {
+    gpr_ref(&m->refcount);
+  }
+  if (gpr_unref(&m->thread_refcount)) {
+    gpr_event_set(&m->event, (void *)1);
+  }
+  mark_thread_done(m);
+}
+
+/* Wait until m->event is set to (void *)1, then decrement m->refcount
+   m->stats_counter m->iterations times, and ensure that the last decrement
+   caused the counter to reach zero, then mark thread as done.  */
+static void refcheck(void *v /*=m*/) {
+  struct test *m = v;
+  gpr_int64 n = m->iterations * m->threads;
+  gpr_int64 i;
+  GPR_ASSERT(gpr_event_wait(&m->event, gpr_inf_future) == (void *)1);
+  GPR_ASSERT(gpr_event_get(&m->event) == (void *)1);
+  for (i = 1; i != n; i++) {
+    GPR_ASSERT(!gpr_unref(&m->refcount));
+    m->counter++;
+  }
+  GPR_ASSERT(gpr_unref(&m->refcount));
+  m->counter++;
+  mark_thread_done(m);
+}
+
+/* ------------------------------------------------- */
+
+int main(int argc, char *argv[]) {
+  grpc_test_init(argc, argv);
+  test("mutex", &inc, NULL, 1);
+  test("mutex try", &inctry, NULL, 1);
+  test("cv", &inc_by_turns, NULL, 1);
+  test("timedcv", &inc_with_1ms_delay, NULL, 1);
+  test("queue", &many_producers, &consumer, 10);
+  test("stats_counter", &statsinc, NULL, 1);
+  test("refcount", &refinc, &refcheck, 1);
+  test("timedevent", &inc_with_1ms_delay_event, NULL, 1);
+  return 0;
+}
diff --git a/test/core/support/thd_test.c b/test/core/support/thd_test.c
new file mode 100644
index 0000000..c70e025
--- /dev/null
+++ b/test/core/support/thd_test.c
@@ -0,0 +1,90 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/* Test of gpr thread support. */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/thd.h>
+#include <grpc/support/time.h>
+#include "test/core/util/test_config.h"
+
+struct test {
+  gpr_mu mu;
+  int n;
+  int is_done;
+  gpr_cv done_cv;
+};
+
+/* A Thread body.   Decrement t->n, and if is becomes zero, set t->done. */
+static void thd_body(void *v) {
+  struct test *t = v;
+  gpr_mu_lock(&t->mu);
+  t->n--;
+  if (t->n == 0) {
+    t->is_done = 1;
+    gpr_cv_signal(&t->done_cv);
+  }
+  gpr_mu_unlock(&t->mu);
+}
+
+/* Test that we can create a number of threads and wait for them. */
+static void test(void) {
+  int i;
+  gpr_thd_id thd;
+  struct test t;
+  int n = 1000;
+  gpr_mu_init(&t.mu);
+  gpr_cv_init(&t.done_cv);
+  t.n = n;
+  t.is_done = 0;
+  for (i = 0; i != n; i++) {
+    GPR_ASSERT(gpr_thd_new(&thd, &thd_body, &t, NULL));
+  }
+  gpr_mu_lock(&t.mu);
+  while (!t.is_done) {
+    gpr_cv_wait(&t.done_cv, &t.mu, gpr_inf_future);
+  }
+  gpr_mu_unlock(&t.mu);
+  GPR_ASSERT(t.n == 0);
+}
+
+/* ------------------------------------------------- */
+
+int main(int argc, char *argv[]) {
+  grpc_test_init(argc, argv);
+  test();
+  return 0;
+}
diff --git a/test/core/support/time_test.c b/test/core/support/time_test.c
new file mode 100644
index 0000000..d74d6a5
--- /dev/null
+++ b/test/core/support/time_test.c
@@ -0,0 +1,255 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/* Test of gpr time support. */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/thd.h>
+#include <grpc/support/time.h>
+#include "test/core/util/test_config.h"
+
+static void to_fp(void *arg, const char *buf, int len) {
+  fwrite(buf, 1, len, (FILE *)arg);
+}
+
+/* Convert gpr_uintmax x to ascii base b (2..16), and write with
+   (*writer)(arg, ...), zero padding to "chars" digits).  */
+static void u_to_s(gpr_uintmax x, unsigned base, int chars,
+                   void (*writer)(void *arg, const char *buf, int len),
+                   void *arg) {
+  char buf[64];
+  char *p = buf + sizeof(buf);
+  do {
+    *--p = "0123456789abcdef"[x % base];
+    x /= base;
+    chars--;
+  } while (x != 0 || chars > 0);
+  (*writer)(arg, p, buf + sizeof(buf) - p);
+}
+
+/* Convert gpr_intmax x to ascii base b (2..16), and write with
+   (*writer)(arg, ...), zero padding to "chars" digits).  */
+static void i_to_s(gpr_intmax x, unsigned base, int chars,
+                   void (*writer)(void *arg, const char *buf, int len),
+                   void *arg) {
+  if (x < 0) {
+    (*writer)(arg, "-", 1);
+    u_to_s(-x, base, chars - 1, writer, arg);
+  } else {
+    u_to_s(x, base, chars, writer, arg);
+  }
+}
+
+/* Convert ts to ascii, and write with (*writer)(arg, ...).  */
+static void ts_to_s(gpr_timespec t,
+                    void (*writer)(void *arg, const char *buf, int len),
+                    void *arg) {
+  if (t.tv_sec < 0 && t.tv_nsec != 0) {
+    t.tv_sec++;
+    t.tv_nsec = 1000000000 - t.tv_nsec;
+  }
+  i_to_s(t.tv_sec, 10, 0, writer, arg);
+  (*writer)(arg, ".", 1);
+  i_to_s(t.tv_nsec, 10, 9, writer, arg);
+}
+
+static void test_values(void) {
+  int i;
+
+  gpr_timespec x = gpr_time_0;
+  GPR_ASSERT(x.tv_sec == 0 && x.tv_nsec == 0);
+
+  x = gpr_inf_future;
+  fprintf(stderr, "far future ");
+  u_to_s(x.tv_sec, 16, 16, &to_fp, stderr);
+  fprintf(stderr, "\n");
+  GPR_ASSERT(x.tv_sec >= INT_MAX);
+  fprintf(stderr, "far future ");
+  ts_to_s(x, &to_fp, stderr);
+  fprintf(stderr, "\n");
+
+  x = gpr_inf_past;
+  fprintf(stderr, "far past   ");
+  u_to_s(x.tv_sec, 16, 16, &to_fp, stderr);
+  fprintf(stderr, "\n");
+  GPR_ASSERT(x.tv_sec <= INT_MIN);
+  fprintf(stderr, "far past   ");
+  ts_to_s(x, &to_fp, stderr);
+  fprintf(stderr, "\n");
+
+  for (i = 1; i != 1000 * 1000 * 1000; i *= 10) {
+    x = gpr_time_from_micros(i);
+    GPR_ASSERT(x.tv_sec == i / GPR_US_PER_SEC &&
+               x.tv_nsec == (i % GPR_US_PER_SEC) * GPR_NS_PER_US);
+    x = gpr_time_from_nanos(i);
+    GPR_ASSERT(x.tv_sec == i / GPR_NS_PER_SEC &&
+               x.tv_nsec == (i % GPR_NS_PER_SEC));
+    x = gpr_time_from_millis(i);
+    GPR_ASSERT(x.tv_sec == i / GPR_MS_PER_SEC &&
+               x.tv_nsec == (i % GPR_MS_PER_SEC) * GPR_NS_PER_MS);
+  }
+
+  /* Test possible overflow in conversion of -ve values. */
+  x = gpr_time_from_micros(-(LONG_MAX - 999997));
+  GPR_ASSERT(x.tv_sec < 0);
+  GPR_ASSERT(x.tv_nsec >= 0 && x.tv_nsec < 1000000000);
+
+  x = gpr_time_from_nanos(-(LONG_MAX - 999999997));
+  GPR_ASSERT(x.tv_sec < 0);
+  GPR_ASSERT(x.tv_nsec >= 0 && x.tv_nsec < 1000000000);
+
+  x = gpr_time_from_millis(-(LONG_MAX - 997));
+  GPR_ASSERT(x.tv_sec < 0);
+  GPR_ASSERT(x.tv_nsec >= 0 && x.tv_nsec < 1000000000);
+
+  /* Test general -ve values. */
+  for (i = -1; i > -1000 * 1000 * 1000; i *= 7) {
+    x = gpr_time_from_micros(i);
+    GPR_ASSERT(x.tv_sec * GPR_US_PER_SEC + x.tv_nsec / GPR_NS_PER_US == i);
+    x = gpr_time_from_nanos(i);
+    GPR_ASSERT(x.tv_sec * GPR_NS_PER_SEC + x.tv_nsec == i);
+    x = gpr_time_from_millis(i);
+    GPR_ASSERT(x.tv_sec * GPR_MS_PER_SEC + x.tv_nsec / GPR_NS_PER_MS == i);
+  }
+}
+
+static void test_add_sub(void) {
+  int i;
+  int j;
+  int k;
+  /* Basic addition and subtraction. */
+  for (i = -100; i <= 100; i++) {
+    for (j = -100; j <= 100; j++) {
+      for (k = 1; k <= 10000000; k *= 10) {
+        int sum = i + j;
+        int diff = i - j;
+        gpr_timespec it = gpr_time_from_micros(i * k);
+        gpr_timespec jt = gpr_time_from_micros(j * k);
+        gpr_timespec sumt = gpr_time_add(it, jt);
+        gpr_timespec difft = gpr_time_sub(it, jt);
+        if (gpr_time_cmp(gpr_time_from_micros(sum * k), sumt) != 0) {
+          fprintf(stderr, "i %d  j %d  sum %d    sumt ", i, j, sum);
+          ts_to_s(sumt, &to_fp, stderr);
+          fprintf(stderr, "\n");
+          GPR_ASSERT(0);
+        }
+        if (gpr_time_cmp(gpr_time_from_micros(diff * k), difft) != 0) {
+          fprintf(stderr, "i %d  j %d  diff %d    diff ", i, j, diff);
+          ts_to_s(sumt, &to_fp, stderr);
+          fprintf(stderr, "\n");
+          GPR_ASSERT(0);
+        }
+      }
+    }
+  }
+}
+
+static void test_overflow(void) {
+  /* overflow */
+  gpr_timespec x = gpr_time_from_micros(1);
+  do {
+    x = gpr_time_add(x, x);
+  } while (gpr_time_cmp(x, gpr_inf_future) < 0);
+  GPR_ASSERT(gpr_time_cmp(x, gpr_inf_future) == 0);
+  x = gpr_time_from_micros(-1);
+  do {
+    x = gpr_time_add(x, x);
+  } while (gpr_time_cmp(x, gpr_inf_past) > 0);
+  GPR_ASSERT(gpr_time_cmp(x, gpr_inf_past) == 0);
+}
+
+static void test_sticky_infinities(void) {
+  int i;
+  int j;
+  int k;
+  static const gpr_timespec *infinity[] = {&gpr_inf_future, &gpr_inf_past};
+  static const gpr_timespec *addend[] = {&gpr_inf_future, &gpr_inf_past,
+                                         &gpr_time_0, NULL};
+
+  /* Infinities are sticky */
+  for (i = 0; i != sizeof(infinity) / sizeof(infinity[0]); i++) {
+    for (j = 0; j != sizeof(addend) / sizeof(addend[0]); j++) {
+      if (addend[j] == NULL) {
+        for (k = -200; k <= 200; k++) {
+          gpr_timespec y = gpr_time_from_micros(k * 100000);
+          gpr_timespec x = gpr_time_add(*infinity[i], y);
+          GPR_ASSERT(gpr_time_cmp(x, *infinity[i]) == 0);
+          x = gpr_time_sub(*infinity[i], y);
+          GPR_ASSERT(gpr_time_cmp(x, *infinity[i]) == 0);
+        }
+      } else {
+        gpr_timespec x = gpr_time_add(*infinity[i], *addend[j]);
+        GPR_ASSERT(gpr_time_cmp(x, *infinity[i]) == 0);
+        x = gpr_time_sub(*infinity[i], *addend[j]);
+        GPR_ASSERT(gpr_time_cmp(x, *infinity[i]) == 0);
+      }
+    }
+  }
+}
+
+static void test_similar() {
+  GPR_ASSERT(1 == gpr_time_similar(gpr_inf_future, gpr_inf_future, gpr_time_0));
+  GPR_ASSERT(1 == gpr_time_similar(gpr_inf_past, gpr_inf_past, gpr_time_0));
+  GPR_ASSERT(0 == gpr_time_similar(gpr_inf_past, gpr_inf_future, gpr_time_0));
+  GPR_ASSERT(0 == gpr_time_similar(gpr_inf_future, gpr_inf_past, gpr_time_0));
+  GPR_ASSERT(1 == gpr_time_similar(gpr_time_from_micros(10),
+                                   gpr_time_from_micros(10), gpr_time_0));
+  GPR_ASSERT(1 == gpr_time_similar(gpr_time_from_micros(10),
+                                   gpr_time_from_micros(15),
+                                   gpr_time_from_micros(10)));
+  GPR_ASSERT(1 == gpr_time_similar(gpr_time_from_micros(15),
+                                   gpr_time_from_micros(10),
+                                   gpr_time_from_micros(10)));
+  GPR_ASSERT(0 == gpr_time_similar(gpr_time_from_micros(10),
+                                   gpr_time_from_micros(25),
+                                   gpr_time_from_micros(10)));
+  GPR_ASSERT(0 == gpr_time_similar(gpr_time_from_micros(25),
+                                   gpr_time_from_micros(10),
+                                   gpr_time_from_micros(10)));
+}
+
+int main(int argc, char *argv[]) {
+  grpc_test_init(argc, argv);
+
+  test_values();
+  test_add_sub();
+  test_overflow();
+  test_sticky_infinities();
+  test_similar();
+  return 0;
+}
diff --git a/test/core/surface/byte_buffer_reader_test.c b/test/core/surface/byte_buffer_reader_test.c
new file mode 100644
index 0000000..bc5a512
--- /dev/null
+++ b/test/core/surface/byte_buffer_reader_test.c
@@ -0,0 +1,111 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <grpc/byte_buffer_reader.h>
+#include <grpc/byte_buffer.h>
+#include <grpc/support/slice.h>
+#include <grpc/grpc.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/thd.h>
+#include <grpc/support/time.h>
+#include "test/core/util/test_config.h"
+
+#include <string.h>
+
+#define LOG_TEST() gpr_log(GPR_INFO, "%s", __FUNCTION__)
+
+static void test_create() {
+  grpc_byte_buffer *buffer;
+  grpc_byte_buffer_reader *reader;
+  gpr_slice empty = gpr_empty_slice();
+  LOG_TEST();
+  buffer = grpc_byte_buffer_create(&empty, 1);
+  reader = grpc_byte_buffer_reader_create(buffer);
+  grpc_byte_buffer_reader_destroy(reader);
+  grpc_byte_buffer_destroy(buffer);
+}
+
+static void test_read_one_slice() {
+  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();
+  slice = gpr_slice_from_copied_string("test");
+  buffer = grpc_byte_buffer_create(&slice, 1);
+  gpr_slice_unref(slice);
+  reader = grpc_byte_buffer_reader_create(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_reader_destroy(reader);
+  grpc_byte_buffer_destroy(buffer);
+}
+
+static void test_read_one_slice_malloc() {
+  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();
+  slice = gpr_slice_malloc(4);
+  memcpy(GPR_SLICE_START_PTR(slice), "test", 4);
+  buffer = grpc_byte_buffer_create(&slice, 1);
+  gpr_slice_unref(slice);
+  reader = grpc_byte_buffer_reader_create(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_reader_destroy(reader);
+  grpc_byte_buffer_destroy(buffer);
+}
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  test_create();
+  test_read_one_slice();
+  test_read_one_slice_malloc();
+  return 0;
+}
diff --git a/test/core/surface/completion_queue_benchmark.c b/test/core/surface/completion_queue_benchmark.c
new file mode 100644
index 0000000..5360d7c
--- /dev/null
+++ b/test/core/surface/completion_queue_benchmark.c
@@ -0,0 +1,168 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/surface/completion_queue.h"
+
+#include <math.h>
+#include <stdio.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/thd.h>
+#include <grpc/support/time.h>
+
+typedef struct test_thread_options {
+  gpr_event on_started;
+  gpr_event *start;
+  gpr_event on_finished;
+  grpc_completion_queue *cc;
+  int iterations;
+} test_thread_options;
+
+static void producer_thread(void *arg) {
+  test_thread_options *opt = arg;
+  int i;
+
+  gpr_event_set(&opt->on_started, (void *)(gpr_intptr) 1);
+  GPR_ASSERT(gpr_event_wait(opt->start, gpr_inf_future));
+
+  for (i = 0; i < opt->iterations; i++) {
+    grpc_cq_begin_op(opt->cc, NULL, GRPC_WRITE_ACCEPTED);
+    grpc_cq_end_write_accepted(opt->cc, (void *)(gpr_intptr) 1, NULL, NULL,
+                               NULL, GRPC_OP_OK);
+  }
+
+  gpr_event_set(&opt->on_finished, (void *)(gpr_intptr) 1);
+}
+
+static void consumer_thread(void *arg) {
+  test_thread_options *opt = arg;
+  grpc_event *ev;
+
+  gpr_event_set(&opt->on_started, (void *)(gpr_intptr) 1);
+  GPR_ASSERT(gpr_event_wait(opt->start, gpr_inf_future));
+
+  for (;;) {
+    ev = grpc_completion_queue_next(opt->cc, gpr_inf_future);
+    switch (ev->type) {
+      case GRPC_WRITE_ACCEPTED:
+        break;
+      case GRPC_QUEUE_SHUTDOWN:
+        gpr_event_set(&opt->on_finished, (void *)(gpr_intptr) 1);
+        return;
+      default:
+        gpr_log(GPR_ERROR, "Invalid event received: %d", ev->type);
+        abort();
+    }
+    grpc_event_finish(ev);
+  }
+}
+
+double ops_per_second(int consumers, int producers, int iterations) {
+  test_thread_options *options =
+      gpr_malloc((producers + consumers) * sizeof(test_thread_options));
+  gpr_event start = GPR_EVENT_INIT;
+  grpc_completion_queue *cc = grpc_completion_queue_create();
+  int i;
+  gpr_timespec t_start, t_end, t_delta;
+
+  /* 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_finished);
+    options[i].start = &start;
+    options[i].cc = cc;
+    options[i].iterations = iterations;
+    GPR_ASSERT(gpr_thd_new(&id,
+                           i < producers ? producer_thread : consumer_thread,
+                           options + i, NULL));
+    gpr_event_wait(&options[i].on_started, gpr_inf_future);
+  }
+
+  /* start the benchmark */
+  t_start = gpr_now();
+  gpr_event_set(&start, (void *)(gpr_intptr) 1);
+
+  /* wait for producers to finish */
+  for (i = 0; i < producers; i++) {
+    GPR_ASSERT(gpr_event_wait(&options[i].on_finished, gpr_inf_future));
+  }
+
+  /* in parallel, we shutdown the completion channel - all events should still
+     be consumed */
+  grpc_completion_queue_shutdown(cc);
+
+  /* join all threads */
+  for (i = producers; i < producers + consumers; i++) {
+    GPR_ASSERT(gpr_event_wait(&options[i].on_finished, gpr_inf_future));
+  }
+  t_end = gpr_now();
+
+  /* destroy the completion channel */
+  grpc_completion_queue_destroy(cc);
+
+  gpr_free(options);
+
+  t_delta = gpr_time_sub(t_end, t_start);
+  return (t_delta.tv_sec + 1e-9 * t_delta.tv_nsec) / (producers * iterations);
+}
+
+double ops_per_second_top(int consumers, int producers) {
+  return ops_per_second(consumers, producers, 1000000 / producers);
+}
+
+int main(void) {
+  const int counts[] = {1, 2, 3, 4, 5, 6, 7, 8, 12, 16, 20, 24, 32, 40, 64};
+  const int ncounts = sizeof(counts) / sizeof(*counts);
+  int i, j;
+
+  printf("\"\",");
+  for (i = 0; i < ncounts; i++) {
+    int producers = counts[i];
+    printf("%d%s", producers, i == ncounts - 1 ? "\n" : ",");
+  }
+
+  for (j = 0; j < ncounts; j++) {
+    int consumers = counts[j];
+    printf("%d,", consumers);
+    for (i = 0; i < ncounts; i++) {
+      int producers = counts[i];
+      printf("%f%s", ops_per_second_top(consumers, producers),
+             i == ncounts - 1 ? "\n" : ",");
+      fflush(stdout);
+    }
+  }
+
+  return 0;
+}
diff --git a/test/core/surface/completion_queue_test.c b/test/core/surface/completion_queue_test.c
new file mode 100644
index 0000000..6df159f
--- /dev/null
+++ b/test/core/surface/completion_queue_test.c
@@ -0,0 +1,435 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/surface/completion_queue.h"
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/thd.h>
+#include <grpc/support/time.h>
+#include <grpc/support/useful.h>
+#include "src/core/surface/surface_em.h"
+#include "test/core/util/test_config.h"
+
+#define LOG_TEST() gpr_log(GPR_INFO, "%s", __FUNCTION__)
+
+static void increment_int_on_finish(void *user_data, grpc_op_error error) {
+  ++*(int *)user_data;
+}
+
+static void *create_test_tag() {
+  static gpr_intptr i = 0;
+  return (void *)(++i);
+}
+
+/* helper for tests to shutdown correctly and tersely */
+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_ASSERT(ev != NULL);
+  GPR_ASSERT(ev->type == GRPC_QUEUE_SHUTDOWN);
+  grpc_event_finish(ev);
+  grpc_completion_queue_destroy(cc);
+}
+
+/* ensure we can create and destroy a completion channel */
+static void test_no_op() {
+  LOG_TEST();
+  shutdown_and_destroy(grpc_completion_queue_create());
+}
+
+static void test_wait_empty() {
+  grpc_completion_queue *cc;
+
+  LOG_TEST();
+
+  cc = grpc_completion_queue_create();
+  GPR_ASSERT(grpc_completion_queue_next(cc, gpr_now()) == NULL);
+  shutdown_and_destroy(cc);
+}
+
+static void test_cq_end_read() {
+  grpc_event *ev;
+  grpc_completion_queue *cc;
+  int on_finish_called = 0;
+  void *tag = create_test_tag();
+
+  LOG_TEST();
+
+  cc = grpc_completion_queue_create();
+
+  grpc_cq_begin_op(cc, NULL, GRPC_READ);
+  grpc_cq_end_read(cc, tag, NULL, increment_int_on_finish, &on_finish_called,
+                   NULL);
+
+  ev = grpc_completion_queue_next(cc, gpr_inf_past);
+  GPR_ASSERT(ev != NULL);
+  GPR_ASSERT(ev->type == GRPC_READ);
+  GPR_ASSERT(ev->tag == tag);
+  GPR_ASSERT(ev->data.read == NULL);
+  GPR_ASSERT(on_finish_called == 0);
+  grpc_event_finish(ev);
+  GPR_ASSERT(on_finish_called == 1);
+
+  shutdown_and_destroy(cc);
+}
+
+static void test_cq_end_invoke_accepted() {
+  grpc_event *ev;
+  grpc_completion_queue *cc;
+  int on_finish_called = 0;
+  void *tag = create_test_tag();
+
+  LOG_TEST();
+
+  cc = grpc_completion_queue_create();
+
+  grpc_cq_begin_op(cc, NULL, GRPC_INVOKE_ACCEPTED);
+  grpc_cq_end_invoke_accepted(cc, tag, NULL, increment_int_on_finish,
+                              &on_finish_called, GRPC_OP_OK);
+
+  ev = grpc_completion_queue_next(cc, gpr_inf_past);
+  GPR_ASSERT(ev != NULL);
+  GPR_ASSERT(ev->type == GRPC_INVOKE_ACCEPTED);
+  GPR_ASSERT(ev->tag == tag);
+  GPR_ASSERT(ev->data.invoke_accepted == GRPC_OP_OK);
+  GPR_ASSERT(on_finish_called == 0);
+  grpc_event_finish(ev);
+  GPR_ASSERT(on_finish_called == 1);
+
+  shutdown_and_destroy(cc);
+}
+
+static void test_cq_end_write_accepted() {
+  grpc_event *ev;
+  grpc_completion_queue *cc;
+  int on_finish_called = 0;
+  void *tag = create_test_tag();
+
+  LOG_TEST();
+
+  cc = grpc_completion_queue_create();
+
+  grpc_cq_begin_op(cc, NULL, GRPC_WRITE_ACCEPTED);
+  grpc_cq_end_write_accepted(cc, tag, NULL, increment_int_on_finish,
+                             &on_finish_called, GRPC_OP_OK);
+
+  ev = grpc_completion_queue_next(cc, gpr_inf_past);
+  GPR_ASSERT(ev != NULL);
+  GPR_ASSERT(ev->type == GRPC_WRITE_ACCEPTED);
+  GPR_ASSERT(ev->tag == tag);
+  GPR_ASSERT(ev->data.write_accepted == GRPC_OP_OK);
+  GPR_ASSERT(on_finish_called == 0);
+  grpc_event_finish(ev);
+  GPR_ASSERT(on_finish_called == 1);
+
+  shutdown_and_destroy(cc);
+}
+
+static void test_cq_end_finish_accepted() {
+  grpc_event *ev;
+  grpc_completion_queue *cc;
+  int on_finish_called = 0;
+  void *tag = create_test_tag();
+
+  LOG_TEST();
+
+  cc = grpc_completion_queue_create();
+
+  grpc_cq_begin_op(cc, NULL, GRPC_FINISH_ACCEPTED);
+  grpc_cq_end_finish_accepted(cc, tag, NULL, increment_int_on_finish,
+                              &on_finish_called, GRPC_OP_OK);
+
+  ev = grpc_completion_queue_next(cc, gpr_inf_past);
+  GPR_ASSERT(ev != NULL);
+  GPR_ASSERT(ev->type == GRPC_FINISH_ACCEPTED);
+  GPR_ASSERT(ev->tag == tag);
+  GPR_ASSERT(ev->data.finish_accepted == GRPC_OP_OK);
+  GPR_ASSERT(on_finish_called == 0);
+  grpc_event_finish(ev);
+  GPR_ASSERT(on_finish_called == 1);
+
+  shutdown_and_destroy(cc);
+}
+
+static void test_cq_end_client_metadata_read() {
+  grpc_event *ev;
+  grpc_completion_queue *cc;
+  int on_finish_called = 0;
+  void *tag = create_test_tag();
+
+  LOG_TEST();
+
+  cc = grpc_completion_queue_create();
+
+  grpc_cq_begin_op(cc, NULL, GRPC_CLIENT_METADATA_READ);
+  grpc_cq_end_client_metadata_read(cc, tag, NULL, increment_int_on_finish,
+                                   &on_finish_called, 0, NULL);
+
+  ev = grpc_completion_queue_next(cc, gpr_inf_past);
+  GPR_ASSERT(ev != NULL);
+  GPR_ASSERT(ev->type == GRPC_CLIENT_METADATA_READ);
+  GPR_ASSERT(ev->tag == tag);
+  GPR_ASSERT(ev->data.client_metadata_read.count == 0);
+  GPR_ASSERT(ev->data.client_metadata_read.elements == NULL);
+  GPR_ASSERT(on_finish_called == 0);
+  grpc_event_finish(ev);
+  GPR_ASSERT(on_finish_called == 1);
+
+  shutdown_and_destroy(cc);
+}
+
+static void test_pluck() {
+  grpc_event *ev;
+  grpc_completion_queue *cc;
+  void *tags[128];
+  int i, j;
+  int on_finish_called = 0;
+
+  LOG_TEST();
+
+  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();
+
+  for (i = 0; i < GPR_ARRAY_SIZE(tags); i++) {
+    grpc_cq_begin_op(cc, NULL, GRPC_WRITE_ACCEPTED);
+    grpc_cq_end_write_accepted(cc, tags[i], NULL, increment_int_on_finish,
+                               &on_finish_called, GRPC_OP_OK);
+  }
+
+  for (i = 0; i < GPR_ARRAY_SIZE(tags); i++) {
+    ev = grpc_completion_queue_pluck(cc, tags[i], gpr_inf_past);
+    GPR_ASSERT(ev->tag == tags[i]);
+    grpc_event_finish(ev);
+  }
+
+  GPR_ASSERT(on_finish_called == GPR_ARRAY_SIZE(tags));
+
+  for (i = 0; i < GPR_ARRAY_SIZE(tags); i++) {
+    grpc_cq_begin_op(cc, NULL, GRPC_WRITE_ACCEPTED);
+    grpc_cq_end_write_accepted(cc, tags[i], NULL, increment_int_on_finish,
+                               &on_finish_called, GRPC_OP_OK);
+  }
+
+  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_ASSERT(ev->tag == tags[GPR_ARRAY_SIZE(tags) - i - 1]);
+    grpc_event_finish(ev);
+  }
+
+  GPR_ASSERT(on_finish_called == 2 * GPR_ARRAY_SIZE(tags));
+
+  shutdown_and_destroy(cc);
+}
+
+#define TEST_THREAD_EVENTS 10000
+
+typedef struct test_thread_options {
+  gpr_event on_started;
+  gpr_event *phase1;
+  gpr_event on_phase1_done;
+  gpr_event *phase2;
+  gpr_event on_finished;
+  int events_triggered;
+  int id;
+  grpc_completion_queue *cc;
+} test_thread_options;
+
+gpr_timespec ten_seconds_time() {
+  return gpr_time_add(gpr_now(), gpr_time_from_micros(10 * 1000000));
+}
+
+static void producer_thread(void *arg) {
+  test_thread_options *opt = arg;
+  int i;
+
+  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, NULL, GRPC_WRITE_ACCEPTED);
+  }
+
+  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_write_accepted(opt->cc, (void *)(gpr_intptr) 1, NULL, NULL,
+                               NULL, GRPC_OP_OK);
+    opt->events_triggered++;
+  }
+
+  gpr_log(GPR_INFO, "producer %d phase 2 done", opt->id);
+  gpr_event_set(&opt->on_finished, (void *)(gpr_intptr) 1);
+}
+
+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());
+    GPR_ASSERT(ev);
+    switch (ev->type) {
+      case GRPC_WRITE_ACCEPTED:
+        GPR_ASSERT(ev->data.write_accepted == GRPC_OP_OK);
+        opt->events_triggered++;
+        grpc_event_finish(ev);
+        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);
+        grpc_event_finish(ev);
+        return;
+      default:
+        gpr_log(GPR_ERROR, "Invalid event received: %d", ev->type);
+        abort();
+    }
+  }
+}
+
+static void test_threading(int producers, int 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();
+  int i;
+  int total_consumed = 0;
+  static int optid = 101;
+
+  gpr_log(GPR_INFO, "%s: %d producers, %d consumers", __FUNCTION__, producers,
+          consumers);
+
+  grpc_completion_queue_dont_poll_test_only(cc);
+
+  /* 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());
+  }
+
+  /* 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, "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);
+
+  /* in parallel, we shutdown the completion channel - all events should still
+     be consumed */
+  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");
+
+  /* destroy the completion channel */
+  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;
+    }
+  }
+  GPR_ASSERT(total_consumed == producers * TEST_THREAD_EVENTS);
+
+  gpr_free(options);
+}
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  grpc_surface_em_init();
+  test_no_op();
+  test_wait_empty();
+  test_cq_end_read();
+  test_cq_end_invoke_accepted();
+  test_cq_end_write_accepted();
+  test_cq_end_finish_accepted();
+  test_cq_end_client_metadata_read();
+  test_pluck();
+  test_threading(1, 1);
+  test_threading(1, 10);
+  test_threading(10, 1);
+  test_threading(10, 10);
+  grpc_surface_em_shutdown();
+  return 0;
+}
diff --git a/test/core/surface/lame_client_test.c b/test/core/surface/lame_client_test.c
new file mode 100644
index 0000000..0520a39
--- /dev/null
+++ b/test/core/surface/lame_client_test.c
@@ -0,0 +1,82 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/surface/lame_client.h"
+
+#include "test/core/end2end/cq_verifier.h"
+#include "test/core/util/test_config.h"
+#include <grpc/support/log.h>
+
+static void *tag(gpr_intptr x) { return (void *)x; }
+
+int main(int argc, char **argv) {
+  grpc_channel *chan;
+  grpc_call *call;
+  grpc_metadata md = {"a", "b", 1};
+  grpc_completion_queue *cq;
+  cq_verifier *cqv;
+
+  grpc_test_init(argc, argv);
+  grpc_init();
+
+  chan = grpc_lame_client_channel_create();
+  GPR_ASSERT(chan);
+  call = grpc_channel_create_call(
+      chan, "/Foo", "anywhere",
+      gpr_time_add(gpr_now(), gpr_time_from_seconds(100)));
+  GPR_ASSERT(call);
+  cq = grpc_completion_queue_create();
+  cqv = cq_verifier_create(cq);
+
+  /* we should be able to add metadata */
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata(call, &md, 0));
+
+  /* and invoke the call */
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_call_start_invoke(call, cq, tag(1), tag(2), tag(3), 0));
+
+  /* the call should immediately fail */
+  cq_expect_invoke_accepted(cqv, tag(1), GRPC_OP_ERROR);
+  cq_expect_client_metadata_read(cqv, tag(2), NULL);
+  cq_expect_finished(cqv, tag(3), NULL);
+  cq_verify(cqv);
+
+  grpc_call_destroy(call);
+  grpc_channel_destroy(chan);
+  cq_verifier_destroy(cqv);
+  grpc_completion_queue_destroy(cq);
+
+  grpc_shutdown();
+
+  return 0;
+}
diff --git a/test/core/transport/chttp2/hpack_parser_test.c b/test/core/transport/chttp2/hpack_parser_test.c
new file mode 100644
index 0000000..12f8b35
--- /dev/null
+++ b/test/core/transport/chttp2/hpack_parser_test.c
@@ -0,0 +1,223 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/transport/chttp2/hpack_parser.h"
+
+#include <stdarg.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/slice.h>
+#include "test/core/util/parse_hexstring.h"
+#include "test/core/util/slice_splitter.h"
+#include "test/core/util/test_config.h"
+
+typedef struct { va_list args; } test_checker;
+
+static void onhdr(void *ud, grpc_mdelem *md) {
+  const char *ekey, *evalue;
+  test_checker *chk = ud;
+  ekey = va_arg(chk->args, char *);
+  GPR_ASSERT(ekey);
+  evalue = va_arg(chk->args, char *);
+  GPR_ASSERT(evalue);
+  GPR_ASSERT(gpr_slice_str_cmp(md->key->slice, ekey) == 0);
+  GPR_ASSERT(gpr_slice_str_cmp(md->value->slice, evalue) == 0);
+  grpc_mdelem_unref(md);
+}
+
+static void test_vector(grpc_chttp2_hpack_parser *parser,
+                        grpc_slice_split_mode mode, const char *hexstring,
+                        ... /* char *key, char *value */) {
+  gpr_slice input = parse_hexstring(hexstring);
+  gpr_slice *slices;
+  size_t nslices;
+  size_t i;
+  test_checker chk;
+
+  va_start(chk.args, hexstring);
+
+  parser->on_header = onhdr;
+  parser->on_header_user_data = &chk;
+
+  grpc_split_slices(mode, &input, 1, &slices, &nslices);
+  gpr_slice_unref(input);
+
+  for (i = 0; i < nslices; i++) {
+    GPR_ASSERT(grpc_chttp2_hpack_parser_parse(
+        parser, GPR_SLICE_START_PTR(slices[i]), GPR_SLICE_END_PTR(slices[i])));
+  }
+
+  for (i = 0; i < nslices; i++) {
+    gpr_slice_unref(slices[i]);
+  }
+  gpr_free(slices);
+
+  GPR_ASSERT(NULL == va_arg(chk.args, char *));
+
+  va_end(chk.args);
+}
+
+static void test_vectors(grpc_slice_split_mode mode) {
+  grpc_chttp2_hpack_parser parser;
+  grpc_mdctx *mdctx = grpc_mdctx_create();
+
+  grpc_chttp2_hpack_parser_init(&parser, mdctx);
+  /* D.2.1 */
+  test_vector(&parser, mode,
+              "400a 6375 7374 6f6d 2d6b 6579 0d63 7573"
+              "746f 6d2d 6865 6164 6572",
+              "custom-key", "custom-header", NULL);
+  /* D.2.2 */
+  test_vector(&parser, mode, "040c 2f73 616d 706c 652f 7061 7468", ":path",
+              "/sample/path", NULL);
+  /* D.2.3 */
+  test_vector(&parser, mode,
+              "1008 7061 7373 776f 7264 0673 6563 7265"
+              "74",
+              "password", "secret", NULL);
+  /* D.2.4 */
+  test_vector(&parser, mode, "82", ":method", "GET", NULL);
+  grpc_chttp2_hpack_parser_destroy(&parser);
+
+  grpc_chttp2_hpack_parser_init(&parser, mdctx);
+  /* D.3.1 */
+  test_vector(&parser, mode,
+              "8286 8441 0f77 7777 2e65 7861 6d70 6c65"
+              "2e63 6f6d",
+              ":method", "GET", ":scheme", "http", ":path", "/", ":authority",
+              "www.example.com", NULL);
+  /* D.3.2 */
+  test_vector(&parser, mode, "8286 84be 5808 6e6f 2d63 6163 6865", ":method",
+              "GET", ":scheme", "http", ":path", "/", ":authority",
+              "www.example.com", "cache-control", "no-cache", NULL);
+  /* D.3.3 */
+  test_vector(&parser, mode,
+              "8287 85bf 400a 6375 7374 6f6d 2d6b 6579"
+              "0c63 7573 746f 6d2d 7661 6c75 65",
+              ":method", "GET", ":scheme", "https", ":path", "/index.html",
+              ":authority", "www.example.com", "custom-key", "custom-value",
+              NULL);
+  grpc_chttp2_hpack_parser_destroy(&parser);
+
+  grpc_chttp2_hpack_parser_init(&parser, mdctx);
+  /* D.4.1 */
+  test_vector(&parser, mode,
+              "8286 8441 8cf1 e3c2 e5f2 3a6b a0ab 90f4"
+              "ff",
+              ":method", "GET", ":scheme", "http", ":path", "/", ":authority",
+              "www.example.com", NULL);
+  /* D.4.2 */
+  test_vector(&parser, mode, "8286 84be 5886 a8eb 1064 9cbf", ":method", "GET",
+              ":scheme", "http", ":path", "/", ":authority", "www.example.com",
+              "cache-control", "no-cache", NULL);
+  /* D.4.3 */
+  test_vector(&parser, mode,
+              "8287 85bf 4088 25a8 49e9 5ba9 7d7f 8925"
+              "a849 e95b b8e8 b4bf",
+              ":method", "GET", ":scheme", "https", ":path", "/index.html",
+              ":authority", "www.example.com", "custom-key", "custom-value",
+              NULL);
+  grpc_chttp2_hpack_parser_destroy(&parser);
+
+  grpc_chttp2_hpack_parser_init(&parser, mdctx);
+  parser.table.max_bytes = 256;
+  /* D.5.1 */
+  test_vector(&parser, mode,
+              "4803 3330 3258 0770 7269 7661 7465 611d"
+              "4d6f 6e2c 2032 3120 4f63 7420 3230 3133"
+              "2032 303a 3133 3a32 3120 474d 546e 1768"
+              "7474 7073 3a2f 2f77 7777 2e65 7861 6d70"
+              "6c65 2e63 6f6d",
+              ":status", "302", "cache-control", "private", "date",
+              "Mon, 21 Oct 2013 20:13:21 GMT", "location",
+              "https://www.example.com", NULL);
+  /* D.5.2 */
+  test_vector(&parser, mode, "4803 3330 37c1 c0bf", ":status", "307",
+              "cache-control", "private", "date",
+              "Mon, 21 Oct 2013 20:13:21 GMT", "location",
+              "https://www.example.com", NULL);
+  /* D.5.3 */
+  test_vector(&parser, mode,
+              "88c1 611d 4d6f 6e2c 2032 3120 4f63 7420"
+              "3230 3133 2032 303a 3133 3a32 3220 474d"
+              "54c0 5a04 677a 6970 7738 666f 6f3d 4153"
+              "444a 4b48 514b 425a 584f 5157 454f 5049"
+              "5541 5851 5745 4f49 553b 206d 6178 2d61"
+              "6765 3d33 3630 303b 2076 6572 7369 6f6e"
+              "3d31",
+              ":status", "200", "cache-control", "private", "date",
+              "Mon, 21 Oct 2013 20:13:22 GMT", "location",
+              "https://www.example.com", "content-encoding", "gzip",
+              "set-cookie",
+              "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1", NULL);
+  grpc_chttp2_hpack_parser_destroy(&parser);
+
+  grpc_chttp2_hpack_parser_init(&parser, mdctx);
+  parser.table.max_bytes = 256;
+  /* D.6.1 */
+  test_vector(&parser, mode,
+              "4882 6402 5885 aec3 771a 4b61 96d0 7abe"
+              "9410 54d4 44a8 2005 9504 0b81 66e0 82a6"
+              "2d1b ff6e 919d 29ad 1718 63c7 8f0b 97c8"
+              "e9ae 82ae 43d3",
+              ":status", "302", "cache-control", "private", "date",
+              "Mon, 21 Oct 2013 20:13:21 GMT", "location",
+              "https://www.example.com", NULL);
+  /* D.6.2 */
+  test_vector(&parser, mode, "4883 640e ffc1 c0bf", ":status", "307",
+              "cache-control", "private", "date",
+              "Mon, 21 Oct 2013 20:13:21 GMT", "location",
+              "https://www.example.com", NULL);
+  /* D.6.3 */
+  test_vector(&parser, mode,
+              "88c1 6196 d07a be94 1054 d444 a820 0595"
+              "040b 8166 e084 a62d 1bff c05a 839b d9ab"
+              "77ad 94e7 821d d7f2 e6c7 b335 dfdf cd5b"
+              "3960 d5af 2708 7f36 72c1 ab27 0fb5 291f"
+              "9587 3160 65c0 03ed 4ee5 b106 3d50 07",
+              ":status", "200", "cache-control", "private", "date",
+              "Mon, 21 Oct 2013 20:13:22 GMT", "location",
+              "https://www.example.com", "content-encoding", "gzip",
+              "set-cookie",
+              "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1", NULL);
+  grpc_chttp2_hpack_parser_destroy(&parser);
+  grpc_mdctx_orphan(mdctx);
+}
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  test_vectors(GRPC_SLICE_SPLIT_MERGE_ALL);
+  test_vectors(GRPC_SLICE_SPLIT_ONE_BYTE);
+  return 0;
+}
diff --git a/test/core/transport/chttp2/hpack_table_test.c b/test/core/transport/chttp2/hpack_table_test.c
new file mode 100644
index 0000000..8810925
--- /dev/null
+++ b/test/core/transport/chttp2/hpack_table_test.c
@@ -0,0 +1,269 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/transport/chttp2/hpack_table.h"
+
+#include <string.h>
+#include <stdio.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include "test/core/util/test_config.h"
+
+#define LOG_TEST() gpr_log(GPR_INFO, "%s", __FUNCTION__)
+
+static void assert_str(const grpc_chttp2_hptbl *tbl, grpc_mdstr *mdstr,
+                       const char *str) {
+  GPR_ASSERT(gpr_slice_str_cmp(mdstr->slice, str) == 0);
+}
+
+static void assert_index(const grpc_chttp2_hptbl *tbl, int idx, const char *key,
+                         const char *value) {
+  grpc_mdelem *md = grpc_chttp2_hptbl_lookup(tbl, idx);
+  assert_str(tbl, md->key, key);
+  assert_str(tbl, md->value, value);
+}
+
+static void test_static_lookup() {
+  grpc_chttp2_hptbl tbl;
+  grpc_mdctx *mdctx;
+
+  mdctx = grpc_mdctx_create();
+  grpc_chttp2_hptbl_init(&tbl, mdctx);
+
+  LOG_TEST();
+  assert_index(&tbl, 1, ":authority", "");
+  assert_index(&tbl, 2, ":method", "GET");
+  assert_index(&tbl, 3, ":method", "POST");
+  assert_index(&tbl, 4, ":path", "/");
+  assert_index(&tbl, 5, ":path", "/index.html");
+  assert_index(&tbl, 6, ":scheme", "http");
+  assert_index(&tbl, 7, ":scheme", "https");
+  assert_index(&tbl, 8, ":status", "200");
+  assert_index(&tbl, 9, ":status", "204");
+  assert_index(&tbl, 10, ":status", "206");
+  assert_index(&tbl, 11, ":status", "304");
+  assert_index(&tbl, 12, ":status", "400");
+  assert_index(&tbl, 13, ":status", "404");
+  assert_index(&tbl, 14, ":status", "500");
+  assert_index(&tbl, 15, "accept-charset", "");
+  assert_index(&tbl, 16, "accept-encoding", "gzip, deflate");
+  assert_index(&tbl, 17, "accept-language", "");
+  assert_index(&tbl, 18, "accept-ranges", "");
+  assert_index(&tbl, 19, "accept", "");
+  assert_index(&tbl, 20, "access-control-allow-origin", "");
+  assert_index(&tbl, 21, "age", "");
+  assert_index(&tbl, 22, "allow", "");
+  assert_index(&tbl, 23, "authorization", "");
+  assert_index(&tbl, 24, "cache-control", "");
+  assert_index(&tbl, 25, "content-disposition", "");
+  assert_index(&tbl, 26, "content-encoding", "");
+  assert_index(&tbl, 27, "content-language", "");
+  assert_index(&tbl, 28, "content-length", "");
+  assert_index(&tbl, 29, "content-location", "");
+  assert_index(&tbl, 30, "content-range", "");
+  assert_index(&tbl, 31, "content-type", "");
+  assert_index(&tbl, 32, "cookie", "");
+  assert_index(&tbl, 33, "date", "");
+  assert_index(&tbl, 34, "etag", "");
+  assert_index(&tbl, 35, "expect", "");
+  assert_index(&tbl, 36, "expires", "");
+  assert_index(&tbl, 37, "from", "");
+  assert_index(&tbl, 38, "host", "");
+  assert_index(&tbl, 39, "if-match", "");
+  assert_index(&tbl, 40, "if-modified-since", "");
+  assert_index(&tbl, 41, "if-none-match", "");
+  assert_index(&tbl, 42, "if-range", "");
+  assert_index(&tbl, 43, "if-unmodified-since", "");
+  assert_index(&tbl, 44, "last-modified", "");
+  assert_index(&tbl, 45, "link", "");
+  assert_index(&tbl, 46, "location", "");
+  assert_index(&tbl, 47, "max-forwards", "");
+  assert_index(&tbl, 48, "proxy-authenticate", "");
+  assert_index(&tbl, 49, "proxy-authorization", "");
+  assert_index(&tbl, 50, "range", "");
+  assert_index(&tbl, 51, "referer", "");
+  assert_index(&tbl, 52, "refresh", "");
+  assert_index(&tbl, 53, "retry-after", "");
+  assert_index(&tbl, 54, "server", "");
+  assert_index(&tbl, 55, "set-cookie", "");
+  assert_index(&tbl, 56, "strict-transport-security", "");
+  assert_index(&tbl, 57, "transfer-encoding", "");
+  assert_index(&tbl, 58, "user-agent", "");
+  assert_index(&tbl, 59, "vary", "");
+  assert_index(&tbl, 60, "via", "");
+  assert_index(&tbl, 61, "www-authenticate", "");
+
+  grpc_chttp2_hptbl_destroy(&tbl);
+  grpc_mdctx_orphan(mdctx);
+}
+
+static void test_many_additions() {
+  grpc_chttp2_hptbl tbl;
+  int i;
+  char key[32];
+  char value[32];
+  grpc_mdctx *mdctx;
+
+  LOG_TEST();
+
+  mdctx = grpc_mdctx_create();
+  grpc_chttp2_hptbl_init(&tbl, mdctx);
+
+  for (i = 0; i < 1000000; i++) {
+    sprintf(key, "K:%d", i);
+    sprintf(value, "VALUE:%d", i);
+    grpc_chttp2_hptbl_add(&tbl, grpc_mdelem_from_strings(mdctx, key, value));
+    assert_index(&tbl, 1 + GRPC_CHTTP2_LAST_STATIC_ENTRY, key, value);
+    if (i) {
+      sprintf(key, "K:%d", i - 1);
+      sprintf(value, "VALUE:%d", i - 1);
+      assert_index(&tbl, 2 + GRPC_CHTTP2_LAST_STATIC_ENTRY, key, value);
+    }
+  }
+
+  grpc_chttp2_hptbl_destroy(&tbl);
+  grpc_mdctx_orphan(mdctx);
+}
+
+static grpc_chttp2_hptbl_find_result find_simple(grpc_chttp2_hptbl *tbl,
+                                                 const char *key,
+                                                 const char *value) {
+  grpc_mdelem *md = grpc_mdelem_from_strings(tbl->mdctx, key, value);
+  grpc_chttp2_hptbl_find_result r = grpc_chttp2_hptbl_find(tbl, md);
+  grpc_mdelem_unref(md);
+  return r;
+}
+
+static void test_find() {
+  grpc_chttp2_hptbl tbl;
+  int i;
+  char buffer[32];
+  grpc_mdctx *mdctx;
+  grpc_chttp2_hptbl_find_result r;
+
+  LOG_TEST();
+
+  mdctx = grpc_mdctx_create();
+  grpc_chttp2_hptbl_init(&tbl, mdctx);
+  grpc_chttp2_hptbl_add(&tbl, grpc_mdelem_from_strings(mdctx, "abc", "xyz"));
+  grpc_chttp2_hptbl_add(&tbl, grpc_mdelem_from_strings(mdctx, "abc", "123"));
+  grpc_chttp2_hptbl_add(&tbl, grpc_mdelem_from_strings(mdctx, "x", "1"));
+
+  r = find_simple(&tbl, "abc", "123");
+  GPR_ASSERT(r.index == 2 + GRPC_CHTTP2_LAST_STATIC_ENTRY);
+  GPR_ASSERT(r.has_value == 1);
+
+  r = find_simple(&tbl, "abc", "xyz");
+  GPR_ASSERT(r.index == 3 + GRPC_CHTTP2_LAST_STATIC_ENTRY);
+  GPR_ASSERT(r.has_value == 1);
+
+  r = find_simple(&tbl, "x", "1");
+  GPR_ASSERT(r.index == 1 + GRPC_CHTTP2_LAST_STATIC_ENTRY);
+  GPR_ASSERT(r.has_value == 1);
+
+  r = find_simple(&tbl, "x", "2");
+  GPR_ASSERT(r.index == 1 + GRPC_CHTTP2_LAST_STATIC_ENTRY);
+  GPR_ASSERT(r.has_value == 0);
+
+  r = find_simple(&tbl, "vary", "some-vary-arg");
+  GPR_ASSERT(r.index == 59);
+  GPR_ASSERT(r.has_value == 0);
+
+  r = find_simple(&tbl, "accept-encoding", "gzip, deflate");
+  GPR_ASSERT(r.index == 16);
+  GPR_ASSERT(r.has_value == 1);
+
+  r = find_simple(&tbl, "accept-encoding", "gzip");
+  GPR_ASSERT(r.index == 16);
+  GPR_ASSERT(r.has_value == 0);
+
+  r = find_simple(&tbl, ":method", "GET");
+  GPR_ASSERT(r.index == 2);
+  GPR_ASSERT(r.has_value == 1);
+
+  r = find_simple(&tbl, ":method", "POST");
+  GPR_ASSERT(r.index == 3);
+  GPR_ASSERT(r.has_value == 1);
+
+  r = find_simple(&tbl, ":method", "PUT");
+  GPR_ASSERT(r.index == 2 || r.index == 3);
+  GPR_ASSERT(r.has_value == 0);
+
+  r = find_simple(&tbl, "this-does-not-exist", "");
+  GPR_ASSERT(r.index == 0);
+  GPR_ASSERT(r.has_value == 0);
+
+  /* overflow the string buffer, check find still works */
+  for (i = 0; i < 10000; i++) {
+    sprintf(buffer, "%d", i);
+    grpc_chttp2_hptbl_add(&tbl,
+                          grpc_mdelem_from_strings(mdctx, "test", buffer));
+  }
+
+  r = find_simple(&tbl, "abc", "123");
+  GPR_ASSERT(r.index == 0);
+  GPR_ASSERT(r.has_value == 0);
+
+  r = find_simple(&tbl, "test", "9999");
+  GPR_ASSERT(r.index == 1 + GRPC_CHTTP2_LAST_STATIC_ENTRY);
+  GPR_ASSERT(r.has_value == 1);
+
+  r = find_simple(&tbl, "test", "9998");
+  GPR_ASSERT(r.index == 2 + GRPC_CHTTP2_LAST_STATIC_ENTRY);
+  GPR_ASSERT(r.has_value == 1);
+
+  for (i = 0; i < tbl.num_ents; i++) {
+    int expect = 9999 - i;
+    sprintf(buffer, "%d", expect);
+
+    r = find_simple(&tbl, "test", buffer);
+    GPR_ASSERT(r.index == i + 1 + GRPC_CHTTP2_LAST_STATIC_ENTRY);
+    GPR_ASSERT(r.has_value == 1);
+  }
+
+  r = find_simple(&tbl, "test", "10000");
+  GPR_ASSERT(r.index != 0);
+  GPR_ASSERT(r.has_value == 0);
+
+  grpc_chttp2_hptbl_destroy(&tbl);
+  grpc_mdctx_orphan(mdctx);
+}
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  test_static_lookup();
+  test_many_additions();
+  test_find();
+  return 0;
+}
diff --git a/test/core/transport/chttp2/status_conversion_test.c b/test/core/transport/chttp2/status_conversion_test.c
new file mode 100644
index 0000000..bb5d7b8
--- /dev/null
+++ b/test/core/transport/chttp2/status_conversion_test.c
@@ -0,0 +1,138 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/transport/chttp2/status_conversion.h"
+#include <grpc/support/log.h>
+#include "test/core/util/test_config.h"
+
+#define GRPC_STATUS_TO_HTTP2_ERROR(a, b) \
+  GPR_ASSERT(grpc_chttp2_grpc_status_to_http2_error(a) == (b))
+#define HTTP2_ERROR_TO_GRPC_STATUS(a, b) \
+  GPR_ASSERT(grpc_chttp2_http2_error_to_grpc_status(a) == (b))
+#define GRPC_STATUS_TO_HTTP2_STATUS(a, b) \
+  GPR_ASSERT(grpc_chttp2_grpc_status_to_http2_status(a) == (b))
+#define HTTP2_STATUS_TO_GRPC_STATUS(a, b) \
+  GPR_ASSERT(grpc_chttp2_http2_status_to_grpc_status(a) == (b))
+
+int main(int argc, char **argv) {
+  int i;
+
+  grpc_test_init(argc, argv);
+
+  GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_OK, GRPC_CHTTP2_NO_ERROR);
+  GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_CANCELLED, GRPC_CHTTP2_CANCEL);
+  GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_UNKNOWN, GRPC_CHTTP2_INTERNAL_ERROR);
+  GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_INVALID_ARGUMENT,
+                             GRPC_CHTTP2_INTERNAL_ERROR);
+  GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_DEADLINE_EXCEEDED,
+                             GRPC_CHTTP2_INTERNAL_ERROR);
+  GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_NOT_FOUND, GRPC_CHTTP2_INTERNAL_ERROR);
+  GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_ALREADY_EXISTS,
+                             GRPC_CHTTP2_INTERNAL_ERROR);
+  GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_PERMISSION_DENIED,
+                             GRPC_CHTTP2_INADEQUATE_SECURITY);
+  GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_UNAUTHENTICATED,
+                             GRPC_CHTTP2_INTERNAL_ERROR);
+  GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_RESOURCE_EXHAUSTED,
+                             GRPC_CHTTP2_ENHANCE_YOUR_CALM);
+  GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_FAILED_PRECONDITION,
+                             GRPC_CHTTP2_INTERNAL_ERROR);
+  GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_ABORTED, GRPC_CHTTP2_INTERNAL_ERROR);
+  GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_OUT_OF_RANGE,
+                             GRPC_CHTTP2_INTERNAL_ERROR);
+  GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_UNIMPLEMENTED,
+                             GRPC_CHTTP2_INTERNAL_ERROR);
+  GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_INTERNAL, GRPC_CHTTP2_INTERNAL_ERROR);
+  GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_UNAVAILABLE,
+                             GRPC_CHTTP2_REFUSED_STREAM);
+  GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_DATA_LOSS, GRPC_CHTTP2_INTERNAL_ERROR);
+
+  GRPC_STATUS_TO_HTTP2_STATUS(GRPC_STATUS_OK, 200);
+  GRPC_STATUS_TO_HTTP2_STATUS(GRPC_STATUS_CANCELLED, 200);
+  GRPC_STATUS_TO_HTTP2_STATUS(GRPC_STATUS_UNKNOWN, 200);
+  GRPC_STATUS_TO_HTTP2_STATUS(GRPC_STATUS_INVALID_ARGUMENT, 200);
+  GRPC_STATUS_TO_HTTP2_STATUS(GRPC_STATUS_DEADLINE_EXCEEDED, 200);
+  GRPC_STATUS_TO_HTTP2_STATUS(GRPC_STATUS_NOT_FOUND, 200);
+  GRPC_STATUS_TO_HTTP2_STATUS(GRPC_STATUS_ALREADY_EXISTS, 200);
+  GRPC_STATUS_TO_HTTP2_STATUS(GRPC_STATUS_PERMISSION_DENIED, 200);
+  GRPC_STATUS_TO_HTTP2_STATUS(GRPC_STATUS_UNAUTHENTICATED, 200);
+  GRPC_STATUS_TO_HTTP2_STATUS(GRPC_STATUS_RESOURCE_EXHAUSTED, 200);
+  GRPC_STATUS_TO_HTTP2_STATUS(GRPC_STATUS_FAILED_PRECONDITION, 200);
+  GRPC_STATUS_TO_HTTP2_STATUS(GRPC_STATUS_ABORTED, 200);
+  GRPC_STATUS_TO_HTTP2_STATUS(GRPC_STATUS_OUT_OF_RANGE, 200);
+  GRPC_STATUS_TO_HTTP2_STATUS(GRPC_STATUS_UNIMPLEMENTED, 200);
+  GRPC_STATUS_TO_HTTP2_STATUS(GRPC_STATUS_INTERNAL, 200);
+  GRPC_STATUS_TO_HTTP2_STATUS(GRPC_STATUS_UNAVAILABLE, 200);
+  GRPC_STATUS_TO_HTTP2_STATUS(GRPC_STATUS_DATA_LOSS, 200);
+
+  HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_NO_ERROR, GRPC_STATUS_INTERNAL);
+  HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_PROTOCOL_ERROR, GRPC_STATUS_INTERNAL);
+  HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_INTERNAL_ERROR, GRPC_STATUS_INTERNAL);
+  HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_FLOW_CONTROL_ERROR,
+                             GRPC_STATUS_INTERNAL);
+  HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_SETTINGS_TIMEOUT,
+                             GRPC_STATUS_INTERNAL);
+  HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_STREAM_CLOSED, GRPC_STATUS_INTERNAL);
+  HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_FRAME_SIZE_ERROR,
+                             GRPC_STATUS_INTERNAL);
+  HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_REFUSED_STREAM,
+                             GRPC_STATUS_UNAVAILABLE);
+  HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_CANCEL, GRPC_STATUS_CANCELLED);
+  HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_COMPRESSION_ERROR,
+                             GRPC_STATUS_INTERNAL);
+  HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_CONNECT_ERROR, GRPC_STATUS_INTERNAL);
+  HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_ENHANCE_YOUR_CALM,
+                             GRPC_STATUS_RESOURCE_EXHAUSTED);
+  HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_INADEQUATE_SECURITY,
+                             GRPC_STATUS_PERMISSION_DENIED);
+
+  HTTP2_STATUS_TO_GRPC_STATUS(200, GRPC_STATUS_OK);
+  HTTP2_STATUS_TO_GRPC_STATUS(400, GRPC_STATUS_INVALID_ARGUMENT);
+  HTTP2_STATUS_TO_GRPC_STATUS(401, GRPC_STATUS_UNAUTHENTICATED);
+  HTTP2_STATUS_TO_GRPC_STATUS(403, GRPC_STATUS_PERMISSION_DENIED);
+  HTTP2_STATUS_TO_GRPC_STATUS(404, GRPC_STATUS_NOT_FOUND);
+  HTTP2_STATUS_TO_GRPC_STATUS(409, GRPC_STATUS_ABORTED);
+  HTTP2_STATUS_TO_GRPC_STATUS(412, GRPC_STATUS_FAILED_PRECONDITION);
+  HTTP2_STATUS_TO_GRPC_STATUS(429, GRPC_STATUS_RESOURCE_EXHAUSTED);
+  HTTP2_STATUS_TO_GRPC_STATUS(499, GRPC_STATUS_CANCELLED);
+  HTTP2_STATUS_TO_GRPC_STATUS(500, GRPC_STATUS_UNKNOWN);
+  HTTP2_STATUS_TO_GRPC_STATUS(503, GRPC_STATUS_UNAVAILABLE);
+  HTTP2_STATUS_TO_GRPC_STATUS(504, GRPC_STATUS_DEADLINE_EXCEEDED);
+
+  /* check all status values can be converted */
+  for (i = 0; i <= 999; i++) {
+    grpc_chttp2_http2_status_to_grpc_status(i);
+  }
+
+  return 0;
+}
diff --git a/test/core/transport/chttp2/stream_encoder_test.c b/test/core/transport/chttp2/stream_encoder_test.c
new file mode 100644
index 0000000..3ee11d9
--- /dev/null
+++ b/test/core/transport/chttp2/stream_encoder_test.c
@@ -0,0 +1,320 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/transport/chttp2/stream_encoder.h"
+
+#include <stdio.h>
+
+#include "src/core/transport/chttp2/hpack_parser.h"
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string.h>
+#include "test/core/util/parse_hexstring.h"
+#include "test/core/util/slice_splitter.h"
+#include "test/core/util/test_config.h"
+
+#define TEST(x) run_test(x, #x)
+
+grpc_mdctx *g_mdctx;
+grpc_chttp2_hpack_compressor g_compressor;
+int g_failure = 0;
+grpc_stream_op_buffer g_sopb;
+
+static gpr_slice create_test_slice(size_t length) {
+  gpr_slice slice = gpr_slice_malloc(length);
+  size_t i;
+  for (i = 0; i < length; i++) {
+    GPR_SLICE_START_PTR(slice)[i] = i;
+  }
+  return slice;
+}
+
+/* verify that the output generated by encoding the stream matches the
+   hexstring passed in */
+static void verify_sopb(size_t window_available, int eof,
+                        size_t expect_window_used, const char *expected) {
+  gpr_slice_buffer output;
+  gpr_slice merged;
+  gpr_slice expect = parse_hexstring(expected);
+  gpr_slice_buffer_init(&output);
+  GPR_ASSERT(expect_window_used ==
+             grpc_chttp2_encode_some(g_sopb.ops, &g_sopb.nops, eof, &output,
+                                     window_available, 0xdeadbeef,
+                                     &g_compressor));
+  merged = grpc_slice_merge(output.slices, output.count);
+  gpr_slice_buffer_destroy(&output);
+
+  if (0 != gpr_slice_cmp(merged, expect)) {
+    char *expect_str =
+        gpr_hexdump((char *)GPR_SLICE_START_PTR(expect),
+                    GPR_SLICE_LENGTH(expect), GPR_HEXDUMP_PLAINTEXT);
+    char *got_str =
+        gpr_hexdump((char *)GPR_SLICE_START_PTR(merged),
+                    GPR_SLICE_LENGTH(merged), GPR_HEXDUMP_PLAINTEXT);
+    gpr_log(GPR_ERROR, "mismatched output for %s", expected);
+    gpr_log(GPR_ERROR, "EXPECT: %s", expect_str);
+    gpr_log(GPR_ERROR, "GOT:    %s", got_str);
+    gpr_free(expect_str);
+    gpr_free(got_str);
+    g_failure = 1;
+  }
+
+  gpr_slice_unref(merged);
+  gpr_slice_unref(expect);
+}
+
+static void assert_result_ok(void *user_data, grpc_op_error error) {
+  GPR_ASSERT(error == GRPC_OP_OK);
+}
+
+static void test_small_data_framing() {
+  grpc_sopb_add_no_op(&g_sopb);
+  verify_sopb(10, 0, 0, "");
+
+  grpc_sopb_add_flow_ctl_cb(&g_sopb, assert_result_ok, NULL);
+  grpc_sopb_add_slice(&g_sopb, create_test_slice(3));
+  verify_sopb(10, 0, 3, "000003 0000 deadbeef 000102");
+
+  grpc_sopb_add_slice(&g_sopb, create_test_slice(4));
+  verify_sopb(10, 0, 4, "000004 0000 deadbeef 00010203");
+
+  grpc_sopb_add_slice(&g_sopb, create_test_slice(3));
+  grpc_sopb_add_slice(&g_sopb, create_test_slice(4));
+  verify_sopb(10, 0, 7, "000007 0000 deadbeef 000102 00010203");
+
+  grpc_sopb_add_slice(&g_sopb, create_test_slice(0));
+  grpc_sopb_add_slice(&g_sopb, create_test_slice(0));
+  grpc_sopb_add_slice(&g_sopb, create_test_slice(0));
+  grpc_sopb_add_slice(&g_sopb, create_test_slice(0));
+  grpc_sopb_add_slice(&g_sopb, create_test_slice(3));
+  verify_sopb(10, 0, 3, "000003 0000 deadbeef 000102");
+
+  verify_sopb(10, 1, 0, "000000 0001 deadbeef");
+
+  grpc_sopb_add_begin_message(&g_sopb, 255, 0);
+  verify_sopb(10, 0, 5, "000005 0000 deadbeef 00000000ff");
+}
+
+static void add_sopb_header(const char *key, const char *value) {
+  grpc_sopb_add_metadata(&g_sopb,
+                         grpc_mdelem_from_strings(g_mdctx, key, value));
+}
+
+static void test_basic_headers() {
+  int i;
+
+  add_sopb_header("a", "a");
+  verify_sopb(0, 0, 0, "000005 0104 deadbeef 40 0161 0161");
+
+  add_sopb_header("a", "a");
+  verify_sopb(0, 0, 0, "000001 0104 deadbeef be");
+
+  add_sopb_header("a", "a");
+  verify_sopb(0, 0, 0, "000001 0104 deadbeef be");
+
+  add_sopb_header("a", "a");
+  add_sopb_header("b", "c");
+  verify_sopb(0, 0, 0, "000006 0104 deadbeef be 40 0162 0163");
+
+  add_sopb_header("a", "a");
+  add_sopb_header("b", "c");
+  verify_sopb(0, 0, 0, "000002 0104 deadbeef bf be");
+
+  add_sopb_header("a", "d");
+  verify_sopb(0, 0, 0, "000004 0104 deadbeef 7f 00 0164");
+
+  /* flush out what's there to make a few values look very popular */
+  for (i = 0; i < 350; i++) {
+    add_sopb_header("a", "a");
+    add_sopb_header("b", "c");
+    add_sopb_header("a", "d");
+    verify_sopb(0, 0, 0, "000003 0104 deadbeef c0 bf be");
+  }
+
+  add_sopb_header("a", "a");
+  add_sopb_header("k", "v");
+  verify_sopb(0, 0, 0, "000006 0104 deadbeef c0 00 016b 0176");
+
+  add_sopb_header("a", "v");
+  /* this could be      000004 0104 deadbeef 0f 30 0176 also */
+  verify_sopb(0, 0, 0, "000004 0104 deadbeef 0f 2f 0176");
+}
+
+static void encode_int_to_str(int i, char *p) {
+  p[0] = 'a' + i % 26;
+  i /= 26;
+  GPR_ASSERT(i < 26);
+  p[1] = 'a' + i;
+  p[2] = 0;
+}
+
+static void test_decode_table_overflow() {
+  int i;
+  char key[3], value[3];
+  char expect[128];
+
+  for (i = 0; i < 114; i++) {
+    if (i > 0) {
+      add_sopb_header("aa", "ba");
+    }
+
+    encode_int_to_str(i, key);
+    encode_int_to_str(i + 1, value);
+
+    if (i + 61 >= 127) {
+      sprintf(expect, "000009 0104 deadbeef ff%02x 40 02%02x%02x 02%02x%02x",
+              i + 61 - 127, key[0], key[1], value[0], value[1]);
+    } else if (i > 0) {
+      sprintf(expect, "000008 0104 deadbeef %02x 40 02%02x%02x 02%02x%02x",
+              0x80 + 61 + i, key[0], key[1], value[0], value[1]);
+    } else {
+      sprintf(expect, "000007 0104 deadbeef 40 02%02x%02x 02%02x%02x", key[0],
+              key[1], value[0], value[1]);
+    }
+
+    add_sopb_header(key, value);
+    verify_sopb(0, 0, 0, expect);
+  }
+
+  /* if the above passes, then we must have just knocked this pair out of the
+     decoder stack, and so we'll be forced to re-encode it */
+  add_sopb_header("aa", "ba");
+  verify_sopb(0, 0, 0, "000007 0104 deadbeef 40 026161 026261");
+}
+
+static void randstr(char *p, int bufsz) {
+  int i;
+  int len = 1 + rand() % bufsz;
+  for (i = 0; i < len; i++) {
+    p[i] = 'a' + rand() % 26;
+  }
+  p[len] = 0;
+}
+
+typedef struct {
+  char key[300];
+  char value[300];
+  int got_hdr;
+} test_decode_random_header_state;
+
+static void chk_hdr(void *p, grpc_mdelem *el) {
+  test_decode_random_header_state *st = p;
+  GPR_ASSERT(0 == gpr_slice_str_cmp(el->key->slice, st->key));
+  GPR_ASSERT(0 == gpr_slice_str_cmp(el->value->slice, st->value));
+  st->got_hdr = 1;
+  grpc_mdelem_unref(el);
+}
+
+static void test_decode_random_headers_inner(int max_len) {
+  int i;
+  test_decode_random_header_state st;
+  gpr_slice_buffer output;
+  gpr_slice merged;
+  grpc_chttp2_hpack_parser parser;
+
+  grpc_chttp2_hpack_parser_init(&parser, g_mdctx);
+
+  gpr_log(GPR_INFO, "max_len = %d", max_len);
+
+  for (i = 0; i < 100000; i++) {
+    randstr(st.key, max_len);
+    randstr(st.value, max_len);
+
+    add_sopb_header(st.key, st.value);
+    gpr_slice_buffer_init(&output);
+    GPR_ASSERT(0 == grpc_chttp2_encode_some(g_sopb.ops, &g_sopb.nops, 0,
+                                            &output, 0, 0xdeadbeef,
+                                            &g_compressor));
+    merged = grpc_slice_merge(output.slices, output.count);
+    gpr_slice_buffer_destroy(&output);
+
+    st.got_hdr = 0;
+    parser.on_header = chk_hdr;
+    parser.on_header_user_data = &st;
+    grpc_chttp2_hpack_parser_parse(&parser, GPR_SLICE_START_PTR(merged) + 9,
+                                   GPR_SLICE_END_PTR(merged));
+    GPR_ASSERT(st.got_hdr);
+
+    gpr_slice_unref(merged);
+  }
+
+  grpc_chttp2_hpack_parser_destroy(&parser);
+}
+
+#define DECL_TEST_DECODE_RANDOM_HEADERS(n)       \
+  static void test_decode_random_headers_##n() { \
+    test_decode_random_headers_inner(n);         \
+  }                                              \
+  int keeps_formatting_correct_##n
+
+DECL_TEST_DECODE_RANDOM_HEADERS(1);
+DECL_TEST_DECODE_RANDOM_HEADERS(2);
+DECL_TEST_DECODE_RANDOM_HEADERS(3);
+DECL_TEST_DECODE_RANDOM_HEADERS(5);
+DECL_TEST_DECODE_RANDOM_HEADERS(8);
+DECL_TEST_DECODE_RANDOM_HEADERS(13);
+DECL_TEST_DECODE_RANDOM_HEADERS(21);
+DECL_TEST_DECODE_RANDOM_HEADERS(34);
+DECL_TEST_DECODE_RANDOM_HEADERS(55);
+DECL_TEST_DECODE_RANDOM_HEADERS(89);
+DECL_TEST_DECODE_RANDOM_HEADERS(144);
+
+static void run_test(void (*test)(), const char *name) {
+  gpr_log(GPR_INFO, "RUN TEST: %s", name);
+  g_mdctx = grpc_mdctx_create_with_seed(0);
+  grpc_chttp2_hpack_compressor_init(&g_compressor, g_mdctx);
+  grpc_sopb_init(&g_sopb);
+  test();
+  grpc_chttp2_hpack_compressor_destroy(&g_compressor);
+  grpc_mdctx_orphan(g_mdctx);
+  grpc_sopb_destroy(&g_sopb);
+}
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  TEST(test_small_data_framing);
+  TEST(test_basic_headers);
+  TEST(test_decode_table_overflow);
+  TEST(test_decode_random_headers_1);
+  TEST(test_decode_random_headers_2);
+  TEST(test_decode_random_headers_3);
+  TEST(test_decode_random_headers_5);
+  TEST(test_decode_random_headers_8);
+  TEST(test_decode_random_headers_13);
+  TEST(test_decode_random_headers_21);
+  TEST(test_decode_random_headers_34);
+  TEST(test_decode_random_headers_55);
+  TEST(test_decode_random_headers_89);
+  TEST(test_decode_random_headers_144);
+  return g_failure;
+}
diff --git a/test/core/transport/chttp2/stream_map_test.c b/test/core/transport/chttp2/stream_map_test.c
new file mode 100644
index 0000000..459ef2a
--- /dev/null
+++ b/test/core/transport/chttp2/stream_map_test.c
@@ -0,0 +1,228 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/transport/chttp2/stream_map.h"
+#include <grpc/support/log.h>
+#include "test/core/util/test_config.h"
+
+#define LOG_TEST() gpr_log(GPR_INFO, "%s", __FUNCTION__)
+
+/* test creation & destruction */
+static void test_no_op() {
+  grpc_chttp2_stream_map map;
+
+  LOG_TEST();
+
+  grpc_chttp2_stream_map_init(&map, 8);
+  grpc_chttp2_stream_map_destroy(&map);
+}
+
+/* test lookup on an empty map */
+static void test_empty_find() {
+  grpc_chttp2_stream_map map;
+
+  LOG_TEST();
+
+  grpc_chttp2_stream_map_init(&map, 8);
+  GPR_ASSERT(NULL == grpc_chttp2_stream_map_find(&map, 39128));
+  grpc_chttp2_stream_map_destroy(&map);
+}
+
+/* test it's safe to delete twice */
+static void test_double_deletion() {
+  grpc_chttp2_stream_map map;
+
+  LOG_TEST();
+
+  grpc_chttp2_stream_map_init(&map, 8);
+  GPR_ASSERT(0 == grpc_chttp2_stream_map_size(&map));
+  grpc_chttp2_stream_map_add(&map, 1, (void *)1);
+  GPR_ASSERT((void *)1 == grpc_chttp2_stream_map_find(&map, 1));
+  GPR_ASSERT(1 == grpc_chttp2_stream_map_size(&map));
+  GPR_ASSERT((void *)1 == grpc_chttp2_stream_map_delete(&map, 1));
+  GPR_ASSERT(0 == grpc_chttp2_stream_map_size(&map));
+  GPR_ASSERT(NULL == grpc_chttp2_stream_map_find(&map, 1));
+  GPR_ASSERT(NULL == grpc_chttp2_stream_map_delete(&map, 1));
+  GPR_ASSERT(NULL == grpc_chttp2_stream_map_find(&map, 1));
+  GPR_ASSERT(NULL == grpc_chttp2_stream_map_delete(&map, 1));
+  GPR_ASSERT(NULL == grpc_chttp2_stream_map_find(&map, 1));
+  GPR_ASSERT(NULL == grpc_chttp2_stream_map_delete(&map, 1));
+  GPR_ASSERT(NULL == grpc_chttp2_stream_map_find(&map, 1));
+  grpc_chttp2_stream_map_destroy(&map);
+}
+
+/* test add & lookup */
+static void test_basic_add_find(size_t n) {
+  grpc_chttp2_stream_map map;
+  size_t i;
+  size_t got;
+
+  LOG_TEST();
+  gpr_log(GPR_INFO, "n = %d", n);
+
+  grpc_chttp2_stream_map_init(&map, 8);
+  GPR_ASSERT(0 == grpc_chttp2_stream_map_size(&map));
+  for (i = 1; i <= n; i++) {
+    grpc_chttp2_stream_map_add(&map, i, (void *)(gpr_uintptr)i);
+  }
+  GPR_ASSERT(n == grpc_chttp2_stream_map_size(&map));
+  GPR_ASSERT(NULL == grpc_chttp2_stream_map_find(&map, 0));
+  GPR_ASSERT(NULL == grpc_chttp2_stream_map_find(&map, n + 1));
+  for (i = 1; i <= n; i++) {
+    got = (gpr_uintptr)grpc_chttp2_stream_map_find(&map, i);
+    GPR_ASSERT(i == got);
+  }
+  grpc_chttp2_stream_map_destroy(&map);
+}
+
+/* verify that for_each gets the right values during test_delete_evens_XXX */
+static void verify_for_each(void *user_data, gpr_uint32 stream_id, void *ptr) {
+  size_t *for_each_check = user_data;
+  GPR_ASSERT(ptr);
+  GPR_ASSERT(*for_each_check == stream_id);
+  *for_each_check += 2;
+}
+
+static void check_delete_evens(grpc_chttp2_stream_map *map, size_t n) {
+  size_t for_each_check = 1;
+  size_t i;
+  size_t got;
+
+  GPR_ASSERT(NULL == grpc_chttp2_stream_map_find(map, 0));
+  GPR_ASSERT(NULL == grpc_chttp2_stream_map_find(map, n + 1));
+  for (i = 1; i <= n; i++) {
+    if (i & 1) {
+      got = (gpr_uintptr)grpc_chttp2_stream_map_find(map, i);
+      GPR_ASSERT(i == got);
+    } else {
+      GPR_ASSERT(NULL == grpc_chttp2_stream_map_find(map, i));
+    }
+  }
+
+  grpc_chttp2_stream_map_for_each(map, verify_for_each, &for_each_check);
+  if (n & 1) {
+    GPR_ASSERT(for_each_check == n + 2);
+  } else {
+    GPR_ASSERT(for_each_check == n + 1);
+  }
+}
+
+/* add a bunch of keys, delete the even ones, and make sure the map is
+   consistent */
+static void test_delete_evens_sweep(size_t n) {
+  grpc_chttp2_stream_map map;
+  size_t i;
+
+  LOG_TEST();
+  gpr_log(GPR_INFO, "n = %d", n);
+
+  grpc_chttp2_stream_map_init(&map, 8);
+  for (i = 1; i <= n; i++) {
+    grpc_chttp2_stream_map_add(&map, i, (void *)(gpr_uintptr)i);
+  }
+  for (i = 1; i <= n; i++) {
+    if ((i & 1) == 0) {
+      GPR_ASSERT((void *)i == grpc_chttp2_stream_map_delete(&map, i));
+    }
+  }
+  check_delete_evens(&map, n);
+  grpc_chttp2_stream_map_destroy(&map);
+}
+
+/* add a bunch of keys, delete the even ones immediately, and make sure the map
+   is consistent */
+static void test_delete_evens_incremental(size_t n) {
+  grpc_chttp2_stream_map map;
+  size_t i;
+
+  LOG_TEST();
+  gpr_log(GPR_INFO, "n = %d", n);
+
+  grpc_chttp2_stream_map_init(&map, 8);
+  for (i = 1; i <= n; i++) {
+    grpc_chttp2_stream_map_add(&map, i, (void *)(gpr_uintptr)i);
+    if ((i & 1) == 0) {
+      grpc_chttp2_stream_map_delete(&map, i);
+    }
+  }
+  check_delete_evens(&map, n);
+  grpc_chttp2_stream_map_destroy(&map);
+}
+
+/* add a bunch of keys, delete old ones after some time, ensure the
+   backing array does not grow */
+static void test_periodic_compaction(size_t n) {
+  grpc_chttp2_stream_map map;
+  size_t i;
+  size_t del;
+
+  LOG_TEST();
+  gpr_log(GPR_INFO, "n = %d", n);
+
+  grpc_chttp2_stream_map_init(&map, 16);
+  GPR_ASSERT(map.capacity == 16);
+  for (i = 1; i <= n; i++) {
+    grpc_chttp2_stream_map_add(&map, i, (void *)i);
+    if (i > 8) {
+      del = i - 8;
+      GPR_ASSERT((void *)del == grpc_chttp2_stream_map_delete(&map, del));
+    }
+  }
+  GPR_ASSERT(map.capacity == 16);
+  grpc_chttp2_stream_map_destroy(&map);
+}
+
+int main(int argc, char **argv) {
+  int n = 1;
+  int prev = 1;
+  int tmp;
+
+  grpc_test_init(argc, argv);
+
+  test_no_op();
+  test_empty_find();
+  test_double_deletion();
+
+  while (n < 10000000) {
+    test_basic_add_find(n);
+    test_delete_evens_sweep(n);
+    test_delete_evens_incremental(n);
+    test_periodic_compaction(n);
+
+    tmp = n;
+    n += prev;
+    prev = tmp;
+  }
+
+  return 0;
+}
diff --git a/test/core/transport/chttp2/timeout_encoding_test.c b/test/core/transport/chttp2/timeout_encoding_test.c
new file mode 100644
index 0000000..793d2b9
--- /dev/null
+++ b/test/core/transport/chttp2/timeout_encoding_test.c
@@ -0,0 +1,140 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/transport/chttp2/timeout_encoding.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include <grpc/support/log.h>
+#include <grpc/support/useful.h>
+#include "test/core/util/test_config.h"
+
+#define LOG_TEST() gpr_log(GPR_INFO, "%s", __FUNCTION__)
+
+static void assert_encodes_as(gpr_timespec ts, const char *s) {
+  char buffer[32];
+  grpc_chttp2_encode_timeout(ts, buffer);
+  gpr_log(GPR_INFO, "check '%s' == '%s'", buffer, s);
+  GPR_ASSERT(0 == strcmp(buffer, s));
+}
+
+void test_encoding() {
+  LOG_TEST();
+  assert_encodes_as(gpr_time_from_micros(-1), "1n");
+  assert_encodes_as(gpr_time_from_seconds(-10), "1n");
+  assert_encodes_as(gpr_time_from_nanos(10), "10n");
+  assert_encodes_as(gpr_time_from_nanos(999999999), "1S");
+  assert_encodes_as(gpr_time_from_micros(1), "1u");
+  assert_encodes_as(gpr_time_from_micros(10), "10u");
+  assert_encodes_as(gpr_time_from_micros(100), "100u");
+  assert_encodes_as(gpr_time_from_micros(890), "890u");
+  assert_encodes_as(gpr_time_from_micros(900), "900u");
+  assert_encodes_as(gpr_time_from_micros(901), "901u");
+  assert_encodes_as(gpr_time_from_millis(1), "1m");
+  assert_encodes_as(gpr_time_from_millis(2), "2m");
+  assert_encodes_as(gpr_time_from_micros(10001), "10100u");
+  assert_encodes_as(gpr_time_from_micros(999999), "1S");
+  assert_encodes_as(gpr_time_from_millis(1000), "1S");
+  assert_encodes_as(gpr_time_from_millis(2000), "2S");
+  assert_encodes_as(gpr_time_from_millis(2500), "2500m");
+  assert_encodes_as(gpr_time_from_millis(59900), "59900m");
+  assert_encodes_as(gpr_time_from_seconds(50), "50S");
+  assert_encodes_as(gpr_time_from_seconds(59), "59S");
+  assert_encodes_as(gpr_time_from_seconds(60), "1M");
+  assert_encodes_as(gpr_time_from_seconds(80), "80S");
+  assert_encodes_as(gpr_time_from_seconds(90), "90S");
+  assert_encodes_as(gpr_time_from_minutes(2), "2M");
+  assert_encodes_as(gpr_time_from_minutes(20), "20M");
+  assert_encodes_as(gpr_time_from_hours(1), "1H");
+  assert_encodes_as(gpr_time_from_hours(10), "10H");
+  assert_encodes_as(gpr_time_from_seconds(1000000000), "1000000000S");
+}
+
+static void assert_decodes_as(const char *buffer, gpr_timespec expected) {
+  gpr_timespec got;
+  gpr_log(GPR_INFO, "check decoding '%s'", buffer);
+  GPR_ASSERT(1 == grpc_chttp2_decode_timeout(buffer, &got));
+  GPR_ASSERT(0 == gpr_time_cmp(got, expected));
+}
+
+void decode_suite(char ext, gpr_timespec (*answer)(long x)) {
+  long test_vals[] = {1,       12,       123,       1234,     12345,   123456,
+                      1234567, 12345678, 123456789, 98765432, 9876543, 987654,
+                      98765,   9876,     987,       98,       9};
+  int i;
+  char input[32];
+  for (i = 0; i < GPR_ARRAY_SIZE(test_vals); i++) {
+    sprintf(input, "%ld%c", test_vals[i], ext);
+    assert_decodes_as(input, answer(test_vals[i]));
+    sprintf(input, "   %ld%c", test_vals[i], ext);
+    assert_decodes_as(input, answer(test_vals[i]));
+    sprintf(input, "%ld %c", test_vals[i], ext);
+    assert_decodes_as(input, answer(test_vals[i]));
+    sprintf(input, "%ld %c  ", test_vals[i], ext);
+    assert_decodes_as(input, answer(test_vals[i]));
+  }
+}
+
+void test_decoding() {
+  LOG_TEST();
+  decode_suite('n', gpr_time_from_nanos);
+  decode_suite('u', gpr_time_from_micros);
+  decode_suite('m', gpr_time_from_millis);
+  decode_suite('S', gpr_time_from_seconds);
+  decode_suite('M', gpr_time_from_minutes);
+  decode_suite('H', gpr_time_from_hours);
+  assert_decodes_as("1000000000000000000000u", gpr_inf_future);
+}
+
+void test_decoding_fails() {
+  gpr_timespec x;
+  LOG_TEST();
+  GPR_ASSERT(0 == grpc_chttp2_decode_timeout("", &x));
+  GPR_ASSERT(0 == grpc_chttp2_decode_timeout(" ", &x));
+  GPR_ASSERT(0 == grpc_chttp2_decode_timeout("x", &x));
+  GPR_ASSERT(0 == grpc_chttp2_decode_timeout("1", &x));
+  GPR_ASSERT(0 == grpc_chttp2_decode_timeout("1x", &x));
+  GPR_ASSERT(0 == grpc_chttp2_decode_timeout("1ux", &x));
+  GPR_ASSERT(0 == grpc_chttp2_decode_timeout("!", &x));
+  GPR_ASSERT(0 == grpc_chttp2_decode_timeout("n1", &x));
+  GPR_ASSERT(0 == grpc_chttp2_decode_timeout("-1u", &x));
+}
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  test_encoding();
+  test_decoding();
+  test_decoding_fails();
+  return 0;
+}
diff --git a/test/core/transport/chttp2_transport_end2end_test.c b/test/core/transport/chttp2_transport_end2end_test.c
new file mode 100644
index 0000000..4a16789
--- /dev/null
+++ b/test/core/transport/chttp2_transport_end2end_test.c
@@ -0,0 +1,139 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "transport_end2end_tests.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include "test/core/util/test_config.h"
+#include "src/core/eventmanager/em.h"
+#include "src/core/transport/chttp2_transport.h"
+#include <grpc/support/log.h>
+
+static grpc_em em;
+
+static void create_sockets(int sv[2]) {
+  int flags;
+  GPR_ASSERT(socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == 0);
+  flags = fcntl(sv[0], F_GETFL, 0);
+  GPR_ASSERT(fcntl(sv[0], F_SETFL, flags | O_NONBLOCK) == 0);
+  flags = fcntl(sv[1], F_GETFL, 0);
+  GPR_ASSERT(fcntl(sv[1], F_SETFL, flags | O_NONBLOCK) == 0);
+}
+
+/* Wrapper to create an http2 transport pair */
+static int create_http2_transport_for_test(
+    grpc_transport_setup_callback client_setup_transport,
+    void *client_setup_arg,
+    grpc_transport_setup_callback server_setup_transport,
+    void *server_setup_arg, size_t slice_size, grpc_mdctx *mdctx) {
+  int sv[2];
+  grpc_endpoint *svr_ep, *cli_ep;
+
+  create_sockets(sv);
+  svr_ep = grpc_tcp_create_dbg(sv[1], &em, slice_size);
+  cli_ep = grpc_tcp_create_dbg(sv[0], &em, slice_size);
+
+  grpc_create_chttp2_transport(client_setup_transport, client_setup_arg, NULL,
+                               cli_ep, NULL, 0, mdctx, 1);
+  grpc_create_chttp2_transport(server_setup_transport, server_setup_arg, NULL,
+                               svr_ep, NULL, 0, mdctx, 0);
+
+  return 0;
+}
+
+static int create_http2_transport_for_test_small_slices(
+    grpc_transport_setup_callback client_setup_transport,
+    void *client_setup_arg,
+    grpc_transport_setup_callback server_setup_transport,
+    void *server_setup_arg, grpc_mdctx *mdctx) {
+  return create_http2_transport_for_test(
+      client_setup_transport, client_setup_arg, server_setup_transport,
+      server_setup_arg, 1, mdctx);
+}
+
+static int create_http2_transport_for_test_medium_slices(
+    grpc_transport_setup_callback client_setup_transport,
+    void *client_setup_arg,
+    grpc_transport_setup_callback server_setup_transport,
+    void *server_setup_arg, grpc_mdctx *mdctx) {
+  return create_http2_transport_for_test(
+      client_setup_transport, client_setup_arg, server_setup_transport,
+      server_setup_arg, 8192, mdctx);
+}
+
+static int create_http2_transport_for_test_large_slices(
+    grpc_transport_setup_callback client_setup_transport,
+    void *client_setup_arg,
+    grpc_transport_setup_callback server_setup_transport,
+    void *server_setup_arg, grpc_mdctx *mdctx) {
+  return create_http2_transport_for_test(
+      client_setup_transport, client_setup_arg, server_setup_transport,
+      server_setup_arg, 1024 * 1024, mdctx);
+}
+
+/* All configurations to be tested */
+grpc_transport_test_config fixture_configs[] = {
+    {"chttp2_on_socketpair/small",
+     create_http2_transport_for_test_small_slices},
+    {"chttp2_on_socketpair/medium",
+     create_http2_transport_for_test_medium_slices},
+    {"chttp2_on_socketpair/large",
+     create_http2_transport_for_test_large_slices},
+};
+
+/* Driver function: run the test suite for each test configuration */
+int main(int argc, char **argv) {
+  size_t i;
+
+  /* disable SIGPIPE */
+  signal(SIGPIPE, SIG_IGN);
+
+  grpc_test_init(argc, argv);
+  grpc_em_init(&em);
+
+  for (i = 0; i < sizeof(fixture_configs) / sizeof(*fixture_configs); i++) {
+    grpc_transport_end2end_tests(&fixture_configs[i]);
+  }
+
+  grpc_em_destroy(&em);
+
+  gpr_log(GPR_INFO, "exiting");
+  return 0;
+}
diff --git a/test/core/transport/metadata_test.c b/test/core/transport/metadata_test.c
new file mode 100644
index 0000000..d71628a
--- /dev/null
+++ b/test/core/transport/metadata_test.c
@@ -0,0 +1,258 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/transport/metadata.h"
+
+#include <stdio.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include "test/core/util/test_config.h"
+
+#define LOG_TEST() gpr_log(GPR_INFO, "%s", __FUNCTION__)
+
+/* a large number */
+#define MANY 1000000
+
+static void test_no_op() {
+  grpc_mdctx *ctx;
+
+  LOG_TEST();
+
+  ctx = grpc_mdctx_create();
+  grpc_mdctx_orphan(ctx);
+}
+
+static void test_create_string() {
+  grpc_mdctx *ctx;
+  grpc_mdstr *s1, *s2, *s3;
+
+  LOG_TEST();
+
+  ctx = grpc_mdctx_create();
+  s1 = grpc_mdstr_from_string(ctx, "hello");
+  s2 = grpc_mdstr_from_string(ctx, "hello");
+  s3 = grpc_mdstr_from_string(ctx, "very much not hello");
+  GPR_ASSERT(s1 == s2);
+  GPR_ASSERT(s3 != s1);
+  GPR_ASSERT(gpr_slice_str_cmp(s1->slice, "hello") == 0);
+  GPR_ASSERT(gpr_slice_str_cmp(s3->slice, "very much not hello") == 0);
+  grpc_mdstr_unref(s1);
+  grpc_mdstr_unref(s2);
+  grpc_mdctx_orphan(ctx);
+  grpc_mdstr_unref(s3);
+}
+
+static void test_create_metadata() {
+  grpc_mdctx *ctx;
+  grpc_mdelem *m1, *m2, *m3;
+
+  LOG_TEST();
+
+  ctx = grpc_mdctx_create();
+  m1 = grpc_mdelem_from_strings(ctx, "a", "b");
+  m2 = grpc_mdelem_from_strings(ctx, "a", "b");
+  m3 = grpc_mdelem_from_strings(ctx, "a", "c");
+  GPR_ASSERT(m1 == m2);
+  GPR_ASSERT(m3 != m1);
+  GPR_ASSERT(m3->key == m1->key);
+  GPR_ASSERT(m3->value != m1->value);
+  GPR_ASSERT(gpr_slice_str_cmp(m1->key->slice, "a") == 0);
+  GPR_ASSERT(gpr_slice_str_cmp(m1->value->slice, "b") == 0);
+  GPR_ASSERT(gpr_slice_str_cmp(m3->value->slice, "c") == 0);
+  grpc_mdelem_unref(m1);
+  grpc_mdelem_unref(m2);
+  grpc_mdelem_unref(m3);
+  grpc_mdctx_orphan(ctx);
+}
+
+static void test_create_many_ephemeral_metadata() {
+  grpc_mdctx *ctx;
+  char buffer[256];
+  long i;
+  size_t mdtab_capacity_before;
+
+  LOG_TEST();
+
+  ctx = grpc_mdctx_create();
+  mdtab_capacity_before = grpc_mdctx_get_mdtab_capacity_test_only(ctx);
+  /* add, and immediately delete a bunch of different elements */
+  for (i = 0; i < MANY; i++) {
+    sprintf(buffer, "%ld", i);
+    grpc_mdelem_unref(grpc_mdelem_from_strings(ctx, "a", buffer));
+  }
+  /* capacity should not grow */
+  GPR_ASSERT(mdtab_capacity_before ==
+             grpc_mdctx_get_mdtab_capacity_test_only(ctx));
+  grpc_mdctx_orphan(ctx);
+}
+
+static void test_create_many_persistant_metadata() {
+  grpc_mdctx *ctx;
+  char buffer[256];
+  long i;
+  grpc_mdelem **created = gpr_malloc(sizeof(grpc_mdelem *) * MANY);
+  grpc_mdelem *md;
+
+  LOG_TEST();
+
+  ctx = grpc_mdctx_create();
+  /* add phase */
+  for (i = 0; i < MANY; i++) {
+    sprintf(buffer, "%ld", i);
+    created[i] = grpc_mdelem_from_strings(ctx, "a", buffer);
+  }
+  /* verify phase */
+  for (i = 0; i < MANY; i++) {
+    sprintf(buffer, "%ld", i);
+    md = grpc_mdelem_from_strings(ctx, "a", buffer);
+    GPR_ASSERT(md == created[i]);
+    grpc_mdelem_unref(md);
+  }
+  /* cleanup phase */
+  for (i = 0; i < MANY; i++) {
+    grpc_mdelem_unref(created[i]);
+  }
+  grpc_mdctx_orphan(ctx);
+
+  gpr_free(created);
+}
+
+static void test_spin_creating_the_same_thing() {
+  grpc_mdctx *ctx;
+
+  LOG_TEST();
+
+  ctx = grpc_mdctx_create();
+  GPR_ASSERT(grpc_mdctx_get_mdtab_count_test_only(ctx) == 0);
+  GPR_ASSERT(grpc_mdctx_get_mdtab_free_test_only(ctx) == 0);
+
+  grpc_mdelem_unref(grpc_mdelem_from_strings(ctx, "a", "b"));
+  GPR_ASSERT(grpc_mdctx_get_mdtab_count_test_only(ctx) == 1);
+  GPR_ASSERT(grpc_mdctx_get_mdtab_free_test_only(ctx) == 1);
+
+  grpc_mdelem_unref(grpc_mdelem_from_strings(ctx, "a", "b"));
+  GPR_ASSERT(grpc_mdctx_get_mdtab_count_test_only(ctx) == 1);
+  GPR_ASSERT(grpc_mdctx_get_mdtab_free_test_only(ctx) == 1);
+
+  grpc_mdelem_unref(grpc_mdelem_from_strings(ctx, "a", "b"));
+  GPR_ASSERT(grpc_mdctx_get_mdtab_count_test_only(ctx) == 1);
+  GPR_ASSERT(grpc_mdctx_get_mdtab_free_test_only(ctx) == 1);
+
+  grpc_mdctx_orphan(ctx);
+}
+
+static void test_things_stick_around() {
+  grpc_mdctx *ctx;
+  int i, j;
+  char buffer[64];
+  int nstrs = 10000;
+  grpc_mdstr **strs = gpr_malloc(sizeof(grpc_mdstr *) * nstrs);
+  int *shuf = gpr_malloc(sizeof(int) * nstrs);
+  grpc_mdstr *test;
+
+  LOG_TEST();
+
+  ctx = grpc_mdctx_create();
+
+  for (i = 0; i < nstrs; i++) {
+    sprintf(buffer, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%dx", i);
+    strs[i] = grpc_mdstr_from_string(ctx, buffer);
+    shuf[i] = i;
+  }
+
+  for (i = 0; i < nstrs; i++) {
+    grpc_mdstr_ref(strs[i]);
+    grpc_mdstr_unref(strs[i]);
+  }
+
+  for (i = 0; i < nstrs; i++) {
+    int p = rand() % nstrs;
+    int q = rand() % nstrs;
+    int temp = shuf[p];
+    shuf[p] = shuf[q];
+    shuf[q] = temp;
+  }
+
+  for (i = 0; i < nstrs; i++) {
+    grpc_mdstr_unref(strs[shuf[i]]);
+    for (j = i + 1; j < nstrs; j++) {
+      sprintf(buffer, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%dx", shuf[j]);
+      test = grpc_mdstr_from_string(ctx, buffer);
+      GPR_ASSERT(test == strs[shuf[j]]);
+      grpc_mdstr_unref(test);
+    }
+  }
+
+  grpc_mdctx_orphan(ctx);
+  gpr_free(strs);
+  gpr_free(shuf);
+}
+
+static void test_slices_work() {
+  /* ensure no memory leaks when switching representation from mdstr to slice */
+  grpc_mdctx *ctx;
+  grpc_mdstr *str;
+  gpr_slice slice;
+
+  LOG_TEST();
+
+  ctx = grpc_mdctx_create();
+
+  str = grpc_mdstr_from_string(
+      ctx, "123456789012345678901234567890123456789012345678901234567890");
+  slice = gpr_slice_ref(str->slice);
+  grpc_mdstr_unref(str);
+  gpr_slice_unref(slice);
+
+  str = grpc_mdstr_from_string(
+      ctx, "123456789012345678901234567890123456789012345678901234567890");
+  slice = gpr_slice_ref(str->slice);
+  gpr_slice_unref(slice);
+  grpc_mdstr_unref(str);
+
+  grpc_mdctx_orphan(ctx);
+}
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  test_no_op();
+  test_create_string();
+  test_create_metadata();
+  test_create_many_ephemeral_metadata();
+  test_create_many_persistant_metadata();
+  test_spin_creating_the_same_thing();
+  test_things_stick_around();
+  test_slices_work();
+  return 0;
+}
diff --git a/test/core/transport/stream_op_test.c b/test/core/transport/stream_op_test.c
new file mode 100644
index 0000000..0d1122c
--- /dev/null
+++ b/test/core/transport/stream_op_test.c
@@ -0,0 +1,125 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/transport/stream_op.h"
+
+#include <string.h>
+
+#include <grpc/support/log.h>
+#include "test/core/util/test_config.h"
+
+static void flow_ctl_cb_fails(void *ignored, grpc_op_error error) {
+  GPR_ASSERT(error == GRPC_OP_ERROR);
+}
+
+static void assert_slices_equal(gpr_slice a, gpr_slice b) {
+  GPR_ASSERT(a.refcount == b.refcount);
+  if (a.refcount) {
+    GPR_ASSERT(a.data.refcounted.bytes == b.data.refcounted.bytes);
+    GPR_ASSERT(a.data.refcounted.length == b.data.refcounted.length);
+  } else {
+    GPR_ASSERT(a.data.inlined.length == b.data.inlined.length);
+    GPR_ASSERT(0 == memcmp(a.data.inlined.bytes, b.data.inlined.bytes,
+                           a.data.inlined.length));
+  }
+}
+
+int main(int argc, char **argv) {
+  /* some basic test data */
+  gpr_slice test_slice_1 = gpr_slice_malloc(1);
+  gpr_slice test_slice_2 = gpr_slice_malloc(2);
+  gpr_slice test_slice_3 = gpr_slice_malloc(3);
+  gpr_slice test_slice_4 = gpr_slice_malloc(4);
+  char x;
+  int i;
+
+  grpc_stream_op_buffer buf;
+  grpc_stream_op_buffer buf2;
+
+  grpc_test_init(argc, argv);
+  /* initialize one of our buffers */
+  grpc_sopb_init(&buf);
+  /* it should start out empty */
+  GPR_ASSERT(buf.nops == 0);
+
+  /* add some data to the buffer */
+  grpc_sopb_add_begin_message(&buf, 1, 2);
+  grpc_sopb_add_slice(&buf, test_slice_1);
+  grpc_sopb_add_slice(&buf, test_slice_2);
+  grpc_sopb_add_slice(&buf, test_slice_3);
+  grpc_sopb_add_slice(&buf, test_slice_4);
+  grpc_sopb_add_flow_ctl_cb(&buf, flow_ctl_cb_fails, &x);
+  grpc_sopb_add_no_op(&buf);
+
+  /* verify that the data went in ok */
+  GPR_ASSERT(buf.nops == 7);
+  GPR_ASSERT(buf.ops[0].type == GRPC_OP_BEGIN_MESSAGE);
+  GPR_ASSERT(buf.ops[0].data.begin_message.length == 1);
+  GPR_ASSERT(buf.ops[0].data.begin_message.flags == 2);
+  GPR_ASSERT(buf.ops[1].type == GRPC_OP_SLICE);
+  assert_slices_equal(buf.ops[1].data.slice, test_slice_1);
+  GPR_ASSERT(buf.ops[2].type == GRPC_OP_SLICE);
+  assert_slices_equal(buf.ops[2].data.slice, test_slice_2);
+  GPR_ASSERT(buf.ops[3].type == GRPC_OP_SLICE);
+  assert_slices_equal(buf.ops[3].data.slice, test_slice_3);
+  GPR_ASSERT(buf.ops[4].type == GRPC_OP_SLICE);
+  assert_slices_equal(buf.ops[4].data.slice, test_slice_4);
+  GPR_ASSERT(buf.ops[5].type == GRPC_OP_FLOW_CTL_CB);
+  GPR_ASSERT(buf.ops[5].data.flow_ctl_cb.cb == flow_ctl_cb_fails);
+  GPR_ASSERT(buf.ops[5].data.flow_ctl_cb.arg == &x);
+  GPR_ASSERT(buf.ops[6].type == GRPC_NO_OP);
+
+  /* initialize the second buffer */
+  grpc_sopb_init(&buf2);
+  /* add a no-op, and then the original buffer */
+  grpc_sopb_add_no_op(&buf2);
+  grpc_sopb_append(&buf2, buf.ops, buf.nops);
+  /* should be one element bigger than the original */
+  GPR_ASSERT(buf2.nops == buf.nops + 1);
+  GPR_ASSERT(buf2.ops[0].type == GRPC_NO_OP);
+  /* and the tail should be the same */
+  for (i = 0; i < buf.nops; i++) {
+    GPR_ASSERT(buf2.ops[i + 1].type == buf.ops[i].type);
+  }
+
+  /* destroy the buffers */
+  grpc_sopb_destroy(&buf);
+  grpc_sopb_destroy(&buf2);
+
+  gpr_slice_unref(test_slice_1);
+  gpr_slice_unref(test_slice_2);
+  gpr_slice_unref(test_slice_3);
+  gpr_slice_unref(test_slice_4);
+
+  return 0;
+}
diff --git a/test/core/transport/transport_end2end_tests.c b/test/core/transport/transport_end2end_tests.c
new file mode 100644
index 0000000..ce6fbcf
--- /dev/null
+++ b/test/core/transport/transport_end2end_tests.c
@@ -0,0 +1,926 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/transport/transport_end2end_tests.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "src/core/transport/transport.h"
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string.h>
+#include <grpc/support/thd.h>
+#include <grpc/support/useful.h>
+
+enum { REQUEST_DEADLINE = 200000 }; /* valgrind need a large value */
+
+static grpc_mdctx *g_metadata_context;
+
+static gpr_once g_pending_ops_init = GPR_ONCE_INIT;
+static gpr_mu g_mu;
+static gpr_cv g_cv;
+static int g_pending_ops;
+
+/* Defines a suite of tests that all GRPC transports should be able to pass */
+
+/******************************************************************************
+ * Testing framework
+ */
+
+/* Forward declarations */
+typedef struct test_fixture test_fixture;
+
+/* User data passed to the transport and handed to each callback */
+typedef struct test_user_data { test_fixture *fixture; } test_user_data;
+
+/* A message we expect to receive (forms a singly linked list with next) */
+typedef struct expected_message {
+  /* The next message expected */
+  struct expected_message *next;
+  /* The (owned) data that we expect to receive */
+  gpr_uint8 *data;
+  /* The length of the expected message */
+  size_t length;
+  /* How many bytes of the expected message have we received? */
+  size_t read_pos;
+  /* Have we received the GRPC_OP_BEGIN for this message */
+  int begun;
+} expected_message;
+
+/* Metadata we expect to receive */
+typedef struct expected_metadata {
+  struct expected_metadata *next;
+  struct expected_metadata *prev;
+  grpc_mdelem *metadata;
+} expected_metadata;
+
+/* Tracks a stream for a test. Forms a doubly-linked list with (prev, next) */
+typedef struct test_stream {
+  /* The owning fixture */
+  test_fixture *fixture;
+  /* The transport client stream */
+  grpc_stream *client_stream;
+  /* The transport server stream */
+  grpc_stream *server_stream;
+  /* Linked lists of messages expected on client and server */
+  expected_message *client_expected_messages;
+  expected_message *server_expected_messages;
+  expected_metadata *client_expected_metadata;
+  expected_metadata *server_expected_metadata;
+
+  /* Test streams are linked in the fixture */
+  struct test_stream *next;
+  struct test_stream *prev;
+} test_stream;
+
+/* A test_fixture tracks all transport state and expectations for a test */
+struct test_fixture {
+  gpr_mu mu;
+  gpr_cv cv; /* broadcast when expectation state has changed */
+
+  /* The transport instances */
+  grpc_transport *client_transport;
+  grpc_transport *server_transport;
+  /* User data for the transport instances - pointers to these are passed
+     to the transport. */
+  test_user_data client_ud;
+  test_user_data server_ud;
+
+  /* A pointer to the head of the tracked streams list, or NULL if no streams
+     are open */
+  test_stream *streams;
+};
+
+static void expect_metadata(test_stream *s, int from_client, const char *key,
+                            const char *value);
+
+/* Convert some number of seconds into a gpr_timespec that many seconds in the
+   future */
+static gpr_timespec deadline_from_seconds(double deadline_seconds) {
+  return gpr_time_add(gpr_now(), gpr_time_from_micros(deadline_seconds * 1e6));
+}
+
+/* Init a test_user_data instance */
+static void init_user_data(test_user_data *ud, test_fixture *f,
+                           grpc_transport_test_config *config, int is_client) {
+  ud->fixture = f;
+}
+
+/* Implements the alloc_recv_buffer transport callback */
+static gpr_slice alloc_recv_buffer(void *user_data, grpc_transport *transport,
+                                   grpc_stream *stream, size_t size_hint) {
+  return gpr_slice_malloc(size_hint);
+}
+
+static void pending_ops_cleanup() {
+  gpr_mu_destroy(&g_mu);
+  gpr_cv_destroy(&g_cv);
+}
+
+static void pending_ops_init() {
+  gpr_mu_init(&g_mu);
+  gpr_cv_init(&g_cv);
+  atexit(pending_ops_cleanup);
+}
+
+static void use_pending_ops() {
+  gpr_once_init(&g_pending_ops_init, pending_ops_init);
+}
+
+static void add_pending_op() {
+  use_pending_ops();
+  gpr_mu_lock(&g_mu);
+  g_pending_ops++;
+  gpr_mu_unlock(&g_mu);
+}
+
+static void end_pending_op() {
+  gpr_mu_lock(&g_mu);
+  g_pending_ops--;
+  gpr_cv_broadcast(&g_cv);
+  gpr_mu_unlock(&g_mu);
+}
+
+static void wait_pending_ops() {
+  use_pending_ops();
+  gpr_mu_lock(&g_mu);
+  while (g_pending_ops > 0) {
+    gpr_cv_wait(&g_cv, &g_mu, gpr_inf_future);
+  }
+  gpr_mu_unlock(&g_mu);
+}
+
+/* Implements the create_stream transport callback */
+static void create_stream(void *user_data, grpc_transport *transport,
+                          const void *server_data) {
+  test_user_data *ud = user_data;
+  test_fixture *f = ud->fixture;
+  test_stream *stream;
+
+  GPR_ASSERT(ud == &f->server_ud);
+  GPR_ASSERT(transport == f->server_transport);
+
+  gpr_mu_lock(&f->mu);
+
+  /* Search streams for the peer to this stream */
+  if (!f->streams) goto done;
+  /* found the expecting stream */
+  stream = f->streams;
+  stream->server_stream = gpr_malloc(grpc_transport_stream_size(transport));
+  grpc_transport_init_stream(transport, stream->server_stream, server_data);
+
+done:
+  /* wakeup begin_stream, and maybe wait_and_verify */
+  gpr_cv_broadcast(&f->cv);
+  gpr_mu_unlock(&f->mu);
+}
+
+/* Search fixture streams for the test_stream instance holding a given transport
+   stream */
+static test_stream *find_test_stream(test_fixture *f, grpc_stream *stream) {
+  test_stream *s;
+
+  GPR_ASSERT(f->streams);
+  s = f->streams;
+  do {
+    if (s->client_stream == stream || s->server_stream == stream) {
+      return s;
+    }
+  } while (s != f->streams);
+
+  GPR_ASSERT(0 && "found");
+  return NULL;
+}
+
+/* Stringify a grpc_stream_state for debugging */
+static const char *state_name(grpc_stream_state state) {
+  switch (state) {
+    case GRPC_STREAM_OPEN:
+      return "GRPC_STREAM_OPEN";
+    case GRPC_STREAM_RECV_CLOSED:
+      return "GRPC_STREAM_RECV_CLOSED";
+    case GRPC_STREAM_SEND_CLOSED:
+      return "GRPC_STREAM_SEND_CLOSED";
+    case GRPC_STREAM_CLOSED:
+      return "GRPC_STREAM_CLOSED";
+  }
+  GPR_ASSERT(0 && "reachable");
+  return NULL;
+}
+
+typedef struct {
+  grpc_transport *transport;
+  grpc_stream *stream;
+} destroy_stream_args;
+
+static void destroy_stream(void *p) {
+  destroy_stream_args *a = p;
+  grpc_transport_destroy_stream(a->transport, a->stream);
+  gpr_free(a->stream);
+  gpr_free(a);
+  end_pending_op();
+}
+
+static void recv_batch(void *user_data, grpc_transport *transport,
+                       grpc_stream *stream, grpc_stream_op *ops,
+                       size_t ops_count, grpc_stream_state final_state) {
+  test_user_data *ud = user_data;
+  test_fixture *f = ud->fixture;
+  test_stream *s;
+  /* Pointer to the root pointer of either client or server expected messages;
+     not a simple pointer as we may need to manipulate the list (on receipt
+     of messages */
+  expected_message **expect_root_message;
+  expected_metadata **expect_root_metadata;
+  expected_metadata *emd;
+  size_t i, j;
+  char *hexstr1, *hexstr2;
+  int repeats = 0;
+
+  gpr_mu_lock(&f->mu);
+
+  s = find_test_stream(f, stream);
+  expect_root_message = s->client_stream == stream
+                            ? &s->client_expected_messages
+                            : &s->server_expected_messages;
+  expect_root_metadata = s->client_stream == stream
+                             ? &s->client_expected_metadata
+                             : &s->server_expected_metadata;
+
+  /* Debug log */
+  gpr_log(GPR_DEBUG, "recv_batch: %d ops on %s final_state=%s", ops_count,
+          s->client_stream == stream ? "client" : "server",
+          state_name(final_state));
+#define CLEAR_REPEATS                           \
+  if (repeats) {                                \
+    gpr_log(GPR_DEBUG, "  + %d more", repeats); \
+    repeats = 0;                                \
+  }
+  for (i = 0; i < ops_count; i++) {
+    switch (ops[i].type) {
+      case GRPC_NO_OP:
+        CLEAR_REPEATS;
+        gpr_log(GPR_DEBUG, "  [%02d] GRPC_NO_OP", i);
+        break;
+      case GRPC_OP_METADATA_BOUNDARY:
+        CLEAR_REPEATS;
+        gpr_log(GPR_DEBUG, "  [%02d] GRPC_OP_METADATA_BOUNDARY", i);
+        break;
+      case GRPC_OP_METADATA:
+        CLEAR_REPEATS;
+        hexstr1 =
+            gpr_hexdump(grpc_mdstr_as_c_string(ops[i].data.metadata->key),
+                        GPR_SLICE_LENGTH(ops[i].data.metadata->key->slice),
+                        GPR_HEXDUMP_PLAINTEXT);
+        hexstr2 =
+            gpr_hexdump(grpc_mdstr_as_c_string(ops[i].data.metadata->value),
+                        GPR_SLICE_LENGTH(ops[i].data.metadata->value->slice),
+                        GPR_HEXDUMP_PLAINTEXT);
+        gpr_log(GPR_DEBUG, "  [%02d] GRPC_OP_METADATA key=%s value=%s", i,
+                hexstr1, hexstr2);
+        gpr_free(hexstr1);
+        gpr_free(hexstr2);
+        break;
+      case GRPC_OP_BEGIN_MESSAGE:
+        CLEAR_REPEATS;
+        gpr_log(GPR_DEBUG, "  [%02d] GRPC_OP_BEGIN_MESSAGE len=%d", i,
+                ops[i].data.begin_message.length);
+        break;
+      case GRPC_OP_DEADLINE:
+        CLEAR_REPEATS;
+        gpr_log(GPR_DEBUG, "  [%02d] GRPC_OP_DEADLINE value=%d.%09d", i,
+                ops[i].data.deadline.tv_sec, ops[i].data.deadline.tv_nsec);
+        break;
+      case GRPC_OP_SLICE:
+        if (i && ops[i - 1].type == GRPC_OP_SLICE &&
+            GPR_SLICE_LENGTH(ops[i - 1].data.slice) ==
+                GPR_SLICE_LENGTH(ops[i].data.slice)) {
+          repeats++;
+        } else {
+          CLEAR_REPEATS;
+          gpr_log(GPR_DEBUG, "  [%02d] GRPC_OP_SLICE len=%d", i,
+                  GPR_SLICE_LENGTH(ops[i].data.slice));
+        }
+        break;
+      case GRPC_OP_FLOW_CTL_CB:
+        CLEAR_REPEATS;
+        gpr_log(GPR_DEBUG, "  [%02d] GRPC_OP_FLOW_CTL_CB", i);
+        break;
+    }
+  }
+  CLEAR_REPEATS;
+
+  /* Iterate over operations, and verify them against expectations */
+  for (i = 0; i < ops_count; i++) {
+    switch (ops[i].type) {
+      case GRPC_NO_OP:
+        break;
+      case GRPC_OP_METADATA_BOUNDARY:
+        break;
+      case GRPC_OP_METADATA:
+        GPR_ASSERT(*expect_root_metadata && "must be expecting metadata");
+        emd = *expect_root_metadata;
+        if (emd == NULL) {
+          gpr_log(GPR_ERROR, "metadata not found");
+          abort();
+        }
+        do {
+          if (emd->metadata == ops[i].data.metadata) {
+            if (emd == *expect_root_metadata) {
+              if (emd->next == emd) {
+                *expect_root_metadata = NULL;
+              } else {
+                *expect_root_metadata = emd->next;
+              }
+            }
+            emd->next->prev = emd->prev;
+            emd->prev->next = emd->next;
+            grpc_mdelem_unref(emd->metadata);
+            grpc_mdelem_unref(ops[i].data.metadata);
+            gpr_free(emd);
+            emd = NULL;
+            break;
+          }
+          emd = emd->next;
+        } while (emd != *expect_root_metadata);
+        if (emd) {
+          gpr_log(GPR_ERROR, "metadata not found");
+          abort();
+        }
+        break;
+      case GRPC_OP_BEGIN_MESSAGE:
+        GPR_ASSERT(*expect_root_message && "must be expecting a message");
+        GPR_ASSERT((*expect_root_message)->read_pos == 0 &&
+                   "must be at the start of a message");
+        GPR_ASSERT((*expect_root_message)->begun == 0 &&
+                   "can only BEGIN a message once");
+        GPR_ASSERT((*expect_root_message)->length ==
+                       ops[i].data.begin_message.length &&
+                   "message lengths must match");
+        (*expect_root_message)->begun = 1;
+        break;
+      case GRPC_OP_SLICE:
+        GPR_ASSERT(*expect_root_message && "must be expecting a message");
+        GPR_ASSERT((*expect_root_message)->begun == 1 &&
+                   "must have begun a message");
+        GPR_ASSERT((*expect_root_message)->read_pos +
+                           GPR_SLICE_LENGTH(ops[i].data.slice) <=
+                       (*expect_root_message)->length &&
+                   "must not send more data than expected");
+        for (j = 0; j < GPR_SLICE_LENGTH(ops[i].data.slice); j++) {
+          GPR_ASSERT((*expect_root_message)
+                             ->data[(*expect_root_message)->read_pos + j] ==
+                         GPR_SLICE_START_PTR(ops[i].data.slice)[j] &&
+                     "must send the correct message");
+        }
+        (*expect_root_message)->read_pos += GPR_SLICE_LENGTH(ops[i].data.slice);
+        if ((*expect_root_message)->read_pos ==
+            (*expect_root_message)->length) {
+          expected_message *great_success = *expect_root_message;
+          *expect_root_message = great_success->next;
+          gpr_free(great_success->data);
+          gpr_free(great_success);
+        }
+        gpr_slice_unref(ops[i].data.slice);
+        break;
+      case GRPC_OP_FLOW_CTL_CB:
+        GPR_ASSERT(0 && "allowed");
+        break;
+      case GRPC_OP_DEADLINE:
+        GPR_ASSERT(0 && "implemented");
+        break;
+    }
+  }
+
+  /* If the stream has become fully closed then we must destroy the transport
+     part of the stream */
+  if (final_state == GRPC_STREAM_CLOSED) {
+    destroy_stream_args *dsa = gpr_malloc(sizeof(destroy_stream_args));
+    gpr_thd_id id;
+    dsa->transport = transport;
+    dsa->stream = stream;
+    /* start a thread after incrementing a pending op counter (so we can wait
+       at test completion */
+    add_pending_op();
+    gpr_thd_new(&id, destroy_stream, dsa, NULL);
+    if (stream == s->client_stream) {
+      GPR_ASSERT(s->client_expected_messages == NULL &&
+                 "must receive all expected messages");
+      s->client_stream = NULL;
+    } else {
+      GPR_ASSERT(s->server_expected_messages == NULL &&
+                 "must receive all expected messages");
+      s->server_stream = NULL;
+    }
+    /* And if both the client and the server report fully closed, we can
+       unlink the stream object entirely */
+    if (s->client_stream == NULL && s->server_stream == NULL) {
+      s->next->prev = s->prev;
+      s->prev->next = s->next;
+      if (s == f->streams) {
+        if (s->next == f->streams) {
+          f->streams = NULL;
+        } else {
+          f->streams = s->next;
+        }
+      }
+    }
+  }
+
+  /* wakeup wait_and_verify */
+  gpr_cv_broadcast(&f->cv);
+  gpr_mu_unlock(&f->mu);
+}
+
+static void close_transport(void *user_data, grpc_transport *transport) {}
+
+static grpc_transport_callbacks transport_callbacks = {
+    alloc_recv_buffer, create_stream, recv_batch, close_transport};
+
+/* Helper for tests to create a stream.
+   Arguments:
+     s - uninitialized test_stream struct to begin
+     f - test fixture to associate this stream with
+     method, host, deadline_seconds - header fields for the stream */
+static void begin_stream(test_stream *s, test_fixture *f, const char *method,
+                         const char *host, double deadline_seconds) {
+  /* Deadline to initiate the stream (prevents the tests from hanging
+     forever) */
+  gpr_timespec deadline = deadline_from_seconds(10.0);
+  grpc_stream_op_buffer sopb;
+
+  grpc_sopb_init(&sopb);
+
+  gpr_mu_lock(&f->mu);
+
+  s->fixture = f;
+  s->client_stream =
+      gpr_malloc(grpc_transport_stream_size(f->client_transport));
+  /* server stream will be set once it's received by the peer transport */
+  s->server_stream = NULL;
+  s->client_expected_messages = NULL;
+  s->server_expected_messages = NULL;
+  s->client_expected_metadata = NULL;
+  s->server_expected_metadata = NULL;
+
+  if (f->streams) {
+    s->next = f->streams;
+    s->prev = s->next->prev;
+    s->next->prev = s->prev->next = s;
+  } else {
+    s->next = s->prev = s;
+  }
+  f->streams = s;
+
+  gpr_mu_unlock(&f->mu);
+
+  GPR_ASSERT(0 == grpc_transport_init_stream(f->client_transport,
+                                             s->client_stream, NULL));
+
+#define ADDMD(k, v)                                                           \
+  do {                                                                        \
+    grpc_mdelem *md = grpc_mdelem_from_strings(g_metadata_context, (k), (v)); \
+    grpc_sopb_add_metadata(&sopb, md);                                        \
+    expect_metadata(s, 1, (k), (v));                                          \
+  } while (0)
+
+  ADDMD(":path", method);
+  ADDMD(":authority", host);
+  ADDMD(":method", "POST");
+  grpc_transport_send_batch(f->client_transport, s->client_stream, sopb.ops,
+                            sopb.nops, 0);
+  sopb.nops = 0;
+
+  grpc_sopb_destroy(&sopb);
+
+  /* wait for the server side stream to be created */
+  gpr_mu_lock(&f->mu);
+  while (s->server_stream == NULL) {
+    GPR_ASSERT(0 == gpr_cv_wait(&f->cv, &f->mu, deadline));
+  }
+  gpr_mu_unlock(&f->mu);
+}
+
+static grpc_transport_setup_result setup_transport(
+    test_fixture *f, grpc_transport **set_transport, void *user_data,
+    grpc_transport *transport) {
+  grpc_transport_setup_result result;
+
+  gpr_mu_lock(&f->mu);
+  *set_transport = transport;
+  gpr_cv_broadcast(&f->cv);
+  gpr_mu_unlock(&f->mu);
+
+  result.callbacks = &transport_callbacks;
+  result.user_data = user_data;
+  return result;
+}
+
+static grpc_transport_setup_result setup_server_transport(
+    void *arg, grpc_transport *transport, grpc_mdctx *mdctx) {
+  test_fixture *f = arg;
+  return setup_transport(f, &f->server_transport, &f->server_ud, transport);
+}
+
+static grpc_transport_setup_result setup_client_transport(
+    void *arg, grpc_transport *transport, grpc_mdctx *mdctx) {
+  test_fixture *f = arg;
+  return setup_transport(f, &f->client_transport, &f->client_ud, transport);
+}
+
+/* Begin a test
+
+   Arguments:
+     f      - uninitialized test_fixture struct
+     config - test configuration for this test
+     name   - the name of this test */
+static void begin_test(test_fixture *f, grpc_transport_test_config *config,
+                       const char *name) {
+  gpr_timespec timeout = gpr_time_add(gpr_now(), gpr_time_from_micros(100e6));
+
+  gpr_log(GPR_INFO, "BEGIN: %s/%s", name, config->name);
+
+  gpr_mu_init(&f->mu);
+  gpr_cv_init(&f->cv);
+
+  f->streams = NULL;
+
+  init_user_data(&f->client_ud, f, config, 1);
+  init_user_data(&f->server_ud, f, config, 0);
+
+  f->client_transport = NULL;
+  f->server_transport = NULL;
+
+  GPR_ASSERT(0 ==
+             config->create_transport(setup_client_transport, f,
+                                      setup_server_transport, f,
+                                      g_metadata_context));
+
+  gpr_mu_lock(&f->mu);
+  while (!f->client_transport || !f->server_transport) {
+    GPR_ASSERT(gpr_cv_wait(&f->cv, &f->mu, timeout));
+  }
+  gpr_mu_unlock(&f->mu);
+}
+
+/* Enumerate expected messages on a stream */
+static void enumerate_expected_messages(
+    test_stream *s, expected_message *root, const char *stream_tag,
+    void (*cb)(void *user, const char *fmt, ...), void *user) {
+  expected_message *msg;
+
+  for (msg = root; msg; msg = msg->next) {
+    cb(user,
+       "Waiting for message to finish: "
+       "length=%zu read_pos=%zu begun=%d",
+       msg->length, msg->read_pos);
+  }
+}
+
+/* Walk through everything that is still waiting to happen, and call 'cb' with
+   userdata 'user' for that expectation. */
+static void enumerate_expectations(test_fixture *f,
+                                   void (*cb)(void *user, const char *fmt, ...),
+                                   void *user) {
+  test_stream *stream;
+
+  if (f->streams) {
+    stream = f->streams;
+    do {
+      cb(user,
+         "Waiting for request to close: "
+         "client=%p, server=%p",
+         stream->client_stream, stream->server_stream);
+      enumerate_expected_messages(stream, stream->client_expected_messages,
+                                  "client", cb, user);
+      enumerate_expected_messages(stream, stream->server_expected_messages,
+                                  "server", cb, user);
+      stream = stream->next;
+    } while (stream != f->streams);
+  }
+}
+
+/* Callback for enumerate_expectations, that increments an integer each time
+   an expectation is seen */
+static void increment_expectation_count(void *p, const char *fmt, ...) {
+  ++*(int *)p;
+}
+
+/* Returns the count of pending expectations in a fixture. Requires mu taken */
+static int count_expectations(test_fixture *f) {
+  int n = 0;
+  enumerate_expectations(f, increment_expectation_count, &n);
+  return n;
+}
+
+/* Callback for enumerate_expectations that adds an expectation to the log */
+static void dump_expectation(void *p, const char *fmt, ...) {
+  char buffer[256];
+  va_list args;
+  va_start(args, fmt);
+
+  vsprintf(buffer, fmt, args);
+  gpr_log(GPR_INFO, "EXPECTED: %s", buffer);
+
+  va_end(args);
+}
+
+/* Add all pending expectations to the log */
+static void dump_expectations(test_fixture *f) {
+  enumerate_expectations(f, dump_expectation, NULL);
+}
+
+/* Wait until all expectations are completed, or crash */
+static void wait_and_verify(test_fixture *f) {
+  gpr_timespec deadline = deadline_from_seconds(10.0);
+
+  gpr_mu_lock(&f->mu);
+  while (count_expectations(f) > 0) {
+    gpr_log(GPR_INFO, "waiting for expectations to complete");
+    if (gpr_cv_wait(&f->cv, &f->mu, deadline)) {
+      gpr_log(GPR_ERROR, "Timeout waiting for expectation completion");
+      dump_expectations(f);
+      gpr_mu_unlock(&f->mu);
+      abort();
+    }
+  }
+  gpr_mu_unlock(&f->mu);
+}
+
+/* Finish a test */
+static void end_test(test_fixture *f) {
+  wait_and_verify(f);
+
+  grpc_transport_close(f->client_transport);
+  grpc_transport_close(f->server_transport);
+  grpc_transport_destroy(f->client_transport);
+  grpc_transport_destroy(f->server_transport);
+
+  wait_pending_ops();
+}
+
+/* Generate a test slice filled with {0,1,2,3,...,255,0,1,2,3,4,...} */
+static gpr_slice generate_test_data(size_t length) {
+  gpr_slice slice = gpr_slice_malloc(length);
+  int i;
+  for (i = 0; i < length; i++) {
+    GPR_SLICE_START_PTR(slice)[i] = i;
+  }
+  return slice;
+}
+
+/* Add an expected message to the end of a list with root root */
+static void append_expected_message(expected_message **root,
+                                    expected_message *message) {
+  expected_message *end;
+
+  if (!*root) {
+    *root = message;
+    return;
+  }
+
+  for (end = *root; end->next; end = end->next)
+    ;
+  end->next = message;
+}
+
+/* Add an expected message on stream 's''.
+   If from_client==1, expect it on the server, otherwise expect it on the client
+   Variadic parameters are a NULL-terminated list of pointers to slices that
+   should be expected as payload */
+static void expect_message(test_stream *s, int from_client,
+                           /* gpr_slice* */...) {
+  va_list args;
+  gpr_slice *slice;
+  size_t capacity = 32;
+  size_t length = 0;
+  gpr_uint8 *buffer = gpr_malloc(capacity);
+  expected_message *e;
+
+  va_start(args, from_client);
+  while ((slice = va_arg(args, gpr_slice *))) {
+    while (GPR_SLICE_LENGTH(*slice) + length > capacity) {
+      capacity *= 2;
+      buffer = gpr_realloc(buffer, capacity);
+    }
+    memcpy(buffer + length, GPR_SLICE_START_PTR(*slice),
+           GPR_SLICE_LENGTH(*slice));
+    length += GPR_SLICE_LENGTH(*slice);
+  }
+  va_end(args);
+
+  e = gpr_malloc(sizeof(expected_message));
+  e->data = buffer;
+  e->length = length;
+  e->read_pos = 0;
+  e->begun = 0;
+  e->next = NULL;
+
+  gpr_mu_lock(&s->fixture->mu);
+  append_expected_message(
+      from_client ? &s->server_expected_messages : &s->client_expected_messages,
+      e);
+  gpr_mu_unlock(&s->fixture->mu);
+}
+
+static void expect_metadata(test_stream *s, int from_client, const char *key,
+                            const char *value) {
+  expected_metadata *e = gpr_malloc(sizeof(expected_metadata));
+  expected_metadata **root =
+      from_client ? &s->server_expected_metadata : &s->client_expected_metadata;
+  e->metadata = grpc_mdelem_from_strings(g_metadata_context, key, value);
+  gpr_mu_lock(&s->fixture->mu);
+  if (!*root) {
+    *root = e;
+    e->next = e->prev = e;
+  } else {
+    e->next = *root;
+    e->prev = e->next->prev;
+    e->next->prev = e->prev->next = e;
+  }
+  gpr_mu_unlock(&s->fixture->mu);
+}
+
+/******************************************************************************
+ * Actual unit tests
+ */
+
+/* Test that we can create, begin, and end a test */
+static void test_no_op(grpc_transport_test_config *config) {
+  test_fixture f;
+  begin_test(&f, config, __FUNCTION__);
+  end_test(&f);
+}
+
+/* Test that a request can be initiated and terminated normally */
+static void test_simple_request(grpc_transport_test_config *config) {
+  test_fixture f;
+  test_stream s;
+
+  begin_test(&f, config, __FUNCTION__);
+  begin_stream(&s, &f, "/Test", "foo.google.com", 10);
+  grpc_transport_send_batch(f.client_transport, s.client_stream, NULL, 0, 1);
+  grpc_transport_send_batch(f.server_transport, s.server_stream, NULL, 0, 1);
+  end_test(&f);
+}
+
+/* Test that a request can be aborted by the client */
+static void test_can_abort_client(grpc_transport_test_config *config) {
+  test_fixture f;
+  test_stream s;
+
+  begin_test(&f, config, __FUNCTION__);
+  begin_stream(&s, &f, "/Test", "foo.google.com", 10);
+  expect_metadata(&s, 0, "grpc-status", "1");
+  expect_metadata(&s, 1, "grpc-status", "1");
+  grpc_transport_abort_stream(f.client_transport, s.client_stream,
+                              GRPC_STATUS_CANCELLED);
+  end_test(&f);
+}
+
+/* Test that a request can be aborted by the server */
+static void test_can_abort_server(grpc_transport_test_config *config) {
+  test_fixture f;
+  test_stream s;
+
+  begin_test(&f, config, __FUNCTION__);
+  begin_stream(&s, &f, "/Test", "foo.google.com", 10);
+  expect_metadata(&s, 0, "grpc-status", "1");
+  expect_metadata(&s, 1, "grpc-status", "1");
+  grpc_transport_abort_stream(f.server_transport, s.server_stream,
+                              GRPC_STATUS_CANCELLED);
+  end_test(&f);
+}
+
+/* Test that a request can be sent with payload */
+static void test_request_with_data(grpc_transport_test_config *config,
+                                   size_t message_length) {
+  test_fixture f;
+  test_stream s;
+  gpr_slice data = generate_test_data(message_length);
+  grpc_stream_op_buffer sopb;
+
+  grpc_sopb_init(&sopb);
+  begin_test(&f, config, __FUNCTION__);
+  gpr_log(GPR_INFO, "message_length = %d", message_length);
+  begin_stream(&s, &f, "/Test", "foo.google.com", 10);
+  expect_message(&s, 1, &data, NULL);
+  grpc_sopb_add_begin_message(&sopb, message_length, 0);
+  grpc_sopb_add_slice(&sopb, data);
+  grpc_transport_set_allow_window_updates(f.server_transport, s.server_stream,
+                                          1);
+  grpc_transport_send_batch(f.client_transport, s.client_stream, sopb.ops,
+                            sopb.nops, 1);
+  sopb.nops = 0;
+  grpc_transport_send_batch(f.server_transport, s.server_stream, NULL, 0, 1);
+  end_test(&f);
+  grpc_sopb_destroy(&sopb);
+}
+
+/* Increment an integer pointed to by x - used for verifying flow control */
+static void increment_int(void *x, grpc_op_error error) { ++*(int *)x; }
+
+/* Test that flow control callbacks are made at appropriate times */
+static void test_request_with_flow_ctl_cb(grpc_transport_test_config *config,
+                                          size_t message_length) {
+  test_fixture f;
+  test_stream s;
+  int flow_ctl_called = 0;
+  gpr_slice data = generate_test_data(message_length);
+  grpc_stream_op_buffer sopb;
+
+  grpc_sopb_init(&sopb);
+  begin_test(&f, config, __FUNCTION__);
+  gpr_log(GPR_INFO, "length=%d", message_length);
+  begin_stream(&s, &f, "/Test", "foo.google.com", 10);
+  expect_message(&s, 1, &data, NULL);
+  grpc_sopb_add_begin_message(&sopb, message_length, 0);
+  grpc_sopb_add_slice(&sopb, data);
+  grpc_sopb_add_flow_ctl_cb(&sopb, increment_int, &flow_ctl_called);
+  grpc_transport_set_allow_window_updates(f.server_transport, s.server_stream,
+                                          1);
+  grpc_transport_send_batch(f.client_transport, s.client_stream, sopb.ops,
+                            sopb.nops, 1);
+  sopb.nops = 0;
+  grpc_transport_send_batch(f.server_transport, s.server_stream, NULL, 0, 1);
+  end_test(&f);
+  GPR_ASSERT(flow_ctl_called == 1);
+  grpc_sopb_destroy(&sopb);
+}
+
+/* Set an event on ping response */
+static void ping_cb(void *p) { gpr_event_set(p, (void *)1); }
+
+/* Test that pinging gets a response */
+static void test_ping(grpc_transport_test_config *config) {
+  test_fixture f;
+  gpr_event ev;
+
+  begin_test(&f, config, __FUNCTION__);
+  gpr_event_init(&ev);
+
+  grpc_transport_ping(f.client_transport, ping_cb, &ev);
+  GPR_ASSERT(gpr_event_wait(&ev, deadline_from_seconds(10)));
+
+  end_test(&f);
+}
+
+/******************************************************************************
+ * Test driver
+ */
+
+static const size_t interesting_message_lengths[] = {
+    1, 100, 10000, 100000, 1000000,
+};
+
+void grpc_transport_end2end_tests(grpc_transport_test_config *config) {
+  int i;
+
+  g_metadata_context = grpc_mdctx_create();
+
+  test_no_op(config);
+  test_simple_request(config);
+  test_can_abort_client(config);
+  test_can_abort_server(config);
+  test_ping(config);
+  for (i = 0; i < GPR_ARRAY_SIZE(interesting_message_lengths); i++) {
+    test_request_with_data(config, interesting_message_lengths[i]);
+    test_request_with_flow_ctl_cb(config, interesting_message_lengths[i]);
+  }
+
+  grpc_mdctx_orphan(g_metadata_context);
+
+  gpr_log(GPR_INFO, "tests completed ok");
+}
diff --git a/test/core/transport/transport_end2end_tests.h b/test/core/transport/transport_end2end_tests.h
new file mode 100644
index 0000000..322034f
--- /dev/null
+++ b/test/core/transport/transport_end2end_tests.h
@@ -0,0 +1,68 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef __GRPC_TEST_TRANSPORT_TRANSPORT_END2END_TESTS_H__
+#define __GRPC_TEST_TRANSPORT_TRANSPORT_END2END_TESTS_H__
+
+#include "src/core/transport/transport.h"
+
+/* Defines a suite of tests that all GRPC transports should be able to pass */
+
+/* A test configuration has a name and a factory method */
+typedef struct grpc_transport_test_config {
+  /* The name of this configuration */
+  char *name;
+  /* Create a transport
+     Returns 0 on success
+
+     Arguments:
+       OUT: client           - the created client half of the transport
+       IN:  client_callbacks - callback structure to be used by the client
+                               transport
+       IN:  client_user_data - user data pointer to be passed into each client
+                               callback
+       OUT: server           - the created server half of the transport
+       IN:  server_callbacks - callback structure to be used by the server
+                               transport
+       IN:  server_user_data - user data pointer to be passed into each
+                               server */
+  int (*create_transport)(grpc_transport_setup_callback client_setup,
+                          void *client_arg,
+                          grpc_transport_setup_callback server_setup,
+                          void *server_arg, grpc_mdctx *mdctx);
+} grpc_transport_test_config;
+
+/* Run the test suite on one configuration */
+void grpc_transport_end2end_tests(grpc_transport_test_config *config);
+
+#endif  /* __GRPC_TEST_TRANSPORT_TRANSPORT_END2END_TESTS_H__ */
diff --git a/test/core/util/grpc_profiler.c b/test/core/util/grpc_profiler.c
new file mode 100644
index 0000000..e135743
--- /dev/null
+++ b/test/core/util/grpc_profiler.c
@@ -0,0 +1,38 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/util/grpc_profiler.h"
+
+void grpc_profiler_start(const char *filename) {}
+
+void grpc_profiler_stop() {}
diff --git a/test/core/util/grpc_profiler.h b/test/core/util/grpc_profiler.h
new file mode 100644
index 0000000..7cc4733
--- /dev/null
+++ b/test/core/util/grpc_profiler.h
@@ -0,0 +1,48 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef __GRPC_TEST_UTIL_GRPC_PROFILER_H__
+#define __GRPC_TEST_UTIL_GRPC_PROFILER_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /*  __cplusplus */
+
+void grpc_profiler_start(const char *filename);
+void grpc_profiler_stop();
+
+#ifdef __cplusplus
+}
+#endif /*  __cplusplus */
+
+#endif  /* __GRPC_TEST_UTIL_GRPC_PROFILER_H__ */
diff --git a/test/core/util/parse_hexstring.c b/test/core/util/parse_hexstring.c
new file mode 100644
index 0000000..888d03b
--- /dev/null
+++ b/test/core/util/parse_hexstring.c
@@ -0,0 +1,70 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/util/parse_hexstring.h"
+#include <grpc/support/log.h>
+
+gpr_slice parse_hexstring(const char *hexstring) {
+  int 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');
+  }
+
+  GPR_ASSERT((nibbles & 1) == 0);
+
+  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 = (temp << 4) | (*p - '0');
+      nibbles++;
+    } else if (*p >= 'a' && *p <= 'f') {
+      temp = (temp << 4) | (*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
new file mode 100644
index 0000000..7477986
--- /dev/null
+++ b/test/core/util/parse_hexstring.h
@@ -0,0 +1,41 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef __GRPC_TEST_UTIL_PARSE_HEXSTRING_H_
+#define __GRPC_TEST_UTIL_PARSE_HEXSTRING_H_
+
+#include <grpc/support/slice.h>
+
+gpr_slice parse_hexstring(const char *hexstring);
+
+#endif /* __GRPC_TEST_UTIL_PARSE_HEXSTRING_H_ */
diff --git a/test/core/util/port.c b/test/core/util/port.c
new file mode 100644
index 0000000..133b53f
--- /dev/null
+++ b/test/core/util/port.c
@@ -0,0 +1,145 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/util/port.h"
+
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <grpc/support/log.h>
+
+#define NUM_RANDOM_PORTS_TO_PICK 100
+
+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);
+  int one = 1;
+  struct sockaddr_in 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;
+  }
+
+  /* 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;
+  }
+
+  /* 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));
+    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);
+  return 1;
+}
+
+int grpc_pick_unused_port() {
+  /* 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
+     iterations, we bind to an anonymous port and let the OS pick the
+     port number.  The random port picking reduces the probability of
+     races with other processes on kernels that want to reuse the same
+     port numbers over and over. */
+
+  /* In alternating iterations we try UDP ports before TCP ports UDP
+     ports -- it could be the case that this machine has been using up
+     UDP ports and they are scarcer. */
+
+  /* Type of port to first pick in next iteration */
+  int is_tcp = 1;
+  int try
+    = 0;
+
+  for (;;) {
+    int port = try
+      < NUM_RANDOM_PORTS_TO_PICK ? rand() % (65536 - 30000) + 30000 : 0;
+    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 try 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 */
+
+    return port;
+  }
+
+  /* The port iterator reached the end without finding a suitable port. */
+  return 0;
+}
+
+int grpc_pick_unused_port_or_die() {
+  int port = grpc_pick_unused_port();
+  GPR_ASSERT(port > 0);
+  return port;
+}
diff --git a/test/core/util/port.h b/test/core/util/port.h
new file mode 100644
index 0000000..d06f047
--- /dev/null
+++ b/test/core/util/port.h
@@ -0,0 +1,44 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef __GRPC_TEST_UTIL_PORT_H__
+#define __GRPC_TEST_UTIL_PORT_H__
+
+/* pick a port number that is currently unused by either tcp or udp. return
+   0 on failure. */
+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();
+
+#endif  /* __GRPC_TEST_UTIL_PORT_H__ */
diff --git a/test/core/util/slice_splitter.c b/test/core/util/slice_splitter.c
new file mode 100644
index 0000000..1682ef4
--- /dev/null
+++ b/test/core/util/slice_splitter.c
@@ -0,0 +1,138 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/util/slice_splitter.h"
+
+#include <string.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/useful.h>
+
+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) {
+  size_t i, j;
+  size_t length;
+
+  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]);
+      }
+      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);
+      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]);
+      }
+      break;
+    case GRPC_SLICE_SPLIT_ONE_BYTE:
+      length = 0;
+      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);
+      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++;
+        }
+      }
+      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) {
+  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);
+}
+
+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_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);
+    }
+    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);
+}
diff --git a/test/core/util/slice_splitter.h b/test/core/util/slice_splitter.h
new file mode 100644
index 0000000..bff4515
--- /dev/null
+++ b/test/core/util/slice_splitter.h
@@ -0,0 +1,68 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef __GRPC_TEST_UTIL_SLICE_SPLITTER_H__
+#define __GRPC_TEST_UTIL_SLICE_SPLITTER_H__
+
+/* utility function to split/merge slices together to help create test
+   cases */
+
+#include <grpc/support/slice.h>
+#include <grpc/support/slice_buffer.h>
+
+typedef enum {
+  /* merge all input slices into a single slice */
+  GRPC_SLICE_SPLIT_MERGE_ALL,
+  /* leave slices as is */
+  GRPC_SLICE_SPLIT_IDENTITY,
+  /* split slices into one byte chunks */
+  GRPC_SLICE_SPLIT_ONE_BYTE
+} grpc_slice_split_mode;
+
+/* 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_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);
+
+const char *grpc_slice_split_mode_name(grpc_slice_split_mode mode);
+
+#endif  /* __GRPC_TEST_UTIL_SLICE_SPLITTER_H__ */
diff --git a/test/core/util/test_config.c b/test/core/util/test_config.c
new file mode 100644
index 0000000..993014a
--- /dev/null
+++ b/test/core/util/test_config.c
@@ -0,0 +1,36 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/util/test_config.h"
+
+void grpc_test_init(int argc, char **argv) {}
diff --git a/test/core/util/test_config.h b/test/core/util/test_config.h
new file mode 100644
index 0000000..8ada77b
--- /dev/null
+++ b/test/core/util/test_config.h
@@ -0,0 +1,47 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef __GRPC_TEST_UTIL_TEST_CONFIG_H__
+#define __GRPC_TEST_UTIL_TEST_CONFIG_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /*  __cplusplus */
+
+void grpc_test_init(int argc, char **argv);
+
+#ifdef __cplusplus
+}
+#endif /*  __cplusplus */
+
+#endif  /* __GRPC_TEST_UTIL_TEST_CONFIG_H__ */
diff --git a/test/cpp/end2end/async_test_server.cc b/test/cpp/end2end/async_test_server.cc
new file mode 100644
index 0000000..0a40dbb
--- /dev/null
+++ b/test/cpp/end2end/async_test_server.cc
@@ -0,0 +1,155 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/cpp/end2end/async_test_server.h"
+
+#include <chrono>
+
+#include <grpc/support/log.h>
+#include "src/cpp/proto/proto_utils.h"
+#include "test/cpp/util/echo.pb.h"
+#include <grpc++/async_server.h>
+#include <grpc++/async_server_context.h>
+#include <grpc++/completion_queue.h>
+#include <grpc++/status.h>
+#include <gtest/gtest.h>
+
+using grpc::cpp::test::util::EchoRequest;
+using grpc::cpp::test::util::EchoResponse;
+
+using std::chrono::duration_cast;
+using std::chrono::microseconds;
+using std::chrono::seconds;
+using std::chrono::system_clock;
+
+namespace grpc {
+namespace testing {
+
+AsyncTestServer::AsyncTestServer() : server_(&cq_), cq_drained_(false) {}
+
+AsyncTestServer::~AsyncTestServer() {}
+
+void AsyncTestServer::AddPort(const grpc::string& addr) {
+  server_.AddPort(addr);
+}
+
+void AsyncTestServer::Start() { server_.Start(); }
+
+// Return true if deadline actual is within 0.5s from expected.
+bool DeadlineMatched(const system_clock::time_point& actual,
+                     const system_clock::time_point& expected) {
+  microseconds diff_usecs = duration_cast<microseconds>(expected - actual);
+  gpr_log(GPR_INFO, "diff_usecs= %d", diff_usecs.count());
+  return diff_usecs.count() < 500000 && diff_usecs.count() > -500000;
+}
+
+void AsyncTestServer::RequestOneRpc() { server_.RequestOneRpc(); }
+
+void AsyncTestServer::MainLoop() {
+  EchoRequest request;
+  EchoResponse response;
+  void* tag = nullptr;
+
+  RequestOneRpc();
+
+  while (true) {
+    CompletionQueue::CompletionType t = cq_.Next(&tag);
+    AsyncServerContext* server_context = static_cast<AsyncServerContext*>(tag);
+    switch (t) {
+      case CompletionQueue::SERVER_RPC_NEW:
+        gpr_log(GPR_INFO, "SERVER_RPC_NEW %p", server_context);
+        if (server_context) {
+          EXPECT_EQ(server_context->method(), "/foo");
+          EXPECT_EQ(server_context->host(), "localhost");
+          // TODO(ctiller): verify deadline
+          server_context->Accept(cq_.cq());
+          // Handle only one rpc at a time.
+          RequestOneRpc();
+          server_context->StartRead(&request);
+        }
+        break;
+      case CompletionQueue::RPC_END:
+        gpr_log(GPR_INFO, "RPC_END %p", server_context);
+        delete server_context;
+        break;
+      case CompletionQueue::SERVER_READ_OK:
+        gpr_log(GPR_INFO, "SERVER_READ_OK %p", server_context);
+        response.set_message(request.message());
+        server_context->StartWrite(response, 0);
+        break;
+      case CompletionQueue::SERVER_READ_ERROR:
+        gpr_log(GPR_INFO, "SERVER_READ_ERROR %p", server_context);
+        server_context->StartWriteStatus(Status::OK);
+        break;
+      case CompletionQueue::HALFCLOSE_OK:
+        gpr_log(GPR_INFO, "HALFCLOSE_OK %p", server_context);
+        // Do nothing, just wait for RPC_END.
+        break;
+      case CompletionQueue::SERVER_WRITE_OK:
+        gpr_log(GPR_INFO, "SERVER_WRITE_OK %p", server_context);
+        server_context->StartRead(&request);
+        break;
+      case CompletionQueue::SERVER_WRITE_ERROR:
+        EXPECT_TRUE(0);
+        break;
+      case CompletionQueue::QUEUE_CLOSED: {
+        gpr_log(GPR_INFO, "QUEUE_CLOSED");
+        HandleQueueClosed();
+        return;
+      }
+      default:
+        EXPECT_TRUE(0);
+        break;
+    }
+  }
+}
+
+void AsyncTestServer::HandleQueueClosed() {
+  std::unique_lock<std::mutex> lock(cq_drained_mu_);
+  cq_drained_ = true;
+  cq_drained_cv_.notify_all();
+}
+
+void AsyncTestServer::Shutdown() {
+  // The server need to be shut down before cq_ as grpc_server flushes all
+  // pending requested calls to the completion queue at shutdown.
+  server_.Shutdown();
+  cq_.Shutdown();
+  std::unique_lock<std::mutex> lock(cq_drained_mu_);
+  while (!cq_drained_) {
+    cq_drained_cv_.wait(lock);
+  }
+}
+
+}  // namespace testing
+}  // namespace grpc
diff --git a/test/cpp/end2end/async_test_server.h b/test/cpp/end2end/async_test_server.h
new file mode 100644
index 0000000..a277061
--- /dev/null
+++ b/test/cpp/end2end/async_test_server.h
@@ -0,0 +1,75 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef __GRPCPP_TEST_END2END_ASYNC_TEST_SERVER_H__
+#define __GRPCPP_TEST_END2END_ASYNC_TEST_SERVER_H__
+
+#include <condition_variable>
+#include <mutex>
+#include <string>
+
+#include <grpc++/async_server.h>
+#include <grpc++/completion_queue.h>
+
+namespace grpc {
+
+namespace testing {
+
+class AsyncTestServer {
+ public:
+  AsyncTestServer();
+  virtual ~AsyncTestServer();
+
+  void AddPort(const grpc::string& addr);
+  void Start();
+  void RequestOneRpc();
+  virtual void MainLoop();
+  void Shutdown();
+
+  CompletionQueue* completion_queue() { return &cq_; }
+
+ protected:
+  void HandleQueueClosed();
+
+ private:
+  CompletionQueue cq_;
+  AsyncServer server_;
+  bool cq_drained_;
+  std::mutex cq_drained_mu_;
+  std::condition_variable cq_drained_cv_;
+};
+
+}  // namespace testing
+}  // namespace grpc
+
+#endif  // __GRPCPP_TEST_END2END_ASYNC_TEST_SERVER_H__
diff --git a/test/cpp/end2end/end2end_test.cc b/test/cpp/end2end/end2end_test.cc
new file mode 100644
index 0000000..255e29e
--- /dev/null
+++ b/test/cpp/end2end/end2end_test.cc
@@ -0,0 +1,125 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <thread>
+#include "src/cpp/server/rpc_service_method.h"
+#include "test/cpp/util/echo.pb.h"
+#include "net/util/netutil.h"
+#include <grpc++/channel_interface.h>
+#include <grpc++/client_context.h>
+#include <grpc++/create_channel.h>
+#include <grpc++/server.h>
+#include <grpc++/server_builder.h>
+#include <grpc++/status.h>
+#include <gtest/gtest.h>
+
+#include <grpc/grpc.h>
+#include <grpc/support/thd.h>
+
+using grpc::cpp::test::util::EchoRequest;
+using grpc::cpp::test::util::EchoResponse;
+using grpc::cpp::test::util::TestService;
+
+namespace grpc {
+
+class TestServiceImpl : public TestService::Service {
+ public:
+  Status Echo(const EchoRequest* request, EchoResponse* response) {
+    response->set_message(request->message());
+    return Status::OK;
+  }
+};
+
+class End2endTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    int port = PickUnusedPortOrDie();
+    server_address_ << "localhost:" << port;
+    // Setup server
+    ServerBuilder builder;
+    builder.AddPort(server_address_.str());
+    builder.RegisterService(service.service());
+    server_ = builder.BuildAndStart();
+  }
+
+  void TearDown() override {
+    server_->Shutdown();
+  }
+
+  std::unique_ptr<Server> server_;
+  std::ostringstream server_address_;
+  TestServiceImpl service;
+};
+
+static void SendRpc(const grpc::string& server_address, int num_rpcs) {
+  std::shared_ptr<ChannelInterface> channel =
+      CreateChannel(server_address);
+  TestService::Stub* stub = TestService::NewStub(channel);
+  EchoRequest request;
+  EchoResponse response;
+  request.set_message("Hello");
+
+  for (int i = 0; i < num_rpcs; ++i) {
+    ClientContext context;
+    Status s = stub->Echo(&context, request, &response);
+    EXPECT_EQ(response.message(), request.message());
+    EXPECT_TRUE(s.IsOk());
+  }
+
+  delete stub;
+}
+
+TEST_F(End2endTest, SimpleRpc) {
+  SendRpc(server_address_.str(), 1);
+}
+
+TEST_F(End2endTest, MultipleRpcs) {
+  vector<std::thread*> threads;
+  for (int i = 0; i < 10; ++i) {
+    threads.push_back(new std::thread(SendRpc, server_address_.str(), 10));
+  }
+  for (int i = 0; i < 10; ++i) {
+    threads[i]->join();
+    delete threads[i];
+  }
+}
+
+}  // namespace grpc
+
+int main(int argc, char** argv) {
+  grpc_init();
+  ::testing::InitGoogleTest(&argc, argv);
+  int result = RUN_ALL_TESTS();
+  grpc_shutdown();
+  return result;
+}
diff --git a/test/cpp/end2end/sync_client_async_server_test.cc b/test/cpp/end2end/sync_client_async_server_test.cc
new file mode 100644
index 0000000..f9ac6f2
--- /dev/null
+++ b/test/cpp/end2end/sync_client_async_server_test.cc
@@ -0,0 +1,237 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+#include <chrono>
+#include <memory>
+#include <sstream>
+#include <string>
+
+#include <grpc/grpc.h>
+#include <grpc/support/thd.h>
+#include "src/cpp/client/internal_stub.h"
+#include "src/cpp/rpc_method.h"
+#include "test/cpp/util/echo.pb.h"
+#include "net/util/netutil.h"
+#include <grpc++/channel_interface.h>
+#include <grpc++/client_context.h>
+#include <grpc++/create_channel.h>
+#include <grpc++/status.h>
+#include <grpc++/stream.h>
+#include "test/cpp/end2end/async_test_server.h"
+#include <gtest/gtest.h>
+
+using grpc::cpp::test::util::EchoRequest;
+using grpc::cpp::test::util::EchoResponse;
+
+using std::chrono::duration_cast;
+using std::chrono::microseconds;
+using std::chrono::seconds;
+using std::chrono::system_clock;
+
+using grpc::testing::AsyncTestServer;
+
+namespace grpc {
+namespace {
+
+void ServerLoop(void* s) {
+  AsyncTestServer* server = static_cast<AsyncTestServer*>(s);
+  server->MainLoop();
+}
+
+class End2endTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    int port = PickUnusedPortOrDie();
+    // TODO(yangg) protobuf has a StringPrintf, maybe use that
+    std::ostringstream oss;
+    oss << "[::]:" << port;
+    // Setup server
+    server_.reset(new AsyncTestServer());
+    server_->AddPort(oss.str());
+    server_->Start();
+
+    RunServerThread();
+
+    // Setup client
+    oss.str("");
+    oss << "127.0.0.1:" << port;
+    std::shared_ptr<ChannelInterface> channel = CreateChannel(oss.str());
+    stub_.set_channel(channel);
+  }
+
+  void RunServerThread() {
+    gpr_thd_id id;
+    EXPECT_TRUE(gpr_thd_new(&id, ServerLoop, server_.get(), NULL));
+  }
+
+  void TearDown() override {
+    server_->Shutdown();
+  }
+
+  std::unique_ptr<AsyncTestServer> server_;
+  InternalStub stub_;
+};
+
+TEST_F(End2endTest, NoOpTest) { EXPECT_TRUE(stub_.channel() != nullptr); }
+
+TEST_F(End2endTest, SimpleRpc) {
+  EchoRequest request;
+  request.set_message("hello");
+  EchoResponse result;
+  ClientContext context;
+  RpcMethod method("/foo");
+  std::chrono::system_clock::time_point deadline =
+      std::chrono::system_clock::now() + std::chrono::seconds(10);
+  context.set_absolute_deadline(deadline);
+  Status s =
+      stub_.channel()->StartBlockingRpc(method, &context, request, &result);
+  EXPECT_EQ(result.message(), request.message());
+  EXPECT_TRUE(s.IsOk());
+}
+
+TEST_F(End2endTest, KSequentialSimpleRpcs) {
+  int k = 3;
+  for (int i = 0; i < k; i++) {
+    EchoRequest request;
+    request.set_message("hello");
+    EchoResponse result;
+    ClientContext context;
+    RpcMethod method("/foo");
+    std::chrono::system_clock::time_point deadline =
+        std::chrono::system_clock::now() + std::chrono::seconds(10);
+    context.set_absolute_deadline(deadline);
+    Status s =
+        stub_.channel()->StartBlockingRpc(method, &context, request, &result);
+    EXPECT_EQ(result.message(), request.message());
+    EXPECT_TRUE(s.IsOk());
+  }
+}
+
+TEST_F(End2endTest, OnePingpongBidiStream) {
+  EchoRequest request;
+  request.set_message("hello");
+  EchoResponse result;
+  ClientContext context;
+  RpcMethod method("/foo", RpcMethod::RpcType::BIDI_STREAMING);
+  std::chrono::system_clock::time_point deadline =
+      std::chrono::system_clock::now() + std::chrono::seconds(10);
+  context.set_absolute_deadline(deadline);
+  StreamContextInterface* stream_interface =
+      stub_.channel()->CreateStream(method, &context, nullptr, nullptr);
+  std::unique_ptr<ClientReaderWriter<EchoRequest, EchoResponse>> stream(
+      new ClientReaderWriter<EchoRequest, EchoResponse>(stream_interface));
+  EXPECT_TRUE(stream->Write(request));
+  EXPECT_TRUE(stream->Read(&result));
+  stream->WritesDone();
+  EXPECT_FALSE(stream->Read(&result));
+  Status s = stream->Wait();
+  EXPECT_EQ(result.message(), request.message());
+  EXPECT_TRUE(s.IsOk());
+}
+
+TEST_F(End2endTest, TwoPingpongBidiStream) {
+  EchoRequest request;
+  request.set_message("hello");
+  EchoResponse result;
+  ClientContext context;
+  RpcMethod method("/foo", RpcMethod::RpcType::BIDI_STREAMING);
+  std::chrono::system_clock::time_point deadline =
+      std::chrono::system_clock::now() + std::chrono::seconds(10);
+  context.set_absolute_deadline(deadline);
+  StreamContextInterface* stream_interface =
+      stub_.channel()->CreateStream(method, &context, nullptr, nullptr);
+  std::unique_ptr<ClientReaderWriter<EchoRequest, EchoResponse>> stream(
+      new ClientReaderWriter<EchoRequest, EchoResponse>(stream_interface));
+  EXPECT_TRUE(stream->Write(request));
+  EXPECT_TRUE(stream->Read(&result));
+  EXPECT_EQ(result.message(), request.message());
+  EXPECT_TRUE(stream->Write(request));
+  EXPECT_TRUE(stream->Read(&result));
+  EXPECT_EQ(result.message(), request.message());
+  stream->WritesDone();
+  EXPECT_FALSE(stream->Read(&result));
+  Status s = stream->Wait();
+  EXPECT_TRUE(s.IsOk());
+}
+
+TEST_F(End2endTest, OnePingpongClientStream) {
+  EchoRequest request;
+  request.set_message("hello");
+  EchoResponse result;
+  ClientContext context;
+  RpcMethod method("/foo", RpcMethod::RpcType::CLIENT_STREAMING);
+  std::chrono::system_clock::time_point deadline =
+      std::chrono::system_clock::now() + std::chrono::seconds(10);
+  context.set_absolute_deadline(deadline);
+  StreamContextInterface* stream_interface =
+      stub_.channel()->CreateStream(method, &context, nullptr, &result);
+  std::unique_ptr<ClientWriter<EchoRequest>> stream(
+      new ClientWriter<EchoRequest>(stream_interface));
+  EXPECT_TRUE(stream->Write(request));
+  stream->WritesDone();
+  Status s = stream->Wait();
+  EXPECT_EQ(result.message(), request.message());
+  EXPECT_TRUE(s.IsOk());
+}
+
+TEST_F(End2endTest, OnePingpongServerStream) {
+  EchoRequest request;
+  request.set_message("hello");
+  EchoResponse result;
+  ClientContext context;
+  RpcMethod method("/foo", RpcMethod::RpcType::SERVER_STREAMING);
+  std::chrono::system_clock::time_point deadline =
+      std::chrono::system_clock::now() + std::chrono::seconds(10);
+  context.set_absolute_deadline(deadline);
+  StreamContextInterface* stream_interface =
+      stub_.channel()->CreateStream(method, &context, &request, nullptr);
+  std::unique_ptr<ClientReader<EchoResponse>> stream(
+      new ClientReader<EchoResponse>(stream_interface));
+  EXPECT_TRUE(stream->Read(&result));
+  EXPECT_FALSE(stream->Read(nullptr));
+  Status s = stream->Wait();
+  EXPECT_EQ(result.message(), request.message());
+  EXPECT_TRUE(s.IsOk());
+}
+
+}  // namespace
+}  // namespace grpc
+
+int main(int argc, char** argv) {
+  grpc_init();
+  ::testing::InitGoogleTest(&argc, argv);
+  int result = RUN_ALL_TESTS();
+  grpc_shutdown();
+  return result;
+}
diff --git a/test/cpp/server/thread_pool_test.cc b/test/cpp/server/thread_pool_test.cc
new file mode 100644
index 0000000..cae1a10
--- /dev/null
+++ b/test/cpp/server/thread_pool_test.cc
@@ -0,0 +1,77 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <condition_variable>
+#include <functional>
+#include <mutex>
+
+#include "src/cpp/server/thread_pool.h"
+#include <gtest/gtest.h>
+
+namespace grpc {
+
+class ThreadPoolTest : public ::testing::Test {
+ public:
+  ThreadPoolTest() : thread_pool_(4) {}
+
+ protected:
+  ThreadPool thread_pool_;
+};
+
+void Callback(std::mutex* mu, std::condition_variable* cv, bool* done) {
+  std::unique_lock<std::mutex> lock(*mu);
+  *done = true;
+  cv->notify_all();
+}
+
+TEST_F(ThreadPoolTest, ScheduleCallback) {
+  std::mutex mu;
+  std::condition_variable cv;
+  bool done = false;
+  std::function<void()> callback = std::bind(Callback, &mu, &cv, &done);
+  thread_pool_.ScheduleCallback(callback);
+
+  // Wait for the callback to finish.
+  std::unique_lock<std::mutex> lock(mu);
+  while (!done) {
+    cv.wait(lock);
+  }
+}
+
+}  // namespace grpc
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  int result = RUN_ALL_TESTS();
+  return result;
+}
diff --git a/test/cpp/util/echo.proto b/test/cpp/util/echo.proto
new file mode 100644
index 0000000..37ae6b9
--- /dev/null
+++ b/test/cpp/util/echo.proto
@@ -0,0 +1,15 @@
+syntax = "proto2";
+
+package grpc.cpp.test.util;
+
+message EchoRequest {
+  optional string message = 1;
+}
+
+message EchoResponse {
+  optional string message = 1;
+}
+
+service TestService {
+  rpc Echo(EchoRequest) returns (EchoResponse) {}
+}
diff --git a/test/cpp/util/status_test.cc b/test/cpp/util/status_test.cc
new file mode 100644
index 0000000..1f37167
--- /dev/null
+++ b/test/cpp/util/status_test.cc
@@ -0,0 +1,77 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+#include <grpc++/status.h>
+#include <grpc/status.h>
+#include <grpc/support/log.h>
+
+// Make sure the existing grpc_status_code match with grpc::Code.
+int main(int argc, char **argv) {
+  GPR_ASSERT(grpc::StatusCode::OK ==
+             static_cast<grpc::StatusCode>(GRPC_STATUS_OK));
+  GPR_ASSERT(grpc::StatusCode::CANCELLED ==
+             static_cast<grpc::StatusCode>(GRPC_STATUS_CANCELLED));
+  GPR_ASSERT(grpc::StatusCode::UNKNOWN ==
+             static_cast<grpc::StatusCode>(GRPC_STATUS_UNKNOWN));
+  GPR_ASSERT(grpc::StatusCode::INVALID_ARGUMENT ==
+             static_cast<grpc::StatusCode>(GRPC_STATUS_INVALID_ARGUMENT));
+  GPR_ASSERT(grpc::StatusCode::DEADLINE_EXCEEDED ==
+             static_cast<grpc::StatusCode>(GRPC_STATUS_DEADLINE_EXCEEDED));
+  GPR_ASSERT(grpc::StatusCode::NOT_FOUND ==
+             static_cast<grpc::StatusCode>(GRPC_STATUS_NOT_FOUND));
+  GPR_ASSERT(grpc::StatusCode::ALREADY_EXISTS ==
+             static_cast<grpc::StatusCode>(GRPC_STATUS_ALREADY_EXISTS));
+  GPR_ASSERT(grpc::StatusCode::PERMISSION_DENIED ==
+             static_cast<grpc::StatusCode>(GRPC_STATUS_PERMISSION_DENIED));
+  GPR_ASSERT(grpc::StatusCode::UNAUTHENTICATED ==
+             static_cast<grpc::StatusCode>(GRPC_STATUS_UNAUTHENTICATED));
+  GPR_ASSERT(grpc::StatusCode::RESOURCE_EXHAUSTED ==
+             static_cast<grpc::StatusCode>(GRPC_STATUS_RESOURCE_EXHAUSTED));
+  GPR_ASSERT(grpc::StatusCode::FAILED_PRECONDITION ==
+             static_cast<grpc::StatusCode>(GRPC_STATUS_FAILED_PRECONDITION));
+  GPR_ASSERT(grpc::StatusCode::ABORTED ==
+             static_cast<grpc::StatusCode>(GRPC_STATUS_ABORTED));
+  GPR_ASSERT(grpc::StatusCode::OUT_OF_RANGE ==
+             static_cast<grpc::StatusCode>(GRPC_STATUS_OUT_OF_RANGE));
+  GPR_ASSERT(grpc::StatusCode::UNIMPLEMENTED ==
+             static_cast<grpc::StatusCode>(GRPC_STATUS_UNIMPLEMENTED));
+  GPR_ASSERT(grpc::StatusCode::INTERNAL ==
+             static_cast<grpc::StatusCode>(GRPC_STATUS_INTERNAL));
+  GPR_ASSERT(grpc::StatusCode::UNAVAILABLE ==
+             static_cast<grpc::StatusCode>(GRPC_STATUS_UNAVAILABLE));
+  GPR_ASSERT(grpc::StatusCode::DATA_LOSS ==
+             static_cast<grpc::StatusCode>(GRPC_STATUS_DATA_LOSS));
+
+  return 0;
+}
diff --git a/test/cpp/util/test_ssl_channel.cc b/test/cpp/util/test_ssl_channel.cc
new file mode 100644
index 0000000..bf4a2d6
--- /dev/null
+++ b/test/cpp/util/test_ssl_channel.cc
@@ -0,0 +1,59 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/cpp/util/test_ssl_channel.h"
+
+#include <grpc/support/log.h>
+extern "C" {
+#include "src/core/channel/channel_args.h"
+#include <grpc/grpc_security.h>
+}
+
+#include "test/core/end2end/data/ssl_test_data.h"
+
+namespace grpc {
+
+TestSslChannel::TestSslChannel(const grpc::string& target) {
+  grpc_credentials* ssl_creds = grpc_ssl_credentials_create(
+      test_ca_cert, test_ca_cert_size, NULL, 0, NULL, 0);
+  grpc_arg ssl_name_override = {
+      GRPC_ARG_STRING,
+      const_cast<char*>(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG),
+      {const_cast<char*>("foo.test.google.com")}};
+  grpc_channel_args client_args = {1, &ssl_name_override};
+  set_c_channel(
+      grpc_secure_channel_create(ssl_creds, target.c_str(), &client_args));
+  grpc_credentials_release(ssl_creds);
+}
+
+}  // namespace grpc
diff --git a/test/cpp/util/test_ssl_channel.h b/test/cpp/util/test_ssl_channel.h
new file mode 100644
index 0000000..28905dc
--- /dev/null
+++ b/test/cpp/util/test_ssl_channel.h
@@ -0,0 +1,55 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef __GRPCPP_TEST_UTIL_TEST_SSL_CHANNEL_H__
+#define __GRPCPP_TEST_UTIL_TEST_SSL_CHANNEL_H__
+
+#include <string>
+
+#include "src/cpp/client/channel.h"
+
+struct grpc_channel;
+
+namespace grpc {
+class StreamContextInterface;
+
+// The channel is used to test against test gfe or interop binaries with ssl
+// support.
+class TestSslChannel : public Channel {
+ public:
+  explicit TestSslChannel(const grpc::string& target);
+};
+
+}  // namespace grpc
+
+#endif  // __GRPCPP_TEST_UTIL_TEST_SSL_CHANNEL_H__
diff --git a/test/cpp/util/time_test.cc b/test/cpp/util/time_test.cc
new file mode 100644
index 0000000..4c633f3
--- /dev/null
+++ b/test/cpp/util/time_test.cc
@@ -0,0 +1,68 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+#include "src/cpp/util/time.h"
+
+#include <chrono>
+
+#include <grpc/support/time.h>
+#include <gtest/gtest.h>
+
+using std::chrono::duration_cast;
+using std::chrono::microseconds;
+using std::chrono::system_clock;
+
+namespace grpc {
+namespace {
+
+class TimeTest : public ::testing::Test {};
+
+TEST_F(TimeTest, AbsolutePointTest) {
+  long us = 10000000L;
+  gpr_timespec ts = gpr_time_from_micros(us);
+  system_clock::time_point tp{microseconds(us)};
+  system_clock::time_point tp_converted =
+      AbsoluteDeadlineTimespec2Timepoint(ts);
+  gpr_timespec ts_converted;
+  AbsoluteDeadlineTimepoint2Timespec(tp_converted, &ts_converted);
+  EXPECT_TRUE(ts.tv_sec == ts_converted.tv_sec);
+  EXPECT_TRUE(ts.tv_nsec == ts_converted.tv_nsec);
+  system_clock::time_point tp_converted_2 =
+      AbsoluteDeadlineTimespec2Timepoint(ts_converted);
+  EXPECT_TRUE(tp == tp_converted);
+  EXPECT_TRUE(tp == tp_converted_2);
+}
+
+}  // namespace
+}  // namespace grpc