void RequiredFieldsTest(const From& from)
{
typename Writer::Buffer buffer(1024);
Writer writer(buffer);
bond::Serialize(from, writer);
{
To to;
Reader reader(buffer.GetBuffer());
bond::bonded<From, Reader&> bonded(reader);
bonded.Deserialize(to);
UT_AssertIsTrue(Equal(from, to));
}
{
To to;
Reader reader(buffer.GetBuffer());
bond::bonded<void, Reader&> bonded(reader, bond::GetRuntimeSchema<From>());
bonded.Deserialize(to);
UT_AssertIsTrue(Equal(from, to));
}
}
void BondedCast(const bond::bonded<T1>& bonded, const T2& expected)
{
T2 value;
bonded.Deserialize(value);
UT_AssertIsTrue(Equal(expected, value));
auto value2 = bonded.template Deserialize<T2>();
UT_AssertIsTrue(Equal(expected, value2));
}
void BondedVoid(const bond::bonded<void>& bonded, const T& expected)
{
T value;
bonded.Deserialize(value);
UT_AssertIsTrue(Equal(expected, value));
CopyAndMove(value);
auto value2 = bonded.Deserialize<T>();
UT_AssertIsTrue(Equal(expected, value2));
}
void operator()(const T&)
{
// The test structure contains 2 required fields of type T. The invalid payload
// contains only partial second field. With dynamic parser the missing required
// field leads to missing field exception, and skipping the field during stack
// unrolling results in Eof exception which is internally caught.
// With static parser there is no missing field exception and only Eof exception.
typedef BondStructRequired<T> Type;
bool exception;
bond::blob payload;
payload = InvalidPayload<Writer>::template PartialField<T>();
// compile-time binding
try
{
exception = false;
Deserialize<Reader, Type, Type>(payload);
}
catch(bond::CoreException&)
{
exception = true;
}
catch(bond::StreamException&)
{
UT_AssertIsTrue(bond::uses_static_parser<Reader>::value);
exception = true;
}
UT_AssertIsTrue(exception);
// runtime binding
try
{
exception = false;
Deserialize<Reader, Type, void>(payload);
}
catch(bond::CoreException&)
{
exception = true;
}
catch(bond::StreamException&)
{
UT_AssertIsTrue(bond::uses_static_parser<Reader>::value);
exception = true;
}
UT_AssertIsTrue(exception);
}
void TestReadStruct(Writer& output, Buffer& output_buffer, uint16_t val0, int64_t val1)
{
output.WriteStructBegin(bond::Metadata(), false);
output.WriteFieldBegin(bond::BT_UINT16, 0);
output.Write(val0);
output.WriteFieldEnd();
output.WriteFieldBegin(bond::BT_INT64, 1);
output.Write(val1);
output.WriteFieldEnd();
output.WriteStructEnd();
// read from output, using CB version 2
typename Reader::Buffer input_buffer(output_buffer.GetBuffer());
Reader input(input_buffer, 2);
uint16_t id;
bond::BondDataType type;
uint16_t value0;
int64_t value1;
input.ReadStructBegin();
input.ReadFieldBegin(type, id);
input.Read(value0);
input.ReadFieldEnd();
UT_AssertAreEqual(type, bond::BT_UINT16);
UT_AssertAreEqual(id, 0);
UT_AssertAreEqual(val0, value0);
input.ReadFieldBegin(type, id);
input.Read(value1);
input.ReadFieldEnd();
input.ReadStructEnd();
UT_AssertAreEqual(type, bond::BT_INT64);
UT_AssertAreEqual(id, 1);
UT_AssertAreEqual(val1, value1);
// test skipping struct, using CB version 2
typename Reader::Buffer input_buffer2(output_buffer.GetBuffer());
Reader input2(input_buffer2, 2);
input2.Skip(bond::BT_STRUCT);
UT_AssertIsTrue(input2.GetBuffer().IsEof());
}
void TestEncoding(const std::vector<T>& data)
{
typename Writer::Buffer output_buffer;
Writer output(output_buffer);
for(size_t i = 0; i < data.size(); ++i)
{
output.Write(data[i]);
}
typename Reader::Buffer input_buffer(output_buffer.GetBuffer());
Reader input(input_buffer);
for(size_t i = 0; i < data.size(); ++i)
{
T value;
input.Read(value);
UT_AssertIsTrue(data[i] == value);
}
}
void Merging(Payload payload, const T& obj, uint16_t version = bond::v1, bool mergeByDeserialize = true)
{
Reader merged = Merge<Reader, Writer>(payload, obj, version);
// Deserialize merged into T and compare against obj
{
T to;
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4127) // C4127: conditional expression is constant
#endif
if (boost::mpl::count_if<typename T::Schema::fields, is_optional_field<_> >::value == 0)
#ifdef _MSC_VER
#pragma warning(pop)
#endif
{
to = InitRandom<T>();
Fixup(to);
}
Deserialize(merged, to);
UT_AssertIsTrue(Equal(obj, to));
}
// Deserialize merged into Payload and compare against combination of the
// orginal payload and the obj.
{
Payload to;
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4127) // C4127: conditional expression is constant
#endif
if (boost::mpl::count_if<typename Payload::Schema::fields, is_optional_field<_> >::value == 0)
#ifdef _MSC_VER
#pragma warning(pop)
#endif
{
to = InitRandom<Payload>();
Fixup(to);
}
Deserialize(merged, to);
if (mergeByDeserialize)
{
// Will fail an assert without
// #define BOND_UNIT_TEST_ONLY_PERMIT_OBJECT_REUSE
Deserialize(Serialize<Reader, Writer>(obj, version), payload);
UT_AssertIsTrue(Equal(payload, to));
}
else
{
UT_AssertIsTrue(MergedEqual(payload, to, obj));
}
}
}
