Current File : //opt/cpanel/ea-ruby27/src/passenger-release-6.0.23/test/cxx/IOTools/BufferedIOTest.cpp
#include <TestSupport.h>
#include <IOTools/BufferedIO.h>
#include <Utils/Timer.h>
#include <IOTools/IOUtils.h>
#include <algorithm>
using namespace Passenger;
using namespace std;
namespace tut {
struct IOTools_BufferedIOTest: public TestBase {
FileDescriptor reader, writer;
BufferedIO io;
string readData;
unsigned int counter;
char buf[100];
BufferedIO::AcceptFunction a_eof;
BufferedIO::AcceptFunction a_twoBytesRead;
IOTools_BufferedIOTest() {
Pipe p = createPipe(__FILE__, __LINE__);
reader = p.first;
writer = p.second;
io = BufferedIO(reader);
counter = 0;
memset(buf, 0, sizeof(buf));
a_eof = boost::bind(&IOTools_BufferedIOTest::eof, this, boost::placeholders::_1, boost::placeholders::_2);
a_twoBytesRead = boost::bind(&IOTools_BufferedIOTest::twoBytesRead, this, boost::placeholders::_1, boost::placeholders::_2);
}
void write(const StaticString &data) {
::write(writer, data.c_str(), data.size());
}
pair<unsigned int, bool> twoBytesRead(const char *data, unsigned int size) {
if (counter == 2) {
return make_pair(0, true);
} else {
unsigned int toRead = min(2u - counter, size);
readData.append(data, toRead);
counter += toRead;
return make_pair(toRead, counter == 2);
}
}
pair<unsigned int, bool> eof(const char *data, unsigned int size) {
readData.append(data, size);
return make_pair(size, false);
}
static void writeAfterSomeTime(int fd, int sleepTime, string data) {
syscalls::usleep(sleepTime);
writeExact(fd, data);
}
static void closeAfterSomeTime(FileDescriptor fd, int sleepTime) {
syscalls::usleep(sleepTime);
fd.close();
}
};
DEFINE_TEST_GROUP(IOTools_BufferedIOTest);
/***** Test readUntil() *****/
TEST_METHOD(1) {
// If the connection is already closed and the buffer is empty, then it returns 0.
writer.close();
ensure_equals(io.readUntil(a_eof), 0u);
ensure_equals(readData, "");
ensure_equals(io.getBuffer(), "");
}
TEST_METHOD(2) {
// If the connection is already closed and the buffer is non-empty,
// then it reads from the buffer.
writer.close();
io.unread("hello world");
ensure_equals(io.readUntil(a_twoBytesRead), 2u);
ensure_equals(readData, "he");
ensure_equals(io.readUntil(a_eof), 9u);
ensure_equals(readData, "hello world");
ensure_equals(io.getBuffer(), "");
}
TEST_METHOD(3) {
// If the buffer is empty then it reads from the connection.
write("hello world");
writer.close();
ensure_equals("(1)", io.readUntil(a_twoBytesRead), 2u);
ensure_equals("(2)", readData, "he");
ensure_equals("(5)", io.readUntil(a_eof), 9u);
ensure_equals("(6)", readData, "hello world");
ensure_equals("(7)", io.readUntil(a_eof), 0u);
ensure_equals("(8)", readData, "hello world");
ensure_equals(io.getBuffer(), "");
}
TEST_METHOD(4) {
// If the buffer is non-empty then it reads from the
// buffer first, then from the connection.
io.unread("hel");
write("lo world");
writer.close();
ensure_equals("(1)", io.readUntil(a_twoBytesRead), 2u);
ensure_equals("(2)", readData, "he");
counter = 0;
ensure_equals("(3)", io.readUntil(a_twoBytesRead), 2u);
ensure_equals("(4)", readData, "hell");
ensure_equals("(5)", io.readUntil(a_eof), 7u);
ensure_equals("(6)", readData, "hello world");
ensure_equals("(7)", io.readUntil(a_eof), 0u);
ensure_equals("(8)", readData, "hello world");
ensure_equals(io.getBuffer(), "");
}
TEST_METHOD(5) {
// It blocks until the acceptor function says it's done or until EOF.
TempThread thr1(boost::bind(writeAfterSomeTime, writer, 20000, "aa"));
Timer<> timer1;
ensure_equals(io.readUntil(a_twoBytesRead), 2u);
ensure_equals(readData, "aa");
ensure("At least 18 msec elapsed", timer1.elapsed() >= 18);
ensure("At most 90 msec elapsed", timer1.elapsed() <= 90);
TempThread thr2(boost::bind(closeAfterSomeTime, writer, 20000));
Timer<> timer2;
ensure_equals(io.readUntil(a_twoBytesRead), 0u);
ensure_equals(readData, "aa");
ensure("At least 18 msec elapsed", timer2.elapsed() >= 18);
ensure("At most 90 msec elapsed", timer2.elapsed() <= 90);
}
TEST_METHOD(6) {
// It throws TimeoutException if it cannot read enough data
// within the specified timeout.
unsigned long long timeout = 50000;
io.unread("he");
write("llo");
Timer<> timer;
try {
io.readUntil(a_eof, &timeout);
fail("TimeoutException expected");
} catch (const TimeoutException &) {
ensure("At least 45 msec elapsed", timer.elapsed() >= 45);
ensure("At most 90 msec elapsed", timer.elapsed() < 90);
ensure("It deducts the waited time from the timeout", timeout < 5000);
ensure_equals(readData, "hello");
ensure_equals(io.getBuffer(), "");
}
}
/***** Test read() *****/
TEST_METHOD(10) {
// If the connection is already closed and the buffer is empty, then it returns 0.
writer.close();
ensure_equals(io.read(buf, sizeof(buf)), 0u);
ensure_equals(io.getBuffer(), "");
}
TEST_METHOD(11) {
// If the connection is already closed and the buffer is non-empty
// and >= N bytes, then it reads everything from the buffer.
io.unread("hel");
write("lo world");
writer.close();
ensure_equals(io.read(buf, 5), 5u);
ensure_equals(StaticString(buf), "hello");
ensure_equals(io.getBuffer(), " world");
}
TEST_METHOD(12) {
// If the connection is already closed and the buffer is non-empty
// and < N bytes, then it reads N bytes from the buffer and the rest
// from the connection.
io.unread("hel");
write("lo world");
writer.close();
ensure_equals(io.read(buf, sizeof(buf)), 11u);
ensure_equals(StaticString(buf), "hello world");
ensure_equals(io.getBuffer(), "");
}
TEST_METHOD(13) {
// If the buffer is empty then it reads from the connection.
write("hello world");
ensure_equals(io.read(buf, 5), 5u);
ensure_equals(StaticString(buf), "hello");
ensure_equals(io.getBuffer(), " world");
}
TEST_METHOD(14) {
// If the buffer is non-empty then it reads from the
// buffer first, then from the connection.
write("hello world");
ensure_equals(io.read(buf, 2), 2u);
ensure_equals(StaticString(buf), "he");
ensure_equals(io.getBuffer(), "llo world");
ensure_equals(io.read(buf, 7), 7u);
ensure_equals(StaticString(buf), "llo wor");
ensure_equals(io.getBuffer(), "ld");
}
TEST_METHOD(15) {
// It blocks until the given number of bytes are read or until EOF.
TempThread thr1(boost::bind(writeAfterSomeTime, writer, 20000, "aa"));
Timer<> timer1;
ensure_equals(io.read(buf, 2), 2u);
ensure_equals(StaticString(buf), "aa");
ensure("At least 18 msec elapsed", timer1.elapsed() >= 18);
ensure("At most 90 msec elapsed", timer1.elapsed() <= 90);
TempThread thr2(boost::bind(closeAfterSomeTime, writer, 20000));
Timer<> timer2;
ensure_equals(io.read(buf, sizeof(buf)), 0u);
ensure_equals(StaticString(buf), "aa");
ensure("At least 18 msec elapsed", timer2.elapsed() >= 18);
ensure("At most 90 msec elapsed", timer2.elapsed() <= 90);
}
TEST_METHOD(16) {
// It throws TimeoutException if it cannot read enough data
// within the specified timeout.
unsigned long long timeout = 50000;
io.unread("he");
write("llo");
Timer<> timer;
try {
io.read(buf, sizeof(buf), &timeout);
fail("TimeoutException expected");
} catch (const TimeoutException &) {
ensure("At least 45 msec elapsed", timer.elapsed() >= 45);
ensure("At most 95 msec elapsed", timer.elapsed() < 95);
ensure("It deducts the waited time from the timeout", timeout < 5000);
ensure_equals(io.getBuffer(), "");
}
}
/***** Test readAll() *****/
TEST_METHOD(20) {
// It reads everything until EOF.
TempThread thr1(boost::bind(writeAfterSomeTime, writer, 20000, "aa"));
TempThread thr2(boost::bind(closeAfterSomeTime, writer, 40000));
Timer<> timer;
ensure_equals(io.readAll(), "aa");
ensure_equals(io.getBuffer(), "");
ensure("At least 38 msec elapsed", timer.elapsed() >= 38);
ensure("At most 150 msec elapsed", timer.elapsed() <= 150);
}
TEST_METHOD(21) {
// It throws TimeoutException if it cannot read enough data
// within the specified timeout.
unsigned long long timeout = 50000;
io.unread("he");
write("llo");
Timer<> timer;
try {
io.readAll(&timeout);
fail("TimeoutException expected");
} catch (const TimeoutException &) {
ensure("At least 45 msec elapsed", timer.elapsed() >= 45);
ensure("At most 95 msec elapsed", timer.elapsed() < 95);
ensure("It deducts the waited time from the timeout", timeout < 5000);
ensure_equals(io.getBuffer(), "");
}
}
/***** Test readLine() *****/
TEST_METHOD(25) {
// If the connection is already closed and the buffer is empty,
// then it returns the empty string.
writer.close();
ensure_equals(io.readLine(), "");
ensure_equals(io.getBuffer(), "");
}
TEST_METHOD(26) {
// If the connection is already closed and the buffer is non-empty,
// then it returns the first line in the buffer.
writer.close();
io.unread("hello\nworld\n.");
ensure_equals(io.readLine(), "hello\n");
ensure_equals(io.getBuffer(), "world\n.");
ensure_equals(io.readLine(), "world\n");
ensure_equals(io.getBuffer(), ".");
ensure_equals(io.readLine(), ".");
ensure_equals(io.getBuffer(), "");
}
TEST_METHOD(27) {
// If the buffer is empty then it reads from the connection.
write("hello\nworld\n.");
ensure_equals(io.readLine(), "hello\n");
ensure_equals(io.getBuffer(), "world\n.");
}
TEST_METHOD(28) {
// If the buffer is non-empty then it reads from the
// buffer first, then from the connection.
io.unread("hello");
write("\nworld\n.");
ensure_equals(io.readLine(), "hello\n");
ensure_equals(io.getBuffer(), "world\n.");
ensure_equals(io.readLine(), "world\n");
ensure_equals(io.getBuffer(), ".");
}
TEST_METHOD(29) {
// If the line is too long then it throws a SecurityException.
write("abcd");
try {
io.readLine(3);
fail("SecurityException expected");
} catch (const SecurityException &) {
// Pass.
}
}
TEST_METHOD(30) {
// It blocks until a line can be read or until EOF.
TempThread thr1(boost::bind(writeAfterSomeTime, writer, 20000, "hello"));
TempThread thr2(boost::bind(writeAfterSomeTime, writer, 35000, "\nworld\n."));
Timer<> timer1;
ensure_equals(io.readLine(), "hello\n");
ensure_equals(io.getBuffer(), "world\n.");
ensure("At least 33 msec elapsed", timer1.elapsed() >= 33);
ensure("At most 95 msec elapsed", timer1.elapsed() <= 90);
TempThread thr3(boost::bind(closeAfterSomeTime, writer, 20000));
Timer<> timer2;
ensure_equals(io.readLine(), "world\n");
ensure_equals(io.getBuffer(), ".");
ensure_equals(io.readLine(), ".");
ensure_equals(io.getBuffer(), "");
ensure("At least 18 msec elapsed", timer2.elapsed() >= 18);
ensure("At most 95 msec elapsed", timer2.elapsed() <= 95);
}
TEST_METHOD(31) {
// It throws TimeoutException if it cannot read enough data
// within the specified timeout.
unsigned long long timeout = 30000;
io.unread("he");
write("llo");
Timer<> timer;
try {
io.readLine(1024, &timeout);
fail("TimeoutException expected");
} catch (const TimeoutException &) {
ensure("At least 25 msec elapsed", timer.elapsed() >= 25);
ensure("At most 90 msec elapsed", timer.elapsed() < 90);
ensure("It deducts the waited time from the timeout", timeout < 5000);
ensure_equals(io.getBuffer(), "");
}
}
}
Mini Shell