Merge branch 'master' into execctx

6 files changed, 288 insertions, 153 deletions

diff --git a/test/core/end2end/tests/simple_request.cc b/test/core/end2end/tests/simple_request.cc
index ec7425aa09..7eb7467981 100644
--- a/test/core/end2end/tests/simple_request.cc
+++ b/test/core/end2end/tests/simple_request.cc
@@ -99,6 +99,7 @@ static void simple_request_body(grpc_end2end_test_config config,
   grpc_metadata_array request_metadata_recv;
   grpc_call_details call_details;
   grpc_status_code status;
+  const char* error_string;
   grpc_call_error error;
   grpc_slice details;
   int was_cancelled = 2;
@@ -148,6 +149,7 @@ static void simple_request_body(grpc_end2end_test_config config,
   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
   op->data.recv_status_on_client.status = &status;
   op->data.recv_status_on_client.status_details = &details;
+  op->data.recv_status_on_client.error_string = &error_string;
   op->flags = 0;
   op->reserved = nullptr;
   op++;
@@ -199,6 +201,15 @@ static void simple_request_body(grpc_end2end_test_config config,
 
   GPR_ASSERT(status == GRPC_STATUS_UNIMPLEMENTED);
   GPR_ASSERT(0 == grpc_slice_str_cmp(details, "xyz"));
+  // the following sanity check makes sure that the requested error string is
+  // correctly populated by the core. It looks for certain substrings that are
+  // not likely to change much. Some parts of the error, like time created,
+  // obviously are not checked.
+  GPR_ASSERT(nullptr != strstr(error_string, "xyz"));
+  GPR_ASSERT(nullptr != strstr(error_string, "description"));
+  GPR_ASSERT(nullptr != strstr(error_string, "Error received from peer"));
+  GPR_ASSERT(nullptr != strstr(error_string, "grpc_message"));
+  GPR_ASSERT(nullptr != strstr(error_string, "grpc_status"));
   GPR_ASSERT(0 == grpc_slice_str_cmp(call_details.method, "/foo"));
   validate_host_override_string("foo.test.google.fr:1234", call_details.host,
                                 config);
@@ -206,6 +217,7 @@ static void simple_request_body(grpc_end2end_test_config config,
   GPR_ASSERT(was_cancelled == 1);
 
   grpc_slice_unref(details);
+  gpr_free((void*)error_string);
   grpc_metadata_array_destroy(&initial_metadata_recv);
   grpc_metadata_array_destroy(&trailing_metadata_recv);
   grpc_metadata_array_destroy(&request_metadata_recv);
diff --git a/test/core/support/BUILD b/test/core/support/BUILD
index 69512cd9a9..32b64d4b8e 100644
--- a/test/core/support/BUILD
+++ b/test/core/support/BUILD
@@ -119,16 +119,6 @@ grpc_cc_test(
 )
 
 grpc_cc_test(
-    name = "stack_lockfree_test",
-    srcs = ["stack_lockfree_test.cc"],
-    language = "C++",
-    deps = [
-        "//:gpr",
-        "//test/core/util:gpr_test_util",
-    ],
-)
-
-grpc_cc_test(
     name = "string_test",
     srcs = ["string_test.cc"],
     language = "C++",
@@ -211,24 +201,51 @@ grpc_cc_test(
 grpc_cc_test(
     name = "memory_test",
     srcs = ["memory_test.cc"],
+    external_deps = [
+        "gtest",
+    ],
     language = "C++",
     deps = [
         "//:grpc",
         "//test/core/util:gpr_test_util",
     ],
-    external_deps = [
-        "gtest",
-    ],
 )
 
 grpc_cc_test(
     name = "vector_test",
     srcs = ["vector_test.cc"],
+    external_deps = [
+        "gtest",
+    ],
     language = "C++",
     deps = [
         "//:grpc",
         "//test/core/util:gpr_test_util",
     ],
+)
+
+grpc_cc_test(
+    name = "ref_counted_test",
+    srcs = ["ref_counted_test.cc"],
+    language = "C++",
+    deps = [
+        "//:ref_counted",
+        "//test/core/util:gpr_test_util",
+    ],
+    external_deps = [
+        "gtest",
+    ],
+)
+
+grpc_cc_test(
+    name = "ref_counted_ptr_test",
+    srcs = ["ref_counted_ptr_test.cc"],
+    language = "C++",
+    deps = [
+        "//:ref_counted",
+        "//:ref_counted_ptr",
+        "//test/core/util:gpr_test_util",
+    ],
     external_deps = [
         "gtest",
     ],
diff --git a/test/core/support/ref_counted_ptr_test.cc b/test/core/support/ref_counted_ptr_test.cc
new file mode 100644
index 0000000000..1830edc4e5
--- /dev/null
+++ b/test/core/support/ref_counted_ptr_test.cc
@@ -0,0 +1,172 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "src/core/lib/support/ref_counted_ptr.h"
+
+#include <gtest/gtest.h>
+
+#include <grpc/support/log.h>
+
+#include "src/core/lib/support/memory.h"
+#include "src/core/lib/support/ref_counted.h"
+#include "test/core/util/test_config.h"
+
+namespace grpc_core {
+namespace testing {
+namespace {
+
+class Foo : public RefCounted {
+ public:
+  Foo() : value_(0) {}
+
+  explicit Foo(int value) : value_(value) {}
+
+  int value() const { return value_; }
+
+ private:
+  int value_;
+};
+
+TEST(RefCountedPtr, DefaultConstructor) { RefCountedPtr<Foo> foo; }
+
+TEST(RefCountedPtr, ExplicitConstructorEmpty) {
+  RefCountedPtr<Foo> foo(nullptr);
+}
+
+TEST(RefCountedPtr, ExplicitConstructor) { RefCountedPtr<Foo> foo(New<Foo>()); }
+
+TEST(RefCountedPtr, MoveConstructor) {
+  RefCountedPtr<Foo> foo(New<Foo>());
+  RefCountedPtr<Foo> foo2(std::move(foo));
+  EXPECT_EQ(nullptr, foo.get());
+  EXPECT_NE(nullptr, foo2.get());
+}
+
+TEST(RefCountedPtr, MoveAssignment) {
+  RefCountedPtr<Foo> foo(New<Foo>());
+  RefCountedPtr<Foo> foo2 = std::move(foo);
+  EXPECT_EQ(nullptr, foo.get());
+  EXPECT_NE(nullptr, foo2.get());
+}
+
+TEST(RefCountedPtr, CopyConstructor) {
+  RefCountedPtr<Foo> foo(New<Foo>());
+  RefCountedPtr<Foo> foo2(foo);
+  EXPECT_NE(nullptr, foo.get());
+  EXPECT_EQ(foo.get(), foo2.get());
+}
+
+TEST(RefCountedPtr, CopyAssignment) {
+  RefCountedPtr<Foo> foo(New<Foo>());
+  RefCountedPtr<Foo> foo2 = foo;
+  EXPECT_NE(nullptr, foo.get());
+  EXPECT_EQ(foo.get(), foo2.get());
+}
+
+TEST(RefCountedPtr, CopyAssignmentWhenEmpty) {
+  RefCountedPtr<Foo> foo;
+  RefCountedPtr<Foo> foo2;
+  foo2 = foo;
+  EXPECT_EQ(nullptr, foo.get());
+  EXPECT_EQ(nullptr, foo2.get());
+}
+
+TEST(RefCountedPtr, CopyAssignmentToSelf) {
+  RefCountedPtr<Foo> foo(New<Foo>());
+  foo = foo;
+}
+
+TEST(RefCountedPtr, EnclosedScope) {
+  RefCountedPtr<Foo> foo(New<Foo>());
+  {
+    RefCountedPtr<Foo> foo2(std::move(foo));
+    EXPECT_EQ(nullptr, foo.get());
+    EXPECT_NE(nullptr, foo2.get());
+  }
+  EXPECT_EQ(nullptr, foo.get());
+}
+
+TEST(RefCountedPtr, ResetFromNullToNonNull) {
+  RefCountedPtr<Foo> foo;
+  EXPECT_EQ(nullptr, foo.get());
+  foo.reset(New<Foo>());
+  EXPECT_NE(nullptr, foo.get());
+}
+
+TEST(RefCountedPtr, ResetFromNonNullToNonNull) {
+  RefCountedPtr<Foo> foo(New<Foo>());
+  EXPECT_NE(nullptr, foo.get());
+  Foo* original = foo.get();
+  foo.reset(New<Foo>());
+  EXPECT_NE(nullptr, foo.get());
+  EXPECT_NE(original, foo.get());
+}
+
+TEST(RefCountedPtr, ResetFromNonNullToNull) {
+  RefCountedPtr<Foo> foo(New<Foo>());
+  EXPECT_NE(nullptr, foo.get());
+  foo.reset();
+  EXPECT_EQ(nullptr, foo.get());
+}
+
+TEST(RefCountedPtr, ResetFromNullToNull) {
+  RefCountedPtr<Foo> foo;
+  EXPECT_EQ(nullptr, foo.get());
+  foo.reset(nullptr);
+  EXPECT_EQ(nullptr, foo.get());
+}
+
+TEST(RefCountedPtr, DerefernceOperators) {
+  RefCountedPtr<Foo> foo(New<Foo>());
+  foo->value();
+  Foo& foo_ref = *foo;
+  foo_ref.value();
+}
+
+TEST(MakeRefCounted, NoArgs) {
+  RefCountedPtr<Foo> foo = MakeRefCounted<Foo>();
+  EXPECT_EQ(0, foo->value());
+}
+
+TEST(MakeRefCounted, Args) {
+  RefCountedPtr<Foo> foo = MakeRefCounted<Foo>(3);
+  EXPECT_EQ(3, foo->value());
+}
+
+TraceFlag foo_tracer(true, "foo");
+
+class FooWithTracing : public RefCountedWithTracing {
+ public:
+  FooWithTracing() : RefCountedWithTracing(&foo_tracer) {}
+};
+
+TEST(RefCountedPtr, RefCountedWithTracing) {
+  RefCountedPtr<FooWithTracing> foo(New<FooWithTracing>());
+  foo->Ref(DEBUG_LOCATION, "foo");
+  foo->Unref(DEBUG_LOCATION, "foo");
+}
+
+}  // namespace
+}  // namespace testing
+}  // namespace grpc_core
+
+int main(int argc, char** argv) {
+  grpc_test_init(argc, argv);
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/test/core/support/ref_counted_test.cc b/test/core/support/ref_counted_test.cc
new file mode 100644
index 0000000000..be9b6ff7c2
--- /dev/null
+++ b/test/core/support/ref_counted_test.cc
@@ -0,0 +1,72 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "src/core/lib/support/ref_counted.h"
+
+#include <gtest/gtest.h>
+
+#include "src/core/lib/support/memory.h"
+#include "test/core/util/test_config.h"
+
+namespace grpc_core {
+namespace testing {
+namespace {
+
+class Foo : public RefCounted {
+ public:
+  Foo() {}
+};
+
+TEST(RefCounted, Basic) {
+  Foo* foo = New<Foo>();
+  foo->Unref();
+}
+
+TEST(RefCounted, ExtraRef) {
+  Foo* foo = New<Foo>();
+  foo->Ref();
+  foo->Unref();
+  foo->Unref();
+}
+
+TraceFlag foo_tracer(true, "foo");
+
+class FooWithTracing : public RefCountedWithTracing {
+ public:
+  FooWithTracing() : RefCountedWithTracing(&foo_tracer) {}
+};
+
+TEST(RefCountedWithTracing, Basic) {
+  FooWithTracing* foo = New<FooWithTracing>();
+  foo->Ref(DEBUG_LOCATION, "extra_ref");
+  foo->Unref(DEBUG_LOCATION, "extra_ref");
+  // Can use the no-argument methods, too.
+  foo->Ref();
+  foo->Unref();
+  foo->Unref(DEBUG_LOCATION, "original_ref");
+}
+
+}  // namespace
+}  // namespace testing
+}  // namespace grpc_core
+
+int main(int argc, char** argv) {
+  grpc_test_init(argc, argv);
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/test/core/support/stack_lockfree_test.cc b/test/core/support/stack_lockfree_test.cc
deleted file mode 100644
index e6d0c9b795..0000000000
--- a/test/core/support/stack_lockfree_test.cc
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include "src/core/lib/support/stack_lockfree.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 "test/core/util/test_config.h"
-
-/* max stack size supported */
-#define MAX_STACK_SIZE 65534
-
-#define MAX_THREADS 32
-
-static void test_serial_sized(size_t size) {
-  gpr_stack_lockfree* stack = gpr_stack_lockfree_create(size);
-  size_t i;
-  size_t j;
-
-  /* First try popping empty */
-  GPR_ASSERT(gpr_stack_lockfree_pop(stack) == -1);
-
-  /* Now add one item and check it */
-  gpr_stack_lockfree_push(stack, 3);
-  GPR_ASSERT(gpr_stack_lockfree_pop(stack) == 3);
-  GPR_ASSERT(gpr_stack_lockfree_pop(stack) == -1);
-
-  /* Now add repeatedly more items and check them */
-  for (i = 1; i < size; i *= 2) {
-    for (j = 0; j <= i; j++) {
-      GPR_ASSERT(gpr_stack_lockfree_push(stack, (int)j) == (j == 0));
-    }
-    for (j = 0; j <= i; j++) {
-      GPR_ASSERT(gpr_stack_lockfree_pop(stack) == (int)(i - j));
-    }
-    GPR_ASSERT(gpr_stack_lockfree_pop(stack) == -1);
-  }
-
-  gpr_stack_lockfree_destroy(stack);
-}
-
-static void test_serial() {
-  size_t i;
-  for (i = 128; i < MAX_STACK_SIZE; i *= 2) {
-    test_serial_sized(i);
-  }
-  test_serial_sized(MAX_STACK_SIZE);
-}
-
-struct test_arg {
-  gpr_stack_lockfree* stack;
-  int stack_size;
-  int nthreads;
-  int rank;
-  int sum;
-};
-
-static void test_mt_body(void* v) {
-  struct test_arg* arg = (struct test_arg*)v;
-  int lo, hi;
-  int i;
-  int res;
-  lo = arg->rank * arg->stack_size / arg->nthreads;
-  hi = (arg->rank + 1) * arg->stack_size / arg->nthreads;
-  for (i = lo; i < hi; i++) {
-    gpr_stack_lockfree_push(arg->stack, i);
-    if ((res = gpr_stack_lockfree_pop(arg->stack)) != -1) {
-      arg->sum += res;
-    }
-  }
-  while ((res = gpr_stack_lockfree_pop(arg->stack)) != -1) {
-    arg->sum += res;
-  }
-}
-
-static void test_mt_sized(size_t size, int nth) {
-  gpr_stack_lockfree* stack;
-  struct test_arg args[MAX_THREADS];
-  gpr_thd_id thds[MAX_THREADS];
-  int sum;
-  int i;
-  gpr_thd_options options = gpr_thd_options_default();
-
-  stack = gpr_stack_lockfree_create(size);
-  for (i = 0; i < nth; i++) {
-    args[i].stack = stack;
-    args[i].stack_size = (int)size;
-    args[i].nthreads = nth;
-    args[i].rank = i;
-    args[i].sum = 0;
-  }
-  gpr_thd_options_set_joinable(&options);
-  for (i = 0; i < nth; i++) {
-    GPR_ASSERT(gpr_thd_new(&thds[i], test_mt_body, &args[i], &options));
-  }
-  sum = 0;
-  for (i = 0; i < nth; i++) {
-    gpr_thd_join(thds[i]);
-    sum = sum + args[i].sum;
-  }
-  GPR_ASSERT((unsigned)sum == ((unsigned)size * (size - 1)) / 2);
-  gpr_stack_lockfree_destroy(stack);
-}
-
-static void test_mt() {
-  size_t size;
-  int nth;
-  for (nth = 1; nth < MAX_THREADS; nth++) {
-    for (size = 128; size < MAX_STACK_SIZE; size *= 2) {
-      test_mt_sized(size, nth);
-    }
-    test_mt_sized(MAX_STACK_SIZE, nth);
-  }
-}
-
-int main(int argc, char** argv) {
-  grpc_test_init(argc, argv);
-  test_serial();
-  test_mt();
-  return 0;
-}
diff --git a/test/core/surface/public_headers_must_be_c89.c b/test/core/surface/public_headers_must_be_c89.c
index b5a83c8eed..33dc70a685 100644
--- a/test/core/surface/public_headers_must_be_c89.c
+++ b/test/core/surface/public_headers_must_be_c89.c
@@ -20,6 +20,7 @@
 #include <grpc/byte_buffer_reader.h>
 #include <grpc/census.h>
 #include <grpc/compression.h>
+#include <grpc/fork.h>
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
 #include <grpc/grpc_security_constants.h>
@@ -29,6 +30,7 @@
 #include <grpc/impl/codegen/compression_types.h>
 #include <grpc/impl/codegen/connectivity_state.h>
 #include <grpc/impl/codegen/exec_ctx_fwd.h>
+#include <grpc/impl/codegen/fork.h>
 #include <grpc/impl/codegen/gpr_slice.h>
 #include <grpc/impl/codegen/gpr_types.h>
 #include <grpc/impl/codegen/grpc_types.h>