Mini Shell

#include <TestSupport.h>
#include <IOTools/IOUtils.h>
#include <IOTools/MessageIO.h>
#include <SystemTools/SystemTime.h>

using namespace Passenger;
using namespace std;
using namespace boost;

namespace tut {
	struct IOTools_MessageIOTest: public TestBase {
		Pipe pipes;

		IOTools_MessageIOTest() {
			pipes = createPipe(__FILE__, __LINE__);
		}
	};

	DEFINE_TEST_GROUP(IOTools_MessageIOTest);

	/***** Test readUint16() and writeUint16() *****/

	TEST_METHOD(1) {
		// They work.
		writeUint16(pipes[1], 0x3F56);
		writeUint16(pipes[1], 0x3F57);
		writeUint16(pipes[1], 0x3F58);

		unsigned char buf[2];
		ensure_equals(readExact(pipes[0], buf, 2), 2u);
		ensure_equals(buf[0], 0x3F);
		ensure_equals(buf[1], 0x56);

		ensure_equals(readUint16(pipes[0]), 0x3F57u);

		uint16_t out;
		ensure(readUint16(pipes[0], out));
		ensure_equals(out, 0x3F58);
	}

	TEST_METHOD(2) {
		// readUint16() throws EOFException on premature EOF.
		writeExact(pipes[1], "x", 1);
		pipes[1].close();
		try {
			readUint16(pipes[0]);
			fail("EOFException expected");
		} catch (const EOFException &) {
		}
	}

	TEST_METHOD(3) {
		// readUint16(uint32_t &) returns false EOFException on premature EOF.
		writeExact(pipes[1], "x", 1);
		pipes[1].close();
		uint16_t out;
		ensure(!readUint16(pipes[0], out));
	}

	TEST_METHOD(4) {
		// Test timeout.
		unsigned long long timeout = 30000;
		unsigned long long startTime = SystemTime::getUsec();
		try {
			readUint16(pipes[0], &timeout);
			fail("TimeoutException expected");
		} catch (const TimeoutException &) {
			unsigned long long elapsed = SystemTime::getUsec() - startTime;
			ensure("About 30 ms elapsed (1)", elapsed >= 29000 && elapsed <= 95000);
			ensure("Time is correctly deducted from 'timeout' (1)", timeout <= 2000);
		}

		writeUntilFull(pipes[1]);

		timeout = 30000;
		startTime = SystemTime::getUsec();
		try {
			writeUint16(pipes[1], 0x12, &timeout);
			fail("TimeoutException expected");
		} catch (const TimeoutException &) {
			unsigned long long elapsed = SystemTime::getUsec() - startTime;
			ensure("About 30 ms elapsed (3)", elapsed >= 29000 && elapsed <= 95000);
			ensure("Time is correctly deducted from 'timeout' (4)", timeout <= 2000);
		}
	}

	/***** Test readUint32() and writeUint32() *****/

	TEST_METHOD(10) {
		// They work.
		writeUint32(pipes[1], 0x12343F56);
		writeUint32(pipes[1], 0x12343F57);
		writeUint32(pipes[1], 0x12343F58);

		unsigned char buf[4];
		ensure_equals(readExact(pipes[0], buf, 4), 4u);
		ensure_equals(buf[0], 0x12);
		ensure_equals(buf[1], 0x34);
		ensure_equals(buf[2], 0x3F);
		ensure_equals(buf[3], 0x56);

		ensure_equals(readUint32(pipes[0]), 0x12343F57u);

		uint32_t out;
		ensure(readUint32(pipes[0], out));
		ensure_equals(out, 0x12343F58u);
	}

	TEST_METHOD(11) {
		// readUint32() throws EOFException on premature EOF.
		writeExact(pipes[1], "xyz", 3);
		pipes[1].close();
		try {
			readUint32(pipes[0]);
			fail("EOFException expected");
		} catch (const EOFException &) {
		}
	}

	TEST_METHOD(12) {
		// readUint16(uint32_t &) returns false EOFException on premature EOF.
		writeExact(pipes[1], "xyz", 3);
		pipes[1].close();
		uint32_t out;
		ensure(!readUint32(pipes[0], out));
	}

	TEST_METHOD(13) {
		// Test timeout.
		unsigned long long timeout = 30000;
		unsigned long long startTime = SystemTime::getUsec();
		try {
			readUint32(pipes[0], &timeout);
			fail("TimeoutException expected");
		} catch (const TimeoutException &) {
			unsigned long long elapsed = SystemTime::getUsec() - startTime;
			ensure(elapsed >= 29000 && elapsed <= 90000);
			ensure(timeout <= 2000);
		}

		writeUntilFull(pipes[1]);

		timeout = 30000;
		startTime = SystemTime::getUsec();
		try {
			writeUint32(pipes[1], 0x1234, &timeout);
			fail("TimeoutException expected");
		} catch (const TimeoutException &) {
			unsigned long long elapsed = SystemTime::getUsec() - startTime;
			ensure(elapsed >= 29000 && elapsed <= 90000);
			ensure(timeout <= 2000);
		}
	}

	/***** Test readArrayMessage() and writeArrayMessage() *****/

	TEST_METHOD(20) {
		// Test <= 10 arguments.
		writeArrayMessage(pipes[1], "ab", "cd", "efg", NULL);
		writeArrayMessage(pipes[1], "ab", "cd", "efh", NULL);

		unsigned char buf[12];
		readExact(pipes[0], buf, 12);
		ensure_equals(buf[0], 0u);
		ensure_equals(buf[1], 10u);
		ensure_equals(buf[2], 'a');
		ensure_equals(buf[3], 'b');
		ensure_equals(buf[4], '\0');
		ensure_equals(buf[5], 'c');
		ensure_equals(buf[6], 'd');
		ensure_equals(buf[7], '\0');
		ensure_equals(buf[8], 'e');
		ensure_equals(buf[9], 'f');
		ensure_equals(buf[10], 'g');
		ensure_equals(buf[11], '\0');

		vector<string> args = readArrayMessage(pipes[0]);
		ensure_equals(args.size(), 3u);
		ensure_equals(args[0], "ab");
		ensure_equals(args[1], "cd");
		ensure_equals(args[2], "efh");
	}

	TEST_METHOD(21) {
		// Test > 10 arguments.
		writeArrayMessage(pipes[1], "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "a", "b", NULL);
		writeArrayMessage(pipes[1], "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", NULL);

		unsigned char buf[26];
		readExact(pipes[0], buf, 26);
		ensure_equals(buf[0], 0u);
		ensure_equals(buf[1], 24u);
		ensure_equals(buf[2], '1');
		ensure_equals(buf[3], '\0');
		ensure_equals(buf[4], '2');
		ensure_equals(buf[5], '\0');
		ensure_equals(buf[6], '3');
		ensure_equals(buf[7], '\0');
		ensure_equals(buf[8], '4');
		ensure_equals(buf[9], '\0');
		ensure_equals(buf[10], '5');
		ensure_equals(buf[11], '\0');
		ensure_equals(buf[12], '6');
		ensure_equals(buf[13], '\0');
		ensure_equals(buf[14], '7');
		ensure_equals(buf[15], '\0');
		ensure_equals(buf[16], '8');
		ensure_equals(buf[17], '\0');
		ensure_equals(buf[18], '9');
		ensure_equals(buf[19], '\0');
		ensure_equals(buf[20], '0');
		ensure_equals(buf[21], '\0');
		ensure_equals(buf[22], 'a');
		ensure_equals(buf[23], '\0');
		ensure_equals(buf[24], 'b');
		ensure_equals(buf[25], '\0');

		vector<string> args = readArrayMessage(pipes[0]);
		ensure_equals(args.size(), 12u);
		ensure_equals(args[0], "c");
		ensure_equals(args[1], "d");
		ensure_equals(args[2], "e");
		ensure_equals(args[3], "f");
		ensure_equals(args[4], "g");
		ensure_equals(args[5], "h");
		ensure_equals(args[6], "i");
		ensure_equals(args[7], "j");
		ensure_equals(args[8], "k");
		ensure_equals(args[9], "l");
		ensure_equals(args[10], "m");
		ensure_equals(args[11], "n");
	}

	TEST_METHOD(22) {
		// readArrayMessage() throws EOFException on premature EOF.
		writeExact(pipes[1], "\x00");
		pipes[1].close();
		try {
			readArrayMessage(pipes[0]);
			fail("EOFException expected (1)");
		} catch (const EOFException &) {
		}

		pipes = createPipe(__FILE__, __LINE__);
		writeExact(pipes[1], "\x00\x04a\x00b");
		pipes[1].close();
		try {
			readArrayMessage(pipes[0]);
			fail("EOFException expected (2)");
		} catch (const EOFException &) {
		}
	}

	TEST_METHOD(23) {
		// Test timeout.
		unsigned long long timeout = 30000;
		unsigned long long startTime = SystemTime::getUsec();
		try {
			readArrayMessage(pipes[0], &timeout);
			fail("TimeoutException expected (1)");
		} catch (const TimeoutException &) {
			unsigned long long elapsed = SystemTime::getUsec() - startTime;
			ensure(elapsed >= 29000 && elapsed <= 90000);
			ensure(timeout <= 2000);
		}

		writeUntilFull(pipes[1]);

		timeout = 30000;
		startTime = SystemTime::getUsec();
		try {
			writeArrayMessage(pipes[1], &timeout, "hi", "ho", NULL);
			fail("TimeoutException expected (2)");
		} catch (const TimeoutException &) {
			unsigned long long elapsed = SystemTime::getUsec() - startTime;
			ensure(elapsed >= 29000 && elapsed <= 90000);
			ensure(timeout <= 2000);
		}
	}

	/***** Test readScalarMessage() and writeScalarMessage() *****/

	TEST_METHOD(30) {
		// They work.
		writeScalarMessage(pipes[1], "hello");
		writeScalarMessage(pipes[1], "world");

		unsigned char buf[4 + 5];
		readExact(pipes[0], buf, 4 + 5);
		ensure_equals(buf[0], 0u);
		ensure_equals(buf[1], 0u);
		ensure_equals(buf[2], 0u);
		ensure_equals(buf[3], 5u);
		ensure_equals(buf[4], 'h');
		ensure_equals(buf[5], 'e');
		ensure_equals(buf[6], 'l');
		ensure_equals(buf[7], 'l');
		ensure_equals(buf[8], 'o');

		ensure_equals(readScalarMessage(pipes[0]), "world");
	}

	TEST_METHOD(31) {
		// readScalarMessage() throws EOFException on premature EOF.
		writeExact(pipes[1], StaticString("\x00", 1));
		pipes[1].close();
		try {
			readScalarMessage(pipes[0]);
			fail("EOFException expected (1)");
		} catch (const EOFException &) {
		}

		pipes = createPipe(__FILE__, __LINE__);
		writeExact(pipes[1], StaticString("\x00\x00\x00\x04" "abc", 4 + 3));
		pipes[1].close();
		try {
			readScalarMessage(pipes[0]);
			fail("EOFException expected (2)");
		} catch (const EOFException &) {
		}
	}

	TEST_METHOD(32) {
		// readScalarMessage() throws SecurityException if the
		// body larger than the limit
		writeExact(pipes[1], StaticString("\x00\x00\x00\x05", 4));
		try {
			readScalarMessage(pipes[0], 4);
			fail("SecurityException expected (1)");
		} catch (const SecurityException &) {
		}
	}

	TEST_METHOD(33) {
		// Test timeout.
		unsigned long long timeout = 30000;
		unsigned long long startTime = SystemTime::getUsec();
		try {
			readScalarMessage(pipes[0], 0, &timeout);
			fail("TimeoutException expected (1)");
		} catch (const TimeoutException &) {
			unsigned long long elapsed = SystemTime::getUsec() - startTime;
			ensure(elapsed >= 29000 && elapsed <= 90000);
			ensure(timeout <= 2000);
		}

		writeUntilFull(pipes[1]);

		timeout = 30000;
		startTime = SystemTime::getUsec();
		try {
			writeScalarMessage(pipes[1], "hello", &timeout);
			fail("TimeoutException expected (2)");
		} catch (const TimeoutException &) {
			unsigned long long elapsed = SystemTime::getUsec() - startTime;
			ensure(elapsed >= 29000 && elapsed <= 90000);
			ensure(timeout <= 2000);
		}
	}
}