mirror of
https://github.com/wpilibsuite/allwpilib
synced 2026-06-20 00:51:42 +00:00
620 lines
16 KiB
C++
620 lines
16 KiB
C++
/*----------------------------------------------------------------------------*/
|
|
/* Copyright (c) FIRST 2015. All Rights Reserved. */
|
|
/* Open Source Software - may be modified and shared by FRC teams. The code */
|
|
/* must be accompanied by the FIRST BSD license file in the root directory of */
|
|
/* the project. */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
#include "WireDecoder.h"
|
|
|
|
#include "StringValueTest.h"
|
|
#include "ValueTest.h"
|
|
|
|
#include "gtest/gtest.h"
|
|
|
|
#include <cfloat>
|
|
#include <climits>
|
|
#include <string>
|
|
|
|
#include "llvm/StringRef.h"
|
|
|
|
namespace ntimpl {
|
|
|
|
class WireDecoderTest : public ::testing::Test {
|
|
protected:
|
|
virtual void SetUp() {
|
|
Value v;
|
|
v_boolean.SetBoolean(true);
|
|
v_double.SetDouble(1.0);
|
|
v_string.SetString("hello");
|
|
v_raw.SetRaw("hello");
|
|
v_boolean_array.SetBooleanArray(std::vector<int>{0, 1, 0});
|
|
v_boolean_array_big.SetBooleanArray(std::vector<int>(255));
|
|
v_double_array.SetDoubleArray(std::vector<double>{0.5, 0.25});
|
|
v_double_array_big.SetDoubleArray(std::vector<double>(255));
|
|
|
|
std::vector<StringValue> sa;
|
|
sa.push_back(StringValue("hello"));
|
|
sa.push_back(StringValue("goodbye"));
|
|
v_string_array.SetStringArray(sa);
|
|
|
|
sa.clear();
|
|
for (int i=0; i<255; ++i)
|
|
sa.push_back(StringValue("h"));
|
|
v_string_array_big.SetStringArray(sa);
|
|
|
|
s_normal = std::string("hello");
|
|
sv_normal = StringValue(s_normal);
|
|
|
|
s_long.clear();
|
|
s_long.append(127, '*');
|
|
s_long.push_back('x');
|
|
sv_long = StringValue(s_long);
|
|
|
|
s_big2.clear();
|
|
s_big2.append(65534, '*');
|
|
s_big2.push_back('x');
|
|
sv_big2 = StringValue(s_big2);
|
|
|
|
s_big3.clear();
|
|
s_big3.append(65534, '*');
|
|
s_big3.append(3, 'x');
|
|
sv_big3 = StringValue(s_big3);
|
|
}
|
|
|
|
Value v_empty;
|
|
Value v_boolean, v_double, v_string, v_raw;
|
|
Value v_boolean_array, v_boolean_array_big;
|
|
Value v_double_array, v_double_array_big;
|
|
Value v_string_array, v_string_array_big;
|
|
|
|
std::string s_normal, s_long, s_big2, s_big3;
|
|
StringValue sv_normal, sv_long, sv_big2, sv_big3;
|
|
};
|
|
|
|
TEST_F(WireDecoderTest, Construct) {
|
|
raw_mem_istream is("", 0);
|
|
WireDecoder d(is, 0x0300u);
|
|
EXPECT_EQ(nullptr, d.error());
|
|
EXPECT_EQ(0x0300u, d.proto_rev());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, SetProtoRev) {
|
|
raw_mem_istream is("", 0);
|
|
WireDecoder d(is, 0x0300u);
|
|
d.set_proto_rev(0x0200u);
|
|
EXPECT_EQ(0x0200u, d.proto_rev());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, Read8) {
|
|
raw_mem_istream is("\x05\x01\x00", 3);
|
|
WireDecoder d(is, 0x0300u);
|
|
unsigned int val;
|
|
ASSERT_TRUE(d.Read8(&val));
|
|
EXPECT_EQ(5u, val);
|
|
ASSERT_TRUE(d.Read8(&val));
|
|
EXPECT_EQ(1u, val);
|
|
ASSERT_TRUE(d.Read8(&val));
|
|
EXPECT_EQ(0u, val);
|
|
ASSERT_FALSE(d.Read8(&val));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, Read16) {
|
|
raw_mem_istream is("\x00\x05\x00\x01\x45\x67\x00\x00", 8);
|
|
WireDecoder d(is, 0x0300u);
|
|
unsigned int val;
|
|
ASSERT_TRUE(d.Read16(&val));
|
|
EXPECT_EQ(5u, val);
|
|
ASSERT_TRUE(d.Read16(&val));
|
|
EXPECT_EQ(1u, val);
|
|
ASSERT_TRUE(d.Read16(&val));
|
|
EXPECT_EQ(0x4567u, val);
|
|
ASSERT_TRUE(d.Read16(&val));
|
|
EXPECT_EQ(0u, val);
|
|
ASSERT_FALSE(d.Read16(&val));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, Read32) {
|
|
raw_mem_istream is(
|
|
"\x00\x00\x00\x05\x00\x00\x00\x01\x00\x00\xab\xcd"
|
|
"\x12\x34\x56\x78\x00\x00\x00\x00",
|
|
20);
|
|
WireDecoder d(is, 0x0300u);
|
|
unsigned long val;
|
|
ASSERT_TRUE(d.Read32(&val));
|
|
EXPECT_EQ(5ul, val);
|
|
ASSERT_TRUE(d.Read32(&val));
|
|
EXPECT_EQ(1ul, val);
|
|
ASSERT_TRUE(d.Read32(&val));
|
|
EXPECT_EQ(0xabcdul, val);
|
|
ASSERT_TRUE(d.Read32(&val));
|
|
EXPECT_EQ(0x12345678ul, val);
|
|
ASSERT_TRUE(d.Read32(&val));
|
|
EXPECT_EQ(0ul, val);
|
|
ASSERT_FALSE(d.Read32(&val));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadDouble) {
|
|
// values except min and max from
|
|
// http://www.binaryconvert.com/result_double.html
|
|
raw_mem_istream is(
|
|
"\x00\x00\x00\x00\x00\x00\x00\x00"
|
|
"\x41\x0c\x13\x80\x00\x00\x00\x00"
|
|
"\x7f\xf0\x00\x00\x00\x00\x00\x00"
|
|
"\x00\x10\x00\x00\x00\x00\x00\x00"
|
|
"\x7f\xef\xff\xff\xff\xff\xff\xff",
|
|
40);
|
|
WireDecoder d(is, 0x0300u);
|
|
double val;
|
|
ASSERT_TRUE(d.ReadDouble(&val));
|
|
EXPECT_EQ(0.0, val);
|
|
ASSERT_TRUE(d.ReadDouble(&val));
|
|
EXPECT_EQ(2.3e5, val);
|
|
ASSERT_TRUE(d.ReadDouble(&val));
|
|
EXPECT_EQ(std::numeric_limits<double>::infinity(), val);
|
|
ASSERT_TRUE(d.ReadDouble(&val));
|
|
EXPECT_EQ(DBL_MIN, val);
|
|
ASSERT_TRUE(d.ReadDouble(&val));
|
|
EXPECT_EQ(DBL_MAX, val);
|
|
ASSERT_FALSE(d.ReadDouble(&val));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadUleb128) {
|
|
raw_mem_istream is("\x00\x7f\x80\x01\x80", 5);
|
|
WireDecoder d(is, 0x0300u);
|
|
unsigned long val;
|
|
ASSERT_TRUE(d.ReadUleb128(&val));
|
|
EXPECT_EQ(0ul, val);
|
|
ASSERT_TRUE(d.ReadUleb128(&val));
|
|
EXPECT_EQ(0x7ful, val);
|
|
ASSERT_TRUE(d.ReadUleb128(&val));
|
|
EXPECT_EQ(0x80ul, val);
|
|
ASSERT_FALSE(d.ReadUleb128(&val)); // partial
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadType) {
|
|
raw_mem_istream is("\x00\x01\x02\x03\x10\x11\x12\x20", 8);
|
|
WireDecoder d(is, 0x0300u);
|
|
NT_Type val;
|
|
ASSERT_TRUE(d.ReadType(&val));
|
|
EXPECT_EQ(NT_BOOLEAN, val);
|
|
ASSERT_TRUE(d.ReadType(&val));
|
|
EXPECT_EQ(NT_DOUBLE, val);
|
|
ASSERT_TRUE(d.ReadType(&val));
|
|
EXPECT_EQ(NT_STRING, val);
|
|
ASSERT_TRUE(d.ReadType(&val));
|
|
EXPECT_EQ(NT_RAW, val);
|
|
ASSERT_TRUE(d.ReadType(&val));
|
|
EXPECT_EQ(NT_BOOLEAN_ARRAY, val);
|
|
ASSERT_TRUE(d.ReadType(&val));
|
|
EXPECT_EQ(NT_DOUBLE_ARRAY, val);
|
|
ASSERT_TRUE(d.ReadType(&val));
|
|
EXPECT_EQ(NT_STRING_ARRAY, val);
|
|
ASSERT_TRUE(d.ReadType(&val));
|
|
EXPECT_EQ(NT_RPC, val);
|
|
ASSERT_FALSE(d.ReadType(&val));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadTypeError) {
|
|
raw_mem_istream is("\x30", 1);
|
|
WireDecoder d(is, 0x0200u);
|
|
NT_Type val;
|
|
ASSERT_FALSE(d.ReadType(&val));
|
|
EXPECT_EQ(NT_UNASSIGNED, val);
|
|
ASSERT_NE(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, Reset) {
|
|
raw_mem_istream is("\x30", 1);
|
|
WireDecoder d(is, 0x0200u);
|
|
NT_Type val;
|
|
ASSERT_FALSE(d.ReadType(&val));
|
|
EXPECT_EQ(NT_UNASSIGNED, val);
|
|
ASSERT_NE(nullptr, d.error());
|
|
d.Reset();
|
|
EXPECT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadBooleanValue2) {
|
|
raw_mem_istream is("\x01\x00", 2);
|
|
WireDecoder d(is, 0x0200u);
|
|
Value val;
|
|
ASSERT_TRUE(d.ReadValue(NT_BOOLEAN, &val));
|
|
EXPECT_EQ(v_boolean, val);
|
|
|
|
Value v_false;
|
|
v_false.SetBoolean(false);
|
|
ASSERT_TRUE(d.ReadValue(NT_BOOLEAN, &val));
|
|
EXPECT_EQ(v_false, val);
|
|
|
|
ASSERT_FALSE(d.ReadValue(NT_BOOLEAN, &val));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadDoubleValue2) {
|
|
raw_mem_istream is(
|
|
"\x3f\xf0\x00\x00\x00\x00\x00\x00"
|
|
"\x3f\xf0\x00\x00\x00\x00\x00\x00",
|
|
16);
|
|
WireDecoder d(is, 0x0200u);
|
|
Value val;
|
|
ASSERT_TRUE(d.ReadValue(NT_DOUBLE, &val));
|
|
EXPECT_EQ(v_double, val);
|
|
|
|
Value val2;
|
|
ASSERT_TRUE(d.ReadValue(NT_DOUBLE, &val2));
|
|
EXPECT_EQ(v_double, val2);
|
|
|
|
ASSERT_FALSE(d.ReadValue(NT_DOUBLE, &val));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadStringValue2) {
|
|
raw_mem_istream is("\x00\x05hello\x00\x03" "bye\x55", 13);
|
|
WireDecoder d(is, 0x0200u);
|
|
Value val;
|
|
ASSERT_TRUE(d.ReadValue(NT_STRING, &val));
|
|
EXPECT_EQ(v_string, val);
|
|
|
|
Value val2;
|
|
Value v_bye;
|
|
v_bye.SetString("bye");
|
|
ASSERT_TRUE(d.ReadValue(NT_STRING, &val2));
|
|
EXPECT_EQ(v_bye, val2);
|
|
|
|
unsigned int b;
|
|
ASSERT_TRUE(d.Read8(&b));
|
|
EXPECT_EQ(0x55u, b);
|
|
|
|
ASSERT_FALSE(d.ReadValue(NT_STRING, &val));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadBooleanArrayValue2) {
|
|
raw_mem_istream is("\x03\x00\x01\x00\x02\x01\x00\xff", 8);
|
|
WireDecoder d(is, 0x0200u);
|
|
Value val;
|
|
ASSERT_TRUE(d.ReadValue(NT_BOOLEAN_ARRAY, &val));
|
|
EXPECT_EQ(v_boolean_array, val);
|
|
|
|
Value val2;
|
|
Value v_boolean_array2;
|
|
v_boolean_array2.SetBooleanArray(std::vector<int>{1, 0});
|
|
ASSERT_TRUE(d.ReadValue(NT_BOOLEAN_ARRAY, &val2));
|
|
EXPECT_EQ(v_boolean_array2, val2);
|
|
|
|
ASSERT_FALSE(d.ReadValue(NT_BOOLEAN_ARRAY, &val));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadBooleanArrayBigValue2) {
|
|
std::string s;
|
|
s.push_back('\xff');
|
|
s.append(255, '\x00');
|
|
raw_mem_istream is(s.data(), s.size());
|
|
WireDecoder d(is, 0x0200u);
|
|
Value val;
|
|
ASSERT_TRUE(d.ReadValue(NT_BOOLEAN_ARRAY, &val));
|
|
EXPECT_EQ(v_boolean_array_big, val);
|
|
|
|
ASSERT_FALSE(d.ReadValue(NT_BOOLEAN_ARRAY, &val));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadDoubleArrayValue2) {
|
|
raw_mem_istream is(
|
|
"\x02\x3f\xe0\x00\x00\x00\x00\x00\x00"
|
|
"\x3f\xd0\x00\x00\x00\x00\x00\x00\x55",
|
|
18);
|
|
WireDecoder d(is, 0x0200u);
|
|
Value val;
|
|
ASSERT_TRUE(d.ReadValue(NT_DOUBLE_ARRAY, &val));
|
|
EXPECT_EQ(v_double_array, val);
|
|
|
|
unsigned int b;
|
|
ASSERT_TRUE(d.Read8(&b));
|
|
EXPECT_EQ(0x55u, b);
|
|
|
|
ASSERT_FALSE(d.ReadValue(NT_DOUBLE_ARRAY, &val));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadDoubleArrayBigValue2) {
|
|
std::string s;
|
|
s.push_back('\xff');
|
|
s.append(255*8, '\x00');
|
|
raw_mem_istream is(s.data(), s.size());
|
|
WireDecoder d(is, 0x0200u);
|
|
Value val;
|
|
ASSERT_TRUE(d.ReadValue(NT_DOUBLE_ARRAY, &val));
|
|
EXPECT_EQ(v_double_array_big, val);
|
|
|
|
ASSERT_FALSE(d.ReadValue(NT_DOUBLE_ARRAY, &val));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadStringArrayValue2) {
|
|
raw_mem_istream is("\x02\x00\x05hello\x00\x07goodbye\x55", 18);
|
|
WireDecoder d(is, 0x0200u);
|
|
Value val;
|
|
ASSERT_TRUE(d.ReadValue(NT_STRING_ARRAY, &val));
|
|
EXPECT_EQ(v_string_array, val);
|
|
|
|
unsigned int b;
|
|
ASSERT_TRUE(d.Read8(&b));
|
|
EXPECT_EQ(0x55u, b);
|
|
|
|
ASSERT_FALSE(d.ReadValue(NT_STRING_ARRAY, &val));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadStringArrayBigValue2) {
|
|
std::string s;
|
|
s.push_back('\xff');
|
|
for (int i=0; i<255; ++i)
|
|
s.append("\x00\x01h", 3);
|
|
raw_mem_istream is(s.data(), s.size());
|
|
WireDecoder d(is, 0x0200u);
|
|
Value val;
|
|
ASSERT_TRUE(d.ReadValue(NT_STRING_ARRAY, &val));
|
|
EXPECT_EQ(v_string_array_big, val);
|
|
|
|
ASSERT_FALSE(d.ReadValue(NT_STRING_ARRAY, &val));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadValueError2) {
|
|
raw_mem_istream is("", 0);
|
|
WireDecoder d(is, 0x0200u);
|
|
Value val;
|
|
ASSERT_FALSE(d.ReadValue(NT_UNASSIGNED, &val)); // unassigned
|
|
ASSERT_NE(nullptr, d.error());
|
|
|
|
d.Reset();
|
|
ASSERT_FALSE(d.ReadValue(NT_RAW, &val)); // not supported
|
|
ASSERT_NE(nullptr, d.error());
|
|
|
|
d.Reset();
|
|
ASSERT_FALSE(d.ReadValue(NT_RPC, &val)); // not supported
|
|
ASSERT_NE(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadBooleanValue3) {
|
|
raw_mem_istream is("\x01\x00", 2);
|
|
WireDecoder d(is, 0x0300u);
|
|
Value val;
|
|
ASSERT_TRUE(d.ReadValue(NT_BOOLEAN, &val));
|
|
EXPECT_EQ(v_boolean, val);
|
|
|
|
Value v_false;
|
|
v_false.SetBoolean(false);
|
|
ASSERT_TRUE(d.ReadValue(NT_BOOLEAN, &val));
|
|
EXPECT_EQ(v_false, val);
|
|
|
|
ASSERT_FALSE(d.ReadValue(NT_BOOLEAN, &val));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadDoubleValue3) {
|
|
raw_mem_istream is(
|
|
"\x3f\xf0\x00\x00\x00\x00\x00\x00"
|
|
"\x3f\xf0\x00\x00\x00\x00\x00\x00",
|
|
16);
|
|
WireDecoder d(is, 0x0300u);
|
|
Value val;
|
|
ASSERT_TRUE(d.ReadValue(NT_DOUBLE, &val));
|
|
EXPECT_EQ(v_double, val);
|
|
|
|
Value val2;
|
|
ASSERT_TRUE(d.ReadValue(NT_DOUBLE, &val2));
|
|
EXPECT_EQ(v_double, val2);
|
|
|
|
ASSERT_FALSE(d.ReadValue(NT_DOUBLE, &val));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadStringValue3) {
|
|
raw_mem_istream is("\x05hello\x03" "bye\x55", 11);
|
|
WireDecoder d(is, 0x0300u);
|
|
Value val;
|
|
ASSERT_TRUE(d.ReadValue(NT_STRING, &val));
|
|
EXPECT_EQ(v_string, val);
|
|
|
|
Value val2;
|
|
Value v_bye;
|
|
v_bye.SetString("bye");
|
|
ASSERT_TRUE(d.ReadValue(NT_STRING, &val2));
|
|
EXPECT_EQ(v_bye, val2);
|
|
|
|
unsigned int b;
|
|
ASSERT_TRUE(d.Read8(&b));
|
|
EXPECT_EQ(0x55u, b);
|
|
|
|
ASSERT_FALSE(d.ReadValue(NT_STRING, &val));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadRawValue3) {
|
|
raw_mem_istream is("\x05hello\x03" "bye\x55", 11);
|
|
WireDecoder d(is, 0x0300u);
|
|
Value val;
|
|
ASSERT_TRUE(d.ReadValue(NT_RAW, &val));
|
|
EXPECT_EQ(v_raw, val);
|
|
|
|
Value val2;
|
|
Value v_bye;
|
|
v_bye.SetRaw("bye");
|
|
ASSERT_TRUE(d.ReadValue(NT_RAW, &val2));
|
|
EXPECT_EQ(v_bye, val2);
|
|
|
|
unsigned int b;
|
|
ASSERT_TRUE(d.Read8(&b));
|
|
EXPECT_EQ(0x55u, b);
|
|
|
|
ASSERT_FALSE(d.ReadValue(NT_RAW, &val));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadBooleanArrayValue3) {
|
|
raw_mem_istream is("\x03\x00\x01\x00\x02\x01\x00\xff", 8);
|
|
WireDecoder d(is, 0x0300u);
|
|
Value val;
|
|
ASSERT_TRUE(d.ReadValue(NT_BOOLEAN_ARRAY, &val));
|
|
EXPECT_EQ(v_boolean_array, val);
|
|
|
|
Value val2;
|
|
Value v_boolean_array2;
|
|
v_boolean_array2.SetBooleanArray(std::vector<int>{1, 0});
|
|
ASSERT_TRUE(d.ReadValue(NT_BOOLEAN_ARRAY, &val2));
|
|
EXPECT_EQ(v_boolean_array2, val2);
|
|
|
|
ASSERT_FALSE(d.ReadValue(NT_BOOLEAN_ARRAY, &val));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadBooleanArrayBigValue3) {
|
|
std::string s;
|
|
s.push_back('\xff');
|
|
s.append(255, '\x00');
|
|
raw_mem_istream is(s.data(), s.size());
|
|
WireDecoder d(is, 0x0300u);
|
|
Value val;
|
|
ASSERT_TRUE(d.ReadValue(NT_BOOLEAN_ARRAY, &val));
|
|
EXPECT_EQ(v_boolean_array_big, val);
|
|
|
|
ASSERT_FALSE(d.ReadValue(NT_BOOLEAN_ARRAY, &val));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadDoubleArrayValue3) {
|
|
raw_mem_istream is(
|
|
"\x02\x3f\xe0\x00\x00\x00\x00\x00\x00"
|
|
"\x3f\xd0\x00\x00\x00\x00\x00\x00\x55",
|
|
18);
|
|
WireDecoder d(is, 0x0300u);
|
|
Value val;
|
|
ASSERT_TRUE(d.ReadValue(NT_DOUBLE_ARRAY, &val));
|
|
EXPECT_EQ(v_double_array, val);
|
|
|
|
unsigned int b;
|
|
ASSERT_TRUE(d.Read8(&b));
|
|
EXPECT_EQ(0x55u, b);
|
|
|
|
ASSERT_FALSE(d.ReadValue(NT_DOUBLE_ARRAY, &val));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadDoubleArrayBigValue3) {
|
|
std::string s;
|
|
s.push_back('\xff');
|
|
s.append(255*8, '\x00');
|
|
raw_mem_istream is(s.data(), s.size());
|
|
WireDecoder d(is, 0x0300u);
|
|
Value val;
|
|
ASSERT_TRUE(d.ReadValue(NT_DOUBLE_ARRAY, &val));
|
|
EXPECT_EQ(v_double_array_big, val);
|
|
|
|
ASSERT_FALSE(d.ReadValue(NT_DOUBLE_ARRAY, &val));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadStringArrayValue3) {
|
|
raw_mem_istream is("\x02\x05hello\x07goodbye\x55", 16);
|
|
WireDecoder d(is, 0x0300u);
|
|
Value val;
|
|
ASSERT_TRUE(d.ReadValue(NT_STRING_ARRAY, &val));
|
|
EXPECT_EQ(v_string_array, val);
|
|
|
|
unsigned int b;
|
|
ASSERT_TRUE(d.Read8(&b));
|
|
EXPECT_EQ(0x55u, b);
|
|
|
|
ASSERT_FALSE(d.ReadValue(NT_STRING_ARRAY, &val));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadStringArrayBigValue3) {
|
|
std::string s;
|
|
s.push_back('\xff');
|
|
for (int i=0; i<255; ++i)
|
|
s.append("\x01h", 2);
|
|
raw_mem_istream is(s.data(), s.size());
|
|
WireDecoder d(is, 0x0300u);
|
|
Value val;
|
|
ASSERT_TRUE(d.ReadValue(NT_STRING_ARRAY, &val));
|
|
EXPECT_EQ(v_string_array_big, val);
|
|
|
|
ASSERT_FALSE(d.ReadValue(NT_STRING_ARRAY, &val));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadValueError3) {
|
|
raw_mem_istream is("", 0);
|
|
WireDecoder d(is, 0x0200u);
|
|
Value val;
|
|
ASSERT_FALSE(d.ReadValue(NT_UNASSIGNED, &val)); // unassigned
|
|
ASSERT_NE(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadString2) {
|
|
std::string s;
|
|
s.append("\x00\x05", 2);
|
|
s += s_normal;
|
|
s.append("\x00\x80", 2);
|
|
s += s_long;
|
|
s.append("\xff\xff", 2);
|
|
s += s_big2;
|
|
s.push_back('\x55');
|
|
raw_mem_istream is(s.data(), s.size());
|
|
WireDecoder d(is, 0x0200u);
|
|
StringValue sv;
|
|
ASSERT_TRUE(d.ReadString(&sv));
|
|
EXPECT_EQ(sv_normal, sv);
|
|
ASSERT_TRUE(d.ReadString(&sv));
|
|
EXPECT_EQ(sv_long, sv);
|
|
ASSERT_TRUE(d.ReadString(&sv));
|
|
EXPECT_EQ(sv_big2, sv);
|
|
|
|
unsigned int b;
|
|
ASSERT_TRUE(d.Read8(&b));
|
|
EXPECT_EQ(0x55u, b);
|
|
|
|
ASSERT_FALSE(d.ReadString(&sv));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
TEST_F(WireDecoderTest, ReadString3) {
|
|
std::string s;
|
|
s.push_back('\x05');
|
|
s += s_normal;
|
|
s.append("\x80\x01", 2);
|
|
s += s_long;
|
|
s.append("\x81\x80\x04", 3);
|
|
s += s_big3;
|
|
s.push_back('\x55');
|
|
raw_mem_istream is(s.data(), s.size());
|
|
WireDecoder d(is, 0x0300u);
|
|
StringValue sv;
|
|
ASSERT_TRUE(d.ReadString(&sv));
|
|
EXPECT_EQ(sv_normal, sv);
|
|
ASSERT_TRUE(d.ReadString(&sv));
|
|
EXPECT_EQ(sv_long, sv);
|
|
ASSERT_TRUE(d.ReadString(&sv));
|
|
EXPECT_EQ(sv_big3, sv);
|
|
|
|
unsigned int b;
|
|
ASSERT_TRUE(d.Read8(&b));
|
|
EXPECT_EQ(0x55u, b);
|
|
|
|
ASSERT_FALSE(d.ReadString(&sv));
|
|
ASSERT_EQ(nullptr, d.error());
|
|
}
|
|
|
|
} // namespace ntimpl
|