inline void
invoke_reuse(uint32_t symbols, uint32_t symbol_size)
{
// Common setting
typename Encoder::factory encoder_factory(symbols, symbol_size);
typename Decoder::factory decoder_factory(symbols, symbol_size);
for(uint32_t i = 0; i < 4; ++i)
{
uint32_t coders = rand_nonzero(10);
std::vector<typename Encoder::pointer> encoders;
std::vector<typename Decoder::pointer> decoders;
for(uint32_t j = 0; j < coders; ++j)
{
encoders.push_back(encoder_factory.build());
decoders.push_back(decoder_factory.build());
}
for(uint32_t j = 0; j < coders; ++j)
{
invoke_reuse_helper(encoders[j], decoders[j]);
}
}
return;
// Test with differing symbols and symbol sizes
for(uint32_t i = 0; i < 4; ++i)
{
uint32_t coders = rand_nonzero(10);
std::vector<typename Encoder::pointer> encoders;
std::vector<typename Decoder::pointer> decoders;
for(uint32_t j = 0; j < coders; ++j)
{
uint32_t s = rand_symbols(encoder_factory.max_symbols());
uint32_t l = rand_symbol_size(encoder_factory.max_symbol_size());
encoder_factory.set_symbols(s);
encoder_factory.set_symbol_size(l);
decoder_factory.set_symbols(s);
decoder_factory.set_symbol_size(l);
encoders.push_back(encoder_factory.build());
decoders.push_back(decoder_factory.build());
}
for(uint32_t j = 0; j < coders; ++j)
{
invoke_reuse_helper(encoders[j], decoders[j]);
}
}
}
void invoke_object(uint32_t max_symbols,
uint32_t max_symbol_size,
uint32_t multiplier)
{
typedef kodo::object_encoder<ObjectData, Encoder, Partitioning>
object_encoder;
typedef kodo::object_decoder<Decoder, Partitioning>
object_decoder;
typedef Partitioning partitioning;
uint32_t object_size = rand_nonzero(max_symbols*max_symbol_size*multiplier);
dummy_object_data data(object_size);
partitioning p(max_symbols, max_symbol_size, object_size);
typename Encoder::factory encoder_factory(max_symbols, max_symbol_size);
typename Decoder::factory decoder_factory(max_symbols, max_symbol_size);
object_encoder obj_encoder(encoder_factory, data);
object_decoder obj_decoder(decoder_factory, obj_encoder.object_size());
EXPECT_EQ(p.blocks(), obj_encoder.encoders());
EXPECT_EQ(p.blocks(), obj_decoder.decoders());
EXPECT_TRUE(obj_encoder.encoders() == obj_decoder.decoders());
EXPECT_EQ(p.object_size(), obj_decoder.object_size());
EXPECT_EQ(p.object_size(), obj_decoder.object_size());
for(uint32_t i = 0; i < obj_encoder.encoders(); ++i)
{
typename Encoder::pointer encoder = obj_encoder.build(i);
typename Decoder::pointer decoder = obj_decoder.build(i);
EXPECT_EQ(p.symbols(i), encoder->symbols());
EXPECT_EQ(p.symbols(i), decoder->symbols());
EXPECT_EQ(p.symbol_size(i), encoder->symbol_size());
EXPECT_EQ(p.symbol_size(i), decoder->symbol_size());
EXPECT_EQ(p.block_size(i), encoder->block_size());
EXPECT_EQ(p.block_size(i), decoder->block_size());
EXPECT_EQ(p.byte_offset(i), encoder->byte_offset());
EXPECT_EQ(p.bytes_used(i), encoder->bytes_used());
EXPECT_EQ(p.bytes_used(i), decoder->bytes_used());
}
}
/// Tests:
/// - object_encoder::encoders() const
/// - object_decoder::decoders() const
/// - object_encoder::build(uint32_t)
/// - object_decoder::build(uint32_t)
TEST(TestObjectCoder, construct_and_invoke_the_basic_api)
{
test_object_coders(32, 1600, 2);
test_object_coders(1, 1600, 2);
uint32_t symbols = rand_symbols();
uint32_t symbol_size = rand_symbol_size();
// Multiplies the data to be encoded so that the object encoder
// is expected to contain multiplier encoders.
uint32_t multiplier = rand_nonzero(10);
test_object_coders(symbols, symbol_size, multiplier);
}
/// Tests:
/// - storage_reader::size() const
/// - storage_reader::read(pointer, uint32_t, uint32_t)
TEST(TestStorageReader, test_storage_reader)
{
uint32_t data_size = 1000;
std::vector<uint8_t> data = random_vector(data_size);
sak::const_storage data_storage = sak::storage(data);
kodo::storage_reader<dummy_encoder> reader(data_storage);
EXPECT_EQ(reader.size(), data_size);
auto encoder = boost::make_shared<dummy_encoder>();
reader.read(encoder, 10U, 10U);
EXPECT_EQ(encoder->m_bytes_used, 10U);
EXPECT_TRUE(sak::equal(encoder->m_symbol_storage,
sak::storage(&data[10], 10U)));
reader.read(encoder, 57U, 101U);
EXPECT_EQ(encoder->m_bytes_used, 101U);
EXPECT_TRUE(sak::equal(encoder->m_symbol_storage,
sak::storage(&data[57], 101U)));
// Try with some random values
uint32_t random_offset = rand_nonzero(data_size - 1);
uint32_t random_size = rand_nonzero(data_size - random_offset);
reader.read(encoder, random_offset, random_size);
EXPECT_EQ(encoder->m_bytes_used, random_size);
EXPECT_TRUE(sak::equal(encoder->m_symbol_storage,
sak::storage(&data[random_offset], random_size)));
}
