diff options
Diffstat (limited to 'test/cpp/end2end')
-rw-r--r-- | test/cpp/end2end/async_end2end_test.cc | 10 | ||||
-rw-r--r-- | test/cpp/end2end/client_crash_test_server.cc | 9 | ||||
-rw-r--r-- | test/cpp/end2end/end2end_test.cc | 22 | ||||
-rw-r--r-- | test/cpp/end2end/filter_end2end_test.cc | 20 | ||||
-rw-r--r-- | test/cpp/end2end/generic_end2end_test.cc | 4 | ||||
-rw-r--r-- | test/cpp/end2end/hybrid_end2end_test.cc | 28 | ||||
-rw-r--r-- | test/cpp/end2end/mock_test.cc | 62 | ||||
-rw-r--r-- | test/cpp/end2end/proto_server_reflection_test.cc | 2 | ||||
-rw-r--r-- | test/cpp/end2end/round_robin_end2end_test.cc | 211 | ||||
-rw-r--r-- | test/cpp/end2end/server_builder_plugin_test.cc | 29 | ||||
-rw-r--r-- | test/cpp/end2end/server_crash_test.cc | 11 | ||||
-rw-r--r-- | test/cpp/end2end/shutdown_test.cc | 6 | ||||
-rw-r--r-- | test/cpp/end2end/streaming_throughput_test.cc | 10 | ||||
-rw-r--r-- | test/cpp/end2end/test_service_impl.h | 12 | ||||
-rw-r--r-- | test/cpp/end2end/thread_stress_test.cc | 52 |
15 files changed, 348 insertions, 140 deletions
diff --git a/test/cpp/end2end/async_end2end_test.cc b/test/cpp/end2end/async_end2end_test.cc index 823f0bd035..3845582d5d 100644 --- a/test/cpp/end2end/async_end2end_test.cc +++ b/test/cpp/end2end/async_end2end_test.cc @@ -211,10 +211,10 @@ bool plugin_has_sync_methods(std::unique_ptr<ServerBuilderPlugin>& plugin) { // that needs to be tested here. class ServerBuilderSyncPluginDisabler : public ::grpc::ServerBuilderOption { public: - void UpdateArguments(ChannelArguments* arg) GRPC_OVERRIDE {} + void UpdateArguments(ChannelArguments* arg) override {} - void UpdatePlugins(std::vector<std::unique_ptr<ServerBuilderPlugin>>* plugins) - GRPC_OVERRIDE { + void UpdatePlugins( + std::vector<std::unique_ptr<ServerBuilderPlugin>>* plugins) override { plugins->erase(std::remove_if(plugins->begin(), plugins->end(), plugin_has_sync_methods), plugins->end()); @@ -246,7 +246,7 @@ class AsyncEnd2endTest : public ::testing::TestWithParam<TestScenario> { protected: AsyncEnd2endTest() { GetParam().Log(); } - void SetUp() GRPC_OVERRIDE { + void SetUp() override { poll_overrider_.reset(new PollingOverrider(!GetParam().disable_blocking)); port_ = grpc_pick_unused_port_or_die(); @@ -269,7 +269,7 @@ class AsyncEnd2endTest : public ::testing::TestWithParam<TestScenario> { gpr_tls_set(&g_is_async_end2end_test, 1); } - void TearDown() GRPC_OVERRIDE { + void TearDown() override { server_->Shutdown(); void* ignored_tag; bool ignored_ok; diff --git a/test/cpp/end2end/client_crash_test_server.cc b/test/cpp/end2end/client_crash_test_server.cc index 6e1457407c..0e0a105989 100644 --- a/test/cpp/end2end/client_crash_test_server.cc +++ b/test/cpp/end2end/client_crash_test_server.cc @@ -58,11 +58,10 @@ using namespace gflags; namespace grpc { namespace testing { -class ServiceImpl GRPC_FINAL - : public ::grpc::testing::EchoTestService::Service { - Status BidiStream(ServerContext* context, - ServerReaderWriter<EchoResponse, EchoRequest>* stream) - GRPC_OVERRIDE { +class ServiceImpl final : public ::grpc::testing::EchoTestService::Service { + Status BidiStream( + ServerContext* context, + ServerReaderWriter<EchoResponse, EchoRequest>* stream) override { EchoRequest request; EchoResponse response; while (stream->Read(&request)) { diff --git a/test/cpp/end2end/end2end_test.cc b/test/cpp/end2end/end2end_test.cc index 43b7d44255..4b8749884f 100644 --- a/test/cpp/end2end/end2end_test.cc +++ b/test/cpp/end2end/end2end_test.cc @@ -92,12 +92,12 @@ class TestMetadataCredentialsPlugin : public MetadataCredentialsPlugin { is_blocking_(is_blocking), is_successful_(is_successful) {} - bool IsBlocking() const GRPC_OVERRIDE { return is_blocking_; } + bool IsBlocking() const override { return is_blocking_; } - Status GetMetadata(grpc::string_ref service_url, grpc::string_ref method_name, - const grpc::AuthContext& channel_auth_context, - std::multimap<grpc::string, grpc::string>* metadata) - GRPC_OVERRIDE { + Status GetMetadata( + grpc::string_ref service_url, grpc::string_ref method_name, + const grpc::AuthContext& channel_auth_context, + std::multimap<grpc::string, grpc::string>* metadata) override { EXPECT_GT(service_url.length(), 0UL); EXPECT_GT(method_name.length(), 0UL); EXPECT_TRUE(channel_auth_context.IsPeerAuthenticated()); @@ -145,11 +145,11 @@ class TestAuthMetadataProcessor : public AuthMetadataProcessor { } // Interface implementation - bool IsBlocking() const GRPC_OVERRIDE { return is_blocking_; } + bool IsBlocking() const override { return is_blocking_; } Status Process(const InputMetadata& auth_metadata, AuthContext* context, OutputMetadata* consumed_auth_metadata, - OutputMetadata* response_metadata) GRPC_OVERRIDE { + OutputMetadata* response_metadata) override { EXPECT_TRUE(consumed_auth_metadata != nullptr); EXPECT_TRUE(context != nullptr); EXPECT_TRUE(response_metadata != nullptr); @@ -185,7 +185,7 @@ class Proxy : public ::grpc::testing::EchoTestService::Service { : stub_(grpc::testing::EchoTestService::NewStub(channel)) {} Status Echo(ServerContext* server_context, const EchoRequest* request, - EchoResponse* response) GRPC_OVERRIDE { + EchoResponse* response) override { std::unique_ptr<ClientContext> client_context = ClientContext::FromServerContext(*server_context); return stub_->Echo(client_context.get(), *request, response); @@ -199,7 +199,7 @@ class TestServiceImplDupPkg : public ::grpc::testing::duplicate::EchoTestService::Service { public: Status Echo(ServerContext* context, const EchoRequest* request, - EchoResponse* response) GRPC_OVERRIDE { + EchoResponse* response) override { response->set_message("no package"); return Status::OK; } @@ -229,7 +229,7 @@ class End2endTest : public ::testing::TestWithParam<TestScenario> { GetParam().Log(); } - void TearDown() GRPC_OVERRIDE { + void TearDown() override { if (is_server_started_) { server_->Shutdown(); if (proxy_server_) proxy_server_->Shutdown(); @@ -1496,7 +1496,7 @@ class ResourceQuotaEnd2endTest : public End2endTest { ResourceQuotaEnd2endTest() : server_resource_quota_("server_resource_quota") {} - virtual void ConfigureServerBuilder(ServerBuilder* builder) GRPC_OVERRIDE { + virtual void ConfigureServerBuilder(ServerBuilder* builder) override { builder->SetResourceQuota(server_resource_quota_); } diff --git a/test/cpp/end2end/filter_end2end_test.cc b/test/cpp/end2end/filter_end2end_test.cc index 853720fd0d..ab6ed46de5 100644 --- a/test/cpp/end2end/filter_end2end_test.cc +++ b/test/cpp/end2end/filter_end2end_test.cc @@ -78,35 +78,35 @@ namespace { int global_num_connections = 0; int global_num_calls = 0; -mutex global_mu; +std::mutex global_mu; void IncrementConnectionCounter() { - unique_lock<mutex> lock(global_mu); + std::unique_lock<std::mutex> lock(global_mu); ++global_num_connections; } void ResetConnectionCounter() { - unique_lock<mutex> lock(global_mu); + std::unique_lock<std::mutex> lock(global_mu); global_num_connections = 0; } int GetConnectionCounterValue() { - unique_lock<mutex> lock(global_mu); + std::unique_lock<std::mutex> lock(global_mu); return global_num_connections; } void IncrementCallCounter() { - unique_lock<mutex> lock(global_mu); + std::unique_lock<std::mutex> lock(global_mu); ++global_num_calls; } void ResetCallCounter() { - unique_lock<mutex> lock(global_mu); + std::unique_lock<std::mutex> lock(global_mu); global_num_calls = 0; } int GetCallCounterValue() { - unique_lock<mutex> lock(global_mu); + std::unique_lock<std::mutex> lock(global_mu); return global_num_calls; } @@ -126,7 +126,7 @@ class CallDataImpl : public CallData { : CallData(channel_data) {} void StartTransportStreamOp(grpc_exec_ctx* exec_ctx, grpc_call_element* elem, - TransportStreamOp* op) GRPC_OVERRIDE { + TransportStreamOp* op) override { // Incrementing the counter could be done from the ctor, but we want // to test that the individual methods are actually called correctly. if (op->recv_initial_metadata() != nullptr) IncrementCallCounter(); @@ -138,7 +138,7 @@ class FilterEnd2endTest : public ::testing::Test { protected: FilterEnd2endTest() : server_host_("localhost") {} - void SetUp() GRPC_OVERRIDE { + void SetUp() override { int port = grpc_pick_unused_port_or_die(); server_address_ << server_host_ << ":" << port; // Setup server @@ -150,7 +150,7 @@ class FilterEnd2endTest : public ::testing::Test { server_ = builder.BuildAndStart(); } - void TearDown() GRPC_OVERRIDE { + void TearDown() override { server_->Shutdown(); void* ignored_tag; bool ignored_ok; diff --git a/test/cpp/end2end/generic_end2end_test.cc b/test/cpp/end2end/generic_end2end_test.cc index 57efa5fa17..25c221bb2b 100644 --- a/test/cpp/end2end/generic_end2end_test.cc +++ b/test/cpp/end2end/generic_end2end_test.cc @@ -75,7 +75,7 @@ class GenericEnd2endTest : public ::testing::Test { protected: GenericEnd2endTest() : server_host_("localhost") {} - void SetUp() GRPC_OVERRIDE { + void SetUp() override { int port = grpc_pick_unused_port_or_die(); server_address_ << server_host_ << ":" << port; // Setup server @@ -91,7 +91,7 @@ class GenericEnd2endTest : public ::testing::Test { server_ = builder.BuildAndStart(); } - void TearDown() GRPC_OVERRIDE { + void TearDown() override { server_->Shutdown(); void* ignored_tag; bool ignored_ok; diff --git a/test/cpp/end2end/hybrid_end2end_test.cc b/test/cpp/end2end/hybrid_end2end_test.cc index 76a5732f33..a4ba76fed1 100644 --- a/test/cpp/end2end/hybrid_end2end_test.cc +++ b/test/cpp/end2end/hybrid_end2end_test.cc @@ -188,7 +188,7 @@ class TestServiceImplDupPkg : public ::grpc::testing::duplicate::EchoTestService::Service { public: Status Echo(ServerContext* context, const EchoRequest* request, - EchoResponse* response) GRPC_OVERRIDE { + EchoResponse* response) override { response->set_message(request->message() + "_dup"); return Status::OK; } @@ -230,7 +230,7 @@ class HybridEnd2endTest : public ::testing::Test { server_ = builder.BuildAndStart(); } - void TearDown() GRPC_OVERRIDE { + void TearDown() override { if (server_) { server_->Shutdown(); } @@ -449,9 +449,9 @@ class StreamedUnaryDupPkg : public duplicate::EchoTestService::WithStreamedUnaryMethod_Echo< TestServiceImplDupPkg> { public: - Status StreamedEcho(ServerContext* context, - ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) - GRPC_OVERRIDE { + Status StreamedEcho( + ServerContext* context, + ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) override { EchoRequest req; EchoResponse resp; uint32_t next_msg_sz; @@ -487,9 +487,9 @@ TEST_F(HybridEnd2endTest, class FullyStreamedUnaryDupPkg : public duplicate::EchoTestService::StreamedUnaryService { public: - Status StreamedEcho(ServerContext* context, - ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) - GRPC_OVERRIDE { + Status StreamedEcho( + ServerContext* context, + ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) override { EchoRequest req; EchoResponse resp; uint32_t next_msg_sz; @@ -528,7 +528,7 @@ class SplitResponseStreamDupPkg public: Status StreamedResponseStream( ServerContext* context, - ServerSplitStreamer<EchoRequest, EchoResponse>* stream) GRPC_OVERRIDE { + ServerSplitStreamer<EchoRequest, EchoResponse>* stream) override { EchoRequest req; EchoResponse resp; uint32_t next_msg_sz; @@ -568,7 +568,7 @@ class FullySplitStreamedDupPkg public: Status StreamedResponseStream( ServerContext* context, - ServerSplitStreamer<EchoRequest, EchoResponse>* stream) GRPC_OVERRIDE { + ServerSplitStreamer<EchoRequest, EchoResponse>* stream) override { EchoRequest req; EchoResponse resp; uint32_t next_msg_sz; @@ -605,9 +605,9 @@ TEST_F(HybridEnd2endTest, // Add a second service that is fully server streamed class FullyStreamedDupPkg : public duplicate::EchoTestService::StreamedService { public: - Status StreamedEcho(ServerContext* context, - ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) - GRPC_OVERRIDE { + Status StreamedEcho( + ServerContext* context, + ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) override { EchoRequest req; EchoResponse resp; uint32_t next_msg_sz; @@ -620,7 +620,7 @@ class FullyStreamedDupPkg : public duplicate::EchoTestService::StreamedService { } Status StreamedResponseStream( ServerContext* context, - ServerSplitStreamer<EchoRequest, EchoResponse>* stream) GRPC_OVERRIDE { + ServerSplitStreamer<EchoRequest, EchoResponse>* stream) override { EchoRequest req; EchoResponse resp; uint32_t next_msg_sz; diff --git a/test/cpp/end2end/mock_test.cc b/test/cpp/end2end/mock_test.cc index 0da5861b67..d6664da5a0 100644 --- a/test/cpp/end2end/mock_test.cc +++ b/test/cpp/end2end/mock_test.cc @@ -61,46 +61,44 @@ namespace testing { namespace { template <class W, class R> -class MockClientReaderWriter GRPC_FINAL - : public ClientReaderWriterInterface<W, R> { +class MockClientReaderWriter final : public ClientReaderWriterInterface<W, R> { public: - void WaitForInitialMetadata() GRPC_OVERRIDE {} - bool NextMessageSize(uint32_t* sz) GRPC_OVERRIDE { + void WaitForInitialMetadata() override {} + bool NextMessageSize(uint32_t* sz) override { *sz = UINT_MAX; return true; } - bool Read(R* msg) GRPC_OVERRIDE { return true; } - bool Write(const W& msg) GRPC_OVERRIDE { return true; } - bool WritesDone() GRPC_OVERRIDE { return true; } - Status Finish() GRPC_OVERRIDE { return Status::OK; } + bool Read(R* msg) override { return true; } + bool Write(const W& msg) override { return true; } + bool WritesDone() override { return true; } + Status Finish() override { return Status::OK; } }; template <> -class MockClientReaderWriter<EchoRequest, EchoResponse> GRPC_FINAL +class MockClientReaderWriter<EchoRequest, EchoResponse> final : public ClientReaderWriterInterface<EchoRequest, EchoResponse> { public: MockClientReaderWriter() : writes_done_(false) {} - void WaitForInitialMetadata() GRPC_OVERRIDE {} - bool NextMessageSize(uint32_t* sz) GRPC_OVERRIDE { + void WaitForInitialMetadata() override {} + bool NextMessageSize(uint32_t* sz) override { *sz = UINT_MAX; return true; } - bool Read(EchoResponse* msg) GRPC_OVERRIDE { + bool Read(EchoResponse* msg) override { if (writes_done_) return false; msg->set_message(last_message_); return true; } - bool Write(const EchoRequest& msg, - const WriteOptions& options) GRPC_OVERRIDE { + bool Write(const EchoRequest& msg, const WriteOptions& options) override { gpr_log(GPR_INFO, "mock recv msg %s", msg.message().c_str()); last_message_ = msg.message(); return true; } - bool WritesDone() GRPC_OVERRIDE { + bool WritesDone() override { writes_done_ = true; return true; } - Status Finish() GRPC_OVERRIDE { return Status::OK; } + Status Finish() override { return Status::OK; } private: bool writes_done_; @@ -113,51 +111,51 @@ class MockStub : public EchoTestService::StubInterface { MockStub() {} ~MockStub() {} Status Echo(ClientContext* context, const EchoRequest& request, - EchoResponse* response) GRPC_OVERRIDE { + EchoResponse* response) override { response->set_message(request.message()); return Status::OK; } Status Unimplemented(ClientContext* context, const EchoRequest& request, - EchoResponse* response) GRPC_OVERRIDE { + EchoResponse* response) override { return Status::OK; } private: ClientAsyncResponseReaderInterface<EchoResponse>* AsyncEchoRaw( ClientContext* context, const EchoRequest& request, - CompletionQueue* cq) GRPC_OVERRIDE { + CompletionQueue* cq) override { return nullptr; } ClientWriterInterface<EchoRequest>* RequestStreamRaw( - ClientContext* context, EchoResponse* response) GRPC_OVERRIDE { + ClientContext* context, EchoResponse* response) override { return nullptr; } ClientAsyncWriterInterface<EchoRequest>* AsyncRequestStreamRaw( ClientContext* context, EchoResponse* response, CompletionQueue* cq, - void* tag) GRPC_OVERRIDE { + void* tag) override { return nullptr; } ClientReaderInterface<EchoResponse>* ResponseStreamRaw( - ClientContext* context, const EchoRequest& request) GRPC_OVERRIDE { + ClientContext* context, const EchoRequest& request) override { return nullptr; } ClientAsyncReaderInterface<EchoResponse>* AsyncResponseStreamRaw( ClientContext* context, const EchoRequest& request, CompletionQueue* cq, - void* tag) GRPC_OVERRIDE { + void* tag) override { return nullptr; } ClientReaderWriterInterface<EchoRequest, EchoResponse>* BidiStreamRaw( - ClientContext* context) GRPC_OVERRIDE { + ClientContext* context) override { return new MockClientReaderWriter<EchoRequest, EchoResponse>(); } ClientAsyncReaderWriterInterface<EchoRequest, EchoResponse>* AsyncBidiStreamRaw(ClientContext* context, CompletionQueue* cq, - void* tag) GRPC_OVERRIDE { + void* tag) override { return nullptr; } ClientAsyncResponseReaderInterface<EchoResponse>* AsyncUnimplementedRaw( ClientContext* context, const EchoRequest& request, - CompletionQueue* cq) GRPC_OVERRIDE { + CompletionQueue* cq) override { return nullptr; } }; @@ -216,14 +214,14 @@ class FakeClient { class TestServiceImpl : public EchoTestService::Service { public: Status Echo(ServerContext* context, const EchoRequest* request, - EchoResponse* response) GRPC_OVERRIDE { + EchoResponse* response) override { response->set_message(request->message()); return Status::OK; } - Status BidiStream(ServerContext* context, - ServerReaderWriter<EchoResponse, EchoRequest>* stream) - GRPC_OVERRIDE { + Status BidiStream( + ServerContext* context, + ServerReaderWriter<EchoResponse, EchoRequest>* stream) override { EchoRequest request; EchoResponse response; while (stream->Read(&request)) { @@ -239,7 +237,7 @@ class MockTest : public ::testing::Test { protected: MockTest() {} - void SetUp() GRPC_OVERRIDE { + void SetUp() override { int port = grpc_pick_unused_port_or_die(); server_address_ << "localhost:" << port; // Setup server @@ -250,7 +248,7 @@ class MockTest : public ::testing::Test { server_ = builder.BuildAndStart(); } - void TearDown() GRPC_OVERRIDE { server_->Shutdown(); } + void TearDown() override { server_->Shutdown(); } void ResetStub() { std::shared_ptr<Channel> channel = diff --git a/test/cpp/end2end/proto_server_reflection_test.cc b/test/cpp/end2end/proto_server_reflection_test.cc index 75efd01f06..8b9688d200 100644 --- a/test/cpp/end2end/proto_server_reflection_test.cc +++ b/test/cpp/end2end/proto_server_reflection_test.cc @@ -56,7 +56,7 @@ class ProtoServerReflectionTest : public ::testing::Test { public: ProtoServerReflectionTest() {} - void SetUp() GRPC_OVERRIDE { + void SetUp() override { port_ = grpc_pick_unused_port_or_die(); ref_desc_pool_ = protobuf::DescriptorPool::generated_pool(); diff --git a/test/cpp/end2end/round_robin_end2end_test.cc b/test/cpp/end2end/round_robin_end2end_test.cc new file mode 100644 index 0000000000..76211cbdd3 --- /dev/null +++ b/test/cpp/end2end/round_robin_end2end_test.cc @@ -0,0 +1,211 @@ +/* + * + * Copyright 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 <mutex> +#include <thread> + +#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/grpc.h> +#include <grpc/support/log.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 "test/cpp/end2end/test_service_impl.h" + +using grpc::testing::EchoRequest; +using grpc::testing::EchoResponse; +using std::chrono::system_clock; + +namespace grpc { +namespace testing { +namespace { + +// Subclass of TestServiceImpl that increments a request counter for +// every call to the Echo RPC. +class MyTestServiceImpl : public TestServiceImpl { + public: + MyTestServiceImpl() : request_count_(0) {} + + Status Echo(ServerContext* context, const EchoRequest* request, + EchoResponse* response) override { + { + std::unique_lock<std::mutex> lock(mu_); + ++request_count_; + } + return TestServiceImpl::Echo(context, request, response); + } + + int request_count() { + std::unique_lock<std::mutex> lock(mu_); + return request_count_; + } + + private: + std::mutex mu_; + int request_count_; +}; + +class RoundRobinEnd2endTest : public ::testing::Test { + protected: + RoundRobinEnd2endTest() : server_host_("localhost") {} + + void StartServers(int num_servers) { + for (int i = 0; i < num_servers; ++i) { + servers_.emplace_back(new ServerData(server_host_)); + } + } + + void TearDown() override { + for (size_t i = 0; i < servers_.size(); ++i) { + servers_[i]->Shutdown(); + } + } + + void ResetStub(bool round_robin) { + ChannelArguments args; + if (round_robin) args.SetLoadBalancingPolicyName("round_robin"); + std::ostringstream uri; + uri << "ipv4:///"; + for (size_t i = 0; i < servers_.size() - 1; ++i) { + uri << "127.0.0.1:" << servers_[i]->port_ << ","; + } + uri << "127.0.0.1:" << servers_[servers_.size() - 1]->port_; + std::shared_ptr<Channel> channel = + CreateCustomChannel(uri.str(), InsecureChannelCredentials(), args); + stub_ = grpc::testing::EchoTestService::NewStub(channel); + } + + void SendRpc(int num_rpcs) { + EchoRequest request; + EchoResponse response; + request.set_message("Live long and prosper."); + for (int i = 0; i < num_rpcs; i++) { + ClientContext context; + Status status = stub_->Echo(&context, request, &response); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(response.message(), request.message()); + } + } + + struct ServerData { + int port_; + std::unique_ptr<Server> server_; + MyTestServiceImpl service_; + std::unique_ptr<std::thread> thread_; + + explicit ServerData(const grpc::string& server_host) { + port_ = grpc_pick_unused_port_or_die(); + gpr_log(GPR_INFO, "starting server on port %d", port_); + std::mutex mu; + std::condition_variable cond; + thread_.reset(new std::thread( + std::bind(&ServerData::Start, this, server_host, &mu, &cond))); + std::unique_lock<std::mutex> lock(mu); + cond.wait(lock); + gpr_log(GPR_INFO, "server startup complete"); + } + + void Start(const grpc::string& server_host, std::mutex* mu, + std::condition_variable* cond) { + std::ostringstream server_address; + server_address << server_host << ":" << port_; + ServerBuilder builder; + builder.AddListeningPort(server_address.str(), + InsecureServerCredentials()); + builder.RegisterService(&service_); + server_ = builder.BuildAndStart(); + std::lock_guard<std::mutex> lock(*mu); + cond->notify_one(); + } + + void Shutdown() { + server_->Shutdown(); + thread_->join(); + } + }; + + const grpc::string server_host_; + CompletionQueue cli_cq_; + std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_; + std::vector<std::unique_ptr<ServerData>> servers_; +}; + +TEST_F(RoundRobinEnd2endTest, PickFirst) { + // Start servers and send one RPC per server. + const int kNumServers = 3; + StartServers(kNumServers); + ResetStub(false /* round_robin */); + SendRpc(kNumServers); + // All requests should have gone to a single server. + bool found = false; + for (size_t i = 0; i < servers_.size(); ++i) { + const int request_count = servers_[i]->service_.request_count(); + if (request_count == kNumServers) { + found = true; + } else { + EXPECT_EQ(0, request_count); + } + } + EXPECT_TRUE(found); +} + +TEST_F(RoundRobinEnd2endTest, RoundRobin) { + // Start servers and send one RPC per server. + const int kNumServers = 3; + StartServers(kNumServers); + ResetStub(true /* round_robin */); + SendRpc(kNumServers); + // One request should have gone to each server. + for (size_t i = 0; i < servers_.size(); ++i) { + EXPECT_EQ(1, servers_[i]->service_.request_count()); + } +} + +} // 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/server_builder_plugin_test.cc b/test/cpp/end2end/server_builder_plugin_test.cc index b967a5d1e9..1b6f4ce37d 100644 --- a/test/cpp/end2end/server_builder_plugin_test.cc +++ b/test/cpp/end2end/server_builder_plugin_test.cc @@ -31,13 +31,14 @@ * */ +#include <thread> + #include <grpc++/channel.h> #include <grpc++/client_context.h> #include <grpc++/create_channel.h> #include <grpc++/impl/server_builder_option.h> #include <grpc++/impl/server_builder_plugin.h> #include <grpc++/impl/server_initializer.h> -#include <grpc++/impl/thd.h> #include <grpc++/security/credentials.h> #include <grpc++/security/server_credentials.h> #include <grpc++/server.h> @@ -65,29 +66,29 @@ class TestServerBuilderPlugin : public ServerBuilderPlugin { register_service_ = false; } - grpc::string name() GRPC_OVERRIDE { return PLUGIN_NAME; } + grpc::string name() override { return PLUGIN_NAME; } - void InitServer(ServerInitializer* si) GRPC_OVERRIDE { + void InitServer(ServerInitializer* si) override { init_server_is_called_ = true; if (register_service_) { si->RegisterService(service_); } } - void Finish(ServerInitializer* si) GRPC_OVERRIDE { finish_is_called_ = true; } + void Finish(ServerInitializer* si) override { finish_is_called_ = true; } - void ChangeArguments(const grpc::string& name, void* value) GRPC_OVERRIDE { + void ChangeArguments(const grpc::string& name, void* value) override { change_arguments_is_called_ = true; } - bool has_async_methods() const GRPC_OVERRIDE { + bool has_async_methods() const override { if (register_service_) { return service_->has_async_methods(); } return false; } - bool has_sync_methods() const GRPC_OVERRIDE { + bool has_sync_methods() const override { if (register_service_) { return service_->has_synchronous_methods(); } @@ -112,10 +113,10 @@ class InsertPluginServerBuilderOption : public ServerBuilderOption { public: InsertPluginServerBuilderOption() { register_service_ = false; } - void UpdateArguments(ChannelArguments* arg) GRPC_OVERRIDE {} + void UpdateArguments(ChannelArguments* arg) override {} - void UpdatePlugins(std::vector<std::unique_ptr<ServerBuilderPlugin>>* plugins) - GRPC_OVERRIDE { + void UpdatePlugins( + std::vector<std::unique_ptr<ServerBuilderPlugin>>* plugins) override { plugins->clear(); std::unique_ptr<TestServerBuilderPlugin> plugin( @@ -154,7 +155,7 @@ class ServerBuilderPluginTest : public ::testing::TestWithParam<bool> { public: ServerBuilderPluginTest() {} - void SetUp() GRPC_OVERRIDE { + void SetUp() override { port_ = grpc_pick_unused_port_or_die(); builder_.reset(new ServerBuilder()); } @@ -191,7 +192,7 @@ class ServerBuilderPluginTest : public ::testing::TestWithParam<bool> { // we run some tests without a service, and for those we need to supply a // frequently polled completion queue cq_ = builder_->AddCompletionQueue(); - cq_thread_ = new grpc::thread(&ServerBuilderPluginTest::RunCQ, this); + cq_thread_ = new std::thread(&ServerBuilderPluginTest::RunCQ, this); server_ = builder_->BuildAndStart(); EXPECT_TRUE(CheckPresent()); } @@ -202,7 +203,7 @@ class ServerBuilderPluginTest : public ::testing::TestWithParam<bool> { stub_ = grpc::testing::EchoTestService::NewStub(channel_); } - void TearDown() GRPC_OVERRIDE { + void TearDown() override { auto plugin = CheckPresent(); EXPECT_TRUE(plugin); EXPECT_TRUE(plugin->init_server_is_called()); @@ -225,7 +226,7 @@ class ServerBuilderPluginTest : public ::testing::TestWithParam<bool> { std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_; std::unique_ptr<ServerCompletionQueue> cq_; std::unique_ptr<Server> server_; - grpc::thread* cq_thread_; + std::thread* cq_thread_; TestServiceImpl service_; int port_; diff --git a/test/cpp/end2end/server_crash_test.cc b/test/cpp/end2end/server_crash_test.cc index 16a5fa2322..8cee1403dc 100644 --- a/test/cpp/end2end/server_crash_test.cc +++ b/test/cpp/end2end/server_crash_test.cc @@ -60,14 +60,13 @@ namespace testing { namespace { -class ServiceImpl GRPC_FINAL - : public ::grpc::testing::EchoTestService::Service { +class ServiceImpl final : public ::grpc::testing::EchoTestService::Service { public: ServiceImpl() : bidi_stream_count_(0), response_stream_count_(0) {} - Status BidiStream(ServerContext* context, - ServerReaderWriter<EchoResponse, EchoRequest>* stream) - GRPC_OVERRIDE { + Status BidiStream( + ServerContext* context, + ServerReaderWriter<EchoResponse, EchoRequest>* stream) override { bidi_stream_count_++; EchoRequest request; EchoResponse response; @@ -82,7 +81,7 @@ class ServiceImpl GRPC_FINAL } Status ResponseStream(ServerContext* context, const EchoRequest* request, - ServerWriter<EchoResponse>* writer) GRPC_OVERRIDE { + ServerWriter<EchoResponse>* writer) override { EchoResponse response; response_stream_count_++; for (int i = 0;; i++) { diff --git a/test/cpp/end2end/shutdown_test.cc b/test/cpp/end2end/shutdown_test.cc index 4cba3b1c81..5b52b1fc1a 100644 --- a/test/cpp/end2end/shutdown_test.cc +++ b/test/cpp/end2end/shutdown_test.cc @@ -61,7 +61,7 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service { explicit TestServiceImpl(gpr_event* ev) : ev_(ev) {} Status Echo(ServerContext* context, const EchoRequest* request, - EchoResponse* response) GRPC_OVERRIDE { + EchoResponse* response) override { gpr_event_set(ev_, (void*)1); while (!context->IsCancelled()) { } @@ -76,7 +76,7 @@ class ShutdownTest : public ::testing::Test { public: ShutdownTest() : shutdown_(false), service_(&ev_) { gpr_event_init(&ev_); } - void SetUp() GRPC_OVERRIDE { + void SetUp() override { port_ = grpc_pick_unused_port_or_die(); server_ = SetUpServer(port_); } @@ -91,7 +91,7 @@ class ShutdownTest : public ::testing::Test { return server; } - void TearDown() GRPC_OVERRIDE { GPR_ASSERT(shutdown_); } + void TearDown() override { GPR_ASSERT(shutdown_); } void ResetStub() { string target = "dns:localhost:" + to_string(port_); diff --git a/test/cpp/end2end/streaming_throughput_test.cc b/test/cpp/end2end/streaming_throughput_test.cc index fbef761ca9..302583766b 100644 --- a/test/cpp/end2end/streaming_throughput_test.cc +++ b/test/cpp/end2end/streaming_throughput_test.cc @@ -121,9 +121,9 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service { } // Only implement the one method we will be calling for brevity. - Status BidiStream(ServerContext* context, - ServerReaderWriter<EchoResponse, EchoRequest>* stream) - GRPC_OVERRIDE { + Status BidiStream( + ServerContext* context, + ServerReaderWriter<EchoResponse, EchoRequest>* stream) override { EchoRequest request; gpr_atm should_exit; gpr_atm_rel_store(&should_exit, static_cast<gpr_atm>(0)); @@ -147,7 +147,7 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service { class End2endTest : public ::testing::Test { protected: - void SetUp() GRPC_OVERRIDE { + void SetUp() override { int port = grpc_pick_unused_port_or_die(); server_address_ << "localhost:" << port; // Setup server @@ -158,7 +158,7 @@ class End2endTest : public ::testing::Test { server_ = builder.BuildAndStart(); } - void TearDown() GRPC_OVERRIDE { server_->Shutdown(); } + void TearDown() override { server_->Shutdown(); } void ResetStub() { std::shared_ptr<Channel> channel = diff --git a/test/cpp/end2end/test_service_impl.h b/test/cpp/end2end/test_service_impl.h index c89f88c900..88e0be7bca 100644 --- a/test/cpp/end2end/test_service_impl.h +++ b/test/cpp/end2end/test_service_impl.h @@ -63,20 +63,20 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service { : signal_client_(false), host_(new grpc::string(host)) {} Status Echo(ServerContext* context, const EchoRequest* request, - EchoResponse* response) GRPC_OVERRIDE; + EchoResponse* response) override; // Unimplemented is left unimplemented to test the returned error. Status RequestStream(ServerContext* context, ServerReader<EchoRequest>* reader, - EchoResponse* response) GRPC_OVERRIDE; + EchoResponse* response) override; Status ResponseStream(ServerContext* context, const EchoRequest* request, - ServerWriter<EchoResponse>* writer) GRPC_OVERRIDE; + ServerWriter<EchoResponse>* writer) override; - Status BidiStream(ServerContext* context, - ServerReaderWriter<EchoResponse, EchoRequest>* stream) - GRPC_OVERRIDE; + Status BidiStream( + ServerContext* context, + ServerReaderWriter<EchoResponse, EchoRequest>* stream) override; bool signal_client() { std::unique_lock<std::mutex> lock(mu_); diff --git a/test/cpp/end2end/thread_stress_test.cc b/test/cpp/end2end/thread_stress_test.cc index 0b9d4cda9f..fe5a219eed 100644 --- a/test/cpp/end2end/thread_stress_test.cc +++ b/test/cpp/end2end/thread_stress_test.cc @@ -86,12 +86,12 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service { TestServiceImpl() : signal_client_(false) {} Status Echo(ServerContext* context, const EchoRequest* request, - EchoResponse* response) GRPC_OVERRIDE { + EchoResponse* response) override { response->set_message(request->message()); MaybeEchoDeadline(context, request, response); if (request->has_param() && request->param().client_cancel_after_us()) { { - unique_lock<mutex> lock(mu_); + std::unique_lock<std::mutex> lock(mu_); signal_client_ = true; } while (!context->IsCancelled()) { @@ -118,7 +118,7 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service { Status RequestStream(ServerContext* context, ServerReader<EchoRequest>* reader, - EchoResponse* response) GRPC_OVERRIDE { + EchoResponse* response) override { EchoRequest request; response->set_message(""); while (reader->Read(&request)) { @@ -130,7 +130,7 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service { // Return 3 messages. // TODO(yangg) make it generic by adding a parameter into EchoRequest Status ResponseStream(ServerContext* context, const EchoRequest* request, - ServerWriter<EchoResponse>* writer) GRPC_OVERRIDE { + ServerWriter<EchoResponse>* writer) override { EchoResponse response; response.set_message(request->message() + "0"); writer->Write(response); @@ -142,9 +142,9 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service { return Status::OK; } - Status BidiStream(ServerContext* context, - ServerReaderWriter<EchoResponse, EchoRequest>* stream) - GRPC_OVERRIDE { + Status BidiStream( + ServerContext* context, + ServerReaderWriter<EchoResponse, EchoRequest>* stream) override { EchoRequest request; EchoResponse response; while (stream->Read(&request)) { @@ -156,20 +156,20 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service { } bool signal_client() { - unique_lock<mutex> lock(mu_); + std::unique_lock<std::mutex> lock(mu_); return signal_client_; } private: bool signal_client_; - mutex mu_; + std::mutex mu_; }; class TestServiceImplDupPkg : public ::grpc::testing::duplicate::EchoTestService::Service { public: Status Echo(ServerContext* context, const EchoRequest* request, - EchoResponse* response) GRPC_OVERRIDE { + EchoResponse* response) override { response->set_message("no package"); return Status::OK; } @@ -215,12 +215,12 @@ class CommonStressTest { class CommonStressTestSyncServer : public CommonStressTest<TestServiceImpl> { public: - void SetUp() GRPC_OVERRIDE { + void SetUp() override { ServerBuilder builder; SetUpStart(&builder, &service_); SetUpEnd(&builder); } - void TearDown() GRPC_OVERRIDE { + void TearDown() override { TearDownStart(); TearDownEnd(); } @@ -232,7 +232,7 @@ class CommonStressTestSyncServer : public CommonStressTest<TestServiceImpl> { class CommonStressTestAsyncServer : public CommonStressTest<grpc::testing::EchoTestService::AsyncService> { public: - void SetUp() GRPC_OVERRIDE { + void SetUp() override { shutting_down_ = false; ServerBuilder builder; SetUpStart(&builder, &service_); @@ -247,9 +247,9 @@ class CommonStressTestAsyncServer new std::thread(&CommonStressTestAsyncServer::ProcessRpcs, this)); } } - void TearDown() GRPC_OVERRIDE { + void TearDown() override { { - unique_lock<mutex> l(mu_); + std::unique_lock<std::mutex> l(mu_); TearDownStart(); shutting_down_ = true; cq_->Shutdown(); @@ -292,7 +292,7 @@ class CommonStressTestAsyncServer } } void RefreshContext(int i) { - unique_lock<mutex> l(mu_); + std::unique_lock<std::mutex> l(mu_); if (!shutting_down_) { contexts_[i].state = Context::READY; contexts_[i].srv_ctx.reset(new ServerContext); @@ -315,7 +315,7 @@ class CommonStressTestAsyncServer ::grpc::testing::EchoTestService::AsyncService service_; std::unique_ptr<ServerCompletionQueue> cq_; bool shutting_down_; - mutex mu_; + std::mutex mu_; std::vector<std::thread*> server_threads_; }; @@ -323,8 +323,8 @@ template <class Common> class End2endTest : public ::testing::Test { protected: End2endTest() {} - void SetUp() GRPC_OVERRIDE { common_.SetUp(); } - void TearDown() GRPC_OVERRIDE { common_.TearDown(); } + void SetUp() override { common_.SetUp(); } + void TearDown() override { common_.TearDown(); } void ResetStub() { common_.ResetStub(); } Common common_; @@ -369,8 +369,8 @@ class AsyncClientEnd2endTest : public ::testing::Test { protected: AsyncClientEnd2endTest() : rpcs_outstanding_(0) {} - void SetUp() GRPC_OVERRIDE { common_.SetUp(); } - void TearDown() GRPC_OVERRIDE { + void SetUp() override { common_.SetUp(); } + void TearDown() override { void* ignored_tag; bool ignored_ok; while (cq_.Next(&ignored_tag, &ignored_ok)) @@ -379,7 +379,7 @@ class AsyncClientEnd2endTest : public ::testing::Test { } void Wait() { - unique_lock<mutex> l(mu_); + std::unique_lock<std::mutex> l(mu_); while (rpcs_outstanding_ != 0) { cv_.wait(l); } @@ -404,7 +404,7 @@ class AsyncClientEnd2endTest : public ::testing::Test { call->response_reader->Finish(&call->response, &call->status, (void*)call); - unique_lock<mutex> l(mu_); + std::unique_lock<std::mutex> l(mu_); rpcs_outstanding_++; } } @@ -422,7 +422,7 @@ class AsyncClientEnd2endTest : public ::testing::Test { bool notify; { - unique_lock<mutex> l(mu_); + std::unique_lock<std::mutex> l(mu_); rpcs_outstanding_--; notify = (rpcs_outstanding_ == 0); } @@ -434,8 +434,8 @@ class AsyncClientEnd2endTest : public ::testing::Test { Common common_; CompletionQueue cq_; - mutex mu_; - condition_variable cv_; + std::mutex mu_; + std::condition_variable cv_; int rpcs_outstanding_; }; |