Skip to content

Commit

Permalink
Clean up serialization
Browse files Browse the repository at this point in the history
This reverts 1a5b4b3 and further functions in serialize.cpp that are unused

The intend for a sane NetworkPacket/stream replacement was good, but a wrapper
class around i/ostream might be more versatile than introducing a new
vector-based serialization class.
  • Loading branch information
SmallJoker authored and nerzhul committed Oct 1, 2020
1 parent 79414aa commit ca5c2db
Show file tree
Hide file tree
Showing 3 changed files with 0 additions and 915 deletions.
324 changes: 0 additions & 324 deletions src/unittest/test_serialization.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -32,18 +32,12 @@ class TestSerialization : public TestBase {
void buildTestStrings();

void testSerializeString();
void testSerializeWideString();
void testSerializeLongString();
void testSerializeJsonString();
void testSerializeHex();
void testDeSerializeString();
void testDeSerializeWideString();
void testDeSerializeLongString();
void testStreamRead();
void testStreamWrite();
void testVecPut();
void testStringLengthLimits();
void testBufReader();
void testFloatFormat();

std::string teststring2;
Expand All @@ -61,17 +55,11 @@ void TestSerialization::runTests(IGameDef *gamedef)

TEST(testSerializeString);
TEST(testDeSerializeString);
TEST(testSerializeWideString);
TEST(testDeSerializeWideString);
TEST(testSerializeLongString);
TEST(testDeSerializeLongString);
TEST(testSerializeJsonString);
TEST(testSerializeHex);
TEST(testStreamRead);
TEST(testStreamWrite);
TEST(testVecPut);
TEST(testStringLengthLimits);
TEST(testBufReader);
TEST(testFloatFormat);
}

Expand Down Expand Up @@ -136,50 +124,6 @@ void TestSerialization::testDeSerializeString()
}
}

void TestSerialization::testSerializeWideString()
{
// Test blank string
UASSERT(serializeWideString(L"") == mkstr("\0\0"));

// Test basic string
UASSERT(serializeWideString(utf8_to_wide("Hello world!")) ==
mkstr("\0\14\0H\0e\0l\0l\0o\0 \0w\0o\0r\0l\0d\0!"));

// Test character range
UASSERT(serializeWideString(teststring2_w) ==
mkstr("\1\0") + teststring2_w_encoded);
}

void TestSerialization::testDeSerializeWideString()
{
// Test deserialize
{
std::istringstream is(serializeWideString(teststring2_w), std::ios::binary);
UASSERT(deSerializeWideString(is) == teststring2_w);
UASSERT(!is.eof());
is.get();
UASSERT(is.eof());
}

// Test deserialize an incomplete length specifier
{
std::istringstream is(mkstr("\x53"), std::ios::binary);
EXCEPTION_CHECK(SerializationError, deSerializeWideString(is));
}

// Test deserialize a string with an incomplete character
{
std::istringstream is(mkstr("\x00\x07\0a\0b\0c\0d\0e\0f\0"), std::ios::binary);
EXCEPTION_CHECK(SerializationError, deSerializeWideString(is));
}

// Test deserialize a string with incomplete data
{
std::istringstream is(mkstr("\x00\x08\0a\0b\0c\0d\0e\0f"), std::ios::binary);
EXCEPTION_CHECK(SerializationError, deSerializeWideString(is));
}
}

void TestSerialization::testSerializeLongString()
{
// Test blank string
Expand Down Expand Up @@ -268,25 +212,6 @@ void TestSerialization::testSerializeJsonString()
UASSERT(is.eof());
}

void TestSerialization::testSerializeHex()
{
// Test blank string
UASSERT(serializeHexString("") == "");
UASSERT(serializeHexString("", true) == "");

// Test basic string
UASSERT(serializeHexString("Hello world!") ==
"48656c6c6f20776f726c6421");
UASSERT(serializeHexString("Hello world!", true) ==
"48 65 6c 6c 6f 20 77 6f 72 6c 64 21");

// Test binary string
UASSERT(serializeHexString(mkstr("\x00\x0a\xb0\x63\x1f\x00\xff")) ==
"000ab0631f00ff");
UASSERT(serializeHexString(mkstr("\x00\x0a\xb0\x63\x1f\x00\xff"), true) ==
"00 0a b0 63 1f 00 ff");
}


void TestSerialization::testStreamRead()
{
Expand Down Expand Up @@ -376,255 +301,6 @@ void TestSerialization::testStreamWrite()
}


void TestSerialization::testVecPut()
{
std::vector<u8> buf;

putU8(&buf, 0x11);
putU16(&buf, 0x2233);
putU32(&buf, 0x44556677);
putU64(&buf, 0x8899AABBCCDDEEFFLL);

putS8(&buf, -128);
putS16(&buf, 30000);
putS32(&buf, -6);
putS64(&buf, -43);

putF1000(&buf, 53.53467f);
putF1000(&buf, -300000.32f);
putF1000(&buf, F1000_MIN);
putF1000(&buf, F1000_MAX);

putString(&buf, "foobar!");

putV2S16(&buf, v2s16(500, 500));
putV3S16(&buf, v3s16(4207, 604, -30));
putV2S32(&buf, v2s32(1920, 1080));
putV3S32(&buf, v3s32(-400, 6400054, 290549855));

putWideString(&buf, L"\x02~woof~\x5455");

putV3F1000(&buf, v3f(500, 10024.2f, -192.54f));
putARGB8(&buf, video::SColor(255, 128, 50, 128));

putLongString(&buf, "some longer string here");

putU16(&buf, 0xF00D);

UASSERT(buf.size() == sizeof(test_serialized_data));
UASSERT(!memcmp(&buf[0], test_serialized_data, sizeof(test_serialized_data)));
}


void TestSerialization::testStringLengthLimits()
{
std::vector<u8> buf;
std::string too_long(STRING_MAX_LEN + 1, 'A');
std::string way_too_large(LONG_STRING_MAX_LEN + 1, 'B');
std::wstring too_long_wide(WIDE_STRING_MAX_LEN + 1, L'C');

EXCEPTION_CHECK(SerializationError, putString(&buf, too_long));

putLongString(&buf, too_long);
too_long.resize(too_long.size() - 1);
putString(&buf, too_long);

EXCEPTION_CHECK(SerializationError, putWideString(&buf, too_long_wide));
too_long_wide.resize(too_long_wide.size() - 1);
putWideString(&buf, too_long_wide);
}


void TestSerialization::testBufReader()
{
u8 u8_data;
u16 u16_data;
u32 u32_data;
u64 u64_data;
s8 s8_data;
s16 s16_data;
s32 s32_data;
s64 s64_data;
f32 f32_data, f32_data2, f32_data3, f32_data4;
video::SColor scolor_data;
v2s16 v2s16_data;
v3s16 v3s16_data;
v2s32 v2s32_data;
v3s32 v3s32_data;
v3f v3f_data;
std::string string_data;
std::wstring widestring_data;
std::string longstring_data;
u8 raw_data[10] = {0};

BufReader buf(test_serialized_data, sizeof(test_serialized_data));

// Try reading data like normal
UASSERT(buf.getU8() == 0x11);
UASSERT(buf.getU16() == 0x2233);
UASSERT(buf.getU32() == 0x44556677);
UASSERT(buf.getU64() == 0x8899AABBCCDDEEFFLL);
UASSERT(buf.getS8() == -128);
UASSERT(buf.getS16() == 30000);
UASSERT(buf.getS32() == -6);
UASSERT(buf.getS64() == -43);
UASSERT(buf.getF1000() == 53.534f);
UASSERT(buf.getF1000() == -300000.32f);
UASSERT(buf.getF1000() == F1000_MIN);
UASSERT(buf.getF1000() == F1000_MAX);
UASSERT(buf.getString() == "foobar!");
UASSERT(buf.getV2S16() == v2s16(500, 500));
UASSERT(buf.getV3S16() == v3s16(4207, 604, -30));
UASSERT(buf.getV2S32() == v2s32(1920, 1080));
UASSERT(buf.getV3S32() == v3s32(-400, 6400054, 290549855));
UASSERT(buf.getWideString() == L"\x02~woof~\x5455");
UASSERT(buf.getV3F1000() == v3f(500, 10024.2f, -192.54f));
UASSERT(buf.getARGB8() == video::SColor(255, 128, 50, 128));
UASSERT(buf.getLongString() == "some longer string here");

// Verify the offset and data is unchanged after a failed read
size_t orig_pos = buf.pos;
u32_data = 0;
UASSERT(buf.getU32NoEx(&u32_data) == false);
UASSERT(buf.pos == orig_pos);
UASSERT(u32_data == 0);

// Now try the same for a failed string read
UASSERT(buf.getStringNoEx(&string_data) == false);
UASSERT(buf.pos == orig_pos);
UASSERT(string_data == "");

// Now try the same for a failed string read
UASSERT(buf.getWideStringNoEx(&widestring_data) == false);
UASSERT(buf.pos == orig_pos);
UASSERT(widestring_data == L"");

UASSERT(buf.getU16() == 0xF00D);

UASSERT(buf.remaining() == 0);

// Check to make sure these each blow exceptions as they're supposed to
EXCEPTION_CHECK(SerializationError, buf.getU8());
EXCEPTION_CHECK(SerializationError, buf.getU16());
EXCEPTION_CHECK(SerializationError, buf.getU32());
EXCEPTION_CHECK(SerializationError, buf.getU64());

EXCEPTION_CHECK(SerializationError, buf.getS8());
EXCEPTION_CHECK(SerializationError, buf.getS16());
EXCEPTION_CHECK(SerializationError, buf.getS32());
EXCEPTION_CHECK(SerializationError, buf.getS64());

EXCEPTION_CHECK(SerializationError, buf.getF1000());
EXCEPTION_CHECK(SerializationError, buf.getARGB8());

EXCEPTION_CHECK(SerializationError, buf.getV2S16());
EXCEPTION_CHECK(SerializationError, buf.getV3S16());
EXCEPTION_CHECK(SerializationError, buf.getV2S32());
EXCEPTION_CHECK(SerializationError, buf.getV3S32());
EXCEPTION_CHECK(SerializationError, buf.getV3F1000());

EXCEPTION_CHECK(SerializationError, buf.getString());
EXCEPTION_CHECK(SerializationError, buf.getWideString());
EXCEPTION_CHECK(SerializationError, buf.getLongString());
EXCEPTION_CHECK(SerializationError,
buf.getRawData(raw_data, sizeof(raw_data)));

// See if we can skip backwards
buf.pos = 5;
UASSERT(buf.getRawDataNoEx(raw_data, 3) == true);
UASSERT(raw_data[0] == 0x66);
UASSERT(raw_data[1] == 0x77);
UASSERT(raw_data[2] == 0x88);

UASSERT(buf.getU32() == 0x99AABBCC);
UASSERT(buf.pos == 12);

// Now let's try it all over again using the NoEx variants
buf.pos = 0;

UASSERT(buf.getU8NoEx(&u8_data));
UASSERT(buf.getU16NoEx(&u16_data));
UASSERT(buf.getU32NoEx(&u32_data));
UASSERT(buf.getU64NoEx(&u64_data));

UASSERT(buf.getS8NoEx(&s8_data));
UASSERT(buf.getS16NoEx(&s16_data));
UASSERT(buf.getS32NoEx(&s32_data));
UASSERT(buf.getS64NoEx(&s64_data));

UASSERT(buf.getF1000NoEx(&f32_data));
UASSERT(buf.getF1000NoEx(&f32_data2));
UASSERT(buf.getF1000NoEx(&f32_data3));
UASSERT(buf.getF1000NoEx(&f32_data4));

UASSERT(buf.getStringNoEx(&string_data));
UASSERT(buf.getV2S16NoEx(&v2s16_data));
UASSERT(buf.getV3S16NoEx(&v3s16_data));
UASSERT(buf.getV2S32NoEx(&v2s32_data));
UASSERT(buf.getV3S32NoEx(&v3s32_data));
UASSERT(buf.getWideStringNoEx(&widestring_data));
UASSERT(buf.getV3F1000NoEx(&v3f_data));
UASSERT(buf.getARGB8NoEx(&scolor_data));

UASSERT(buf.getLongStringNoEx(&longstring_data));

// and make sure we got the correct data
UASSERT(u8_data == 0x11);
UASSERT(u16_data == 0x2233);
UASSERT(u32_data == 0x44556677);
UASSERT(u64_data == 0x8899AABBCCDDEEFFLL);
UASSERT(s8_data == -128);
UASSERT(s16_data == 30000);
UASSERT(s32_data == -6);
UASSERT(s64_data == -43);
UASSERT(f32_data == 53.534f);
UASSERT(f32_data2 == -300000.32f);
UASSERT(f32_data3 == F1000_MIN);
UASSERT(f32_data4 == F1000_MAX);
UASSERT(string_data == "foobar!");
UASSERT(v2s16_data == v2s16(500, 500));
UASSERT(v3s16_data == v3s16(4207, 604, -30));
UASSERT(v2s32_data == v2s32(1920, 1080));
UASSERT(v3s32_data == v3s32(-400, 6400054, 290549855));
UASSERT(widestring_data == L"\x02~woof~\x5455");
UASSERT(v3f_data == v3f(500, 10024.2f, -192.54f));
UASSERT(scolor_data == video::SColor(255, 128, 50, 128));
UASSERT(longstring_data == "some longer string here");

UASSERT(buf.remaining() == 2);
UASSERT(buf.getRawDataNoEx(raw_data, 3) == false);
UASSERT(buf.remaining() == 2);
UASSERT(buf.getRawDataNoEx(raw_data, 2) == true);
UASSERT(raw_data[0] == 0xF0);
UASSERT(raw_data[1] == 0x0D);
UASSERT(buf.remaining() == 0);

// Make sure no more available data causes a failure
UASSERT(!buf.getU8NoEx(&u8_data));
UASSERT(!buf.getU16NoEx(&u16_data));
UASSERT(!buf.getU32NoEx(&u32_data));
UASSERT(!buf.getU64NoEx(&u64_data));

UASSERT(!buf.getS8NoEx(&s8_data));
UASSERT(!buf.getS16NoEx(&s16_data));
UASSERT(!buf.getS32NoEx(&s32_data));
UASSERT(!buf.getS64NoEx(&s64_data));

UASSERT(!buf.getF1000NoEx(&f32_data));
UASSERT(!buf.getARGB8NoEx(&scolor_data));

UASSERT(!buf.getV2S16NoEx(&v2s16_data));
UASSERT(!buf.getV3S16NoEx(&v3s16_data));
UASSERT(!buf.getV2S32NoEx(&v2s32_data));
UASSERT(!buf.getV3S32NoEx(&v3s32_data));
UASSERT(!buf.getV3F1000NoEx(&v3f_data));

UASSERT(!buf.getStringNoEx(&string_data));
UASSERT(!buf.getWideStringNoEx(&widestring_data));
UASSERT(!buf.getLongStringNoEx(&longstring_data));
UASSERT(!buf.getRawDataNoEx(raw_data, sizeof(raw_data)));
}

void TestSerialization::testFloatFormat()
{
FloatType type = getFloatSerializationType();
Expand Down
Loading

0 comments on commit ca5c2db

Please sign in to comment.