static void test_encoder_factory(uint32_t max_symbols, uint32_t max_symbol_size, int32_t codec, int32_t finite_field) { kodoc_factory_t encoder_factory = kodoc_new_encoder_factory(codec, finite_field, max_symbols, max_symbol_size); // Test the max_* properties EXPECT_EQ(max_symbols, kodoc_factory_max_symbols(encoder_factory)); EXPECT_EQ(max_symbol_size, kodoc_factory_max_symbol_size(encoder_factory)); EXPECT_EQ(max_symbol_size * max_symbols, kodoc_factory_max_block_size(encoder_factory)); EXPECT_GT(kodoc_factory_max_payload_size(encoder_factory), max_symbol_size); // Build an encoder with the default settings kodoc_coder_t encoder = kodoc_factory_build_coder(encoder_factory); EXPECT_EQ(max_symbols, kodoc_symbols(encoder)); EXPECT_EQ(max_symbol_size, kodoc_symbol_size(encoder)); // Lower the number of symbols and the symbol_size uint32_t new_symbols = max_symbols / 2; kodoc_factory_set_symbols(encoder_factory, new_symbols); uint32_t new_symbol_size = max_symbol_size - 4; kodoc_factory_set_symbol_size(encoder_factory, new_symbol_size); // Test that the max_* properties are not changed EXPECT_EQ(max_symbols, kodoc_factory_max_symbols(encoder_factory)); EXPECT_EQ(max_symbol_size, kodoc_factory_max_symbol_size(encoder_factory)); EXPECT_EQ(max_symbol_size * max_symbols, kodoc_factory_max_block_size(encoder_factory)); EXPECT_GT(kodoc_factory_max_payload_size(encoder_factory), max_symbol_size); // Build an encoder with the changed settings kodoc_coder_t encoder2 = kodoc_factory_build_coder(encoder_factory); EXPECT_EQ(new_symbols, kodoc_symbols(encoder2)); EXPECT_EQ(new_symbol_size, kodoc_symbol_size(encoder2)); kodoc_delete_coder(encoder); kodoc_delete_coder(encoder2); kodoc_delete_factory(encoder_factory); }
inline void run_test_basic_api(int32_t encoder_type, int32_t decoder_type, int32_t finite_field, uint32_t symbols, uint32_t symbol_size) { kodoc_factory_t encoder_factory = kodoc_new_encoder_factory( encoder_type, finite_field, symbols, symbol_size); kodoc_factory_t decoder_factory = kodoc_new_decoder_factory( decoder_type, finite_field, symbols, symbol_size); kodoc_coder_t encoder = kodoc_factory_build_coder(encoder_factory); kodoc_coder_t decoder = kodoc_factory_build_coder(decoder_factory); EXPECT_EQ(symbols, kodoc_factory_max_symbols(encoder_factory)); EXPECT_EQ(symbol_size, kodoc_factory_max_symbol_size(encoder_factory)); EXPECT_EQ(symbols, kodoc_symbols(encoder)); EXPECT_EQ(symbol_size, kodoc_symbol_size(encoder)); EXPECT_EQ(symbols, kodoc_factory_max_symbols(decoder_factory)); EXPECT_EQ(symbol_size, kodoc_factory_max_symbol_size(decoder_factory)); EXPECT_EQ(symbols, kodoc_symbols(decoder)); EXPECT_EQ(symbol_size, kodoc_symbol_size(decoder)); EXPECT_EQ(symbols * symbol_size, kodoc_block_size(encoder)); EXPECT_EQ(symbols * symbol_size, kodoc_block_size(decoder)); EXPECT_TRUE(kodoc_factory_max_payload_size(encoder_factory) >= kodoc_payload_size(encoder)); EXPECT_TRUE(kodoc_factory_max_payload_size(decoder_factory) >= kodoc_payload_size(decoder)); EXPECT_EQ(kodoc_factory_max_payload_size(encoder_factory), kodoc_factory_max_payload_size(decoder_factory)); if (encoder_type == kodoc_sparse_full_vector || encoder_type == kodoc_sparse_seed) { // Set the coding vector density on the encoder kodoc_set_density(encoder, 0.2); EXPECT_EQ(0.2, kodoc_density(encoder)); } uint32_t payload_size = kodoc_payload_size(encoder); uint8_t* payload = (uint8_t*) malloc(payload_size); uint8_t** input_symbols = NULL; uint8_t** output_symbols = NULL; // Allocate symbols in non-contiguous buffers input_symbols = (uint8_t**) malloc(symbols * sizeof(uint8_t*)); output_symbols = (uint8_t**) malloc(symbols * sizeof(uint8_t*)); for (uint32_t i = 0; i < symbols; ++i) { // Create the individual symbols for the encoder input_symbols[i] = (uint8_t*) malloc(symbol_size); // Randomize input data for (uint32_t j = 0; j < symbol_size; ++j) input_symbols[i][j] = rand() % 256; // Store the symbol pointer in the encoder kodoc_set_const_symbol(encoder, i, input_symbols[i], symbol_size); // Create the output symbol buffers for the decoder output_symbols[i] = (uint8_t*) malloc(symbol_size); // Specify the output buffers used for decoding kodoc_set_mutable_symbol(decoder, i, output_symbols[i], symbol_size); } if (kodoc_has_symbol_decoding_status_updater_interface(decoder)) { EXPECT_FALSE(kodoc_is_status_updater_enabled(decoder)); kodoc_set_status_updater_on(decoder); EXPECT_TRUE(kodoc_is_status_updater_enabled(decoder)); kodoc_set_status_updater_off(decoder); EXPECT_FALSE(kodoc_is_status_updater_enabled(decoder)); } else { EXPECT_TRUE( decoder_type == kodoc_fulcrum || decoder_type == kodoc_reed_solomon ); } EXPECT_TRUE(kodoc_is_complete(decoder) == 0); while (!kodoc_is_complete(decoder)) { kodoc_write_payload(encoder, payload); kodoc_read_payload(decoder, payload); } EXPECT_TRUE(kodoc_is_complete(decoder) != 0); EXPECT_EQ(symbols, kodoc_rank(decoder)); EXPECT_EQ(symbols, kodoc_symbols_uncoded(decoder)); EXPECT_EQ(0U, kodoc_symbols_partially_decoded(decoder)); EXPECT_EQ(0U, kodoc_symbols_missing(decoder)); assert(input_symbols); assert(output_symbols); // Compare the input and output symbols one-by-one for (uint32_t i = 0; i < symbols; ++i) { EXPECT_EQ(memcmp(input_symbols[i], output_symbols[i], symbol_size), 0); free(input_symbols[i]); free(output_symbols[i]); } free(input_symbols); free(output_symbols); free(payload); kodoc_delete_coder(encoder); kodoc_delete_coder(decoder); kodoc_delete_factory(encoder_factory); kodoc_delete_factory(decoder_factory); }
void test_sliding_window(uint32_t max_symbols, uint32_t max_symbol_size, int32_t finite_field) { kodoc_factory_t encoder_factory = kodoc_new_encoder_factory( kodoc_sliding_window, finite_field, max_symbols, max_symbol_size); kodoc_factory_t decoder_factory = kodoc_new_decoder_factory( kodoc_sliding_window, finite_field, max_symbols, max_symbol_size); kodoc_coder_t encoder = kodoc_factory_build_coder(encoder_factory); kodoc_coder_t decoder = kodoc_factory_build_coder(decoder_factory); EXPECT_EQ(max_symbols,kodoc_factory_max_symbols(encoder_factory)); EXPECT_EQ(max_symbol_size,kodoc_factory_max_symbol_size(encoder_factory)); EXPECT_EQ(max_symbols, kodoc_symbols(encoder)); EXPECT_EQ(max_symbol_size,kodoc_symbol_size(encoder)); EXPECT_EQ(max_symbols, kodoc_factory_max_symbols(decoder_factory)); EXPECT_EQ(max_symbol_size, kodoc_factory_max_symbol_size(decoder_factory)); EXPECT_EQ(max_symbols, kodoc_symbols(decoder)); EXPECT_EQ(max_symbol_size, kodoc_symbol_size(decoder)); EXPECT_EQ(max_symbols * max_symbol_size, kodoc_block_size(encoder)); EXPECT_EQ(max_symbols * max_symbol_size, kodoc_block_size(decoder)); EXPECT_TRUE(kodoc_factory_max_payload_size(encoder_factory) >= kodoc_payload_size(encoder)); EXPECT_TRUE(kodoc_factory_max_payload_size(decoder_factory) >= kodoc_payload_size(decoder)); EXPECT_EQ(kodoc_factory_max_payload_size(encoder_factory), kodoc_factory_max_payload_size(decoder_factory)); uint32_t feedback_size = 0; EXPECT_EQ(kodoc_feedback_size(encoder), kodoc_feedback_size(decoder)); feedback_size = kodoc_feedback_size(encoder); EXPECT_TRUE(feedback_size > 0); // Allocate some storage for a "payload" the payload is what we would // eventually send over a network uint32_t payload_size = kodoc_payload_size(encoder); uint8_t* payload = (uint8_t*) malloc(payload_size); uint8_t* feedback = (uint8_t*) malloc(feedback_size); // Allocate some data to encode. In this case we make a buffer // with the same size as the encoder's block size (the max. // amount a single encoder can encode) uint32_t block_size = kodoc_block_size(encoder); uint8_t* data_in = (uint8_t*) malloc(block_size); uint8_t* data_out = (uint8_t*) malloc(block_size); // Just for fun - fill the data with random data for (uint32_t i = 0; i < block_size; ++i) data_in[i] = rand() % 256; // Install a custom trace function for the encoder and decoder kodoc_set_trace_callback(encoder, encoder_trace_callback, NULL); kodoc_set_trace_callback(decoder, decoder_trace_callback, NULL); // Assign the data buffer to the encoder so that we may start // to produce encoded symbols from it kodoc_set_const_symbols(encoder, data_in, block_size); kodoc_set_mutable_symbols(decoder, data_out, block_size); EXPECT_TRUE(kodoc_is_complete(decoder) == 0); while (!kodoc_is_complete(decoder)) { // Encode the packet into the payload buffer uint32_t payload_used = kodoc_write_payload(encoder, payload); EXPECT_TRUE(payload_used <= kodoc_payload_size(encoder)); // Pass that packet to the decoder kodoc_read_payload(decoder, payload); // All payloads must be innovative due to the perfect feedback EXPECT_TRUE(kodoc_is_partially_complete(decoder) != 0); kodoc_write_feedback(decoder, feedback); kodoc_read_feedback(encoder, feedback); } EXPECT_TRUE(kodoc_is_complete(decoder) != 0); // Check if we properly decoded the data EXPECT_EQ(memcmp(data_in, data_out, block_size), 0); // Check that the trace functions were called at least once EXPECT_GT(encoder_trace_called, 0U); EXPECT_GT(decoder_trace_called, 0U); free(data_in); free(data_out); free(payload); free(feedback); kodoc_delete_coder(encoder); kodoc_delete_coder(decoder); kodoc_delete_factory(encoder_factory); kodoc_delete_factory(decoder_factory); }