Add codegen generic to hybrid tests

1 files changed, 103 insertions, 0 deletions

diff --git a/test/cpp/end2end/hybrid_end2end_test.cc b/test/cpp/end2end/hybrid_end2end_test.cc
index 10e16429e6..4238c59380 100644
--- a/test/cpp/end2end/hybrid_end2end_test.cc
+++ b/test/cpp/end2end/hybrid_end2end_test.cc
@@ -74,6 +74,27 @@ void HandleEcho(Service* service, ServerCompletionQueue* cq, bool dup_service) {
   Verify(cq, 2, true);
 }
 
+// Handlers to handle codegen generic request at a server. To be run in a
+// separate thread. Note that this is the same as the async version, except
+// that the req/resp are ByteBuffers
+template <class Service>
+void HandleCodegenGenericEcho(Service* service, ServerCompletionQueue* cq,
+                              bool dup_service) {
+  ServerContext srv_ctx;
+  GenericServerAsyncResponseWriter response_writer(&srv_ctx);
+  ByteBuffer recv_buffer;
+  service->RequestEcho(&srv_ctx, &recv_buffer, &response_writer, cq, cq,
+                       tag(1));
+  Verify(cq, 1, true);
+  EchoRequest recv_request;
+  EXPECT_TRUE(ParseFromByteBuffer(&recv_buffer, &recv_request));
+  EchoResponse send_response;
+  send_response.set_message(recv_request.message());
+  auto send_buffer = SerializeToByteBuffer(&send_response);
+  response_writer.Finish(*send_buffer, Status::OK, tag(2));
+  Verify(cq, 2, true);
+}
+
 template <class Service>
 void HandleClientStreaming(Service* service, ServerCompletionQueue* cq) {
   ServerContext srv_ctx;
@@ -93,6 +114,31 @@ void HandleClientStreaming(Service* service, ServerCompletionQueue* cq) {
 }
 
 template <class Service>
+void HandleCodegenGenericClientStreaming(Service* service,
+                                         ServerCompletionQueue* cq) {
+  ServerContext srv_ctx;
+  ByteBuffer recv_buffer;
+  EchoRequest recv_request;
+  EchoResponse send_response;
+  GenericServerAsyncReader srv_stream(&srv_ctx);
+  service->RequestRequestStream(&srv_ctx, &srv_stream, cq, cq, tag(1));
+  Verify(cq, 1, true);
+  int i = 1;
+  while (true) {
+    i++;
+    srv_stream.Read(&recv_buffer, tag(i));
+    if (!VerifyReturnSuccess(cq, i)) {
+      break;
+    }
+    EXPECT_TRUE(ParseFromByteBuffer(&recv_buffer, &recv_request));
+    send_response.mutable_message()->append(recv_request.message());
+  }
+  auto send_buffer = SerializeToByteBuffer(&send_response);
+  srv_stream.Finish(*send_buffer, Status::OK, tag(100));
+  Verify(cq, 100, true);
+}
+
+template <class Service>
 void HandleServerStreaming(Service* service, ServerCompletionQueue* cq) {
   ServerContext srv_ctx;
   EchoRequest recv_request;
@@ -379,6 +425,63 @@ TEST_F(HybridEnd2endTest, AsyncEcho) {
   echo_handler_thread.join();
 }
 
+TEST_F(HybridEnd2endTest, CodegenGenericEcho) {
+  typedef EchoTestService::WithCodegenGenericMethod_Echo<TestServiceImpl> SType;
+  SType service;
+  SetUpServer(&service, nullptr, nullptr);
+  ResetStub();
+  std::thread echo_handler_thread(HandleCodegenGenericEcho<SType>, &service,
+                                  cqs_[0].get(), false);
+  TestAllMethods();
+  echo_handler_thread.join();
+}
+
+TEST_F(HybridEnd2endTest, CodegenGenericRequestStream) {
+  typedef EchoTestService::WithCodegenGenericMethod_RequestStream<
+      TestServiceImpl>
+      SType;
+  SType service;
+  SetUpServer(&service, nullptr, nullptr);
+  ResetStub();
+  std::thread request_stream_handler_thread(
+      HandleCodegenGenericClientStreaming<SType>, &service, cqs_[0].get());
+  TestAllMethods();
+  request_stream_handler_thread.join();
+}
+
+TEST_F(HybridEnd2endTest, AsyncEchoCodegenGenericRequestStream) {
+  typedef EchoTestService::WithCodegenGenericMethod_RequestStream<
+      EchoTestService::WithAsyncMethod_Echo<TestServiceImpl>>
+      SType;
+  SType service;
+  SetUpServer(&service, nullptr, nullptr);
+  ResetStub();
+  std::thread echo_handler_thread(HandleEcho<SType>, &service, cqs_[0].get(),
+                                  false);
+  std::thread request_stream_handler_thread(
+      HandleCodegenGenericClientStreaming<SType>, &service, cqs_[1].get());
+  TestAllMethods();
+  request_stream_handler_thread.join();
+  echo_handler_thread.join();
+}
+
+TEST_F(HybridEnd2endTest, GenericEchoCodegenGenericRequestStream) {
+  typedef EchoTestService::WithCodegenGenericMethod_RequestStream<
+      EchoTestService::WithGenericMethod_Echo<TestServiceImpl>>
+      SType;
+  SType service;
+  AsyncGenericService generic_service;
+  SetUpServer(&service, nullptr, &generic_service);
+  ResetStub();
+  std::thread generic_handler_thread(HandleGenericCall, &generic_service,
+                                     cqs_[0].get());
+  std::thread request_stream_handler_thread(
+      HandleCodegenGenericClientStreaming<SType>, &service, cqs_[1].get());
+  TestAllMethods();
+  generic_handler_thread.join();
+  request_stream_handler_thread.join();
+}
+
 TEST_F(HybridEnd2endTest, AsyncEchoRequestStream) {
   typedef EchoTestService::WithAsyncMethod_RequestStream<
       EchoTestService::WithAsyncMethod_Echo<TestServiceImpl>>