Merge branch 'master' of github.com:grpc/grpc into qps_reporter_refactoring

17 files changed, 814 insertions, 158 deletions

diff --git a/test/cpp/end2end/client_crash_test.cc b/test/cpp/end2end/client_crash_test.cc
new file mode 100644
index 0000000000..e86681f75a
--- /dev/null
+++ b/test/cpp/end2end/client_crash_test.cc
@@ -0,0 +1,165 @@
+/*
+ *
+ * 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 "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 "src/cpp/server/thread_pool.h"
+#include <grpc++/channel_arguments.h>
+#include <grpc++/channel_interface.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 <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/cpp/util/subprocess.h"
+
+using grpc::cpp::test::util::EchoRequest;
+using grpc::cpp::test::util::EchoResponse;
+using std::chrono::system_clock;
+
+static std::string g_root;
+
+namespace grpc {
+namespace testing {
+
+namespace {
+
+class CrashTest : public ::testing::Test {
+ protected:
+  CrashTest() {}
+
+  std::unique_ptr<grpc::cpp::test::util::TestService::Stub>
+  CreateServerAndStub() {
+    auto port = grpc_pick_unused_port_or_die();
+    std::ostringstream addr_stream;
+    addr_stream << "localhost:" << port;
+    auto addr = addr_stream.str();
+    server_.reset(new SubProcess({
+      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();
+    // give some time for the TCP connection to drop
+    gpr_sleep_until(gpr_time_add(gpr_now(), gpr_time_from_seconds(1)));
+  }
+
+ private:
+  std::unique_ptr<SubProcess> server_;
+};
+
+TEST_F(CrashTest, KillAfterWrite) {
+  auto stub = CreateServerAndStub();
+
+  EchoRequest request;
+  EchoResponse response;
+  ClientContext context;
+
+  auto stream = stub->BidiStream(&context);
+
+  request.set_message("Hello");
+  EXPECT_TRUE(stream->Write(request));
+  EXPECT_TRUE(stream->Read(&response));
+  EXPECT_EQ(response.message(), request.message());
+
+  request.set_message("I'm going to kill you");
+  EXPECT_TRUE(stream->Write(request));
+
+  KillServer();
+
+  EXPECT_FALSE(stream->Read(&response));
+
+  EXPECT_FALSE(stream->Finish().IsOk());
+}
+
+TEST_F(CrashTest, KillBeforeWrite) {
+  auto stub = CreateServerAndStub();
+
+  EchoRequest request;
+  EchoResponse response;
+  ClientContext context;
+
+  auto stream = stub->BidiStream(&context);
+
+  request.set_message("Hello");
+  EXPECT_TRUE(stream->Write(request));
+  EXPECT_TRUE(stream->Read(&response));
+  EXPECT_EQ(response.message(), request.message());
+
+  KillServer();
+
+  request.set_message("You should be dead");
+  EXPECT_FALSE(stream->Write(request));
+  EXPECT_FALSE(stream->Read(&response));
+
+  EXPECT_FALSE(stream->Finish().IsOk());
+}
+
+}  // namespace
+
+}  // namespace testing
+}  // namespace grpc
+
+int main(int argc, char** argv) {
+  std::string me = argv[0];
+  auto lslash = me.rfind('/');
+  if (lslash != std::string::npos) {
+    g_root = me.substr(0, lslash);
+  } else {
+    g_root = ".";
+  }
+
+  grpc_test_init(argc, argv);
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/test/cpp/end2end/client_crash_test_server.cc b/test/cpp/end2end/client_crash_test_server.cc
new file mode 100644
index 0000000000..20808a0240
--- /dev/null
+++ b/test/cpp/end2end/client_crash_test_server.cc
@@ -0,0 +1,94 @@
+/*
+ *
+ * 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 <iostream>
+#include <memory>
+#include <string>
+#include <gflags/gflags.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/cpp/util/echo.grpc.pb.h"
+
+DEFINE_string(address, "", "Address to bind to");
+
+using grpc::cpp::test::util::EchoRequest;
+using grpc::cpp::test::util::EchoResponse;
+
+// In some distros, gflags is in the namespace google, and in some others,
+// in gflags. This hack is enabling us to find both.
+namespace google {}
+namespace gflags {}
+using namespace google;
+using namespace gflags;
+
+namespace grpc {
+namespace testing {
+
+class ServiceImpl GRPC_FINAL : public ::grpc::cpp::test::util::TestService::Service {
+  Status BidiStream(ServerContext* context,
+                    ServerReaderWriter<EchoResponse, EchoRequest>* stream)
+      GRPC_OVERRIDE {
+    EchoRequest request;
+    EchoResponse response;
+    while (stream->Read(&request)) {
+      gpr_log(GPR_INFO, "recv msg %s", request.message().c_str());
+      response.set_message(request.message());
+      stream->Write(response);
+    }
+    return Status::OK;
+  }
+};
+
+void RunServer() {
+  ServiceImpl service;
+
+  ServerBuilder builder;
+  builder.AddListeningPort(FLAGS_address, grpc::InsecureServerCredentials());
+  builder.RegisterService(&service);
+  std::unique_ptr<Server> server(builder.BuildAndStart());
+  std::cout << "Server listening on " << FLAGS_address << std::endl;
+  server->Wait();
+}
+}
+}
+
+int main(int argc, char** argv) {
+  ParseCommandLineFlags(&argc, &argv, true);
+  grpc::testing::RunServer();
+
+  return 0;
+}
diff --git a/test/cpp/end2end/end2end_test.cc b/test/cpp/end2end/end2end_test.cc
index 76271c3e1d..7a15591b44 100644
--- a/test/cpp/end2end/end2end_test.cc
+++ b/test/cpp/end2end/end2end_test.cc
@@ -96,14 +96,16 @@ class TestServiceImpl : public ::grpc::cpp::test::util::TestService::Service {
         signal_client_ = true;
       }
       while (!context->IsCancelled()) {
-        std::this_thread::sleep_for(std::chrono::microseconds(
-            request->param().client_cancel_after_us()));
+        gpr_sleep_until(gpr_time_add(
+            gpr_now(),
+            gpr_time_from_micros(request->param().client_cancel_after_us())));
       }
       return Status::Cancelled;
     } else if (request->has_param() &&
                request->param().server_cancel_after_us()) {
-      std::this_thread::sleep_for(
-          std::chrono::microseconds(request->param().server_cancel_after_us()));
+      gpr_sleep_until(gpr_time_add(
+            gpr_now(),
+            gpr_time_from_micros(request->param().server_cancel_after_us())));
       return Status::Cancelled;
     } else {
       EXPECT_FALSE(context->IsCancelled());
@@ -469,7 +471,7 @@ TEST_F(End2endTest, BadCredentials) {
 }
 
 void CancelRpc(ClientContext* context, int delay_us, TestServiceImpl* service) {
-  std::this_thread::sleep_for(std::chrono::microseconds(delay_us));
+  gpr_sleep_until(gpr_time_add(gpr_now(), gpr_time_from_micros(delay_us)));
   while (!service->signal_client()) {
   }
   context->TryCancel();
diff --git a/test/cpp/end2end/server_crash_test.cc b/test/cpp/end2end/server_crash_test.cc
new file mode 100644
index 0000000000..11d73aec7d
--- /dev/null
+++ b/test/cpp/end2end/server_crash_test.cc
@@ -0,0 +1,166 @@
+/*
+ *
+ * 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 "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 "src/cpp/server/thread_pool.h"
+#include <grpc++/channel_arguments.h>
+#include <grpc++/channel_interface.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 <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/cpp/util/subprocess.h"
+
+using grpc::cpp::test::util::EchoRequest;
+using grpc::cpp::test::util::EchoResponse;
+using std::chrono::system_clock;
+
+static std::string g_root;
+
+namespace grpc {
+namespace testing {
+
+namespace {
+
+class ServiceImpl GRPC_FINAL : public ::grpc::cpp::test::util::TestService::Service {
+  Status BidiStream(ServerContext* context,
+                    ServerReaderWriter<EchoResponse, EchoRequest>* stream)
+      GRPC_OVERRIDE {
+    EchoRequest request;
+    EchoResponse response;
+    while (stream->Read(&request)) {
+      gpr_log(GPR_INFO, "recv msg %s", request.message().c_str());
+      response.set_message(request.message());
+      stream->Write(response);
+      gpr_sleep_until(gpr_time_add(gpr_now(), gpr_time_from_seconds(1)));
+    }
+    return Status::OK;
+  }
+
+  Status ResponseStream(ServerContext* context, const EchoRequest* request,
+                        ServerWriter<EchoResponse>* writer) GRPC_OVERRIDE {
+    EchoResponse response;
+    for (int i = 0;; i++) {
+      std::ostringstream msg;
+      msg << "Hello " << i;
+      response.set_message(msg.str());
+      if (!writer->Write(response)) break;
+      gpr_sleep_until(gpr_time_add(gpr_now(), gpr_time_from_seconds(1)));
+    }
+    return Status::OK;
+  }
+};
+
+class CrashTest : public ::testing::Test {
+ protected:
+  CrashTest() {}
+
+  std::unique_ptr<Server>
+  CreateServerAndClient(const std::string& mode) {
+    auto port = grpc_pick_unused_port_or_die();
+    std::ostringstream addr_stream;
+    addr_stream << "localhost:" << port;
+    auto addr = addr_stream.str();
+    client_.reset(new SubProcess({
+      g_root + "/server_crash_test_client",
+      "--address=" + addr,
+      "--mode=" + mode
+    }));
+    GPR_ASSERT(client_);
+
+    ServerBuilder builder;
+    builder.AddListeningPort(addr, grpc::InsecureServerCredentials());
+    builder.RegisterService(&service_);
+    return builder.BuildAndStart();
+  }
+
+  void KillClient() {
+    client_.reset();
+  }
+
+ private:
+  std::unique_ptr<SubProcess> client_;
+  ServiceImpl service_;
+};
+
+TEST_F(CrashTest, ResponseStream) {
+  auto server = CreateServerAndClient("response");
+
+  gpr_sleep_until(gpr_time_add(gpr_now(), gpr_time_from_seconds(5)));
+  KillClient();
+  server->Shutdown();
+}
+
+TEST_F(CrashTest, BidiStream) {
+  auto server = CreateServerAndClient("bidi");
+
+  gpr_sleep_until(gpr_time_add(gpr_now(), gpr_time_from_seconds(5)));
+  KillClient();
+  server->Shutdown();
+}
+
+}  // namespace
+
+}  // namespace testing
+}  // namespace grpc
+
+int main(int argc, char** argv) {
+  std::string me = argv[0];
+  auto lslash = me.rfind('/');
+  if (lslash != std::string::npos) {
+    g_root = me.substr(0, lslash);
+  } else {
+    g_root = ".";
+  }
+
+  grpc_test_init(argc, argv);
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/test/cpp/end2end/server_crash_test_client.cc b/test/cpp/end2end/server_crash_test_client.cc
new file mode 100644
index 0000000000..497ccb4cb2
--- /dev/null
+++ b/test/cpp/end2end/server_crash_test_client.cc
@@ -0,0 +1,93 @@
+/*
+ *
+ * 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 <iostream>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <gflags/gflags.h>
+
+#include <grpc++/channel_arguments.h>
+#include <grpc++/channel_interface.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");
+DEFINE_string(mode, "", "Test mode to use");
+
+using grpc::cpp::test::util::EchoRequest;
+using grpc::cpp::test::util::EchoResponse;
+
+// In some distros, gflags is in the namespace google, and in some others,
+// in gflags. This hack is enabling us to find both.
+namespace google {}
+namespace gflags {}
+using namespace google;
+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()));
+
+  EchoRequest request;
+  EchoResponse response;
+  grpc::ClientContext context;
+
+  if (FLAGS_mode == "bidi") {
+    auto stream = stub->BidiStream(&context);
+    for (int i = 0;; i++) {
+      std::ostringstream msg;
+      msg << "Hello " << i;
+      request.set_message(msg.str());
+      GPR_ASSERT(stream->Write(request));
+      GPR_ASSERT(stream->Read(&response));
+      GPR_ASSERT(response.message() == request.message());
+    }
+  } else if (FLAGS_mode == "response") {
+    EchoRequest request;
+    request.set_message("Hello");
+    auto stream = stub->ResponseStream(&context, request);
+    for (;;) {
+      GPR_ASSERT(stream->Read(&response));
+    }
+  } else {
+    gpr_log(GPR_ERROR, "invalid test mode '%s'", FLAGS_mode.c_str());
+    return 1;
+  }
+
+  return 0;
+}
diff --git a/test/cpp/end2end/thread_stress_test.cc b/test/cpp/end2end/thread_stress_test.cc
index 12656128c0..310227a29c 100644
--- a/test/cpp/end2end/thread_stress_test.cc
+++ b/test/cpp/end2end/thread_stress_test.cc
@@ -94,14 +94,16 @@ class TestServiceImpl : public ::grpc::cpp::test::util::TestService::Service {
         signal_client_ = true;
       }
       while (!context->IsCancelled()) {
-        std::this_thread::sleep_for(std::chrono::microseconds(
-            request->param().client_cancel_after_us()));
+        gpr_sleep_until(gpr_time_add(
+            gpr_now(),
+            gpr_time_from_micros(request->param().client_cancel_after_us())));
       }
       return Status::Cancelled;
     } else if (request->has_param() &&
                request->param().server_cancel_after_us()) {
-      std::this_thread::sleep_for(
-          std::chrono::microseconds(request->param().server_cancel_after_us()));
+      gpr_sleep_until(gpr_time_add(
+          gpr_now(),
+          gpr_time_from_micros(request->param().server_cancel_after_us())));
       return Status::Cancelled;
     } else {
       EXPECT_FALSE(context->IsCancelled());
diff --git a/test/cpp/qps/client.h b/test/cpp/qps/client.h
index 2dc5b3860f..dc3a9f2ac5 100644
--- a/test/cpp/qps/client.h
+++ b/test/cpp/qps/client.h
@@ -113,24 +113,26 @@ class Client {
         : done_(false),
           new_(nullptr),
           impl_([this, idx, client]() {
-              for (;;) {
-                // run the loop body
-        	      bool thread_still_ok = client->ThreadFunc(&histogram_, idx);
-                // lock, see if we're done
-                std::lock_guard<std::mutex> g(mu_);
-                if (!thread_still_ok) {
-                  gpr_log(GPR_ERROR, "Finishing client thread due to RPC error");
-                  done_ = true;
-                }
-                if (done_) {return;}
-        	      // check if we're marking, swap out the histogram if so
-        	      if (new_) {
-                        new_->Swap(&histogram_);
-                        new_ = nullptr;
-                        cv_.notify_one();
-                }
+            for (;;) {
+              // run the loop body
+              bool thread_still_ok = client->ThreadFunc(&histogram_, idx);
+              // lock, see if we're done
+              std::lock_guard<std::mutex> g(mu_);
+              if (!thread_still_ok) {
+                gpr_log(GPR_ERROR, "Finishing client thread due to RPC error");
+                done_ = true;
               }
-            }) {}
+              if (done_) {
+                return;
+              }
+              // check if we're marking, swap out the histogram if so
+              if (new_) {
+                new_->Swap(&histogram_);
+                new_ = nullptr;
+                cv_.notify_one();
+              }
+            }
+          }) {}
 
     ~Thread() {
       {
@@ -168,10 +170,9 @@ class Client {
   std::unique_ptr<Timer> timer_;
 };
 
-std::unique_ptr<Client>
-  CreateSynchronousUnaryClient(const ClientConfig& args);
-std::unique_ptr<Client>
-  CreateSynchronousStreamingClient(const ClientConfig& args);
+std::unique_ptr<Client> CreateSynchronousUnaryClient(const ClientConfig& args);
+std::unique_ptr<Client> CreateSynchronousStreamingClient(
+    const ClientConfig& args);
 std::unique_ptr<Client> CreateAsyncUnaryClient(const ClientConfig& args);
 std::unique_ptr<Client> CreateAsyncStreamingClient(const ClientConfig& args);
 
diff --git a/test/cpp/qps/client_async.cc b/test/cpp/qps/client_async.cc
index e3ab57728d..00bbd8a8a0 100644
--- a/test/cpp/qps/client_async.cc
+++ b/test/cpp/qps/client_async.cc
@@ -128,16 +128,16 @@ class ClientRpcContextUnaryImpl : public ClientRpcContext {
 class AsyncClient : public Client {
  public:
   explicit AsyncClient(const ClientConfig& config,
-		       std::function<void(CompletionQueue*, TestService::Stub*,
-					  const SimpleRequest&)> setup_ctx) :
-      Client(config) {
+                       std::function<void(CompletionQueue*, TestService::Stub*,
+                                          const SimpleRequest&)> setup_ctx)
+      : Client(config) {
     for (int i = 0; i < config.async_client_threads(); i++) {
       cli_cqs_.emplace_back(new CompletionQueue);
     }
     int t = 0;
     for (int i = 0; i < config.outstanding_rpcs_per_channel(); i++) {
       for (auto channel = channels_.begin(); channel != channels_.end();
-	   channel++) {
+           channel++) {
         auto* cq = cli_cqs_[t].get();
         t = (t + 1) % cli_cqs_.size();
         setup_ctx(cq, channel->get_stub(), request_);
@@ -155,16 +155,19 @@ class AsyncClient : public Client {
     }
   }
 
-  bool ThreadFunc(Histogram* histogram, size_t thread_idx)
-      GRPC_OVERRIDE GRPC_FINAL {
+  bool ThreadFunc(Histogram* histogram,
+                  size_t thread_idx) GRPC_OVERRIDE GRPC_FINAL {
     void* got_tag;
     bool ok;
-    switch (cli_cqs_[thread_idx]->AsyncNext(&got_tag, &ok,
-                                            std::chrono::system_clock::now() +
-                                            std::chrono::seconds(1))) {
-      case CompletionQueue::SHUTDOWN: return false;
-      case CompletionQueue::TIMEOUT: return true;
-      case CompletionQueue::GOT_EVENT: break;
+    switch (cli_cqs_[thread_idx]->AsyncNext(
+        &got_tag, &ok,
+        std::chrono::system_clock::now() + std::chrono::seconds(1))) {
+      case CompletionQueue::SHUTDOWN:
+        return false;
+      case CompletionQueue::TIMEOUT:
+        return true;
+      case CompletionQueue::GOT_EVENT:
+        break;
     }
 
     ClientRpcContext* ctx = ClientRpcContext::detag(got_tag);
@@ -177,18 +180,20 @@ class AsyncClient : public Client {
 
     return true;
   }
+
  private:
   std::vector<std::unique_ptr<CompletionQueue>> cli_cqs_;
 };
 
 class AsyncUnaryClient GRPC_FINAL : public AsyncClient {
  public:
-  explicit AsyncUnaryClient(const ClientConfig& config) :
-      AsyncClient(config, SetupCtx) {
+  explicit AsyncUnaryClient(const ClientConfig& config)
+      : AsyncClient(config, SetupCtx) {
     StartThreads(config.async_client_threads());
   }
   ~AsyncUnaryClient() GRPC_OVERRIDE { EndThreads(); }
-private:
+
+ private:
   static void SetupCtx(CompletionQueue* cq, TestService::Stub* stub,
                        const SimpleRequest& req) {
     auto check_done = [](grpc::Status s, SimpleResponse* response) {};
@@ -205,12 +210,11 @@ template <class RequestType, class ResponseType>
 class ClientRpcContextStreamingImpl : public ClientRpcContext {
  public:
   ClientRpcContextStreamingImpl(
-      TestService::Stub *stub, const RequestType &req,
-      std::function<
-              std::unique_ptr<grpc::ClientAsyncReaderWriter<
-                              RequestType,ResponseType>>(
-              TestService::Stub *, grpc::ClientContext *, void *)> start_req,
-      std::function<void(grpc::Status, ResponseType *)> on_done)
+      TestService::Stub* stub, const RequestType& req,
+      std::function<std::unique_ptr<
+          grpc::ClientAsyncReaderWriter<RequestType, ResponseType>>(
+          TestService::Stub*, grpc::ClientContext*, void*)> start_req,
+      std::function<void(grpc::Status, ResponseType*)> on_done)
       : context_(),
         stub_(stub),
         req_(req),
@@ -221,7 +225,7 @@ class ClientRpcContextStreamingImpl : public ClientRpcContext {
         start_(Timer::Now()),
         stream_(start_req_(stub_, &context_, ClientRpcContext::tag(this))) {}
   ~ClientRpcContextStreamingImpl() GRPC_OVERRIDE {}
-  bool RunNextState(bool ok, Histogram *hist) GRPC_OVERRIDE {
+  bool RunNextState(bool ok, Histogram* hist) GRPC_OVERRIDE {
     return (this->*next_state_)(ok, hist);
   }
   void StartNewClone() GRPC_OVERRIDE {
@@ -229,59 +233,58 @@ class ClientRpcContextStreamingImpl : public ClientRpcContext {
   }
 
  private:
-  bool ReqSent(bool ok, Histogram *) {
-    return StartWrite(ok);
-  }
+  bool ReqSent(bool ok, Histogram*) { return StartWrite(ok); }
   bool StartWrite(bool ok) {
     if (!ok) {
-      return(false);
+      return (false);
     }
     start_ = Timer::Now();
     next_state_ = &ClientRpcContextStreamingImpl::WriteDone;
     stream_->Write(req_, ClientRpcContext::tag(this));
     return true;
   }
-  bool WriteDone(bool ok, Histogram *) {
+  bool WriteDone(bool ok, Histogram*) {
     if (!ok) {
-      return(false);
+      return (false);
     }
     next_state_ = &ClientRpcContextStreamingImpl::ReadDone;
     stream_->Read(&response_, ClientRpcContext::tag(this));
     return true;
   }
-  bool ReadDone(bool ok, Histogram *hist) {
+  bool ReadDone(bool ok, Histogram* hist) {
     hist->Add((Timer::Now() - start_) * 1e9);
     return StartWrite(ok);
   }
   grpc::ClientContext context_;
-  TestService::Stub *stub_;
+  TestService::Stub* stub_;
   RequestType req_;
   ResponseType response_;
-  bool (ClientRpcContextStreamingImpl::*next_state_)(bool, Histogram *);
-  std::function<void(grpc::Status, ResponseType *)> callback_;
-  std::function<std::unique_ptr<grpc::ClientAsyncReaderWriter<
-				  RequestType,ResponseType>>(
-      TestService::Stub *, grpc::ClientContext *, void *)> start_req_;
+  bool (ClientRpcContextStreamingImpl::*next_state_)(bool, Histogram*);
+  std::function<void(grpc::Status, ResponseType*)> callback_;
+  std::function<
+      std::unique_ptr<grpc::ClientAsyncReaderWriter<RequestType, ResponseType>>(
+          TestService::Stub*, grpc::ClientContext*, void*)> start_req_;
   grpc::Status status_;
   double start_;
-  std::unique_ptr<grpc::ClientAsyncReaderWriter<RequestType,ResponseType>>
-    stream_;
+  std::unique_ptr<grpc::ClientAsyncReaderWriter<RequestType, ResponseType>>
+      stream_;
 };
 
 class AsyncStreamingClient GRPC_FINAL : public AsyncClient {
  public:
-  explicit AsyncStreamingClient(const ClientConfig &config) :
-      AsyncClient(config, SetupCtx) {
+  explicit AsyncStreamingClient(const ClientConfig& config)
+      : AsyncClient(config, SetupCtx) {
     StartThreads(config.async_client_threads());
   }
 
   ~AsyncStreamingClient() GRPC_OVERRIDE { EndThreads(); }
-private:
+
+ private:
   static void SetupCtx(CompletionQueue* cq, TestService::Stub* stub,
-                       const SimpleRequest& req)  {
+                       const SimpleRequest& req) {
     auto check_done = [](grpc::Status s, SimpleResponse* response) {};
-    auto start_req = [cq](TestService::Stub *stub, grpc::ClientContext *ctx,
-                          void *tag) {
+    auto start_req = [cq](TestService::Stub* stub, grpc::ClientContext* ctx,
+                          void* tag) {
       auto stream = stub->AsyncStreamingCall(ctx, cq, tag);
       return stream;
     };
diff --git a/test/cpp/qps/client_sync.cc b/test/cpp/qps/client_sync.cc
index 264293561d..c28dc91321 100644
--- a/test/cpp/qps/client_sync.cc
+++ b/test/cpp/qps/client_sync.cc
@@ -99,7 +99,9 @@ class SynchronousUnaryClient GRPC_FINAL : public SynchronousClient {
 class SynchronousStreamingClient GRPC_FINAL : public SynchronousClient {
  public:
   SynchronousStreamingClient(const ClientConfig& config)
-    : SynchronousClient(config), context_(num_threads_), stream_(num_threads_) {
+      : SynchronousClient(config),
+        context_(num_threads_),
+        stream_(num_threads_) {
     for (size_t thread_idx = 0; thread_idx < num_threads_; thread_idx++) {
       auto* stub = channels_[thread_idx % channels_.size()].get_stub();
       stream_[thread_idx] = stub->StreamingCall(&context_[thread_idx]);
@@ -110,8 +112,8 @@ class SynchronousStreamingClient GRPC_FINAL : public SynchronousClient {
     EndThreads();
     for (auto stream = stream_.begin(); stream != stream_.end(); stream++) {
       if (*stream) {
-	(*stream)->WritesDone();
-	EXPECT_TRUE((*stream)->Finish().IsOk());
+        (*stream)->WritesDone();
+        EXPECT_TRUE((*stream)->Finish().IsOk());
       }
     }
   }
@@ -119,7 +121,7 @@ class SynchronousStreamingClient GRPC_FINAL : public SynchronousClient {
   bool ThreadFunc(Histogram* histogram, size_t thread_idx) GRPC_OVERRIDE {
     double start = Timer::Now();
     if (stream_[thread_idx]->Write(request_) &&
-	stream_[thread_idx]->Read(&responses_[thread_idx])) {
+        stream_[thread_idx]->Read(&responses_[thread_idx])) {
       histogram->Add((Timer::Now() - start) * 1e9);
       return true;
     }
@@ -128,8 +130,8 @@ class SynchronousStreamingClient GRPC_FINAL : public SynchronousClient {
 
  private:
   std::vector<grpc::ClientContext> context_;
-  std::vector<std::unique_ptr<grpc::ClientReaderWriter<
-				SimpleRequest, SimpleResponse>>> stream_;
+  std::vector<std::unique_ptr<
+      grpc::ClientReaderWriter<SimpleRequest, SimpleResponse>>> stream_;
 };
 
 std::unique_ptr<Client> CreateSynchronousUnaryClient(
diff --git a/test/cpp/qps/driver.cc b/test/cpp/qps/driver.cc
index 682d515ebe..bf12730f97 100644
--- a/test/cpp/qps/driver.cc
+++ b/test/cpp/qps/driver.cc
@@ -105,7 +105,7 @@ std::unique_ptr<ScenarioResult> RunScenario(
     if (!called_init) {
       char args_buf[100];
       strcpy(args_buf, "some-benchmark");
-      char *args[] = {args_buf};
+      char* args[] = {args_buf};
       grpc_test_init(1, args);
       called_init = true;
     }
@@ -211,7 +211,8 @@ std::unique_ptr<ScenarioResult> RunScenario(
 
   // Wait some time
   gpr_log(GPR_INFO, "Running");
-  gpr_sleep_until(gpr_time_add(start, gpr_time_from_seconds(benchmark_seconds)));
+  gpr_sleep_until(
+      gpr_time_add(start, gpr_time_from_seconds(benchmark_seconds)));
 
   // Finish a run
   std::unique_ptr<ScenarioResult> result(new ScenarioResult);
diff --git a/test/cpp/qps/qps_driver.cc b/test/cpp/qps/qps_driver.cc
index 0b6759a6ed..281e2e8119 100644
--- a/test/cpp/qps/qps_driver.cc
+++ b/test/cpp/qps/qps_driver.cc
@@ -104,8 +104,8 @@ static void QpsDriver() {
   // client will deadlock on a timer.
   GPR_ASSERT(!(server_type == grpc::testing::SYNCHRONOUS_SERVER &&
                rpc_type == grpc::testing::STREAMING &&
-               FLAGS_server_threads <  FLAGS_client_channels *
-               FLAGS_outstanding_rpcs_per_channel));
+               FLAGS_server_threads <
+                   FLAGS_client_channels * FLAGS_outstanding_rpcs_per_channel));
 
   const auto result = RunScenario(
       client_config, FLAGS_num_clients, server_config, FLAGS_num_servers,
diff --git a/test/cpp/qps/qps_worker.cc b/test/cpp/qps/qps_worker.cc
index 46d70dce52..fb49271991 100644
--- a/test/cpp/qps/qps_worker.cc
+++ b/test/cpp/qps/qps_worker.cc
@@ -64,17 +64,19 @@ namespace testing {
 std::unique_ptr<Client> CreateClient(const ClientConfig& config) {
   switch (config.client_type()) {
     case ClientType::SYNCHRONOUS_CLIENT:
-      return (config.rpc_type() == RpcType::UNARY) ?
-	CreateSynchronousUnaryClient(config) :
-	CreateSynchronousStreamingClient(config);
+      return (config.rpc_type() == RpcType::UNARY)
+                 ? CreateSynchronousUnaryClient(config)
+                 : CreateSynchronousStreamingClient(config);
     case ClientType::ASYNC_CLIENT:
-      return (config.rpc_type() == RpcType::UNARY) ?
-	CreateAsyncUnaryClient(config) : CreateAsyncStreamingClient(config);
+      return (config.rpc_type() == RpcType::UNARY)
+                 ? CreateAsyncUnaryClient(config)
+                 : CreateAsyncStreamingClient(config);
   }
   abort();
 }
 
-std::unique_ptr<Server> CreateServer(const ServerConfig& config, int server_port) {
+std::unique_ptr<Server> CreateServer(const ServerConfig& config,
+                                     int server_port) {
   switch (config.server_type()) {
     case ServerType::SYNCHRONOUS_SERVER:
       return CreateSynchronousServer(config, server_port);
@@ -86,7 +88,8 @@ std::unique_ptr<Server> CreateServer(const ServerConfig& config, int server_port
 
 class WorkerImpl GRPC_FINAL : public Worker::Service {
  public:
-  explicit WorkerImpl(int server_port) : server_port_(server_port), acquired_(false) {}
+  explicit WorkerImpl(int server_port)
+      : server_port_(server_port), acquired_(false) {}
 
   Status RunTest(ServerContext* ctx,
                  ServerReaderWriter<ClientStatus, ClientArgs>* stream)
@@ -97,7 +100,7 @@ class WorkerImpl GRPC_FINAL : public Worker::Service {
     }
 
     grpc_profiler_start("qps_client.prof");
-    Status ret = RunTestBody(ctx,stream);
+    Status ret = RunTestBody(ctx, stream);
     grpc_profiler_stop();
     return ret;
   }
@@ -111,7 +114,7 @@ class WorkerImpl GRPC_FINAL : public Worker::Service {
     }
 
     grpc_profiler_start("qps_server.prof");
-    Status ret = RunServerBody(ctx,stream);
+    Status ret = RunServerBody(ctx, stream);
     grpc_profiler_stop();
     return ret;
   }
@@ -226,8 +229,7 @@ QpsWorker::QpsWorker(int driver_port, int server_port) {
   server_ = std::move(builder.BuildAndStart());
 }
 
-QpsWorker::~QpsWorker() {
-}
+QpsWorker::~QpsWorker() {}
 
 }  // namespace testing
 }  // namespace grpc
diff --git a/test/cpp/qps/server_async.cc b/test/cpp/qps/server_async.cc
index 6cb3192908..58499f345f 100644
--- a/test/cpp/qps/server_async.cc
+++ b/test/cpp/qps/server_async.cc
@@ -64,7 +64,7 @@ namespace testing {
 class AsyncQpsServerTest : public Server {
  public:
   AsyncQpsServerTest(const ServerConfig &config, int port) : shutdown_(false) {
-    char* server_address = NULL;
+    char *server_address = NULL;
     gpr_join_host_port(&server_address, "::", port);
 
     ServerBuilder builder;
@@ -95,9 +95,9 @@ class AsyncQpsServerTest : public Server {
       threads_.push_back(std::thread([=]() {
         // Wait until work is available or we are shutting down
         bool ok;
-        void* got_tag;
+        void *got_tag;
         while (srv_cq_->Next(&got_tag, &ok)) {
-          ServerRpcContext* ctx = detag(got_tag);
+          ServerRpcContext *ctx = detag(got_tag);
           // The tag is a pointer to an RPC context to invoke
           if (ctx->RunNextState(ok) == false) {
             // this RPC context is done, so refresh it
@@ -133,23 +133,23 @@ class AsyncQpsServerTest : public Server {
     ServerRpcContext() {}
     virtual ~ServerRpcContext(){};
     virtual bool RunNextState(bool) = 0;  // next state, return false if done
-    virtual void Reset() = 0;         // start this back at a clean state
+    virtual void Reset() = 0;             // start this back at a clean state
   };
-  static void* tag(ServerRpcContext* func) {
-    return reinterpret_cast<void*>(func);
+  static void *tag(ServerRpcContext *func) {
+    return reinterpret_cast<void *>(func);
   }
-  static ServerRpcContext* detag(void* tag) {
-    return reinterpret_cast<ServerRpcContext*>(tag);
+  static ServerRpcContext *detag(void *tag) {
+    return reinterpret_cast<ServerRpcContext *>(tag);
   }
 
   template <class RequestType, class ResponseType>
   class ServerRpcContextUnaryImpl GRPC_FINAL : public ServerRpcContext {
    public:
     ServerRpcContextUnaryImpl(
-        std::function<void(ServerContext*, RequestType*,
-                           grpc::ServerAsyncResponseWriter<ResponseType>*,
-                           void*)> request_method,
-        std::function<grpc::Status(const RequestType*, ResponseType*)>
+        std::function<void(ServerContext *, RequestType *,
+                           grpc::ServerAsyncResponseWriter<ResponseType> *,
+                           void *)> request_method,
+        std::function<grpc::Status(const RequestType *, ResponseType *)>
             invoke_method)
         : next_state_(&ServerRpcContextUnaryImpl::invoker),
           request_method_(request_method),
@@ -159,7 +159,9 @@ class AsyncQpsServerTest : public Server {
                       AsyncQpsServerTest::tag(this));
     }
     ~ServerRpcContextUnaryImpl() GRPC_OVERRIDE {}
-    bool RunNextState(bool ok) GRPC_OVERRIDE {return (this->*next_state_)(ok);}
+    bool RunNextState(bool ok) GRPC_OVERRIDE {
+      return (this->*next_state_)(ok);
+    }
     void Reset() GRPC_OVERRIDE {
       srv_ctx_ = ServerContext();
       req_ = RequestType();
@@ -192,10 +194,10 @@ class AsyncQpsServerTest : public Server {
     ServerContext srv_ctx_;
     RequestType req_;
     bool (ServerRpcContextUnaryImpl::*next_state_)(bool);
-    std::function<void(ServerContext*, RequestType*,
-                       grpc::ServerAsyncResponseWriter<ResponseType>*, void*)>
+    std::function<void(ServerContext *, RequestType *,
+                       grpc::ServerAsyncResponseWriter<ResponseType> *, void *)>
         request_method_;
-    std::function<grpc::Status(const RequestType*, ResponseType*)>
+    std::function<grpc::Status(const RequestType *, ResponseType *)>
         invoke_method_;
     grpc::ServerAsyncResponseWriter<ResponseType> response_writer_;
   };
@@ -204,9 +206,9 @@ class AsyncQpsServerTest : public Server {
   class ServerRpcContextStreamingImpl GRPC_FINAL : public ServerRpcContext {
    public:
     ServerRpcContextStreamingImpl(
-        std::function<void(ServerContext *,
-                           grpc::ServerAsyncReaderWriter<ResponseType,
-			   RequestType> *, void *)> request_method,
+        std::function<void(ServerContext *, grpc::ServerAsyncReaderWriter<
+                                                ResponseType, RequestType> *,
+                           void *)> request_method,
         std::function<grpc::Status(const RequestType *, ResponseType *)>
             invoke_method)
         : next_state_(&ServerRpcContextStreamingImpl::request_done),
@@ -215,14 +217,15 @@ class AsyncQpsServerTest : public Server {
           stream_(&srv_ctx_) {
       request_method_(&srv_ctx_, &stream_, AsyncQpsServerTest::tag(this));
     }
-    ~ServerRpcContextStreamingImpl() GRPC_OVERRIDE {
+    ~ServerRpcContextStreamingImpl() GRPC_OVERRIDE {}
+    bool RunNextState(bool ok) GRPC_OVERRIDE {
+      return (this->*next_state_)(ok);
     }
-    bool RunNextState(bool ok) GRPC_OVERRIDE {return (this->*next_state_)(ok);}
     void Reset() GRPC_OVERRIDE {
       srv_ctx_ = ServerContext();
       req_ = RequestType();
-      stream_ = grpc::ServerAsyncReaderWriter<ResponseType,
-					      RequestType>(&srv_ctx_);
+      stream_ =
+          grpc::ServerAsyncReaderWriter<ResponseType, RequestType>(&srv_ctx_);
 
       // Then request the method
       next_state_ = &ServerRpcContextStreamingImpl::request_done;
@@ -241,47 +244,47 @@ class AsyncQpsServerTest : public Server {
 
     bool read_done(bool ok) {
       if (ok) {
-	// invoke the method
-	ResponseType response;
-	// Call the RPC processing function
-	grpc::Status status = invoke_method_(&req_, &response);
-	// initiate the write
-	stream_.Write(response, AsyncQpsServerTest::tag(this));
-	next_state_ = &ServerRpcContextStreamingImpl::write_done;
-      } else {	// client has sent writes done
-	// finish the stream
-	stream_.Finish(Status::OK, AsyncQpsServerTest::tag(this));
-	next_state_ = &ServerRpcContextStreamingImpl::finish_done;
+        // invoke the method
+        ResponseType response;
+        // Call the RPC processing function
+        grpc::Status status = invoke_method_(&req_, &response);
+        // initiate the write
+        stream_.Write(response, AsyncQpsServerTest::tag(this));
+        next_state_ = &ServerRpcContextStreamingImpl::write_done;
+      } else {  // client has sent writes done
+        // finish the stream
+        stream_.Finish(Status::OK, AsyncQpsServerTest::tag(this));
+        next_state_ = &ServerRpcContextStreamingImpl::finish_done;
       }
       return true;
     }
     bool write_done(bool ok) {
       // now go back and get another streaming read!
       if (ok) {
-	stream_.Read(&req_, AsyncQpsServerTest::tag(this));
-	next_state_ = &ServerRpcContextStreamingImpl::read_done;
-      }
-      else {
-	stream_.Finish(Status::OK, AsyncQpsServerTest::tag(this));
-	next_state_ = &ServerRpcContextStreamingImpl::finish_done;
+        stream_.Read(&req_, AsyncQpsServerTest::tag(this));
+        next_state_ = &ServerRpcContextStreamingImpl::read_done;
+      } else {
+        stream_.Finish(Status::OK, AsyncQpsServerTest::tag(this));
+        next_state_ = &ServerRpcContextStreamingImpl::finish_done;
       }
       return true;
     }
-    bool finish_done(bool ok) {return false; /* reset the context */ }
+    bool finish_done(bool ok) { return false; /* reset the context */ }
 
     ServerContext srv_ctx_;
     RequestType req_;
     bool (ServerRpcContextStreamingImpl::*next_state_)(bool);
-    std::function<void(ServerContext *,
-		       grpc::ServerAsyncReaderWriter<ResponseType,
-		       RequestType> *, void *)> request_method_;
+    std::function<void(
+        ServerContext *,
+        grpc::ServerAsyncReaderWriter<ResponseType, RequestType> *, void *)>
+        request_method_;
     std::function<grpc::Status(const RequestType *, ResponseType *)>
         invoke_method_;
-    grpc::ServerAsyncReaderWriter<ResponseType,RequestType> stream_;
+    grpc::ServerAsyncReaderWriter<ResponseType, RequestType> stream_;
   };
 
-  static Status ProcessRPC(const SimpleRequest* request,
-			   SimpleResponse* response) {
+  static Status ProcessRPC(const SimpleRequest *request,
+                           SimpleResponse *response) {
     if (request->response_size() > 0) {
       if (!SetPayload(request->response_type(), request->response_size(),
                       response->mutable_payload())) {
@@ -294,19 +297,20 @@ class AsyncQpsServerTest : public Server {
   std::unique_ptr<grpc::Server> server_;
   std::unique_ptr<grpc::ServerCompletionQueue> srv_cq_;
   TestService::AsyncService async_service_;
-  std::function<void(ServerContext*, SimpleRequest*,
-                     grpc::ServerAsyncResponseWriter<SimpleResponse>*, void*)>
+  std::function<void(ServerContext *, SimpleRequest *,
+                     grpc::ServerAsyncResponseWriter<SimpleResponse> *, void *)>
       request_unary_;
-  std::function<void(ServerContext*, grpc::ServerAsyncReaderWriter<
-		     SimpleResponse,SimpleRequest>*, void*)>
+  std::function<void(
+      ServerContext *,
+      grpc::ServerAsyncReaderWriter<SimpleResponse, SimpleRequest> *, void *)>
       request_streaming_;
-  std::forward_list<ServerRpcContext*> contexts_;
+  std::forward_list<ServerRpcContext *> contexts_;
 
   std::mutex shutdown_mutex_;
   bool shutdown_;
 };
 
-std::unique_ptr<Server> CreateAsyncServer(const ServerConfig& config,
+std::unique_ptr<Server> CreateAsyncServer(const ServerConfig &config,
                                           int port) {
   return std::unique_ptr<Server>(new AsyncQpsServerTest(config, port));
 }
diff --git a/test/cpp/qps/server_sync.cc b/test/cpp/qps/server_sync.cc
index 2770233a7c..bc00de9ced 100644
--- a/test/cpp/qps/server_sync.cc
+++ b/test/cpp/qps/server_sync.cc
@@ -70,18 +70,18 @@ class TestServiceImpl GRPC_FINAL : public TestService::Service {
     }
     return Status::OK;
   }
-  Status StreamingCall(ServerContext *context,
-		       ServerReaderWriter<SimpleResponse, SimpleRequest>*
-		       stream) GRPC_OVERRIDE {
+  Status StreamingCall(
+      ServerContext* context,
+      ServerReaderWriter<SimpleResponse, SimpleRequest>* stream) GRPC_OVERRIDE {
     SimpleRequest request;
     while (stream->Read(&request)) {
       SimpleResponse response;
       if (request.response_size() > 0) {
-	if (!Server::SetPayload(request.response_type(),
-				request.response_size(),
-				response.mutable_payload())) {
-	  return Status(grpc::StatusCode::INTERNAL, "Error creating payload.");
-	}
+        if (!Server::SetPayload(request.response_type(),
+                                request.response_size(),
+                                response.mutable_payload())) {
+          return Status(grpc::StatusCode::INTERNAL, "Error creating payload.");
+        }
       }
       stream->Write(response);
     }
diff --git a/test/cpp/qps/worker.cc b/test/cpp/qps/worker.cc
index 281c617382..dfc102fc17 100644
--- a/test/cpp/qps/worker.cc
+++ b/test/cpp/qps/worker.cc
@@ -37,6 +37,7 @@
 #include <thread>
 
 #include <grpc/grpc.h>
+#include <grpc/support/time.h>
 #include <gflags/gflags.h>
 
 #include "qps_worker.h"
@@ -47,7 +48,7 @@ DEFINE_int32(server_port, 0, "Spawned server port.");
 
 static bool got_sigint = false;
 
-static void sigint_handler(int x) {got_sigint = true;}
+static void sigint_handler(int x) { got_sigint = true; }
 
 namespace grpc {
 namespace testing {
@@ -56,7 +57,7 @@ static void RunServer() {
   QpsWorker worker(FLAGS_driver_port, FLAGS_server_port);
 
   while (!got_sigint) {
-    std::this_thread::sleep_for(std::chrono::seconds(5));
+    gpr_sleep_until(gpr_time_add(gpr_now(), gpr_time_from_seconds(5)));
   }
 }
 
@@ -69,6 +70,6 @@ int main(int argc, char** argv) {
   signal(SIGINT, sigint_handler);
 
   grpc::testing::RunServer();
-  
+
   return 0;
 }
diff --git a/test/cpp/util/subprocess.cc b/test/cpp/util/subprocess.cc
new file mode 100644
index 0000000000..d758f629ac
--- /dev/null
+++ b/test/cpp/util/subprocess.cc
@@ -0,0 +1,59 @@
+/*
+ *
+ * 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 "test/cpp/util/subprocess.h"
+
+#include <vector>
+
+#include <grpc/support/subprocess.h>
+
+namespace grpc {
+
+static gpr_subprocess *MakeProcess(std::initializer_list<std::string> args) {
+  std::vector<const char *> vargs;
+  for (auto it = args.begin(); it != args.end(); ++it) {
+    vargs.push_back(it->c_str());
+  }
+  return gpr_subprocess_create(vargs.size(), &vargs[0]);
+}
+
+SubProcess::SubProcess(std::initializer_list<std::string> args)
+    : subprocess_(MakeProcess(args)) {}
+
+SubProcess::~SubProcess() { gpr_subprocess_destroy(subprocess_); }
+
+int SubProcess::Join() { return gpr_subprocess_join(subprocess_); }
+
+void SubProcess::Interrupt() { gpr_subprocess_interrupt(subprocess_); }
+
+}  // namespace grpc
\ No newline at end of file
diff --git a/test/cpp/util/subprocess.h b/test/cpp/util/subprocess.h
new file mode 100644
index 0000000000..8fafe3d177
--- /dev/null
+++ b/test/cpp/util/subprocess.h
@@ -0,0 +1,61 @@
+/*
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_TEST_CPP_UTIL_SUBPROCESS_H
+#define GRPC_TEST_CPP_UTIL_SUBPROCESS_H
+
+#include <initializer_list>
+#include <string>
+
+struct gpr_subprocess;
+
+namespace grpc {
+
+class SubProcess {
+ public:
+  SubProcess(std::initializer_list<std::string> args);
+  ~SubProcess();
+
+  int Join();
+  void Interrupt();
+
+ private:
+  SubProcess(const SubProcess& other);
+  SubProcess& operator=(const SubProcess& other);
+
+  gpr_subprocess* const subprocess_;
+};
+
+}  // namespace grpc
+
+#endif  // GRPC_TEST_CPP_UTIL_SUBPROCESS_H