src/unittest/test_serialization.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "test.h"
  21
  22 #include "util/string.h"
  23 #include "util/serialize.h"
  24
  25 class TestSerialization : public TestBase {
  26 public:
  27         TestSerialization() { TestManager::registerTestModule(this); }
  28         const char *getName() { return "TestSerialization"; }
  29
  30         void runTests(IGameDef *gamedef);
  31         void buildTestStrings();
  32
  33         void testSerializeString();
  34         void testSerializeWideString();
  35         void testSerializeLongString();
  36         void testSerializeJsonString();
  37         void testSerializeHex();
  38         void testDeSerializeString();
  39         void testDeSerializeWideString();
  40         void testDeSerializeLongString();
  41
  42         std::string teststring2;
  43         std::wstring teststring2_w;
  44         std::string teststring2_w_encoded;
  45 };
  46
  47 static TestSerialization g_test_instance;
  48
  49 void TestSerialization::runTests(IGameDef *gamedef)
  50 {
  51         buildTestStrings();
  52
  53         TEST(testSerializeString);
  54         TEST(testDeSerializeString);
  55         TEST(testSerializeWideString);
  56         TEST(testDeSerializeWideString);
  57         TEST(testSerializeLongString);
  58         TEST(testDeSerializeLongString);
  59         TEST(testSerializeJsonString);
  60         TEST(testSerializeHex);
  61 }
  62
  63 ////////////////////////////////////////////////////////////////////////////////
  64
  65 // To be used like this:
  66 //   mkstr("Some\0string\0with\0embedded\0nuls")
  67 // since std::string("...") doesn't work as expected in that case.
  68 template<size_t N> std::string mkstr(const char (&s)[N])
  69 {
  70         return std::string(s, N - 1);
  71 }
  72
  73 void TestSerialization::buildTestStrings()
  74 {
  75         std::ostringstream tmp_os;
  76         std::wostringstream tmp_os_w;
  77         std::ostringstream tmp_os_w_encoded;
  78         for (int i = 0; i < 256; i++) {
  79                 tmp_os << (char)i;
  80                 tmp_os_w << (wchar_t)i;
  81                 tmp_os_w_encoded << (char)0 << (char)i;
  82         }
  83         teststring2 = tmp_os.str();
  84         teststring2_w = tmp_os_w.str();
  85         teststring2_w_encoded = tmp_os_w_encoded.str();
  86 }
  87
  88 void TestSerialization::testSerializeString()
  89 {
  90         // Test blank string
  91         UASSERT(serializeString("") == mkstr("\0\0"));
  92
  93         // Test basic string
  94         UASSERT(serializeString("Hello world!") == mkstr("\0\14Hello world!"));
  95
  96         // Test character range
  97         UASSERT(serializeString(teststring2) == mkstr("\1\0") + teststring2);
  98 }
  99
 100 void TestSerialization::testDeSerializeString()
 101 {
 102         // Test deserialize
 103         {
 104                 std::istringstream is(serializeString(teststring2), std::ios::binary);
 105                 UASSERT(deSerializeString(is) == teststring2);
 106                 UASSERT(!is.eof());
 107                 is.get();
 108                 UASSERT(is.eof());
 109         }
 110
 111         // Test deserialize an incomplete length specifier
 112         {
 113                 std::istringstream is(mkstr("\x53"), std::ios::binary);
 114                 EXCEPTION_CHECK(SerializationError, deSerializeString(is));
 115         }
 116
 117         // Test deserialize a string with incomplete data
 118         {
 119                 std::istringstream is(mkstr("\x00\x55 abcdefg"), std::ios::binary);
 120                 EXCEPTION_CHECK(SerializationError, deSerializeString(is));
 121         }
 122 }
 123
 124 void TestSerialization::testSerializeWideString()
 125 {
 126         // Test blank string
 127         UASSERT(serializeWideString(L"") == mkstr("\0\0"));
 128
 129         // Test basic string
 130         UASSERT(serializeWideString(utf8_to_wide("Hello world!")) ==
 131                 mkstr("\0\14\0H\0e\0l\0l\0o\0 \0w\0o\0r\0l\0d\0!"));
 132
 133         // Test character range
 134         UASSERT(serializeWideString(teststring2_w) ==
 135                 mkstr("\1\0") + teststring2_w_encoded);
 136 }
 137
 138 void TestSerialization::testDeSerializeWideString()
 139 {
 140         // Test deserialize
 141         {
 142                 std::istringstream is(serializeWideString(teststring2_w), std::ios::binary);
 143                 UASSERT(deSerializeWideString(is) == teststring2_w);
 144                 UASSERT(!is.eof());
 145                 is.get();
 146                 UASSERT(is.eof());
 147         }
 148
 149         // Test deserialize an incomplete length specifier
 150         {
 151                 std::istringstream is(mkstr("\x53"), std::ios::binary);
 152                 EXCEPTION_CHECK(SerializationError, deSerializeWideString(is));
 153         }
 154
 155         // Test deserialize a string with an incomplete character
 156         {
 157                 std::istringstream is(mkstr("\x00\x07\0a\0b\0c\0d\0e\0f\0"), std::ios::binary);
 158                 EXCEPTION_CHECK(SerializationError, deSerializeWideString(is));
 159         }
 160
 161         // Test deserialize a string with incomplete data
 162         {
 163                 std::istringstream is(mkstr("\x00\x08\0a\0b\0c\0d\0e\0f"), std::ios::binary);
 164                 EXCEPTION_CHECK(SerializationError, deSerializeWideString(is));
 165         }
 166 }
 167
 168 void TestSerialization::testSerializeLongString()
 169 {
 170         // Test blank string
 171         UASSERT(serializeLongString("") == mkstr("\0\0\0\0"));
 172
 173         // Test basic string
 174         UASSERT(serializeLongString("Hello world!") == mkstr("\0\0\0\14Hello world!"));
 175
 176         // Test character range
 177         UASSERT(serializeLongString(teststring2) == mkstr("\0\0\1\0") + teststring2);
 178 }
 179
 180 void TestSerialization::testDeSerializeLongString()
 181 {
 182         // Test deserialize
 183         {
 184                 std::istringstream is(serializeLongString(teststring2), std::ios::binary);
 185                 UASSERT(deSerializeLongString(is) == teststring2);
 186                 UASSERT(!is.eof());
 187                 is.get();
 188                 UASSERT(is.eof());
 189         }
 190
 191         // Test deserialize an incomplete length specifier
 192         {
 193                 std::istringstream is(mkstr("\x53"), std::ios::binary);
 194                 EXCEPTION_CHECK(SerializationError, deSerializeLongString(is));
 195         }
 196
 197         // Test deserialize a string with incomplete data
 198         {
 199                 std::istringstream is(mkstr("\x00\x00\x00\x05 abc"), std::ios::binary);
 200                 EXCEPTION_CHECK(SerializationError, deSerializeLongString(is));
 201         }
 202
 203         // Test deserialize a string with a length too large
 204         {
 205                 std::istringstream is(mkstr("\xFF\xFF\xFF\xFF blah"), std::ios::binary);
 206                 EXCEPTION_CHECK(SerializationError, deSerializeLongString(is));
 207         }
 208 }
 209
 210
 211 void TestSerialization::testSerializeJsonString()
 212 {
 213         // Test blank string
 214         UASSERT(serializeJsonString("") == "\"\"");
 215
 216         // Test basic string
 217         UASSERT(serializeJsonString("Hello world!") == "\"Hello world!\"");
 218
 219         // MSVC fails when directly using "\\\\"
 220         std::string backslash = "\\";
 221         UASSERT(serializeJsonString(teststring2) ==
 222                 mkstr("\"") +
 223                 "\\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007" +
 224                 "\\b\\t\\n\\u000b\\f\\r\\u000e\\u000f" +
 225                 "\\u0010\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017" +
 226                 "\\u0018\\u0019\\u001a\\u001b\\u001c\\u001d\\u001e\\u001f" +
 227                 " !\\\"" + teststring2.substr(0x23, 0x2f-0x23) +
 228                 "\\/" + teststring2.substr(0x30, 0x5c-0x30) +
 229                 backslash + backslash + teststring2.substr(0x5d, 0x7f-0x5d) + "\\u007f" +
 230                 "\\u0080\\u0081\\u0082\\u0083\\u0084\\u0085\\u0086\\u0087" +
 231                 "\\u0088\\u0089\\u008a\\u008b\\u008c\\u008d\\u008e\\u008f" +
 232                 "\\u0090\\u0091\\u0092\\u0093\\u0094\\u0095\\u0096\\u0097" +
 233                 "\\u0098\\u0099\\u009a\\u009b\\u009c\\u009d\\u009e\\u009f" +
 234                 "\\u00a0\\u00a1\\u00a2\\u00a3\\u00a4\\u00a5\\u00a6\\u00a7" +
 235                 "\\u00a8\\u00a9\\u00aa\\u00ab\\u00ac\\u00ad\\u00ae\\u00af" +
 236                 "\\u00b0\\u00b1\\u00b2\\u00b3\\u00b4\\u00b5\\u00b6\\u00b7" +
 237                 "\\u00b8\\u00b9\\u00ba\\u00bb\\u00bc\\u00bd\\u00be\\u00bf" +
 238                 "\\u00c0\\u00c1\\u00c2\\u00c3\\u00c4\\u00c5\\u00c6\\u00c7" +
 239                 "\\u00c8\\u00c9\\u00ca\\u00cb\\u00cc\\u00cd\\u00ce\\u00cf" +
 240                 "\\u00d0\\u00d1\\u00d2\\u00d3\\u00d4\\u00d5\\u00d6\\u00d7" +
 241                 "\\u00d8\\u00d9\\u00da\\u00db\\u00dc\\u00dd\\u00de\\u00df" +
 242                 "\\u00e0\\u00e1\\u00e2\\u00e3\\u00e4\\u00e5\\u00e6\\u00e7" +
 243                 "\\u00e8\\u00e9\\u00ea\\u00eb\\u00ec\\u00ed\\u00ee\\u00ef" +
 244                 "\\u00f0\\u00f1\\u00f2\\u00f3\\u00f4\\u00f5\\u00f6\\u00f7" +
 245                 "\\u00f8\\u00f9\\u00fa\\u00fb\\u00fc\\u00fd\\u00fe\\u00ff" +
 246                 "\"");
 247
 248         // Test deserialize
 249         std::istringstream is(serializeJsonString(teststring2), std::ios::binary);
 250         UASSERT(deSerializeJsonString(is) == teststring2);
 251         UASSERT(!is.eof());
 252         is.get();
 253         UASSERT(is.eof());
 254 }
 255
 256 void TestSerialization::testSerializeHex()
 257 {
 258         // Test blank string
 259         UASSERT(serializeHexString("") == "");
 260         UASSERT(serializeHexString("", true) == "");
 261
 262         // Test basic string
 263         UASSERT(serializeHexString("Hello world!") ==
 264                 "48656c6c6f20776f726c6421");
 265         UASSERT(serializeHexString("Hello world!", true) ==
 266                 "48 65 6c 6c 6f 20 77 6f 72 6c 64 21");
 267
 268         // Test binary string
 269         UASSERT(serializeHexString(mkstr("\x00\x0a\xb0\x63\x1f\x00\xff")) ==
 270                 "000ab0631f00ff");
 271         UASSERT(serializeHexString(mkstr("\x00\x0a\xb0\x63\x1f\x00\xff"), true) ==
 272                 "00 0a b0 63 1f 00 ff");
 273 }