boost/mysql
2
0
Fork 0
mirror of https://github.com/boostorg/mysql.git synced 2026-02-15 01:02:17 +00:00
Code Issues Projects Releases Wiki Activity
Files
e3a067d32443c78c7876e9c65e0ec758dadf08fc
mysql/test/serialization.cpp
ruben e3a067d324 Increased warning level 
Now examples and tests compile with more strict warning levels
Now warnings are treated like errors
Now test has its own CMakeLists.txt
Solved several warnings
2020-01-12 14:17:10 +00:00

501 lines
18 KiB
C++
Raw Blame History

/*
* deserialization.cpp
*
* Created on: Jun 29, 2019
* Author: ruben
*/
#include "serialization_test_common.hpp"
using namespace testing;
using namespace std;
using namespace mysql;
using namespace mysql::detail;
namespace
{
template <std::size_t N>
inline std::string_view buffer_to_sv(const std::uint8_t (&buff)[N])
{
return std::string_view (reinterpret_cast<const char*>(buff), N);
}
struct DeserializeErrorParams
{
shared_ptr<TypeErasedValue> value;
vector<uint8_t> buffer;
string test_name;
Error expected_error;
template <typename T>
DeserializeErrorParams create(vector<uint8_t>&& buffer, string&& test_name, Error err = Error::incomplete_message)
{
return DeserializeErrorParams {
make_shared<TypeErasedValueImpl<T>>(T{}),
move(buffer),
move(test_name),
err
};
}
};
ostream& operator<<(ostream& os, const DeserializeErrorParams& params)
{
return os << params.value->get_type_name() << " - " << params.test_name;
}
// Special error conditions
struct DeserializeErrorTest : testing::TestWithParam<DeserializeErrorParams>
{
};
TEST_P(DeserializeErrorTest, Deserialize_ErrorCondition_ReturnsErrorCode)
{
auto first = GetParam().buffer.data();
auto last = GetParam().buffer.data() + GetParam().buffer.size();
DeserializationContext ctx (first, last, capabilities(0));
auto value = GetParam().value->default_construct();
auto err = value->deserialize(ctx);
EXPECT_EQ(err, GetParam().expected_error);
}
// Definitions for the parameterized tests
string string_250 (250, 'a');
string string_251 (251, 'a');
string string_ffff (0xffff, 'a');
string string_10000 (0x10000, 'a');
enum class EnumInt1 : uint8_t
{
value0 = 0,
value1 = 3,
value2 = 0xff
};
enum class EnumInt2 : uint16_t
{
value0 = 0,
value1 = 3,
value2 = 0xfeff
};
enum class EnumInt4 : uint32_t
{
value0 = 0,
value1 = 3,
value2 = 0xfcfdfeff
};
INSTANTIATE_TEST_SUITE_P(UnsignedFixedSizeInts, FullSerializationTest, ::testing::Values(
SerializeParams(int1{0xff}, {0xff}),
SerializeParams(int2{0xfeff}, {0xff, 0xfe}),
SerializeParams(int3{0xfdfeff}, {0xff, 0xfe, 0xfd}),
SerializeParams(int4{0xfcfdfeff}, {0xff, 0xfe, 0xfd, 0xfc}),
SerializeParams(int6{0xfafbfcfdfeff}, {0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa}),
SerializeParams(int8{0xf8f9fafbfcfdfeff}, {0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8})
));
INSTANTIATE_TEST_SUITE_P(SignedFixedSizeInts, FullSerializationTest, ::testing::Values(
SerializeParams(int1_signed{-1}, {0xff}, "Negative"),
SerializeParams(int2_signed{-0x101}, {0xff, 0xfe}, "Negative"),
SerializeParams(int4_signed{-0x3020101}, {0xff, 0xfe, 0xfd, 0xfc}, "Negative"),
SerializeParams(int8_signed{-0x0706050403020101}, {0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8}, "Negative"),
SerializeParams(int1_signed{0x01}, {0x01}, "Positive"),
SerializeParams(int2_signed{0x0201}, {0x01, 0x02}, "Positive"),
SerializeParams(int4_signed{0x04030201}, {0x01, 0x02, 0x03, 0x04}, "Positive"),
SerializeParams(int8_signed{0x0807060504030201}, {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}, "Positive")
));
INSTANTIATE_TEST_SUITE_P(LengthEncodedInt, FullSerializationTest, ::testing::Values(
SerializeParams(int_lenenc{1}, {0x01}, "1 byte (regular value)"),
SerializeParams(int_lenenc{250}, {0xfa}, "1 byte (max value)"),
SerializeParams(int_lenenc{0xfeb7}, {0xfc, 0xb7, 0xfe}, "2 bytes (regular value)"),
SerializeParams(int_lenenc{0xffff}, {0xfc, 0xff, 0xff}, "2 bytes (max value)"),
SerializeParams(int_lenenc{0xa0feff}, {0xfd, 0xff, 0xfe, 0xa0}, "3 bytes (regular value)"),
SerializeParams(int_lenenc{0xffffff}, {0xfd, 0xff, 0xff, 0xff}, "3 bytes (max value)"),
SerializeParams(int_lenenc{0xf8f9fafbfcfdfeff},
{0xfe, 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8}, "8 bytes (regular value)"),
SerializeParams(int_lenenc{0xffffffffffffffff},
{0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, "8 bytes (max value)")
));
INSTANTIATE_TEST_SUITE_P(FixedSizeString, FullSerializationTest, ::testing::Values(
SerializeParams(string_fixed<4>{'a', 'b', 'd', 'e'}, {0x61, 0x62, 0x64, 0x65}, "Regular characters"),
SerializeParams(string_fixed<3>{'\0', '\1', 'a'}, {0x00, 0x01, 0x61}, "Null characters"),
SerializeParams(string_fixed<3>{char(0xc3), char(0xb1), 'a'}, {0xc3, 0xb1, 0x61}, "UTF-8 characters"),
SerializeParams(string_fixed<1>{'a'}, {0x61}, "Size 1 string")
));
INSTANTIATE_TEST_SUITE_P(NullTerminatedString, FullSerializationTest, ::testing::Values(
SerializeParams(string_null{"abc"}, {0x61, 0x62, 0x63, 0x00}, "Regular characters"),
SerializeParams(string_null{"\xc3\xb1"}, {0xc3, 0xb1, 0x00}, "UTF-8 characters"),
SerializeParams(string_null{""}, {0x00}, "Empty string")
));
INSTANTIATE_TEST_SUITE_P(LengthEncodedString, FullSerializationTest, ::testing::Values(
SerializeParams(string_lenenc{""}, {0x00}, "Empty string"),
SerializeParams(string_lenenc{"abc"}, {0x03, 0x61, 0x62, 0x63}, "1 byte size, regular characters"),
SerializeParams(string_lenenc{string_view("a\0b", 3)}, {0x03, 0x61, 0x00, 0x62}, "1 byte size, null characters"),
SerializeParams(string_lenenc{string_250}, concat({250}, vector<uint8_t>(250, 0x61)), "1 byte size, max"),
SerializeParams(string_lenenc{string_251}, concat({0xfc, 251, 0}, vector<uint8_t>(251, 0x61)), "2 byte size, min"),
SerializeParams(string_lenenc{string_ffff}, concat({0xfc, 0xff, 0xff}, vector<uint8_t>(0xffff, 0x61)), "2 byte size, max"),
SerializeParams(string_lenenc{string_10000}, concat({0xfd, 0x00, 0x00, 0x01}, vector<uint8_t>(0x10000, 0x61)), "3 byte size, max")
));
INSTANTIATE_TEST_SUITE_P(EofString, SerializeDeserializeTest, ::testing::Values(
SerializeParams(string_eof{"abc"}, {0x61, 0x62, 0x63}, "Regular characters"),
SerializeParams(string_eof{string_view("a\0b", 3)}, {0x61, 0x00, 0x62}, "Null characters"),
SerializeParams(string_eof{""}, {}, "Empty string")
));
INSTANTIATE_TEST_SUITE_P(Enums, FullSerializationTest, ::testing::Values(
SerializeParams(EnumInt1::value1, {0x03}, "low value"),
SerializeParams(EnumInt1::value2, {0xff}, "high value"),
SerializeParams(EnumInt2::value1, {0x03, 0x00}, "low value"),
SerializeParams(EnumInt2::value2, {0xff, 0xfe}, "high value"),
SerializeParams(EnumInt4::value1, {0x03, 0x00, 0x00, 0x00}, "low value"),
SerializeParams(EnumInt4::value2, {0xff, 0xfe, 0xfd, 0xfc}, "high value")
));
INSTANTIATE_TEST_SUITE_P(PacketHeader, FullSerializationTest, ::testing::Values(
// packet header
SerializeParams(msgs::packet_header{{3}, {0}}, {0x03, 0x00, 0x00, 0x00}, "small packet, seqnum==0"),
SerializeParams(msgs::packet_header{{9}, {2}}, {0x09, 0x00, 0x00, 0x02}, "small packet, seqnum!=0"),
SerializeParams(msgs::packet_header{{0xcacbcc}, {0xfa}}, {0xcc, 0xcb, 0xca, 0xfa}, "big packet, seqnum!=0"),
SerializeParams(msgs::packet_header{{0xffffff}, {0xff}}, {0xff, 0xff, 0xff, 0xff}, "max packet, max seqnum")
));
INSTANTIATE_TEST_SUITE_P(OkPacket, DeserializeTest, ::testing::Values(
SerializeParams(msgs::ok_packet{
{4}, // affected rows
{0}, // last insert ID
{SERVER_STATUS_AUTOCOMMIT | SERVER_QUERY_NO_INDEX_USED}, // server status
{0}, // warnings
string_lenenc{"Rows matched: 5 Changed: 4 Warnings: 0"}
}, {
0x04, 0x00, 0x22, 0x00, 0x00, 0x00, 0x28, 0x52, 0x6f, 0x77, 0x73,
0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x64, 0x3a, 0x20, 0x35, 0x20, 0x20, 0x43, 0x68, 0x61,
0x6e, 0x67, 0x65, 0x64, 0x3a, 0x20, 0x34, 0x20, 0x20, 0x57, 0x61, 0x72, 0x6e, 0x69, 0x6e, 0x67,
0x73, 0x3a, 0x20, 0x30
}, "successful UPDATE"),
SerializeParams(msgs::ok_packet{
{1}, // affected rows
{6}, // last insert ID
{SERVER_STATUS_AUTOCOMMIT}, // server status
{0}, // warnings
{} // no message
},{
0x01, 0x06, 0x02, 0x00, 0x00, 0x00
}, "successful INSERT"),
SerializeParams(msgs::ok_packet{
{0}, // affected rows
{0}, // last insert ID
{SERVER_STATUS_AUTOCOMMIT}, // server status
{0}, // warnings
{} // no message
}, {
0x00, 0x00, 0x02, 0x00, 0x00, 0x00
}, "Successful login")
));
INSTANTIATE_TEST_SUITE_P(ErrPacket, DeserializeTest, ::testing::Values(
SerializeParams(msgs::err_packet{
{1049}, // eror code
{0x23}, // sql state marker
{'4', '2', '0', '0', '0'}, // sql state
{"Unknown database 'a'"} // err msg
}, {
0x19, 0x04, 0x23, 0x34, 0x32, 0x30, 0x30, 0x30, 0x55, 0x6e, 0x6b,
0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x64, 0x61, 0x74,
0x61, 0x62, 0x61, 0x73, 0x65, 0x20, 0x27, 0x61, 0x27
}, "Wrong USE database"),
SerializeParams(msgs::err_packet{
{1146}, // eror code
{0x23}, // sql state marker
{'4', '2', 'S', '0', '2'}, // sql state
{"Table 'awesome.unknown' doesn't exist"} // err msg
}, {
0x7a, 0x04, 0x23, 0x34, 0x32, 0x53, 0x30, 0x32,
0x54, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x27, 0x61,
0x77, 0x65, 0x73, 0x6f, 0x6d, 0x65, 0x2e, 0x75,
0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x27, 0x20,
0x64, 0x6f, 0x65, 0x73, 0x6e, 0x27, 0x74, 0x20,
0x65, 0x78, 0x69, 0x73, 0x74
}, "Unknown table"),
SerializeParams(msgs::err_packet{
{1045}, // error code
{0x23}, // SQL state marker
{'2', '8', '0', '0', '0'}, // SQL state
{"Access denied for user 'root'@'localhost' (using password: YES)"}
}, {
0x15, 0x04, 0x23, 0x32, 0x38, 0x30, 0x30, 0x30,
0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x64,
0x65, 0x6e, 0x69, 0x65, 0x64, 0x20, 0x66, 0x6f,
0x72, 0x20, 0x75, 0x73, 0x65, 0x72, 0x20, 0x27,
0x72, 0x6f, 0x6f, 0x74, 0x27, 0x40, 0x27, 0x6c,
0x6f, 0x63, 0x61, 0x6c, 0x68, 0x6f, 0x73, 0x74,
0x27, 0x20, 0x28, 0x75, 0x73, 0x69, 0x6e, 0x67,
0x20, 0x70, 0x61, 0x73, 0x73, 0x77, 0x6f, 0x72,
0x64, 0x3a, 0x20, 0x59, 0x45, 0x53, 0x29
}, "Failed login")
));
constexpr std::uint8_t handshake_auth_plugin_data [] = {
0x52, 0x1a, 0x50, 0x3a, 0x4b, 0x12, 0x70, 0x2f,
0x03, 0x5a, 0x74, 0x05, 0x28, 0x2b, 0x7f, 0x21,
0x43, 0x4a, 0x21, 0x62
};
constexpr std::uint32_t hanshake_caps =
CLIENT_LONG_PASSWORD |
CLIENT_FOUND_ROWS |
CLIENT_LONG_FLAG |
CLIENT_CONNECT_WITH_DB |
CLIENT_NO_SCHEMA |
CLIENT_COMPRESS |
CLIENT_ODBC |
CLIENT_LOCAL_FILES |
CLIENT_IGNORE_SPACE |
CLIENT_PROTOCOL_41 |
CLIENT_INTERACTIVE |
CLIENT_IGNORE_SIGPIPE |
CLIENT_TRANSACTIONS |
CLIENT_RESERVED | // old flag, but set in this frame
CLIENT_RESERVED2 | // old flag, but set in this frame
CLIENT_MULTI_STATEMENTS |
CLIENT_MULTI_RESULTS |
CLIENT_PS_MULTI_RESULTS |
CLIENT_PLUGIN_AUTH |
CLIENT_CONNECT_ATTRS |
CLIENT_PLUGIN_AUTH_LENENC_CLIENT_DATA |
CLIENT_CAN_HANDLE_EXPIRED_PASSWORDS |
CLIENT_SESSION_TRACK |
CLIENT_DEPRECATE_EOF |
CLIENT_REMEMBER_OPTIONS;
INSTANTIATE_TEST_SUITE_P(Handhsake, DeserializeSpaceTest, ::testing::Values(
SerializeParams(msgs::handshake{
{"5.7.27-0ubuntu0.19.04.1"}, // server version
{2}, // connection ID
{buffer_to_sv(handshake_auth_plugin_data)},
{hanshake_caps},
static_cast<std::uint8_t>(collation::latin1_swedish_ci),
{ SERVER_STATUS_AUTOCOMMIT },
{ "mysql_native_password" },
{} // data buffer; internal, not used in the comparisons for correctness
}, {
0x35, 0x2e, 0x37, 0x2e, 0x32, 0x37, 0x2d, 0x30,
0x75, 0x62, 0x75, 0x6e, 0x74, 0x75, 0x30, 0x2e,
0x31, 0x39, 0x2e, 0x30, 0x34, 0x2e, 0x31, 0x00,
0x02, 0x00, 0x00, 0x00, 0x52, 0x1a, 0x50, 0x3a,
0x4b, 0x12, 0x70, 0x2f, 0x00, 0xff, 0xf7, 0x08,
0x02, 0x00, 0xff, 0x81, 0x15, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
0x5a, 0x74, 0x05, 0x28, 0x2b, 0x7f, 0x21, 0x43,
0x4a, 0x21, 0x62, 0x00, 0x6d, 0x79, 0x73, 0x71,
0x6c, 0x5f, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65,
0x5f, 0x70, 0x61, 0x73, 0x73, 0x77, 0x6f, 0x72,
0x64, 0x00
})
));
constexpr std::uint8_t handshake_response_auth_data [] = {
0xfe, 0xc6, 0x2c, 0x9f, 0xab, 0x43, 0x69, 0x46,
0xc5, 0x51, 0x35, 0xa5, 0xff, 0xdb, 0x3f, 0x48,
0xe6, 0xfc, 0x34, 0xc9
};
constexpr std::uint32_t handshake_response_caps =
CLIENT_LONG_PASSWORD |
CLIENT_LONG_FLAG |
CLIENT_LOCAL_FILES |
CLIENT_PROTOCOL_41 |
CLIENT_INTERACTIVE |
CLIENT_TRANSACTIONS |
CLIENT_RESERVED2 |
CLIENT_MULTI_STATEMENTS |
CLIENT_MULTI_RESULTS |
CLIENT_PS_MULTI_RESULTS |
CLIENT_PLUGIN_AUTH |
CLIENT_CONNECT_ATTRS |
CLIENT_PLUGIN_AUTH_LENENC_CLIENT_DATA |
CLIENT_CAN_HANDLE_EXPIRED_PASSWORDS |
CLIENT_SESSION_TRACK |
CLIENT_DEPRECATE_EOF;
INSTANTIATE_TEST_SUITE_P(HandhsakeResponse, SerializeTest, ::testing::Values(
SerializeParams(msgs::handshake_response{
{ handshake_response_caps },
{ 16777216 }, // max packet size
static_cast<std::uint8_t>(collation::utf8_general_ci),
{ "root" },
{ buffer_to_sv(handshake_response_auth_data) },
{ "" }, // Irrelevant, not using connect with DB
{ "mysql_native_password" } // auth plugin name
}, {
0x85, 0xa6, 0xff, 0x01, 0x00, 0x00, 0x00, 0x01,
0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x72, 0x6f, 0x6f, 0x74, 0x00, 0x14, 0xfe, 0xc6,
0x2c, 0x9f, 0xab, 0x43, 0x69, 0x46, 0xc5, 0x51,
0x35, 0xa5, 0xff, 0xdb, 0x3f, 0x48, 0xe6, 0xfc,
0x34, 0xc9, 0x6d, 0x79, 0x73, 0x71, 0x6c, 0x5f,
0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x70,
0x61, 0x73, 0x73, 0x77, 0x6f, 0x72, 0x64, 0x00
}, "without database", handshake_response_caps),
SerializeParams(msgs::handshake_response{
{ handshake_response_caps | CLIENT_CONNECT_WITH_DB },
{ 16777216 }, // max packet size
static_cast<std::uint8_t>(collation::utf8_general_ci),
{ "root" },
{ buffer_to_sv(handshake_response_auth_data) },
{ "database" }, // database name
{ "mysql_native_password" } // auth plugin name
}, {
0x8d, 0xa6, 0xff, 0x01, 0x00, 0x00, 0x00, 0x01,
0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x72, 0x6f, 0x6f, 0x74, 0x00, 0x14, 0xfe, 0xc6,
0x2c, 0x9f, 0xab, 0x43, 0x69, 0x46, 0xc5, 0x51,
0x35, 0xa5, 0xff, 0xdb, 0x3f, 0x48, 0xe6, 0xfc,
0x34, 0xc9, 0x64, 0x61, 0x74, 0x61, 0x62, 0x61,
0x73, 0x65, 0x00, 0x6d, 0x79, 0x73, 0x71, 0x6c,
0x5f, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f,
0x70, 0x61, 0x73, 0x73, 0x77, 0x6f, 0x72, 0x64,
0x00
}, "with database", handshake_response_caps | CLIENT_CONNECT_WITH_DB)
));
constexpr std::uint8_t auth_switch_request_auth_data [] = {
0x49, 0x49, 0x7e, 0x51, 0x5d, 0x1f, 0x19, 0x6a,
0x0f, 0x5a, 0x63, 0x15, 0x3e, 0x28, 0x31, 0x3e,
0x3c, 0x79, 0x09, 0x7c
};
INSTANTIATE_TEST_SUITE_P(AuthSwitchRequest, DeserializeTest, testing::Values(
SerializeParams(msgs::auth_switch_request{
{"mysql_native_password"},
{buffer_to_sv(auth_switch_request_auth_data)}
}, {
0x6d, 0x79, 0x73,
0x71, 0x6c, 0x5f, 0x6e, 0x61, 0x74, 0x69, 0x76,
0x65, 0x5f, 0x70, 0x61, 0x73, 0x73, 0x77, 0x6f,
0x72, 0x64, 0x00, 0x49, 0x49, 0x7e, 0x51, 0x5d,
0x1f, 0x19, 0x6a, 0x0f, 0x5a, 0x63, 0x15, 0x3e,
0x28, 0x31, 0x3e, 0x3c, 0x79, 0x09, 0x7c, 0x00
})
));
constexpr std::uint8_t auth_switch_response_auth_data [] = {
0xba, 0x55, 0x9c, 0xc5, 0x9c, 0xbf, 0xca, 0x06,
0x91, 0xff, 0xaa, 0x72, 0x59, 0xfc, 0x53, 0xdf,
0x88, 0x2d, 0xf9, 0xcf
};
INSTANTIATE_TEST_SUITE_P(AuthSwitchResponse, SerializeTest, testing::Values(
SerializeParams(msgs::auth_switch_response{
{buffer_to_sv(auth_switch_response_auth_data)}
}, {
0xba, 0x55, 0x9c, 0xc5, 0x9c, 0xbf, 0xca, 0x06,
0x91, 0xff, 0xaa, 0x72, 0x59, 0xfc, 0x53, 0xdf,
0x88, 0x2d, 0xf9, 0xcf
})
));
// Column definition
INSTANTIATE_TEST_SUITE_P(ColumnDefinition, DeserializeSpaceTest, testing::Values(
SerializeParams(msgs::column_definition{
{"def"}, //catalog
{"awesome"}, // schema (database)
{"test_table"}, // table
{"test_table"}, // physical table
{"id"}, // field name
{"id"}, // physical field name
collation::binary,
{11}, // length
protocol_field_type::long_,
{
column_flags::not_null |
column_flags::pri_key |
column_flags::auto_increment |
column_flags::part_key
},
{0} // decimals
}, {
0x03, 0x64, 0x65, 0x66, 0x07, 0x61, 0x77, 0x65,
0x73, 0x6f, 0x6d, 0x65, 0x0a, 0x74, 0x65, 0x73,
0x74, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x0a,
0x74, 0x65, 0x73, 0x74, 0x5f, 0x74, 0x61, 0x62,
0x6c, 0x65, 0x02, 0x69, 0x64, 0x02, 0x69, 0x64,
0x0c, 0x3f, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x03,
0x03, 0x42, 0x00, 0x00, 0x00
}, "Numeric, auto-increment primary key"),
SerializeParams(msgs::column_definition{
{"def"}, //catalog
{"awesome"}, // schema (database)
{"child"}, // table
{"child_table"}, // physical table
{"field_alias"}, // field name
{"field_varchar"}, // physical field name
collation::utf8_general_ci,
{765}, // length
protocol_field_type::var_string,
{}, // no column flags
{0} // decimals
}, {
0x03, 0x64, 0x65, 0x66, 0x07, 0x61, 0x77, 0x65,
0x73, 0x6f, 0x6d, 0x65, 0x05, 0x63, 0x68, 0x69,
0x6c, 0x64, 0x0b, 0x63, 0x68, 0x69, 0x6c, 0x64,
0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x0b, 0x66,
0x69, 0x65, 0x6c, 0x64, 0x5f, 0x61, 0x6c, 0x69,
0x61, 0x73, 0x0d, 0x66, 0x69, 0x65, 0x6c, 0x64,
0x5f, 0x76, 0x61, 0x72, 0x63, 0x68, 0x61, 0x72,
0x0c, 0x21, 0x00, 0xfd, 0x02, 0x00, 0x00, 0xfd,
0x00, 0x00, 0x00, 0x00, 0x00
}, "Varchar field, aliased field and table names (query with a JOIN)"),
SerializeParams(msgs::column_definition{
{"def"}, //catalog
{"awesome"}, // schema (database)
{"test_table"}, // table
{"test_table"}, // physical table
{"field_float"}, // field name
{"field_float"}, // physical field name
collation::binary, // binary
{12}, // length
protocol_field_type::float_,
{}, // no column flags
{31} // decimals
}, {
0x03, 0x64, 0x65, 0x66, 0x07, 0x61, 0x77, 0x65,
0x73, 0x6f, 0x6d, 0x65, 0x0a, 0x74, 0x65, 0x73,
0x74, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x0a,
0x74, 0x65, 0x73, 0x74, 0x5f, 0x74, 0x61, 0x62,
0x6c, 0x65, 0x0b, 0x66, 0x69, 0x65, 0x6c, 0x64,
0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x0b, 0x66,
0x69, 0x65, 0x6c, 0x64, 0x5f, 0x66, 0x6c, 0x6f,
0x61, 0x74, 0x0c, 0x3f, 0x00, 0x0c, 0x00, 0x00,
0x00, 0x04, 0x00, 0x00, 0x1f, 0x00, 0x00
}, "Float field")
));
INSTANTIATE_TEST_SUITE_P(ComQuery, SerializeTest, testing::Values(
SerializeParams(msgs::com_query{
{"show databases"}
}, {
0x03, 0x73, 0x68, 0x6f, 0x77, 0x20, 0x64, 0x61,
0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x73
})
));
} // anon namespace
Reference in New Issue View Git Blame Copy Permalink