D7net
Home
Console
Upload
information
Create File
Create Folder
About
Tools
:
/
proc
/
self
/
root
/
opt
/
cpanel
/
ea-ruby27
/
src
/
passenger-release-6.0.23
/
test
/
cxx
/
IOTools
/
Filename :
IOUtilsTest.cpp
back
Copy
#include <TestSupport.h> #include <IOTools/IOUtils.h> #include <SystemTools/SystemTime.h> #include <oxt/system_calls.hpp> #include <boost/bind/bind.hpp> #include <sys/types.h> #include <cerrno> #include <string> using namespace Passenger; using namespace std; using namespace boost; using namespace oxt; namespace tut { static ssize_t writevResult; static int writevErrno; static int writevCalled; static string writevData; static ssize_t writev_mock(int fildes, const struct iovec *iov, int iovcnt) { if (writevResult >= 0) { string data; for (int i = 0; i < iovcnt && data.size() < (size_t) writevResult; i++) { data.append( (const char *) iov[i].iov_base, iov[i].iov_len); } data.resize(writevResult); writevData.append(data); } writevCalled++; errno = writevErrno; return writevResult; } struct IOTools_IOUtilsTest: public TestBase { string restBuffer; IOTools_IOUtilsTest() { writevResult = 0; writevErrno = 0; writevCalled = 0; writevData.clear(); setWritevFunction(writev_mock); } ~IOTools_IOUtilsTest() { setWritevFunction(NULL); } Pipe createNonBlockingPipe() { Pipe p = createPipe(__FILE__, __LINE__); setNonBlocking(p.second); return p; } static void writeDataAfterSomeTime(int fd, unsigned int sleepTimeInUsec) { try { syscalls::usleep(sleepTimeInUsec); syscalls::write(fd, "hi", 2); } catch (const boost::thread_interrupted &) { // Do nothing. } } static void writeDataSlowly(int fd, unsigned int bytesToWrite, unsigned int bytesPerSec) { try { for (unsigned i = 0; i < bytesToWrite && !boost::this_thread::interruption_requested(); i++) { syscalls::write(fd, "x", 1); syscalls::usleep(1000000 / bytesPerSec); } } catch (const boost::thread_interrupted &) { // Do nothing. } } static void readDataAfterSomeTime(int fd, unsigned int sleepTimeInUsec) { try { char buf[1024 * 8]; syscalls::usleep(sleepTimeInUsec); syscalls::read(fd, buf, sizeof(buf)); } catch (const boost::thread_interrupted &) { // Do nothing. } } static void readDataSlowly(int fd, int bytesToRead, int bytesPerSec) { try { unsigned long long start = SystemTime::getUsec(); unsigned long long deadline = start + (bytesToRead * 1000000.0 / bytesPerSec); int alreadyRead = 0; while (alreadyRead < bytesToRead && !boost::this_thread::interruption_requested()) { unsigned long long elapsed = SystemTime::getUsec(); double progress = (elapsed - start) / (double) (deadline - start); int shouldHaveRead = progress * bytesToRead; int shouldNowRead = shouldHaveRead - alreadyRead; if (shouldNowRead > 0) { char *buf = new char[shouldNowRead]; ssize_t ret = syscalls::read(fd, buf, shouldNowRead); int e = errno; delete[] buf; if (ret == -1) { throw SystemException("read error", e); } else if (ret == 0) { break; } alreadyRead += ret; } syscalls::usleep(1000); } } catch (const boost::thread_interrupted &) { // Do nothing. } } }; DEFINE_TEST_GROUP_WITH_LIMIT(IOTools_IOUtilsTest, 100); /***** Test gatheredWrite() with empty input rest buffer *****/ TEST_METHOD(1) { // Test complete write of a single data buffer. StaticString data = "hello world"; writevResult = data.size(); ensure_equals(gatheredWrite(0, &data, 1, restBuffer), writevResult); ensure_equals(writevData, "hello world"); ensure(restBuffer.empty()); } TEST_METHOD(2) { // Test complete write of multiple data buffers. StaticString data[] = { "hello ", "world", "!!!!!!" }; writevResult = strlen("hello world!!!!!!"); ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult); ensure_equals(writevData, "hello world!!!!!!"); ensure(restBuffer.empty()); } TEST_METHOD(3) { // Test partial write of a single data buffer. StaticString data = "hello world"; writevResult = 3; ensure_equals(gatheredWrite(0, &data, 1, restBuffer), writevResult); ensure_equals(writevData, "hel"); ensure_equals(restBuffer, "lo world"); } TEST_METHOD(4) { // Test partial write of multiple data buffers: // first buffer is partially written. StaticString data[] = { "hello ", "world", "!!!!!!" }; writevResult = 2; ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult); ensure_equals(writevData, "he"); ensure_equals(restBuffer, "llo world!!!!!!"); } TEST_METHOD(5) { // Test partial write of multiple data buffers: // first buffer is completely written. StaticString data[] = { "hello ", "world", "!!!!!!" }; writevResult = 6; ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult); ensure_equals(writevData, "hello "); ensure_equals(restBuffer, "world!!!!!!"); } TEST_METHOD(6) { // Test partial write of multiple data buffers: // non-first buffer is partially written. StaticString data[] = { "hello ", "world", "!!!!!!" }; writevResult = 8; ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult); ensure_equals(writevData, "hello wo"); ensure_equals(restBuffer, "rld!!!!!!"); } TEST_METHOD(7) { // Test partial write of multiple data buffers: // non-first buffer is completely written. StaticString data[] = { "hello ", "world", "!!!!!!" }; writevResult = 11; ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult); ensure_equals(writevData, "hello world"); ensure_equals(restBuffer, "!!!!!!"); } TEST_METHOD(8) { // Test failed write of a single data buffer: blocking error. StaticString data = "hello world"; writevResult = -1; writevErrno = EAGAIN; ensure_equals(gatheredWrite(0, &data, 1, restBuffer), 0); ensure_equals(restBuffer, "hello world"); } TEST_METHOD(9) { // Test failed write of a single data buffer: other error. StaticString data = "hello world"; writevResult = -1; writevErrno = EBADF; ssize_t ret = gatheredWrite(0, &data, 1, restBuffer); int e = errno; ensure_equals(ret, -1); ensure_equals(e, EBADF); ensure_equals("Rest buffer remains untouched", restBuffer, ""); } TEST_METHOD(10) { // Test failed write of multiple data buffers: blocking error. StaticString data[] = { "hello ", "world", "!!!" }; writevResult = -1; writevErrno = EAGAIN; ensure_equals(gatheredWrite(0, data, 3, restBuffer), 0); ensure_equals(restBuffer, "hello world!!!"); } TEST_METHOD(11) { // Test failed write of multiple data buffers: other error. StaticString data[] = { "hello ", "world", "!!!" }; writevResult = -1; writevErrno = EBADF; ssize_t ret = gatheredWrite(0, data, 3, restBuffer); int e = errno; ensure_equals(ret, -1); ensure_equals(e, EBADF); ensure_equals("Rest buffer remains untouched", restBuffer, ""); } TEST_METHOD(12) { // Test writing nothing. StaticString data[] = { "", "", "" }; ssize_t ret = gatheredWrite(0, data, 3, restBuffer); int e = errno; ensure_equals(ret, 0); ensure_equals(e, 0); ensure_equals(writevCalled, 0); ensure_equals(restBuffer, ""); } TEST_METHOD(13) { // Test writing multiple buffers where some are empty. StaticString data[] = { "hello ", "", "world" }; writevResult = strlen("hello world"); ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult); ensure_equals(writevData, "hello world"); ensure_equals(restBuffer, ""); } /***** Test gatheredWrite() with non-empty input rest buffer *****/ TEST_METHOD(15) { // Test complete write with a single data buffer. restBuffer = "oh "; StaticString data = "hello world"; writevResult = restBuffer.size() + data.size(); ensure_equals(gatheredWrite(0, &data, 1, restBuffer), writevResult); ensure_equals(writevData, "oh hello world"); ensure(restBuffer.empty()); } TEST_METHOD(16) { // Test complete write with multiple data buffers. restBuffer = "oh "; StaticString data[] = { "hello ", "world", "!!!" }; writevResult = strlen("oh hello world!!!"); ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult); ensure_equals(writevData, "oh hello world!!!"); ensure(restBuffer.empty()); } TEST_METHOD(17) { // Test partial write of a single data buffer. StaticString data = "hello world"; writevResult = 3; ensure_equals(gatheredWrite(0, &data, 1, restBuffer), writevResult); ensure_equals(writevData, "hel"); ensure_equals(restBuffer, "lo world"); } TEST_METHOD(18) { // Test partial write of multiple data buffers: // rest buffer is partially written. restBuffer = "oh "; StaticString data[] = { "hello ", "world", "!!!" }; writevResult = 2; ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult); ensure_equals(writevData, "oh"); ensure_equals(restBuffer, " hello world!!!"); } TEST_METHOD(19) { // Test partial write of multiple data buffers: // rest buffer is completely written. restBuffer = "oh "; StaticString data[] = { "hello ", "world", "!!!" }; writevResult = strlen("oh "); ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult); ensure_equals(writevData, "oh "); ensure_equals(restBuffer, "hello world!!!"); } TEST_METHOD(20) { // Test partial write of multiple data buffers: // first buffer is partially written. restBuffer = "oh "; StaticString data[] = { "hello ", "world", "!!!" }; writevResult = strlen("oh h"); ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult); ensure_equals(writevData, "oh h"); ensure_equals(restBuffer, "ello world!!!"); } TEST_METHOD(21) { // Test partial write of multiple data buffers: // first buffer is completely written. restBuffer = "oh "; StaticString data[] = { "hello ", "world", "!!!" }; writevResult = strlen("oh hello "); ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult); ensure_equals(writevData, "oh hello "); ensure_equals(restBuffer, "world!!!"); } TEST_METHOD(22) { // Test partial write of multiple data buffers: // non-first buffer is partially written. restBuffer = "oh "; StaticString data[] = { "hello ", "world", "!!!" }; writevResult = strlen("oh hello wo"); ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult); ensure_equals(writevData, "oh hello wo"); ensure_equals(restBuffer, "rld!!!"); } TEST_METHOD(23) { // Test partial write of multiple data buffers: // non-first buffer is completely written. restBuffer = "oh "; StaticString data[] = { "hello ", "world", "!!!" }; writevResult = strlen("oh hello world"); ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult); ensure_equals(writevData, "oh hello world"); ensure_equals(restBuffer, "!!!"); } TEST_METHOD(24) { // Test failed write of a single data buffer: blocking error. restBuffer = "oh "; StaticString data = "hello world"; writevResult = -1; writevErrno = EAGAIN; ensure_equals(gatheredWrite(0, &data, 1, restBuffer), 0); ensure_equals(restBuffer, "oh hello world"); } TEST_METHOD(25) { // Test failed write of a single data buffer: other error. restBuffer = "oh "; StaticString data = "hello world"; writevResult = -1; writevErrno = EBADF; ssize_t ret = gatheredWrite(0, &data, 1, restBuffer); int e = errno; ensure_equals(ret, -1); ensure_equals(e, EBADF); ensure_equals("Rest buffer remains untouched", restBuffer, "oh "); } TEST_METHOD(26) { // Test failed write of multiple data buffers: blocking error. restBuffer = "oh "; StaticString data[] = { "hello ", "world", "!!!" }; writevResult = -1; writevErrno = EAGAIN; ensure_equals(gatheredWrite(0, data, 3, restBuffer), 0); ensure_equals(restBuffer, "oh hello world!!!"); } TEST_METHOD(27) { // Test failed write of multiple data buffers: other error. restBuffer = "oh "; StaticString data[] = { "hello ", "world", "!!!" }; writevResult = -1; writevErrno = EBADF; ssize_t ret = gatheredWrite(0, data, 3, restBuffer); int e = errno; ensure_equals(ret, -1); ensure_equals(e, EBADF); ensure_equals("Rest buffer remains untouched", restBuffer, "oh "); } TEST_METHOD(28) { // Test writing multiple buffers that are all empty. restBuffer = "oh "; StaticString data[] = { "", "", "" }; writevResult = 3; ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult); ensure_equals(writevData, "oh "); ensure_equals(restBuffer, ""); } TEST_METHOD(29) { // Test writing multiple buffers where one is empty. restBuffer = "oh "; StaticString data[] = { "hello ", "", "world" }; writevResult = strlen("oh hello world"); ensure_equals(gatheredWrite(0, data, 3, restBuffer), writevResult); ensure_equals(writevData, "oh hello world"); ensure_equals(restBuffer, ""); } /***** Test gatheredWrite() blocking version *****/ TEST_METHOD(35) { // It doesn't call writev() if requested to send 0 bytes. StaticString data[2] = { "", "" }; gatheredWrite(0, data, 2); ensure_equals(writevCalled, 0); } TEST_METHOD(36) { // Test sending all data in a single writev() call. StaticString data[] = { "hello", "my", "world" }; writevResult = strlen("hellomyworld"); gatheredWrite(0, data, 3); ensure_equals(writevData, "hellomyworld"); ensure_equals(writevCalled, 1); } TEST_METHOD(42) { // Test writing byte-by-byte. StaticString data[] = { "hello", "my", "world", "!!" }; writevResult = 1; gatheredWrite(0, data, 4); ensure_equals(writevCalled, (int) strlen("hellomyworld!!")); ensure_equals(writevData, "hellomyworld!!"); } TEST_METHOD(43) { // Test writev() writing in chunks of 2 bytes. StaticString data[] = { "hello", "my", "world", "!!" }; writevResult = 2; gatheredWrite(0, data, 4); ensure_equals(writevCalled, (int) strlen("hellomyworld!!") / 2); ensure_equals(writevData, "hellomyworld!!"); } static ssize_t writev_mock_44(int fildes, const struct iovec *iov, int iovcnt) { if (writevCalled == 3) { // Have the last call return 2 instead of 4. writevResult = 2; } return writev_mock(fildes, iov, iovcnt); } TEST_METHOD(44) { // Test writev() writing in chunks of 4 bytes. setWritevFunction(writev_mock_44); StaticString data[] = { "hello", "my", "world", "!!" }; writevResult = 4; gatheredWrite(0, data, 4); ensure_equals(writevCalled, 4); ensure_equals(writevData, "hellomyworld!!"); } TEST_METHOD(45) { // Test writev() timeout support. setWritevFunction(NULL); Pipe p = createPipe(__FILE__, __LINE__); unsigned long long startTime = SystemTime::getUsec(); unsigned long long timeout = 30000; char data1[1024], data2[1024]; StaticString data[] = { StaticString(data1, sizeof(data1) - 1), StaticString(data2, sizeof(data2) - 1) }; memset(data1, 'x', sizeof(data1)); memset(data2, 'y', sizeof(data2)); try { for (int i = 0; i < 1024; i++) { gatheredWrite(p[1], data, 2, &timeout); } fail("TimeoutException expected"); } catch (const TimeoutException &) { unsigned long long elapsed = SystemTime::getUsec() - startTime; ensure("At least 29 msec have passed", elapsed >= 29000); ensure("At most 95 msec have passed", elapsed <= 95000); ensure(timeout <= 2000); } } /***** Test waitUntilReadable() *****/ TEST_METHOD(50) { // waitUntilReadable() waits for the specified timeout if no data is readable. Pipe p = createPipe(__FILE__, __LINE__); unsigned long long timeout = 25000; ensure("No data is available", !waitUntilReadable(p.first, &timeout)); ensure("The passed time is deducted from the timeout", timeout < 5000); } TEST_METHOD(51) { // waitUntilReadable() waits for less than the specified timeout if data // is not available immediately but still available before the timeout. Pipe p = createPipe(__FILE__, __LINE__); TempThread thr(boost::bind(&writeDataAfterSomeTime, p.second, 35000)); unsigned long long timeout = 1000000; ensure("Data is available", waitUntilReadable(p.first, &timeout)); ensure("At least 35 msec passed.", timeout <= 1000000 - 35000); ensure("At most 70 msec passed.", timeout >= 1000000 - 70000); // depends on system scheduler though } TEST_METHOD(52) { // waitUntilReadable() returns immediately if timeout is 0. Pipe p = createPipe(__FILE__, __LINE__); unsigned long long timeout = 0; ensure("No data is available", !waitUntilReadable(p.first, &timeout)); ensure_equals("Timeout is not modified", timeout, 0u); write(p.second, "hi", 2); ensure("Data is available", waitUntilReadable(p.first, &timeout)); ensure_equals("Timeout is not modified", timeout, 0u); } TEST_METHOD(53) { // waitUntilReadable() returns immediately if there's data immediately available. Pipe p = createPipe(__FILE__, __LINE__); unsigned long long timeout = 100000; write(p.second, "hi", 2); ensure("Data is available", waitUntilReadable(p.first, &timeout)); ensure("Timeout is not modified", timeout >= 100000 - 5000); } /***** Test readExact() *****/ TEST_METHOD(54) { // readExact() throws TimeoutException if no data is received within the timeout. Pipe p = createPipe(__FILE__, __LINE__); unsigned long long timeout = 50000; char buf; try { readExact(p.first, &buf, 1, &timeout); fail("No TimeoutException thrown."); } catch (const TimeoutException &) { ensure("The passed time is deducted from timeout", timeout < 5000); } } TEST_METHOD(55) { // readExact() throws TimeoutException if not enough data is received within the timeout. Pipe p = createPipe(__FILE__, __LINE__); unsigned long long timeout = 20000; char buf[100]; TempThread thr(boost::bind(&writeDataSlowly, p.second, sizeof(buf), 1)); try { readExact(p.first, &buf, sizeof(buf), &timeout); fail("No TimeoutException thrown."); } catch (const TimeoutException &) { ensure("The passed time is deducted from timeout", timeout < 5000); } } TEST_METHOD(56) { // readExact() throws TimeoutException if timeout is 0 and no data is immediately available. Pipe p = createPipe(__FILE__, __LINE__); unsigned long long timeout = 0; char buf; try { readExact(p.first, &buf, 1, &timeout); fail("No TimeoutException thrown."); } catch (const TimeoutException &) { ensure_equals("Timeout unchanged", timeout, 0u); } } TEST_METHOD(57) { // readExact() throws TimeoutException if timeout is 0 and not enough data is // immediately available. Pipe p = createPipe(__FILE__, __LINE__); unsigned long long timeout = 0; write(p.second, "hi", 2); try { char buf[100]; readExact(p.first, &buf, sizeof(buf), &timeout); fail("No TimeoutException thrown."); } catch (const TimeoutException &) { ensure_equals("Timeout is unchanged", timeout, 0u); } } TEST_METHOD(58) { // readExact() deducts the amount of time spent on waiting from the timeout variable. Pipe p = createPipe(__FILE__, __LINE__); unsigned long long timeout = 100000; char buf[3]; // Spawn a thread that writes 100 bytes per second, i.e. each byte takes 10 msec. TempThread thr(boost::bind(&writeDataSlowly, p.second, 1000, 100)); // We read 3 bytes. ensure_equals(readExact(p.first, &buf, sizeof(buf), &timeout), 3u); ensure("Should have taken at least 20 msec", timeout <= 100000 - 20000); #if defined(__FreeBSD__) || defined(BOOST_OS_MACOS) // Stupid timer resolution on FreeBSD... ensure("Should have taken at most 95 msec", timeout >= 100000 - 95000); #else ensure("Should have taken at most 50 msec", timeout >= 100000 - 40000); #endif } TEST_METHOD(59) { // readExact() does not wait and does not modify the timeout variable if there's // immediately enough data available. Pipe p = createPipe(__FILE__, __LINE__); unsigned long long timeout = 100000; char buf[2]; write(p.second, "hi", 2); ensure_equals(readExact(p.first, &buf, 2, &timeout), 2u); ensure("Timeout not modified", timeout >= 95000); } /***** Test waitUntilWritable() *****/ TEST_METHOD(60) { // waitUntilWritable() waits for the specified timeout if no data is writable. Pipe p = createNonBlockingPipe(); writeUntilFull(p.second); unsigned long long timeout = 25000; ensure("Socket did not become writable", !waitUntilWritable(p.second, &timeout)); ensure("The passed time is deducted from the timeout", timeout < 5000); } TEST_METHOD(61) { // waitUntilWritable() waits for less than the specified timeout if the fd // is not immediately writable but still writable before the timeout. Pipe p = createNonBlockingPipe(); writeUntilFull(p.second); TempThread thr(boost::bind(&readDataAfterSomeTime, p.first, 35000)); unsigned long long timeout = 1000000; ensure("Socket became writable", waitUntilWritable(p.second, &timeout)); ensure("At least 35 msec passed.", timeout <= 1000000 - 35000); ensure("At most 70 msec passed.", timeout >= 1000000 - 70000); // depends on system scheduler though } TEST_METHOD(62) { // waitUntilWritable() returns immediately if timeout is 0. Pipe p = createNonBlockingPipe(); writeUntilFull(p.second); unsigned long long timeout = 0; ensure("Socket is not writable", !waitUntilWritable(p.second, &timeout)); ensure_equals("Timeout is not modified", timeout, 0u); char buf[1024 * 8]; read(p.first, buf, sizeof(buf)); ensure("Socket became writable", waitUntilWritable(p.second, &timeout)); ensure_equals("Timeout is not modified", timeout, 0u); } TEST_METHOD(63) { // waitUntilWritable() returns immediately if the fd is immediately writable. Pipe p = createNonBlockingPipe(); writeUntilFull(p.second); unsigned long long timeout = 100000; char buf[1024 * 8]; read(p.first, buf, sizeof(buf)); ensure("Socket became writable", waitUntilWritable(p.second, &timeout)); ensure("Timeout is not modified", timeout >= 100000 - 5000); } /***** Test readExact() *****/ TEST_METHOD(64) { // writeExact() throws TimeoutException if fd does not become writable within the timeout. Pipe p = createNonBlockingPipe(); writeUntilFull(p.second); unsigned long long timeout = 50000; try { writeExact(p.second, "x", 1, &timeout); fail("No TimeoutException thrown."); } catch (const TimeoutException &) { ensure("The passed time is deducted from timeout", timeout < 5000); } } TEST_METHOD(65) { // writeExact() throws TimeoutException if not enough data is written within the timeout. Pipe p = createNonBlockingPipe(); writeUntilFull(p.second); unsigned long long timeout = 20000; char buf[1024 * 3]; TempThread thr(boost::bind(&readDataSlowly, p.first, sizeof(buf), 512)); try { writeExact(p.second, "x", 1, &timeout); fail("No TimeoutException thrown."); } catch (const TimeoutException &) { ensure("The passed time is deducted from timeout", timeout < 5000); } } TEST_METHOD(66) { // writeExact() throws TimeoutException if timeout is 0 and the fd is not immediately writable. Pipe p = createNonBlockingPipe(); writeUntilFull(p.second); unsigned long long timeout = 0; try { writeExact(p.second, "x", 1, &timeout); fail("No TimeoutException thrown."); } catch (const TimeoutException &) { ensure_equals("Timeout unchanged", timeout, 0u); } } TEST_METHOD(67) { // writeExact() throws TimeoutException if timeout is 0 not enough data could be written immediately. Pipe p = createNonBlockingPipe(); writeUntilFull(p.second); unsigned long long timeout = 0; char buf[1024]; read(p.first, buf, sizeof(buf)); char buf2[1024 * 8]; memset(buf2, 0, sizeof(buf2)); try { writeExact(p.second, buf2, sizeof(buf2), &timeout); fail("No TimeoutException thrown."); } catch (const TimeoutException &) { ensure_equals("Timeout is unchanged", timeout, 0u); } } TEST_METHOD(68) { // readExact() deducts the amount of time spent on waiting from the timeout variable. Pipe p = createNonBlockingPipe(); unsigned long long timeout = 100000; // Spawn a thread that reads 200000 bytes in 35 msec. TempThread thr(boost::bind(&readDataSlowly, p.first, 5714286, 5714286)); // We write 200000 bytes. char buf[200000]; memset(buf, 0, sizeof(buf)); writeExact(p.second, &buf, sizeof(buf), &timeout); ensure("Should have taken at least 20 msec", timeout <= 100000 - 20000); ensure("Should have taken at most 95 msec", timeout >= 100000 - 95000); } TEST_METHOD(69) { // writeExact() does not wait and does not modify the timeout variable if // all data can be written immediately. Pipe p = createNonBlockingPipe(); unsigned long long timeout = 100000; char buf[1024]; memset(buf, 0, sizeof(buf)); writeExact(p.second, buf, sizeof(buf), &timeout); ensure("Timeout not modified", timeout >= 95000); } /***** Test getSocketAddressType() *****/ TEST_METHOD(70) { ensure_equals(getSocketAddressType(""), SAT_UNKNOWN); ensure_equals(getSocketAddressType("/foo.socket"), SAT_UNKNOWN); ensure_equals(getSocketAddressType("unix:"), SAT_UNKNOWN); ensure_equals(getSocketAddressType("unix:/"), SAT_UNIX); ensure_equals(getSocketAddressType("unix:/foo.socket"), SAT_UNIX); ensure_equals(getSocketAddressType("tcp:"), SAT_UNKNOWN); ensure_equals(getSocketAddressType("tcp://"), SAT_UNKNOWN); // Doesn't check whether it contains port ensure_equals(getSocketAddressType("tcp://127.0.0.1"), SAT_TCP); ensure_equals(getSocketAddressType("tcp://127.0.0.1:80"), SAT_TCP); } TEST_METHOD(71) { ensure_equals(parseUnixSocketAddress("unix:/foo.socket"), "/foo.socket"); try { parseUnixSocketAddress("unix:"); fail("ArgumentException expected"); } catch (const ArgumentException &e) { // Pass. } } TEST_METHOD(72) { string host; unsigned short port; parseTcpSocketAddress("tcp://127.0.0.1:80", host, port); ensure_equals(host, "127.0.0.1"); ensure_equals(port, 80); parseTcpSocketAddress("tcp://[::1]:80", host, port); ensure_equals(host, "::1"); ensure_equals(port, 80); try { parseTcpSocketAddress("tcp://", host, port); fail("ArgumentException expected (1)"); } catch (const ArgumentException &e) { // Pass. } try { parseTcpSocketAddress("tcp://127.0.0.1", host, port); fail("ArgumentException expected (2)"); } catch (const ArgumentException &e) { // Pass. } try { parseTcpSocketAddress("tcp://127.0.0.1:", host, port); fail("ArgumentException expected (3)"); } catch (const ArgumentException &e) { // Pass. } try { parseTcpSocketAddress("tcp://[::1]", host, port); fail("ArgumentException expected (4)"); } catch (const ArgumentException &e) { // Pass. } try { parseTcpSocketAddress("tcp://[::1]:", host, port); fail("ArgumentException expected (5)"); } catch (const ArgumentException &e) { // Pass. } } /***** Test readFileDescriptor() and writeFileDescriptor() *****/ TEST_METHOD(80) { // Test whether it works. SocketPair sockets = createUnixSocketPair(__FILE__, __LINE__); Pipe pipes = createPipe(__FILE__, __LINE__); writeFileDescriptor(sockets[0], pipes[1]); FileDescriptor fd(readFileDescriptor(sockets[1]), __FILE__, __LINE__); writeExact(fd, "hello"); char buf[6]; ensure_equals(readExact(pipes[0], buf, 5), 5u); buf[5] = '\0'; ensure_equals(StaticString(buf), "hello"); } TEST_METHOD(81) { // Test whether timeout works. SocketPair sockets = createUnixSocketPair(__FILE__, __LINE__); Pipe pipes = createPipe(__FILE__, __LINE__); unsigned long long timeout = 30000; unsigned long long startTime = SystemTime::getUsec(); try { FileDescriptor fd(readFileDescriptor(sockets[0], &timeout), __FILE__, __LINE__); fail("TimeoutException expected"); } catch (const TimeoutException &) { unsigned long long elapsed = SystemTime::getUsec() - startTime; ensure("readFileDescriptor() timed out after at least 29 msec", elapsed >= 29000); ensure("readFileDescriptor() timed out after at most 95 msec", elapsed <= 95000); ensure(timeout <= 2000); } writeUntilFull(sockets[0]); startTime = SystemTime::getUsec(); timeout = 30000; try { writeFileDescriptor(sockets[0], pipes[0], &timeout); fail("TimeoutException expected"); } catch (const TimeoutException &) { unsigned long long elapsed = SystemTime::getUsec() - startTime; ensure("writeFileDescriptor() timed out after 30 msec", elapsed >= 29000 && elapsed <= 95000); ensure(timeout <= 2000); } } /***** Test readAll() *****/ TEST_METHOD(85) { set_test_name("readAll() with unlimited maxSize"); Pipe p = createPipe(__FILE__, __LINE__); writeExact(p[1], "hello world"); p[1].close(); pair<string, bool> result = readAll(p[0], std::numeric_limits<size_t>::max()); ensure_equals(result.first, "hello world"); ensure(result.second); } TEST_METHOD(86) { set_test_name("readAll() with size smaller than actual data"); Pipe p = createPipe(__FILE__, __LINE__); writeExact(p[1], "hello world"); p[1].close(); pair<string, bool> result = readAll(p[0], 5); ensure_equals(result.first, "hello"); ensure(!result.second); } }