Craig Tiller | 0220cf1 | 2015-02-12 17:39:26 -0800 | [diff] [blame] | 1 | /* |
| 2 | * |
Craig Tiller | 0605995 | 2015-02-18 08:34:56 -0800 | [diff] [blame] | 3 | * Copyright 2015, Google Inc. |
Craig Tiller | 0220cf1 | 2015-02-12 17:39:26 -0800 | [diff] [blame] | 4 | * All rights reserved. |
| 5 | * |
| 6 | * Redistribution and use in source and binary forms, with or without |
| 7 | * modification, are permitted provided that the following conditions are |
| 8 | * met: |
| 9 | * |
| 10 | * * Redistributions of source code must retain the above copyright |
| 11 | * notice, this list of conditions and the following disclaimer. |
| 12 | * * Redistributions in binary form must reproduce the above |
| 13 | * copyright notice, this list of conditions and the following disclaimer |
| 14 | * in the documentation and/or other materials provided with the |
| 15 | * distribution. |
| 16 | * * Neither the name of Google Inc. nor the names of its |
| 17 | * contributors may be used to endorse or promote products derived from |
| 18 | * this software without specific prior written permission. |
| 19 | * |
| 20 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 21 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 22 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 23 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 24 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 25 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 26 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 27 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 28 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 29 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 30 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 31 | * |
| 32 | */ |
| 33 | |
Yang Gao | da699b8 | 2015-02-18 01:10:22 -0800 | [diff] [blame] | 34 | #include <memory> |
Craig Tiller | 0220cf1 | 2015-02-12 17:39:26 -0800 | [diff] [blame] | 35 | |
yang-g | 9e2f90c | 2015-08-21 15:35:03 -0700 | [diff] [blame] | 36 | #include <grpc/grpc.h> |
| 37 | #include <grpc/support/thd.h> |
| 38 | #include <grpc/support/time.h> |
yang-g | 8c2be9f | 2015-08-19 16:28:09 -0700 | [diff] [blame] | 39 | #include <grpc++/channel.h> |
Craig Tiller | 0220cf1 | 2015-02-12 17:39:26 -0800 | [diff] [blame] | 40 | #include <grpc++/client_context.h> |
| 41 | #include <grpc++/create_channel.h> |
Craig Tiller | 0220cf1 | 2015-02-12 17:39:26 -0800 | [diff] [blame] | 42 | #include <grpc++/server.h> |
| 43 | #include <grpc++/server_builder.h> |
| 44 | #include <grpc++/server_context.h> |
Craig Tiller | 0220cf1 | 2015-02-12 17:39:26 -0800 | [diff] [blame] | 45 | #include <gtest/gtest.h> |
| 46 | |
yang-g | 9e2f90c | 2015-08-21 15:35:03 -0700 | [diff] [blame] | 47 | #include "test/core/util/port.h" |
| 48 | #include "test/core/util/test_config.h" |
| 49 | #include "test/cpp/util/echo_duplicate.grpc.pb.h" |
| 50 | #include "test/cpp/util/echo.grpc.pb.h" |
yang-g | e21908f | 2015-08-25 13:47:51 -0700 | [diff] [blame] | 51 | #include "test/cpp/util/string_ref_helper.h" |
Craig Tiller | 0220cf1 | 2015-02-12 17:39:26 -0800 | [diff] [blame] | 52 | |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 53 | #ifdef GPR_POSIX_SOCKET |
| 54 | #include "src/core/iomgr/pollset_posix.h" |
| 55 | #endif |
| 56 | |
Craig Tiller | 0220cf1 | 2015-02-12 17:39:26 -0800 | [diff] [blame] | 57 | using grpc::cpp::test::util::EchoRequest; |
| 58 | using grpc::cpp::test::util::EchoResponse; |
| 59 | using std::chrono::system_clock; |
| 60 | |
| 61 | namespace grpc { |
| 62 | namespace testing { |
| 63 | |
| 64 | namespace { |
| 65 | |
Craig Tiller | d6c98df | 2015-08-18 09:33:44 -0700 | [diff] [blame] | 66 | void* tag(int i) { return (void*)(gpr_intptr)i; } |
Yang Gao | c05b6cb | 2015-02-13 00:34:10 -0800 | [diff] [blame] | 67 | |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 68 | #ifdef GPR_POSIX_SOCKET |
Craig Tiller | 4c06b82 | 2015-08-06 08:41:31 -0700 | [diff] [blame] | 69 | static int assert_non_blocking_poll(struct pollfd* pfds, nfds_t nfds, |
| 70 | int timeout) { |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 71 | GPR_ASSERT(timeout == 0); |
| 72 | return poll(pfds, nfds, timeout); |
| 73 | } |
| 74 | |
| 75 | class PollOverride { |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 76 | public: |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 77 | PollOverride(grpc_poll_function_type f) { |
| 78 | prev_ = grpc_poll_function; |
| 79 | grpc_poll_function = f; |
| 80 | } |
| 81 | |
Craig Tiller | 4c06b82 | 2015-08-06 08:41:31 -0700 | [diff] [blame] | 82 | ~PollOverride() { grpc_poll_function = prev_; } |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 83 | |
| 84 | private: |
| 85 | grpc_poll_function_type prev_; |
| 86 | }; |
| 87 | |
| 88 | class PollingCheckRegion : public PollOverride { |
| 89 | public: |
Craig Tiller | 4c06b82 | 2015-08-06 08:41:31 -0700 | [diff] [blame] | 90 | explicit PollingCheckRegion(bool allow_blocking) |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 91 | : PollOverride(allow_blocking ? poll : assert_non_blocking_poll) {} |
| 92 | }; |
| 93 | #else |
| 94 | class PollingCheckRegion { |
| 95 | public: |
| 96 | explicit PollingCheckRegion(bool allow_blocking) {} |
| 97 | }; |
| 98 | #endif |
| 99 | |
| 100 | class Verifier : public PollingCheckRegion { |
| 101 | public: |
| 102 | explicit Verifier(bool spin) : PollingCheckRegion(!spin), spin_(spin) {} |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 103 | Verifier& Expect(int i, bool expect_ok) { |
| 104 | expectations_[tag(i)] = expect_ok; |
| 105 | return *this; |
vjpai | 7aadf46 | 2015-03-16 23:58:44 -0700 | [diff] [blame] | 106 | } |
Craig Tiller | d6c98df | 2015-08-18 09:33:44 -0700 | [diff] [blame] | 107 | void Verify(CompletionQueue* cq) { |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 108 | GPR_ASSERT(!expectations_.empty()); |
| 109 | while (!expectations_.empty()) { |
| 110 | bool ok; |
| 111 | void* got_tag; |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 112 | if (spin_) { |
| 113 | for (;;) { |
| 114 | auto r = cq->AsyncNext(&got_tag, &ok, gpr_time_0(GPR_CLOCK_REALTIME)); |
| 115 | if (r == CompletionQueue::TIMEOUT) continue; |
| 116 | if (r == CompletionQueue::GOT_EVENT) break; |
| 117 | gpr_log(GPR_ERROR, "unexpected result from AsyncNext"); |
| 118 | abort(); |
| 119 | } |
| 120 | } else { |
| 121 | EXPECT_TRUE(cq->Next(&got_tag, &ok)); |
| 122 | } |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 123 | auto it = expectations_.find(got_tag); |
| 124 | EXPECT_TRUE(it != expectations_.end()); |
| 125 | EXPECT_EQ(it->second, ok); |
| 126 | expectations_.erase(it); |
| 127 | } |
| 128 | } |
Craig Tiller | d6c98df | 2015-08-18 09:33:44 -0700 | [diff] [blame] | 129 | void Verify(CompletionQueue* cq, |
| 130 | std::chrono::system_clock::time_point deadline) { |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 131 | if (expectations_.empty()) { |
| 132 | bool ok; |
Craig Tiller | d6c98df | 2015-08-18 09:33:44 -0700 | [diff] [blame] | 133 | void* got_tag; |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 134 | if (spin_) { |
| 135 | while (std::chrono::system_clock::now() < deadline) { |
Craig Tiller | 4c06b82 | 2015-08-06 08:41:31 -0700 | [diff] [blame] | 136 | EXPECT_EQ( |
| 137 | cq->AsyncNext(&got_tag, &ok, gpr_time_0(GPR_CLOCK_REALTIME)), |
| 138 | CompletionQueue::TIMEOUT); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 139 | } |
| 140 | } else { |
Craig Tiller | 4c06b82 | 2015-08-06 08:41:31 -0700 | [diff] [blame] | 141 | EXPECT_EQ(cq->AsyncNext(&got_tag, &ok, deadline), |
| 142 | CompletionQueue::TIMEOUT); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 143 | } |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 144 | } else { |
| 145 | while (!expectations_.empty()) { |
| 146 | bool ok; |
Craig Tiller | d6c98df | 2015-08-18 09:33:44 -0700 | [diff] [blame] | 147 | void* got_tag; |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 148 | if (spin_) { |
| 149 | for (;;) { |
| 150 | GPR_ASSERT(std::chrono::system_clock::now() < deadline); |
Craig Tiller | 4c06b82 | 2015-08-06 08:41:31 -0700 | [diff] [blame] | 151 | auto r = |
| 152 | cq->AsyncNext(&got_tag, &ok, gpr_time_0(GPR_CLOCK_REALTIME)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 153 | if (r == CompletionQueue::TIMEOUT) continue; |
| 154 | if (r == CompletionQueue::GOT_EVENT) break; |
| 155 | gpr_log(GPR_ERROR, "unexpected result from AsyncNext"); |
| 156 | abort(); |
Craig Tiller | 4c06b82 | 2015-08-06 08:41:31 -0700 | [diff] [blame] | 157 | } |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 158 | } else { |
Craig Tiller | 4c06b82 | 2015-08-06 08:41:31 -0700 | [diff] [blame] | 159 | EXPECT_EQ(cq->AsyncNext(&got_tag, &ok, deadline), |
| 160 | CompletionQueue::GOT_EVENT); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 161 | } |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 162 | auto it = expectations_.find(got_tag); |
| 163 | EXPECT_TRUE(it != expectations_.end()); |
| 164 | EXPECT_EQ(it->second, ok); |
| 165 | expectations_.erase(it); |
| 166 | } |
| 167 | } |
| 168 | } |
| 169 | |
| 170 | private: |
| 171 | std::map<void*, bool> expectations_; |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 172 | bool spin_; |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 173 | }; |
vjpai | 7aadf46 | 2015-03-16 23:58:44 -0700 | [diff] [blame] | 174 | |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 175 | class AsyncEnd2endTest : public ::testing::TestWithParam<bool> { |
Craig Tiller | 0220cf1 | 2015-02-12 17:39:26 -0800 | [diff] [blame] | 176 | protected: |
Craig Tiller | f9e6adf | 2015-05-06 11:45:59 -0700 | [diff] [blame] | 177 | AsyncEnd2endTest() {} |
Craig Tiller | 0220cf1 | 2015-02-12 17:39:26 -0800 | [diff] [blame] | 178 | |
Craig Tiller | cf133f4 | 2015-02-26 14:05:56 -0800 | [diff] [blame] | 179 | void SetUp() GRPC_OVERRIDE { |
Craig Tiller | 0220cf1 | 2015-02-12 17:39:26 -0800 | [diff] [blame] | 180 | int port = grpc_pick_unused_port_or_die(); |
| 181 | server_address_ << "localhost:" << port; |
| 182 | // Setup server |
| 183 | ServerBuilder builder; |
Craig Tiller | d6c98df | 2015-08-18 09:33:44 -0700 | [diff] [blame] | 184 | builder.AddListeningPort(server_address_.str(), |
| 185 | grpc::InsecureServerCredentials()); |
Craig Tiller | 0220cf1 | 2015-02-12 17:39:26 -0800 | [diff] [blame] | 186 | builder.RegisterAsyncService(&service_); |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 187 | cq_ = builder.AddCompletionQueue(); |
Craig Tiller | 0220cf1 | 2015-02-12 17:39:26 -0800 | [diff] [blame] | 188 | server_ = builder.BuildAndStart(); |
| 189 | } |
| 190 | |
Craig Tiller | cf133f4 | 2015-02-26 14:05:56 -0800 | [diff] [blame] | 191 | void TearDown() GRPC_OVERRIDE { |
Craig Tiller | 492968f | 2015-02-18 13:14:03 -0800 | [diff] [blame] | 192 | server_->Shutdown(); |
| 193 | void* ignored_tag; |
| 194 | bool ignored_ok; |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 195 | cq_->Shutdown(); |
| 196 | while (cq_->Next(&ignored_tag, &ignored_ok)) |
Craig Tiller | 492968f | 2015-02-18 13:14:03 -0800 | [diff] [blame] | 197 | ; |
| 198 | } |
Craig Tiller | 0220cf1 | 2015-02-12 17:39:26 -0800 | [diff] [blame] | 199 | |
| 200 | void ResetStub() { |
yang-g | 730055d | 2015-08-27 12:29:45 -0700 | [diff] [blame] | 201 | std::shared_ptr<Channel> channel = |
| 202 | CreateChannel(server_address_.str(), InsecureCredentials()); |
Nicolas "Pixel" Noble | 7fa5167 | 2015-09-02 02:29:09 +0200 | [diff] [blame] | 203 | stub_ = grpc::cpp::test::util::TestService::NewStub(channel); |
Craig Tiller | 0220cf1 | 2015-02-12 17:39:26 -0800 | [diff] [blame] | 204 | } |
| 205 | |
Yang Gao | 406b32f | 2015-02-13 16:25:33 -0800 | [diff] [blame] | 206 | void SendRpc(int num_rpcs) { |
| 207 | for (int i = 0; i < num_rpcs; i++) { |
| 208 | EchoRequest send_request; |
| 209 | EchoRequest recv_request; |
| 210 | EchoResponse send_response; |
| 211 | EchoResponse recv_response; |
| 212 | Status recv_status; |
| 213 | |
| 214 | ClientContext cli_ctx; |
| 215 | ServerContext srv_ctx; |
| 216 | grpc::ServerAsyncResponseWriter<EchoResponse> response_writer(&srv_ctx); |
| 217 | |
| 218 | send_request.set_message("Hello"); |
Craig Tiller | 47c83fd | 2015-02-21 22:45:35 -0800 | [diff] [blame] | 219 | std::unique_ptr<ClientAsyncResponseReader<EchoResponse> > response_reader( |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 220 | stub_->AsyncEcho(&cli_ctx, send_request, cq_.get())); |
Yang Gao | 406b32f | 2015-02-13 16:25:33 -0800 | [diff] [blame] | 221 | |
Craig Tiller | d6c98df | 2015-08-18 09:33:44 -0700 | [diff] [blame] | 222 | service_.RequestEcho(&srv_ctx, &recv_request, &response_writer, cq_.get(), |
| 223 | cq_.get(), tag(2)); |
Yang Gao | 406b32f | 2015-02-13 16:25:33 -0800 | [diff] [blame] | 224 | |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 225 | Verifier(GetParam()).Expect(2, true).Verify(cq_.get()); |
Yang Gao | 406b32f | 2015-02-13 16:25:33 -0800 | [diff] [blame] | 226 | EXPECT_EQ(send_request.message(), recv_request.message()); |
| 227 | |
| 228 | send_response.set_message(recv_request.message()); |
| 229 | response_writer.Finish(send_response, Status::OK, tag(3)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 230 | Verifier(GetParam()).Expect(3, true).Verify(cq_.get()); |
Yang Gao | 406b32f | 2015-02-13 16:25:33 -0800 | [diff] [blame] | 231 | |
Yang Gao | 3a5e549 | 2015-02-18 14:32:38 -0800 | [diff] [blame] | 232 | response_reader->Finish(&recv_response, &recv_status, tag(4)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 233 | Verifier(GetParam()).Expect(4, true).Verify(cq_.get()); |
Yang Gao | 406b32f | 2015-02-13 16:25:33 -0800 | [diff] [blame] | 234 | |
| 235 | EXPECT_EQ(send_response.message(), recv_response.message()); |
Yang Gao | c1a2c31 | 2015-06-16 10:59:46 -0700 | [diff] [blame] | 236 | EXPECT_TRUE(recv_status.ok()); |
Yang Gao | 406b32f | 2015-02-13 16:25:33 -0800 | [diff] [blame] | 237 | } |
| 238 | } |
| 239 | |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 240 | std::unique_ptr<ServerCompletionQueue> cq_; |
Craig Tiller | 0220cf1 | 2015-02-12 17:39:26 -0800 | [diff] [blame] | 241 | std::unique_ptr<grpc::cpp::test::util::TestService::Stub> stub_; |
| 242 | std::unique_ptr<Server> server_; |
| 243 | grpc::cpp::test::util::TestService::AsyncService service_; |
| 244 | std::ostringstream server_address_; |
| 245 | }; |
| 246 | |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 247 | TEST_P(AsyncEnd2endTest, SimpleRpc) { |
Craig Tiller | 0220cf1 | 2015-02-12 17:39:26 -0800 | [diff] [blame] | 248 | ResetStub(); |
Yang Gao | 406b32f | 2015-02-13 16:25:33 -0800 | [diff] [blame] | 249 | SendRpc(1); |
| 250 | } |
Yang Gao | bb84a30 | 2015-02-12 23:30:12 -0800 | [diff] [blame] | 251 | |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 252 | TEST_P(AsyncEnd2endTest, SequentialRpcs) { |
Yang Gao | 406b32f | 2015-02-13 16:25:33 -0800 | [diff] [blame] | 253 | ResetStub(); |
| 254 | SendRpc(10); |
Craig Tiller | 0220cf1 | 2015-02-12 17:39:26 -0800 | [diff] [blame] | 255 | } |
| 256 | |
vjpai | 7aadf46 | 2015-03-16 23:58:44 -0700 | [diff] [blame] | 257 | // Test a simple RPC using the async version of Next |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 258 | TEST_P(AsyncEnd2endTest, AsyncNextRpc) { |
vjpai | 7aadf46 | 2015-03-16 23:58:44 -0700 | [diff] [blame] | 259 | ResetStub(); |
| 260 | |
| 261 | EchoRequest send_request; |
| 262 | EchoRequest recv_request; |
| 263 | EchoResponse send_response; |
| 264 | EchoResponse recv_response; |
| 265 | Status recv_status; |
| 266 | |
| 267 | ClientContext cli_ctx; |
| 268 | ServerContext srv_ctx; |
| 269 | grpc::ServerAsyncResponseWriter<EchoResponse> response_writer(&srv_ctx); |
| 270 | |
| 271 | send_request.set_message("Hello"); |
Yang Gao | 757afae | 2015-03-17 15:49:26 -0700 | [diff] [blame] | 272 | std::unique_ptr<ClientAsyncResponseReader<EchoResponse> > response_reader( |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 273 | stub_->AsyncEcho(&cli_ctx, send_request, cq_.get())); |
vjpai | 7aadf46 | 2015-03-16 23:58:44 -0700 | [diff] [blame] | 274 | |
Yang Gao | 757afae | 2015-03-17 15:49:26 -0700 | [diff] [blame] | 275 | std::chrono::system_clock::time_point time_now( |
Craig Tiller | f51199f | 2015-05-08 09:32:53 -0700 | [diff] [blame] | 276 | std::chrono::system_clock::now()); |
| 277 | std::chrono::system_clock::time_point time_limit( |
| 278 | std::chrono::system_clock::now() + std::chrono::seconds(10)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 279 | Verifier(GetParam()).Verify(cq_.get(), time_now); |
| 280 | Verifier(GetParam()).Verify(cq_.get(), time_now); |
vjpai | 7aadf46 | 2015-03-16 23:58:44 -0700 | [diff] [blame] | 281 | |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 282 | service_.RequestEcho(&srv_ctx, &recv_request, &response_writer, cq_.get(), |
| 283 | cq_.get(), tag(2)); |
vjpai | 7aadf46 | 2015-03-16 23:58:44 -0700 | [diff] [blame] | 284 | |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 285 | Verifier(GetParam()).Expect(2, true).Verify(cq_.get(), time_limit); |
vjpai | 7aadf46 | 2015-03-16 23:58:44 -0700 | [diff] [blame] | 286 | EXPECT_EQ(send_request.message(), recv_request.message()); |
vjpai | 7aadf46 | 2015-03-16 23:58:44 -0700 | [diff] [blame] | 287 | |
| 288 | send_response.set_message(recv_request.message()); |
| 289 | response_writer.Finish(send_response, Status::OK, tag(3)); |
Craig Tiller | 4c06b82 | 2015-08-06 08:41:31 -0700 | [diff] [blame] | 290 | Verifier(GetParam()) |
| 291 | .Expect(3, true) |
| 292 | .Verify(cq_.get(), std::chrono::system_clock::time_point::max()); |
vjpai | 7aadf46 | 2015-03-16 23:58:44 -0700 | [diff] [blame] | 293 | |
| 294 | response_reader->Finish(&recv_response, &recv_status, tag(4)); |
Craig Tiller | 4c06b82 | 2015-08-06 08:41:31 -0700 | [diff] [blame] | 295 | Verifier(GetParam()) |
| 296 | .Expect(4, true) |
| 297 | .Verify(cq_.get(), std::chrono::system_clock::time_point::max()); |
vjpai | 7aadf46 | 2015-03-16 23:58:44 -0700 | [diff] [blame] | 298 | |
| 299 | EXPECT_EQ(send_response.message(), recv_response.message()); |
Yang Gao | c1a2c31 | 2015-06-16 10:59:46 -0700 | [diff] [blame] | 300 | EXPECT_TRUE(recv_status.ok()); |
vjpai | 7aadf46 | 2015-03-16 23:58:44 -0700 | [diff] [blame] | 301 | } |
Yang Gao | 757afae | 2015-03-17 15:49:26 -0700 | [diff] [blame] | 302 | |
Yang Gao | 0e0d8e1 | 2015-02-13 14:40:41 -0800 | [diff] [blame] | 303 | // Two pings and a final pong. |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 304 | TEST_P(AsyncEnd2endTest, SimpleClientStreaming) { |
Yang Gao | 005f18a | 2015-02-13 10:22:33 -0800 | [diff] [blame] | 305 | ResetStub(); |
| 306 | |
| 307 | EchoRequest send_request; |
| 308 | EchoRequest recv_request; |
| 309 | EchoResponse send_response; |
| 310 | EchoResponse recv_response; |
| 311 | Status recv_status; |
| 312 | ClientContext cli_ctx; |
| 313 | ServerContext srv_ctx; |
| 314 | ServerAsyncReader<EchoResponse, EchoRequest> srv_stream(&srv_ctx); |
| 315 | |
| 316 | send_request.set_message("Hello"); |
Yang Gao | da699b8 | 2015-02-18 01:10:22 -0800 | [diff] [blame] | 317 | std::unique_ptr<ClientAsyncWriter<EchoRequest> > cli_stream( |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 318 | stub_->AsyncRequestStream(&cli_ctx, &recv_response, cq_.get(), tag(1))); |
Yang Gao | 005f18a | 2015-02-13 10:22:33 -0800 | [diff] [blame] | 319 | |
Craig Tiller | d6c98df | 2015-08-18 09:33:44 -0700 | [diff] [blame] | 320 | service_.RequestRequestStream(&srv_ctx, &srv_stream, cq_.get(), cq_.get(), |
| 321 | tag(2)); |
Yang Gao | 005f18a | 2015-02-13 10:22:33 -0800 | [diff] [blame] | 322 | |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 323 | Verifier(GetParam()).Expect(2, true).Expect(1, true).Verify(cq_.get()); |
Yang Gao | 005f18a | 2015-02-13 10:22:33 -0800 | [diff] [blame] | 324 | |
| 325 | cli_stream->Write(send_request, tag(3)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 326 | Verifier(GetParam()).Expect(3, true).Verify(cq_.get()); |
Yang Gao | 005f18a | 2015-02-13 10:22:33 -0800 | [diff] [blame] | 327 | |
| 328 | srv_stream.Read(&recv_request, tag(4)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 329 | Verifier(GetParam()).Expect(4, true).Verify(cq_.get()); |
Yang Gao | 005f18a | 2015-02-13 10:22:33 -0800 | [diff] [blame] | 330 | EXPECT_EQ(send_request.message(), recv_request.message()); |
| 331 | |
| 332 | cli_stream->Write(send_request, tag(5)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 333 | Verifier(GetParam()).Expect(5, true).Verify(cq_.get()); |
Yang Gao | 005f18a | 2015-02-13 10:22:33 -0800 | [diff] [blame] | 334 | |
| 335 | srv_stream.Read(&recv_request, tag(6)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 336 | Verifier(GetParam()).Expect(6, true).Verify(cq_.get()); |
Yang Gao | 005f18a | 2015-02-13 10:22:33 -0800 | [diff] [blame] | 337 | |
| 338 | EXPECT_EQ(send_request.message(), recv_request.message()); |
| 339 | cli_stream->WritesDone(tag(7)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 340 | Verifier(GetParam()).Expect(7, true).Verify(cq_.get()); |
Yang Gao | 005f18a | 2015-02-13 10:22:33 -0800 | [diff] [blame] | 341 | |
| 342 | srv_stream.Read(&recv_request, tag(8)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 343 | Verifier(GetParam()).Expect(8, false).Verify(cq_.get()); |
Yang Gao | 005f18a | 2015-02-13 10:22:33 -0800 | [diff] [blame] | 344 | |
| 345 | send_response.set_message(recv_request.message()); |
| 346 | srv_stream.Finish(send_response, Status::OK, tag(9)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 347 | Verifier(GetParam()).Expect(9, true).Verify(cq_.get()); |
Yang Gao | 005f18a | 2015-02-13 10:22:33 -0800 | [diff] [blame] | 348 | |
| 349 | cli_stream->Finish(&recv_status, tag(10)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 350 | Verifier(GetParam()).Expect(10, true).Verify(cq_.get()); |
Yang Gao | 005f18a | 2015-02-13 10:22:33 -0800 | [diff] [blame] | 351 | |
| 352 | EXPECT_EQ(send_response.message(), recv_response.message()); |
Yang Gao | c1a2c31 | 2015-06-16 10:59:46 -0700 | [diff] [blame] | 353 | EXPECT_TRUE(recv_status.ok()); |
Yang Gao | 005f18a | 2015-02-13 10:22:33 -0800 | [diff] [blame] | 354 | } |
| 355 | |
Yang Gao | 0e0d8e1 | 2015-02-13 14:40:41 -0800 | [diff] [blame] | 356 | // One ping, two pongs. |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 357 | TEST_P(AsyncEnd2endTest, SimpleServerStreaming) { |
Yang Gao | 0e0d8e1 | 2015-02-13 14:40:41 -0800 | [diff] [blame] | 358 | ResetStub(); |
| 359 | |
| 360 | EchoRequest send_request; |
| 361 | EchoRequest recv_request; |
| 362 | EchoResponse send_response; |
| 363 | EchoResponse recv_response; |
| 364 | Status recv_status; |
| 365 | ClientContext cli_ctx; |
| 366 | ServerContext srv_ctx; |
| 367 | ServerAsyncWriter<EchoResponse> srv_stream(&srv_ctx); |
| 368 | |
| 369 | send_request.set_message("Hello"); |
Yang Gao | da699b8 | 2015-02-18 01:10:22 -0800 | [diff] [blame] | 370 | std::unique_ptr<ClientAsyncReader<EchoResponse> > cli_stream( |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 371 | stub_->AsyncResponseStream(&cli_ctx, send_request, cq_.get(), tag(1))); |
Yang Gao | 0e0d8e1 | 2015-02-13 14:40:41 -0800 | [diff] [blame] | 372 | |
Craig Tiller | f9e6adf | 2015-05-06 11:45:59 -0700 | [diff] [blame] | 373 | service_.RequestResponseStream(&srv_ctx, &recv_request, &srv_stream, |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 374 | cq_.get(), cq_.get(), tag(2)); |
Yang Gao | 0e0d8e1 | 2015-02-13 14:40:41 -0800 | [diff] [blame] | 375 | |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 376 | Verifier(GetParam()).Expect(1, true).Expect(2, true).Verify(cq_.get()); |
Yang Gao | 0e0d8e1 | 2015-02-13 14:40:41 -0800 | [diff] [blame] | 377 | EXPECT_EQ(send_request.message(), recv_request.message()); |
| 378 | |
| 379 | send_response.set_message(recv_request.message()); |
| 380 | srv_stream.Write(send_response, tag(3)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 381 | Verifier(GetParam()).Expect(3, true).Verify(cq_.get()); |
Yang Gao | 0e0d8e1 | 2015-02-13 14:40:41 -0800 | [diff] [blame] | 382 | |
| 383 | cli_stream->Read(&recv_response, tag(4)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 384 | Verifier(GetParam()).Expect(4, true).Verify(cq_.get()); |
Yang Gao | 0e0d8e1 | 2015-02-13 14:40:41 -0800 | [diff] [blame] | 385 | EXPECT_EQ(send_response.message(), recv_response.message()); |
| 386 | |
| 387 | srv_stream.Write(send_response, tag(5)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 388 | Verifier(GetParam()).Expect(5, true).Verify(cq_.get()); |
Yang Gao | 0e0d8e1 | 2015-02-13 14:40:41 -0800 | [diff] [blame] | 389 | |
| 390 | cli_stream->Read(&recv_response, tag(6)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 391 | Verifier(GetParam()).Expect(6, true).Verify(cq_.get()); |
Yang Gao | 0e0d8e1 | 2015-02-13 14:40:41 -0800 | [diff] [blame] | 392 | EXPECT_EQ(send_response.message(), recv_response.message()); |
| 393 | |
| 394 | srv_stream.Finish(Status::OK, tag(7)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 395 | Verifier(GetParam()).Expect(7, true).Verify(cq_.get()); |
Yang Gao | 0e0d8e1 | 2015-02-13 14:40:41 -0800 | [diff] [blame] | 396 | |
| 397 | cli_stream->Read(&recv_response, tag(8)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 398 | Verifier(GetParam()).Expect(8, false).Verify(cq_.get()); |
Yang Gao | 0e0d8e1 | 2015-02-13 14:40:41 -0800 | [diff] [blame] | 399 | |
| 400 | cli_stream->Finish(&recv_status, tag(9)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 401 | Verifier(GetParam()).Expect(9, true).Verify(cq_.get()); |
Yang Gao | 0e0d8e1 | 2015-02-13 14:40:41 -0800 | [diff] [blame] | 402 | |
Yang Gao | c1a2c31 | 2015-06-16 10:59:46 -0700 | [diff] [blame] | 403 | EXPECT_TRUE(recv_status.ok()); |
Yang Gao | 0e0d8e1 | 2015-02-13 14:40:41 -0800 | [diff] [blame] | 404 | } |
| 405 | |
| 406 | // One ping, one pong. |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 407 | TEST_P(AsyncEnd2endTest, SimpleBidiStreaming) { |
Yang Gao | c05b6cb | 2015-02-13 00:34:10 -0800 | [diff] [blame] | 408 | ResetStub(); |
| 409 | |
| 410 | EchoRequest send_request; |
| 411 | EchoRequest recv_request; |
| 412 | EchoResponse send_response; |
| 413 | EchoResponse recv_response; |
| 414 | Status recv_status; |
| 415 | ClientContext cli_ctx; |
| 416 | ServerContext srv_ctx; |
| 417 | ServerAsyncReaderWriter<EchoResponse, EchoRequest> srv_stream(&srv_ctx); |
| 418 | |
| 419 | send_request.set_message("Hello"); |
Yang Gao | da699b8 | 2015-02-18 01:10:22 -0800 | [diff] [blame] | 420 | std::unique_ptr<ClientAsyncReaderWriter<EchoRequest, EchoResponse> > |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 421 | cli_stream(stub_->AsyncBidiStream(&cli_ctx, cq_.get(), tag(1))); |
Yang Gao | c05b6cb | 2015-02-13 00:34:10 -0800 | [diff] [blame] | 422 | |
Craig Tiller | d6c98df | 2015-08-18 09:33:44 -0700 | [diff] [blame] | 423 | service_.RequestBidiStream(&srv_ctx, &srv_stream, cq_.get(), cq_.get(), |
| 424 | tag(2)); |
Yang Gao | c05b6cb | 2015-02-13 00:34:10 -0800 | [diff] [blame] | 425 | |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 426 | Verifier(GetParam()).Expect(1, true).Expect(2, true).Verify(cq_.get()); |
Yang Gao | c05b6cb | 2015-02-13 00:34:10 -0800 | [diff] [blame] | 427 | |
| 428 | cli_stream->Write(send_request, tag(3)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 429 | Verifier(GetParam()).Expect(3, true).Verify(cq_.get()); |
Yang Gao | c05b6cb | 2015-02-13 00:34:10 -0800 | [diff] [blame] | 430 | |
| 431 | srv_stream.Read(&recv_request, tag(4)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 432 | Verifier(GetParam()).Expect(4, true).Verify(cq_.get()); |
Yang Gao | c05b6cb | 2015-02-13 00:34:10 -0800 | [diff] [blame] | 433 | EXPECT_EQ(send_request.message(), recv_request.message()); |
| 434 | |
| 435 | send_response.set_message(recv_request.message()); |
| 436 | srv_stream.Write(send_response, tag(5)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 437 | Verifier(GetParam()).Expect(5, true).Verify(cq_.get()); |
Yang Gao | c05b6cb | 2015-02-13 00:34:10 -0800 | [diff] [blame] | 438 | |
| 439 | cli_stream->Read(&recv_response, tag(6)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 440 | Verifier(GetParam()).Expect(6, true).Verify(cq_.get()); |
Yang Gao | c05b6cb | 2015-02-13 00:34:10 -0800 | [diff] [blame] | 441 | EXPECT_EQ(send_response.message(), recv_response.message()); |
| 442 | |
| 443 | cli_stream->WritesDone(tag(7)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 444 | Verifier(GetParam()).Expect(7, true).Verify(cq_.get()); |
Yang Gao | c05b6cb | 2015-02-13 00:34:10 -0800 | [diff] [blame] | 445 | |
| 446 | srv_stream.Read(&recv_request, tag(8)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 447 | Verifier(GetParam()).Expect(8, false).Verify(cq_.get()); |
Yang Gao | c05b6cb | 2015-02-13 00:34:10 -0800 | [diff] [blame] | 448 | |
| 449 | srv_stream.Finish(Status::OK, tag(9)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 450 | Verifier(GetParam()).Expect(9, true).Verify(cq_.get()); |
Yang Gao | c05b6cb | 2015-02-13 00:34:10 -0800 | [diff] [blame] | 451 | |
| 452 | cli_stream->Finish(&recv_status, tag(10)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 453 | Verifier(GetParam()).Expect(10, true).Verify(cq_.get()); |
Yang Gao | c05b6cb | 2015-02-13 00:34:10 -0800 | [diff] [blame] | 454 | |
Yang Gao | c1a2c31 | 2015-06-16 10:59:46 -0700 | [diff] [blame] | 455 | EXPECT_TRUE(recv_status.ok()); |
Yang Gao | c05b6cb | 2015-02-13 00:34:10 -0800 | [diff] [blame] | 456 | } |
| 457 | |
Yang Gao | 406b32f | 2015-02-13 16:25:33 -0800 | [diff] [blame] | 458 | // Metadata tests |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 459 | TEST_P(AsyncEnd2endTest, ClientInitialMetadataRpc) { |
Yang Gao | 406b32f | 2015-02-13 16:25:33 -0800 | [diff] [blame] | 460 | ResetStub(); |
| 461 | |
| 462 | EchoRequest send_request; |
| 463 | EchoRequest recv_request; |
| 464 | EchoResponse send_response; |
| 465 | EchoResponse recv_response; |
| 466 | Status recv_status; |
| 467 | |
| 468 | ClientContext cli_ctx; |
| 469 | ServerContext srv_ctx; |
| 470 | grpc::ServerAsyncResponseWriter<EchoResponse> response_writer(&srv_ctx); |
| 471 | |
| 472 | send_request.set_message("Hello"); |
| 473 | std::pair<grpc::string, grpc::string> meta1("key1", "val1"); |
| 474 | std::pair<grpc::string, grpc::string> meta2("key2", "val2"); |
| 475 | cli_ctx.AddMetadata(meta1.first, meta1.second); |
| 476 | cli_ctx.AddMetadata(meta2.first, meta2.second); |
| 477 | |
Yang Gao | 3a5e549 | 2015-02-18 14:32:38 -0800 | [diff] [blame] | 478 | std::unique_ptr<ClientAsyncResponseReader<EchoResponse> > response_reader( |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 479 | stub_->AsyncEcho(&cli_ctx, send_request, cq_.get())); |
Yang Gao | 406b32f | 2015-02-13 16:25:33 -0800 | [diff] [blame] | 480 | |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 481 | service_.RequestEcho(&srv_ctx, &recv_request, &response_writer, cq_.get(), |
| 482 | cq_.get(), tag(2)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 483 | Verifier(GetParam()).Expect(2, true).Verify(cq_.get()); |
Yang Gao | 406b32f | 2015-02-13 16:25:33 -0800 | [diff] [blame] | 484 | EXPECT_EQ(send_request.message(), recv_request.message()); |
| 485 | auto client_initial_metadata = srv_ctx.client_metadata(); |
yang-g | e21908f | 2015-08-25 13:47:51 -0700 | [diff] [blame] | 486 | EXPECT_EQ(meta1.second, |
| 487 | ToString(client_initial_metadata.find(meta1.first)->second)); |
| 488 | EXPECT_EQ(meta2.second, |
| 489 | ToString(client_initial_metadata.find(meta2.first)->second)); |
Craig Tiller | 8bf2dca | 2015-07-10 13:08:41 -0700 | [diff] [blame] | 490 | EXPECT_GE(client_initial_metadata.size(), static_cast<size_t>(2)); |
Yang Gao | 406b32f | 2015-02-13 16:25:33 -0800 | [diff] [blame] | 491 | |
| 492 | send_response.set_message(recv_request.message()); |
| 493 | response_writer.Finish(send_response, Status::OK, tag(3)); |
| 494 | |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 495 | Verifier(GetParam()).Expect(3, true).Verify(cq_.get()); |
Yang Gao | 406b32f | 2015-02-13 16:25:33 -0800 | [diff] [blame] | 496 | |
Yang Gao | 3a5e549 | 2015-02-18 14:32:38 -0800 | [diff] [blame] | 497 | response_reader->Finish(&recv_response, &recv_status, tag(4)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 498 | Verifier(GetParam()).Expect(4, true).Verify(cq_.get()); |
Yang Gao | 406b32f | 2015-02-13 16:25:33 -0800 | [diff] [blame] | 499 | |
| 500 | EXPECT_EQ(send_response.message(), recv_response.message()); |
Yang Gao | c1a2c31 | 2015-06-16 10:59:46 -0700 | [diff] [blame] | 501 | EXPECT_TRUE(recv_status.ok()); |
Yang Gao | 406b32f | 2015-02-13 16:25:33 -0800 | [diff] [blame] | 502 | } |
| 503 | |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 504 | TEST_P(AsyncEnd2endTest, ServerInitialMetadataRpc) { |
Yang Gao | 2b7f537 | 2015-02-18 00:45:53 -0800 | [diff] [blame] | 505 | ResetStub(); |
| 506 | |
| 507 | EchoRequest send_request; |
| 508 | EchoRequest recv_request; |
| 509 | EchoResponse send_response; |
| 510 | EchoResponse recv_response; |
| 511 | Status recv_status; |
| 512 | |
| 513 | ClientContext cli_ctx; |
| 514 | ServerContext srv_ctx; |
| 515 | grpc::ServerAsyncResponseWriter<EchoResponse> response_writer(&srv_ctx); |
| 516 | |
| 517 | send_request.set_message("Hello"); |
| 518 | std::pair<grpc::string, grpc::string> meta1("key1", "val1"); |
| 519 | std::pair<grpc::string, grpc::string> meta2("key2", "val2"); |
| 520 | |
Yang Gao | 3a5e549 | 2015-02-18 14:32:38 -0800 | [diff] [blame] | 521 | std::unique_ptr<ClientAsyncResponseReader<EchoResponse> > response_reader( |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 522 | stub_->AsyncEcho(&cli_ctx, send_request, cq_.get())); |
Yang Gao | 2b7f537 | 2015-02-18 00:45:53 -0800 | [diff] [blame] | 523 | |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 524 | service_.RequestEcho(&srv_ctx, &recv_request, &response_writer, cq_.get(), |
| 525 | cq_.get(), tag(2)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 526 | Verifier(GetParam()).Expect(2, true).Verify(cq_.get()); |
Yang Gao | 2b7f537 | 2015-02-18 00:45:53 -0800 | [diff] [blame] | 527 | EXPECT_EQ(send_request.message(), recv_request.message()); |
| 528 | srv_ctx.AddInitialMetadata(meta1.first, meta1.second); |
| 529 | srv_ctx.AddInitialMetadata(meta2.first, meta2.second); |
| 530 | response_writer.SendInitialMetadata(tag(3)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 531 | Verifier(GetParam()).Expect(3, true).Verify(cq_.get()); |
Yang Gao | 2b7f537 | 2015-02-18 00:45:53 -0800 | [diff] [blame] | 532 | |
Yang Gao | 3a5e549 | 2015-02-18 14:32:38 -0800 | [diff] [blame] | 533 | response_reader->ReadInitialMetadata(tag(4)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 534 | Verifier(GetParam()).Expect(4, true).Verify(cq_.get()); |
Yang Gao | 2b7f537 | 2015-02-18 00:45:53 -0800 | [diff] [blame] | 535 | auto server_initial_metadata = cli_ctx.GetServerInitialMetadata(); |
yang-g | e21908f | 2015-08-25 13:47:51 -0700 | [diff] [blame] | 536 | EXPECT_EQ(meta1.second, |
| 537 | ToString(server_initial_metadata.find(meta1.first)->second)); |
| 538 | EXPECT_EQ(meta2.second, |
| 539 | ToString(server_initial_metadata.find(meta2.first)->second)); |
vjpai | d5577aa | 2015-02-18 22:26:48 -0800 | [diff] [blame] | 540 | EXPECT_EQ(static_cast<size_t>(2), server_initial_metadata.size()); |
Yang Gao | 3a5e549 | 2015-02-18 14:32:38 -0800 | [diff] [blame] | 541 | |
| 542 | send_response.set_message(recv_request.message()); |
| 543 | response_writer.Finish(send_response, Status::OK, tag(5)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 544 | Verifier(GetParam()).Expect(5, true).Verify(cq_.get()); |
Yang Gao | 3a5e549 | 2015-02-18 14:32:38 -0800 | [diff] [blame] | 545 | |
| 546 | response_reader->Finish(&recv_response, &recv_status, tag(6)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 547 | Verifier(GetParam()).Expect(6, true).Verify(cq_.get()); |
Yang Gao | 3a5e549 | 2015-02-18 14:32:38 -0800 | [diff] [blame] | 548 | |
| 549 | EXPECT_EQ(send_response.message(), recv_response.message()); |
Yang Gao | c1a2c31 | 2015-06-16 10:59:46 -0700 | [diff] [blame] | 550 | EXPECT_TRUE(recv_status.ok()); |
Yang Gao | 2b7f537 | 2015-02-18 00:45:53 -0800 | [diff] [blame] | 551 | } |
| 552 | |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 553 | TEST_P(AsyncEnd2endTest, ServerTrailingMetadataRpc) { |
Yang Gao | 2b7f537 | 2015-02-18 00:45:53 -0800 | [diff] [blame] | 554 | ResetStub(); |
| 555 | |
| 556 | EchoRequest send_request; |
| 557 | EchoRequest recv_request; |
| 558 | EchoResponse send_response; |
| 559 | EchoResponse recv_response; |
| 560 | Status recv_status; |
| 561 | |
| 562 | ClientContext cli_ctx; |
| 563 | ServerContext srv_ctx; |
| 564 | grpc::ServerAsyncResponseWriter<EchoResponse> response_writer(&srv_ctx); |
| 565 | |
| 566 | send_request.set_message("Hello"); |
| 567 | std::pair<grpc::string, grpc::string> meta1("key1", "val1"); |
| 568 | std::pair<grpc::string, grpc::string> meta2("key2", "val2"); |
| 569 | |
Yang Gao | 3a5e549 | 2015-02-18 14:32:38 -0800 | [diff] [blame] | 570 | std::unique_ptr<ClientAsyncResponseReader<EchoResponse> > response_reader( |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 571 | stub_->AsyncEcho(&cli_ctx, send_request, cq_.get())); |
Yang Gao | 2b7f537 | 2015-02-18 00:45:53 -0800 | [diff] [blame] | 572 | |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 573 | service_.RequestEcho(&srv_ctx, &recv_request, &response_writer, cq_.get(), |
| 574 | cq_.get(), tag(2)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 575 | Verifier(GetParam()).Expect(2, true).Verify(cq_.get()); |
Yang Gao | 2b7f537 | 2015-02-18 00:45:53 -0800 | [diff] [blame] | 576 | EXPECT_EQ(send_request.message(), recv_request.message()); |
| 577 | response_writer.SendInitialMetadata(tag(3)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 578 | Verifier(GetParam()).Expect(3, true).Verify(cq_.get()); |
Yang Gao | 2b7f537 | 2015-02-18 00:45:53 -0800 | [diff] [blame] | 579 | |
| 580 | send_response.set_message(recv_request.message()); |
| 581 | srv_ctx.AddTrailingMetadata(meta1.first, meta1.second); |
| 582 | srv_ctx.AddTrailingMetadata(meta2.first, meta2.second); |
| 583 | response_writer.Finish(send_response, Status::OK, tag(4)); |
| 584 | |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 585 | Verifier(GetParam()).Expect(4, true).Verify(cq_.get()); |
Yang Gao | 2b7f537 | 2015-02-18 00:45:53 -0800 | [diff] [blame] | 586 | |
Yang Gao | 3a5e549 | 2015-02-18 14:32:38 -0800 | [diff] [blame] | 587 | response_reader->Finish(&recv_response, &recv_status, tag(5)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 588 | Verifier(GetParam()).Expect(5, true).Verify(cq_.get()); |
Yang Gao | 2b7f537 | 2015-02-18 00:45:53 -0800 | [diff] [blame] | 589 | EXPECT_EQ(send_response.message(), recv_response.message()); |
Yang Gao | c1a2c31 | 2015-06-16 10:59:46 -0700 | [diff] [blame] | 590 | EXPECT_TRUE(recv_status.ok()); |
Yang Gao | 2b7f537 | 2015-02-18 00:45:53 -0800 | [diff] [blame] | 591 | auto server_trailing_metadata = cli_ctx.GetServerTrailingMetadata(); |
yang-g | e21908f | 2015-08-25 13:47:51 -0700 | [diff] [blame] | 592 | EXPECT_EQ(meta1.second, |
| 593 | ToString(server_trailing_metadata.find(meta1.first)->second)); |
| 594 | EXPECT_EQ(meta2.second, |
| 595 | ToString(server_trailing_metadata.find(meta2.first)->second)); |
vjpai | d5577aa | 2015-02-18 22:26:48 -0800 | [diff] [blame] | 596 | EXPECT_EQ(static_cast<size_t>(2), server_trailing_metadata.size()); |
Yang Gao | 2b7f537 | 2015-02-18 00:45:53 -0800 | [diff] [blame] | 597 | } |
| 598 | |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 599 | TEST_P(AsyncEnd2endTest, MetadataRpc) { |
Yang Gao | 2b7f537 | 2015-02-18 00:45:53 -0800 | [diff] [blame] | 600 | ResetStub(); |
| 601 | |
| 602 | EchoRequest send_request; |
| 603 | EchoRequest recv_request; |
| 604 | EchoResponse send_response; |
| 605 | EchoResponse recv_response; |
| 606 | Status recv_status; |
| 607 | |
| 608 | ClientContext cli_ctx; |
| 609 | ServerContext srv_ctx; |
| 610 | grpc::ServerAsyncResponseWriter<EchoResponse> response_writer(&srv_ctx); |
| 611 | |
| 612 | send_request.set_message("Hello"); |
| 613 | std::pair<grpc::string, grpc::string> meta1("key1", "val1"); |
Yang Gao | 3a5e549 | 2015-02-18 14:32:38 -0800 | [diff] [blame] | 614 | std::pair<grpc::string, grpc::string> meta2( |
Vijay Pai | 92a928f | 2015-03-26 16:30:22 -0400 | [diff] [blame] | 615 | "key2-bin", |
Craig Tiller | d6c98df | 2015-08-18 09:33:44 -0700 | [diff] [blame] | 616 | grpc::string("\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc", 13)); |
Yang Gao | 2b7f537 | 2015-02-18 00:45:53 -0800 | [diff] [blame] | 617 | std::pair<grpc::string, grpc::string> meta3("key3", "val3"); |
Craig Tiller | 47c83fd | 2015-02-21 22:45:35 -0800 | [diff] [blame] | 618 | std::pair<grpc::string, grpc::string> meta6( |
| 619 | "key4-bin", |
Vijay Pai | 92a928f | 2015-03-26 16:30:22 -0400 | [diff] [blame] | 620 | grpc::string("\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d", |
Craig Tiller | d6c98df | 2015-08-18 09:33:44 -0700 | [diff] [blame] | 621 | 14)); |
Yang Gao | 2b7f537 | 2015-02-18 00:45:53 -0800 | [diff] [blame] | 622 | std::pair<grpc::string, grpc::string> meta5("key5", "val5"); |
Craig Tiller | 47c83fd | 2015-02-21 22:45:35 -0800 | [diff] [blame] | 623 | std::pair<grpc::string, grpc::string> meta4( |
| 624 | "key6-bin", |
Craig Tiller | d6c98df | 2015-08-18 09:33:44 -0700 | [diff] [blame] | 625 | grpc::string( |
| 626 | "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee", 15)); |
Yang Gao | 2b7f537 | 2015-02-18 00:45:53 -0800 | [diff] [blame] | 627 | |
| 628 | cli_ctx.AddMetadata(meta1.first, meta1.second); |
| 629 | cli_ctx.AddMetadata(meta2.first, meta2.second); |
| 630 | |
Yang Gao | 3a5e549 | 2015-02-18 14:32:38 -0800 | [diff] [blame] | 631 | std::unique_ptr<ClientAsyncResponseReader<EchoResponse> > response_reader( |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 632 | stub_->AsyncEcho(&cli_ctx, send_request, cq_.get())); |
Yang Gao | 2b7f537 | 2015-02-18 00:45:53 -0800 | [diff] [blame] | 633 | |
Craig Tiller | 06cf3cc | 2015-05-13 13:11:01 -0700 | [diff] [blame] | 634 | service_.RequestEcho(&srv_ctx, &recv_request, &response_writer, cq_.get(), |
| 635 | cq_.get(), tag(2)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 636 | Verifier(GetParam()).Expect(2, true).Verify(cq_.get()); |
Yang Gao | 2b7f537 | 2015-02-18 00:45:53 -0800 | [diff] [blame] | 637 | EXPECT_EQ(send_request.message(), recv_request.message()); |
| 638 | auto client_initial_metadata = srv_ctx.client_metadata(); |
yang-g | e21908f | 2015-08-25 13:47:51 -0700 | [diff] [blame] | 639 | EXPECT_EQ(meta1.second, |
| 640 | ToString(client_initial_metadata.find(meta1.first)->second)); |
| 641 | EXPECT_EQ(meta2.second, |
| 642 | ToString(client_initial_metadata.find(meta2.first)->second)); |
Craig Tiller | 8bf2dca | 2015-07-10 13:08:41 -0700 | [diff] [blame] | 643 | EXPECT_GE(client_initial_metadata.size(), static_cast<size_t>(2)); |
Yang Gao | 2b7f537 | 2015-02-18 00:45:53 -0800 | [diff] [blame] | 644 | |
| 645 | srv_ctx.AddInitialMetadata(meta3.first, meta3.second); |
| 646 | srv_ctx.AddInitialMetadata(meta4.first, meta4.second); |
| 647 | response_writer.SendInitialMetadata(tag(3)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 648 | Verifier(GetParam()).Expect(3, true).Verify(cq_.get()); |
Yang Gao | 3a5e549 | 2015-02-18 14:32:38 -0800 | [diff] [blame] | 649 | response_reader->ReadInitialMetadata(tag(4)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 650 | Verifier(GetParam()).Expect(4, true).Verify(cq_.get()); |
Yang Gao | 2b7f537 | 2015-02-18 00:45:53 -0800 | [diff] [blame] | 651 | auto server_initial_metadata = cli_ctx.GetServerInitialMetadata(); |
yang-g | e21908f | 2015-08-25 13:47:51 -0700 | [diff] [blame] | 652 | EXPECT_EQ(meta3.second, |
| 653 | ToString(server_initial_metadata.find(meta3.first)->second)); |
| 654 | EXPECT_EQ(meta4.second, |
| 655 | ToString(server_initial_metadata.find(meta4.first)->second)); |
Craig Tiller | 8bf2dca | 2015-07-10 13:08:41 -0700 | [diff] [blame] | 656 | EXPECT_GE(server_initial_metadata.size(), static_cast<size_t>(2)); |
Yang Gao | 3a5e549 | 2015-02-18 14:32:38 -0800 | [diff] [blame] | 657 | |
| 658 | send_response.set_message(recv_request.message()); |
| 659 | srv_ctx.AddTrailingMetadata(meta5.first, meta5.second); |
| 660 | srv_ctx.AddTrailingMetadata(meta6.first, meta6.second); |
| 661 | response_writer.Finish(send_response, Status::OK, tag(5)); |
| 662 | |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 663 | Verifier(GetParam()).Expect(5, true).Verify(cq_.get()); |
Yang Gao | 3a5e549 | 2015-02-18 14:32:38 -0800 | [diff] [blame] | 664 | |
Yang Gao | 3a5e549 | 2015-02-18 14:32:38 -0800 | [diff] [blame] | 665 | response_reader->Finish(&recv_response, &recv_status, tag(6)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 666 | Verifier(GetParam()).Expect(6, true).Verify(cq_.get()); |
Yang Gao | 3a5e549 | 2015-02-18 14:32:38 -0800 | [diff] [blame] | 667 | EXPECT_EQ(send_response.message(), recv_response.message()); |
Yang Gao | c1a2c31 | 2015-06-16 10:59:46 -0700 | [diff] [blame] | 668 | EXPECT_TRUE(recv_status.ok()); |
Yang Gao | 2b7f537 | 2015-02-18 00:45:53 -0800 | [diff] [blame] | 669 | auto server_trailing_metadata = cli_ctx.GetServerTrailingMetadata(); |
yang-g | e21908f | 2015-08-25 13:47:51 -0700 | [diff] [blame] | 670 | EXPECT_EQ(meta5.second, |
| 671 | ToString(server_trailing_metadata.find(meta5.first)->second)); |
| 672 | EXPECT_EQ(meta6.second, |
| 673 | ToString(server_trailing_metadata.find(meta6.first)->second)); |
Craig Tiller | 8bf2dca | 2015-07-10 13:08:41 -0700 | [diff] [blame] | 674 | EXPECT_GE(server_trailing_metadata.size(), static_cast<size_t>(2)); |
Yang Gao | 2b7f537 | 2015-02-18 00:45:53 -0800 | [diff] [blame] | 675 | } |
yang-g | b335256 | 2015-08-04 14:42:06 -0700 | [diff] [blame] | 676 | |
| 677 | // Server uses AsyncNotifyWhenDone API to check for cancellation |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 678 | TEST_P(AsyncEnd2endTest, ServerCheckCancellation) { |
yang-g | b335256 | 2015-08-04 14:42:06 -0700 | [diff] [blame] | 679 | ResetStub(); |
| 680 | |
| 681 | EchoRequest send_request; |
| 682 | EchoRequest recv_request; |
| 683 | EchoResponse send_response; |
| 684 | EchoResponse recv_response; |
| 685 | Status recv_status; |
| 686 | |
| 687 | ClientContext cli_ctx; |
| 688 | ServerContext srv_ctx; |
| 689 | grpc::ServerAsyncResponseWriter<EchoResponse> response_writer(&srv_ctx); |
| 690 | |
| 691 | send_request.set_message("Hello"); |
| 692 | std::unique_ptr<ClientAsyncResponseReader<EchoResponse> > response_reader( |
| 693 | stub_->AsyncEcho(&cli_ctx, send_request, cq_.get())); |
| 694 | |
| 695 | srv_ctx.AsyncNotifyWhenDone(tag(5)); |
| 696 | service_.RequestEcho(&srv_ctx, &recv_request, &response_writer, cq_.get(), |
| 697 | cq_.get(), tag(2)); |
| 698 | |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 699 | Verifier(GetParam()).Expect(2, true).Verify(cq_.get()); |
yang-g | b335256 | 2015-08-04 14:42:06 -0700 | [diff] [blame] | 700 | EXPECT_EQ(send_request.message(), recv_request.message()); |
| 701 | |
| 702 | cli_ctx.TryCancel(); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 703 | Verifier(GetParam()).Expect(5, true).Verify(cq_.get()); |
yang-g | b335256 | 2015-08-04 14:42:06 -0700 | [diff] [blame] | 704 | EXPECT_TRUE(srv_ctx.IsCancelled()); |
| 705 | |
| 706 | response_reader->Finish(&recv_response, &recv_status, tag(4)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 707 | Verifier(GetParam()).Expect(4, false).Verify(cq_.get()); |
yang-g | b335256 | 2015-08-04 14:42:06 -0700 | [diff] [blame] | 708 | |
| 709 | EXPECT_EQ(StatusCode::CANCELLED, recv_status.error_code()); |
| 710 | } |
| 711 | |
| 712 | // Server uses AsyncNotifyWhenDone API to check for normal finish |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 713 | TEST_P(AsyncEnd2endTest, ServerCheckDone) { |
yang-g | b335256 | 2015-08-04 14:42:06 -0700 | [diff] [blame] | 714 | ResetStub(); |
| 715 | |
| 716 | EchoRequest send_request; |
| 717 | EchoRequest recv_request; |
| 718 | EchoResponse send_response; |
| 719 | EchoResponse recv_response; |
| 720 | Status recv_status; |
| 721 | |
| 722 | ClientContext cli_ctx; |
| 723 | ServerContext srv_ctx; |
| 724 | grpc::ServerAsyncResponseWriter<EchoResponse> response_writer(&srv_ctx); |
| 725 | |
| 726 | send_request.set_message("Hello"); |
| 727 | std::unique_ptr<ClientAsyncResponseReader<EchoResponse> > response_reader( |
| 728 | stub_->AsyncEcho(&cli_ctx, send_request, cq_.get())); |
| 729 | |
| 730 | srv_ctx.AsyncNotifyWhenDone(tag(5)); |
| 731 | service_.RequestEcho(&srv_ctx, &recv_request, &response_writer, cq_.get(), |
| 732 | cq_.get(), tag(2)); |
| 733 | |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 734 | Verifier(GetParam()).Expect(2, true).Verify(cq_.get()); |
yang-g | b335256 | 2015-08-04 14:42:06 -0700 | [diff] [blame] | 735 | EXPECT_EQ(send_request.message(), recv_request.message()); |
| 736 | |
| 737 | send_response.set_message(recv_request.message()); |
| 738 | response_writer.Finish(send_response, Status::OK, tag(3)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 739 | Verifier(GetParam()).Expect(3, true).Verify(cq_.get()); |
| 740 | Verifier(GetParam()).Expect(5, true).Verify(cq_.get()); |
yang-g | b335256 | 2015-08-04 14:42:06 -0700 | [diff] [blame] | 741 | EXPECT_FALSE(srv_ctx.IsCancelled()); |
| 742 | |
| 743 | response_reader->Finish(&recv_response, &recv_status, tag(4)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 744 | Verifier(GetParam()).Expect(4, true).Verify(cq_.get()); |
yang-g | b335256 | 2015-08-04 14:42:06 -0700 | [diff] [blame] | 745 | |
| 746 | EXPECT_EQ(send_response.message(), recv_response.message()); |
| 747 | EXPECT_TRUE(recv_status.ok()); |
| 748 | } |
| 749 | |
Craig Tiller | 8f7bff7 | 2015-08-17 13:23:14 -0700 | [diff] [blame] | 750 | TEST_P(AsyncEnd2endTest, UnimplementedRpc) { |
yang-g | 730055d | 2015-08-27 12:29:45 -0700 | [diff] [blame] | 751 | std::shared_ptr<Channel> channel = |
| 752 | CreateChannel(server_address_.str(), InsecureCredentials()); |
yang-g | 9b7757d | 2015-08-13 11:15:53 -0700 | [diff] [blame] | 753 | std::unique_ptr<grpc::cpp::test::util::UnimplementedService::Stub> stub; |
Nicolas "Pixel" Noble | 7fa5167 | 2015-09-02 02:29:09 +0200 | [diff] [blame] | 754 | stub = grpc::cpp::test::util::UnimplementedService::NewStub(channel); |
yang-g | 9b7757d | 2015-08-13 11:15:53 -0700 | [diff] [blame] | 755 | EchoRequest send_request; |
| 756 | EchoResponse recv_response; |
| 757 | Status recv_status; |
| 758 | |
| 759 | ClientContext cli_ctx; |
| 760 | send_request.set_message("Hello"); |
| 761 | std::unique_ptr<ClientAsyncResponseReader<EchoResponse> > response_reader( |
| 762 | stub->AsyncUnimplemented(&cli_ctx, send_request, cq_.get())); |
| 763 | |
| 764 | response_reader->Finish(&recv_response, &recv_status, tag(4)); |
Craig Tiller | 8f7bff7 | 2015-08-17 13:23:14 -0700 | [diff] [blame] | 765 | Verifier(GetParam()).Expect(4, false).Verify(cq_.get()); |
yang-g | 9b7757d | 2015-08-13 11:15:53 -0700 | [diff] [blame] | 766 | |
| 767 | EXPECT_EQ(StatusCode::UNIMPLEMENTED, recv_status.error_code()); |
| 768 | EXPECT_EQ("", recv_status.error_message()); |
| 769 | } |
| 770 | |
Craig Tiller | 4c06b82 | 2015-08-06 08:41:31 -0700 | [diff] [blame] | 771 | INSTANTIATE_TEST_CASE_P(AsyncEnd2end, AsyncEnd2endTest, |
| 772 | ::testing::Values(false, true)); |
Craig Tiller | 69f90e6 | 2015-08-06 08:32:35 -0700 | [diff] [blame] | 773 | |
Craig Tiller | 0220cf1 | 2015-02-12 17:39:26 -0800 | [diff] [blame] | 774 | } // namespace |
| 775 | } // namespace testing |
| 776 | } // namespace grpc |
| 777 | |
| 778 | int main(int argc, char** argv) { |
| 779 | grpc_test_init(argc, argv); |
Craig Tiller | 0220cf1 | 2015-02-12 17:39:26 -0800 | [diff] [blame] | 780 | ::testing::InitGoogleTest(&argc, argv); |
Yang Gao | c4b6ffb | 2015-04-23 16:35:24 -0700 | [diff] [blame] | 781 | return RUN_ALL_TESTS(); |
Craig Tiller | 0220cf1 | 2015-02-12 17:39:26 -0800 | [diff] [blame] | 782 | } |