9 files changed, 698 insertions, 30 deletions

diff --git a/test/core/surface/byte_buffer_reader_test.c b/test/core/surface/byte_buffer_reader_test.c
index 6b41698717..c87fbdc897 100644
--- a/test/core/surface/byte_buffer_reader_test.c
+++ b/test/core/surface/byte_buffer_reader_test.c
@@ -217,6 +217,42 @@ static void test_readall(void) {
   grpc_byte_buffer_destroy(buffer);
 }
 
+static void test_byte_buffer_copy(void) {
+  char *lotsa_as[512];
+  char *lotsa_bs[1024];
+  gpr_slice slices[2];
+  grpc_byte_buffer *buffer;
+  grpc_byte_buffer *copied_buffer;
+  grpc_byte_buffer_reader reader;
+  gpr_slice slice_out;
+
+  LOG_TEST("test_byte_buffer_copy");
+
+  memset(lotsa_as, 'a', 512);
+  memset(lotsa_bs, 'b', 1024);
+  /* use slices large enough to overflow inlining */
+  slices[0] = gpr_slice_malloc(512);
+  memcpy(GPR_SLICE_START_PTR(slices[0]), lotsa_as, 512);
+  slices[1] = gpr_slice_malloc(1024);
+  memcpy(GPR_SLICE_START_PTR(slices[1]), lotsa_bs, 1024);
+
+  buffer = grpc_raw_byte_buffer_create(slices, 2);
+  gpr_slice_unref(slices[0]);
+  gpr_slice_unref(slices[1]);
+  copied_buffer = grpc_byte_buffer_copy(buffer);
+
+  grpc_byte_buffer_reader_init(&reader, copied_buffer);
+  slice_out = grpc_byte_buffer_reader_readall(&reader);
+
+  GPR_ASSERT(GPR_SLICE_LENGTH(slice_out) == 512 + 1024);
+  GPR_ASSERT(memcmp(GPR_SLICE_START_PTR(slice_out), lotsa_as, 512) == 0);
+  GPR_ASSERT(memcmp(&(GPR_SLICE_START_PTR(slice_out)[512]), lotsa_bs, 1024) ==
+             0);
+  gpr_slice_unref(slice_out);
+  grpc_byte_buffer_destroy(buffer);
+  grpc_byte_buffer_destroy(copied_buffer);
+}
+
 int main(int argc, char **argv) {
   grpc_test_init(argc, argv);
   test_read_one_slice();
@@ -225,6 +261,7 @@ int main(int argc, char **argv) {
   test_read_gzip_compressed_slice();
   test_read_deflate_compressed_slice();
   test_byte_buffer_from_reader();
+  test_byte_buffer_copy();
   test_readall();
   return 0;
 }
diff --git a/test/core/surface/channel_create_test.c b/test/core/surface/channel_create_test.c
new file mode 100644
index 0000000000..044e766473
--- /dev/null
+++ b/test/core/surface/channel_create_test.c
@@ -0,0 +1,55 @@
+/*
+ *
+ * Copyright 2015, 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 "src/core/client_config/resolver_registry.h"
+#include "test/core/util/test_config.h"
+
+void test_unknown_scheme_target(void) {
+  grpc_channel *chan;
+  /* avoid default prefix */
+  grpc_resolver_registry_shutdown();
+  grpc_resolver_registry_init("");
+
+  chan = grpc_insecure_channel_create("blah://blah", NULL, NULL);
+  GPR_ASSERT(chan == NULL);
+}
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  grpc_init();
+  test_unknown_scheme_target();
+  grpc_shutdown();
+  return 0;
+}
diff --git a/test/core/surface/completion_queue_test.c b/test/core/surface/completion_queue_test.c
index e3fc789788..252fe80621 100644
--- a/test/core/surface/completion_queue_test.c
+++ b/test/core/surface/completion_queue_test.c
@@ -89,7 +89,7 @@ static void test_cq_end_op(void) {
 
   cc = grpc_completion_queue_create(NULL);
 
-  grpc_cq_begin_op(cc);
+  grpc_cq_begin_op(cc, tag);
   grpc_cq_end_op(&exec_ctx, cc, tag, 1, do_nothing_end_completion, NULL,
                  &completion);
 
@@ -148,7 +148,7 @@ static void test_pluck(void) {
   cc = grpc_completion_queue_create(NULL);
 
   for (i = 0; i < GPR_ARRAY_SIZE(tags); i++) {
-    grpc_cq_begin_op(cc);
+    grpc_cq_begin_op(cc, tags[i]);
     grpc_cq_end_op(&exec_ctx, cc, tags[i], 1, do_nothing_end_completion, NULL,
                    &completions[i]);
   }
@@ -160,7 +160,7 @@ static void test_pluck(void) {
   }
 
   for (i = 0; i < GPR_ARRAY_SIZE(tags); i++) {
-    grpc_cq_begin_op(cc);
+    grpc_cq_begin_op(cc, tags[i]);
     grpc_cq_end_op(&exec_ctx, cc, tags[i], 1, do_nothing_end_completion, NULL,
                    &completions[i]);
   }
@@ -175,6 +175,77 @@ static void test_pluck(void) {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
+static void test_pluck_after_shutdown(void) {
+  grpc_event ev;
+  grpc_completion_queue *cc;
+
+  LOG_TEST("test_pluck_after_shutdown");
+  cc = grpc_completion_queue_create(NULL);
+  grpc_completion_queue_shutdown(cc);
+  ev = grpc_completion_queue_pluck(cc, NULL, gpr_inf_future(GPR_CLOCK_REALTIME),
+                                   NULL);
+  GPR_ASSERT(ev.type == GRPC_QUEUE_SHUTDOWN);
+  grpc_completion_queue_destroy(cc);
+}
+
+struct thread_state {
+  grpc_completion_queue *cc;
+  void *tag;
+};
+
+static void pluck_one(void *arg) {
+  struct thread_state *state = arg;
+  grpc_completion_queue_pluck(state->cc, state->tag,
+                              gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+}
+
+static void test_too_many_plucks(void) {
+  grpc_event ev;
+  grpc_completion_queue *cc;
+  void *tags[GRPC_MAX_COMPLETION_QUEUE_PLUCKERS];
+  grpc_cq_completion completions[GPR_ARRAY_SIZE(tags)];
+  gpr_thd_id thread_ids[GPR_ARRAY_SIZE(tags)];
+  struct thread_state thread_states[GPR_ARRAY_SIZE(tags)];
+  gpr_thd_options thread_options = gpr_thd_options_default();
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  unsigned i, j;
+
+  LOG_TEST("test_too_many_plucks");
+
+  cc = grpc_completion_queue_create(NULL);
+  gpr_thd_options_set_joinable(&thread_options);
+
+  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]);
+    }
+    thread_states[i].cc = cc;
+    thread_states[i].tag = tags[i];
+    gpr_thd_new(thread_ids + i, pluck_one, thread_states + i, &thread_options);
+  }
+
+  /* wait until all other threads are plucking */
+  gpr_sleep_until(GRPC_TIMEOUT_MILLIS_TO_DEADLINE(100));
+
+  ev = grpc_completion_queue_pluck(cc, create_test_tag(),
+                                   gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+  GPR_ASSERT(ev.type == GRPC_QUEUE_TIMEOUT);
+
+  for (i = 0; i < GPR_ARRAY_SIZE(tags); i++) {
+    grpc_cq_begin_op(cc, tags[i]);
+    grpc_cq_end_op(&exec_ctx, cc, tags[i], 1, do_nothing_end_completion, NULL,
+                   &completions[i]);
+  }
+
+  for (i = 0; i < GPR_ARRAY_SIZE(tags); i++) {
+    gpr_thd_join(thread_ids[i]);
+  }
+
+  shutdown_and_destroy(cc);
+  grpc_exec_ctx_finish(&exec_ctx);
+}
+
 #define TEST_THREAD_EVENTS 10000
 
 typedef struct test_thread_options {
@@ -208,7 +279,7 @@ static void producer_thread(void *arg) {
 
   gpr_log(GPR_INFO, "producer %d phase 1", opt->id);
   for (i = 0; i < TEST_THREAD_EVENTS; i++) {
-    grpc_cq_begin_op(opt->cc);
+    grpc_cq_begin_op(opt->cc, (void *)(gpr_intptr)1);
   }
 
   gpr_log(GPR_INFO, "producer %d phase 1 done", opt->id);
@@ -343,6 +414,8 @@ int main(int argc, char **argv) {
   test_shutdown_then_next_with_timeout();
   test_cq_end_op();
   test_pluck();
+  test_pluck_after_shutdown();
+  test_too_many_plucks();
   test_threading(1, 1);
   test_threading(1, 10);
   test_threading(10, 1);
diff --git a/test/core/surface/init_test.c b/test/core/surface/init_test.c
new file mode 100644
index 0000000000..d4451e4567
--- /dev/null
+++ b/test/core/surface/init_test.c
@@ -0,0 +1,78 @@
+/*
+ *
+ * Copyright 2015, 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/util/test_config.h"
+
+static int g_flag;
+
+static void test(int rounds) {
+  int i;
+  for (i = 0; i < rounds; i++) {
+    grpc_init();
+  }
+  for (i = 0; i < rounds; i++) {
+    grpc_shutdown();
+  }
+}
+
+static void test_mixed(void) {
+  grpc_init();
+  grpc_init();
+  grpc_shutdown();
+  grpc_init();
+  grpc_shutdown();
+  grpc_shutdown();
+}
+
+static void plugin_init(void) { g_flag = 1; }
+static void plugin_destroy(void) { g_flag = 2; }
+
+static void test_plugin() {
+  grpc_register_plugin(plugin_init, plugin_destroy);
+  grpc_init();
+  GPR_ASSERT(g_flag == 1);
+  grpc_shutdown();
+  GPR_ASSERT(g_flag == 2);
+}
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  test(1);
+  test(2);
+  test(3);
+  test_mixed();
+  test_plugin();
+  return 0;
+}
diff --git a/test/core/surface/invalid_channel_args_test.c b/test/core/surface/invalid_channel_args_test.c
new file mode 100644
index 0000000000..1b1b8b8f92
--- /dev/null
+++ b/test/core/surface/invalid_channel_args_test.c
@@ -0,0 +1,186 @@
+/*
+ *
+ * Copyright 2015, 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/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
+#include "test/core/util/test_config.h"
+
+static char *g_last_log_error_message = NULL;
+static const char *g_file_name = "channel.c";
+
+static int ends_with(const char *src, const char *suffix) {
+  size_t src_len = strlen(src);
+  size_t suffix_len = strlen(suffix);
+  if (src_len < suffix_len) {
+    return 0;
+  }
+  return strcmp(src + src_len - suffix_len, suffix) == 0;
+}
+
+static void log_error_sink(gpr_log_func_args *args) {
+  if (args->severity == GPR_LOG_SEVERITY_ERROR &&
+      ends_with(args->file, g_file_name)) {
+    g_last_log_error_message = gpr_strdup(args->message);
+  }
+}
+
+static void verify_last_error(const char *message) {
+  if (message == NULL) {
+    GPR_ASSERT(g_last_log_error_message == NULL);
+    return;
+  }
+  GPR_ASSERT(strcmp(message, g_last_log_error_message) == 0);
+  gpr_free(g_last_log_error_message);
+  g_last_log_error_message = NULL;
+}
+
+static char *compose_error_string(const char *key, const char *message) {
+  char *ret;
+  gpr_asprintf(&ret, "%s%s", key, message);
+  return ret;
+}
+
+static void one_test(grpc_channel_args *args, char *expected_error_message) {
+  grpc_channel *chan =
+      grpc_insecure_channel_create("nonexistant:54321", args, NULL);
+  verify_last_error(expected_error_message);
+  gpr_free(expected_error_message);
+  grpc_channel_destroy(chan);
+}
+
+static void test_no_error_message(void) { one_test(NULL, NULL); }
+
+static void test_max_message_length_type(void) {
+  grpc_arg client_arg;
+  grpc_channel_args client_args;
+  char *expected_error_message;
+
+  client_arg.type = GRPC_ARG_STRING;
+  client_arg.key = GRPC_ARG_MAX_MESSAGE_LENGTH;
+  client_arg.value.string = NULL;
+
+  client_args.num_args = 1;
+  client_args.args = &client_arg;
+  expected_error_message = compose_error_string(
+      GRPC_ARG_MAX_MESSAGE_LENGTH, " ignored: it must be an integer");
+  one_test(&client_args, expected_error_message);
+}
+
+static void test_max_message_length_negative(void) {
+  grpc_arg client_arg;
+  grpc_channel_args client_args;
+  char *expected_error_message;
+
+  client_arg.type = GRPC_ARG_INTEGER;
+  client_arg.key = GRPC_ARG_MAX_MESSAGE_LENGTH;
+  client_arg.value.integer = -1;
+
+  client_args.num_args = 1;
+  client_args.args = &client_arg;
+  expected_error_message = compose_error_string(GRPC_ARG_MAX_MESSAGE_LENGTH,
+                                                " ignored: it must be >= 0");
+  one_test(&client_args, expected_error_message);
+}
+
+static void test_default_authority_type(void) {
+  grpc_arg client_arg;
+  grpc_channel_args client_args;
+  char *expected_error_message;
+
+  client_arg.type = GRPC_ARG_INTEGER;
+  client_arg.key = GRPC_ARG_DEFAULT_AUTHORITY;
+  client_arg.value.integer = 0;
+
+  client_args.num_args = 1;
+  client_args.args = &client_arg;
+  expected_error_message = compose_error_string(
+      GRPC_ARG_DEFAULT_AUTHORITY, " ignored: it must be a string");
+  one_test(&client_args, expected_error_message);
+}
+
+static void test_ssl_name_override_type(void) {
+  grpc_arg client_arg;
+  grpc_channel_args client_args;
+  char *expected_error_message;
+
+  client_arg.type = GRPC_ARG_INTEGER;
+  client_arg.key = GRPC_SSL_TARGET_NAME_OVERRIDE_ARG;
+  client_arg.value.integer = 0;
+
+  client_args.num_args = 1;
+  client_args.args = &client_arg;
+  expected_error_message = compose_error_string(
+      GRPC_SSL_TARGET_NAME_OVERRIDE_ARG, " ignored: it must be a string");
+  one_test(&client_args, expected_error_message);
+}
+
+static void test_ssl_name_override_failed(void) {
+  grpc_arg client_arg[2];
+  grpc_channel_args client_args;
+  char *expected_error_message;
+
+  client_arg[0].type = GRPC_ARG_STRING;
+  client_arg[0].key = GRPC_ARG_DEFAULT_AUTHORITY;
+  client_arg[0].value.string = "default";
+  client_arg[1].type = GRPC_ARG_STRING;
+  client_arg[1].key = GRPC_SSL_TARGET_NAME_OVERRIDE_ARG;
+  client_arg[1].value.string = "ssl";
+
+  client_args.num_args = 2;
+  client_args.args = client_arg;
+  expected_error_message =
+      compose_error_string(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG,
+                           " ignored: default host already set some other way");
+  one_test(&client_args, expected_error_message);
+}
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  grpc_init();
+  gpr_set_log_function(log_error_sink);
+
+  test_no_error_message();
+  test_max_message_length_type();
+  test_max_message_length_negative();
+  test_default_authority_type();
+  test_ssl_name_override_type();
+  test_ssl_name_override_failed();
+
+  grpc_shutdown();
+
+  return 0;
+}
diff --git a/test/core/surface/lame_client_test.c b/test/core/surface/lame_client_test.c
index 0d29bea555..35b0212fcf 100644
--- a/test/core/surface/lame_client_test.c
+++ b/test/core/surface/lame_client_test.c
@@ -31,15 +31,52 @@
  *
  */
 
-#include <grpc/grpc.h>
+#include <string.h>
 
-#include "test/core/end2end/cq_verifier.h"
-#include "test/core/util/test_config.h"
+#include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include "src/core/channel/channel_stack.h"
+#include "src/core/iomgr/closure.h"
+#include "src/core/surface/channel.h"
+#include "src/core/transport/transport.h"
+#include "test/core/end2end/cq_verifier.h"
+#include "test/core/util/test_config.h"
+
+grpc_closure transport_op_cb;
 
 static void *tag(gpr_intptr x) { return (void *)x; }
 
+void verify_connectivity(grpc_exec_ctx *exec_ctx, void *arg, int success) {
+  grpc_transport_op *op = arg;
+  GPR_ASSERT(GRPC_CHANNEL_FATAL_FAILURE == *op->connectivity_state);
+  GPR_ASSERT(success);
+}
+
+void do_nothing(grpc_exec_ctx *exec_ctx, void *arg, int success) {}
+
+void test_transport_op(grpc_channel *channel) {
+  grpc_transport_op op;
+  grpc_channel_element *elem;
+  grpc_connectivity_state state = GRPC_CHANNEL_IDLE;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+
+  memset(&op, 0, sizeof(op));
+  grpc_closure_init(&transport_op_cb, verify_connectivity, &op);
+
+  op.on_connectivity_state_change = &transport_op_cb;
+  op.connectivity_state = &state;
+  elem = grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0);
+  elem->filter->start_transport_op(&exec_ctx, elem, &op);
+  grpc_exec_ctx_finish(&exec_ctx);
+
+  memset(&op, 0, sizeof(op));
+  grpc_closure_init(&transport_op_cb, do_nothing, NULL);
+  op.on_consumed = &transport_op_cb;
+  elem->filter->start_transport_op(&exec_ctx, elem, &op);
+  grpc_exec_ctx_finish(&exec_ctx);
+}
+
 int main(int argc, char **argv) {
   grpc_channel *chan;
   grpc_call *call;
@@ -47,21 +84,31 @@ int main(int argc, char **argv) {
   cq_verifier *cqv;
   grpc_op ops[6];
   grpc_op *op;
+  grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;
   grpc_status_code status;
   grpc_call_error error;
   char *details = NULL;
   size_t details_capacity = 0;
+  char *peer;
 
   grpc_test_init(argc, argv);
   grpc_init();
 
+  grpc_metadata_array_init(&initial_metadata_recv);
   grpc_metadata_array_init(&trailing_metadata_recv);
 
   chan = grpc_lame_client_channel_create(
       "lampoon:national", GRPC_STATUS_UNKNOWN, "Rpc sent on a lame channel.");
   GPR_ASSERT(chan);
+
+  test_transport_op(chan);
+
+  GPR_ASSERT(GRPC_CHANNEL_FATAL_FAILURE ==
+             grpc_channel_check_connectivity_state(chan, 0));
+
   cq = grpc_completion_queue_create(NULL);
+
   call = grpc_channel_create_call(chan, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
                                   "/Foo", "anywhere",
                                   GRPC_TIMEOUT_SECONDS_TO_DEADLINE(100), NULL);
@@ -74,6 +121,19 @@ int main(int argc, char **argv) {
   op->flags = 0;
   op->reserved = NULL;
   op++;
+  op->op = GRPC_OP_RECV_INITIAL_METADATA;
+  op->data.recv_initial_metadata = &initial_metadata_recv;
+  op->flags = 0;
+  op->reserved = NULL;
+  op++;
+  error = grpc_call_start_batch(call, ops, (size_t)(op - ops), tag(1), NULL);
+  GPR_ASSERT(GRPC_CALL_OK == error);
+
+  /* the call should immediately fail */
+  cq_expect_completion(cqv, tag(1), 0);
+  cq_verify(cqv);
+
+  op = ops;
   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
@@ -82,18 +142,23 @@ int main(int argc, char **argv) {
   op->flags = 0;
   op->reserved = NULL;
   op++;
-  error = grpc_call_start_batch(call, ops, (size_t)(op - ops), tag(1), NULL);
+  error = grpc_call_start_batch(call, ops, (size_t)(op - ops), tag(2), NULL);
   GPR_ASSERT(GRPC_CALL_OK == error);
 
   /* the call should immediately fail */
-  cq_expect_completion(cqv, tag(1), 1);
+  cq_expect_completion(cqv, tag(2), 1);
   cq_verify(cqv);
 
+  peer = grpc_call_get_peer(call);
+  GPR_ASSERT(strcmp(peer, "lampoon:national") == 0);
+  gpr_free(peer);
+
   grpc_call_destroy(call);
   grpc_channel_destroy(chan);
   cq_verifier_destroy(cqv);
   grpc_completion_queue_destroy(cq);
 
+  grpc_metadata_array_destroy(&initial_metadata_recv);
   grpc_metadata_array_destroy(&trailing_metadata_recv);
   gpr_free(details);
 
diff --git a/test/core/surface/secure_channel_create_test.c b/test/core/surface/secure_channel_create_test.c
new file mode 100644
index 0000000000..f3e5fefaf0
--- /dev/null
+++ b/test/core/surface/secure_channel_create_test.c
@@ -0,0 +1,95 @@
+/*
+ *
+ * Copyright 2015, 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/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/support/log.h>
+#include "src/core/client_config/resolver_registry.h"
+#include "src/core/security/credentials.h"
+#include "src/core/security/security_connector.h"
+#include "src/core/surface/channel.h"
+#include "test/core/util/test_config.h"
+
+void test_unknown_scheme_target(void) {
+  grpc_channel *chan;
+  grpc_channel_credentials *creds;
+  grpc_resolver_registry_shutdown();
+  grpc_resolver_registry_init("");
+
+  creds = grpc_fake_transport_security_credentials_create();
+  chan = grpc_secure_channel_create(creds, "blah://blah", NULL, NULL);
+  GPR_ASSERT(chan == NULL);
+  grpc_channel_credentials_unref(creds);
+}
+
+void test_security_connector_already_in_arg(void) {
+  grpc_channel *chan;
+  grpc_channel_element *elem;
+  grpc_channel_args args;
+  grpc_arg arg;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+
+  arg.type = GRPC_ARG_POINTER;
+  arg.value.pointer.p = NULL;
+  arg.key = GRPC_SECURITY_CONNECTOR_ARG;
+  args.num_args = 1;
+  args.args = &arg;
+  chan = grpc_secure_channel_create(NULL, NULL, &args, NULL);
+  elem = grpc_channel_stack_element(grpc_channel_get_channel_stack(chan), 0);
+  GPR_ASSERT(0 == strcmp(elem->filter->name, "lame-client"));
+  GRPC_CHANNEL_INTERNAL_UNREF(&exec_ctx, chan, "test");
+  grpc_exec_ctx_finish(&exec_ctx);
+}
+
+void test_null_creds(void) {
+  grpc_channel *chan;
+  grpc_channel_element *elem;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  chan = grpc_secure_channel_create(NULL, NULL, NULL, NULL);
+  elem = grpc_channel_stack_element(grpc_channel_get_channel_stack(chan), 0);
+  GPR_ASSERT(0 == strcmp(elem->filter->name, "lame-client"));
+  GRPC_CHANNEL_INTERNAL_UNREF(&exec_ctx, chan, "test");
+  grpc_exec_ctx_finish(&exec_ctx);
+}
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  grpc_init();
+  test_security_connector_already_in_arg();
+  test_null_creds();
+  test_unknown_scheme_target();
+  grpc_shutdown();
+  return 0;
+}
diff --git a/test/core/surface/multi_init_test.c b/test/core/surface/server_chttp2_test.c
index 99b7a52ff9..ec7df6f0e3 100644
--- a/test/core/surface/multi_init_test.c
+++ b/test/core/surface/server_chttp2_test.c
@@ -32,32 +32,18 @@
  */
 
 #include <grpc/grpc.h>
+#include <grpc/support/log.h>
 #include "test/core/util/test_config.h"
 
-static void test(int rounds) {
-  int i;
-  for (i = 0; i < rounds; i++) {
-    grpc_init();
-  }
-  for (i = 0; i < rounds; i++) {
-    grpc_shutdown();
-  }
-}
-
-static void test_mixed() {
-  grpc_init();
-  grpc_init();
-  grpc_shutdown();
-  grpc_init();
-  grpc_shutdown();
-  grpc_shutdown();
+void test_unparsable_target(void) {
+  int port = grpc_server_add_insecure_http2_port(NULL, "[");
+  GPR_ASSERT(port == 0);
 }
 
 int main(int argc, char **argv) {
   grpc_test_init(argc, argv);
-  test(1);
-  test(2);
-  test(3);
-  test_mixed();
+  grpc_init();
+  test_unparsable_target();
+  grpc_shutdown();
   return 0;
 }
diff --git a/test/core/surface/server_test.c b/test/core/surface/server_test.c
new file mode 100644
index 0000000000..1d5211d225
--- /dev/null
+++ b/test/core/surface/server_test.c
@@ -0,0 +1,93 @@
+/*
+ *
+ * Copyright 2015, 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/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
+#include "test/core/util/port.h"
+#include "test/core/util/test_config.h"
+
+void test_register_method_fail(void) {
+  grpc_server *server = grpc_server_create(NULL, NULL);
+  void *method;
+  void *method_old;
+  method = grpc_server_register_method(server, NULL, NULL);
+  GPR_ASSERT(method == NULL);
+  method_old = grpc_server_register_method(server, "m", "h");
+  GPR_ASSERT(method_old != NULL);
+  method = grpc_server_register_method(server, "m", "h");
+  GPR_ASSERT(method == NULL);
+  grpc_server_destroy(server);
+}
+
+void test_request_call_on_no_server_cq(void) {
+  grpc_completion_queue *cc = grpc_completion_queue_create(NULL);
+  GPR_ASSERT(GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE ==
+             grpc_server_request_call(NULL, NULL, NULL, NULL, cc, cc, NULL));
+  GPR_ASSERT(GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE ==
+             grpc_server_request_registered_call(NULL, NULL, NULL, NULL, NULL,
+                                                 NULL, cc, cc, NULL));
+  grpc_completion_queue_destroy(cc);
+}
+
+void test_bind_server_twice(void) {
+  char *addr;
+  grpc_server *server1 = grpc_server_create(NULL, NULL);
+  grpc_server *server2 = grpc_server_create(NULL, NULL);
+  grpc_completion_queue *cq = grpc_completion_queue_create(NULL);
+  int port = grpc_pick_unused_port_or_die();
+  gpr_asprintf(&addr, "[::]:%d", port);
+  grpc_server_register_completion_queue(server1, cq, NULL);
+  grpc_server_register_completion_queue(server2, cq, NULL);
+  GPR_ASSERT(port == grpc_server_add_insecure_http2_port(server1, addr));
+  GPR_ASSERT(0 == grpc_server_add_insecure_http2_port(server2, addr));
+  grpc_server_shutdown_and_notify(server1, cq, NULL);
+  grpc_server_shutdown_and_notify(server2, cq, NULL);
+  grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_MONOTONIC), NULL);
+  grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_MONOTONIC), NULL);
+  grpc_server_destroy(server1);
+  grpc_server_destroy(server2);
+  grpc_completion_queue_destroy(cq);
+  gpr_free(addr);
+}
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  grpc_init();
+  test_register_method_fail();
+  test_request_call_on_no_server_cq();
+  test_bind_server_twice();
+  grpc_shutdown();
+  return 0;
+}