TESTBED: Move encoding conversion tests to testbed

This way it is possible to test the backend conversions too.

4 files changed, 821 insertions, 0 deletions

diff --git a/engines/testbed/encoding.cpp b/engines/testbed/encoding.cpp
new file mode 100644
index 0000000000..8fe2c6bf11
--- /dev/null
+++ b/engines/testbed/encoding.cpp
@@ -0,0 +1,746 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "common/encoding.h"
+#include "common/system.h"
+#include "engines/testbed/encoding.h"
+
+namespace Testbed {
+
+TestExitStatus Encodingtests::testConversionUnicodeMachineEndian() {
+	Testsuite::displayMessage("Encoding conversion tests.\nTo test iconv conversion, compile with --enable-iconv.\nTo test backend conversion, compile with --disable-iconv.\nSome tests may fail without iconv, because some backends support only a handful of conversions.");
+	Common::String info = "Unicode conversion test. Multiple conversions between UTF-8, UTF-16 and UTF-32 in the default machinge endian will be performed.";
+
+	Common::Point pt(0, 100);
+	Testsuite::writeOnScreen("Testing unicode conversion in machine native endianness.", pt);
+
+	if (Testsuite::handleInteractiveInput(info, "OK", "Skip", kOptionRight)) {
+		Testsuite::logPrintf("Info! Skipping test : testConversionUnicodeMachineEndian\n");
+		return kTestSkipped;
+	}
+					   //  |dolar|   cent    |     euro       |
+	unsigned char utf8[] = {0x24, 0xC2, 0xA2, 0xE2, 0x82, 0xAC, 0};
+							//| dolar |  cent  |    euro   |
+	unsigned char utf16be[] = {0, 0x24, 0, 0xA2, 0x20, 0xAC, 0, 0};
+							//| dolar |  cent  |    euro   |
+	unsigned char utf16le[] = {0x24, 0, 0xA2, 0, 0xAC, 0x20, 0, 0};
+							//| dolar       |  cent        |    euro  
+	unsigned char utf32be[] = {0, 0, 0, 0x24, 0, 0, 0, 0xA2, 0, 0, 0x20, 0xAC, 0, 0, 0, 0};
+							//| dolar       |  cent        |    euro
+	unsigned char utf32le[] = {0x24, 0, 0, 0, 0xA2, 0, 0, 0, 0xAC, 0x20, 0, 0, 0, 0, 0, 0};
+#ifdef SCUMM_BIG_ENDIAN
+	unsigned char *utf16 = utf16be;
+	unsigned char *utf32 = utf32be;
+#else
+	unsigned char *utf16 = utf16le;
+	unsigned char *utf32 = utf32le;
+#endif
+
+	// UTF16 to UTF8
+	Common::Encoding converter("UTF-8", "UTF-16");
+
+	char *result = converter.convert((char *) utf16, 6);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-16 to UTF-8 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf8, 7)) {
+		Testsuite::logPrintf("UTF-16 to UTF-8 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	result = Common::Encoding::convert("UTF-8", "UTF-16", (char *) utf16, 6);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-16 to UTF-8 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf8, 7)) {
+		Testsuite::logPrintf("UTF-16 to UTF-8 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	// UTF32 to UTF8
+	converter.setFrom("UTF-32");
+
+	result = converter.convert((char *) utf32, 12);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-32 to UTF-8 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf8, 7)) {
+		Testsuite::logPrintf("UTF-32 to UTF-8 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	result = Common::Encoding::convert("UTF-8", "UTF-32", (char *) utf32, 12);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-32 to UTF-8 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf8, 7)) {
+		Testsuite::logPrintf("UTF-32 to UTF-8 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	// UTF32 to UTF16
+	converter.setTo("UTF-16");
+
+	result = converter.convert((char *) utf32, 12);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-32 to UTF-16 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf16, 8)) {
+		Testsuite::logPrintf("UTF-32 to UTF-16 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	result = Common::Encoding::convert("UTF-16", "UTF-32", (char *) utf32, 12);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-32 to UTF-16 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf16, 8)) {
+		Testsuite::logPrintf("UTF-32 to UTF-16 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	// UTF8 to UTF16
+	converter.setFrom("UTF-8");
+
+	result = converter.convert((char *) utf8, 6);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-8 to UTF-16 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf16, 8)) {
+		Testsuite::logPrintf("UTF-8 to UTF-16 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	result = Common::Encoding::convert("UTF-16", "UTF-8", (char *) utf8, 6);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-8 to UTF-16 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf16, 8)) {
+		Testsuite::logPrintf("UTF-8 to UTF-16 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	// UTF8 to UTF32
+	converter.setTo("UTF-32");
+
+	result = converter.convert((char *) utf8, 6);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-8 to UTF-32 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf32, 16)) {
+		Testsuite::logPrintf("UTF-8 to UTF-32 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	result = Common::Encoding::convert("UTF-32", "UTF-8", (char *) utf8, 6);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-8 to UTF-32 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf32, 16)) {
+		Testsuite::logPrintf("UTF-8 to UTF-32 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	// UTF16 to UTF32
+	converter.setFrom("UTF-16");
+
+	result = converter.convert((char *) utf16, 6);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-16 to UTF-32 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf32, 16)) {
+		Testsuite::logPrintf("UTF-16 to UTF-32 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	result = Common::Encoding::convert("UTF-32", "UTF-16", (char *) utf16, 6);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-16 to UTF-32 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf32, 16)) {
+		Testsuite::logPrintf("UTF-16 to UTF-32 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	return kTestPassed;
+}
+
+TestExitStatus Encodingtests::testConversionUnicodeBigEndian() {
+	Common::String info = "Unicode conversion test. Multiple conversions between UTF-8, UTF-16 and UTF-32 in big endian will be performed.";
+
+	Common::Point pt(0, 100);
+	Testsuite::writeOnScreen("Testing unicode conversion in big endian.", pt);
+
+	if (Testsuite::handleInteractiveInput(info, "OK", "Skip", kOptionRight)) {
+		Testsuite::logPrintf("Info! Skipping test : testConversionUnicodeBigEndian\n");
+		return kTestSkipped;
+	}
+					   //  |dolar|   cent    |     euro       |
+	unsigned char utf8[] = {0x24, 0xC2, 0xA2, 0xE2, 0x82, 0xAC, 0};
+							//| dolar |  cent  |    euro   |
+	unsigned char utf16be[] = {0, 0x24, 0, 0xA2, 0x20, 0xAC, 0, 0};
+							//| dolar       |  cent        |    euro  
+	unsigned char utf32be[] = {0, 0, 0, 0x24, 0, 0, 0, 0xA2, 0, 0, 0x20, 0xAC, 0, 0, 0, 0};
+
+	// UTF16 to UTF8
+	Common::Encoding converter("UTF-8", "UTF-16BE");
+
+	char *result = converter.convert((char *) utf16be, 6);
+
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-16 to UTF-8 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf8, 7)) {
+		Testsuite::logPrintf("UTF-16 to UTF-8 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	result = Common::Encoding::convert("UTF-8", "UTF-16BE", (char *) utf16be, 6);
+
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-16 to UTF-8 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf8, 7)) {
+		Testsuite::logPrintf("UTF-16 to UTF-8 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	// UTF32 to UTF8
+	converter.setFrom("UTF-32BE");
+
+	result = converter.convert((char *) utf32be, 12);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-32 to UTF-8 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf8, 7)) {
+		Testsuite::logPrintf("UTF-32 to UTF-8 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	result = Common::Encoding::convert("UTF-8", "UTF-32BE", (char *) utf32be, 12);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-32 to UTF-8 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf8, 7)) {
+		Testsuite::logPrintf("UTF-32 to UTF-8 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	// UTF32 to UTF16
+	converter.setTo("UTF-16BE");
+
+	result = converter.convert((char *) utf32be, 12);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-32 to UTF-16 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf16be, 8)) {
+		Testsuite::logPrintf("UTF-32 to UTF-16 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	result = Common::Encoding::convert("UTF-16BE", "UTF-32BE", (char *) utf32be, 12);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-32 to UTF-16 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf16be, 8)) {
+		Testsuite::logPrintf("UTF-32 to UTF-16 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	// UTF8 to UTF16
+	converter.setFrom("UTF-8");
+
+	result = converter.convert((char *) utf8, 6);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-8 to UTF-16 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf16be, 8)) {
+		Testsuite::logPrintf("UTF-8 to UTF-16 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	result = Common::Encoding::convert("UTF-16BE", "UTF-8", (char *) utf8, 6);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-8 to UTF-16 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf16be, 8)) {
+		Testsuite::logPrintf("UTF-8 to UTF-16 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	// UTF8 to UTF32
+	converter.setTo("UTF-32BE");
+
+	result = converter.convert((char *) utf8, 6);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-8 to UTF-32 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf32be, 16)) {
+		Testsuite::logPrintf("UTF-8 to UTF-32 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	result = Common::Encoding::convert("UTF-32BE", "UTF-8", (char *) utf8, 6);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-8 to UTF-32 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf32be, 16)) {
+		Testsuite::logPrintf("UTF-8 to UTF-32 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	// UTF16 to UTF32
+	converter.setFrom("UTF-16BE");
+
+	result = converter.convert((char *) utf16be, 6);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-16 to UTF-32 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf32be, 16)) {
+		Testsuite::logPrintf("UTF-16 to UTF-32 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	result = Common::Encoding::convert("UTF-32BE", "UTF-16BE", (char *) utf16be, 6);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-16 to UTF-32 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf32be, 16)) {
+		Testsuite::logPrintf("UTF-16 to UTF-32 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+	return kTestPassed;
+}
+
+TestExitStatus Encodingtests::testConversionUnicodeLittleEndian() {
+	Common::String info = "Unicode conversion test. Multiple conversions between UTF-8, UTF-16 and UTF-32 in little endian will be performed.";
+
+	Common::Point pt(0, 100);
+	Testsuite::writeOnScreen("Testing unicode conversion in little endianness.", pt);
+
+	if (Testsuite::handleInteractiveInput(info, "OK", "Skip", kOptionRight)) {
+		Testsuite::logPrintf("Info! Skipping test : testConversionUnicodeLittleEndian\n");
+		return kTestSkipped;
+	}
+					   //  |dolar|   cent    |     euro       |
+	unsigned char utf8[] = {0x24, 0xC2, 0xA2, 0xE2, 0x82, 0xAC, 0};
+							//| dolar |  cent  |    euro   |
+	unsigned char utf16le[] = {0x24, 0, 0xA2, 0, 0xAC, 0x20, 0, 0};
+							//| dolar       |  cent        |    euro
+	unsigned char utf32le[] = {0x24, 0, 0, 0, 0xA2, 0, 0, 0, 0xAC, 0x20, 0, 0, 0, 0, 0, 0};
+
+	// UTF16 to UTF8
+	Common::Encoding converter("UTF-8", "UTF-16LE");
+
+	char *result = converter.convert((char *) utf16le, 6);
+
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-16 to UTF-8 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf8, 7)) {
+		Testsuite::logPrintf("UTF-16 to UTF-8 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	result = Common::Encoding::convert("UTF-8", "UTF-16LE", (char *) utf16le, 6);
+
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-16 to UTF-8 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf8, 7)) {
+		Testsuite::logPrintf("UTF-16 to UTF-8 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	// UTF32 to UTF8
+	converter.setFrom("UTF-32LE");
+
+	result = converter.convert((char *) utf32le, 12);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-32 to UTF-8 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf8, 7)) {
+		Testsuite::logPrintf("UTF-32 to UTF-8 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	result = Common::Encoding::convert("UTF-8", "UTF-32LE", (char *) utf32le, 12);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-32 to UTF-8 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf8, 7)) {
+		Testsuite::logPrintf("UTF-32 to UTF-8 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	// UTF32 to UTF16
+	converter.setTo("UTF-16LE");
+
+	result = converter.convert((char *) utf32le, 12);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-32 to UTF-16 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf16le, 8)) {
+		Testsuite::logPrintf("UTF-32 to UTF-16 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	result = Common::Encoding::convert("UTF-16LE", "UTF-32LE", (char *) utf32le, 12);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-32 to UTF-16 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf16le, 8)) {
+		Testsuite::logPrintf("UTF-32 to UTF-16 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	// UTF8 to UTF16
+	converter.setFrom("UTF-8");
+
+	result = converter.convert((char *) utf8, 6);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-8 to UTF-16 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf16le, 8)) {
+		Testsuite::logPrintf("UTF-8 to UTF-16 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	result = Common::Encoding::convert("UTF-16LE", "UTF-8", (char *) utf8, 6);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-8 to UTF-16 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf16le, 8)) {
+		Testsuite::logPrintf("UTF-8 to UTF-16 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	// UTF8 to UTF32
+	converter.setTo("UTF-32LE");
+
+	result = converter.convert((char *) utf8, 6);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-8 to UTF-32 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf32le, 16)) {
+		Testsuite::logPrintf("UTF-8 to UTF-32 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	result = Common::Encoding::convert("UTF-32LE", "UTF-8", (char *) utf8, 6);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-8 to UTF-32 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf32le, 16)) {
+		Testsuite::logPrintf("UTF-8 to UTF-32 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	// UTF16 to UTF32
+	converter.setFrom("UTF-16LE");
+
+	result = converter.convert((char *) utf16le, 6);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-16 to UTF-32 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf32le, 16)) {
+		Testsuite::logPrintf("UTF-16 to UTF-32 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	result = Common::Encoding::convert("UTF-32LE", "UTF-16LE", (char *) utf16le, 6);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-16 to UTF-32 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf32le, 16)) {
+		Testsuite::logPrintf("UTF-16 to UTF-32 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+	return kTestPassed;
+}
+
+TestExitStatus Encodingtests::testCyrillicTransliteration() {
+	Common::String info = "Cyrillic transliteration test. Multiple conversions between unicode, iso-8859-5 and ASCII will be performed.";
+
+	Common::Point pt(0, 100);
+	Testsuite::writeOnScreen("Testing Cyrillic transliteration", pt);
+
+	if (Testsuite::handleInteractiveInput(info, "OK", "Skip", kOptionRight)) {
+		Testsuite::logPrintf("Info! Skipping test : testCyrillicTransliteration\n");
+		return kTestSkipped;
+	}
+	unsigned char utf8[] = {/* Z */0xD0, 0x97, /* d */ 0xD0, 0xB4, /* r */ 0xD1, 0x80, /* a */ 0xD0, 0xB0, /* v */ 0xD0, 0xB2, /* s */ 0xD1, 0x81, /* t */ 0xD1, 0x82, /* v */ 0xD0, 0xB2, /* u */ 0xD1, 0x83, /* j */ 0xD0, 0xB9, /* t */ 0xD1, 0x82, /* e */ 0xD0, 0xB5, 0};
+	unsigned char iso_8859_5[] = {0xB7, 0xD4, 0xE0, 0xD0, 0xD2, 0xE1, 0xE2, 0xD2, 0xE3, 0xD9, 0xE2, 0xD5, 0};
+	unsigned char ascii[] = "Zdravstvujte";
+
+	Common::Encoding converter("ASCII", "UTF-8");
+	char *result = converter.convert((char *)utf8, 24);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-8 to ASCII conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, ascii, 13)) {
+		Testsuite::logPrintf("UTF-8 to ASCII conversion isn'differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	converter.setFrom("iso-8859-5");
+	result = converter.convert((char *)iso_8859_5, 12);
+	if (result == NULL) {
+		Testsuite::logPrintf("iso-8859-5 to ASCII conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, ascii, 13)) {
+		Testsuite::logPrintf("iso-8859-5 to ASCII conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	converter.setTo("UTF-8");
+	result = converter.convert((char *)iso_8859_5, 12);
+	if (result == NULL) {
+		Testsuite::logPrintf("iso-8859-5 to UTF-8 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf8, 25)) {
+		Testsuite::logPrintf("iso-8859-5 to UTF-differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	converter.setTo("iso-8859-5");
+	converter.setFrom("UTF-8");
+	result = converter.convert((char *)utf8, 24);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-8 to iso-8859-5 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, iso_8859_5, 13)) {
+		Testsuite::logPrintf("UTF-8 to iso-8859-differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	// this should stay the same
+	converter.setFrom("ASCII");
+	result = converter.convert((char *)ascii, 12);
+	if (result == NULL) {
+		Testsuite::logPrintf("ASCII to iso-8859-5 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, ascii, 13)) {
+		Testsuite::logPrintf("ASCII to iso-8859-5 conversion differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+	return kTestPassed;
+}
+
+TestExitStatus Encodingtests::testOtherConversions() {
+	Common::String info = "Other conversions test. Some regular encoding conversions will be performed.";
+
+	Common::Point pt(0, 100);
+	Testsuite::writeOnScreen("Testing other encoding conversions", pt);
+
+	if (Testsuite::handleInteractiveInput(info, "OK", "Skip", kOptionRight)) {
+		Testsuite::logPrintf("Info! Skipping test : testOtherConversions\n");
+		return kTestSkipped;
+	}
+	unsigned char cp850[] = {0x99, 0xE0, 0xEA, 0x41, 0x64, 0};
+	unsigned char utf8_1[] = {0xC3, 0x96, 0xC3, 0x93, 0xC3, 0x9B, 0x41, 0x64, 0};
+
+	unsigned char iso_8859_2[] = {0xA9, 0xE1, 0x6C, 0x65, 0xE8, 0x65, 0x6B, 0};
+	unsigned char utf8_2[] = {0xC5, 0xA0, 0xC3, 0xA1, 0x6C, 0x65, 0xC4, 0x8D, 0x65, 0x6B, 0};
+
+	char *result = Common::Encoding::convert("UTF-8", "CP850", (char *)cp850, 5);
+	if (result == NULL) {
+		Testsuite::logPrintf("CP850 to UTF-8 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf8_1, 9)) {
+		Testsuite::logPrintf("CP850 to UTF-8 conversion isn'differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	result = Common::Encoding::convert("CP850", "UTF-8", (char *)utf8_1, 8);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-8 to CP850 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, cp850, 6)) {
+		Testsuite::logPrintf("UTF-8 to CP850 conversion isn'differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	result = Common::Encoding::convert("UTF-8", "iso-8859-2", (char *)iso_8859_2, 7);
+	if (result == NULL) {
+		Testsuite::logPrintf("iso-8859-2 to UTF-8 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, utf8_2, 11)) {
+		Testsuite::logPrintf("iso-8859-2 to UTF-differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+
+	result = Common::Encoding::convert("iso-8859-2", "UTF-8", (char *)utf8_2, 11);
+	if (result == NULL) {
+		Testsuite::logPrintf("UTF-8 to iso-8859-2 conversion isn't available");
+		return kTestFailed;
+	}
+	if (memcmp(result, iso_8859_2, 8)) {
+		Testsuite::logPrintf("UTF-8 to iso-8859-differs from the expected result.");
+		free(result);
+		return kTestFailed;
+	}
+	free(result);
+	return kTestPassed;
+}
+
+EncodingTestSuite::EncodingTestSuite() {
+	addTest("testConversionUnicodeMachineEndian", &Encodingtests::testConversionUnicodeMachineEndian, true);
+	addTest("testConversionUnicodeBigEndian", &Encodingtests::testConversionUnicodeBigEndian, true);
+	addTest("testConversionUnicodeLittleEndian", &Encodingtests::testConversionUnicodeLittleEndian, true);
+	addTest("testCyrillicTransliteration", &Encodingtests::testCyrillicTransliteration, true);
+	addTest("testOtherConversions", &Encodingtests::testOtherConversions, true);
+}
+
+} // End of namespace Testbed
diff --git a/engines/testbed/encoding.h b/engines/testbed/encoding.h
new file mode 100644
index 0000000000..ab01d7a1cb
--- /dev/null
+++ b/engines/testbed/encoding.h
@@ -0,0 +1,71 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef TESTBED_ENCODING_H
+#define TESTBED_ENCODING_H
+
+#include "testbed/testsuite.h"
+#include "common/encoding.h"
+
+namespace Testbed {
+
+namespace Encodingtests {
+
+// Helper functions for Speech tests
+
+// will contain function declarations for Encoding tests
+// add more here
+
+TestExitStatus testConversionUnicodeMachineEndian();
+TestExitStatus testConversionUnicodeBigEndian();
+TestExitStatus testConversionUnicodeLittleEndian();
+TestExitStatus testCyrillicTransliteration();
+TestExitStatus testOtherConversions();
+
+} // End of namespace Speechtests
+
+class EncodingTestSuite : public Testsuite {
+public:
+	/**
+	 * The constructor for the XXXTestSuite
+	 * For every test to be executed one must:
+	 * 1) Create a function that would invoke the test
+	 * 2) Add that test to list by executing addTest()
+	 *
+	 * @see addTest()
+	 */
+	EncodingTestSuite();
+	~EncodingTestSuite() {}
+	const char *getName() const {
+		return "Encoding";
+	}
+
+	const char *getDescription() const {
+		return "Encoding conversion";
+	}
+
+};
+
+
+} // End of namespace Testbed
+
+#endif // TESTBED_ENCODING_H
diff --git a/engines/testbed/module.mk b/engines/testbed/module.mk
index 5838751439..d8ff0e70b5 100644
--- a/engines/testbed/module.mk
+++ b/engines/testbed/module.mk
@@ -11,6 +11,7 @@ MODULE_OBJS := \
 	misc.o \
 	savegame.o \
 	sound.o \
+	encoding.o \
 	testbed.o \
 	testsuite.o
 
diff --git a/engines/testbed/testbed.cpp b/engines/testbed/testbed.cpp
index f071ab347a..1b0c2dd776 100644
--- a/engines/testbed/testbed.cpp
+++ b/engines/testbed/testbed.cpp
@@ -38,6 +38,7 @@
 #include "testbed/misc.h"
 #include "testbed/savegame.h"
 #include "testbed/sound.h"
+#include "testbed/encoding.h"
 #include "testbed/testbed.h"
 #ifdef USE_CLOUD
 #include "testbed/cloud.h"
@@ -150,6 +151,8 @@ TestbedEngine::TestbedEngine(OSystem *syst)
 	ts = new WebserverTestSuite();
 	_testsuiteList.push_back(ts);
 #endif
+	ts = new EncodingTestSuite();
+	_testsuiteList.push_back(ts);
 }
 
 TestbedEngine::~TestbedEngine() {