diff options
Diffstat (limited to 'test')
-rw-r--r-- | test/cpp/end2end/async_end2end_test.cc | 16 | ||||
-rw-r--r-- | test/cpp/end2end/client_crash_test.cc | 14 | ||||
-rw-r--r-- | test/cpp/end2end/client_crash_test_server.cc | 5 | ||||
-rw-r--r-- | test/cpp/end2end/end2end_test.cc | 30 | ||||
-rw-r--r-- | test/cpp/end2end/generic_end2end_test.cc | 17 | ||||
-rw-r--r-- | test/cpp/end2end/hybrid_end2end_test.cc | 178 | ||||
-rw-r--r-- | test/cpp/end2end/mixed_handlers_end2end_test.cc | 747 | ||||
-rw-r--r-- | test/cpp/end2end/mock_test.cc | 26 | ||||
-rw-r--r-- | test/cpp/end2end/server_crash_test.cc | 13 | ||||
-rw-r--r-- | test/cpp/end2end/server_crash_test_client.cc | 4 | ||||
-rw-r--r-- | test/cpp/end2end/shutdown_test.cc | 14 | ||||
-rw-r--r-- | test/cpp/end2end/streaming_throughput_test.cc | 12 | ||||
-rw-r--r-- | test/cpp/end2end/thread_stress_test.cc | 20 | ||||
-rw-r--r-- | test/cpp/end2end/zookeeper_test.cc | 15 | ||||
-rw-r--r-- | test/cpp/util/cli_call.cc | 8 | ||||
-rw-r--r-- | test/cpp/util/cli_call_test.cc | 8 |
16 files changed, 1028 insertions, 99 deletions
diff --git a/test/cpp/end2end/async_end2end_test.cc b/test/cpp/end2end/async_end2end_test.cc index 320a064592..0616cc07ee 100644 --- a/test/cpp/end2end/async_end2end_test.cc +++ b/test/cpp/end2end/async_end2end_test.cc @@ -33,21 +33,21 @@ #include <memory> -#include <grpc/grpc.h> -#include <grpc/support/thd.h> -#include <grpc/support/time.h> #include <grpc++/channel.h> #include <grpc++/client_context.h> #include <grpc++/create_channel.h> #include <grpc++/server.h> #include <grpc++/server_builder.h> #include <grpc++/server_context.h> +#include <grpc/grpc.h> +#include <grpc/support/thd.h> +#include <grpc/support/time.h> #include <gtest/gtest.h> -#include "test/core/util/port.h" -#include "test/core/util/test_config.h" #include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h" #include "src/proto/grpc/testing/echo.grpc.pb.h" +#include "test/core/util/port.h" +#include "test/core/util/test_config.h" #include "test/cpp/util/string_ref_helper.h" #ifdef GPR_POSIX_SOCKET @@ -201,7 +201,7 @@ class AsyncEnd2endTest : public ::testing::TestWithParam<bool> { void ResetStub() { std::shared_ptr<Channel> channel = CreateChannel(server_address_.str(), InsecureChannelCredentials()); - stub_ = grpc::testing::TestService::NewStub(channel); + stub_ = grpc::testing::EchoTestService::NewStub(channel); } void SendRpc(int num_rpcs) { @@ -239,9 +239,9 @@ class AsyncEnd2endTest : public ::testing::TestWithParam<bool> { } std::unique_ptr<ServerCompletionQueue> cq_; - std::unique_ptr<grpc::testing::TestService::Stub> stub_; + std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_; std::unique_ptr<Server> server_; - grpc::testing::TestService::AsyncService service_; + grpc::testing::EchoTestService::AsyncService service_; std::ostringstream server_address_; }; diff --git a/test/cpp/end2end/client_crash_test.cc b/test/cpp/end2end/client_crash_test.cc index 68c63b2f93..c01f40dbc2 100644 --- a/test/cpp/end2end/client_crash_test.cc +++ b/test/cpp/end2end/client_crash_test.cc @@ -31,21 +31,21 @@ * */ -#include <grpc/grpc.h> -#include <grpc/support/thd.h> -#include <grpc/support/time.h> #include <grpc++/channel.h> #include <grpc++/client_context.h> #include <grpc++/create_channel.h> #include <grpc++/server.h> #include <grpc++/server_builder.h> #include <grpc++/server_context.h> +#include <grpc/grpc.h> +#include <grpc/support/thd.h> +#include <grpc/support/time.h> #include <gtest/gtest.h> -#include "test/core/util/port.h" -#include "test/core/util/test_config.h" #include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h" #include "src/proto/grpc/testing/echo.grpc.pb.h" +#include "test/core/util/port.h" +#include "test/core/util/test_config.h" #include "test/cpp/util/subprocess.h" using grpc::testing::EchoRequest; @@ -63,7 +63,7 @@ class CrashTest : public ::testing::Test { protected: CrashTest() {} - std::unique_ptr<grpc::testing::TestService::Stub> CreateServerAndStub() { + std::unique_ptr<grpc::testing::EchoTestService::Stub> CreateServerAndStub() { auto port = grpc_pick_unused_port_or_die(); std::ostringstream addr_stream; addr_stream << "localhost:" << port; @@ -72,7 +72,7 @@ class CrashTest : public ::testing::Test { g_root + "/client_crash_test_server", "--address=" + addr, })); GPR_ASSERT(server_); - return grpc::testing::TestService::NewStub( + return grpc::testing::EchoTestService::NewStub( CreateChannel(addr, InsecureChannelCredentials())); } diff --git a/test/cpp/end2end/client_crash_test_server.cc b/test/cpp/end2end/client_crash_test_server.cc index f9a9c187a7..9568ca26be 100644 --- a/test/cpp/end2end/client_crash_test_server.cc +++ b/test/cpp/end2end/client_crash_test_server.cc @@ -31,10 +31,10 @@ * */ +#include <gflags/gflags.h> #include <iostream> #include <memory> #include <string> -#include <gflags/gflags.h> #include <grpc++/server.h> #include <grpc++/server_builder.h> @@ -56,7 +56,8 @@ using namespace gflags; namespace grpc { namespace testing { -class ServiceImpl GRPC_FINAL : public ::grpc::testing::TestService::Service { +class ServiceImpl GRPC_FINAL + : public ::grpc::testing::EchoTestService::Service { Status BidiStream(ServerContext* context, ServerReaderWriter<EchoResponse, EchoRequest>* stream) GRPC_OVERRIDE { diff --git a/test/cpp/end2end/end2end_test.cc b/test/cpp/end2end/end2end_test.cc index 28f8a8ec46..d72e93c10d 100644 --- a/test/cpp/end2end/end2end_test.cc +++ b/test/cpp/end2end/end2end_test.cc @@ -34,9 +34,6 @@ #include <mutex> #include <thread> -#include <grpc/grpc.h> -#include <grpc/support/thd.h> -#include <grpc/support/time.h> #include <grpc++/channel.h> #include <grpc++/client_context.h> #include <grpc++/create_channel.h> @@ -46,14 +43,17 @@ #include <grpc++/server.h> #include <grpc++/server_builder.h> #include <grpc++/server_context.h> +#include <grpc/grpc.h> +#include <grpc/support/thd.h> +#include <grpc/support/time.h> #include <gtest/gtest.h> #include "src/core/security/credentials.h" +#include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h" +#include "src/proto/grpc/testing/echo.grpc.pb.h" #include "test/core/end2end/data/ssl_test_data.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" -#include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h" -#include "src/proto/grpc/testing/echo.grpc.pb.h" #include "test/cpp/util/string_ref_helper.h" using grpc::testing::EchoRequest; @@ -196,10 +196,10 @@ class TestAuthMetadataProcessor : public AuthMetadataProcessor { const char TestAuthMetadataProcessor::kGoodGuy[] = "Dr Jekyll"; const char TestAuthMetadataProcessor::kIdentityPropName[] = "novel identity"; -class Proxy : public ::grpc::testing::TestService::Service { +class Proxy : public ::grpc::testing::EchoTestService::Service { public: Proxy(std::shared_ptr<Channel> channel) - : stub_(grpc::testing::TestService::NewStub(channel)) {} + : stub_(grpc::testing::EchoTestService::NewStub(channel)) {} Status Echo(ServerContext* server_context, const EchoRequest* request, EchoResponse* response) GRPC_OVERRIDE { @@ -209,10 +209,10 @@ class Proxy : public ::grpc::testing::TestService::Service { } private: - std::unique_ptr< ::grpc::testing::TestService::Stub> stub_; + std::unique_ptr< ::grpc::testing::EchoTestService::Stub> stub_; }; -class TestServiceImpl : public ::grpc::testing::TestService::Service { +class TestServiceImpl : public ::grpc::testing::EchoTestService::Service { public: TestServiceImpl() : signal_client_(false), host_() {} explicit TestServiceImpl(const grpc::string& host) @@ -344,7 +344,7 @@ class TestServiceImpl : public ::grpc::testing::TestService::Service { }; class TestServiceImplDupPkg - : public ::grpc::testing::duplicate::TestService::Service { + : public ::grpc::testing::duplicate::EchoTestService::Service { public: Status Echo(ServerContext* context, const EchoRequest* request, EchoResponse* response) GRPC_OVERRIDE { @@ -435,12 +435,12 @@ class End2endTest : public ::testing::TestWithParam<TestScenario> { channel_ = CreateChannel(proxyaddr.str(), InsecureChannelCredentials()); } - stub_ = grpc::testing::TestService::NewStub(channel_); + stub_ = grpc::testing::EchoTestService::NewStub(channel_); } bool is_server_started_; std::shared_ptr<Channel> channel_; - std::unique_ptr<grpc::testing::TestService::Stub> stub_; + std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_; std::unique_ptr<Server> server_; std::unique_ptr<Server> proxy_server_; std::unique_ptr<Proxy> proxy_service_; @@ -451,7 +451,7 @@ class End2endTest : public ::testing::TestWithParam<TestScenario> { TestServiceImplDupPkg dup_pkg_service_; }; -static void SendRpc(grpc::testing::TestService::Stub* stub, int num_rpcs) { +static void SendRpc(grpc::testing::EchoTestService::Stub* stub, int num_rpcs) { EchoRequest request; EchoResponse response; request.set_message("Hello hello hello hello"); @@ -561,8 +561,8 @@ TEST_P(End2endTest, DiffPackageServices) { EXPECT_EQ(response.message(), request.message()); EXPECT_TRUE(s.ok()); - std::unique_ptr<grpc::testing::duplicate::TestService::Stub> dup_pkg_stub( - grpc::testing::duplicate::TestService::NewStub(channel_)); + std::unique_ptr<grpc::testing::duplicate::EchoTestService::Stub> dup_pkg_stub( + grpc::testing::duplicate::EchoTestService::NewStub(channel_)); ClientContext context2; s = dup_pkg_stub->Echo(&context2, request, &response); EXPECT_EQ("no package", response.message()); diff --git a/test/cpp/end2end/generic_end2end_test.cc b/test/cpp/end2end/generic_end2end_test.cc index 14b534fbd2..c5d9de3f29 100644 --- a/test/cpp/end2end/generic_end2end_test.cc +++ b/test/cpp/end2end/generic_end2end_test.cc @@ -33,24 +33,24 @@ #include <memory> -#include <grpc/grpc.h> -#include <grpc/support/thd.h> -#include <grpc/support/time.h> -#include <grpc++/impl/proto_utils.h> #include <grpc++/channel.h> #include <grpc++/client_context.h> #include <grpc++/create_channel.h> #include <grpc++/generic/async_generic_service.h> #include <grpc++/generic/generic_stub.h> +#include <grpc++/impl/proto_utils.h> #include <grpc++/server.h> #include <grpc++/server_builder.h> #include <grpc++/server_context.h> #include <grpc++/support/slice.h> +#include <grpc/grpc.h> +#include <grpc/support/thd.h> +#include <grpc/support/time.h> #include <gtest/gtest.h> +#include "src/proto/grpc/testing/echo.grpc.pb.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" -#include "src/proto/grpc/testing/echo.grpc.pb.h" using grpc::testing::EchoRequest; using grpc::testing::EchoResponse; @@ -134,7 +134,7 @@ class GenericEnd2endTest : public ::testing::Test { void client_fail(int i) { verify_ok(&cli_cq_, i, false); } void SendRpc(int num_rpcs) { - const grpc::string kMethodName("/grpc.cpp.test.util.TestService/Echo"); + const grpc::string kMethodName("/grpc.cpp.test.util.EchoTestService/Echo"); for (int i = 0; i < num_rpcs; i++) { EchoRequest send_request; EchoRequest recv_request; @@ -193,7 +193,7 @@ class GenericEnd2endTest : public ::testing::Test { CompletionQueue cli_cq_; std::unique_ptr<ServerCompletionQueue> srv_cq_; - std::unique_ptr<grpc::testing::TestService::Stub> stub_; + std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_; std::unique_ptr<grpc::GenericStub> generic_stub_; std::unique_ptr<Server> server_; AsyncGenericService generic_service_; @@ -215,7 +215,8 @@ TEST_F(GenericEnd2endTest, SequentialRpcs) { TEST_F(GenericEnd2endTest, SimpleBidiStreaming) { ResetStub(); - const grpc::string kMethodName("/grpc.cpp.test.util.TestService/BidiStream"); + const grpc::string kMethodName( + "/grpc.cpp.test.util.EchoTestService/BidiStream"); EchoRequest send_request; EchoRequest recv_request; EchoResponse send_response; diff --git a/test/cpp/end2end/hybrid_end2end_test.cc b/test/cpp/end2end/hybrid_end2end_test.cc new file mode 100644 index 0000000000..24de363740 --- /dev/null +++ b/test/cpp/end2end/hybrid_end2end_test.cc @@ -0,0 +1,178 @@ +/* + * + * Copyright 2015-2016, 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 <memory> + +#include <grpc++/channel.h> +#include <grpc++/client_context.h> +#include <grpc++/create_channel.h> +#include <grpc++/server.h> +#include <grpc++/server_builder.h> +#include <grpc++/server_context.h> +#include <grpc/grpc.h> +#include <grpc/support/thd.h> +#include <grpc/support/time.h> +#include <gtest/gtest.h> + +#include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h" +#include "src/proto/grpc/testing/echo.grpc.pb.h" +#include "test/core/util/port.h" +#include "test/core/util/test_config.h" +#include "test/cpp/util/string_ref_helper.h" + +using grpc::testing::EchoRequest; +using grpc::testing::EchoResponse; + +namespace grpc { +namespace testing { + +namespace { + +void* tag(int i) { return (void*)(intptr_t)i; } + +// Handlers to handle async request at a server. To be run in a separate thread. +void HandleEcho(::grpc::Service* service, ServerCompletionQueue* cq) { + ServerContext srv_ctx; + grpc::ServerAsyncResponseWriter<EcoResponse> response_writer(&srv_ctx); + EchoRequest recv_request; + EchoResponse send_response; + service->RequestEcho(&srv_ctx, &recv_request, &response_writer, cq, cq, tag(1)); + Verify(cq, 1, true); + send_response.set_message(recv_request.message()); + response_writer.Finish(send_response, Status::OK, tag(2)); + Verify(cq, 2, true); +} + +void HandleClientStreaming(::grpc::Service* service, ServerCompletionQueue* cq) { + ServerContext srv_ctx; + EchoRequest recv_request; + EchoResponse send_response; + ServerAsyncReader<EchoResponse, EchoRequest> srv_stream(&srv_ctx); + service_.RequestRequestStream(&srv_ctx, &srv_stream, cq, cq, tag(1)); + Verify(cq, 1, true); + do { + srv_stream.Read(&recv_request, tag(2)); + } while (VerifyReturnSuccess(2)); + srv_stream.Finish(send_response, Status::OK, tag(3)); + Verify(cq, 3, true); +} + +class HybridEnd2endTest : public ::testing::Test { + protected: + HybridEnd2endTest() {} + + void SetUpServer(::grpc::Service* service) { + int port = grpc_pick_unused_port_or_die(); + server_address_ << "localhost:" << port; + + // Setup server + ServerBuilder builder; + builder.AddListeningPort(server_address_.str(), + grpc::InsecureServerCredentials()); + builder.RegisterService(&service_); + cq_ = builder.AddCompletionQueue(); + server_ = builder.BuildAndStart(); + } + + void TearDown() GRPC_OVERRIDE { + server_->Shutdown(); + void* ignored_tag; + bool ignored_ok; + cq_->Shutdown(); + while (cq_->Next(&ignored_tag, &ignored_ok)) + ; + } + + void ResetStub() { + std::shared_ptr<Channel> channel = + CreateChannel(server_address_.str(), InsecureChannelCredentials()); + stub_ = grpc::testing::EchoTestService::NewStub(channel); + } + + void TestAllMethods() { + SendEcho(); + SendSimpleClientStreaming(); + } + + void SendEcho() { + EchoRequest send_request; + EchoResponse recv_response; + ClientContext cli_ctx; + send_request.set_message("Hello"); + Status recv_status = stub_->Echo(&cli_ctx, send_request, &recv_response); + EXPECT_EQ(send_request.message(), recv_response.message()); + EXPECT_TRUE(recv_status.ok()); + } + + void SendSimpleClientStreaming() { + EchoRequest send_request; + EchoResponse recv_response; + ClientContext cli_ctx; + send_request.set_message("Hello"); + auto stream = stub_->RequestStream(&cli_ctx, &recv_response); + for (int i = 0; i < 5; i++) { + EXPECT_TRUE(stream->Write(&send_request)); + } + Status recv_status = stream->Finish(); + EXPECT_EQ(send_request.message(), recv_response.message()); + EXPECT_TRUE(recv_status.ok()); + } + + std::unique_ptr<ServerCompletionQueue> cq_; + std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_; + std::unique_ptr<Server> server_; + std::ostringstream server_address_; +}; + +TEST_F(HybridEnd2endTest, AsyncEchorequestStream) { + WithAsyncMethod_Echo<WithAsyncMethod_RequestStream<EchoTestService> > service; + SetUpServer(&service); + ResetStub(); + std::thread echo_handler_thread(HandleEcho, &service, cq_.get()); + std::thread request_stream_thread(HandleClientStreaming, &service, cq_.get()); + TestAllMethods(); + echo_handler_thread.join(); + request_stream_thread.join(); +} + + + +} // namespace +} // namespace testing +} // namespace grpc + +int main(int argc, char** argv) { + grpc_test_init(argc, argv); + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} diff --git a/test/cpp/end2end/mixed_handlers_end2end_test.cc b/test/cpp/end2end/mixed_handlers_end2end_test.cc new file mode 100644 index 0000000000..a896ad2d73 --- /dev/null +++ b/test/cpp/end2end/mixed_handlers_end2end_test.cc @@ -0,0 +1,747 @@ +/* + * + * Copyright 2015-2016, 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 <memory> + +#include <grpc/grpc.h> +#include <grpc/support/thd.h> +#include <grpc/support/time.h> +#include <grpc++/channel.h> +#include <grpc++/client_context.h> +#include <grpc++/create_channel.h> +#include <grpc++/server.h> +#include <grpc++/server_builder.h> +#include <grpc++/server_context.h> +#include <gtest/gtest.h> + +#include "test/core/util/port.h" +#include "test/core/util/test_config.h" +#include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h" +#include "src/proto/grpc/testing/echo.grpc.pb.h" +#include "test/cpp/util/string_ref_helper.h" + +using grpc::testing::EchoRequest; +using grpc::testing::EchoResponse; +using std::chrono::system_clock; + +namespace grpc { +namespace testing { + +namespace { + +void* tag(int i) { return (void*)(intptr_t)i; } + +class Verifier { + public: + explicit Verifier(bool spin) : spin_(spin) {} + Verifier& Expect(int i, bool expect_ok) { + expectations_[tag(i)] = expect_ok; + return *this; + } + void Verify(CompletionQueue* cq) { + GPR_ASSERT(!expectations_.empty()); + while (!expectations_.empty()) { + bool ok; + void* got_tag; + if (spin_) { + for (;;) { + auto r = cq->AsyncNext(&got_tag, &ok, gpr_time_0(GPR_CLOCK_REALTIME)); + if (r == CompletionQueue::TIMEOUT) continue; + if (r == CompletionQueue::GOT_EVENT) break; + gpr_log(GPR_ERROR, "unexpected result from AsyncNext"); + abort(); + } + } else { + EXPECT_TRUE(cq->Next(&got_tag, &ok)); + } + auto it = expectations_.find(got_tag); + EXPECT_TRUE(it != expectations_.end()); + EXPECT_EQ(it->second, ok); + expectations_.erase(it); + } + } + void Verify(CompletionQueue* cq, + std::chrono::system_clock::time_point deadline) { + if (expectations_.empty()) { + bool ok; + void* got_tag; + if (spin_) { + while (std::chrono::system_clock::now() < deadline) { + EXPECT_EQ( + cq->AsyncNext(&got_tag, &ok, gpr_time_0(GPR_CLOCK_REALTIME)), + CompletionQueue::TIMEOUT); + } + } else { + EXPECT_EQ(cq->AsyncNext(&got_tag, &ok, deadline), + CompletionQueue::TIMEOUT); + } + } else { + while (!expectations_.empty()) { + bool ok; + void* got_tag; + if (spin_) { + for (;;) { + GPR_ASSERT(std::chrono::system_clock::now() < deadline); + auto r = + cq->AsyncNext(&got_tag, &ok, gpr_time_0(GPR_CLOCK_REALTIME)); + if (r == CompletionQueue::TIMEOUT) continue; + if (r == CompletionQueue::GOT_EVENT) break; + gpr_log(GPR_ERROR, "unexpected result from AsyncNext"); + abort(); + } + } else { + EXPECT_EQ(cq->AsyncNext(&got_tag, &ok, deadline), + CompletionQueue::GOT_EVENT); + } + auto it = expectations_.find(got_tag); + EXPECT_TRUE(it != expectations_.end()); + EXPECT_EQ(it->second, ok); + expectations_.erase(it); + } + } + } + + private: + std::map<void*, bool> expectations_; + bool spin_; +}; + +class AsyncEnd2endTest : public ::testing::TestWithParam<bool> { + protected: + AsyncEnd2endTest() {} + + void SetUp() GRPC_OVERRIDE { + int port = grpc_pick_unused_port_or_die(); + server_address_ << "localhost:" << port; + + // Setup server + ServerBuilder builder; + builder.AddListeningPort(server_address_.str(), + grpc::InsecureServerCredentials()); + builder.RegisterService(&service_); + cq_ = builder.AddCompletionQueue(); + server_ = builder.BuildAndStart(); + } + + void TearDown() GRPC_OVERRIDE { + server_->Shutdown(); + void* ignored_tag; + bool ignored_ok; + cq_->Shutdown(); + while (cq_->Next(&ignored_tag, &ignored_ok)) + ; + } + + void ResetStub() { + std::shared_ptr<Channel> channel = + CreateChannel(server_address_.str(), InsecureChannelCredentials()); + stub_ = grpc::testing::TestService::NewStub(channel); + } + + void SendRpc(int num_rpcs) { + for (int i = 0; i < num_rpcs; i++) { + EchoRequest send_request; + EchoRequest recv_request; + EchoResponse send_response; + EchoResponse recv_response; + Status recv_status; + + ClientContext cli_ctx; + ServerContext srv_ctx; + grpc::ServerAsyncResponseWriter<EchoResponse> response_writer(&srv_ctx); + + send_request.set_message("Hello"); + std::unique_ptr<ClientAsyncResponseReader<EchoResponse> > response_reader( + stub_->AsyncEcho(&cli_ctx, send_request, cq_.get())); + + service_.RequestEcho(&srv_ctx, &recv_request, &response_writer, cq_.get(), + cq_.get(), tag(2)); + + Verifier(GetParam()).Expect(2, true).Verify(cq_.get()); + EXPECT_EQ(send_request.message(), recv_request.message()); + + send_response.set_message(recv_request.message()); + response_writer.Finish(send_response, Status::OK, tag(3)); + Verifier(GetParam()).Expect(3, true).Verify(cq_.get()); + + response_reader->Finish(&recv_response, &recv_status, tag(4)); + Verifier(GetParam()).Expect(4, true).Verify(cq_.get()); + + EXPECT_EQ(send_response.message(), recv_response.message()); + EXPECT_TRUE(recv_status.ok()); + } + } + + std::unique_ptr<ServerCompletionQueue> cq_; + std::unique_ptr<grpc::testing::TestService::Stub> stub_; + std::unique_ptr<Server> server_; + grpc::testing::TestService::AsyncService service_; + std::ostringstream server_address_; +}; + +TEST_P(AsyncEnd2endTest, SimpleRpc) { + ResetStub(); + SendRpc(1); +} + +TEST_P(AsyncEnd2endTest, SequentialRpcs) { + ResetStub(); + SendRpc(10); +} + +// Test a simple RPC using the async version of Next +TEST_P(AsyncEnd2endTest, AsyncNextRpc) { + ResetStub(); + + EchoRequest send_request; + EchoRequest recv_request; + EchoResponse send_response; + EchoResponse recv_response; + Status recv_status; + + ClientContext cli_ctx; + ServerContext srv_ctx; + grpc::ServerAsyncResponseWriter<EchoResponse> response_writer(&srv_ctx); + + send_request.set_message("Hello"); + std::unique_ptr<ClientAsyncResponseReader<EchoResponse> > response_reader( + stub_->AsyncEcho(&cli_ctx, send_request, cq_.get())); + + std::chrono::system_clock::time_point time_now( + std::chrono::system_clock::now()); + std::chrono::system_clock::time_point time_limit( + std::chrono::system_clock::now() + std::chrono::seconds(10)); + Verifier(GetParam()).Verify(cq_.get(), time_now); + Verifier(GetParam()).Verify(cq_.get(), time_now); + + service_.RequestEcho(&srv_ctx, &recv_request, &response_writer, cq_.get(), + cq_.get(), tag(2)); + + Verifier(GetParam()).Expect(2, true).Verify(cq_.get(), time_limit); + EXPECT_EQ(send_request.message(), recv_request.message()); + + send_response.set_message(recv_request.message()); + response_writer.Finish(send_response, Status::OK, tag(3)); + Verifier(GetParam()) + .Expect(3, true) + .Verify(cq_.get(), std::chrono::system_clock::time_point::max()); + + response_reader->Finish(&recv_response, &recv_status, tag(4)); + Verifier(GetParam()) + .Expect(4, true) + .Verify(cq_.get(), std::chrono::system_clock::time_point::max()); + + EXPECT_EQ(send_response.message(), recv_response.message()); + EXPECT_TRUE(recv_status.ok()); +} + +// Two pings and a final pong. +TEST_P(AsyncEnd2endTest, SimpleClientStreaming) { + ResetStub(); + + EchoRequest send_request; + EchoRequest recv_request; + EchoResponse send_response; + EchoResponse recv_response; + Status recv_status; + ClientContext cli_ctx; + ServerContext srv_ctx; + ServerAsyncReader<EchoResponse, EchoRequest> srv_stream(&srv_ctx); + + send_request.set_message("Hello"); + std::unique_ptr<ClientAsyncWriter<EchoRequest> > cli_stream( + stub_->AsyncRequestStream(&cli_ctx, &recv_response, cq_.get(), tag(1))); + + service_.RequestRequestStream(&srv_ctx, &srv_stream, cq_.get(), cq_.get(), + tag(2)); + + Verifier(GetParam()).Expect(2, true).Expect(1, true).Verify(cq_.get()); + + cli_stream->Write(send_request, tag(3)); + Verifier(GetParam()).Expect(3, true).Verify(cq_.get()); + + srv_stream.Read(&recv_request, tag(4)); + Verifier(GetParam()).Expect(4, true).Verify(cq_.get()); + EXPECT_EQ(send_request.message(), recv_request.message()); + + cli_stream->Write(send_request, tag(5)); + Verifier(GetParam()).Expect(5, true).Verify(cq_.get()); + + srv_stream.Read(&recv_request, tag(6)); + Verifier(GetParam()).Expect(6, true).Verify(cq_.get()); + + EXPECT_EQ(send_request.message(), recv_request.message()); + cli_stream->WritesDone(tag(7)); + Verifier(GetParam()).Expect(7, true).Verify(cq_.get()); + + srv_stream.Read(&recv_request, tag(8)); + Verifier(GetParam()).Expect(8, false).Verify(cq_.get()); + + send_response.set_message(recv_request.message()); + srv_stream.Finish(send_response, Status::OK, tag(9)); + Verifier(GetParam()).Expect(9, true).Verify(cq_.get()); + + cli_stream->Finish(&recv_status, tag(10)); + Verifier(GetParam()).Expect(10, true).Verify(cq_.get()); + + EXPECT_EQ(send_response.message(), recv_response.message()); + EXPECT_TRUE(recv_status.ok()); +} + +// One ping, two pongs. +TEST_P(AsyncEnd2endTest, SimpleServerStreaming) { + ResetStub(); + + EchoRequest send_request; + EchoRequest recv_request; + EchoResponse send_response; + EchoResponse recv_response; + Status recv_status; + ClientContext cli_ctx; + ServerContext srv_ctx; + ServerAsyncWriter<EchoResponse> srv_stream(&srv_ctx); + + send_request.set_message("Hello"); + std::unique_ptr<ClientAsyncReader<EchoResponse> > cli_stream( + stub_->AsyncResponseStream(&cli_ctx, send_request, cq_.get(), tag(1))); + + service_.RequestResponseStream(&srv_ctx, &recv_request, &srv_stream, + cq_.get(), cq_.get(), tag(2)); + + Verifier(GetParam()).Expect(1, true).Expect(2, true).Verify(cq_.get()); + EXPECT_EQ(send_request.message(), recv_request.message()); + + send_response.set_message(recv_request.message()); + srv_stream.Write(send_response, tag(3)); + Verifier(GetParam()).Expect(3, true).Verify(cq_.get()); + + cli_stream->Read(&recv_response, tag(4)); + Verifier(GetParam()).Expect(4, true).Verify(cq_.get()); + EXPECT_EQ(send_response.message(), recv_response.message()); + + srv_stream.Write(send_response, tag(5)); + Verifier(GetParam()).Expect(5, true).Verify(cq_.get()); + + cli_stream->Read(&recv_response, tag(6)); + Verifier(GetParam()).Expect(6, true).Verify(cq_.get()); + EXPECT_EQ(send_response.message(), recv_response.message()); + + srv_stream.Finish(Status::OK, tag(7)); + Verifier(GetParam()).Expect(7, true).Verify(cq_.get()); + + cli_stream->Read(&recv_response, tag(8)); + Verifier(GetParam()).Expect(8, false).Verify(cq_.get()); + + cli_stream->Finish(&recv_status, tag(9)); + Verifier(GetParam()).Expect(9, true).Verify(cq_.get()); + + EXPECT_TRUE(recv_status.ok()); +} + +// One ping, one pong. +TEST_P(AsyncEnd2endTest, SimpleBidiStreaming) { + ResetStub(); + + EchoRequest send_request; + EchoRequest recv_request; + EchoResponse send_response; + EchoResponse recv_response; + Status recv_status; + ClientContext cli_ctx; + ServerContext srv_ctx; + ServerAsyncReaderWriter<EchoResponse, EchoRequest> srv_stream(&srv_ctx); + + send_request.set_message("Hello"); + std::unique_ptr<ClientAsyncReaderWriter<EchoRequest, EchoResponse> > + cli_stream(stub_->AsyncBidiStream(&cli_ctx, cq_.get(), tag(1))); + + service_.RequestBidiStream(&srv_ctx, &srv_stream, cq_.get(), cq_.get(), + tag(2)); + + Verifier(GetParam()).Expect(1, true).Expect(2, true).Verify(cq_.get()); + + cli_stream->Write(send_request, tag(3)); + Verifier(GetParam()).Expect(3, true).Verify(cq_.get()); + + srv_stream.Read(&recv_request, tag(4)); + Verifier(GetParam()).Expect(4, true).Verify(cq_.get()); + EXPECT_EQ(send_request.message(), recv_request.message()); + + send_response.set_message(recv_request.message()); + srv_stream.Write(send_response, tag(5)); + Verifier(GetParam()).Expect(5, true).Verify(cq_.get()); + + cli_stream->Read(&recv_response, tag(6)); + Verifier(GetParam()).Expect(6, true).Verify(cq_.get()); + EXPECT_EQ(send_response.message(), recv_response.message()); + + cli_stream->WritesDone(tag(7)); + Verifier(GetParam()).Expect(7, true).Verify(cq_.get()); + + srv_stream.Read(&recv_request, tag(8)); + Verifier(GetParam()).Expect(8, false).Verify(cq_.get()); + + srv_stream.Finish(Status::OK, tag(9)); + Verifier(GetParam()).Expect(9, true).Verify(cq_.get()); + + cli_stream->Finish(&recv_status, tag(10)); + Verifier(GetParam()).Expect(10, true).Verify(cq_.get()); + + EXPECT_TRUE(recv_status.ok()); +} + +// Metadata tests +TEST_P(AsyncEnd2endTest, ClientInitialMetadataRpc) { + ResetStub(); + + EchoRequest send_request; + EchoRequest recv_request; + EchoResponse send_response; + EchoResponse recv_response; + Status recv_status; + + ClientContext cli_ctx; + ServerContext srv_ctx; + grpc::ServerAsyncResponseWriter<EchoResponse> response_writer(&srv_ctx); + + send_request.set_message("Hello"); + std::pair<grpc::string, grpc::string> meta1("key1", "val1"); + std::pair<grpc::string, grpc::string> meta2("key2", "val2"); + cli_ctx.AddMetadata(meta1.first, meta1.second); + cli_ctx.AddMetadata(meta2.first, meta2.second); + + std::unique_ptr<ClientAsyncResponseReader<EchoResponse> > response_reader( + stub_->AsyncEcho(&cli_ctx, send_request, cq_.get())); + + service_.RequestEcho(&srv_ctx, &recv_request, &response_writer, cq_.get(), + cq_.get(), tag(2)); + Verifier(GetParam()).Expect(2, true).Verify(cq_.get()); + EXPECT_EQ(send_request.message(), recv_request.message()); + auto client_initial_metadata = srv_ctx.client_metadata(); + EXPECT_EQ(meta1.second, + ToString(client_initial_metadata.find(meta1.first)->second)); + EXPECT_EQ(meta2.second, + ToString(client_initial_metadata.find(meta2.first)->second)); + EXPECT_GE(client_initial_metadata.size(), static_cast<size_t>(2)); + + send_response.set_message(recv_request.message()); + response_writer.Finish(send_response, Status::OK, tag(3)); + + Verifier(GetParam()).Expect(3, true).Verify(cq_.get()); + + response_reader->Finish(&recv_response, &recv_status, tag(4)); + Verifier(GetParam()).Expect(4, true).Verify(cq_.get()); + + EXPECT_EQ(send_response.message(), recv_response.message()); + EXPECT_TRUE(recv_status.ok()); +} + +TEST_P(AsyncEnd2endTest, ServerInitialMetadataRpc) { + ResetStub(); + + EchoRequest send_request; + EchoRequest recv_request; + EchoResponse send_response; + EchoResponse recv_response; + Status recv_status; + + ClientContext cli_ctx; + ServerContext srv_ctx; + grpc::ServerAsyncResponseWriter<EchoResponse> response_writer(&srv_ctx); + + send_request.set_message("Hello"); + std::pair<grpc::string, grpc::string> meta1("key1", "val1"); + std::pair<grpc::string, grpc::string> meta2("key2", "val2"); + + std::unique_ptr<ClientAsyncResponseReader<EchoResponse> > response_reader( + stub_->AsyncEcho(&cli_ctx, send_request, cq_.get())); + + service_.RequestEcho(&srv_ctx, &recv_request, &response_writer, cq_.get(), + cq_.get(), tag(2)); + Verifier(GetParam()).Expect(2, true).Verify(cq_.get()); + EXPECT_EQ(send_request.message(), recv_request.message()); + srv_ctx.AddInitialMetadata(meta1.first, meta1.second); + srv_ctx.AddInitialMetadata(meta2.first, meta2.second); + response_writer.SendInitialMetadata(tag(3)); + Verifier(GetParam()).Expect(3, true).Verify(cq_.get()); + + response_reader->ReadInitialMetadata(tag(4)); + Verifier(GetParam()).Expect(4, true).Verify(cq_.get()); + auto server_initial_metadata = cli_ctx.GetServerInitialMetadata(); + EXPECT_EQ(meta1.second, + ToString(server_initial_metadata.find(meta1.first)->second)); + EXPECT_EQ(meta2.second, + ToString(server_initial_metadata.find(meta2.first)->second)); + EXPECT_EQ(static_cast<size_t>(2), server_initial_metadata.size()); + + send_response.set_message(recv_request.message()); + response_writer.Finish(send_response, Status::OK, tag(5)); + Verifier(GetParam()).Expect(5, true).Verify(cq_.get()); + + response_reader->Finish(&recv_response, &recv_status, tag(6)); + Verifier(GetParam()).Expect(6, true).Verify(cq_.get()); + + EXPECT_EQ(send_response.message(), recv_response.message()); + EXPECT_TRUE(recv_status.ok()); +} + +TEST_P(AsyncEnd2endTest, ServerTrailingMetadataRpc) { + ResetStub(); + + EchoRequest send_request; + EchoRequest recv_request; + EchoResponse send_response; + EchoResponse recv_response; + Status recv_status; + + ClientContext cli_ctx; + ServerContext srv_ctx; + grpc::ServerAsyncResponseWriter<EchoResponse> response_writer(&srv_ctx); + + send_request.set_message("Hello"); + std::pair<grpc::string, grpc::string> meta1("key1", "val1"); + std::pair<grpc::string, grpc::string> meta2("key2", "val2"); + + std::unique_ptr<ClientAsyncResponseReader<EchoResponse> > response_reader( + stub_->AsyncEcho(&cli_ctx, send_request, cq_.get())); + + service_.RequestEcho(&srv_ctx, &recv_request, &response_writer, cq_.get(), + cq_.get(), tag(2)); + Verifier(GetParam()).Expect(2, true).Verify(cq_.get()); + EXPECT_EQ(send_request.message(), recv_request.message()); + response_writer.SendInitialMetadata(tag(3)); + Verifier(GetParam()).Expect(3, true).Verify(cq_.get()); + + send_response.set_message(recv_request.message()); + srv_ctx.AddTrailingMetadata(meta1.first, meta1.second); + srv_ctx.AddTrailingMetadata(meta2.first, meta2.second); + response_writer.Finish(send_response, Status::OK, tag(4)); + + Verifier(GetParam()).Expect(4, true).Verify(cq_.get()); + + response_reader->Finish(&recv_response, &recv_status, tag(5)); + Verifier(GetParam()).Expect(5, true).Verify(cq_.get()); + EXPECT_EQ(send_response.message(), recv_response.message()); + EXPECT_TRUE(recv_status.ok()); + auto server_trailing_metadata = cli_ctx.GetServerTrailingMetadata(); + EXPECT_EQ(meta1.second, + ToString(server_trailing_metadata.find(meta1.first)->second)); + EXPECT_EQ(meta2.second, + ToString(server_trailing_metadata.find(meta2.first)->second)); + EXPECT_EQ(static_cast<size_t>(2), server_trailing_metadata.size()); +} + +TEST_P(AsyncEnd2endTest, MetadataRpc) { + ResetStub(); + + EchoRequest send_request; + EchoRequest recv_request; + EchoResponse send_response; + EchoResponse recv_response; + Status recv_status; + + ClientContext cli_ctx; + ServerContext srv_ctx; + grpc::ServerAsyncResponseWriter<EchoResponse> response_writer(&srv_ctx); + + send_request.set_message("Hello"); + std::pair<grpc::string, grpc::string> meta1("key1", "val1"); + std::pair<grpc::string, grpc::string> meta2( + "key2-bin", + grpc::string("\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc", 13)); + std::pair<grpc::string, grpc::string> meta3("key3", "val3"); + std::pair<grpc::string, grpc::string> meta6( + "key4-bin", + grpc::string("\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d", + 14)); + std::pair<grpc::string, grpc::string> meta5("key5", "val5"); + std::pair<grpc::string, grpc::string> meta4( + "key6-bin", + grpc::string( + "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee", 15)); + + cli_ctx.AddMetadata(meta1.first, meta1.second); + cli_ctx.AddMetadata(meta2.first, meta2.second); + + std::unique_ptr<ClientAsyncResponseReader<EchoResponse> > response_reader( + stub_->AsyncEcho(&cli_ctx, send_request, cq_.get())); + + service_.RequestEcho(&srv_ctx, &recv_request, &response_writer, cq_.get(), + cq_.get(), tag(2)); + Verifier(GetParam()).Expect(2, true).Verify(cq_.get()); + EXPECT_EQ(send_request.message(), recv_request.message()); + auto client_initial_metadata = srv_ctx.client_metadata(); + EXPECT_EQ(meta1.second, + ToString(client_initial_metadata.find(meta1.first)->second)); + EXPECT_EQ(meta2.second, + ToString(client_initial_metadata.find(meta2.first)->second)); + EXPECT_GE(client_initial_metadata.size(), static_cast<size_t>(2)); + + srv_ctx.AddInitialMetadata(meta3.first, meta3.second); + srv_ctx.AddInitialMetadata(meta4.first, meta4.second); + response_writer.SendInitialMetadata(tag(3)); + Verifier(GetParam()).Expect(3, true).Verify(cq_.get()); + response_reader->ReadInitialMetadata(tag(4)); + Verifier(GetParam()).Expect(4, true).Verify(cq_.get()); + auto server_initial_metadata = cli_ctx.GetServerInitialMetadata(); + EXPECT_EQ(meta3.second, + ToString(server_initial_metadata.find(meta3.first)->second)); + EXPECT_EQ(meta4.second, + ToString(server_initial_metadata.find(meta4.first)->second)); + EXPECT_GE(server_initial_metadata.size(), static_cast<size_t>(2)); + + send_response.set_message(recv_request.message()); + srv_ctx.AddTrailingMetadata(meta5.first, meta5.second); + srv_ctx.AddTrailingMetadata(meta6.first, meta6.second); + response_writer.Finish(send_response, Status::OK, tag(5)); + + Verifier(GetParam()).Expect(5, true).Verify(cq_.get()); + + response_reader->Finish(&recv_response, &recv_status, tag(6)); + Verifier(GetParam()).Expect(6, true).Verify(cq_.get()); + EXPECT_EQ(send_response.message(), recv_response.message()); + EXPECT_TRUE(recv_status.ok()); + auto server_trailing_metadata = cli_ctx.GetServerTrailingMetadata(); + EXPECT_EQ(meta5.second, + ToString(server_trailing_metadata.find(meta5.first)->second)); + EXPECT_EQ(meta6.second, + ToString(server_trailing_metadata.find(meta6.first)->second)); + EXPECT_GE(server_trailing_metadata.size(), static_cast<size_t>(2)); +} + +// Server uses AsyncNotifyWhenDone API to check for cancellation +TEST_P(AsyncEnd2endTest, ServerCheckCancellation) { + ResetStub(); + + EchoRequest send_request; + EchoRequest recv_request; + EchoResponse send_response; + EchoResponse recv_response; + Status recv_status; + + ClientContext cli_ctx; + ServerContext srv_ctx; + grpc::ServerAsyncResponseWriter<EchoResponse> response_writer(&srv_ctx); + + send_request.set_message("Hello"); + std::unique_ptr<ClientAsyncResponseReader<EchoResponse> > response_reader( + stub_->AsyncEcho(&cli_ctx, send_request, cq_.get())); + + srv_ctx.AsyncNotifyWhenDone(tag(5)); + service_.RequestEcho(&srv_ctx, &recv_request, &response_writer, cq_.get(), + cq_.get(), tag(2)); + + Verifier(GetParam()).Expect(2, true).Verify(cq_.get()); + EXPECT_EQ(send_request.message(), recv_request.message()); + + cli_ctx.TryCancel(); + Verifier(GetParam()).Expect(5, true).Verify(cq_.get()); + EXPECT_TRUE(srv_ctx.IsCancelled()); + + response_reader->Finish(&recv_response, &recv_status, tag(4)); + Verifier(GetParam()).Expect(4, false).Verify(cq_.get()); + + EXPECT_EQ(StatusCode::CANCELLED, recv_status.error_code()); +} + +// Server uses AsyncNotifyWhenDone API to check for normal finish +TEST_P(AsyncEnd2endTest, ServerCheckDone) { + ResetStub(); + + EchoRequest send_request; + EchoRequest recv_request; + EchoResponse send_response; + EchoResponse recv_response; + Status recv_status; + + ClientContext cli_ctx; + ServerContext srv_ctx; + grpc::ServerAsyncResponseWriter<EchoResponse> response_writer(&srv_ctx); + + send_request.set_message("Hello"); + std::unique_ptr<ClientAsyncResponseReader<EchoResponse> > response_reader( + stub_->AsyncEcho(&cli_ctx, send_request, cq_.get())); + + srv_ctx.AsyncNotifyWhenDone(tag(5)); + service_.RequestEcho(&srv_ctx, &recv_request, &response_writer, cq_.get(), + cq_.get(), tag(2)); + + Verifier(GetParam()).Expect(2, true).Verify(cq_.get()); + EXPECT_EQ(send_request.message(), recv_request.message()); + + send_response.set_message(recv_request.message()); + response_writer.Finish(send_response, Status::OK, tag(3)); + Verifier(GetParam()).Expect(3, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(5, true).Verify(cq_.get()); + EXPECT_FALSE(srv_ctx.IsCancelled()); + + response_reader->Finish(&recv_response, &recv_status, tag(4)); + Verifier(GetParam()).Expect(4, true).Verify(cq_.get()); + + EXPECT_EQ(send_response.message(), recv_response.message()); + EXPECT_TRUE(recv_status.ok()); +} + +TEST_P(AsyncEnd2endTest, UnimplementedRpc) { + std::shared_ptr<Channel> channel = + CreateChannel(server_address_.str(), InsecureChannelCredentials()); + std::unique_ptr<grpc::testing::UnimplementedService::Stub> stub; + stub = grpc::testing::UnimplementedService::NewStub(channel); + EchoRequest send_request; + EchoResponse recv_response; + Status recv_status; + + ClientContext cli_ctx; + send_request.set_message("Hello"); + std::unique_ptr<ClientAsyncResponseReader<EchoResponse> > response_reader( + stub->AsyncUnimplemented(&cli_ctx, send_request, cq_.get())); + + response_reader->Finish(&recv_response, &recv_status, tag(4)); + Verifier(GetParam()).Expect(4, false).Verify(cq_.get()); + + EXPECT_EQ(StatusCode::UNIMPLEMENTED, recv_status.error_code()); + EXPECT_EQ("", recv_status.error_message()); +} + +INSTANTIATE_TEST_CASE_P(AsyncEnd2end, AsyncEnd2endTest, + ::testing::Values(false, true)); + +} // namespace +} // namespace testing +} // namespace grpc + +int main(int argc, char** argv) { + grpc_test_init(argc, argv); + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} diff --git a/test/cpp/end2end/mock_test.cc b/test/cpp/end2end/mock_test.cc index dddd1d0a2e..0ace5d9418 100644 --- a/test/cpp/end2end/mock_test.cc +++ b/test/cpp/end2end/mock_test.cc @@ -33,25 +33,25 @@ #include <thread> -#include <grpc/grpc.h> -#include <grpc/support/thd.h> -#include <grpc/support/time.h> #include <grpc++/channel.h> #include <grpc++/client_context.h> #include <grpc++/create_channel.h> #include <grpc++/server.h> #include <grpc++/server_builder.h> #include <grpc++/server_context.h> +#include <grpc/grpc.h> +#include <grpc/support/thd.h> +#include <grpc/support/time.h> #include <gtest/gtest.h> -#include "test/core/util/port.h" -#include "test/core/util/test_config.h" #include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h" #include "src/proto/grpc/testing/echo.grpc.pb.h" +#include "test/core/util/port.h" +#include "test/core/util/test_config.h" using grpc::testing::EchoRequest; using grpc::testing::EchoResponse; -using grpc::testing::TestService; +using grpc::testing::EchoTestService; using std::chrono::system_clock; namespace grpc { @@ -98,7 +98,7 @@ class MockClientReaderWriter<EchoRequest, EchoResponse> GRPC_FINAL }; // Mocked stub. -class MockStub : public TestService::StubInterface { +class MockStub : public EchoTestService::StubInterface { public: MockStub() {} ~MockStub() {} @@ -154,7 +154,7 @@ class MockStub : public TestService::StubInterface { class FakeClient { public: - explicit FakeClient(TestService::StubInterface* stub) : stub_(stub) {} + explicit FakeClient(EchoTestService::StubInterface* stub) : stub_(stub) {} void DoEcho() { ClientContext context; @@ -197,13 +197,13 @@ class FakeClient { EXPECT_TRUE(s.ok()); } - void ResetStub(TestService::StubInterface* stub) { stub_ = stub; } + void ResetStub(EchoTestService::StubInterface* stub) { stub_ = stub; } private: - TestService::StubInterface* stub_; + EchoTestService::StubInterface* stub_; }; -class TestServiceImpl : public TestService::Service { +class TestServiceImpl : public EchoTestService::Service { public: Status Echo(ServerContext* context, const EchoRequest* request, EchoResponse* response) GRPC_OVERRIDE { @@ -245,10 +245,10 @@ class MockTest : public ::testing::Test { void ResetStub() { std::shared_ptr<Channel> channel = CreateChannel(server_address_.str(), InsecureChannelCredentials()); - stub_ = grpc::testing::TestService::NewStub(channel); + stub_ = grpc::testing::EchoTestService::NewStub(channel); } - std::unique_ptr<grpc::testing::TestService::Stub> stub_; + std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_; std::unique_ptr<Server> server_; std::ostringstream server_address_; TestServiceImpl service_; diff --git a/test/cpp/end2end/server_crash_test.cc b/test/cpp/end2end/server_crash_test.cc index 87ce6369d2..e447360276 100644 --- a/test/cpp/end2end/server_crash_test.cc +++ b/test/cpp/end2end/server_crash_test.cc @@ -31,21 +31,21 @@ * */ -#include <grpc/grpc.h> -#include <grpc/support/thd.h> -#include <grpc/support/time.h> #include <grpc++/channel.h> #include <grpc++/client_context.h> #include <grpc++/create_channel.h> #include <grpc++/server.h> #include <grpc++/server_builder.h> #include <grpc++/server_context.h> +#include <grpc/grpc.h> +#include <grpc/support/thd.h> +#include <grpc/support/time.h> #include <gtest/gtest.h> +#include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h" +#include "src/proto/grpc/testing/echo.grpc.pb.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" -#include "src/proto/grpc/testing/echo.grpc.pb.h" -#include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h" #include "test/cpp/util/subprocess.h" using grpc::testing::EchoRequest; @@ -59,7 +59,8 @@ namespace testing { namespace { -class ServiceImpl GRPC_FINAL : public ::grpc::testing::TestService::Service { +class ServiceImpl GRPC_FINAL + : public ::grpc::testing::EchoTestService::Service { public: ServiceImpl() : bidi_stream_count_(0), response_stream_count_(0) {} diff --git a/test/cpp/end2end/server_crash_test_client.cc b/test/cpp/end2end/server_crash_test_client.cc index b349ae7357..1964840fa5 100644 --- a/test/cpp/end2end/server_crash_test_client.cc +++ b/test/cpp/end2end/server_crash_test_client.cc @@ -31,11 +31,11 @@ * */ +#include <gflags/gflags.h> #include <iostream> #include <memory> #include <sstream> #include <string> -#include <gflags/gflags.h> #include <grpc++/channel.h> #include <grpc++/client_context.h> @@ -57,7 +57,7 @@ using namespace gflags; int main(int argc, char** argv) { ParseCommandLineFlags(&argc, &argv, true); - auto stub = grpc::testing::TestService::NewStub( + auto stub = grpc::testing::EchoTestService::NewStub( grpc::CreateChannel(FLAGS_address, grpc::InsecureChannelCredentials())); EchoRequest request; diff --git a/test/cpp/end2end/shutdown_test.cc b/test/cpp/end2end/shutdown_test.cc index 50d4f6dca3..992ee98013 100644 --- a/test/cpp/end2end/shutdown_test.cc +++ b/test/cpp/end2end/shutdown_test.cc @@ -33,20 +33,20 @@ #include <thread> -#include <grpc/grpc.h> -#include <grpc/support/sync.h> #include <grpc++/channel.h> #include <grpc++/client_context.h> #include <grpc++/create_channel.h> #include <grpc++/server.h> #include <grpc++/server_builder.h> #include <grpc++/server_context.h> +#include <grpc/grpc.h> +#include <grpc/support/sync.h> #include <gtest/gtest.h> #include "src/core/support/env.h" -#include "test/core/util/test_config.h" -#include "test/core/util/port.h" #include "src/proto/grpc/testing/echo.grpc.pb.h" +#include "test/core/util/port.h" +#include "test/core/util/test_config.h" using grpc::testing::EchoRequest; using grpc::testing::EchoResponse; @@ -54,7 +54,7 @@ using grpc::testing::EchoResponse; namespace grpc { namespace testing { -class TestServiceImpl : public ::grpc::testing::TestService::Service { +class TestServiceImpl : public ::grpc::testing::EchoTestService::Service { public: explicit TestServiceImpl(gpr_event* ev) : ev_(ev) {} @@ -94,7 +94,7 @@ class ShutdownTest : public ::testing::Test { void ResetStub() { string target = "dns:localhost:" + to_string(port_); channel_ = CreateChannel(target, InsecureChannelCredentials()); - stub_ = grpc::testing::TestService::NewStub(channel_); + stub_ = grpc::testing::EchoTestService::NewStub(channel_); } string to_string(const int number) { @@ -115,7 +115,7 @@ class ShutdownTest : public ::testing::Test { protected: std::shared_ptr<Channel> channel_; - std::unique_ptr<grpc::testing::TestService::Stub> stub_; + std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_; std::unique_ptr<Server> server_; bool shutdown_; int port_; diff --git a/test/cpp/end2end/streaming_throughput_test.cc b/test/cpp/end2end/streaming_throughput_test.cc index ca563472a7..9e82c30701 100644 --- a/test/cpp/end2end/streaming_throughput_test.cc +++ b/test/cpp/end2end/streaming_throughput_test.cc @@ -31,9 +31,9 @@ * */ +#include <time.h> #include <mutex> #include <thread> -#include <time.h> #include <grpc++/channel.h> #include <grpc++/client_context.h> @@ -49,10 +49,10 @@ #include <grpc/support/time.h> #include <gtest/gtest.h> -#include "test/core/util/port.h" -#include "test/core/util/test_config.h" #include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h" #include "src/proto/grpc/testing/echo.grpc.pb.h" +#include "test/core/util/port.h" +#include "test/core/util/test_config.h" using grpc::testing::EchoRequest; using grpc::testing::EchoResponse; @@ -99,7 +99,7 @@ const char* kLargeString = namespace grpc { namespace testing { -class TestServiceImpl : public ::grpc::testing::TestService::Service { +class TestServiceImpl : public ::grpc::testing::EchoTestService::Service { public: static void BidiStream_Sender( ServerReaderWriter<EchoResponse, EchoRequest>* stream, @@ -161,10 +161,10 @@ class End2endTest : public ::testing::Test { void ResetStub() { std::shared_ptr<Channel> channel = CreateChannel(server_address_.str(), InsecureChannelCredentials()); - stub_ = grpc::testing::TestService::NewStub(channel); + stub_ = grpc::testing::EchoTestService::NewStub(channel); } - std::unique_ptr<grpc::testing::TestService::Stub> stub_; + std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_; std::unique_ptr<Server> server_; std::ostringstream server_address_; TestServiceImpl service_; diff --git a/test/cpp/end2end/thread_stress_test.cc b/test/cpp/end2end/thread_stress_test.cc index 8efc645fa3..d2b83ded67 100644 --- a/test/cpp/end2end/thread_stress_test.cc +++ b/test/cpp/end2end/thread_stress_test.cc @@ -34,21 +34,21 @@ #include <mutex> #include <thread> -#include <grpc/grpc.h> -#include <grpc/support/thd.h> -#include <grpc/support/time.h> #include <grpc++/channel.h> #include <grpc++/client_context.h> #include <grpc++/create_channel.h> #include <grpc++/server.h> #include <grpc++/server_builder.h> #include <grpc++/server_context.h> +#include <grpc/grpc.h> +#include <grpc/support/thd.h> +#include <grpc/support/time.h> #include <gtest/gtest.h> -#include "test/core/util/port.h" -#include "test/core/util/test_config.h" #include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h" #include "src/proto/grpc/testing/echo.grpc.pb.h" +#include "test/core/util/port.h" +#include "test/core/util/test_config.h" using grpc::testing::EchoRequest; using grpc::testing::EchoResponse; @@ -74,7 +74,7 @@ void MaybeEchoDeadline(ServerContext* context, const EchoRequest* request, } // namespace -class TestServiceImpl : public ::grpc::testing::TestService::Service { +class TestServiceImpl : public ::grpc::testing::EchoTestService::Service { public: TestServiceImpl() : signal_client_(false) {} @@ -159,7 +159,7 @@ class TestServiceImpl : public ::grpc::testing::TestService::Service { }; class TestServiceImplDupPkg - : public ::grpc::testing::duplicate::TestService::Service { + : public ::grpc::testing::duplicate::EchoTestService::Service { public: Status Echo(ServerContext* context, const EchoRequest* request, EchoResponse* response) GRPC_OVERRIDE { @@ -191,10 +191,10 @@ class End2endTest : public ::testing::Test { void ResetStub() { std::shared_ptr<Channel> channel = CreateChannel(server_address_.str(), InsecureChannelCredentials()); - stub_ = grpc::testing::TestService::NewStub(channel); + stub_ = grpc::testing::EchoTestService::NewStub(channel); } - std::unique_ptr<grpc::testing::TestService::Stub> stub_; + std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_; std::unique_ptr<Server> server_; std::ostringstream server_address_; const int kMaxMessageSize_; @@ -202,7 +202,7 @@ class End2endTest : public ::testing::Test { TestServiceImplDupPkg dup_pkg_service_; }; -static void SendRpc(grpc::testing::TestService::Stub* stub, int num_rpcs) { +static void SendRpc(grpc::testing::EchoTestService::Stub* stub, int num_rpcs) { EchoRequest request; EchoResponse response; request.set_message("Hello"); diff --git a/test/cpp/end2end/zookeeper_test.cc b/test/cpp/end2end/zookeeper_test.cc index 802df6bb94..0040ebf4c7 100644 --- a/test/cpp/end2end/zookeeper_test.cc +++ b/test/cpp/end2end/zookeeper_test.cc @@ -37,15 +37,15 @@ #include <grpc++/server.h> #include <grpc++/server_builder.h> #include <grpc++/server_context.h> -#include <gtest/gtest.h> #include <grpc/grpc.h> #include <grpc/grpc_zookeeper.h> +#include <gtest/gtest.h> #include <zookeeper/zookeeper.h> -#include "test/core/util/test_config.h" -#include "test/core/util/port.h" -#include "src/proto/grpc/testing/echo.grpc.pb.h" #include "src/core/support/env.h" +#include "src/proto/grpc/testing/echo.grpc.pb.h" +#include "test/core/util/port.h" +#include "test/core/util/test_config.h" using grpc::testing::EchoRequest; using grpc::testing::EchoResponse; @@ -53,7 +53,8 @@ using grpc::testing::EchoResponse; namespace grpc { namespace testing { -class ZookeeperTestServiceImpl : public ::grpc::testing::TestService::Service { +class ZookeeperTestServiceImpl + : public ::grpc::testing::EchoTestService::Service { public: Status Echo(ServerContext* context, const EchoRequest* request, EchoResponse* response) GRPC_OVERRIDE { @@ -157,7 +158,7 @@ class ZookeeperTest : public ::testing::Test { void ResetStub() { string target = "zookeeper://" + zookeeper_address_ + "/test"; channel_ = CreateChannel(target, InsecureChannelCredentials()); - stub_ = grpc::testing::TestService::NewStub(channel_); + stub_ = grpc::testing::EchoTestService::NewStub(channel_); } string to_string(const int number) { @@ -167,7 +168,7 @@ class ZookeeperTest : public ::testing::Test { } std::shared_ptr<Channel> channel_; - std::unique_ptr<grpc::testing::TestService::Stub> stub_; + std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_; std::unique_ptr<Server> server1_; std::unique_ptr<Server> server2_; ZookeeperTestServiceImpl service_; diff --git a/test/cpp/util/cli_call.cc b/test/cpp/util/cli_call.cc index 0de388d3ca..5d70f6c26b 100644 --- a/test/cpp/util/cli_call.cc +++ b/test/cpp/util/cli_call.cc @@ -35,13 +35,13 @@ #include <iostream> -#include <grpc/grpc.h> -#include <grpc/support/log.h> -#include <grpc/support/slice.h> -#include <grpc++/support/byte_buffer.h> #include <grpc++/channel.h> #include <grpc++/client_context.h> #include <grpc++/generic/generic_stub.h> +#include <grpc++/support/byte_buffer.h> +#include <grpc/grpc.h> +#include <grpc/support/log.h> +#include <grpc/support/slice.h> namespace grpc { namespace testing { diff --git a/test/cpp/util/cli_call_test.cc b/test/cpp/util/cli_call_test.cc index 94f54616a9..98f02d4b20 100644 --- a/test/cpp/util/cli_call_test.cc +++ b/test/cpp/util/cli_call_test.cc @@ -53,7 +53,7 @@ using grpc::testing::EchoResponse; namespace grpc { namespace testing { -class TestServiceImpl : public ::grpc::testing::TestService::Service { +class TestServiceImpl : public ::grpc::testing::EchoTestService::Service { public: Status Echo(ServerContext* context, const EchoRequest* request, EchoResponse* response) GRPC_OVERRIDE { @@ -91,11 +91,11 @@ class CliCallTest : public ::testing::Test { void ResetStub() { channel_ = CreateChannel(server_address_.str(), InsecureChannelCredentials()); - stub_ = grpc::testing::TestService::NewStub(channel_); + stub_ = grpc::testing::EchoTestService::NewStub(channel_); } std::shared_ptr<Channel> channel_; - std::unique_ptr<grpc::testing::TestService::Stub> stub_; + std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_; std::unique_ptr<Server> server_; std::ostringstream server_address_; TestServiceImpl service_; @@ -115,7 +115,7 @@ TEST_F(CliCallTest, SimpleRpc) { EXPECT_EQ(response.message(), request.message()); EXPECT_TRUE(s.ok()); - const grpc::string kMethod("/grpc.testing.TestService/Echo"); + const grpc::string kMethod("/grpc.testing.EchoTestService/Echo"); grpc::string request_bin, response_bin, expected_response_bin; EXPECT_TRUE(request.SerializeToString(&request_bin)); EXPECT_TRUE(response.SerializeToString(&expected_response_bin)); |