Initial commit

test/common/base64.h

@@ -0,0 +1,128 @@
+#include <cxxtest/TestSuite.h>
+
+#include "common/base64.h"
+#include "common/memstream.h"
+
+static const char *base64_test_string[] = {
+	"",
+	"a",
+	"abc",
+	"abcdefghijklmnopqrstuvwxyz",
+	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
+	("12345678901234567890123456789012345678901234567890123456789012"
+		"345678901234567890")
+};
+
+static const char *base64_test_encoded[] = {
+	"",
+	"YQ==",
+	"YWJj",
+	"YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXo=",
+	("QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVphYmNkZWZnaGlqa2xtbm9wcXJzdH"
+		"V2d3h5ejAxMjM0NTY3ODk="),
+	("MTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Nj"
+		"c4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTA=")
+};
+
+static const char *base64_validate_tests[] = {
+	"YQ", // missing padding
+	"!@#$", // characters not in encoding table
+	"YQ==YWJj", // data after padding
+};
+
+#include "common/pack-start.h"	// START STRUCT PACKING
+
+struct Base64TestStruct {
+	uint32 x;
+	byte y;
+	uint16 z;
+	uint32 a;
+	byte b;
+} PACKED_STRUCT;
+
+#include "common/pack-end.h"	// END STRUCT PACKING
+
+class Base64TestSuite : public CxxTest::TestSuite {
+	public:
+	void test_b64Validate() {
+		for (int i = 0; i < 6; i++) {
+			Common::String encoded = base64_test_encoded[i];
+			// All of these should return true.
+			TS_ASSERT_EQUALS(Common::b64Validate(encoded), true);
+		}
+		for (int i = 0; i < 3; i++) {
+			Common::String encoded = base64_validate_tests[i];
+			// All of these should return false.
+			TS_ASSERT_EQUALS(Common::b64Validate(encoded), false);
+		}
+
+	}
+
+	void test_b64EncodeString() {
+		for (int i = 0; i < 6; i++) {
+			Common::String string = base64_test_string[i];
+			Common::String encoded = Common::b64EncodeString(string);
+			TS_ASSERT_EQUALS(encoded, base64_test_encoded[i]);
+		}
+	}
+
+	void test_b64EncodeStream() {
+		for (int i = 0; i < 6; i++) {
+			Common::MemoryReadStream stream((const byte *)base64_test_string[i], strlen(base64_test_string[i]));
+			Common::String encoded = Common::b64EncodeStream(stream);
+			TS_ASSERT_EQUALS(encoded, base64_test_encoded[i]);
+		}
+	}
+
+	void test_b64EncodeData() {
+		Base64TestStruct *test = new Base64TestStruct();
+		test->x = TO_LE_32(1);
+		test->y =          2;
+		test->z = TO_LE_16(3);
+		test->a = TO_LE_32(4);
+		test->b =          5;
+
+		Common::String encoded = Common::b64EncodeData(test, sizeof(Base64TestStruct));
+		TS_ASSERT_EQUALS(encoded, "AQAAAAIDAAQAAAAF");
+		delete test;
+	}
+
+	void test_b64DecodeString() {
+		for (int i = 0; i < 6; i++) {
+			Common::String encoded = base64_test_encoded[i];
+			Common::String string = Common::b64DecodeString(encoded);
+			TS_ASSERT_EQUALS(string, base64_test_string[i]);
+		}
+	}
+
+	void test_b64DecodeStream() {
+		for (int i = 0; i < 6; i++) {
+			Common::String encoded = base64_test_encoded[i];
+			Common::MemoryReadStream *stream = Common::b64DecodeStream(encoded, strlen(base64_test_string[i]));
+			TS_ASSERT_EQUALS(stream->size(), (int64)strlen(base64_test_string[i]));
+
+			char *data = (char *)malloc(stream->size());
+			stream->read(data, stream->size());
+			delete stream;
+
+			Common::String string(data, strlen(base64_test_string[i]));
+			TS_ASSERT_EQUALS(string, base64_test_string[i]);
+			free(data);
+		}
+	}
+
+	void test_b64DecodeData() {
+		Base64TestStruct *test = new Base64TestStruct();
+
+		Common::String encoded = "AQAAAAIDAAQAAAAF";
+		bool success = Common::b64DecodeData(encoded, test);
+		TS_ASSERT_EQUALS(success, true);
+
+		TS_ASSERT_EQUALS(FROM_LE_32(test->x), 1u);
+		TS_ASSERT_EQUALS(test->y,             2u);
+		TS_ASSERT_EQUALS(FROM_LE_16(test->z), 3u);
+		TS_ASSERT_EQUALS(FROM_LE_32(test->a), 4u);
+		TS_ASSERT_EQUALS(test->b,             5u);
+		delete test;
+	}
+};