diff options
| author |  Alistair Veitch <aveitch@google.com> | 2015-08-25 15:36:20 -0700 |
|---|---|---|
| committer | Alistair Veitch <aveitch@google.com> | 2015-08-25 15:36:20 -0700 |
| commit | a4e884721d4333eef8b208b26ff35f1dde25b6c1 (patch) | |
| tree | a82dabdddbe7d00190be04b299a378aed4041f24 /test/cpp | |
| parent | f886985d2c775d480079ea979323ae22efc0afc6 (diff) | |
| parent | 3cfb4795ceaaebff3b33f2ef7612ffcff72b53ab (diff) | |
merge to head
Diffstat (limited to 'test/cpp')
63 files changed, 1352 insertions, 635 deletions
diff --git a/test/cpp/client/channel_arguments_test.cc b/test/cpp/client/channel_arguments_test.cc index 01c56cb795..3d75e7b0e6 100644 --- a/test/cpp/client/channel_arguments_test.cc +++ b/test/cpp/client/channel_arguments_test.cc @@ -31,7 +31,7 @@ * */ -#include <grpc++/channel_arguments.h> +#include <grpc++/support/channel_arguments.h> #include <grpc/grpc.h> #include <gtest/gtest.h> diff --git a/test/cpp/common/auth_property_iterator_test.cc b/test/cpp/common/auth_property_iterator_test.cc index 74b18ced0d..630c38c7f6 100644 --- a/test/cpp/common/auth_property_iterator_test.cc +++ b/test/cpp/common/auth_property_iterator_test.cc @@ -32,7 +32,7 @@ */ #include <grpc/grpc_security.h> -#include <grpc++/auth_context.h> +#include <grpc++/support/auth_context.h> #include <gtest/gtest.h> #include "src/cpp/common/secure_auth_context.h" @@ -61,11 +61,8 @@ class AuthPropertyIteratorTest : public ::testing::Test { EXPECT_EQ(1, grpc_auth_context_set_peer_identity_property_name(ctx_, "name")); } - void TearDown() GRPC_OVERRIDE { - grpc_auth_context_release(ctx_); - } + void TearDown() GRPC_OVERRIDE { grpc_auth_context_release(ctx_); } grpc_auth_context* ctx_; - }; TEST_F(AuthPropertyIteratorTest, DefaultCtor) { @@ -100,7 +97,7 @@ TEST_F(AuthPropertyIteratorTest, GeneralTest) { } // namespace } // namespace grpc -int main(int argc, char **argv) { +int main(int argc, char** argv) { ::testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); } diff --git a/test/cpp/common/secure_auth_context_test.cc b/test/cpp/common/secure_auth_context_test.cc index 075d4ce8c9..c71ef58023 100644 --- a/test/cpp/common/secure_auth_context_test.cc +++ b/test/cpp/common/secure_auth_context_test.cc @@ -32,7 +32,7 @@ */ #include <grpc/grpc_security.h> -#include <grpc++/auth_context.h> +#include <grpc++/support/auth_context.h> #include <gtest/gtest.h> #include "src/cpp/common/secure_auth_context.h" @@ -101,7 +101,7 @@ TEST_F(SecureAuthContextTest, Iterators) { } // namespace } // namespace grpc -int main(int argc, char **argv) { +int main(int argc, char** argv) { ::testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); } diff --git a/test/cpp/end2end/async_end2end_test.cc b/test/cpp/end2end/async_end2end_test.cc index 9b53bdc999..6343810ee9 100644 --- a/test/cpp/end2end/async_end2end_test.cc +++ b/test/cpp/end2end/async_end2end_test.cc @@ -33,13 +33,10 @@ #include <memory> -#include "test/core/util/port.h" -#include "test/core/util/test_config.h" -#include "test/cpp/util/echo_duplicate.grpc.pb.h" -#include "test/cpp/util/echo.grpc.pb.h" -#include <grpc++/async_unary_call.h> -#include <grpc++/channel_arguments.h> -#include <grpc++/channel_interface.h> +#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++/credentials.h> @@ -47,14 +44,16 @@ #include <grpc++/server_builder.h> #include <grpc++/server_context.h> #include <grpc++/server_credentials.h> -#include <grpc++/status.h> -#include <grpc++/stream.h> -#include <grpc++/time.h> #include <gtest/gtest.h> -#include <grpc/grpc.h> -#include <grpc/support/thd.h> -#include <grpc/support/time.h> +#include "test/core/util/port.h" +#include "test/core/util/test_config.h" +#include "test/cpp/util/echo_duplicate.grpc.pb.h" +#include "test/cpp/util/echo.grpc.pb.h" + +#ifdef GPR_POSIX_SOCKET +#include "src/core/iomgr/pollset_posix.h" +#endif using grpc::cpp::test::util::EchoRequest; using grpc::cpp::test::util::EchoResponse; @@ -65,36 +64,102 @@ namespace testing { namespace { -void* tag(int i) { return (void*)(gpr_intptr) i; } +void* tag(int i) { return (void*)(gpr_intptr)i; } -class Verifier { +#ifdef GPR_POSIX_SOCKET +static int assert_non_blocking_poll(struct pollfd* pfds, nfds_t nfds, + int timeout) { + GPR_ASSERT(timeout == 0); + return poll(pfds, nfds, timeout); +} + +class PollOverride { public: + PollOverride(grpc_poll_function_type f) { + prev_ = grpc_poll_function; + grpc_poll_function = f; + } + + ~PollOverride() { grpc_poll_function = prev_; } + + private: + grpc_poll_function_type prev_; +}; + +class PollingCheckRegion : public PollOverride { + public: + explicit PollingCheckRegion(bool allow_blocking) + : PollOverride(allow_blocking ? poll : assert_non_blocking_poll) {} +}; +#else +class PollingCheckRegion { + public: + explicit PollingCheckRegion(bool allow_blocking) {} +}; +#endif + +class Verifier : public PollingCheckRegion { + public: + explicit Verifier(bool spin) : PollingCheckRegion(!spin), spin_(spin) {} Verifier& Expect(int i, bool expect_ok) { expectations_[tag(i)] = expect_ok; return *this; } - void Verify(CompletionQueue *cq) { + void Verify(CompletionQueue* cq) { GPR_ASSERT(!expectations_.empty()); while (!expectations_.empty()) { bool ok; void* got_tag; - EXPECT_TRUE(cq->Next(&got_tag, &ok)); + 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) { + void Verify(CompletionQueue* cq, + std::chrono::system_clock::time_point deadline) { if (expectations_.empty()) { bool ok; - void *got_tag; - EXPECT_EQ(cq->AsyncNext(&got_tag, &ok, deadline), CompletionQueue::TIMEOUT); + 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; - EXPECT_EQ(cq->AsyncNext(&got_tag, &ok, deadline), CompletionQueue::GOT_EVENT); + 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); @@ -105,9 +170,10 @@ class Verifier { private: std::map<void*, bool> expectations_; + bool spin_; }; -class AsyncEnd2endTest : public ::testing::Test { +class AsyncEnd2endTest : public ::testing::TestWithParam<bool> { protected: AsyncEnd2endTest() {} @@ -116,7 +182,8 @@ class AsyncEnd2endTest : public ::testing::Test { server_address_ << "localhost:" << port; // Setup server ServerBuilder builder; - builder.AddListeningPort(server_address_.str(), grpc::InsecureServerCredentials()); + builder.AddListeningPort(server_address_.str(), + grpc::InsecureServerCredentials()); builder.RegisterAsyncService(&service_); cq_ = builder.AddCompletionQueue(); server_ = builder.BuildAndStart(); @@ -132,7 +199,7 @@ class AsyncEnd2endTest : public ::testing::Test { } void ResetStub() { - std::shared_ptr<ChannelInterface> channel = CreateChannel( + std::shared_ptr<Channel> channel = CreateChannel( server_address_.str(), InsecureCredentials(), ChannelArguments()); stub_ = std::move(grpc::cpp::test::util::TestService::NewStub(channel)); } @@ -153,18 +220,18 @@ class AsyncEnd2endTest : public ::testing::Test { 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)); + service_.RequestEcho(&srv_ctx, &recv_request, &response_writer, cq_.get(), + cq_.get(), tag(2)); - Verifier().Expect(2, true).Verify(cq_.get()); + 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().Expect(3, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(3, true).Verify(cq_.get()); response_reader->Finish(&recv_response, &recv_status, tag(4)); - Verifier().Expect(4, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(4, true).Verify(cq_.get()); EXPECT_EQ(send_response.message(), recv_response.message()); EXPECT_TRUE(recv_status.ok()); @@ -178,18 +245,18 @@ class AsyncEnd2endTest : public ::testing::Test { std::ostringstream server_address_; }; -TEST_F(AsyncEnd2endTest, SimpleRpc) { +TEST_P(AsyncEnd2endTest, SimpleRpc) { ResetStub(); SendRpc(1); } -TEST_F(AsyncEnd2endTest, SequentialRpcs) { +TEST_P(AsyncEnd2endTest, SequentialRpcs) { ResetStub(); SendRpc(10); } // Test a simple RPC using the async version of Next -TEST_F(AsyncEnd2endTest, AsyncNextRpc) { +TEST_P(AsyncEnd2endTest, AsyncNextRpc) { ResetStub(); EchoRequest send_request; @@ -210,28 +277,32 @@ TEST_F(AsyncEnd2endTest, AsyncNextRpc) { std::chrono::system_clock::now()); std::chrono::system_clock::time_point time_limit( std::chrono::system_clock::now() + std::chrono::seconds(10)); - Verifier().Verify(cq_.get(), time_now); - Verifier().Verify(cq_.get(), time_now); + 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().Expect(2, true).Verify(cq_.get(), time_limit); + 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().Expect(3, true).Verify(cq_.get(), std::chrono::system_clock::time_point::max()); + 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().Expect(4, true).Verify(cq_.get(), std::chrono::system_clock::time_point::max()); + 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_F(AsyncEnd2endTest, SimpleClientStreaming) { +TEST_P(AsyncEnd2endTest, SimpleClientStreaming) { ResetStub(); EchoRequest send_request; @@ -247,44 +318,44 @@ TEST_F(AsyncEnd2endTest, SimpleClientStreaming) { 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)); + service_.RequestRequestStream(&srv_ctx, &srv_stream, cq_.get(), cq_.get(), + tag(2)); - Verifier().Expect(2, true).Expect(1, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(2, true).Expect(1, true).Verify(cq_.get()); cli_stream->Write(send_request, tag(3)); - Verifier().Expect(3, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(3, true).Verify(cq_.get()); srv_stream.Read(&recv_request, tag(4)); - Verifier().Expect(4, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(4, true).Verify(cq_.get()); EXPECT_EQ(send_request.message(), recv_request.message()); cli_stream->Write(send_request, tag(5)); - Verifier().Expect(5, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(5, true).Verify(cq_.get()); srv_stream.Read(&recv_request, tag(6)); - Verifier().Expect(6, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(6, true).Verify(cq_.get()); EXPECT_EQ(send_request.message(), recv_request.message()); cli_stream->WritesDone(tag(7)); - Verifier().Expect(7, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(7, true).Verify(cq_.get()); srv_stream.Read(&recv_request, tag(8)); - Verifier().Expect(8, false).Verify(cq_.get()); + 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().Expect(9, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(9, true).Verify(cq_.get()); cli_stream->Finish(&recv_status, tag(10)); - Verifier().Expect(10, true).Verify(cq_.get()); + 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_F(AsyncEnd2endTest, SimpleServerStreaming) { +TEST_P(AsyncEnd2endTest, SimpleServerStreaming) { ResetStub(); EchoRequest send_request; @@ -303,38 +374,38 @@ TEST_F(AsyncEnd2endTest, SimpleServerStreaming) { service_.RequestResponseStream(&srv_ctx, &recv_request, &srv_stream, cq_.get(), cq_.get(), tag(2)); - Verifier().Expect(1, true).Expect(2, true).Verify(cq_.get()); + 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().Expect(3, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(3, true).Verify(cq_.get()); cli_stream->Read(&recv_response, tag(4)); - Verifier().Expect(4, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(4, true).Verify(cq_.get()); EXPECT_EQ(send_response.message(), recv_response.message()); srv_stream.Write(send_response, tag(5)); - Verifier().Expect(5, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(5, true).Verify(cq_.get()); cli_stream->Read(&recv_response, tag(6)); - Verifier().Expect(6, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(6, true).Verify(cq_.get()); EXPECT_EQ(send_response.message(), recv_response.message()); srv_stream.Finish(Status::OK, tag(7)); - Verifier().Expect(7, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(7, true).Verify(cq_.get()); cli_stream->Read(&recv_response, tag(8)); - Verifier().Expect(8, false).Verify(cq_.get()); + Verifier(GetParam()).Expect(8, false).Verify(cq_.get()); cli_stream->Finish(&recv_status, tag(9)); - Verifier().Expect(9, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(9, true).Verify(cq_.get()); EXPECT_TRUE(recv_status.ok()); } // One ping, one pong. -TEST_F(AsyncEnd2endTest, SimpleBidiStreaming) { +TEST_P(AsyncEnd2endTest, SimpleBidiStreaming) { ResetStub(); EchoRequest send_request; @@ -350,43 +421,43 @@ TEST_F(AsyncEnd2endTest, SimpleBidiStreaming) { 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)); + service_.RequestBidiStream(&srv_ctx, &srv_stream, cq_.get(), cq_.get(), + tag(2)); - Verifier().Expect(1, true).Expect(2, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(1, true).Expect(2, true).Verify(cq_.get()); cli_stream->Write(send_request, tag(3)); - Verifier().Expect(3, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(3, true).Verify(cq_.get()); srv_stream.Read(&recv_request, tag(4)); - Verifier().Expect(4, true).Verify(cq_.get()); + 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().Expect(5, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(5, true).Verify(cq_.get()); cli_stream->Read(&recv_response, tag(6)); - Verifier().Expect(6, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(6, true).Verify(cq_.get()); EXPECT_EQ(send_response.message(), recv_response.message()); cli_stream->WritesDone(tag(7)); - Verifier().Expect(7, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(7, true).Verify(cq_.get()); srv_stream.Read(&recv_request, tag(8)); - Verifier().Expect(8, false).Verify(cq_.get()); + Verifier(GetParam()).Expect(8, false).Verify(cq_.get()); srv_stream.Finish(Status::OK, tag(9)); - Verifier().Expect(9, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(9, true).Verify(cq_.get()); cli_stream->Finish(&recv_status, tag(10)); - Verifier().Expect(10, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(10, true).Verify(cq_.get()); EXPECT_TRUE(recv_status.ok()); } // Metadata tests -TEST_F(AsyncEnd2endTest, ClientInitialMetadataRpc) { +TEST_P(AsyncEnd2endTest, ClientInitialMetadataRpc) { ResetStub(); EchoRequest send_request; @@ -410,7 +481,7 @@ TEST_F(AsyncEnd2endTest, ClientInitialMetadataRpc) { service_.RequestEcho(&srv_ctx, &recv_request, &response_writer, cq_.get(), cq_.get(), tag(2)); - Verifier().Expect(2, true).Verify(cq_.get()); + 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, client_initial_metadata.find(meta1.first)->second); @@ -420,16 +491,16 @@ TEST_F(AsyncEnd2endTest, ClientInitialMetadataRpc) { send_response.set_message(recv_request.message()); response_writer.Finish(send_response, Status::OK, tag(3)); - Verifier().Expect(3, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(3, true).Verify(cq_.get()); response_reader->Finish(&recv_response, &recv_status, tag(4)); - Verifier().Expect(4, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(4, true).Verify(cq_.get()); EXPECT_EQ(send_response.message(), recv_response.message()); EXPECT_TRUE(recv_status.ok()); } -TEST_F(AsyncEnd2endTest, ServerInitialMetadataRpc) { +TEST_P(AsyncEnd2endTest, ServerInitialMetadataRpc) { ResetStub(); EchoRequest send_request; @@ -451,15 +522,15 @@ TEST_F(AsyncEnd2endTest, ServerInitialMetadataRpc) { service_.RequestEcho(&srv_ctx, &recv_request, &response_writer, cq_.get(), cq_.get(), tag(2)); - Verifier().Expect(2, true).Verify(cq_.get()); + 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().Expect(3, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(3, true).Verify(cq_.get()); response_reader->ReadInitialMetadata(tag(4)); - Verifier().Expect(4, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(4, true).Verify(cq_.get()); auto server_initial_metadata = cli_ctx.GetServerInitialMetadata(); EXPECT_EQ(meta1.second, server_initial_metadata.find(meta1.first)->second); EXPECT_EQ(meta2.second, server_initial_metadata.find(meta2.first)->second); @@ -467,16 +538,16 @@ TEST_F(AsyncEnd2endTest, ServerInitialMetadataRpc) { send_response.set_message(recv_request.message()); response_writer.Finish(send_response, Status::OK, tag(5)); - Verifier().Expect(5, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(5, true).Verify(cq_.get()); response_reader->Finish(&recv_response, &recv_status, tag(6)); - Verifier().Expect(6, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(6, true).Verify(cq_.get()); EXPECT_EQ(send_response.message(), recv_response.message()); EXPECT_TRUE(recv_status.ok()); } -TEST_F(AsyncEnd2endTest, ServerTrailingMetadataRpc) { +TEST_P(AsyncEnd2endTest, ServerTrailingMetadataRpc) { ResetStub(); EchoRequest send_request; @@ -498,20 +569,20 @@ TEST_F(AsyncEnd2endTest, ServerTrailingMetadataRpc) { service_.RequestEcho(&srv_ctx, &recv_request, &response_writer, cq_.get(), cq_.get(), tag(2)); - Verifier().Expect(2, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(2, true).Verify(cq_.get()); EXPECT_EQ(send_request.message(), recv_request.message()); response_writer.SendInitialMetadata(tag(3)); - Verifier().Expect(3, true).Verify(cq_.get()); + 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().Expect(4, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(4, true).Verify(cq_.get()); response_reader->Finish(&recv_response, &recv_status, tag(5)); - Verifier().Expect(5, true).Verify(cq_.get()); + 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(); @@ -520,7 +591,7 @@ TEST_F(AsyncEnd2endTest, ServerTrailingMetadataRpc) { EXPECT_EQ(static_cast<size_t>(2), server_trailing_metadata.size()); } -TEST_F(AsyncEnd2endTest, MetadataRpc) { +TEST_P(AsyncEnd2endTest, MetadataRpc) { ResetStub(); EchoRequest send_request; @@ -537,18 +608,17 @@ TEST_F(AsyncEnd2endTest, MetadataRpc) { 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)); + 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)); + 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)); + 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); @@ -558,7 +628,7 @@ TEST_F(AsyncEnd2endTest, MetadataRpc) { service_.RequestEcho(&srv_ctx, &recv_request, &response_writer, cq_.get(), cq_.get(), tag(2)); - Verifier().Expect(2, true).Verify(cq_.get()); + 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, client_initial_metadata.find(meta1.first)->second); @@ -568,9 +638,9 @@ TEST_F(AsyncEnd2endTest, MetadataRpc) { srv_ctx.AddInitialMetadata(meta3.first, meta3.second); srv_ctx.AddInitialMetadata(meta4.first, meta4.second); response_writer.SendInitialMetadata(tag(3)); - Verifier().Expect(3, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(3, true).Verify(cq_.get()); response_reader->ReadInitialMetadata(tag(4)); - Verifier().Expect(4, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(4, true).Verify(cq_.get()); auto server_initial_metadata = cli_ctx.GetServerInitialMetadata(); EXPECT_EQ(meta3.second, server_initial_metadata.find(meta3.first)->second); EXPECT_EQ(meta4.second, server_initial_metadata.find(meta4.first)->second); @@ -581,10 +651,10 @@ TEST_F(AsyncEnd2endTest, MetadataRpc) { srv_ctx.AddTrailingMetadata(meta6.first, meta6.second); response_writer.Finish(send_response, Status::OK, tag(5)); - Verifier().Expect(5, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(5, true).Verify(cq_.get()); response_reader->Finish(&recv_response, &recv_status, tag(6)); - Verifier().Expect(6, true).Verify(cq_.get()); + 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(); @@ -594,7 +664,7 @@ TEST_F(AsyncEnd2endTest, MetadataRpc) { } // Server uses AsyncNotifyWhenDone API to check for cancellation -TEST_F(AsyncEnd2endTest, ServerCheckCancellation) { +TEST_P(AsyncEnd2endTest, ServerCheckCancellation) { ResetStub(); EchoRequest send_request; @@ -615,21 +685,21 @@ TEST_F(AsyncEnd2endTest, ServerCheckCancellation) { service_.RequestEcho(&srv_ctx, &recv_request, &response_writer, cq_.get(), cq_.get(), tag(2)); - Verifier().Expect(2, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(2, true).Verify(cq_.get()); EXPECT_EQ(send_request.message(), recv_request.message()); cli_ctx.TryCancel(); - Verifier().Expect(5, true).Verify(cq_.get()); + Verifier(GetParam()).Expect(5, true).Verify(cq_.get()); EXPECT_TRUE(srv_ctx.IsCancelled()); response_reader->Finish(&recv_response, &recv_status, tag(4)); - Verifier().Expect(4, false).Verify(cq_.get()); + 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_F(AsyncEnd2endTest, ServerCheckDone) { +TEST_P(AsyncEnd2endTest, ServerCheckDone) { ResetStub(); EchoRequest send_request; @@ -650,22 +720,47 @@ TEST_F(AsyncEnd2endTest, ServerCheckDone) { service_.RequestEcho(&srv_ctx, &recv_request, &response_writer, cq_.get(), cq_.get(), tag(2)); - Verifier().Expect(2, true).Verify(cq_.get()); + 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().Expect(3, true).Verify(cq_.get()); - Verifier().Expect(5, true).Verify(cq_.get()); + 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().Expect(4, true).Verify(cq_.get()); + 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(), InsecureCredentials(), ChannelArguments()); + std::unique_ptr<grpc::cpp::test::util::UnimplementedService::Stub> stub; + stub = + std::move(grpc::cpp::test::util::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 diff --git a/test/cpp/end2end/client_crash_test.cc b/test/cpp/end2end/client_crash_test.cc index 906f124c05..3359080cec 100644 --- a/test/cpp/end2end/client_crash_test.cc +++ b/test/cpp/end2end/client_crash_test.cc @@ -31,12 +31,10 @@ * */ -#include "test/core/util/port.h" -#include "test/core/util/test_config.h" -#include "test/cpp/util/echo_duplicate.grpc.pb.h" -#include "test/cpp/util/echo.grpc.pb.h" -#include <grpc++/channel_arguments.h> -#include <grpc++/channel_interface.h> +#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++/credentials.h> @@ -44,15 +42,12 @@ #include <grpc++/server_builder.h> #include <grpc++/server_context.h> #include <grpc++/server_credentials.h> -#include <grpc++/status.h> -#include <grpc++/stream.h> -#include <grpc++/time.h> #include <gtest/gtest.h> -#include <grpc/grpc.h> -#include <grpc/support/thd.h> -#include <grpc/support/time.h> - +#include "test/core/util/port.h" +#include "test/core/util/test_config.h" +#include "test/cpp/util/echo_duplicate.grpc.pb.h" +#include "test/cpp/util/echo.grpc.pb.h" #include "test/cpp/util/subprocess.h" using grpc::cpp::test::util::EchoRequest; @@ -77,17 +72,14 @@ class CrashTest : public ::testing::Test { addr_stream << "localhost:" << port; auto addr = addr_stream.str(); server_.reset(new SubProcess({ - g_root + "/client_crash_test_server", - "--address=" + addr, + g_root + "/client_crash_test_server", "--address=" + addr, })); GPR_ASSERT(server_); return grpc::cpp::test::util::TestService::NewStub( CreateChannel(addr, InsecureCredentials(), ChannelArguments())); } - void KillServer() { - server_.reset(); - } + void KillServer() { server_.reset(); } private: std::unique_ptr<SubProcess> server_; diff --git a/test/cpp/end2end/client_crash_test_server.cc b/test/cpp/end2end/client_crash_test_server.cc index 20808a0240..79a7832874 100644 --- a/test/cpp/end2end/client_crash_test_server.cc +++ b/test/cpp/end2end/client_crash_test_server.cc @@ -40,7 +40,6 @@ #include <grpc++/server_builder.h> #include <grpc++/server_context.h> #include <grpc++/server_credentials.h> -#include <grpc++/status.h> #include "test/cpp/util/echo.grpc.pb.h" DEFINE_string(address, "", "Address to bind to"); @@ -58,7 +57,8 @@ using namespace gflags; namespace grpc { namespace testing { -class ServiceImpl GRPC_FINAL : public ::grpc::cpp::test::util::TestService::Service { +class ServiceImpl GRPC_FINAL + : public ::grpc::cpp::test::util::TestService::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 37669815c6..2728dce07e 100644 --- a/test/cpp/end2end/end2end_test.cc +++ b/test/cpp/end2end/end2end_test.cc @@ -34,30 +34,25 @@ #include <mutex> #include <thread> -#include "src/core/security/credentials.h" -#include "test/core/end2end/data/ssl_test_data.h" -#include "test/core/util/port.h" -#include "test/core/util/test_config.h" -#include "test/cpp/util/echo_duplicate.grpc.pb.h" -#include "test/cpp/util/echo.grpc.pb.h" -#include <grpc++/channel_arguments.h> -#include <grpc++/channel_interface.h> +#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++/credentials.h> -#include <grpc++/dynamic_thread_pool.h> #include <grpc++/server.h> #include <grpc++/server_builder.h> #include <grpc++/server_context.h> #include <grpc++/server_credentials.h> -#include <grpc++/status.h> -#include <grpc++/stream.h> -#include <grpc++/time.h> #include <gtest/gtest.h> -#include <grpc/grpc.h> -#include <grpc/support/thd.h> -#include <grpc/support/time.h> +#include "src/core/security/credentials.h" +#include "test/core/end2end/data/ssl_test_data.h" +#include "test/core/util/port.h" +#include "test/core/util/test_config.h" +#include "test/cpp/util/echo_duplicate.grpc.pb.h" +#include "test/cpp/util/echo.grpc.pb.h" using grpc::cpp::test::util::EchoRequest; using grpc::cpp::test::util::EchoResponse; @@ -106,7 +101,7 @@ bool CheckIsLocalhost(const grpc::string& addr) { class Proxy : public ::grpc::cpp::test::util::TestService::Service { public: - Proxy(std::shared_ptr<ChannelInterface> channel) + Proxy(std::shared_ptr<Channel> channel) : stub_(grpc::cpp::test::util::TestService::NewStub(channel)) {} Status Echo(ServerContext* server_context, const EchoRequest* request, @@ -262,7 +257,7 @@ class TestServiceImplDupPkg class End2endTest : public ::testing::TestWithParam<bool> { protected: End2endTest() - : kMaxMessageSize_(8192), special_service_("special"), thread_pool_(2) {} + : kMaxMessageSize_(8192), special_service_("special") {} void SetUp() GRPC_OVERRIDE { int port = grpc_pick_unused_port_or_die(); @@ -270,7 +265,7 @@ class End2endTest : public ::testing::TestWithParam<bool> { // Setup server ServerBuilder builder; SslServerCredentialsOptions::PemKeyCertPair pkcp = {test_server1_key, - test_server1_cert}; + test_server1_cert}; SslServerCredentialsOptions ssl_opts; ssl_opts.pem_root_certs = ""; ssl_opts.pem_key_cert_pairs.push_back(pkcp); @@ -281,7 +276,6 @@ class End2endTest : public ::testing::TestWithParam<bool> { builder.SetMaxMessageSize( kMaxMessageSize_); // For testing max message size. builder.RegisterService(&dup_pkg_service_); - builder.SetThreadPool(&thread_pool_); server_ = builder.BuildAndStart(); } @@ -290,13 +284,17 @@ class End2endTest : public ::testing::TestWithParam<bool> { if (proxy_server_) proxy_server_->Shutdown(); } - void ResetStub(bool use_proxy) { + void ResetChannel() { SslCredentialsOptions ssl_opts = {test_root_cert, "", ""}; ChannelArguments args; args.SetSslTargetNameOverride("foo.test.google.fr"); args.SetString(GRPC_ARG_SECONDARY_USER_AGENT_STRING, "end2end_test"); - channel_ = CreateChannel(server_address_.str(), SslCredentials(ssl_opts), - args); + channel_ = + CreateChannel(server_address_.str(), SslCredentials(ssl_opts), args); + } + + void ResetStub(bool use_proxy) { + ResetChannel(); if (use_proxy) { proxy_service_.reset(new Proxy(channel_)); int port = grpc_pick_unused_port_or_die(); @@ -305,7 +303,6 @@ class End2endTest : public ::testing::TestWithParam<bool> { ServerBuilder builder; builder.AddListeningPort(proxyaddr.str(), InsecureServerCredentials()); builder.RegisterService(proxy_service_.get()); - builder.SetThreadPool(&thread_pool_); proxy_server_ = builder.BuildAndStart(); channel_ = CreateChannel(proxyaddr.str(), InsecureCredentials(), @@ -315,7 +312,7 @@ class End2endTest : public ::testing::TestWithParam<bool> { stub_ = std::move(grpc::cpp::test::util::TestService::NewStub(channel_)); } - std::shared_ptr<ChannelInterface> channel_; + std::shared_ptr<Channel> channel_; std::unique_ptr<grpc::cpp::test::util::TestService::Stub> stub_; std::unique_ptr<Server> server_; std::unique_ptr<Server> proxy_server_; @@ -325,7 +322,6 @@ class End2endTest : public ::testing::TestWithParam<bool> { TestServiceImpl service_; TestServiceImpl special_service_; TestServiceImplDupPkg dup_pkg_service_; - DynamicThreadPool thread_pool_; }; static void SendRpc(grpc::cpp::test::util::TestService::Stub* stub, @@ -567,7 +563,7 @@ TEST_F(End2endTest, DiffPackageServices) { TEST_F(End2endTest, BadCredentials) { std::shared_ptr<Credentials> bad_creds = ServiceAccountCredentials("", "", 1); EXPECT_EQ(static_cast<Credentials*>(nullptr), bad_creds.get()); - std::shared_ptr<ChannelInterface> channel = + std::shared_ptr<Channel> channel = CreateChannel(server_address_.str(), bad_creds, ChannelArguments()); std::unique_ptr<grpc::cpp::test::util::TestService::Stub> stub( grpc::cpp::test::util::TestService::NewStub(channel)); @@ -579,15 +575,15 @@ TEST_F(End2endTest, BadCredentials) { Status s = stub->Echo(&context, request, &response); EXPECT_EQ("", response.message()); EXPECT_FALSE(s.ok()); - EXPECT_EQ(StatusCode::UNKNOWN, s.error_code()); - EXPECT_EQ("Rpc sent on a lame channel.", s.error_message()); + EXPECT_EQ(StatusCode::INVALID_ARGUMENT, s.error_code()); + EXPECT_EQ("Invalid credentials.", s.error_message()); ClientContext context2; auto stream = stub->BidiStream(&context2); s = stream->Finish(); EXPECT_FALSE(s.ok()); - EXPECT_EQ(StatusCode::UNKNOWN, s.error_code()); - EXPECT_EQ("Rpc sent on a lame channel.", s.error_message()); + EXPECT_EQ(StatusCode::INVALID_ARGUMENT, s.error_code()); + EXPECT_EQ("Invalid credentials.", s.error_message()); } void CancelRpc(ClientContext* context, int delay_us, TestServiceImpl* service) { @@ -870,7 +866,7 @@ TEST_P(End2endTest, HugeResponse) { namespace { void ReaderThreadFunc(ClientReaderWriter<EchoRequest, EchoResponse>* stream, - gpr_event *ev) { + gpr_event* ev) { EchoResponse resp; gpr_event_set(ev, (void*)1); while (stream->Read(&resp)) { @@ -925,11 +921,28 @@ TEST_F(End2endTest, ChannelState) { EXPECT_FALSE(ok); EXPECT_EQ(GRPC_CHANNEL_IDLE, channel_->GetState(true)); - EXPECT_TRUE(channel_->WaitForStateChange( - GRPC_CHANNEL_IDLE, gpr_inf_future(GPR_CLOCK_REALTIME))); + EXPECT_TRUE(channel_->WaitForStateChange(GRPC_CHANNEL_IDLE, + gpr_inf_future(GPR_CLOCK_REALTIME))); EXPECT_EQ(GRPC_CHANNEL_CONNECTING, channel_->GetState(false)); } +// Talking to a non-existing service. +TEST_F(End2endTest, NonExistingService) { + ResetChannel(); + std::unique_ptr<grpc::cpp::test::util::UnimplementedService::Stub> stub; + stub = + std::move(grpc::cpp::test::util::UnimplementedService::NewStub(channel_)); + + EchoRequest request; + EchoResponse response; + request.set_message("Hello"); + + ClientContext context; + Status s = stub->Unimplemented(&context, request, &response); + EXPECT_EQ(StatusCode::UNIMPLEMENTED, s.error_code()); + EXPECT_EQ("", s.error_message()); +} + INSTANTIATE_TEST_CASE_P(End2end, End2endTest, ::testing::Values(false, true)); } // namespace testing diff --git a/test/cpp/end2end/generic_end2end_test.cc b/test/cpp/end2end/generic_end2end_test.cc index b53c32144b..de7eab8dc2 100644 --- a/test/cpp/end2end/generic_end2end_test.cc +++ b/test/cpp/end2end/generic_end2end_test.cc @@ -33,32 +33,26 @@ #include <memory> -#include "test/core/util/port.h" -#include "test/core/util/test_config.h" -#include "test/cpp/util/echo.grpc.pb.h" +#include <grpc/grpc.h> +#include <grpc/support/thd.h> +#include <grpc/support/time.h> #include <grpc++/impl/proto_utils.h> -#include <grpc++/async_generic_service.h> -#include <grpc++/async_unary_call.h> -#include <grpc++/byte_buffer.h> -#include <grpc++/channel_arguments.h> -#include <grpc++/channel_interface.h> +#include <grpc++/channel.h> #include <grpc++/client_context.h> #include <grpc++/create_channel.h> #include <grpc++/credentials.h> -#include <grpc++/generic_stub.h> +#include <grpc++/generic/async_generic_service.h> +#include <grpc++/generic/generic_stub.h> #include <grpc++/server.h> #include <grpc++/server_builder.h> #include <grpc++/server_context.h> #include <grpc++/server_credentials.h> -#include <grpc++/slice.h> -#include <grpc++/status.h> -#include <grpc++/stream.h> -#include <grpc++/time.h> +#include <grpc++/support/slice.h> #include <gtest/gtest.h> -#include <grpc/grpc.h> -#include <grpc/support/thd.h> -#include <grpc/support/time.h> +#include "test/core/util/port.h" +#include "test/core/util/test_config.h" +#include "test/cpp/util/echo.grpc.pb.h" using grpc::cpp::test::util::EchoRequest; using grpc::cpp::test::util::EchoResponse; @@ -68,7 +62,7 @@ namespace grpc { namespace testing { namespace { -void* tag(int i) { return (void*)(gpr_intptr) i; } +void* tag(int i) { return (void*)(gpr_intptr)i; } void verify_ok(CompletionQueue* cq, int i, bool expect_ok) { bool ok; @@ -107,7 +101,8 @@ class GenericEnd2endTest : public ::testing::Test { server_address_ << server_host_ << ":" << port; // Setup server ServerBuilder builder; - builder.AddListeningPort(server_address_.str(), InsecureServerCredentials()); + builder.AddListeningPort(server_address_.str(), + InsecureServerCredentials()); builder.RegisterAsyncGenericService(&generic_service_); srv_cq_ = builder.AddCompletionQueue(); server_ = builder.BuildAndStart(); @@ -126,7 +121,7 @@ class GenericEnd2endTest : public ::testing::Test { } void ResetStub() { - std::shared_ptr<ChannelInterface> channel = CreateChannel( + std::shared_ptr<Channel> channel = CreateChannel( server_address_.str(), InsecureCredentials(), ChannelArguments()); generic_stub_.reset(new GenericStub(channel)); } diff --git a/test/cpp/end2end/mock_test.cc b/test/cpp/end2end/mock_test.cc index 32130e24e9..b2c6dc39a8 100644 --- a/test/cpp/end2end/mock_test.cc +++ b/test/cpp/end2end/mock_test.cc @@ -33,28 +33,23 @@ #include <thread> -#include "test/core/util/port.h" -#include "test/core/util/test_config.h" -#include "test/cpp/util/echo_duplicate.grpc.pb.h" -#include "test/cpp/util/echo.grpc.pb.h" -#include <grpc++/channel_arguments.h> -#include <grpc++/channel_interface.h> +#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++/credentials.h> -#include <grpc++/dynamic_thread_pool.h> #include <grpc++/server.h> #include <grpc++/server_builder.h> #include <grpc++/server_context.h> #include <grpc++/server_credentials.h> -#include <grpc++/status.h> -#include <grpc++/stream.h> -#include <grpc++/time.h> #include <gtest/gtest.h> -#include <grpc/grpc.h> -#include <grpc/support/thd.h> -#include <grpc/support/time.h> +#include "test/core/util/port.h" +#include "test/core/util/test_config.h" +#include "test/cpp/util/echo_duplicate.grpc.pb.h" +#include "test/cpp/util/echo.grpc.pb.h" using grpc::cpp::test::util::EchoRequest; using grpc::cpp::test::util::EchoResponse; @@ -234,7 +229,7 @@ class TestServiceImpl : public TestService::Service { class MockTest : public ::testing::Test { protected: - MockTest() : thread_pool_(2) {} + MockTest() {} void SetUp() GRPC_OVERRIDE { int port = grpc_pick_unused_port_or_die(); @@ -244,14 +239,13 @@ class MockTest : public ::testing::Test { builder.AddListeningPort(server_address_.str(), InsecureServerCredentials()); builder.RegisterService(&service_); - builder.SetThreadPool(&thread_pool_); server_ = builder.BuildAndStart(); } void TearDown() GRPC_OVERRIDE { server_->Shutdown(); } void ResetStub() { - std::shared_ptr<ChannelInterface> channel = CreateChannel( + std::shared_ptr<Channel> channel = CreateChannel( server_address_.str(), InsecureCredentials(), ChannelArguments()); stub_ = std::move(grpc::cpp::test::util::TestService::NewStub(channel)); } @@ -260,7 +254,6 @@ class MockTest : public ::testing::Test { std::unique_ptr<Server> server_; std::ostringstream server_address_; TestServiceImpl service_; - DynamicThreadPool thread_pool_; }; // Do one real rpc and one mocked one diff --git a/test/cpp/end2end/server_crash_test.cc b/test/cpp/end2end/server_crash_test.cc index 5c7bb4e653..1a0f04e22b 100644 --- a/test/cpp/end2end/server_crash_test.cc +++ b/test/cpp/end2end/server_crash_test.cc @@ -31,12 +31,10 @@ * */ -#include "test/core/util/port.h" -#include "test/core/util/test_config.h" -#include "test/cpp/util/echo_duplicate.grpc.pb.h" -#include "test/cpp/util/echo.grpc.pb.h" -#include <grpc++/channel_arguments.h> -#include <grpc++/channel_interface.h> +#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++/credentials.h> @@ -44,15 +42,12 @@ #include <grpc++/server_builder.h> #include <grpc++/server_context.h> #include <grpc++/server_credentials.h> -#include <grpc++/status.h> -#include <grpc++/stream.h> -#include <grpc++/time.h> #include <gtest/gtest.h> -#include <grpc/grpc.h> -#include <grpc/support/thd.h> -#include <grpc/support/time.h> - +#include "test/core/util/port.h" +#include "test/core/util/test_config.h" +#include "test/cpp/util/echo.grpc.pb.h" +#include "test/cpp/util/echo_duplicate.grpc.pb.h" #include "test/cpp/util/subprocess.h" using grpc::cpp::test::util::EchoRequest; diff --git a/test/cpp/end2end/server_crash_test_client.cc b/test/cpp/end2end/server_crash_test_client.cc index 497ccb4cb2..7ca43a0c5b 100644 --- a/test/cpp/end2end/server_crash_test_client.cc +++ b/test/cpp/end2end/server_crash_test_client.cc @@ -37,12 +37,10 @@ #include <string> #include <gflags/gflags.h> -#include <grpc++/channel_arguments.h> -#include <grpc++/channel_interface.h> +#include <grpc++/channel.h> #include <grpc++/client_context.h> #include <grpc++/create_channel.h> #include <grpc++/credentials.h> -#include <grpc++/status.h> #include "test/cpp/util/echo.grpc.pb.h" DEFINE_string(address, "", "Address to connect to"); @@ -60,8 +58,8 @@ using namespace gflags; int main(int argc, char** argv) { ParseCommandLineFlags(&argc, &argv, true); - auto stub = grpc::cpp::test::util::TestService::NewStub( - grpc::CreateChannel(FLAGS_address, grpc::InsecureCredentials(), grpc::ChannelArguments())); + auto stub = grpc::cpp::test::util::TestService::NewStub(grpc::CreateChannel( + FLAGS_address, grpc::InsecureCredentials(), grpc::ChannelArguments())); EchoRequest request; EchoResponse response; diff --git a/test/cpp/end2end/shutdown_test.cc b/test/cpp/end2end/shutdown_test.cc new file mode 100644 index 0000000000..e83f86f7ec --- /dev/null +++ b/test/cpp/end2end/shutdown_test.cc @@ -0,0 +1,157 @@ +/* + * + * Copyright 2015, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#include <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++/credentials.h> +#include <grpc++/server.h> +#include <grpc++/server_builder.h> +#include <grpc++/server_context.h> +#include <grpc++/server_credentials.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 "test/cpp/util/echo.grpc.pb.h" + +using grpc::cpp::test::util::EchoRequest; +using grpc::cpp::test::util::EchoResponse; + +namespace grpc { +namespace testing { + +class TestServiceImpl : public ::grpc::cpp::test::util::TestService::Service { + public: + explicit TestServiceImpl(gpr_event* ev) : ev_(ev) {} + + Status Echo(ServerContext* context, const EchoRequest* request, + EchoResponse* response) GRPC_OVERRIDE { + gpr_event_set(ev_, (void*)1); + while (!context->IsCancelled()) { + } + return Status::OK; + } + + private: + gpr_event* ev_; +}; + +class ShutdownTest : public ::testing::Test { + public: + ShutdownTest() : shutdown_(false), service_(&ev_) { gpr_event_init(&ev_); } + + void SetUp() GRPC_OVERRIDE { + port_ = grpc_pick_unused_port_or_die(); + server_ = SetUpServer(port_); + } + + std::unique_ptr<Server> SetUpServer(const int port) { + grpc::string server_address = "localhost:" + to_string(port); + + ServerBuilder builder; + builder.AddListeningPort(server_address, InsecureServerCredentials()); + builder.RegisterService(&service_); + std::unique_ptr<Server> server = builder.BuildAndStart(); + return server; + } + + void TearDown() GRPC_OVERRIDE { GPR_ASSERT(shutdown_); } + + void ResetStub() { + string target = "dns:localhost:" + to_string(port_); + channel_ = CreateChannel(target, InsecureCredentials(), ChannelArguments()); + stub_ = std::move(grpc::cpp::test::util::TestService::NewStub(channel_)); + } + + string to_string(const int number) { + std::stringstream strs; + strs << number; + return strs.str(); + } + + void SendRequest() { + EchoRequest request; + EchoResponse response; + request.set_message("Hello"); + ClientContext context; + GPR_ASSERT(!shutdown_); + Status s = stub_->Echo(&context, request, &response); + GPR_ASSERT(shutdown_); + } + + protected: + std::shared_ptr<Channel> channel_; + std::unique_ptr<grpc::cpp::test::util::TestService::Stub> stub_; + std::unique_ptr<Server> server_; + bool shutdown_; + int port_; + gpr_event ev_; + TestServiceImpl service_; +}; + +// Tests zookeeper state change between two RPCs +// TODO(ctiller): leaked objects in this test +TEST_F(ShutdownTest, ShutdownTest) { + ResetStub(); + + // send the request in a background thread + std::thread thr(std::bind(&ShutdownTest::SendRequest, this)); + + // wait for the server to get the event + gpr_event_wait(&ev_, gpr_inf_future(GPR_CLOCK_MONOTONIC)); + + shutdown_ = true; + + // shutdown should trigger cancellation causing everything to shutdown + auto deadline = + std::chrono::system_clock::now() + std::chrono::microseconds(100); + server_->Shutdown(deadline); + EXPECT_GE(std::chrono::system_clock::now(), deadline); + + thr.join(); +} + +} // 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/thread_stress_test.cc b/test/cpp/end2end/thread_stress_test.cc index ff9c945c7c..8304f04d56 100644 --- a/test/cpp/end2end/thread_stress_test.cc +++ b/test/cpp/end2end/thread_stress_test.cc @@ -34,28 +34,23 @@ #include <mutex> #include <thread> -#include "test/core/util/port.h" -#include "test/core/util/test_config.h" -#include "test/cpp/util/echo_duplicate.grpc.pb.h" -#include "test/cpp/util/echo.grpc.pb.h" -#include <grpc++/channel_arguments.h> -#include <grpc++/channel_interface.h> +#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++/credentials.h> -#include <grpc++/dynamic_thread_pool.h> #include <grpc++/server.h> #include <grpc++/server_builder.h> #include <grpc++/server_context.h> #include <grpc++/server_credentials.h> -#include <grpc++/status.h> -#include <grpc++/stream.h> -#include <grpc++/time.h> #include <gtest/gtest.h> -#include <grpc/grpc.h> -#include <grpc/support/thd.h> -#include <grpc/support/time.h> +#include "test/core/util/port.h" +#include "test/core/util/test_config.h" +#include "test/cpp/util/echo_duplicate.grpc.pb.h" +#include "test/cpp/util/echo.grpc.pb.h" using grpc::cpp::test::util::EchoRequest; using grpc::cpp::test::util::EchoResponse; @@ -177,7 +172,7 @@ class TestServiceImplDupPkg class End2endTest : public ::testing::Test { protected: - End2endTest() : kMaxMessageSize_(8192), thread_pool_(2) {} + End2endTest() : kMaxMessageSize_(8192) {} void SetUp() GRPC_OVERRIDE { int port = grpc_pick_unused_port_or_die(); @@ -190,14 +185,13 @@ class End2endTest : public ::testing::Test { builder.SetMaxMessageSize( kMaxMessageSize_); // For testing max message size. builder.RegisterService(&dup_pkg_service_); - builder.SetThreadPool(&thread_pool_); server_ = builder.BuildAndStart(); } void TearDown() GRPC_OVERRIDE { server_->Shutdown(); } void ResetStub() { - std::shared_ptr<ChannelInterface> channel = CreateChannel( + std::shared_ptr<Channel> channel = CreateChannel( server_address_.str(), InsecureCredentials(), ChannelArguments()); stub_ = std::move(grpc::cpp::test::util::TestService::NewStub(channel)); } @@ -208,7 +202,6 @@ class End2endTest : public ::testing::Test { const int kMaxMessageSize_; TestServiceImpl service_; TestServiceImplDupPkg dup_pkg_service_; - DynamicThreadPool thread_pool_; }; static void SendRpc(grpc::cpp::test::util::TestService::Stub* stub, diff --git a/test/cpp/end2end/zookeeper_test.cc b/test/cpp/end2end/zookeeper_test.cc new file mode 100644 index 0000000000..e7d95b1c46 --- /dev/null +++ b/test/cpp/end2end/zookeeper_test.cc @@ -0,0 +1,221 @@ +/* + * + * Copyright 2015, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#include <grpc++/channel.h> +#include <grpc++/client_context.h> +#include <grpc++/create_channel.h> +#include <grpc++/credentials.h> +#include <grpc++/server.h> +#include <grpc++/server_builder.h> +#include <grpc++/server_context.h> +#include <grpc++/server_credentials.h> +#include <gtest/gtest.h> +#include <grpc/grpc.h> +#include <grpc/grpc_zookeeper.h> +#include <zookeeper/zookeeper.h> + +#include "test/core/util/test_config.h" +#include "test/core/util/port.h" +#include "test/cpp/util/echo.grpc.pb.h" +#include "src/core/support/env.h" + +using grpc::cpp::test::util::EchoRequest; +using grpc::cpp::test::util::EchoResponse; + +namespace grpc { +namespace testing { + +class ZookeeperTestServiceImpl + : public ::grpc::cpp::test::util::TestService::Service { + public: + Status Echo(ServerContext* context, const EchoRequest* request, + EchoResponse* response) GRPC_OVERRIDE { + response->set_message(request->message()); + return Status::OK; + } +}; + +class ZookeeperTest : public ::testing::Test { + protected: + ZookeeperTest() {} + + void SetUp() GRPC_OVERRIDE { + SetUpZookeeper(); + + // Sets up two servers + int port1 = grpc_pick_unused_port_or_die(); + server1_ = SetUpServer(port1); + + int port2 = grpc_pick_unused_port_or_die(); + server2_ = SetUpServer(port2); + + // Registers service /test in zookeeper + RegisterService("/test", "test"); + + // Registers service instance /test/1 in zookeeper + string value = + "{\"host\":\"localhost\",\"port\":\"" + to_string(port1) + "\"}"; + RegisterService("/test/1", value); + + // Registers service instance /test/2 in zookeeper + value = "{\"host\":\"localhost\",\"port\":\"" + to_string(port2) + "\"}"; + RegisterService("/test/2", value); + } + + // Requires zookeeper server running + void SetUpZookeeper() { + // Finds zookeeper server address in environment + // Default is localhost:2181 + zookeeper_address_ = "localhost:2181"; + char* addr = gpr_getenv("GRPC_ZOOKEEPER_SERVER_TEST"); + if (addr != NULL) { + string addr_str(addr); + zookeeper_address_ = addr_str; + gpr_free(addr); + } + gpr_log(GPR_DEBUG, zookeeper_address_.c_str()); + + // Connects to zookeeper server + zoo_set_debug_level(ZOO_LOG_LEVEL_WARN); + zookeeper_handle_ = + zookeeper_init(zookeeper_address_.c_str(), NULL, 15000, 0, 0, 0); + GPR_ASSERT(zookeeper_handle_ != NULL); + + // Registers zookeeper name resolver in grpc + grpc_zookeeper_register(); + } + + std::unique_ptr<Server> SetUpServer(const int port) { + string server_address = "localhost:" + to_string(port); + + ServerBuilder builder; + builder.AddListeningPort(server_address, InsecureServerCredentials()); + builder.RegisterService(&service_); + std::unique_ptr<Server> server = builder.BuildAndStart(); + return server; + } + + void RegisterService(const string& name, const string& value) { + char* path = (char*)gpr_malloc(name.size()); + + int status = zoo_exists(zookeeper_handle_, name.c_str(), 0, NULL); + if (status == ZNONODE) { + status = + zoo_create(zookeeper_handle_, name.c_str(), value.c_str(), + value.size(), &ZOO_OPEN_ACL_UNSAFE, 0, path, name.size()); + } else { + status = zoo_set(zookeeper_handle_, name.c_str(), value.c_str(), + value.size(), -1); + } + gpr_free(path); + GPR_ASSERT(status == 0); + } + + void DeleteService(const string& name) { + int status = zoo_delete(zookeeper_handle_, name.c_str(), -1); + GPR_ASSERT(status == 0); + } + + void ChangeZookeeperState() { + server1_->Shutdown(); + DeleteService("/test/1"); + } + + void TearDown() GRPC_OVERRIDE { + server1_->Shutdown(); + server2_->Shutdown(); + zookeeper_close(zookeeper_handle_); + } + + void ResetStub() { + string target = "zookeeper://" + zookeeper_address_ + "/test"; + channel_ = CreateChannel(target, InsecureCredentials(), ChannelArguments()); + stub_ = std::move(grpc::cpp::test::util::TestService::NewStub(channel_)); + } + + string to_string(const int number) { + std::stringstream strs; + strs << number; + return strs.str(); + } + + std::shared_ptr<Channel> channel_; + std::unique_ptr<grpc::cpp::test::util::TestService::Stub> stub_; + std::unique_ptr<Server> server1_; + std::unique_ptr<Server> server2_; + ZookeeperTestServiceImpl service_; + zhandle_t* zookeeper_handle_; + string zookeeper_address_; +}; + +// Tests zookeeper state change between two RPCs +// TODO(ctiller): leaked objects in this test +TEST_F(ZookeeperTest, ZookeeperStateChangeTwoRpc) { + ResetStub(); + + // First RPC + EchoRequest request1; + EchoResponse response1; + ClientContext context1; + context1.set_authority("test"); + request1.set_message("Hello"); + Status s1 = stub_->Echo(&context1, request1, &response1); + EXPECT_EQ(response1.message(), request1.message()); + EXPECT_TRUE(s1.ok()); + + // Zookeeper state changes + gpr_log(GPR_DEBUG, "Zookeeper state change"); + ChangeZookeeperState(); + // Waits for re-resolving addresses + // TODO(ctiller): RPC will probably fail if not waiting + sleep(1); + + // Second RPC + EchoRequest request2; + EchoResponse response2; + ClientContext context2; + context2.set_authority("test"); + request2.set_message("World"); + Status s2 = stub_->Echo(&context2, request2, &response2); + EXPECT_EQ(response2.message(), request2.message()); + EXPECT_TRUE(s2.ok()); +} + +} // 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/interop/client.cc b/test/cpp/interop/client.cc index ebc5cfc85a..cb5232153b 100644 --- a/test/cpp/interop/client.cc +++ b/test/cpp/interop/client.cc @@ -38,10 +38,9 @@ #include <grpc/grpc.h> #include <grpc/support/log.h> #include <gflags/gflags.h> -#include <grpc++/channel_interface.h> +#include <grpc++/channel.h> #include <grpc++/client_context.h> -#include <grpc++/status.h> -#include <grpc++/stream.h> + #include "test/cpp/interop/client_helper.h" #include "test/cpp/interop/interop_client.h" #include "test/cpp/util/test_config.h" @@ -56,8 +55,12 @@ DEFINE_string(test_case, "large_unary", "Configure different test cases. Valid options are: " "empty_unary : empty (zero bytes) request and response; " "large_unary : single request and (large) response; " + "large_compressed_unary : single request and compressed (large) " + "response; " "client_streaming : request streaming with single response; " "server_streaming : single request with response streaming; " + "server_compressed_streaming : single request with compressed " + "response streaming; " "slow_consumer : single request with response; " " streaming with slow client consumer; " "half_duplex : half-duplex streaming; " @@ -70,7 +73,7 @@ DEFINE_string(test_case, "large_unary", "jwt_token_creds: large_unary with JWT token auth; " "oauth2_auth_token: raw oauth2 access token auth; " "per_rpc_creds: raw oauth2 access token on a single rpc; " - "status_code_and_message: verify status code & message; " + "status_code_and_message: verify status code & message; " "all : all of above."); DEFINE_string(default_service_account, "", "Email of GCE default service account"); @@ -91,10 +94,14 @@ int main(int argc, char** argv) { client.DoEmpty(); } else if (FLAGS_test_case == "large_unary") { client.DoLargeUnary(); + } else if (FLAGS_test_case == "large_compressed_unary") { + client.DoLargeCompressedUnary(); } else if (FLAGS_test_case == "client_streaming") { client.DoRequestStreaming(); } else if (FLAGS_test_case == "server_streaming") { client.DoResponseStreaming(); + } else if (FLAGS_test_case == "server_compressed_streaming") { + client.DoResponseCompressedStreaming(); } else if (FLAGS_test_case == "slow_consumer") { client.DoResponseStreamingWithSlowConsumer(); } else if (FLAGS_test_case == "half_duplex") { @@ -129,6 +136,7 @@ int main(int argc, char** argv) { client.DoLargeUnary(); client.DoRequestStreaming(); client.DoResponseStreaming(); + client.DoResponseCompressedStreaming(); client.DoHalfDuplex(); client.DoPingPong(); client.DoCancelAfterBegin(); @@ -148,10 +156,11 @@ int main(int argc, char** argv) { gpr_log( GPR_ERROR, "Unsupported test case %s. Valid options are all|empty_unary|" - "large_unary|client_streaming|server_streaming|half_duplex|ping_pong|" - "cancel_after_begin|cancel_after_first_response|" - "timeout_on_sleeping_server|service_account_creds|compute_engine_creds|" - "jwt_token_creds|oauth2_auth_token|per_rpc_creds", + "large_unary|large_compressed_unary|client_streaming|server_streaming|" + "server_compressed_streaming|half_duplex|ping_pong|cancel_after_begin|" + "cancel_after_first_response|timeout_on_sleeping_server|" + "service_account_creds|compute_engine_creds|jwt_token_creds|" + "oauth2_auth_token|per_rpc_creds", FLAGS_test_case.c_str()); ret = 1; } diff --git a/test/cpp/interop/client_helper.cc b/test/cpp/interop/client_helper.cc index 73d82f7b88..abc14aeb98 100644 --- a/test/cpp/interop/client_helper.cc +++ b/test/cpp/interop/client_helper.cc @@ -33,21 +33,20 @@ #include "test/cpp/interop/client_helper.h" +#include <unistd.h> + #include <fstream> #include <memory> #include <sstream> -#include <unistd.h> - #include <grpc/grpc.h> #include <grpc/support/alloc.h> #include <grpc/support/log.h> #include <gflags/gflags.h> -#include <grpc++/channel_arguments.h> -#include <grpc++/channel_interface.h> +#include <grpc++/channel.h> #include <grpc++/create_channel.h> #include <grpc++/credentials.h> -#include <grpc++/stream.h> + #include "src/cpp/client/secure_credentials.h" #include "test/core/security/oauth2_utils.h" #include "test/cpp/util/create_test_channel.h" @@ -100,7 +99,7 @@ grpc::string GetOauth2AccessToken() { return access_token; } -std::shared_ptr<ChannelInterface> CreateChannelForTestCase( +std::shared_ptr<Channel> CreateChannelForTestCase( const grpc::string& test_case) { GPR_ASSERT(FLAGS_server_port); const int host_port_buf_size = 1024; diff --git a/test/cpp/interop/client_helper.h b/test/cpp/interop/client_helper.h index c4361bb9de..92d5078f48 100644 --- a/test/cpp/interop/client_helper.h +++ b/test/cpp/interop/client_helper.h @@ -36,8 +36,9 @@ #include <memory> -#include <grpc++/config.h> -#include <grpc++/channel_interface.h> +#include <grpc++/channel.h> + +#include "src/core/surface/call.h" namespace grpc { namespace testing { @@ -46,9 +47,27 @@ grpc::string GetServiceAccountJsonKey(); grpc::string GetOauth2AccessToken(); -std::shared_ptr<ChannelInterface> CreateChannelForTestCase( +std::shared_ptr<Channel> CreateChannelForTestCase( const grpc::string& test_case); +class InteropClientContextInspector { + public: + InteropClientContextInspector(const ::grpc::ClientContext& context) + : context_(context) {} + + // Inspector methods, able to peek inside ClientContext, follow. + grpc_compression_algorithm GetCallCompressionAlgorithm() const { + return grpc_call_get_compression_algorithm(context_.call_); + } + + gpr_uint32 GetMessageFlags() const { + return grpc_call_get_message_flags(context_.call_); + } + + private: + const ::grpc::ClientContext& context_; +}; + } // namespace testing } // namespace grpc diff --git a/test/cpp/interop/interop_client.cc b/test/cpp/interop/interop_client.cc index dfb90fadc2..ca13cdc53d 100644 --- a/test/cpp/interop/interop_client.cc +++ b/test/cpp/interop/interop_client.cc @@ -33,17 +33,20 @@ #include "test/cpp/interop/interop_client.h" -#include <memory> - #include <unistd.h> +#include <fstream> +#include <memory> + #include <grpc/grpc.h> #include <grpc/support/log.h> -#include <grpc++/channel_interface.h> +#include <grpc/support/string_util.h> +#include <grpc/support/useful.h> +#include <grpc++/channel.h> #include <grpc++/client_context.h> #include <grpc++/credentials.h> -#include <grpc++/status.h> -#include <grpc++/stream.h> + +#include "src/core/transport/stream_op.h" #include "test/cpp/interop/client_helper.h" #include "test/proto/test.grpc.pb.h" #include "test/proto/empty.grpc.pb.h" @@ -52,6 +55,8 @@ namespace grpc { namespace testing { +static const char* kRandomFile = "test/cpp/interop/rnd.dat"; + namespace { // The same value is defined by the Java client. const std::vector<int> request_stream_sizes = {27182, 8, 1828, 45904}; @@ -61,9 +66,23 @@ const int kResponseMessageSize = 1030; const int kReceiveDelayMilliSeconds = 20; const int kLargeRequestSize = 271828; const int kLargeResponseSize = 314159; + +CompressionType GetInteropCompressionTypeFromCompressionAlgorithm( + grpc_compression_algorithm algorithm) { + switch (algorithm) { + case GRPC_COMPRESS_NONE: + return CompressionType::NONE; + case GRPC_COMPRESS_GZIP: + return CompressionType::GZIP; + case GRPC_COMPRESS_DEFLATE: + return CompressionType::DEFLATE; + default: + GPR_ASSERT(false); + } +} } // namespace -InteropClient::InteropClient(std::shared_ptr<ChannelInterface> channel) +InteropClient::InteropClient(std::shared_ptr<Channel> channel) : channel_(channel) {} void InteropClient::AssertOkOrPrintErrorStatus(const Status& s) { @@ -95,17 +114,48 @@ void InteropClient::PerformLargeUnary(SimpleRequest* request, std::unique_ptr<TestService::Stub> stub(TestService::NewStub(channel_)); ClientContext context; - request->set_response_type(PayloadType::COMPRESSABLE); + InteropClientContextInspector inspector(context); + // If the request doesn't already specify the response type, default to + // COMPRESSABLE. request->set_response_size(kLargeResponseSize); grpc::string payload(kLargeRequestSize, '\0'); request->mutable_payload()->set_body(payload.c_str(), kLargeRequestSize); Status s = stub->UnaryCall(&context, *request, response); + // Compression related checks. + GPR_ASSERT(request->response_compression() == + GetInteropCompressionTypeFromCompressionAlgorithm( + inspector.GetCallCompressionAlgorithm())); + if (request->response_compression() == NONE) { + GPR_ASSERT(!(inspector.GetMessageFlags() & GRPC_WRITE_INTERNAL_COMPRESS)); + } else if (request->response_type() == PayloadType::COMPRESSABLE) { + // requested compression and compressable response => results should always + // be compressed. + GPR_ASSERT(inspector.GetMessageFlags() & GRPC_WRITE_INTERNAL_COMPRESS); + } + AssertOkOrPrintErrorStatus(s); - GPR_ASSERT(response->payload().type() == PayloadType::COMPRESSABLE); - GPR_ASSERT(response->payload().body() == - grpc::string(kLargeResponseSize, '\0')); + + // Payload related checks. + if (request->response_type() != PayloadType::RANDOM) { + GPR_ASSERT(response->payload().type() == request->response_type()); + } + switch (response->payload().type()) { + case PayloadType::COMPRESSABLE: + GPR_ASSERT(response->payload().body() == + grpc::string(kLargeResponseSize, '\0')); + break; + case PayloadType::UNCOMPRESSABLE: { + std::ifstream rnd_file(kRandomFile); + GPR_ASSERT(rnd_file.good()); + for (int i = 0; i < kLargeResponseSize; i++) { + GPR_ASSERT(response->payload().body()[i] == (char)rnd_file.get()); + } + } break; + default: + GPR_ASSERT(false); + } } void InteropClient::DoComputeEngineCreds( @@ -117,6 +167,7 @@ void InteropClient::DoComputeEngineCreds( SimpleResponse response; request.set_fill_username(true); request.set_fill_oauth_scope(true); + request.set_response_type(PayloadType::COMPRESSABLE); PerformLargeUnary(&request, &response); gpr_log(GPR_INFO, "Got username %s", response.username().c_str()); gpr_log(GPR_INFO, "Got oauth_scope %s", response.oauth_scope().c_str()); @@ -136,6 +187,7 @@ void InteropClient::DoServiceAccountCreds(const grpc::string& username, SimpleResponse response; request.set_fill_username(true); request.set_fill_oauth_scope(true); + request.set_response_type(PayloadType::COMPRESSABLE); PerformLargeUnary(&request, &response); GPR_ASSERT(!response.username().empty()); GPR_ASSERT(!response.oauth_scope().empty()); @@ -199,6 +251,7 @@ void InteropClient::DoJwtTokenCreds(const grpc::string& username) { SimpleRequest request; SimpleResponse response; request.set_fill_username(true); + request.set_response_type(PayloadType::COMPRESSABLE); PerformLargeUnary(&request, &response); GPR_ASSERT(!response.username().empty()); GPR_ASSERT(username.find(response.username()) != grpc::string::npos); @@ -209,10 +262,33 @@ void InteropClient::DoLargeUnary() { gpr_log(GPR_INFO, "Sending a large unary rpc..."); SimpleRequest request; SimpleResponse response; + request.set_response_type(PayloadType::COMPRESSABLE); PerformLargeUnary(&request, &response); gpr_log(GPR_INFO, "Large unary done."); } +void InteropClient::DoLargeCompressedUnary() { + const CompressionType compression_types[] = {NONE, GZIP, DEFLATE}; + const PayloadType payload_types[] = {COMPRESSABLE, UNCOMPRESSABLE, RANDOM}; + for (size_t i = 0; i < GPR_ARRAY_SIZE(payload_types); i++) { + for (size_t j = 0; j < GPR_ARRAY_SIZE(compression_types); j++) { + char* log_suffix; + gpr_asprintf(&log_suffix, "(compression=%s; payload=%s)", + CompressionType_Name(compression_types[j]).c_str(), + PayloadType_Name(payload_types[i]).c_str()); + + gpr_log(GPR_INFO, "Sending a large compressed unary rpc %s.", log_suffix); + SimpleRequest request; + SimpleResponse response; + request.set_response_type(payload_types[i]); + request.set_response_compression(compression_types[j]); + PerformLargeUnary(&request, &response); + gpr_log(GPR_INFO, "Large compressed unary done %s.", log_suffix); + gpr_free(log_suffix); + } + } +} + void InteropClient::DoRequestStreaming() { gpr_log(GPR_INFO, "Sending request steaming rpc ..."); std::unique_ptr<TestService::Stub> stub(TestService::NewStub(channel_)); @@ -261,11 +337,90 @@ void InteropClient::DoResponseStreaming() { } GPR_ASSERT(response_stream_sizes.size() == i); Status s = stream->Finish(); - AssertOkOrPrintErrorStatus(s); gpr_log(GPR_INFO, "Response streaming done."); } +void InteropClient::DoResponseCompressedStreaming() { + std::unique_ptr<TestService::Stub> stub(TestService::NewStub(channel_)); + + const CompressionType compression_types[] = {NONE, GZIP, DEFLATE}; + const PayloadType payload_types[] = {COMPRESSABLE, UNCOMPRESSABLE, RANDOM}; + for (size_t i = 0; i < GPR_ARRAY_SIZE(payload_types); i++) { + for (size_t j = 0; j < GPR_ARRAY_SIZE(compression_types); j++) { + ClientContext context; + InteropClientContextInspector inspector(context); + StreamingOutputCallRequest request; + + char* log_suffix; + gpr_asprintf(&log_suffix, "(compression=%s; payload=%s)", + CompressionType_Name(compression_types[j]).c_str(), + PayloadType_Name(payload_types[i]).c_str()); + + gpr_log(GPR_INFO, "Receiving response steaming rpc %s.", log_suffix); + + request.set_response_type(payload_types[i]); + request.set_response_compression(compression_types[j]); + + for (size_t k = 0; k < response_stream_sizes.size(); ++k) { + ResponseParameters* response_parameter = + request.add_response_parameters(); + response_parameter->set_size(response_stream_sizes[k]); + } + StreamingOutputCallResponse response; + + std::unique_ptr<ClientReader<StreamingOutputCallResponse>> stream( + stub->StreamingOutputCall(&context, request)); + + size_t k = 0; + while (stream->Read(&response)) { + // Payload related checks. + if (request.response_type() != PayloadType::RANDOM) { + GPR_ASSERT(response.payload().type() == request.response_type()); + } + switch (response.payload().type()) { + case PayloadType::COMPRESSABLE: + GPR_ASSERT(response.payload().body() == + grpc::string(response_stream_sizes[k], '\0')); + break; + case PayloadType::UNCOMPRESSABLE: { + std::ifstream rnd_file(kRandomFile); + GPR_ASSERT(rnd_file.good()); + for (int n = 0; n < response_stream_sizes[k]; n++) { + GPR_ASSERT(response.payload().body()[n] == (char)rnd_file.get()); + } + } break; + default: + GPR_ASSERT(false); + } + + // Compression related checks. + GPR_ASSERT(request.response_compression() == + GetInteropCompressionTypeFromCompressionAlgorithm( + inspector.GetCallCompressionAlgorithm())); + if (request.response_compression() == NONE) { + GPR_ASSERT( + !(inspector.GetMessageFlags() & GRPC_WRITE_INTERNAL_COMPRESS)); + } else if (request.response_type() == PayloadType::COMPRESSABLE) { + // requested compression and compressable response => results should + // always be compressed. + GPR_ASSERT(inspector.GetMessageFlags() & + GRPC_WRITE_INTERNAL_COMPRESS); + } + + ++k; + } + + GPR_ASSERT(response_stream_sizes.size() == k); + Status s = stream->Finish(); + + AssertOkOrPrintErrorStatus(s); + gpr_log(GPR_INFO, "Response streaming done %s.", log_suffix); + gpr_free(log_suffix); + } + } +} + void InteropClient::DoResponseStreamingWithSlowConsumer() { gpr_log(GPR_INFO, "Receiving response steaming rpc with slow consumer ..."); std::unique_ptr<TestService::Stub> stub(TestService::NewStub(channel_)); @@ -316,7 +471,6 @@ void InteropClient::DoHalfDuplex() { unsigned int i = 0; StreamingOutputCallResponse response; while (stream->Read(&response)) { - GPR_ASSERT(response.payload().has_body()); GPR_ASSERT(response.payload().body() == grpc::string(response_stream_sizes[i], '\0')); ++i; @@ -346,7 +500,6 @@ void InteropClient::DoPingPong() { payload->set_body(grpc::string(request_stream_sizes[i], '\0')); GPR_ASSERT(stream->Write(request)); GPR_ASSERT(stream->Read(&response)); - GPR_ASSERT(response.payload().has_body()); GPR_ASSERT(response.payload().body() == grpc::string(response_stream_sizes[i], '\0')); } @@ -393,7 +546,6 @@ void InteropClient::DoCancelAfterFirstResponse() { StreamingOutputCallResponse response; GPR_ASSERT(stream->Write(request)); GPR_ASSERT(stream->Read(&response)); - GPR_ASSERT(response.payload().has_body()); GPR_ASSERT(response.payload().body() == grpc::string(31415, '\0')); gpr_log(GPR_INFO, "Trying to cancel..."); context.TryCancel(); @@ -430,7 +582,7 @@ void InteropClient::DoStatusWithMessage() { ClientContext context; SimpleRequest request; SimpleResponse response; - EchoStatus *requested_status = request.mutable_response_status(); + EchoStatus* requested_status = request.mutable_response_status(); requested_status->set_code(grpc::StatusCode::UNKNOWN); grpc::string test_msg = "This is a test message"; requested_status->set_message(test_msg); diff --git a/test/cpp/interop/interop_client.h b/test/cpp/interop/interop_client.h index 6e26c49e5d..5e26cc82e6 100644 --- a/test/cpp/interop/interop_client.h +++ b/test/cpp/interop/interop_client.h @@ -33,11 +33,11 @@ #ifndef GRPC_TEST_CPP_INTEROP_INTEROP_CLIENT_H #define GRPC_TEST_CPP_INTEROP_INTEROP_CLIENT_H + #include <memory> #include <grpc/grpc.h> -#include <grpc++/channel_interface.h> -#include <grpc++/status.h> +#include <grpc++/channel.h> #include "test/proto/messages.grpc.pb.h" namespace grpc { @@ -45,17 +45,19 @@ namespace testing { class InteropClient { public: - explicit InteropClient(std::shared_ptr<ChannelInterface> channel); + explicit InteropClient(std::shared_ptr<Channel> channel); ~InteropClient() {} - void Reset(std::shared_ptr<ChannelInterface> channel) { channel_ = channel; } + void Reset(std::shared_ptr<Channel> channel) { channel_ = channel; } void DoEmpty(); void DoLargeUnary(); + void DoLargeCompressedUnary(); void DoPingPong(); void DoHalfDuplex(); void DoRequestStreaming(); void DoResponseStreaming(); + void DoResponseCompressedStreaming(); void DoResponseStreamingWithSlowConsumer(); void DoCancelAfterBegin(); void DoCancelAfterFirstResponse(); @@ -80,7 +82,7 @@ class InteropClient { void PerformLargeUnary(SimpleRequest* request, SimpleResponse* response); void AssertOkOrPrintErrorStatus(const Status& s); - std::shared_ptr<ChannelInterface> channel_; + std::shared_ptr<Channel> channel_; }; } // namespace testing diff --git a/test/cpp/interop/interop_test.cc b/test/cpp/interop/interop_test.cc index aac6e56b89..f01b032e95 100644 --- a/test/cpp/interop/interop_test.cc +++ b/test/cpp/interop/interop_test.cc @@ -44,17 +44,18 @@ #include <sys/types.h> #include <sys/wait.h> -extern "C" { -#include "src/core/iomgr/socket_utils_posix.h" -#include "src/core/support/string.h" -} - #include <grpc/support/alloc.h> #include <grpc/support/host_port.h> #include <grpc/support/log.h> #include <grpc/support/string_util.h> #include "test/core/util/port.h" +extern "C" { +#include "src/core/iomgr/socket_utils_posix.h" +#include "src/core/support/string.h" +} + + int test_client(const char* root, const char* host, int port) { int status; pid_t cli; diff --git a/test/cpp/interop/reconnect_interop_client.cc b/test/cpp/interop/reconnect_interop_client.cc index 65f098050e..d332dcad84 100644 --- a/test/cpp/interop/reconnect_interop_client.cc +++ b/test/cpp/interop/reconnect_interop_client.cc @@ -37,9 +37,8 @@ #include <grpc/grpc.h> #include <grpc/support/log.h> #include <gflags/gflags.h> -#include <grpc++/channel_interface.h> +#include <grpc++/channel.h> #include <grpc++/client_context.h> -#include <grpc++/status.h> #include "test/cpp/util/create_test_channel.h" #include "test/cpp/util/test_config.h" #include "test/proto/test.grpc.pb.h" @@ -50,7 +49,7 @@ DEFINE_int32(server_control_port, 0, "Server port for control rpcs."); DEFINE_int32(server_retry_port, 0, "Server port for testing reconnection."); DEFINE_string(server_host, "127.0.0.1", "Server host to connect to"); -using grpc::ChannelInterface; +using grpc::Channel; using grpc::ClientContext; using grpc::CreateTestChannel; using grpc::Status; @@ -78,7 +77,7 @@ int main(int argc, char** argv) { gpr_log(GPR_INFO, "Starting connections with retries."); server_address.str(""); server_address << FLAGS_server_host << ':' << FLAGS_server_retry_port; - std::shared_ptr<ChannelInterface> retry_channel = + std::shared_ptr<Channel> retry_channel = CreateTestChannel(server_address.str(), true); // About 13 retries. const int kDeadlineSeconds = 540; diff --git a/test/cpp/interop/reconnect_interop_server.cc b/test/cpp/interop/reconnect_interop_server.cc index 8bc51aa52e..d4f171b1d0 100644 --- a/test/cpp/interop/reconnect_interop_server.cc +++ b/test/cpp/interop/reconnect_interop_server.cc @@ -31,23 +31,22 @@ * */ +#include <signal.h> +#include <unistd.h> + #include <condition_variable> #include <memory> #include <mutex> #include <sstream> -#include <signal.h> -#include <unistd.h> - #include <gflags/gflags.h> #include <grpc/grpc.h> #include <grpc/support/log.h> -#include <grpc++/config.h> #include <grpc++/server.h> #include <grpc++/server_builder.h> #include <grpc++/server_context.h> #include <grpc++/server_credentials.h> -#include <grpc++/status.h> + #include "test/core/util/reconnect_server.h" #include "test/cpp/util/test_config.h" #include "test/proto/test.grpc.pb.h" diff --git a/test/cpp/interop/rnd.dat b/test/cpp/interop/rnd.dat Binary files differnew file mode 100644 index 0000000000..8c7f38f9e0 --- /dev/null +++ b/test/cpp/interop/rnd.dat diff --git a/test/cpp/interop/server.cc b/test/cpp/interop/server.cc index 05a10de51e..4921fde9fa 100644 --- a/test/cpp/interop/server.cc +++ b/test/cpp/interop/server.cc @@ -31,28 +31,28 @@ * */ +#include <signal.h> +#include <unistd.h> + +#include <fstream> #include <memory> #include <sstream> #include <thread> -#include <signal.h> -#include <unistd.h> - #include <gflags/gflags.h> #include <grpc/grpc.h> #include <grpc/support/log.h> -#include <grpc++/config.h> +#include <grpc/support/useful.h> #include <grpc++/server.h> #include <grpc++/server_builder.h> #include <grpc++/server_context.h> #include <grpc++/server_credentials.h> -#include <grpc++/status.h> -#include <grpc++/stream.h> + +#include "test/cpp/interop/server_helper.h" +#include "test/cpp/util/test_config.h" #include "test/proto/test.grpc.pb.h" #include "test/proto/empty.grpc.pb.h" #include "test/proto/messages.grpc.pb.h" -#include "test/cpp/interop/server_helper.h" -#include "test/cpp/util/test_config.h" DEFINE_bool(enable_ssl, false, "Whether to use ssl/tls."); DEFINE_int32(port, 0, "Server port."); @@ -65,6 +65,7 @@ using grpc::ServerReader; using grpc::ServerReaderWriter; using grpc::ServerWriter; using grpc::SslServerCredentialsOptions; +using grpc::testing::InteropServerContextInspector; using grpc::testing::Payload; using grpc::testing::PayloadType; using grpc::testing::SimpleRequest; @@ -77,19 +78,54 @@ using grpc::testing::TestService; using grpc::Status; static bool got_sigint = false; +static const char* kRandomFile = "test/cpp/interop/rnd.dat"; bool SetPayload(PayloadType type, int size, Payload* payload) { - PayloadType response_type = type; - // TODO(yangg): Support UNCOMPRESSABLE payload. - if (type != PayloadType::COMPRESSABLE) { - return false; + PayloadType response_type; + if (type == PayloadType::RANDOM) { + response_type = + rand() & 0x1 ? PayloadType::COMPRESSABLE : PayloadType::UNCOMPRESSABLE; + } else { + response_type = type; } payload->set_type(response_type); - std::unique_ptr<char[]> body(new char[size]()); - payload->set_body(body.get(), size); + switch (response_type) { + case PayloadType::COMPRESSABLE: { + std::unique_ptr<char[]> body(new char[size]()); + payload->set_body(body.get(), size); + } break; + case PayloadType::UNCOMPRESSABLE: { + std::unique_ptr<char[]> body(new char[size]()); + std::ifstream rnd_file(kRandomFile); + GPR_ASSERT(rnd_file.good()); + rnd_file.read(body.get(), size); + GPR_ASSERT(!rnd_file.eof()); // Requested more rnd bytes than available + payload->set_body(body.get(), size); + } break; + default: + GPR_ASSERT(false); + } return true; } +template <typename RequestType> +void SetResponseCompression(ServerContext* context, + const RequestType& request) { + switch (request.response_compression()) { + case grpc::testing::NONE: + context->set_compression_algorithm(GRPC_COMPRESS_NONE); + break; + case grpc::testing::GZIP: + context->set_compression_algorithm(GRPC_COMPRESS_GZIP); + break; + case grpc::testing::DEFLATE: + context->set_compression_algorithm(GRPC_COMPRESS_DEFLATE); + break; + default: + abort(); + } +} + class TestServiceImpl : public TestService::Service { public: Status EmptyCall(ServerContext* context, const grpc::testing::Empty* request, @@ -99,7 +135,8 @@ class TestServiceImpl : public TestService::Service { Status UnaryCall(ServerContext* context, const SimpleRequest* request, SimpleResponse* response) { - if (request->has_response_size() && request->response_size() > 0) { + SetResponseCompression(context, *request); + if (request->response_size() > 0) { if (!SetPayload(request->response_type(), request->response_size(), response->mutable_payload())) { return Status(grpc::StatusCode::INTERNAL, "Error creating payload."); @@ -107,9 +144,9 @@ class TestServiceImpl : public TestService::Service { } if (request->has_response_status()) { - return Status(static_cast<grpc::StatusCode> - (request->response_status().code()), - request->response_status().message()); + return Status( + static_cast<grpc::StatusCode>(request->response_status().code()), + request->response_status().message()); } return Status::OK; @@ -118,13 +155,16 @@ class TestServiceImpl : public TestService::Service { Status StreamingOutputCall( ServerContext* context, const StreamingOutputCallRequest* request, ServerWriter<StreamingOutputCallResponse>* writer) { + SetResponseCompression(context, *request); StreamingOutputCallResponse response; bool write_success = true; - response.mutable_payload()->set_type(request->response_type()); for (int i = 0; write_success && i < request->response_parameters_size(); i++) { - response.mutable_payload()->set_body( - grpc::string(request->response_parameters(i).size(), '\0')); + if (!SetPayload(request->response_type(), + request->response_parameters(i).size(), + response.mutable_payload())) { + return Status(grpc::StatusCode::INTERNAL, "Error creating payload."); + } write_success = writer->Write(response); } if (write_success) { @@ -140,7 +180,7 @@ class TestServiceImpl : public TestService::Service { StreamingInputCallRequest request; int aggregated_payload_size = 0; while (reader->Read(&request)) { - if (request.has_payload() && request.payload().has_body()) { + if (request.has_payload()) { aggregated_payload_size += request.payload().body().size(); } } @@ -156,6 +196,7 @@ class TestServiceImpl : public TestService::Service { StreamingOutputCallResponse response; bool write_success = true; while (write_success && stream->Read(&request)) { + SetResponseCompression(context, request); if (request.response_parameters_size() != 0) { response.mutable_payload()->set_type(request.payload().type()); response.mutable_payload()->set_body( diff --git a/test/cpp/interop/server_helper.cc b/test/cpp/interop/server_helper.cc index 30a78ffddf..e897f4ebf0 100644 --- a/test/cpp/interop/server_helper.cc +++ b/test/cpp/interop/server_helper.cc @@ -36,10 +36,11 @@ #include <memory> #include <gflags/gflags.h> -#include "test/core/end2end/data/ssl_test_data.h" -#include <grpc++/config.h> #include <grpc++/server_credentials.h> +#include "src/core/surface/call.h" +#include "test/core/end2end/data/ssl_test_data.h" + DECLARE_bool(enable_ssl); namespace grpc { @@ -58,16 +59,25 @@ std::shared_ptr<ServerCredentials> CreateInteropServerCredentials() { } } -InteropContextInspector::InteropContextInspector( +InteropServerContextInspector::InteropServerContextInspector( const ::grpc::ServerContext& context) : context_(context) {} -std::shared_ptr<const AuthContext> InteropContextInspector::GetAuthContext() - const { +grpc_compression_algorithm +InteropServerContextInspector::GetCallCompressionAlgorithm() const { + return grpc_call_get_compression_algorithm(context_.call_); +} + +gpr_uint32 InteropServerContextInspector::GetEncodingsAcceptedByClient() const { + return grpc_call_get_encodings_accepted_by_peer(context_.call_); +} + +std::shared_ptr<const AuthContext> +InteropServerContextInspector::GetAuthContext() const { return context_.auth_context(); } -bool InteropContextInspector::IsCancelled() const { +bool InteropServerContextInspector::IsCancelled() const { return context_.IsCancelled(); } diff --git a/test/cpp/interop/server_helper.h b/test/cpp/interop/server_helper.h index ce977b4705..7b6b12cd4d 100644 --- a/test/cpp/interop/server_helper.h +++ b/test/cpp/interop/server_helper.h @@ -36,6 +36,7 @@ #include <memory> +#include <grpc/compression.h> #include <grpc++/server_context.h> #include <grpc++/server_credentials.h> @@ -44,13 +45,15 @@ namespace testing { std::shared_ptr<ServerCredentials> CreateInteropServerCredentials(); -class InteropContextInspector { +class InteropServerContextInspector { public: - InteropContextInspector(const ::grpc::ServerContext& context); + InteropServerContextInspector(const ::grpc::ServerContext& context); // Inspector methods, able to peek inside ServerContext, follow. std::shared_ptr<const AuthContext> GetAuthContext() const; bool IsCancelled() const; + grpc_compression_algorithm GetCallCompressionAlgorithm() const; + gpr_uint32 GetEncodingsAcceptedByClient() const; private: const ::grpc::ServerContext& context_; diff --git a/test/cpp/qps/client.h b/test/cpp/qps/client.h index 1c4f46328f..0f95cfea38 100644 --- a/test/cpp/qps/client.h +++ b/test/cpp/qps/client.h @@ -34,14 +34,14 @@ #ifndef TEST_QPS_CLIENT_H #define TEST_QPS_CLIENT_H +#include <condition_variable> +#include <mutex> + #include "test/cpp/qps/histogram.h" #include "test/cpp/qps/interarrival.h" #include "test/cpp/qps/timer.h" #include "test/cpp/qps/qpstest.grpc.pb.h" - -#include <condition_variable> -#include <mutex> -#include <grpc++/config.h> +#include "test/cpp/util/create_test_channel.h" namespace grpc { @@ -125,11 +125,11 @@ class Client { channel_ = CreateTestChannel(target, config.enable_ssl()); stub_ = TestService::NewStub(channel_); } - ChannelInterface* get_channel() { return channel_.get(); } + Channel* get_channel() { return channel_.get(); } TestService::Stub* get_stub() { return stub_.get(); } private: - std::shared_ptr<ChannelInterface> channel_; + std::shared_ptr<Channel> channel_; std::unique_ptr<TestService::Stub> stub_; }; std::vector<ClientChannelInfo> channels_; diff --git a/test/cpp/qps/client_async.cc b/test/cpp/qps/client_async.cc index a337610cbf..f779e4a577 100644 --- a/test/cpp/qps/client_async.cc +++ b/test/cpp/qps/client_async.cc @@ -46,14 +46,12 @@ #include <grpc/support/histogram.h> #include <grpc/support/log.h> #include <gflags/gflags.h> -#include <grpc++/async_unary_call.h> #include <grpc++/client_context.h> -#include <grpc++/status.h> -#include <grpc++/stream.h> -#include "test/cpp/util/create_test_channel.h" + #include "test/cpp/qps/qpstest.grpc.pb.h" #include "test/cpp/qps/timer.h" #include "test/cpp/qps/client.h" +#include "test/cpp/util/create_test_channel.h" namespace grpc { namespace testing { diff --git a/test/cpp/qps/client_sync.cc b/test/cpp/qps/client_sync.cc index db5416a707..123dca6600 100644 --- a/test/cpp/qps/client_sync.cc +++ b/test/cpp/qps/client_sync.cc @@ -31,6 +31,8 @@ * */ +#include <sys/signal.h> + #include <cassert> #include <chrono> #include <memory> @@ -40,21 +42,18 @@ #include <vector> #include <sstream> -#include <sys/signal.h> - +#include <gflags/gflags.h> #include <grpc/grpc.h> #include <grpc/support/alloc.h> #include <grpc/support/histogram.h> #include <grpc/support/host_port.h> #include <grpc/support/log.h> #include <grpc/support/time.h> -#include <gflags/gflags.h> #include <grpc++/client_context.h> #include <grpc++/server.h> #include <grpc++/server_builder.h> -#include <grpc++/status.h> -#include <grpc++/stream.h> #include <gtest/gtest.h> + #include "test/cpp/util/create_test_channel.h" #include "test/cpp/qps/client.h" #include "test/cpp/qps/qpstest.grpc.pb.h" diff --git a/test/cpp/qps/driver.cc b/test/cpp/qps/driver.cc index 78e3720938..3bd61ea4e8 100644 --- a/test/cpp/qps/driver.cc +++ b/test/cpp/qps/driver.cc @@ -31,24 +31,24 @@ * */ -#include "test/cpp/qps/driver.h" -#include "src/core/support/env.h" +#include <unistd.h> +#include <list> +#include <thread> +#include <deque> +#include <vector> + #include <grpc/support/alloc.h> #include <grpc/support/log.h> #include <grpc/support/host_port.h> -#include <grpc++/channel_arguments.h> #include <grpc++/client_context.h> #include <grpc++/create_channel.h> -#include <grpc++/stream.h> -#include <list> -#include <thread> -#include <deque> -#include <vector> -#include <unistd.h> -#include "test/cpp/qps/histogram.h" -#include "test/cpp/qps/qps_worker.h" + +#include "src/core/support/env.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" +#include "test/cpp/qps/driver.h" +#include "test/cpp/qps/histogram.h" +#include "test/cpp/qps/qps_worker.h" using std::list; using std::thread; diff --git a/test/cpp/qps/interarrival.h b/test/cpp/qps/interarrival.h index 04d14f689f..841619e3ff 100644 --- a/test/cpp/qps/interarrival.h +++ b/test/cpp/qps/interarrival.h @@ -39,7 +39,7 @@ #include <cstdlib> #include <vector> -#include <grpc++/config.h> +#include <grpc++/support/config.h> namespace grpc { namespace testing { diff --git a/test/cpp/qps/perf_db_client.cc b/test/cpp/qps/perf_db_client.cc index 08d20f0b8d..98efd8c3e3 100644 --- a/test/cpp/qps/perf_db_client.cc +++ b/test/cpp/qps/perf_db_client.cc @@ -44,9 +44,7 @@ void PerfDbClient::setConfigs(const ClientConfig& client_config, } // sets the QPS -void PerfDbClient::setQps(double qps) { - qps_ = qps; -} +void PerfDbClient::setQps(double qps) { qps_ = qps; } // sets the QPS per core void PerfDbClient::setQpsPerCore(double qps_per_core) { @@ -54,10 +52,8 @@ void PerfDbClient::setQpsPerCore(double qps_per_core) { } // sets the 50th, 90th, 95th, 99th and 99.9th percentile latency -void PerfDbClient::setLatencies(double perc_lat_50, - double perc_lat_90, - double perc_lat_95, - double perc_lat_99, +void PerfDbClient::setLatencies(double perc_lat_50, double perc_lat_90, + double perc_lat_95, double perc_lat_99, double perc_lat_99_point_9) { perc_lat_50_ = perc_lat_50; perc_lat_90_ = perc_lat_90; @@ -68,7 +64,8 @@ void PerfDbClient::setLatencies(double perc_lat_50, // sets the server and client, user and system times void PerfDbClient::setTimes(double server_system_time, double server_user_time, - double client_system_time, double client_user_time) { + double client_system_time, + double client_user_time) { server_system_time_ = server_system_time; server_user_time_ = server_user_time; client_system_time_ = client_system_time; diff --git a/test/cpp/qps/perf_db_client.h b/test/cpp/qps/perf_db_client.h index ce7a88bbff..ae5d17074b 100644 --- a/test/cpp/qps/perf_db_client.h +++ b/test/cpp/qps/perf_db_client.h @@ -37,12 +37,11 @@ #include <cfloat> #include <grpc/grpc.h> -#include <grpc++/channel_arguments.h> -#include <grpc++/channel_interface.h> +#include <grpc++/support/channel_arguments.h> +#include <grpc++/channel.h> #include <grpc++/client_context.h> #include <grpc++/create_channel.h> #include <grpc++/credentials.h> -#include <grpc++/status.h> #include "test/cpp/qps/perf_db.grpc.pb.h" namespace grpc { @@ -65,7 +64,7 @@ class PerfDbClient { client_user_time_ = DBL_MIN; } - void init(std::shared_ptr<ChannelInterface> channel) { + void init(std::shared_ptr<Channel> channel) { stub_ = PerfDbTransfer::NewStub(channel); } @@ -82,9 +81,8 @@ class PerfDbClient { void setQpsPerCore(double qps_per_core); // sets the 50th, 90th, 95th, 99th and 99.9th percentile latency - void setLatencies(double perc_lat_50, double perc_lat_90, - double perc_lat_95, double perc_lat_99, - double perc_lat_99_point_9); + void setLatencies(double perc_lat_50, double perc_lat_90, double perc_lat_95, + double perc_lat_99, double perc_lat_99_point_9); // sets the server and client, user and system times void setTimes(double server_system_time, double server_user_time, diff --git a/test/cpp/qps/qps_interarrival_test.cc b/test/cpp/qps/qps_interarrival_test.cc index cecd1be03f..a7979e6187 100644 --- a/test/cpp/qps/qps_interarrival_test.cc +++ b/test/cpp/qps/qps_interarrival_test.cc @@ -31,18 +31,18 @@ * */ -#include "test/cpp/qps/interarrival.h" #include <chrono> #include <iostream> // Use the C histogram rather than C++ to avoid depending on proto #include <grpc/support/histogram.h> -#include <grpc++/config.h> + +#include "test/cpp/qps/interarrival.h" using grpc::testing::RandomDist; using grpc::testing::InterarrivalTimer; -void RunTest(RandomDist&& r, int threads, std::string title) { +void RunTest(RandomDist &&r, int threads, std::string title) { InterarrivalTimer timer; timer.init(r, threads); gpr_histogram *h(gpr_histogram_create(0.01, 60e9)); diff --git a/test/cpp/qps/qps_openloop_test.cc b/test/cpp/qps/qps_openloop_test.cc index 96a9b4504c..5a6a9249a9 100644 --- a/test/cpp/qps/qps_openloop_test.cc +++ b/test/cpp/qps/qps_openloop_test.cc @@ -31,12 +31,12 @@ * */ +#include <signal.h> + #include <set> #include <grpc/support/log.h> -#include <signal.h> - #include "test/cpp/qps/driver.h" #include "test/cpp/qps/report.h" #include "test/cpp/util/benchmark_config.h" @@ -59,8 +59,8 @@ static void RunQPS() { client_config.set_async_client_threads(8); client_config.set_rpc_type(UNARY); client_config.set_load_type(POISSON); - client_config.mutable_load_params()-> - mutable_poisson()->set_offered_load(1000.0); + client_config.mutable_load_params()->mutable_poisson()->set_offered_load( + 1000.0); ServerConfig server_config; server_config.set_server_type(ASYNC_SERVER); diff --git a/test/cpp/qps/qps_test.cc b/test/cpp/qps/qps_test.cc index ba980a6664..d0c4a79cd9 100644 --- a/test/cpp/qps/qps_test.cc +++ b/test/cpp/qps/qps_test.cc @@ -31,12 +31,12 @@ * */ +#include <signal.h> + #include <set> #include <grpc/support/log.h> -#include <signal.h> - #include "test/cpp/qps/driver.h" #include "test/cpp/qps/report.h" #include "test/cpp/util/benchmark_config.h" diff --git a/test/cpp/qps/qps_test_with_poll.cc b/test/cpp/qps/qps_test_with_poll.cc index 90a8da8d11..31d2c1bf7b 100644 --- a/test/cpp/qps/qps_test_with_poll.cc +++ b/test/cpp/qps/qps_test_with_poll.cc @@ -31,12 +31,12 @@ * */ +#include <signal.h> + #include <set> #include <grpc/support/log.h> -#include <signal.h> - #include "test/cpp/qps/driver.h" #include "test/cpp/qps/report.h" #include "test/cpp/util/benchmark_config.h" diff --git a/test/cpp/qps/qps_worker.cc b/test/cpp/qps/qps_worker.cc index f1cea5ee66..51e955a80a 100644 --- a/test/cpp/qps/qps_worker.cc +++ b/test/cpp/qps/qps_worker.cc @@ -47,16 +47,15 @@ #include <grpc/support/log.h> #include <grpc/support/host_port.h> #include <grpc++/client_context.h> -#include <grpc++/status.h> #include <grpc++/server.h> #include <grpc++/server_builder.h> #include <grpc++/server_credentials.h> -#include <grpc++/stream.h> + #include "test/core/util/grpc_profiler.h" -#include "test/cpp/util/create_test_channel.h" #include "test/cpp/qps/qpstest.pb.h" #include "test/cpp/qps/client.h" #include "test/cpp/qps/server.h" +#include "test/cpp/util/create_test_channel.h" namespace grpc { namespace testing { diff --git a/test/cpp/qps/report.h b/test/cpp/qps/report.h index aec3cbe80a..620abade39 100644 --- a/test/cpp/qps/report.h +++ b/test/cpp/qps/report.h @@ -37,7 +37,8 @@ #include <memory> #include <set> #include <vector> -#include <grpc++/config.h> + +#include <grpc++/support/config.h> #include "test/cpp/qps/driver.h" #include "test/cpp/qps/qpstest.grpc.pb.h" diff --git a/test/cpp/qps/server_async.cc b/test/cpp/qps/server_async.cc index b4fc49c31c..77415f42ce 100644 --- a/test/cpp/qps/server_async.cc +++ b/test/cpp/qps/server_async.cc @@ -41,22 +41,20 @@ #include <thread> #include <gflags/gflags.h> +#include <grpc/grpc.h> #include <grpc/support/alloc.h> #include <grpc/support/host_port.h> -#include <grpc++/async_unary_call.h> -#include <grpc++/config.h> +#include <grpc/support/log.h> +#include <grpc++/support/config.h> #include <grpc++/server.h> #include <grpc++/server_builder.h> #include <grpc++/server_context.h> #include <grpc++/server_credentials.h> -#include <grpc++/status.h> -#include <grpc++/stream.h> #include <gtest/gtest.h> + #include "test/cpp/qps/qpstest.grpc.pb.h" #include "test/cpp/qps/server.h" -#include <grpc/grpc.h> -#include <grpc/support/log.h> namespace grpc { namespace testing { diff --git a/test/cpp/qps/server_sync.cc b/test/cpp/qps/server_sync.cc index 4c3c9cb497..29ec19cd4b 100644 --- a/test/cpp/qps/server_sync.cc +++ b/test/cpp/qps/server_sync.cc @@ -32,28 +32,23 @@ */ #include <sys/signal.h> -#include <thread> - #include <unistd.h> +#include <thread> #include <gflags/gflags.h> +#include <grpc/grpc.h> #include <grpc/support/alloc.h> #include <grpc/support/host_port.h> -#include <grpc++/config.h> -#include <grpc++/dynamic_thread_pool.h> -#include <grpc++/fixed_size_thread_pool.h> +#include <grpc/support/log.h> #include <grpc++/server.h> #include <grpc++/server_builder.h> #include <grpc++/server_context.h> #include <grpc++/server_credentials.h> -#include <grpc++/status.h> -#include <grpc++/stream.h> + #include "test/cpp/qps/qpstest.grpc.pb.h" #include "test/cpp/qps/server.h" #include "test/cpp/qps/timer.h" -#include <grpc/grpc.h> -#include <grpc/support/log.h> namespace grpc { namespace testing { @@ -93,12 +88,7 @@ class TestServiceImpl GRPC_FINAL : public TestService::Service { class SynchronousServer GRPC_FINAL : public grpc::testing::Server { public: SynchronousServer(const ServerConfig& config, int port) - : thread_pool_(), impl_(MakeImpl(port)) { - if (config.threads() > 0) { - thread_pool_.reset(new FixedSizeThreadPool(config.threads())); - } else { - thread_pool_.reset(new DynamicThreadPool(-config.threads())); - } + : impl_(MakeImpl(port)) { } private: @@ -112,13 +102,10 @@ class SynchronousServer GRPC_FINAL : public grpc::testing::Server { builder.RegisterService(&service_); - builder.SetThreadPool(thread_pool_.get()); - return builder.BuildAndStart(); } TestServiceImpl service_; - std::unique_ptr<ThreadPoolInterface> thread_pool_; std::unique_ptr<grpc::Server> impl_; }; diff --git a/test/cpp/qps/stats.h b/test/cpp/qps/stats.h index 82dc03e3da..93875017ca 100644 --- a/test/cpp/qps/stats.h +++ b/test/cpp/qps/stats.h @@ -34,9 +34,10 @@ #ifndef TEST_QPS_STATS_UTILS_H #define TEST_QPS_STATS_UTILS_H -#include "test/cpp/qps/histogram.h" #include <string> +#include "test/cpp/qps/histogram.h" + namespace grpc { namespace testing { diff --git a/test/cpp/qps/sync_streaming_ping_pong_test.cc b/test/cpp/qps/sync_streaming_ping_pong_test.cc index d53905a779..52e43939a8 100644 --- a/test/cpp/qps/sync_streaming_ping_pong_test.cc +++ b/test/cpp/qps/sync_streaming_ping_pong_test.cc @@ -31,12 +31,12 @@ * */ +#include <signal.h> + #include <set> #include <grpc/support/log.h> -#include <signal.h> - #include "test/cpp/qps/driver.h" #include "test/cpp/qps/report.h" #include "test/cpp/util/benchmark_config.h" diff --git a/test/cpp/qps/sync_unary_ping_pong_test.cc b/test/cpp/qps/sync_unary_ping_pong_test.cc index d276d13a43..fbd21357aa 100644 --- a/test/cpp/qps/sync_unary_ping_pong_test.cc +++ b/test/cpp/qps/sync_unary_ping_pong_test.cc @@ -31,12 +31,12 @@ * */ +#include <signal.h> + #include <set> #include <grpc/support/log.h> -#include <signal.h> - #include "test/cpp/qps/driver.h" #include "test/cpp/qps/report.h" #include "test/cpp/util/benchmark_config.h" diff --git a/test/cpp/qps/timer.cc b/test/cpp/qps/timer.cc index c1ba23decd..8edb838da3 100644 --- a/test/cpp/qps/timer.cc +++ b/test/cpp/qps/timer.cc @@ -36,7 +36,6 @@ #include <sys/time.h> #include <sys/resource.h> #include <grpc/support/time.h> -#include <grpc++/config.h> Timer::Timer() : start_(Sample()) {} diff --git a/test/cpp/qps/worker.cc b/test/cpp/qps/worker.cc index 7cf4903148..935e4853a6 100644 --- a/test/cpp/qps/worker.cc +++ b/test/cpp/qps/worker.cc @@ -36,9 +36,9 @@ #include <chrono> #include <thread> +#include <gflags/gflags.h> #include <grpc/grpc.h> #include <grpc/support/time.h> -#include <gflags/gflags.h> #include "test/cpp/qps/qps_worker.h" #include "test/cpp/util/test_config.h" diff --git a/test/cpp/server/dynamic_thread_pool_test.cc b/test/cpp/server/dynamic_thread_pool_test.cc deleted file mode 100644 index 63b603b8f7..0000000000 --- a/test/cpp/server/dynamic_thread_pool_test.cc +++ /dev/null @@ -1,77 +0,0 @@ -/* - * - * Copyright 2015, Google Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following disclaimer - * in the documentation and/or other materials provided with the - * distribution. - * * Neither the name of Google Inc. nor the names of its - * contributors may be used to endorse or promote products derived from - * this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ - -#include <condition_variable> -#include <functional> -#include <mutex> - -#include <grpc++/dynamic_thread_pool.h> -#include <gtest/gtest.h> - -namespace grpc { - -class DynamicThreadPoolTest : public ::testing::Test { - public: - DynamicThreadPoolTest() : thread_pool_(0) {} - - protected: - DynamicThreadPool thread_pool_; -}; - -void Callback(std::mutex* mu, std::condition_variable* cv, bool* done) { - std::unique_lock<std::mutex> lock(*mu); - *done = true; - cv->notify_all(); -} - -TEST_F(DynamicThreadPoolTest, Add) { - std::mutex mu; - std::condition_variable cv; - bool done = false; - std::function<void()> callback = std::bind(Callback, &mu, &cv, &done); - thread_pool_.Add(callback); - - // Wait for the callback to finish. - std::unique_lock<std::mutex> lock(mu); - while (!done) { - cv.wait(lock); - } -} - -} // namespace grpc - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - int result = RUN_ALL_TESTS(); - return result; -} diff --git a/test/cpp/server/fixed_size_thread_pool_test.cc b/test/cpp/server/fixed_size_thread_pool_test.cc deleted file mode 100644 index 442e974fc1..0000000000 --- a/test/cpp/server/fixed_size_thread_pool_test.cc +++ /dev/null @@ -1,77 +0,0 @@ -/* - * - * Copyright 2015, Google Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following disclaimer - * in the documentation and/or other materials provided with the - * distribution. - * * Neither the name of Google Inc. nor the names of its - * contributors may be used to endorse or promote products derived from - * this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ - -#include <condition_variable> -#include <functional> -#include <mutex> - -#include <grpc++/fixed_size_thread_pool.h> -#include <gtest/gtest.h> - -namespace grpc { - -class FixedSizeThreadPoolTest : public ::testing::Test { - public: - FixedSizeThreadPoolTest() : thread_pool_(4) {} - - protected: - FixedSizeThreadPool thread_pool_; -}; - -void Callback(std::mutex* mu, std::condition_variable* cv, bool* done) { - std::unique_lock<std::mutex> lock(*mu); - *done = true; - cv->notify_all(); -} - -TEST_F(FixedSizeThreadPoolTest, Add) { - std::mutex mu; - std::condition_variable cv; - bool done = false; - std::function<void()> callback = std::bind(Callback, &mu, &cv, &done); - thread_pool_.Add(callback); - - // Wait for the callback to finish. - std::unique_lock<std::mutex> lock(mu); - while (!done) { - cv.wait(lock); - } -} - -} // namespace grpc - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - int result = RUN_ALL_TESTS(); - return result; -} diff --git a/test/cpp/util/benchmark_config.cc b/test/cpp/util/benchmark_config.cc index 91fbbf9677..3c38221b4c 100644 --- a/test/cpp/util/benchmark_config.cc +++ b/test/cpp/util/benchmark_config.cc @@ -37,7 +37,8 @@ DEFINE_bool(enable_log_reporter, true, "Enable reporting of benchmark results through GprLog"); -DEFINE_bool(report_metrics_db, false, "True if metrics to be reported to performance database"); +DEFINE_bool(report_metrics_db, false, + "True if metrics to be reported to performance database"); DEFINE_string(hashed_id, "", "Hash of the user id"); @@ -45,7 +46,8 @@ DEFINE_string(test_name, "", "Name of the test being executed"); DEFINE_string(sys_info, "", "System information"); -DEFINE_string(server_address, "localhost:50052", "Address of the performance database server"); +DEFINE_string(server_address, "localhost:50052", + "Address of the performance database server"); DEFINE_string(tag, "", "Optional tag for the test"); @@ -69,10 +71,10 @@ static std::shared_ptr<Reporter> InitBenchmarkReporters() { composite_reporter->add( std::unique_ptr<Reporter>(new GprLogReporter("LogReporter"))); } - if(FLAGS_report_metrics_db) { - composite_reporter->add( - std::unique_ptr<Reporter>(new PerfDbReporter("PerfDbReporter", FLAGS_hashed_id, FLAGS_test_name, - FLAGS_sys_info, FLAGS_server_address, FLAGS_tag))); + if (FLAGS_report_metrics_db) { + composite_reporter->add(std::unique_ptr<Reporter>( + new PerfDbReporter("PerfDbReporter", FLAGS_hashed_id, FLAGS_test_name, + FLAGS_sys_info, FLAGS_server_address, FLAGS_tag))); } return std::shared_ptr<Reporter>(composite_reporter); diff --git a/test/cpp/util/byte_buffer_test.cc b/test/cpp/util/byte_buffer_test.cc index 13eb49730a..f36c32cac5 100644 --- a/test/cpp/util/byte_buffer_test.cc +++ b/test/cpp/util/byte_buffer_test.cc @@ -31,13 +31,13 @@ * */ -#include <grpc++/byte_buffer.h> +#include <grpc++/support/byte_buffer.h> #include <cstring> #include <vector> #include <grpc/support/slice.h> -#include <grpc++/slice.h> +#include <grpc++/support/slice.h> #include <gtest/gtest.h> namespace grpc { @@ -46,8 +46,7 @@ namespace { const char* kContent1 = "hello xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"; const char* kContent2 = "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy world"; -class ByteBufferTest : public ::testing::Test { -}; +class ByteBufferTest : public ::testing::Test {}; TEST_F(ByteBufferTest, CreateFromSingleSlice) { gpr_slice hello = gpr_slice_from_copied_string(kContent1); diff --git a/test/cpp/util/cli_call.cc b/test/cpp/util/cli_call.cc index 83a7a1744a..d60cee9c02 100644 --- a/test/cpp/util/cli_call.cc +++ b/test/cpp/util/cli_call.cc @@ -35,24 +35,21 @@ #include <iostream> -#include <grpc++/byte_buffer.h> -#include <grpc++/channel_interface.h> -#include <grpc++/client_context.h> -#include <grpc++/generic_stub.h> -#include <grpc++/status.h> -#include <grpc++/stream.h> - #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> namespace grpc { namespace testing { namespace { -void* tag(int i) { return (void*)(gpr_intptr) i; } +void* tag(int i) { return (void*)(gpr_intptr)i; } } // namespace -Status CliCall::Call(std::shared_ptr<grpc::ChannelInterface> channel, +Status CliCall::Call(std::shared_ptr<grpc::Channel> channel, const grpc::string& method, const grpc::string& request, grpc::string* response, const MetadataContainer& metadata, MetadataContainer* server_initial_metadata, diff --git a/test/cpp/util/cli_call.h b/test/cpp/util/cli_call.h index 8d114c9cb5..7a3dcf2e9f 100644 --- a/test/cpp/util/cli_call.h +++ b/test/cpp/util/cli_call.h @@ -36,9 +36,8 @@ #include <map> -#include <grpc++/channel_interface.h> -#include <grpc++/config.h> -#include <grpc++/status.h> +#include <grpc++/channel.h> +#include <grpc++/support/status.h> namespace grpc { namespace testing { @@ -46,7 +45,7 @@ namespace testing { class CliCall GRPC_FINAL { public: typedef std::multimap<grpc::string, grpc::string> MetadataContainer; - static Status Call(std::shared_ptr<grpc::ChannelInterface> channel, + static Status Call(std::shared_ptr<grpc::Channel> channel, const grpc::string& method, const grpc::string& request, grpc::string* response, const MetadataContainer& metadata, MetadataContainer* server_initial_metadata, diff --git a/test/cpp/util/cli_call_test.cc b/test/cpp/util/cli_call_test.cc index 848a3aee57..35bfad202f 100644 --- a/test/cpp/util/cli_call_test.cc +++ b/test/cpp/util/cli_call_test.cc @@ -31,24 +31,22 @@ * */ -#include "test/core/util/test_config.h" #include "test/cpp/util/cli_call.h" -#include "test/cpp/util/echo.grpc.pb.h" -#include <grpc++/channel_arguments.h> -#include <grpc++/channel_interface.h> + +#include <grpc/grpc.h> +#include <grpc++/channel.h> #include <grpc++/client_context.h> #include <grpc++/create_channel.h> #include <grpc++/credentials.h> -#include <grpc++/dynamic_thread_pool.h> #include <grpc++/server.h> #include <grpc++/server_builder.h> #include <grpc++/server_context.h> #include <grpc++/server_credentials.h> -#include <grpc++/status.h> -#include "test/core/util/port.h" #include <gtest/gtest.h> -#include <grpc/grpc.h> +#include "test/core/util/port.h" +#include "test/core/util/test_config.h" +#include "test/cpp/util/echo.grpc.pb.h" using grpc::cpp::test::util::EchoRequest; using grpc::cpp::test::util::EchoResponse; @@ -75,7 +73,7 @@ class TestServiceImpl : public ::grpc::cpp::test::util::TestService::Service { class CliCallTest : public ::testing::Test { protected: - CliCallTest() : thread_pool_(2) {} + CliCallTest() {} void SetUp() GRPC_OVERRIDE { int port = grpc_pick_unused_port_or_die(); @@ -85,7 +83,6 @@ class CliCallTest : public ::testing::Test { builder.AddListeningPort(server_address_.str(), InsecureServerCredentials()); builder.RegisterService(&service_); - builder.SetThreadPool(&thread_pool_); server_ = builder.BuildAndStart(); } @@ -97,12 +94,11 @@ class CliCallTest : public ::testing::Test { stub_ = std::move(grpc::cpp::test::util::TestService::NewStub(channel_)); } - std::shared_ptr<ChannelInterface> channel_; + std::shared_ptr<Channel> channel_; std::unique_ptr<grpc::cpp::test::util::TestService::Stub> stub_; std::unique_ptr<Server> server_; std::ostringstream server_address_; TestServiceImpl service_; - DynamicThreadPool thread_pool_; }; // Send a rpc with a normal stub and then a CliCall. Verify they match. diff --git a/test/cpp/util/create_test_channel.cc b/test/cpp/util/create_test_channel.cc index dc48fa2d87..161b4bdc1d 100644 --- a/test/cpp/util/create_test_channel.cc +++ b/test/cpp/util/create_test_channel.cc @@ -33,11 +33,11 @@ #include "test/cpp/util/create_test_channel.h" -#include "test/core/end2end/data/ssl_test_data.h" -#include <grpc++/channel_arguments.h> #include <grpc++/create_channel.h> #include <grpc++/credentials.h> +#include "test/core/end2end/data/ssl_test_data.h" + namespace grpc { // When ssl is enabled, if server is empty, override_hostname is used to @@ -55,7 +55,7 @@ namespace grpc { // CreateTestChannel("test.google.com:443", "", true, true, creds); // same as above // CreateTestChannel("", "test.google.com:443", true, true, creds); -std::shared_ptr<ChannelInterface> CreateTestChannel( +std::shared_ptr<Channel> CreateTestChannel( const grpc::string& server, const grpc::string& override_hostname, bool enable_ssl, bool use_prod_roots, const std::shared_ptr<Credentials>& creds) { @@ -80,7 +80,7 @@ std::shared_ptr<ChannelInterface> CreateTestChannel( } } -std::shared_ptr<ChannelInterface> CreateTestChannel( +std::shared_ptr<Channel> CreateTestChannel( const grpc::string& server, const grpc::string& override_hostname, bool enable_ssl, bool use_prod_roots) { return CreateTestChannel(server, override_hostname, enable_ssl, @@ -88,8 +88,8 @@ std::shared_ptr<ChannelInterface> CreateTestChannel( } // Shortcut for end2end and interop tests. -std::shared_ptr<ChannelInterface> CreateTestChannel(const grpc::string& server, - bool enable_ssl) { +std::shared_ptr<Channel> CreateTestChannel(const grpc::string& server, + bool enable_ssl) { return CreateTestChannel(server, "foo.test.google.fr", enable_ssl, false); } diff --git a/test/cpp/util/create_test_channel.h b/test/cpp/util/create_test_channel.h index 5f2609ddd8..1263d4ed68 100644 --- a/test/cpp/util/create_test_channel.h +++ b/test/cpp/util/create_test_channel.h @@ -36,20 +36,19 @@ #include <memory> -#include <grpc++/config.h> #include <grpc++/credentials.h> namespace grpc { -class ChannelInterface; +class Channel; -std::shared_ptr<ChannelInterface> CreateTestChannel(const grpc::string& server, - bool enable_ssl); +std::shared_ptr<Channel> CreateTestChannel(const grpc::string& server, + bool enable_ssl); -std::shared_ptr<ChannelInterface> CreateTestChannel( +std::shared_ptr<Channel> CreateTestChannel( const grpc::string& server, const grpc::string& override_hostname, bool enable_ssl, bool use_prod_roots); -std::shared_ptr<ChannelInterface> CreateTestChannel( +std::shared_ptr<Channel> CreateTestChannel( const grpc::string& server, const grpc::string& override_hostname, bool enable_ssl, bool use_prod_roots, const std::shared_ptr<Credentials>& creds); diff --git a/test/cpp/util/echo.proto b/test/cpp/util/echo.proto index 58ec680ecd..8ea2f59897 100644 --- a/test/cpp/util/echo.proto +++ b/test/cpp/util/echo.proto @@ -28,7 +28,7 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -syntax = "proto2"; +syntax = "proto3"; import "test/cpp/util/messages.proto"; @@ -41,3 +41,7 @@ service TestService { rpc BidiStream(stream EchoRequest) returns (stream EchoResponse); rpc Unimplemented(EchoRequest) returns (EchoResponse); } + +service UnimplementedService { + rpc Unimplemented(EchoRequest) returns (EchoResponse); +} diff --git a/test/cpp/util/echo_duplicate.proto b/test/cpp/util/echo_duplicate.proto index e54c016d2f..9c1d67825a 100644 --- a/test/cpp/util/echo_duplicate.proto +++ b/test/cpp/util/echo_duplicate.proto @@ -30,7 +30,7 @@ // This is a partial copy of echo.proto with a different package name. -syntax = "proto2"; +syntax = "proto3"; import "test/cpp/util/messages.proto"; diff --git a/test/cpp/util/grpc_cli.cc b/test/cpp/util/grpc_cli.cc index 3c3baeb769..746d67deeb 100644 --- a/test/cpp/util/grpc_cli.cc +++ b/test/cpp/util/grpc_cli.cc @@ -64,14 +64,13 @@ #include <sstream> #include <gflags/gflags.h> -#include "test/cpp/util/cli_call.h" -#include "test/cpp/util/test_config.h" -#include <grpc++/channel_arguments.h> -#include <grpc++/channel_interface.h> +#include <grpc/grpc.h> +#include <grpc++/channel.h> #include <grpc++/create_channel.h> #include <grpc++/credentials.h> -#include <grpc/grpc.h> +#include "test/cpp/util/cli_call.h" +#include "test/cpp/util/test_config.h" DEFINE_bool(enable_ssl, true, "Whether to use ssl/tls."); DEFINE_bool(use_auth, false, "Whether to create default google credentials."); @@ -154,7 +153,7 @@ int main(int argc, char** argv) { creds = grpc::SslCredentials(grpc::SslCredentialsOptions()); } } - std::shared_ptr<grpc::ChannelInterface> channel = + std::shared_ptr<grpc::Channel> channel = grpc::CreateChannel(server_address, creds, grpc::ChannelArguments()); grpc::string response; diff --git a/test/cpp/util/messages.proto b/test/cpp/util/messages.proto index 24e199b809..359d1db74f 100644 --- a/test/cpp/util/messages.proto +++ b/test/cpp/util/messages.proto @@ -28,32 +28,32 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -syntax = "proto2"; +syntax = "proto3"; package grpc.cpp.test.util; message RequestParams { - optional bool echo_deadline = 1; - optional int32 client_cancel_after_us = 2; - optional int32 server_cancel_after_us = 3; - optional bool echo_metadata = 4; - optional bool check_auth_context = 5; - optional int32 response_message_length = 6; - optional bool echo_peer = 7; + bool echo_deadline = 1; + int32 client_cancel_after_us = 2; + int32 server_cancel_after_us = 3; + bool echo_metadata = 4; + bool check_auth_context = 5; + int32 response_message_length = 6; + bool echo_peer = 7; } message EchoRequest { - optional string message = 1; - optional RequestParams param = 2; + string message = 1; + RequestParams param = 2; } message ResponseParams { - optional int64 request_deadline = 1; - optional string host = 2; - optional string peer = 3; + int64 request_deadline = 1; + string host = 2; + string peer = 3; } message EchoResponse { - optional string message = 1; - optional ResponseParams param = 2; + string message = 1; + ResponseParams param = 2; } diff --git a/test/cpp/util/slice_test.cc b/test/cpp/util/slice_test.cc index eb328490e1..de7ff031ab 100644 --- a/test/cpp/util/slice_test.cc +++ b/test/cpp/util/slice_test.cc @@ -31,7 +31,7 @@ * */ -#include <grpc++/slice.h> +#include <grpc++/support/slice.h> #include <grpc/support/slice.h> #include <gtest/gtest.h> diff --git a/test/cpp/util/status_test.cc b/test/cpp/util/status_test.cc index 17b92ab06a..837a6bab02 100644 --- a/test/cpp/util/status_test.cc +++ b/test/cpp/util/status_test.cc @@ -31,7 +31,8 @@ * */ -#include <grpc++/status.h> +#include <grpc++/support/status.h> + #include <grpc/status.h> #include <grpc/support/log.h> diff --git a/test/cpp/util/string_ref_test.cc b/test/cpp/util/string_ref_test.cc new file mode 100644 index 0000000000..c4ca4fce84 --- /dev/null +++ b/test/cpp/util/string_ref_test.cc @@ -0,0 +1,215 @@ +/* + * + * Copyright 2015, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#include <grpc++/support/string_ref.h> + +#include <string.h> + +#include <gtest/gtest.h> + +namespace grpc { +namespace { + +const char kTestString[] = "blah"; +const char kTestStringWithEmbeddedNull[] = "blah\0foo"; +const size_t kTestStringWithEmbeddedNullLength = 8; +const char kTestUnrelatedString[] = "foo"; + +class StringRefTest : public ::testing::Test { +}; + +TEST_F(StringRefTest, Empty) { + string_ref s; + EXPECT_EQ(0U, s.length()); + EXPECT_EQ(nullptr, s.data()); +} + +TEST_F(StringRefTest, FromCString) { + string_ref s(kTestString); + EXPECT_EQ(strlen(kTestString), s.length()); + EXPECT_EQ(kTestString, s.data()); +} + +TEST_F(StringRefTest, FromCStringWithLength) { + string_ref s(kTestString, 2); + EXPECT_EQ(2U, s.length()); + EXPECT_EQ(kTestString, s.data()); +} + +TEST_F(StringRefTest, FromString) { + string copy(kTestString); + string_ref s(copy); + EXPECT_EQ(copy.data(), s.data()); + EXPECT_EQ(copy.length(), s.length()); +} + +TEST_F(StringRefTest, CopyConstructor) { + string_ref s1(kTestString);; + string_ref s2(s1); + EXPECT_EQ(s1.length(), s2.length()); + EXPECT_EQ(s1.data(), s2.data()); +} + +TEST_F(StringRefTest, FromStringWithEmbeddedNull) { + string copy(kTestStringWithEmbeddedNull, kTestStringWithEmbeddedNullLength); + string_ref s(copy); + EXPECT_EQ(copy.data(), s.data()); + EXPECT_EQ(copy.length(), s.length()); + EXPECT_EQ(kTestStringWithEmbeddedNullLength, s.length()); +} + +TEST_F(StringRefTest, Assignment) { + string_ref s1(kTestString);; + string_ref s2; + EXPECT_EQ(nullptr, s2.data()); + s2 = s1; + EXPECT_EQ(s1.length(), s2.length()); + EXPECT_EQ(s1.data(), s2.data()); +} + +TEST_F(StringRefTest, Iterator) { + string_ref s(kTestString); + size_t i = 0; + for (char c : s) { + EXPECT_EQ(kTestString[i++], c); + } + EXPECT_EQ(strlen(kTestString), i); +} + +TEST_F(StringRefTest, ReverseIterator) { + string_ref s(kTestString); + size_t i = strlen(kTestString); + for (auto rit = s.crbegin(); rit != s.crend(); ++rit) { + EXPECT_EQ(kTestString[--i], *rit); + } + EXPECT_EQ(0U, i); +} + +TEST_F(StringRefTest, Capacity) { + string_ref empty; + EXPECT_EQ(0U, empty.length()); + EXPECT_EQ(0U, empty.size()); + EXPECT_EQ(0U, empty.max_size()); + EXPECT_TRUE(empty.empty()); + + string_ref s(kTestString); + EXPECT_EQ(strlen(kTestString), s.length()); + EXPECT_EQ(s.length(), s.size()); + EXPECT_EQ(s.max_size(), s.length()); + EXPECT_FALSE(s.empty()); +} + +TEST_F(StringRefTest, Compare) { + string_ref s1(kTestString); + string s1_copy(kTestString); + string_ref s2(kTestUnrelatedString); + string_ref s3(kTestStringWithEmbeddedNull, kTestStringWithEmbeddedNullLength); + EXPECT_EQ(0, s1.compare(s1_copy)); + EXPECT_NE(0, s1.compare(s2)); + EXPECT_NE(0, s1.compare(s3)); +} + +TEST_F(StringRefTest, StartsWith) { + string_ref s1(kTestString); + string_ref s2(kTestUnrelatedString); + string_ref s3(kTestStringWithEmbeddedNull, kTestStringWithEmbeddedNullLength); + EXPECT_TRUE(s1.starts_with(s1)); + EXPECT_FALSE(s1.starts_with(s2)); + EXPECT_FALSE(s2.starts_with(s1)); + EXPECT_FALSE(s1.starts_with(s3)); + EXPECT_TRUE(s3.starts_with(s1)); +} + +TEST_F(StringRefTest, Endswith) { + string_ref s1(kTestString); + string_ref s2(kTestUnrelatedString); + string_ref s3(kTestStringWithEmbeddedNull, kTestStringWithEmbeddedNullLength); + EXPECT_TRUE(s1.ends_with(s1)); + EXPECT_FALSE(s1.ends_with(s2)); + EXPECT_FALSE(s2.ends_with(s1)); + EXPECT_FALSE(s2.ends_with(s3)); + EXPECT_TRUE(s3.ends_with(s2)); +} + +TEST_F(StringRefTest, Find) { + string_ref s1(kTestString); + string_ref s2(kTestUnrelatedString); + string_ref s3(kTestStringWithEmbeddedNull, kTestStringWithEmbeddedNullLength); + EXPECT_EQ(0U, s1.find(s1)); + EXPECT_EQ(0U, s2.find(s2)); + EXPECT_EQ(0U, s3.find(s3)); + EXPECT_EQ(string_ref::npos,s1.find(s2) ); + EXPECT_EQ(string_ref::npos,s2.find(s1)); + EXPECT_EQ(string_ref::npos,s1.find(s3)); + EXPECT_EQ(0U, s3.find(s1)); + EXPECT_EQ(5U, s3.find(s2)); + EXPECT_EQ(string_ref::npos, s1.find('z')); + EXPECT_EQ(1U, s2.find('o')); +} + +TEST_F(StringRefTest, SubString) { + string_ref s(kTestStringWithEmbeddedNull, kTestStringWithEmbeddedNullLength); + string_ref sub1 = s.substr(0, 4); + EXPECT_EQ(string_ref(kTestString), sub1); + string_ref sub2 = s.substr(5); + EXPECT_EQ(string_ref(kTestUnrelatedString), sub2); +} + +TEST_F(StringRefTest, ComparisonOperators) { + string_ref s1(kTestString); + string_ref s2(kTestUnrelatedString); + string_ref s3(kTestStringWithEmbeddedNull, kTestStringWithEmbeddedNullLength); + EXPECT_EQ(s1, s1); + EXPECT_EQ(s2, s2); + EXPECT_EQ(s3, s3); + EXPECT_GE(s1, s1); + EXPECT_GE(s2, s2); + EXPECT_GE(s3, s3); + EXPECT_LE(s1, s1); + EXPECT_LE(s2, s2); + EXPECT_LE(s3, s3); + EXPECT_NE(s1, s2); + EXPECT_NE(s1, s3); + EXPECT_NE(s2, s3); + EXPECT_GT(s3, s1); + EXPECT_LT(s1, s3); +} + +} // namespace +} // namespace grpc + +int main(int argc, char** argv) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} + diff --git a/test/cpp/util/time_test.cc b/test/cpp/util/time_test.cc index 4cb6ec4b4e..1e501dfd28 100644 --- a/test/cpp/util/time_test.cc +++ b/test/cpp/util/time_test.cc @@ -32,7 +32,7 @@ */ #include <grpc/support/time.h> -#include <grpc++/time.h> +#include <grpc++/support/time.h> #include <gtest/gtest.h> using std::chrono::duration_cast; |