projects / folly.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fix RequestContext held too long issue in EventBase
[folly.git] / folly / io / async / test / AsyncSSLSocketWriteTest.cpp
diff --git a/folly/io/async/test/AsyncSSLSocketWriteTest.cpp b/folly/io/async/test/AsyncSSLSocketWriteTest.cpp
index 4497e65ffa22f1f29db69ae0be4b7e686c59ce4e..3cea20d83dde8fa924915642fbdf3f230506b097 100644 (file)
--- a/folly/io/async/test/AsyncSSLSocketWriteTest.cpp
+++ b/folly/io/async/test/AsyncSSLSocketWriteTest.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016 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.
@@ -13,14 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <folly/Foreach.h>
 #include <folly/io/Cursor.h>
 #include <folly/io/async/AsyncSSLSocket.h>
 #include <folly/io/async/AsyncSocket.h>
 #include <folly/io/async/EventBase.h>
+#include <folly/portability/GMock.h>
+#include <folly/portability/GTest.h>
 
-#include <gtest/gtest.h>
-#include <gmock/gmock.h>
 #include <string>
 #include <vector>
 
@@ -58,8 +57,12 @@ class MockAsyncSSLSocket : public AsyncSSLSocket{
   MOCK_CONST_METHOD0(getRawBytesWritten, size_t());
 
   // public wrapper for protected interface
-  ssize_t testPerformWrite(const iovec* vec, uint32_t count, WriteFlags flags,
-                           uint32_t* countWritten, uint32_t* partialWritten) {
+  WriteResult testPerformWrite(
+      const iovec* vec,
+      uint32_t count,
+      WriteFlags flags,
+      uint32_t* countWritten,
+      uint32_t* partialWritten) {
     return performWrite(vec, count, flags, countWritten, partialWritten);
   }
 
@@ -121,8 +124,8 @@ TEST_F(AsyncSSLSocketWriteTest, write_coalescing1) {
   int n = 3;
   auto vec = makeVec({3, 3, 3});
   EXPECT_CALL(*(sock_.get()), sslWriteImpl(_, _, 9))
-    .WillOnce(Invoke([this] (SSL *, const void *buf, int n) {
-          verifyVec(buf, n, 0);
+    .WillOnce(Invoke([this] (SSL *, const void *buf, int m) {
+          verifyVec(buf, m, 0);
           return 9; }));
   uint32_t countWritten = 0;
   uint32_t partialWritten = 0;
@@ -138,15 +141,15 @@ TEST_F(AsyncSSLSocketWriteTest, write_coalescing2) {
   auto vec = makeVec({1500, 3, 3});
   int pos = 0;
   EXPECT_CALL(*(sock_.get()), sslWriteImpl(_, _, 1500))
-    .WillOnce(Invoke([this, &pos] (SSL *, const void *buf, int n) {
-          verifyVec(buf, n, pos);
-          pos += n;
-          return n; }));
+    .WillOnce(Invoke([this, &pos] (SSL *, const void *buf, int m) {
+          verifyVec(buf, m, pos);
+          pos += m;
+          return m; }));
   EXPECT_CALL(*(sock_.get()), sslWriteImpl(_, _, 6))
-    .WillOnce(Invoke([this, &pos] (SSL *, const void *buf, int n) {
-          verifyVec(buf, n, pos);
-          pos += n;
-          return n; }));
+    .WillOnce(Invoke([this, &pos] (SSL *, const void *buf, int m) {
+          verifyVec(buf, m, pos);
+          pos += m;
+          return m; }));
   uint32_t countWritten = 0;
   uint32_t partialWritten = 0;
   sock_->testPerformWrite(vec.get(), n, WriteFlags::NONE, &countWritten,
@@ -162,10 +165,10 @@ TEST_F(AsyncSSLSocketWriteTest, write_coalescing3) {
   int pos = 0;
   EXPECT_CALL(*(sock_.get()), sslWriteImpl(_, _, 1500))
     .Times(2)
-    .WillRepeatedly(Invoke([this, &pos] (SSL *, const void *buf, int n) {
-          verifyVec(buf, n, pos);
-          pos += n;
-          return n; }));
+    .WillRepeatedly(Invoke([this, &pos] (SSL *, const void *buf, int m) {
+          verifyVec(buf, m, pos);
+          pos += m;
+          return m; }));
   uint32_t countWritten = 0;
   uint32_t partialWritten = 0;
   sock_->testPerformWrite(vec.get(), n, WriteFlags::NONE, &countWritten,
@@ -180,8 +183,8 @@ TEST_F(AsyncSSLSocketWriteTest, write_coalescing4) {
   auto vec = makeVec({300, 300, 300, 300, 300});
   int pos = 0;
   EXPECT_CALL(*(sock_.get()), sslWriteImpl(_, _, 1500))
-    .WillOnce(Invoke([this, &pos] (SSL *, const void *buf, int n) {
-          verifyVec(buf, n, pos);
+    .WillOnce(Invoke([this, &pos] (SSL *, const void *buf, int m) {
+          verifyVec(buf, m, pos);
           pos += 1000;
           return 1000; /* 500 bytes "pending" */ }));
   uint32_t countWritten = 0;
@@ -192,9 +195,9 @@ TEST_F(AsyncSSLSocketWriteTest, write_coalescing4) {
   EXPECT_EQ(partialWritten, 100);
   consumeVec(vec.get(), countWritten, partialWritten);
   EXPECT_CALL(*(sock_.get()), sslWriteImpl(_, _, 500))
-    .WillOnce(Invoke([this, &pos] (SSL *, const void *buf, int n) {
-          verifyVec(buf, n, pos);
-          pos += n;
+    .WillOnce(Invoke([this, &pos] (SSL *, const void *buf, int m) {
+          verifyVec(buf, m, pos);
+          pos += m;
           return 500; }));
   sock_->testPerformWrite(vec.get() + countWritten, n - countWritten,
                           WriteFlags::NONE,
@@ -209,15 +212,15 @@ TEST_F(AsyncSSLSocketWriteTest, write_coalescing5) {
   auto vec = makeVec({1000, 500, 500});
   int pos = 0;
   EXPECT_CALL(*(sock_.get()), sslWriteImpl(_, _, 1500))
-    .WillOnce(Invoke([this, &pos] (SSL *, const void *buf, int n) {
-          verifyVec(buf, n, pos);
-          pos += n;
-          return n; }));
+    .WillOnce(Invoke([this, &pos] (SSL *, const void *buf, int m) {
+          verifyVec(buf, m, pos);
+          pos += m;
+          return m; }));
   EXPECT_CALL(*(sock_.get()), sslWriteImpl(_, _, 500))
-    .WillOnce(Invoke([this, &pos] (SSL *, const void *buf, int n) {
-          verifyVec(buf, n, pos);
-          pos += n;
-          return n; }));
+    .WillOnce(Invoke([this, &pos] (SSL *, const void *buf, int m) {
+          verifyVec(buf, m, pos);
+          pos += m;
+          return m; }));
   uint32_t countWritten = 0;
   uint32_t partialWritten = 0;
   sock_->testPerformWrite(vec.get(), n, WriteFlags::NONE, &countWritten,
@@ -232,8 +235,8 @@ TEST_F(AsyncSSLSocketWriteTest, write_coalescing6) {
   auto vec = makeVec({1000, 500});
   int pos = 0;
   EXPECT_CALL(*(sock_.get()), sslWriteImpl(_, _, 1500))
-    .WillOnce(Invoke([this, &pos] (SSL *, const void *buf, int n) {
-          verifyVec(buf, n, pos);
+    .WillOnce(Invoke([this, &pos] (SSL *, const void *buf, int m) {
+          verifyVec(buf, m, pos);
           pos += 700;
           return 700; }));
   uint32_t countWritten = 0;
@@ -244,10 +247,10 @@ TEST_F(AsyncSSLSocketWriteTest, write_coalescing6) {
   EXPECT_EQ(partialWritten, 700);
   consumeVec(vec.get(), countWritten, partialWritten);
   EXPECT_CALL(*(sock_.get()), sslWriteImpl(_, _, 800))
-    .WillOnce(Invoke([this, &pos] (SSL *, const void *buf, int n) {
-          verifyVec(buf, n, pos);
-          pos += n;
-          return n; }));
+    .WillOnce(Invoke([this, &pos] (SSL *, const void *buf, int m) {
+          verifyVec(buf, m, pos);
+          pos += m;
+          return m; }));
   sock_->testPerformWrite(vec.get() + countWritten, n - countWritten,
                           WriteFlags::NONE,
                           &countWritten, &partialWritten);
@@ -269,25 +272,25 @@ TEST_F(AsyncSSLSocketWriteTest, write_with_eor1) {
   EXPECT_TRUE(sock_->isEorTrackingEnabled());
 
   EXPECT_CALL(*(sock_.get()), getRawBytesWritten())
-    // rawBytesWritten after writting initAppBytesWritten + 1500
-    // + some random SSL overhead
-    .WillOnce(Return(3600))
-    // rawBytesWritten after writting last 6 bytes
-    // + some random SSL overhead
-    .WillOnce(Return(3728));
+      // rawBytesWritten after writting initAppBytesWritten + 1500
+      // + some random SSL overhead
+      .WillOnce(Return(3600u))
+      // rawBytesWritten after writting last 6 bytes
+      // + some random SSL overhead
+      .WillOnce(Return(3728u));
   EXPECT_CALL(*(sock_.get()), sslWriteImpl(_, _, 1500))
-    .WillOnce(Invoke([=, &pos] (SSL *, const void *buf, int n) {
+    .WillOnce(Invoke([=, &pos] (SSL *, const void *buf, int m) {
           // the first 1500 does not have the EOR byte
           sock_->checkEor(0, 0);
-          verifyVec(buf, n, pos);
-          pos += n;
-          return n; }));
+          verifyVec(buf, m, pos);
+          pos += m;
+          return m; }));
   EXPECT_CALL(*(sock_.get()), sslWriteImpl(_, _, 6))
-    .WillOnce(Invoke([=, &pos] (SSL *, const void *buf, int n) {
-          sock_->checkEor(appEor, 3600 + n);
-          verifyVec(buf, n, pos);
-          pos += n;
-          return n; }));
+    .WillOnce(Invoke([=, &pos] (SSL *, const void *buf, int m) {
+          sock_->checkEor(appEor, 3600 + m);
+          verifyVec(buf, m, pos);
+          pos += m;
+          return m; }));
 
   uint32_t countWritten = 0;
   uint32_t partialWritten = 0;
@@ -318,18 +321,18 @@ TEST_F(AsyncSSLSocketWriteTest, write_with_eor2) {
     // + some random SSL overhead
     .WillOnce(Return(4100));
   EXPECT_CALL(*(sock_.get()), sslWriteImpl(_, _, 1500))
-    .WillOnce(Invoke([=, &pos] (SSL *, const void *buf, int n) {
+    .WillOnce(Invoke([=, &pos] (SSL *, const void *buf, int m) {
           // the first 1500 does not have the EOR byte
           sock_->checkEor(0, 0);
-          verifyVec(buf, n, pos);
-          pos += n;
-          return n; }));
+          verifyVec(buf, m, pos);
+          pos += m;
+          return m; }));
   EXPECT_CALL(*(sock_.get()), sslWriteImpl(_, _, 300))
-    .WillOnce(Invoke([=, &pos] (SSL *, const void *buf, int n) {
-          sock_->checkEor(appEor, 3600 + n);
-          verifyVec(buf, n, pos);
-          pos += n;
-          return n; }));
+    .WillOnce(Invoke([=, &pos] (SSL *, const void *buf, int m) {
+          sock_->checkEor(appEor, 3600 + m);
+          verifyVec(buf, m, pos);
+          pos += m;
+          return m; }));
 
   uint32_t countWritten = 0;
   uint32_t partialWritten = 0;
@@ -347,8 +350,8 @@ TEST_F(AsyncSSLSocketWriteTest, write_with_eor3) {
   int n = 1;
   auto vec = makeVec({1600});
   int pos = 0;
-  const size_t initAppBytesWritten = 500;
-  const size_t appEor = initAppBytesWritten + 1600;
+  static constexpr size_t initAppBytesWritten = 500;
+  static constexpr size_t appEor = initAppBytesWritten + 1600;
 
   sock_->setAppBytesWritten(initAppBytesWritten);
   sock_->setEorTracking(true);
@@ -361,9 +364,9 @@ TEST_F(AsyncSSLSocketWriteTest, write_with_eor3) {
     // + some random SSL overhead
     .WillOnce(Return(3100));
   EXPECT_CALL(*(sock_.get()), sslWriteImpl(_, _, 1600))
-    .WillOnce(Invoke([this, &pos] (SSL *, const void *buf, int n) {
-          sock_->checkEor(appEor, 2000 + n);
-          verifyVec(buf, n, pos);
+    .WillOnce(Invoke([this, &pos] (SSL *, const void *buf, int m) {
+          sock_->checkEor(appEor, 2000 + m);
+          verifyVec(buf, m, pos);
           pos += 1000;
           return 1000; }));
 
@@ -380,11 +383,11 @@ TEST_F(AsyncSSLSocketWriteTest, write_with_eor3) {
     .WillOnce(Return(3100))
     .WillOnce(Return(3800));
   EXPECT_CALL(*(sock_.get()), sslWriteImpl(_, _, 600))
-    .WillOnce(Invoke([this, &pos] (SSL *, const void *buf, int n) {
-          sock_->checkEor(appEor, 3100 + n);
-          verifyVec(buf, n, pos);
-          pos += n;
-          return n; }));
+    .WillOnce(Invoke([this, &pos] (SSL *, const void *buf, int m) {
+          sock_->checkEor(appEor, 3100 + m);
+          verifyVec(buf, m, pos);
+          pos += m;
+          return m; }));
   sock_->testPerformWrite(vec.get() + countWritten, n - countWritten,
                           WriteFlags::EOR,
                           &countWritten, &partialWritten);
@@ -393,4 +396,4 @@ TEST_F(AsyncSSLSocketWriteTest, write_with_eor3) {
   sock_->checkEor(0, 0);
 }
 
-}
+} // namespace folly
Unnamed repository; edit this file 'description' to name the repository.