void convert_inplace_test_do_it( dl_ctx_t dl_ctx, dl_typeid_t type,
unsigned char* store_buffer, size_t store_size,
unsigned char* out_buffer, size_t* out_size,
unsigned int conv_ptr_size, dl_endian_t conv_endian )
{
/*
About test
since converting pointersizes from smaller to bigger can't be done inplace this test differs
depending on conversion.
tests will use inplace convert if possible, otherwise it checks that the operation returns
DL_ERROR_UNSUPORTED_OPERATION as it should.
ie. if our test is only converting endian we do both conversions inplace, otherwise we
do the supported operation inplace.
*/
unsigned char convert_buffer[2048];
memset( convert_buffer, 0xFE, sizeof(convert_buffer) );
size_t convert_size = 0;
if( conv_ptr_size <= sizeof(void*) )
{
memcpy( convert_buffer, store_buffer, store_size );
EXPECT_DL_ERR_OK( dl_convert_inplace( dl_ctx, type, convert_buffer, store_size, conv_endian, conv_ptr_size, &convert_size ) );
memset( convert_buffer + convert_size, 0xFE, sizeof(convert_buffer) - convert_size );
}
else
{
// check that error is correct
EXPECT_DL_ERR_EQ( DL_ERROR_UNSUPPORTED_OPERATION, dl_convert_inplace( dl_ctx, type, store_buffer, store_size, conv_endian, conv_ptr_size, &convert_size ) );
// convert with ordinary convert
EXPECT_DL_ERR_OK( dl_convert_calc_size( dl_ctx, type, store_buffer, store_size, conv_ptr_size, &convert_size ) );
EXPECT_DL_ERR_OK( dl_convert( dl_ctx, type, store_buffer, store_size, convert_buffer, convert_size, conv_endian, conv_ptr_size, 0x0 ) );
}
EXPECT_EQ( (unsigned char)0xFE, convert_buffer[convert_size] ); // no overwrite on the generated text plox!
EXPECT_INSTANCE_INFO( convert_buffer, convert_size, conv_ptr_size, conv_endian, type );
// convert back!
if( conv_ptr_size < sizeof(void*))
{
// check that error is correct
EXPECT_DL_ERR_EQ( DL_ERROR_UNSUPPORTED_OPERATION, dl_convert_inplace( dl_ctx, type, convert_buffer, store_size, DL_ENDIAN_HOST, sizeof(void*), out_size ) );
// convert with ordinary convert
EXPECT_DL_ERR_OK( dl_convert_calc_size( dl_ctx, type, convert_buffer, convert_size, sizeof(void*), out_size ) );
EXPECT_DL_ERR_OK( dl_convert( dl_ctx, type, convert_buffer, convert_size, out_buffer, *out_size, DL_ENDIAN_HOST, sizeof(void*), 0x0 ) );
}
else
{
memcpy( out_buffer, convert_buffer, convert_size );
EXPECT_DL_ERR_OK( dl_convert_inplace( dl_ctx, type, out_buffer, convert_size, DL_ENDIAN_HOST, sizeof(void*), out_size ) );
memset( out_buffer + *out_size, 0xFE, OUT_BUFFER_SIZE - *out_size );
}
}
TEST_F(DLError, version_mismatch_returned)
{
unused u;
size_t dummy;
unsigned char packed[sizeof(unused) * 10]; // large enough buffer!
unsigned char swaped[sizeof(unused) * 10]; // large enough buffer!
unsigned char bus_buffer[sizeof(unused) * 10]; // large enough buffer!
char bus_text[sizeof(unused) * 10]; // large enough buffer!
dl_endian_t other_endian = DL_ENDIAN_HOST == DL_ENDIAN_LITTLE ? DL_ENDIAN_BIG : DL_ENDIAN_LITTLE;
EXPECT_DL_ERR_OK( dl_instance_store( Ctx, unused::TYPE_ID, &u, packed, DL_ARRAY_LENGTH(packed), 0x0 ) );
EXPECT_DL_ERR_OK( dl_convert( Ctx, unused::TYPE_ID, packed, DL_ARRAY_LENGTH(packed), swaped, DL_ARRAY_LENGTH(swaped), other_endian, sizeof(void*), 0x0 ) );
// testing that errors are returned correctly by modding data.
union
{
unsigned int* instance_version;
unsigned char* instance;
} conv;
conv.instance = packed;
unsigned int* instance_version;
instance_version = conv.instance_version + 1;
EXPECT_EQ(1u, *instance_version);
*instance_version = 0xFFFFFFFF;
conv.instance = swaped;
instance_version = conv.instance_version + 1;
EXPECT_EQ(0x01000000u, *instance_version);
*instance_version = 0xFFFFFFFF;
// test all functions in...
#define EXPECT_DL_ERR_VERSION_MISMATCH( err ) EXPECT_DL_ERR_EQ( DL_ERROR_VERSION_MISMATCH, err )
Pods p;
// dl.h
EXPECT_DL_ERR_VERSION_MISMATCH( dl_instance_load( Ctx, unused::TYPE_ID, &p, sizeof(Pods), packed, DL_ARRAY_LENGTH(packed), 0x0 ) );
// dl_convert.h
EXPECT_DL_ERR_VERSION_MISMATCH( dl_convert( Ctx, unused::TYPE_ID, packed, DL_ARRAY_LENGTH(packed), bus_buffer, DL_ARRAY_LENGTH(bus_buffer), other_endian, sizeof(void*), 0x0 ) );
EXPECT_DL_ERR_VERSION_MISMATCH( dl_convert( Ctx, unused::TYPE_ID, swaped, DL_ARRAY_LENGTH(swaped), bus_buffer, DL_ARRAY_LENGTH(bus_buffer), DL_ENDIAN_HOST, sizeof(void*), 0x0 ) );
EXPECT_DL_ERR_VERSION_MISMATCH( dl_convert_inplace( Ctx, unused::TYPE_ID, packed, DL_ARRAY_LENGTH(packed), other_endian, sizeof(void*), 0x0 ) );
EXPECT_DL_ERR_VERSION_MISMATCH( dl_convert_inplace( Ctx, unused::TYPE_ID, swaped, DL_ARRAY_LENGTH(swaped), DL_ENDIAN_HOST, sizeof(void*), 0x0 ) );
EXPECT_DL_ERR_VERSION_MISMATCH( dl_convert_calc_size( Ctx, unused::TYPE_ID, packed, DL_ARRAY_LENGTH(packed), sizeof(void*), &dummy ) );
EXPECT_DL_ERR_VERSION_MISMATCH( dl_convert_calc_size( Ctx, unused::TYPE_ID, swaped, DL_ARRAY_LENGTH(swaped), sizeof(void*), &dummy ) );
// dl_txt.h
EXPECT_DL_ERR_VERSION_MISMATCH( dl_txt_unpack( Ctx, unused::TYPE_ID, packed, DL_ARRAY_LENGTH(packed), bus_text, DL_ARRAY_LENGTH(bus_text), 0x0 ) );
EXPECT_DL_ERR_VERSION_MISMATCH( dl_txt_unpack_calc_size( Ctx, unused::TYPE_ID, packed, DL_ARRAY_LENGTH(packed), &dummy ) );
#undef EXPECT_DL_ERR_VERSION_MISMATCH
}
TEST_F(DLError, type_mismatch_returned)
{
// testing that DL_ERROR_TYPE_MISMATCH is returned if provided type is not matching type stored in instance
unused u;
size_t dummy;
unsigned char packed[sizeof(unused) * 10]; // large enough buffer!
unsigned char swaped[sizeof(unused) * 10]; // large enough buffer!
unsigned char bus_buffer[sizeof(unused) * 10]; // large enough buffer!
char bus_text[sizeof(unused) * 10]; // large enough buffer!
dl_endian_t other_endian = DL_ENDIAN_HOST == DL_ENDIAN_LITTLE ? DL_ENDIAN_BIG : DL_ENDIAN_LITTLE;
EXPECT_DL_ERR_OK( dl_instance_store( Ctx, unused::TYPE_ID, &u, packed, DL_ARRAY_LENGTH(packed), 0x0 ) );
EXPECT_DL_ERR_OK( dl_convert( Ctx, unused::TYPE_ID, packed, DL_ARRAY_LENGTH(packed), swaped, DL_ARRAY_LENGTH(swaped), other_endian, sizeof(void*), 0x0 ) );
// test all functions in...
#define EXPECT_DL_ERR_TYPE_MISMATCH( err ) EXPECT_DL_ERR_EQ( DL_ERROR_TYPE_MISMATCH, err )
Pods p;
// dl.h
EXPECT_DL_ERR_TYPE_MISMATCH( dl_instance_load( Ctx, Pods::TYPE_ID, &p, sizeof(Pods), packed, DL_ARRAY_LENGTH(packed), 0x0 ) );
// dl_convert.h
EXPECT_DL_ERR_TYPE_MISMATCH( dl_convert( Ctx, Pods::TYPE_ID, packed, DL_ARRAY_LENGTH(packed), bus_buffer, DL_ARRAY_LENGTH(bus_buffer), other_endian, sizeof(void*), 0x0 ) );
EXPECT_DL_ERR_TYPE_MISMATCH( dl_convert( Ctx, Pods::TYPE_ID, swaped, DL_ARRAY_LENGTH(swaped), bus_buffer, DL_ARRAY_LENGTH(bus_buffer), DL_ENDIAN_HOST, sizeof(void*), 0x0 ) );
EXPECT_DL_ERR_TYPE_MISMATCH( dl_convert_inplace( Ctx, Pods::TYPE_ID, packed, DL_ARRAY_LENGTH(packed), other_endian, sizeof(void*), 0x0 ) );
EXPECT_DL_ERR_TYPE_MISMATCH( dl_convert_inplace( Ctx, Pods::TYPE_ID, swaped, DL_ARRAY_LENGTH(swaped), DL_ENDIAN_HOST, sizeof(void*), 0x0 ) );
EXPECT_DL_ERR_TYPE_MISMATCH( dl_convert_calc_size( Ctx, Pods::TYPE_ID, packed, DL_ARRAY_LENGTH(packed), sizeof(void*), &dummy ) );
EXPECT_DL_ERR_TYPE_MISMATCH( dl_convert_calc_size( Ctx, Pods::TYPE_ID, swaped, DL_ARRAY_LENGTH(swaped), sizeof(void*), &dummy ) );
// dl_txt.h
EXPECT_DL_ERR_TYPE_MISMATCH( dl_txt_unpack( Ctx, Pods::TYPE_ID, packed, DL_ARRAY_LENGTH(packed), bus_text, DL_ARRAY_LENGTH(bus_text), 0x0 ) );
EXPECT_DL_ERR_TYPE_MISMATCH( dl_txt_unpack_calc_size( Ctx, Pods::TYPE_ID, packed, DL_ARRAY_LENGTH(packed), &dummy ) );
#undef EXPECT_DL_ERR_TYPE_MISMATCH
}