2 * Copyright 2014-present Facebook, Inc.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 #include <folly/Memory.h>
18 #include <folly/io/async/AsyncPipe.h>
19 #include <folly/io/async/EventBase.h>
20 #include <folly/portability/GTest.h>
24 using namespace testing;
28 class TestReadCallback : public folly::AsyncReader::ReadCallback {
30 bool isBufferMovable() noexcept override {
33 void setMovable(bool movable) {
37 void readBufferAvailable(
38 std::unique_ptr<folly::IOBuf> readBuf) noexcept override {
39 readBuffer_.append(std::move(readBuf));
42 void readDataAvailable(size_t len) noexcept override {
43 readBuffer_.postallocate(len);
46 void getReadBuffer(void** bufReturn, size_t* lenReturn) noexcept override {
47 auto res = readBuffer_.preallocate(4000, 65000);
48 *bufReturn = res.first;
49 *lenReturn = res.second;
52 void readEOF() noexcept override {}
54 void readErr(const folly::AsyncSocketException&) noexcept override {
58 std::string getData() {
59 auto buf = readBuffer_.move();
61 return std::string((char *)buf->data(), buf->length());
70 folly::IOBufQueue readBuffer_{folly::IOBufQueue::cacheChainLength()};
75 class TestWriteCallback : public folly::AsyncWriter::WriteCallback {
77 void writeSuccess() noexcept override { writes_++; }
79 void writeErr(size_t, const folly::AsyncSocketException&) noexcept override {
92 class AsyncPipeTest: public Test {
94 void reset(bool movable) {
96 readCallback_.reset();
98 writeCallback_.reset();
100 int rc = pipe(pipeFds_);
103 EXPECT_EQ(::fcntl(pipeFds_[0], F_SETFL, O_NONBLOCK), 0);
104 EXPECT_EQ(::fcntl(pipeFds_[1], F_SETFL, O_NONBLOCK), 0);
105 reader_ = folly::AsyncPipeReader::newReader(
106 &eventBase_, pipeFds_[0]);
107 writer_ = folly::AsyncPipeWriter::newWriter(
108 &eventBase_, pipeFds_[1]);
110 readCallback_.setMovable(movable);
114 folly::EventBase eventBase_;
116 folly::AsyncPipeReader::UniquePtr reader_;
117 folly::AsyncPipeWriter::UniquePtr writer_;
118 TestReadCallback readCallback_;
119 TestWriteCallback writeCallback_;
122 std::unique_ptr<folly::IOBuf> getBuf(const std::string& data) {
123 auto buf = folly::IOBuf::copyBuffer(data.c_str(), data.length());
129 TEST_F(AsyncPipeTest, simple) {
130 for (int pass = 0; pass < 2; ++pass) {
131 reset(pass % 2 != 0);
132 reader_->setReadCB(&readCallback_);
133 writer_->write(getBuf("hello"), &writeCallback_);
134 writer_->closeOnEmpty();
136 EXPECT_EQ(readCallback_.getData(), "hello");
137 EXPECT_FALSE(readCallback_.error_);
138 EXPECT_EQ(writeCallback_.writes_, 1);
139 EXPECT_FALSE(writeCallback_.error_);
143 TEST_F(AsyncPipeTest, blocked_writes) {
144 for (int pass = 0; pass < 2; ++pass) {
145 reset(pass % 2 != 0);
146 uint32_t writeAttempts = 0;
149 writer_->write(getBuf("hello"), &writeCallback_);
150 } while (writeCallback_.writes_ == writeAttempts);
151 // there is one blocked write
152 writer_->closeOnEmpty();
154 reader_->setReadCB(&readCallback_);
157 std::string expected;
158 for (uint32_t i = 0; i < writeAttempts; i++) {
161 EXPECT_EQ(readCallback_.getData(), expected);
162 EXPECT_FALSE(readCallback_.error_);
163 EXPECT_EQ(writeCallback_.writes_, writeAttempts);
164 EXPECT_FALSE(writeCallback_.error_);
168 TEST_F(AsyncPipeTest, writeOnClose) {
169 for (int pass = 0; pass < 2; ++pass) {
170 reset(pass % 2 != 0);
171 reader_->setReadCB(&readCallback_);
172 writer_->write(getBuf("hello"), &writeCallback_);
173 writer_->closeOnEmpty();
174 writer_->write(getBuf("hello"), &writeCallback_);
176 EXPECT_EQ(readCallback_.getData(), "hello");
177 EXPECT_FALSE(readCallback_.error_);
178 EXPECT_EQ(writeCallback_.writes_, 1);
179 EXPECT_TRUE(writeCallback_.error_);