mirror of
https://github.com/solemnwarning/directplay-lite
synced 2024-12-30 16:45:37 +01:00
733 lines
19 KiB
C++
733 lines
19 KiB
C++
/* DirectPlay Lite
|
|
* Copyright (C) 2018 Daniel Collins <solemnwarning@solemnwarning.net>
|
|
*
|
|
* 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 <gtest/gtest.h>
|
|
|
|
#include "../src/packet.hpp"
|
|
|
|
class PacketDeserialiserTest: public ::testing::Test {
|
|
protected:
|
|
PacketDeserialiser *pd;
|
|
|
|
PacketDeserialiserTest(): pd(NULL) {}
|
|
|
|
virtual ~PacketDeserialiserTest()
|
|
{
|
|
delete pd;
|
|
}
|
|
};
|
|
|
|
class PacketDeserialiserEmpty: public PacketDeserialiserTest {
|
|
protected:
|
|
virtual void SetUp() override
|
|
{
|
|
static const unsigned char RAW[] = {
|
|
0x01, 0x00, 0x00, 0x00, /* type */
|
|
0x00, 0x00, 0x00, 0x00, /* value_length */
|
|
};
|
|
|
|
ASSERT_NO_THROW({ pd = new PacketDeserialiser(RAW, sizeof(RAW)); });
|
|
}
|
|
};
|
|
|
|
TEST_F(PacketDeserialiserEmpty, Type)
|
|
{
|
|
EXPECT_EQ(pd->packet_type(), (uint32_t)(1));
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserEmpty, NumFields)
|
|
{
|
|
EXPECT_EQ(pd->num_fields(), (size_t)(0));
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserEmpty, IsNull)
|
|
{
|
|
EXPECT_THROW({ pd->is_null(0); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserEmpty, GetDWORD)
|
|
{
|
|
EXPECT_THROW({ pd->get_dword(0); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserEmpty, GetData)
|
|
{
|
|
EXPECT_THROW({ pd->get_data(0); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserEmpty, GetWString)
|
|
{
|
|
EXPECT_THROW({ pd->get_wstring(0); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserEmpty, GetGUID)
|
|
{
|
|
EXPECT_THROW({ pd->get_guid(0); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
class PacketDeserialiserNull: public PacketDeserialiserTest {
|
|
protected:
|
|
virtual void SetUp() override
|
|
{
|
|
static const unsigned char RAW[] = {
|
|
0x02, 0x00, 0x00, 0x00, /* type */
|
|
0x08, 0x00, 0x00, 0x00, /* value_length */
|
|
|
|
0x00, 0x00, 0x00, 0x00, /* type */
|
|
0x00, 0x00, 0x00, 0x00, /* value_length */
|
|
};
|
|
|
|
ASSERT_NO_THROW({ pd = new PacketDeserialiser(RAW, sizeof(RAW)); });
|
|
}
|
|
};
|
|
|
|
TEST_F(PacketDeserialiserNull, Type)
|
|
{
|
|
EXPECT_EQ(pd->packet_type(), (uint32_t)(2));
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserNull, NumFields)
|
|
{
|
|
EXPECT_EQ(pd->num_fields(), (size_t)(1));
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserNull, IsNull)
|
|
{
|
|
EXPECT_NO_THROW({ EXPECT_EQ(pd->is_null(0), true); });
|
|
EXPECT_THROW({ pd->is_null(1); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserNull, GetDWORD)
|
|
{
|
|
EXPECT_THROW({ pd->get_dword(0); }, PacketDeserialiser::Error::TypeMismatch);
|
|
EXPECT_THROW({ pd->get_dword(1); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserNull, GetData)
|
|
{
|
|
EXPECT_THROW({ pd->get_data(0); }, PacketDeserialiser::Error::TypeMismatch);
|
|
EXPECT_THROW({ pd->get_data(1); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserNull, GetWString)
|
|
{
|
|
EXPECT_THROW({ pd->get_wstring(0); }, PacketDeserialiser::Error::TypeMismatch);
|
|
EXPECT_THROW({ pd->get_wstring(1); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserNull, GetGUID)
|
|
{
|
|
EXPECT_THROW({ pd->get_guid(0); }, PacketDeserialiser::Error::TypeMismatch);
|
|
EXPECT_THROW({ pd->get_guid(1); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
class PacketDeserialiserDWORD: public PacketDeserialiserTest {
|
|
protected:
|
|
virtual void SetUp() override
|
|
{
|
|
static const unsigned char RAW[] = {
|
|
0x03, 0x00, 0x00, 0x00, /* type */
|
|
0x0C, 0x00, 0x00, 0x00, /* value_length */
|
|
|
|
0x01, 0x00, 0x00, 0x00, /* type */
|
|
0x04, 0x00, 0x00, 0x00, /* value_length */
|
|
0x01, 0x23, 0x45, 0x67, /* value */
|
|
};
|
|
|
|
ASSERT_NO_THROW({ pd = new PacketDeserialiser(RAW, sizeof(RAW)); });
|
|
}
|
|
};
|
|
|
|
TEST_F(PacketDeserialiserDWORD, Type)
|
|
{
|
|
EXPECT_EQ(pd->packet_type(), (uint32_t)(3));
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserDWORD, NumFields)
|
|
{
|
|
EXPECT_EQ(pd->num_fields(), (size_t)(1));
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserDWORD, IsNull)
|
|
{
|
|
EXPECT_NO_THROW({ EXPECT_EQ(pd->is_null(0), false); });
|
|
EXPECT_THROW({ pd->is_null(1); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserDWORD, GetDWORD)
|
|
{
|
|
EXPECT_NO_THROW({ EXPECT_EQ(pd->get_dword(0), (DWORD)(0x67452301)); });
|
|
EXPECT_THROW({ pd->get_dword(1); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserDWORD, GetData)
|
|
{
|
|
EXPECT_THROW({ pd->get_data(0); }, PacketDeserialiser::Error::TypeMismatch);
|
|
EXPECT_THROW({ pd->get_data(1); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserDWORD, GetWString)
|
|
{
|
|
EXPECT_THROW({ pd->get_wstring(0); }, PacketDeserialiser::Error::TypeMismatch);
|
|
EXPECT_THROW({ pd->get_wstring(1); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserDWORD, GetGUID)
|
|
{
|
|
EXPECT_THROW({ pd->get_guid(0); }, PacketDeserialiser::Error::TypeMismatch);
|
|
EXPECT_THROW({ pd->get_guid(1); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
class PacketDeserialiserData: public PacketDeserialiserTest {
|
|
protected:
|
|
virtual void SetUp() override
|
|
{
|
|
static const unsigned char RAW[] = {
|
|
0x04, 0x00, 0x00, 0x00, /* type */
|
|
0x0E, 0x00, 0x00, 0x00, /* value_length */
|
|
|
|
0x02, 0x00, 0x00, 0x00, /* type */
|
|
0x06, 0x00, 0x00, 0x00, /* value_length */
|
|
0xFE, 0xED, 0xBE, 0xEF, /* value */
|
|
0xAA, 0xAA,
|
|
};
|
|
|
|
ASSERT_NO_THROW({ pd = new PacketDeserialiser(RAW, sizeof(RAW)); });
|
|
}
|
|
};
|
|
|
|
TEST_F(PacketDeserialiserData, Type)
|
|
{
|
|
EXPECT_EQ(pd->packet_type(), (uint32_t)(4));
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserData, NumFields)
|
|
{
|
|
EXPECT_EQ(pd->num_fields(), (size_t)(1));
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserData, IsNull)
|
|
{
|
|
EXPECT_NO_THROW({ EXPECT_EQ(pd->is_null(0), false); });
|
|
EXPECT_THROW({ pd->is_null(1); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserData, GetDWORD)
|
|
{
|
|
EXPECT_THROW({ pd->get_dword(0); }, PacketDeserialiser::Error::TypeMismatch);
|
|
EXPECT_THROW({ pd->get_dword(1); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserData, GetData)
|
|
{
|
|
const unsigned char EXPECT[] = { 0xFE, 0xED, 0xBE, 0xEF, 0xAA, 0xAA };
|
|
std::pair<const void*, size_t> got;
|
|
|
|
ASSERT_NO_THROW({ got = pd->get_data(0); });
|
|
|
|
std::vector<unsigned char> got_data ((const unsigned char*)(got.first), (const unsigned char*)(got.first) + got.second);
|
|
std::vector<unsigned char> expect_data(EXPECT, EXPECT + sizeof(EXPECT));
|
|
|
|
EXPECT_EQ(got_data, expect_data);
|
|
|
|
EXPECT_THROW({ pd->get_data(1); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserData, GetWString)
|
|
{
|
|
EXPECT_THROW({ pd->get_wstring(0); }, PacketDeserialiser::Error::TypeMismatch);
|
|
EXPECT_THROW({ pd->get_wstring(1); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserData, GetGUID)
|
|
{
|
|
EXPECT_THROW({ pd->get_guid(0); }, PacketDeserialiser::Error::TypeMismatch);
|
|
EXPECT_THROW({ pd->get_guid(1); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
class PacketDeserialiserWString: public PacketDeserialiserTest {
|
|
protected:
|
|
virtual void SetUp() override
|
|
{
|
|
static const unsigned char RAW[] = {
|
|
0x05, 0x00, 0x00, 0x00, /* type */
|
|
0x12, 0x00, 0x00, 0x00, /* value_length */
|
|
|
|
0x03, 0x00, 0x00, 0x00, /* type */
|
|
0x0A, 0x00, 0x00, 0x00, /* value_length */
|
|
0x48, 0x00, 0x65, 0x00, /* value */
|
|
0x6C, 0x00, 0x6C, 0x00,
|
|
0x6F, 0x00,
|
|
};
|
|
|
|
ASSERT_NO_THROW({ pd = new PacketDeserialiser(RAW, sizeof(RAW)); });
|
|
}
|
|
};
|
|
|
|
TEST_F(PacketDeserialiserWString, Type)
|
|
{
|
|
EXPECT_EQ(pd->packet_type(), (uint32_t)(5));
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserWString, NumFields)
|
|
{
|
|
EXPECT_EQ(pd->num_fields(), (size_t)(1));
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserWString, IsNull)
|
|
{
|
|
EXPECT_NO_THROW({ EXPECT_EQ(pd->is_null(0), false); });
|
|
EXPECT_THROW({ pd->is_null(1); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserWString, GetDWORD)
|
|
{
|
|
EXPECT_THROW({ pd->get_dword(0); }, PacketDeserialiser::Error::TypeMismatch);
|
|
EXPECT_THROW({ pd->get_dword(1); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserWString, GetData)
|
|
{
|
|
EXPECT_THROW({ pd->get_data(0); }, PacketDeserialiser::Error::TypeMismatch);
|
|
EXPECT_THROW({ pd->get_data(1); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserWString, GetWString)
|
|
{
|
|
EXPECT_NO_THROW({ EXPECT_EQ(pd->get_wstring(0), L"Hello"); });
|
|
EXPECT_THROW({ pd->get_wstring(1); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserWString, GetGUID)
|
|
{
|
|
EXPECT_THROW({ pd->get_guid(0); }, PacketDeserialiser::Error::TypeMismatch);
|
|
EXPECT_THROW({ pd->get_guid(1); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
class PacketDeserialiserGUID: public PacketDeserialiserTest {
|
|
protected:
|
|
virtual void SetUp() override
|
|
{
|
|
static const unsigned char RAW[] = {
|
|
0x06, 0x00, 0x00, 0x00, /* type */
|
|
0x18, 0x00, 0x00, 0x00, /* value_length */
|
|
|
|
0x04, 0x00, 0x00, 0x00, /* type */
|
|
0x10, 0x00, 0x00, 0x00, /* value_length */
|
|
0x01, 0x23, 0x45, 0x67, /* value */
|
|
0x89, 0x1A, 0xBC, 0xDE,
|
|
0xF0, 0x12, 0x34, 0x56,
|
|
0x78, 0x91, 0xAB, 0xCD,
|
|
};
|
|
|
|
ASSERT_NO_THROW({ pd = new PacketDeserialiser(RAW, sizeof(RAW)); });
|
|
}
|
|
};
|
|
|
|
TEST_F(PacketDeserialiserGUID, Type)
|
|
{
|
|
EXPECT_EQ(pd->packet_type(), (uint32_t)(6));
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserGUID, NumFields)
|
|
{
|
|
EXPECT_EQ(pd->num_fields(), (size_t)(1));
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserGUID, IsNull)
|
|
{
|
|
EXPECT_NO_THROW({ EXPECT_EQ(pd->is_null(0), false); });
|
|
EXPECT_THROW({ pd->is_null(1); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserGUID, GetDWORD)
|
|
{
|
|
EXPECT_THROW({ pd->get_dword(0); }, PacketDeserialiser::Error::TypeMismatch);
|
|
EXPECT_THROW({ pd->get_dword(1); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserGUID, GetData)
|
|
{
|
|
EXPECT_THROW({ pd->get_data(0); }, PacketDeserialiser::Error::TypeMismatch);
|
|
EXPECT_THROW({ pd->get_data(1); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserGUID, GetWString)
|
|
{
|
|
EXPECT_THROW({ pd->get_wstring(0); }, PacketDeserialiser::Error::TypeMismatch);
|
|
EXPECT_THROW({ pd->get_wstring(1); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserGUID, GetGUID)
|
|
{
|
|
const GUID EXPECT = { 0x67452301, 0x1A89, 0xDEBC, { 0xF0, 0x12, 0x34, 0x56, 0x78, 0x91, 0xAB, 0xCD } };
|
|
|
|
EXPECT_NO_THROW({ EXPECT_EQ(pd->get_guid(0), EXPECT); });
|
|
EXPECT_THROW({ pd->get_guid(1); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
class PacketDeserialiserNullDWORDDataWString: public PacketDeserialiserTest {
|
|
protected:
|
|
virtual void SetUp() override
|
|
{
|
|
static const unsigned char RAW[] = {
|
|
0x34, 0x12, 0x00, 0x00, /* type */
|
|
0x31, 0x00, 0x00, 0x00, /* value_length (49) */
|
|
|
|
0x00, 0x00, 0x00, 0x00, /* type */
|
|
0x00, 0x00, 0x00, 0x00, /* value_length */
|
|
|
|
0x01, 0x00, 0x00, 0x00, /* type */
|
|
0x04, 0x00, 0x00, 0x00, /* value_length */
|
|
0xFE, 0xED, 0x00, 0x00, /* value */
|
|
|
|
0x02, 0x00, 0x00, 0x00, /* type */
|
|
0x05, 0x00, 0x00, 0x00, /* value_length */
|
|
0x01, 0x23, 0x45, 0x67, /* value */
|
|
0x89,
|
|
|
|
0x03, 0x00, 0x00, 0x00, /* type */
|
|
0x08, 0x00, 0x00, 0x00, /* value_length */
|
|
0x57, 0x00, 0x53, 0x00, /* value */
|
|
0x74, 0x00, 0x72, 0x00,
|
|
};
|
|
|
|
ASSERT_NO_THROW({ pd = new PacketDeserialiser(RAW, sizeof(RAW)); });
|
|
}
|
|
};
|
|
|
|
TEST_F(PacketDeserialiserNullDWORDDataWString, Type)
|
|
{
|
|
EXPECT_EQ(pd->packet_type(), (uint32_t)(0x1234));
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserNullDWORDDataWString, NumFields)
|
|
{
|
|
EXPECT_EQ(pd->num_fields(), (size_t)(4));
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserNullDWORDDataWString, IsNull)
|
|
{
|
|
EXPECT_NO_THROW({ EXPECT_EQ(pd->is_null(0), true); });
|
|
EXPECT_NO_THROW({ EXPECT_EQ(pd->is_null(1), false); });
|
|
EXPECT_NO_THROW({ EXPECT_EQ(pd->is_null(2), false); });
|
|
EXPECT_NO_THROW({ EXPECT_EQ(pd->is_null(3), false); });
|
|
|
|
EXPECT_THROW({ pd->is_null(4); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserNullDWORDDataWString, GetDWORD)
|
|
{
|
|
EXPECT_THROW({ pd->get_dword(0); }, PacketDeserialiser::Error::TypeMismatch);
|
|
EXPECT_NO_THROW({ EXPECT_EQ(pd->get_dword(1), (DWORD)(0xEDFE)); });
|
|
EXPECT_THROW({ pd->get_dword(2); }, PacketDeserialiser::Error::TypeMismatch);
|
|
EXPECT_THROW({ pd->get_dword(3); }, PacketDeserialiser::Error::TypeMismatch);
|
|
EXPECT_THROW({ pd->get_dword(4); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserNullDWORDDataWString, GetData)
|
|
{
|
|
const unsigned char EXPECT[] = { 0x01, 0x23, 0x45, 0x67, 0x89 };
|
|
std::pair<const void*, size_t> got;
|
|
|
|
ASSERT_NO_THROW({ got = pd->get_data(2); });
|
|
|
|
std::vector<unsigned char> got_data ((const unsigned char*)(got.first), (const unsigned char*)(got.first) + got.second);
|
|
std::vector<unsigned char> expect_data(EXPECT, EXPECT + sizeof(EXPECT));
|
|
|
|
EXPECT_EQ(got_data, expect_data);
|
|
|
|
EXPECT_THROW({ pd->get_data(0); }, PacketDeserialiser::Error::TypeMismatch);
|
|
EXPECT_THROW({ pd->get_data(1); }, PacketDeserialiser::Error::TypeMismatch);
|
|
EXPECT_THROW({ pd->get_data(3); }, PacketDeserialiser::Error::TypeMismatch);
|
|
EXPECT_THROW({ pd->get_data(4); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST_F(PacketDeserialiserNullDWORDDataWString, GetWString)
|
|
{
|
|
EXPECT_THROW({ pd->get_wstring(0); }, PacketDeserialiser::Error::TypeMismatch);
|
|
EXPECT_THROW({ pd->get_wstring(1); }, PacketDeserialiser::Error::TypeMismatch);
|
|
EXPECT_THROW({ pd->get_wstring(2); }, PacketDeserialiser::Error::TypeMismatch);
|
|
EXPECT_NO_THROW({ EXPECT_EQ(pd->get_wstring(3), L"WStr"); });
|
|
EXPECT_THROW({ pd->get_wstring(4); }, PacketDeserialiser::Error::MissingField);
|
|
}
|
|
|
|
TEST(PacketDeserialiser, NoData)
|
|
{
|
|
EXPECT_THROW({ PacketDeserialiser p(NULL, 0); }, PacketDeserialiser::Error::Incomplete);
|
|
}
|
|
|
|
TEST(PacketDeserialiser, PartialHeader)
|
|
{
|
|
const unsigned char RAW[] = {
|
|
0x01, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00,
|
|
};
|
|
|
|
EXPECT_THROW({ PacketDeserialiser p(RAW, sizeof(RAW)); }, PacketDeserialiser::Error::Incomplete);
|
|
}
|
|
|
|
TEST(PacketDeserialiser, PartialData)
|
|
{
|
|
const unsigned char RAW[] = {
|
|
0x01, 0x00, 0x00, 0x00,
|
|
0x04, 0x00, 0x00, 0x00,
|
|
|
|
0x00, 0x00, 0x00,
|
|
};
|
|
|
|
EXPECT_THROW({ PacketDeserialiser p(RAW, sizeof(RAW)); }, PacketDeserialiser::Error::Incomplete);
|
|
}
|
|
|
|
TEST(PacketDeserialiser, ExtraData)
|
|
{
|
|
const unsigned char RAW[] = {
|
|
0x01, 0x00, 0x00, 0x00,
|
|
0x08, 0x00, 0x00, 0x00,
|
|
|
|
0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x00, 0x00
|
|
};
|
|
|
|
EXPECT_NO_THROW({ PacketDeserialiser p(RAW, sizeof(RAW)); });
|
|
}
|
|
|
|
TEST(PacketDeserialiser, FieldShortHeader)
|
|
{
|
|
const unsigned char RAW[] = {
|
|
0x01, 0x00, 0x00, 0x00,
|
|
0x07, 0x00, 0x00, 0x00,
|
|
|
|
0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00,
|
|
};
|
|
|
|
EXPECT_THROW({ PacketDeserialiser p(RAW, sizeof(RAW)); }, PacketDeserialiser::Error::Malformed);
|
|
}
|
|
|
|
TEST(PacketDeserialiser, FieldTooShort)
|
|
{
|
|
const unsigned char RAW[] = {
|
|
0x01, 0x00, 0x00, 0x00,
|
|
0x09, 0x00, 0x00, 0x00,
|
|
|
|
0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x00,
|
|
};
|
|
|
|
EXPECT_THROW({ PacketDeserialiser p(RAW, sizeof(RAW)); }, PacketDeserialiser::Error::Malformed);
|
|
}
|
|
|
|
TEST(PacketDeserialiser, FieldTooLong)
|
|
{
|
|
const unsigned char RAW[] = {
|
|
0x01, 0x00, 0x00, 0x00,
|
|
0x09, 0x00, 0x00, 0x00,
|
|
|
|
0x00, 0x00, 0x00, 0x00,
|
|
0x02, 0x00, 0x00, 0x00,
|
|
|
|
0x00,
|
|
};
|
|
|
|
EXPECT_THROW({ PacketDeserialiser p(RAW, sizeof(RAW)); }, PacketDeserialiser::Error::Malformed);
|
|
}
|
|
|
|
TEST(PacketDeserialiser, ZeroLengthDWORD)
|
|
{
|
|
const unsigned char RAW[] = {
|
|
0x01, 0x00, 0x00, 0x00,
|
|
0x08, 0x00, 0x00, 0x00,
|
|
|
|
0x01, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00,
|
|
};
|
|
|
|
PacketDeserialiser *pd = NULL;
|
|
|
|
ASSERT_NO_THROW({ pd = new PacketDeserialiser(RAW, sizeof(RAW)); });
|
|
EXPECT_THROW({ pd->get_dword(0); }, PacketDeserialiser::Error::Malformed);
|
|
|
|
delete pd;
|
|
}
|
|
|
|
TEST(PacketDeserialiser, UndersizeDWORD)
|
|
{
|
|
const unsigned char RAW[] = {
|
|
0x01, 0x00, 0x00, 0x00,
|
|
0x0B, 0x00, 0x00, 0x00,
|
|
|
|
0x01, 0x00, 0x00, 0x00,
|
|
0x03, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00,
|
|
};
|
|
|
|
PacketDeserialiser *pd = NULL;
|
|
|
|
ASSERT_NO_THROW({ pd = new PacketDeserialiser(RAW, sizeof(RAW)); });
|
|
EXPECT_THROW({ pd->get_dword(0); }, PacketDeserialiser::Error::Malformed);
|
|
|
|
delete pd;
|
|
}
|
|
|
|
TEST(PacketDeserialiser, OversizeDWORD)
|
|
{
|
|
const unsigned char RAW[] = {
|
|
0x01, 0x00, 0x00, 0x00,
|
|
0x0D, 0x00, 0x00, 0x00,
|
|
|
|
0x01, 0x00, 0x00, 0x00,
|
|
0x05, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00,
|
|
0x00
|
|
};
|
|
|
|
PacketDeserialiser *pd = NULL;
|
|
|
|
ASSERT_NO_THROW({ pd = new PacketDeserialiser(RAW, sizeof(RAW)); });
|
|
EXPECT_THROW({ pd->get_dword(0); }, PacketDeserialiser::Error::Malformed);
|
|
|
|
delete pd;
|
|
}
|
|
|
|
TEST(PacketDeserialiser, ZeroLengthData)
|
|
{
|
|
const unsigned char RAW[] = {
|
|
0x01, 0x00, 0x00, 0x00,
|
|
0x08, 0x00, 0x00, 0x00,
|
|
|
|
0x02, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00,
|
|
};
|
|
|
|
PacketDeserialiser *pd = NULL;
|
|
|
|
ASSERT_NO_THROW({ pd = new PacketDeserialiser(RAW, sizeof(RAW)); });
|
|
|
|
EXPECT_NO_THROW({
|
|
auto data = pd->get_data(0);
|
|
EXPECT_EQ(data.second, (size_t)(0));
|
|
});
|
|
|
|
delete pd;
|
|
}
|
|
|
|
TEST(PacketDeserialiser, ZeroLengthWString)
|
|
{
|
|
const unsigned char RAW[] = {
|
|
0x01, 0x00, 0x00, 0x00,
|
|
0x08, 0x00, 0x00, 0x00,
|
|
|
|
0x03, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00,
|
|
};
|
|
|
|
PacketDeserialiser *pd = NULL;
|
|
|
|
ASSERT_NO_THROW({ pd = new PacketDeserialiser(RAW, sizeof(RAW)); });
|
|
EXPECT_NO_THROW({ EXPECT_EQ(pd->get_wstring(0), L""); });
|
|
|
|
delete pd;
|
|
}
|
|
|
|
TEST(PacketDeserialiser, OneByteWString)
|
|
{
|
|
const unsigned char RAW[] = {
|
|
0x01, 0x00, 0x00, 0x00,
|
|
0x09, 0x00, 0x00, 0x00,
|
|
|
|
0x03, 0x00, 0x00, 0x00,
|
|
0x01, 0x00, 0x00, 0x00,
|
|
0x00,
|
|
};
|
|
|
|
PacketDeserialiser *pd = NULL;
|
|
|
|
ASSERT_NO_THROW({ pd = new PacketDeserialiser(RAW, sizeof(RAW)); });
|
|
EXPECT_THROW({ pd->get_wstring(0); }, PacketDeserialiser::Error::Malformed);
|
|
|
|
delete pd;
|
|
}
|
|
|
|
TEST(PacketDeserialiser, ZeroLengthGUID)
|
|
{
|
|
const unsigned char RAW[] = {
|
|
0x01, 0x00, 0x00, 0x00,
|
|
0x08, 0x00, 0x00, 0x00,
|
|
|
|
0x04, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00,
|
|
};
|
|
|
|
PacketDeserialiser *pd = NULL;
|
|
|
|
ASSERT_NO_THROW({ pd = new PacketDeserialiser(RAW, sizeof(RAW)); });
|
|
EXPECT_THROW({ pd->get_guid(0); }, PacketDeserialiser::Error::Malformed);
|
|
|
|
delete pd;
|
|
}
|
|
|
|
TEST(PacketDeserialiser, UndersizeGUID)
|
|
{
|
|
static const unsigned char RAW[] = {
|
|
0x06, 0x00, 0x00, 0x00, /* type */
|
|
0x17, 0x00, 0x00, 0x00, /* value_length */
|
|
|
|
0x04, 0x00, 0x00, 0x00, /* type */
|
|
0x0F, 0x00, 0x00, 0x00, /* value_length */
|
|
0x01, 0x23, 0x45, 0x67, /* value */
|
|
0x89, 0x1A, 0xBC, 0xDE,
|
|
0xF0, 0x12, 0x34, 0x56,
|
|
0x78, 0x91, 0xAB,
|
|
};
|
|
|
|
PacketDeserialiser *pd = NULL;
|
|
|
|
ASSERT_NO_THROW({ pd = new PacketDeserialiser(RAW, sizeof(RAW)); });
|
|
EXPECT_THROW({ pd->get_guid(0); }, PacketDeserialiser::Error::Malformed);
|
|
|
|
delete pd;
|
|
}
|
|
|
|
TEST(PacketDeserialiser, OversizeGUID)
|
|
{
|
|
static const unsigned char RAW[] = {
|
|
0x06, 0x00, 0x00, 0x00, /* type */
|
|
0x19, 0x00, 0x00, 0x00, /* value_length */
|
|
|
|
0x04, 0x00, 0x00, 0x00, /* type */
|
|
0x11, 0x00, 0x00, 0x00, /* value_length */
|
|
0x01, 0x23, 0x45, 0x67, /* value */
|
|
0x89, 0x1A, 0xBC, 0xDE,
|
|
0xF0, 0x12, 0x34, 0x56,
|
|
0x78, 0x91, 0xAB, 0xCD,
|
|
0xAA,
|
|
};
|
|
|
|
PacketDeserialiser *pd = NULL;
|
|
|
|
ASSERT_NO_THROW({ pd = new PacketDeserialiser(RAW, sizeof(RAW)); });
|
|
EXPECT_THROW({ pd->get_guid(0); }, PacketDeserialiser::Error::Malformed);
|
|
|
|
delete pd;
|
|
}
|