merge with head

4 files changed, 222 insertions, 1 deletions

diff --git a/test/core/bad_client/tests/simple_request.c b/test/core/bad_client/tests/simple_request.c
index b6c3b65ac3..5cddafc0b5 100644
--- a/test/core/bad_client/tests/simple_request.c
+++ b/test/core/bad_client/tests/simple_request.c
@@ -51,10 +51,27 @@
   "\x10\x0c"                                                               \
   "content-type\x10"                                                       \
   "application/grpc"                                                       \
-  "\x10\x14grpc-accept-encoding\x15identity,deflate,gzip"                  \
+  "\x10\x14grpc-accept-encoding\x15""deflate,identity,gzip"                \
   "\x10\x02te\x08trailers"                                                 \
   "\x10\x0auser-agent\"bad-client grpc-c/0.12.0.0 (linux)"
 
+#define PFX_STR_UNUSUAL                                                    \
+  "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"                                       \
+  "\x00\x00\x00\x04\x00\x00\x00\x00\x00" /* settings frame */              \
+  "\x00\x00\xf4\x01\x04\x00\x00\x00\x01" /* headers: generated from        \
+                                            simple_request_unusual.headers \
+                                            in this directory */           \
+  "\x10\x05:path\x08/foo/bar"                                              \
+  "\x10\x07:scheme\x04http"                                                \
+  "\x10\x07:method\x04POST"                                                \
+  "\x10\x04host\x09localhost"                                              \
+  "\x10\x0c""content-type\x1e""application/grpc+this-is-valid"             \
+  "\x10\x14grpc-accept-encoding\x15identity,deflate,gzip"                  \
+  "\x10\x02te\x08trailers"                                                 \
+  "\x10\x0auser-agent\"bad-client grpc-c/0.12.0.0 (linux)"                 \
+  "\x10\x0cgrpc-timeout\x03""10S"                                          \
+  "\x10\x0cgrpc-timeout\x02""5S"
+
 static void *tag(gpr_intptr t) { return (void *)t; }
 
 static void verifier(grpc_server *server, grpc_completion_queue *cq) {
@@ -87,6 +104,7 @@ int main(int argc, char **argv) {
 
   /* basic request: check that things are working */
   GRPC_RUN_BAD_CLIENT_TEST(verifier, PFX_STR, 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, PFX_STR_UNUSUAL, 0);
 
   /* push an illegal data frame */
   GRPC_RUN_BAD_CLIENT_TEST(verifier, PFX_STR
diff --git a/test/core/bad_client/tests/simple_request_unusual.headers b/test/core/bad_client/tests/simple_request_unusual.headers
new file mode 100644
index 0000000000..f36e1dfc9f
--- /dev/null
+++ b/test/core/bad_client/tests/simple_request_unusual.headers
@@ -0,0 +1,13 @@
+# headers used in simple_request.c
+# use tools/codegen/core/gen_header_frame.py to generate the binary strings
+# contained in the source code
+:path: /foo/bar
+:scheme: http
+:method: POST
+host: localhost
+content-type: application/grpc+this-is-valid
+grpc-accept-encoding: deflate,identity,gzip
+te: trailers
+user-agent: bad-client grpc-c/0.12.0.0 (linux)
+grpc-timeout: 10S
+grpc-timeout: 5S
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/cpp/end2end/generic_end2end_test.cc b/test/cpp/end2end/generic_end2end_test.cc
index 082119d6d5..6ecf7eb2fe 100644
--- a/test/cpp/end2end/generic_end2end_test.cc
+++ b/test/cpp/end2end/generic_end2end_test.cc
@@ -102,6 +102,10 @@ class GenericEnd2endTest : public ::testing::Test {
     builder.AddListeningPort(server_address_.str(),
                              InsecureServerCredentials());
     builder.RegisterAsyncGenericService(&generic_service_);
+    // Include a second call to RegisterAsyncGenericService to make sure that
+    // we get an error in the log, since it is not allowed to have 2 async
+    // generic services
+    builder.RegisterAsyncGenericService(&generic_service_);
     srv_cq_ = builder.AddCompletionQueue();
     server_ = builder.BuildAndStart();
   }