diff --git a/include/grpc++/support/byte_buffer.h b/include/grpc++/support/byte_buffer.h
index be1957ac84a..84042cbef80 100644
--- a/include/grpc++/support/byte_buffer.h
+++ b/include/grpc++/support/byte_buffer.h
@@ -57,7 +57,7 @@ class ByteBuffer GRPC_FINAL {
 
   /// Constuct a byte buffer by referencing elements of existing buffer
   /// \a buf. Wrapper of core function grpc_byte_buffer_copy
-  ByteBuffer(const ByteBuffer&buf);
+  ByteBuffer(const ByteBuffer& buf);
 
   ~ByteBuffer();
 
diff --git a/src/cpp/util/byte_buffer.cc b/src/cpp/util/byte_buffer.cc
index 1c1d55271da..df873eb1ceb 100644
--- a/src/cpp/util/byte_buffer.cc
+++ b/src/cpp/util/byte_buffer.cc
@@ -79,13 +79,12 @@ size_t ByteBuffer::Length() const {
   }
 }
 
-ByteBuffer::ByteBuffer(const ByteBuffer& buf):
-    buffer_(grpc_byte_buffer_copy(buf.buffer_)) {
-}
+ByteBuffer::ByteBuffer(const ByteBuffer& buf)
+    : buffer_(grpc_byte_buffer_copy(buf.buffer_)) {}
 
 ByteBuffer& ByteBuffer::operator=(const ByteBuffer& buf) {
-  Clear(); // first remove existing data
-  buffer_ = grpc_byte_buffer_copy(buf.buffer_); // then copy
+  Clear();                                       // first remove existing data
+  buffer_ = grpc_byte_buffer_copy(buf.buffer_);  // then copy
   return *this;
 }
 
diff --git a/test/cpp/qps/client_async.cc b/test/cpp/qps/client_async.cc
index d822d78aac0..3e2317c6d46 100644
--- a/test/cpp/qps/client_async.cc
+++ b/test/cpp/qps/client_async.cc
@@ -93,8 +93,7 @@ class ClientRpcContextUnaryImpl : public ClientRpcContext {
       std::function<
           std::unique_ptr<grpc::ClientAsyncResponseReader<ResponseType>>(
               BenchmarkService::Stub*, grpc::ClientContext*, const RequestType&,
-              CompletionQueue*)>
-          start_req,
+              CompletionQueue*)> start_req,
       std::function<void(grpc::Status, ResponseType*)> on_done)
       : ClientRpcContext(channel_id),
         context_(),
@@ -140,8 +139,7 @@ class ClientRpcContextUnaryImpl : public ClientRpcContext {
   std::function<void(grpc::Status, ResponseType*)> callback_;
   std::function<std::unique_ptr<grpc::ClientAsyncResponseReader<ResponseType>>(
       BenchmarkService::Stub*, grpc::ClientContext*, const RequestType&,
-      CompletionQueue*)>
-      start_req_;
+      CompletionQueue*)> start_req_;
   grpc::Status status_;
   double start_;
   std::unique_ptr<grpc::ClientAsyncResponseReader<ResponseType>>
@@ -160,12 +158,11 @@ class AsyncClient : public ClientImpl<StubType, RequestType> {
   using Client::closed_loop_;
   using ClientImpl<StubType, RequestType>::channels_;
   using ClientImpl<StubType, RequestType>::request_;
-  AsyncClient(
-      const ClientConfig& config,
-      std::function<ClientRpcContext*(int, StubType*, const RequestType&)>
-          setup_ctx,
-      std::function<std::unique_ptr<StubType>(std::shared_ptr<Channel>)>
-          create_stub)
+  AsyncClient(const ClientConfig& config,
+              std::function<ClientRpcContext*(int, StubType*,
+                                              const RequestType&)> setup_ctx,
+              std::function<std::unique_ptr<StubType>(std::shared_ptr<Channel>)>
+                  create_stub)
       : ClientImpl<StubType, RequestType>(config, create_stub),
         channel_lock_(new std::mutex[config.client_channels()]),
         contexts_(config.client_channels()),
@@ -394,8 +391,7 @@ class ClientRpcContextStreamingImpl : public ClientRpcContext {
       std::function<std::unique_ptr<
           grpc::ClientAsyncReaderWriter<RequestType, ResponseType>>(
           BenchmarkService::Stub*, grpc::ClientContext*, CompletionQueue*,
-          void*)>
-          start_req,
+          void*)> start_req,
       std::function<void(grpc::Status, ResponseType*)> on_done)
       : ClientRpcContext(channel_id),
         context_(),
@@ -447,10 +443,10 @@ class ClientRpcContextStreamingImpl : public ClientRpcContext {
   ResponseType response_;
   bool (ClientRpcContextStreamingImpl::*next_state_)(bool, Histogram*);
   std::function<void(grpc::Status, ResponseType*)> callback_;
-  std::function<std::unique_ptr<
-      grpc::ClientAsyncReaderWriter<RequestType, ResponseType>>(
-      BenchmarkService::Stub*, grpc::ClientContext*, CompletionQueue*, void*)>
-      start_req_;
+  std::function<
+      std::unique_ptr<grpc::ClientAsyncReaderWriter<RequestType, ResponseType>>(
+          BenchmarkService::Stub*, grpc::ClientContext*, CompletionQueue*,
+          void*)> start_req_;
   grpc::Status status_;
   double start_;
   std::unique_ptr<grpc::ClientAsyncReaderWriter<RequestType, ResponseType>>
@@ -494,8 +490,7 @@ class ClientRpcContextGenericStreamingImpl : public ClientRpcContext {
       int channel_id, grpc::GenericStub* stub, const ByteBuffer& req,
       std::function<std::unique_ptr<grpc::GenericClientAsyncReaderWriter>(
           grpc::GenericStub*, grpc::ClientContext*,
-          const grpc::string& method_name, CompletionQueue*, void*)>
-          start_req,
+          const grpc::string& method_name, CompletionQueue*, void*)> start_req,
       std::function<void(grpc::Status, ByteBuffer*)> on_done)
       : ClientRpcContext(channel_id),
         context_(),
@@ -552,8 +547,7 @@ class ClientRpcContextGenericStreamingImpl : public ClientRpcContext {
   std::function<void(grpc::Status, ByteBuffer*)> callback_;
   std::function<std::unique_ptr<grpc::GenericClientAsyncReaderWriter>(
       grpc::GenericStub*, grpc::ClientContext*, const grpc::string&,
-      CompletionQueue*, void*)>
-      start_req_;
+      CompletionQueue*, void*)> start_req_;
   grpc::Status status_;
   double start_;
   std::unique_ptr<grpc::GenericClientAsyncReaderWriter> stream_;
diff --git a/test/cpp/qps/qps_driver.cc b/test/cpp/qps/qps_driver.cc
index 76d1595c4ba..c70db188d9c 100644
--- a/test/cpp/qps/qps_driver.cc
+++ b/test/cpp/qps/qps_driver.cc
@@ -113,7 +113,7 @@ static void QpsDriver() {
     }
   } else if (FLAGS_bbuf_resp_size >= 0) {
     auto params =
-      client_config.mutable_payload_config()->mutable_bytebuf_params();
+        client_config.mutable_payload_config()->mutable_bytebuf_params();
     params->set_resp_size(FLAGS_bbuf_resp_size);
     if (FLAGS_bbuf_req_size >= 0) {
       params->set_req_size(FLAGS_bbuf_req_size);
diff --git a/test/cpp/qps/server_async.cc b/test/cpp/qps/server_async.cc
index da7646eaf2c..1ae88d7323e 100644
--- a/test/cpp/qps/server_async.cc
+++ b/test/cpp/qps/server_async.cc
@@ -72,8 +72,7 @@ class AsyncQpsServerTest : public Server {
                          CompletionQueue *, ServerCompletionQueue *, void *)>
           request_streaming_function,
       std::function<grpc::Status(const PayloadConfig &, const RequestType *,
-                                 ResponseType *)>
-          process_rpc)
+                                 ResponseType *)> process_rpc)
       : Server(config) {
     char *server_address = NULL;
 
@@ -94,8 +93,8 @@ class AsyncQpsServerTest : public Server {
 
     using namespace std::placeholders;
 
-    auto process_rpc_bound = std::bind(process_rpc, config.payload_config(),
-                                       _1, _2);
+    auto process_rpc_bound =
+        std::bind(process_rpc, config.payload_config(), _1, _2);
 
     for (int i = 0; i < 10000 / config.async_server_threads(); i++) {
       for (int j = 0; j < config.async_server_threads(); j++) {
@@ -185,8 +184,7 @@ class AsyncQpsServerTest : public Server {
     ServerRpcContextUnaryImpl(
         std::function<void(ServerContextType *, RequestType *,
                            grpc::ServerAsyncResponseWriter<ResponseType> *,
-                           void *)>
-            request_method,
+                           void *)> request_method,
         std::function<grpc::Status(const RequestType *, ResponseType *)>
             invoke_method)
         : srv_ctx_(new ServerContextType),
@@ -359,8 +357,7 @@ static void RegisterGenericService(ServerBuilder *builder,
   builder->RegisterAsyncGenericService(service);
 }
 
-
-static Status ProcessSimpleRPC(const PayloadConfig&,
+static Status ProcessSimpleRPC(const PayloadConfig &,
                                const SimpleRequest *request,
                                SimpleResponse *response) {
   if (request->response_size() > 0) {
@@ -372,7 +369,7 @@ static Status ProcessSimpleRPC(const PayloadConfig&,
   return Status::OK;
 }
 
-static Status ProcessGenericRPC(const PayloadConfig& payload_config,
+static Status ProcessGenericRPC(const PayloadConfig &payload_config,
                                 const ByteBuffer *request,
                                 ByteBuffer *response) {
   int resp_size = payload_config.bytebuf_params().resp_size();
@@ -384,22 +381,19 @@ static Status ProcessGenericRPC(const PayloadConfig& payload_config,
 }
 
 std::unique_ptr<Server> CreateAsyncServer(const ServerConfig &config) {
-  return std::unique_ptr<Server>(
-      new AsyncQpsServerTest<SimpleRequest, SimpleResponse,
-                             BenchmarkService::AsyncService,
-                             grpc::ServerContext>(
-          config, RegisterBenchmarkService,
-          &BenchmarkService::AsyncService::RequestUnaryCall,
-          &BenchmarkService::AsyncService::RequestStreamingCall,
-          ProcessSimpleRPC));
+  return std::unique_ptr<Server>(new AsyncQpsServerTest<
+      SimpleRequest, SimpleResponse, BenchmarkService::AsyncService,
+      grpc::ServerContext>(
+      config, RegisterBenchmarkService,
+      &BenchmarkService::AsyncService::RequestUnaryCall,
+      &BenchmarkService::AsyncService::RequestStreamingCall, ProcessSimpleRPC));
 }
 std::unique_ptr<Server> CreateAsyncGenericServer(const ServerConfig &config) {
   return std::unique_ptr<Server>(
       new AsyncQpsServerTest<ByteBuffer, ByteBuffer, grpc::AsyncGenericService,
                              grpc::GenericServerContext>(
           config, RegisterGenericService, nullptr,
-          &grpc::AsyncGenericService::RequestCall,
-          ProcessGenericRPC));
+          &grpc::AsyncGenericService::RequestCall, ProcessGenericRPC));
 }
 
 }  // namespace testing