Consistently have the namespace closing comment

[folly.git] / folly / io / async / test / MockAsyncTransport.h

diff --git a/folly/io/async/test/MockAsyncTransport.h b/folly/io/async/test/MockAsyncTransport.h
index 9202cd9ceea46836e9110cafada4634d8500b514..feaf0ee3cc76fe06eaf4e47a88d139b81de3521a 100644 (file)
--- a/folly/io/async/test/MockAsyncTransport.h
+++ b/folly/io/async/test/MockAsyncTransport.h
@@ -1,5 +1,5 @@
 /*
- * Copyright 2015 Facebook, Inc.
+ * Copyright 2017 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,10 +15,9 @@
  */
 #pragma once
 
-#include <gmock/gmock.h>
-
 #include <folly/Memory.h>
 #include <folly/io/async/AsyncTransport.h>
+#include <folly/portability/GMock.h>
 
 namespace folly { namespace test {
 
@@ -27,31 +26,15 @@ class MockAsyncTransport: public AsyncTransportWrapper {
   MOCK_METHOD1(setReadCB, void(ReadCallback*));
   MOCK_CONST_METHOD0(getReadCallback, ReadCallback*());
   MOCK_CONST_METHOD0(getReadCB, ReadCallback*());
-  MOCK_METHOD5(write, void(WriteCallback*,
-                           const void*, size_t,
-                           WriteFlags,
-                           BufferCallback*));
-  MOCK_METHOD5(writev, void(WriteCallback*,
-                            const iovec*, size_t,
-                            WriteFlags,
-                            BufferCallback*));
-  MOCK_METHOD4(writeChain,
-               void(WriteCallback*,
-                    std::shared_ptr<folly::IOBuf>,
-                    WriteFlags,
-                    BufferCallback*));
-
+  MOCK_METHOD4(write, void(WriteCallback*, const void*, size_t, WriteFlags));
+  MOCK_METHOD4(writev, void(WriteCallback*, const iovec*, size_t, WriteFlags));
+  MOCK_METHOD3(writeChain,
+               void(WriteCallback*, std::shared_ptr<folly::IOBuf>, WriteFlags));
 
   void writeChain(WriteCallback* callback,
                   std::unique_ptr<folly::IOBuf>&& iob,
-                  WriteFlags flags =
-                  WriteFlags::NONE,
-                  BufferCallback* bufCB = nullptr) override {
-    writeChain(
-        callback,
-        std::shared_ptr<folly::IOBuf>(iob.release()),
-        flags,
-        bufCB);
+                  WriteFlags flags = WriteFlags::NONE) override {
+    writeChain(callback, std::shared_ptr<folly::IOBuf>(iob.release()), flags);
   }
 
   MOCK_METHOD0(close, void());
@@ -77,7 +60,15 @@ class MockAsyncTransport: public AsyncTransportWrapper {
   MOCK_CONST_METHOD0(getRawBytesReceived, size_t());
   MOCK_CONST_METHOD0(isEorTrackingEnabled, bool());
   MOCK_METHOD1(setEorTracking, void(bool));
+  MOCK_CONST_METHOD0(getWrappedTransport, AsyncTransportWrapper*());
+  MOCK_CONST_METHOD0(isReplaySafe, bool());
+  MOCK_METHOD1(setReplaySafetyCallback,
+               void(AsyncTransport::ReplaySafetyCallback*));
+};
 
+class MockReplaySafetyCallback : public AsyncTransport::ReplaySafetyCallback {
+ public:
+  GMOCK_METHOD0_(, noexcept, , onReplaySafe, void());
 };
 
 class MockReadCallback: public AsyncTransportWrapper::ReadCallback {
@@ -86,15 +77,15 @@ class MockReadCallback: public AsyncTransportWrapper::ReadCallback {
   GMOCK_METHOD1_(, noexcept, , readDataAvailable, void(size_t));
   GMOCK_METHOD0_(, noexcept, , isBufferMovable, bool());
   GMOCK_METHOD1_(, noexcept, ,
-      readBufferAvailableInternal, void(std::shared_ptr<folly::IOBuf>));
+      readBufferAvailableInternal,
+      void(std::unique_ptr<folly::IOBuf>&));
   GMOCK_METHOD0_(, noexcept, , readEOF, void());
   GMOCK_METHOD1_(, noexcept, , readErr,
                  void(const AsyncSocketException&));
 
   void readBufferAvailable(std::unique_ptr<folly::IOBuf> readBuf)
     noexcept override {
-    readBufferAvailableInternal(
-        folly::to_shared_ptr(std::move(readBuf)));
+    readBufferAvailableInternal(readBuf);
   }
 };
 
@@ -105,4 +96,5 @@ class MockWriteCallback: public AsyncTransportWrapper::WriteCallback {
                  void(size_t, const AsyncSocketException&));
 };
 
-}}
+} // namespace test
+} // namespace folly