1 files changed, 63 insertions, 22 deletions

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(