Skip to content
Snippets Groups Projects
Commit d6e7fa9d authored by Dominik Loidolt's avatar Dominik Loidolt
Browse files

Refactor compression decompression round trip test suite

parent 6e207101
No related branches found
No related tags found
1 merge request!28Updated debug_print(): Enhanced Adaptability for Various Environments
......@@ -15,9 +15,8 @@
*
* @brief random compression decompression tests
* @details We generate random data and compress them with random parameters.
* After that we put the data in a compression entity. We decompress the
* compression entity and compare the decompressed data with the original
* data.
* After that we decompress the compression entity and compare the
* decompressed data with the original data.
*/
......@@ -32,6 +31,7 @@
#include <decmp.h>
#include <cmp_data_types.h>
#include <leon_inttypes.h>
#include <byteorder.h>
#if defined __has_include
# if __has_include(<time.h>)
......@@ -41,13 +41,11 @@
# endif
#endif
#define IMAX_BITS(m) ((m)/((m)%255+1) / 255%255*8 + 7-86/((m)%255+12))
#define RAND_MAX_WIDTH IMAX_BITS(RAND_MAX)
#define ROUND_UP_TO_MULTIPLE_OF_4(x) (((x) + 3) & ~3)
/**
* @brief Seeds the pseudo-random number generator used by rand()
* @brief Seeds the pseudo-random number generator
*/
void setUp(void)
......@@ -69,14 +67,33 @@ void setUp(void)
}
static size_t gen_ima_data(uint16_t *data, uint32_t samples,
const struct cmp_max_used_bits *max_used_bits)
static size_t gen_ima_data(uint16_t *data, enum cmp_data_type data_type,
uint32_t samples, const struct cmp_max_used_bits *max_used_bits)
{
uint32_t i;
if (data)
if (data) {
uint32_t max_data_bits;
switch (data_type) {
case DATA_TYPE_IMAGETTE:
case DATA_TYPE_IMAGETTE_ADAPTIVE:
max_data_bits = max_used_bits->nc_imagette;
break;
case DATA_TYPE_SAT_IMAGETTE:
case DATA_TYPE_SAT_IMAGETTE_ADAPTIVE:
max_data_bits = max_used_bits->saturated_imagette;
break;
case DATA_TYPE_F_CAM_IMAGETTE:
case DATA_TYPE_F_CAM_IMAGETTE_ADAPTIVE:
max_data_bits = max_used_bits->fc_imagette;
break;
default:
TEST_FAIL();
}
for (i = 0; i < samples; i++)
data[i] = (uint16_t)cmp_rand_nbits(max_used_bits->nc_imagette);
data[i] = (uint16_t)cmp_rand_nbits(max_data_bits);
}
return sizeof(*data) * samples;
}
......@@ -365,85 +382,7 @@ static size_t gen_l_fx_efx_ncob_ecob_data(struct l_fx_efx_ncob_ecob *data, uint3
}
static uint8_t get_sst(enum cmp_data_type data_type)
{
uint8_t sst = 0;
switch (data_type) {
case DATA_TYPE_IMAGETTE:
case DATA_TYPE_IMAGETTE_ADAPTIVE:
sst = SST_NCxx_S_SCIENCE_IMAGETTE;
break;
case DATA_TYPE_SAT_IMAGETTE:
case DATA_TYPE_SAT_IMAGETTE_ADAPTIVE:
sst = SST_NCxx_S_SCIENCE_SAT_IMAGETTE;
break;
case DATA_TYPE_OFFSET:
sst = SST_NCxx_S_SCIENCE_OFFSET;
break;
case DATA_TYPE_BACKGROUND:
sst = SST_NCxx_S_SCIENCE_BACKGROUND;
break;
case DATA_TYPE_SMEARING:
sst = SST_NCxx_S_SCIENCE_SMEARING;
break;
case DATA_TYPE_S_FX:
sst = SST_NCxx_S_SCIENCE_S_FX;
break;
case DATA_TYPE_S_FX_EFX:
sst = SST_NCxx_S_SCIENCE_S_FX_EFX;
break;
case DATA_TYPE_S_FX_NCOB:
sst = SST_NCxx_S_SCIENCE_S_FX_NCOB;
break;
case DATA_TYPE_S_FX_EFX_NCOB_ECOB:
sst = SST_NCxx_S_SCIENCE_S_FX_EFX_NCOB_ECOB;
break;
case DATA_TYPE_L_FX:
sst = SST_NCxx_S_SCIENCE_L_FX;
break;
case DATA_TYPE_L_FX_EFX:
sst = SST_NCxx_S_SCIENCE_L_FX_EFX;
break;
case DATA_TYPE_L_FX_NCOB:
sst = SST_NCxx_S_SCIENCE_L_FX_NCOB;
break;
case DATA_TYPE_L_FX_EFX_NCOB_ECOB:
sst = SST_NCxx_S_SCIENCE_L_FX_EFX_NCOB_ECOB;
break;
case DATA_TYPE_F_FX:
sst = SST_NCxx_S_SCIENCE_F_FX;
break;
case DATA_TYPE_F_FX_EFX:
sst = SST_NCxx_S_SCIENCE_F_FX_EFX;
break;
case DATA_TYPE_F_FX_NCOB:
sst = SST_NCxx_S_SCIENCE_F_FX_NCOB;
break;
case DATA_TYPE_F_FX_EFX_NCOB_ECOB:
sst = SST_NCxx_S_SCIENCE_F_FX_EFX_NCOB_ECOB;
break;
case DATA_TYPE_F_CAM_IMAGETTE:
case DATA_TYPE_F_CAM_IMAGETTE_ADAPTIVE:
sst = SST_FCx_S_SCIENCE_IMAGETTE;
break;
case DATA_TYPE_F_CAM_OFFSET:
sst = SST_FCx_S_SCIENCE_OFFSET_VALUES;
break;
case DATA_TYPE_F_CAM_BACKGROUND:
sst = SST_FCx_S_BACKGROUND_VALUES;
break;
default:
case DATA_TYPE_UNKNOWN:
TEST_FAIL();
/* debug_print("Error: Unknown compression data type!\n"); */
};
return sst;
}
size_t generate_random_collection_hdr(struct collection_hdr *col, enum cmp_data_type data_type,
uint32_t generate_random_collection_hdr(struct collection_hdr *col, enum cmp_data_type data_type,
uint32_t samples)
{
static uint8_t sequence_num;
......@@ -452,11 +391,15 @@ size_t generate_random_collection_hdr(struct collection_hdr *col, enum cmp_data_
TEST_ASSERT(data_size <= UINT16_MAX);
if (col) {
#ifdef HAS_TIME_H
TEST_ASSERT_FALSE(cmp_col_set_timestamp(col, cmp_ent_create_timestamp(NULL)));
#else
TEST_ASSERT_FALSE(cmp_col_set_timestamp(col, 0x150D15AB1ED));
#endif
TEST_ASSERT_FALSE(cmp_col_set_configuration_id(col, (uint16_t)cmp_rand32()));
TEST_ASSERT_FALSE(cmp_col_set_pkt_type(col, COL_SCI_PKTS_TYPE));
TEST_ASSERT_FALSE(cmp_col_set_subservice(col, get_sst(data_type)));
TEST_ASSERT_FALSE(cmp_col_set_subservice(col, convert_cmp_data_type_to_subservice(data_type)));
TEST_ASSERT_FALSE(cmp_col_set_ccd_id(col, (uint8_t)cmp_rand_between(0, 3)));
TEST_ASSERT_FALSE(cmp_col_set_sequence_num(col, sequence_num++));
......@@ -467,13 +410,17 @@ size_t generate_random_collection_hdr(struct collection_hdr *col, enum cmp_data_
/**
* @brief generate random test data
* @brief generates a random collection (with header)
*
* @param samples number of random test samples
* @param data_type compression data type of the test data
* @param max_used_bits pointer to a max_used_bits structure
* @param col pointer to where the random collection will be stored;
* if NULL, the function will only return the size of the
* random collection
* @param data_type specifies the compression data type of the test data
* @param samples the number of random test data samples to generate
* @param max_used_bits pointer to a structure that tracks the maximum number of
* bits used
*
* @returns a pointer to the generated random test data
* @return the size of the generated random collection in bytes
*/
size_t generate_random_collection(struct collection_hdr *col, enum cmp_data_type data_type,
......@@ -485,22 +432,17 @@ size_t generate_random_collection(struct collection_hdr *col, enum cmp_data_type
if (col)
science_data = col->entry;
if (rdcu_supported_data_type_is_used(data_type)) {
/* for the rdcu the header counts as data */
size_t hdr_in_samples = COLLECTION_HDR_SIZE/size_of_a_sample(data_type);
TEST_ASSERT(samples >= hdr_in_samples);
samples -= hdr_in_samples;
}
size = generate_random_collection_hdr(col, data_type, samples);
/* TDOO remove me */
int i;
for (i = 0; i < size_of_a_sample(data_type)*samples; ++i) {
if (col){
#if 0
{ int i;
for (i = 0; i < size_of_a_sample(data_type)*samples; i++) {
if (col)
col->entry[i] = i;
}
}
return size+i;
}
#endif
switch (data_type) {
case DATA_TYPE_IMAGETTE:
......@@ -509,7 +451,7 @@ size_t generate_random_collection(struct collection_hdr *col, enum cmp_data_type
case DATA_TYPE_SAT_IMAGETTE_ADAPTIVE:
case DATA_TYPE_F_CAM_IMAGETTE:
case DATA_TYPE_F_CAM_IMAGETTE_ADAPTIVE:
size += gen_ima_data(science_data, samples, max_used_bits);
size += gen_ima_data(science_data, data_type, samples, max_used_bits);
break;
case DATA_TYPE_OFFSET:
size += gen_nc_offset_data(science_data, samples, max_used_bits);
......@@ -575,11 +517,25 @@ struct chunk_def {
};
static size_t generate_random_chunk(void *chunk, struct chunk_def col_array[], size_t array_elements,
/**
* @brief generates a random chunk of collections
*
* @param chunk pointer to where the random chunk will be stored; if
* NULL, the function will only return the size of the
* random chunk
* @param col_array specifies which collections are contained in the chunk
* @param array_elements number of elements in the col_array
* @param max_used_bits pointer to a structure that tracks the maximum number of
* bits used
*
* @return the size of the generated random chunk in bytes
*/
static uint32_t generate_random_chunk(void *chunk, struct chunk_def col_array[], size_t array_elements,
const struct cmp_max_used_bits *max_used_bits)
{
size_t i;
size_t chunk_size = 0;
uint32_t chunk_size = 0;
struct collection_hdr *col = NULL;
for (i = 0; i < array_elements; i++) {
......@@ -599,7 +555,7 @@ static size_t generate_random_chunk(void *chunk, struct chunk_def col_array[], s
* @param cfg pointer to a compression configuration
*/
void generate_random_cmp_par(struct cmp_cfg *cfg)
void generate_random_cmp_cfg(struct cmp_cfg *cfg)
{
if (cmp_imagette_data_type_is_used(cfg->data_type)) {
cfg->cmp_par_imagette = cmp_rand_between(MIN_IMA_GOLOMB_PAR, MAX_IMA_GOLOMB_PAR);
......@@ -644,6 +600,56 @@ void generate_random_cmp_par(struct cmp_cfg *cfg)
}
/**
* @brief generate random chunk compression parameters
*
* @param par pointer where to store the chunk compression
*/
void generate_random_cmp_par(struct cmp_par *par)
{
if (par) {
par->cmp_mode = cmp_rand_between(0, MAX_RDCU_CMP_MODE);
par->model_value = cmp_rand_between(0, MAX_MODEL_VALUE);
par->lossy_par = cmp_rand_between(0, MAX_ICU_ROUND);
par->nc_imagette = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->s_exp_flags = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->s_fx = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->s_ncob = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->s_efx = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->s_ecob = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->l_exp_flags = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->l_fx = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->l_ncob = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->l_efx = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->l_ecob = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->l_fx_cob_variance = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->saturated_imagette = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->nc_offset_mean = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->nc_offset_variance = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->nc_background_mean = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->nc_background_variance = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->nc_background_outlier_pixels = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->smearing_mean = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->smearing_variance_mean = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->smearing_outlier_pixels = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->fc_imagette = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->fc_offset_mean = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->fc_offset_variance = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->fc_background_mean = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->fc_background_variance = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
par->fc_background_outlier_pixels = cmp_rand_between(MIN_NON_IMA_GOLOMB_PAR, MAX_NON_IMA_GOLOMB_PAR);
}
}
/**
* @brief compress the given configuration and decompress it afterwards; finally
* compare the results
......@@ -673,7 +679,7 @@ void compression_decompression(struct cmp_cfg *cfg)
/* create a compression entity */
cmp_data_size = cmp_cal_size_of_data(cfg->buffer_length, cfg->data_type);
cmp_data_size &= ~0x3U; /* the size of the compressed data should be a multiple of 4 */
/* cmp_data_size &= ~0x3U; /1* the size of the compressed data should be a multiple of 4 *1/ */
TEST_ASSERT_NOT_EQUAL_INT(0, cmp_data_size);
cmp_ent_size = cmp_ent_create(NULL, cfg->data_type, cfg->cmp_mode == CMP_MODE_RAW, cmp_data_size);
......@@ -682,12 +688,13 @@ void compression_decompression(struct cmp_cfg *cfg)
cmp_ent_size = cmp_ent_create(ent, cfg->data_type, cfg->cmp_mode == CMP_MODE_RAW, cmp_data_size);
TEST_ASSERT_NOT_EQUAL_UINT(0, cmp_ent_size);
/* we put the coompressed data direct into the compression entity */
/* we put the compressed data direct into the compression entity */
cfg->icu_output_buf = cmp_ent_get_data_buf(ent);
TEST_ASSERT_NOT_NULL(cfg->icu_output_buf);
/* now compress the data */
cmp_size_bits = icu_compress_data(cfg);
TEST_ASSERT(cmp_size_bits > 0);
/* put the compression parameters in the entity header */
......@@ -741,26 +748,27 @@ void compression_decompression(struct cmp_cfg *cfg)
}
#define CMP_BUFFER_FAKTOR 3 /* compression data buffer size / data to compress buffer size */
/**
* @brief random compression decompression test
* @details We generate random data and compress them with random parameters.
* @brief random RDCU like compression decompression test
*
* We generate random imagette data and compress them with random parameters.
* After that we put the data in a compression entity. We decompress the
* compression entity and compare the decompressed data with the original
* data.
* compression entity and compare the decompressed data with the original data.
*
* @test icu_compress_data
* @test decompress_cmp_entiy
*/
#define MB *(1U<<20)
#define MAX_DATA_TO_COMPRESS_SIZE 0x1000B
void test_random_compression_decompression(void)
void test_random_round_trip_like_rdcu_compression(void)
{
enum cmp_data_type data_type;
enum cmp_mode cmp_mode;
struct cmp_cfg cfg;
uint32_t cmp_buffer_size;
enum {
MAX_DATA_TO_COMPRESS_SIZE = 0x1000B,
CMP_BUFFER_FAKTOR = 3 /* compression data buffer size / data to compress buffer size */
};
void *data_to_compress1 = malloc(MAX_DATA_TO_COMPRESS_SIZE);
void *data_to_compress2 = malloc(MAX_DATA_TO_COMPRESS_SIZE);
void *updated_model = calloc(1, MAX_DATA_TO_COMPRESS_SIZE);
......@@ -768,22 +776,19 @@ void test_random_compression_decompression(void)
for (data_type = 1; data_type <= DATA_TYPE_F_CAM_BACKGROUND; data_type++) {
/* printf("%s\n", data_type2string(data_type)); */
/* generate random data*/
/* uint32_t samples = cmp_rand_between(1, 430179/CMP_BUFFER_FAKTOR); */
size_t size;
uint32_t samples = cmp_rand_between(1, UINT16_MAX/size_of_a_sample(data_type));
uint32_t model_value = cmp_rand_between(0, MAX_MODEL_VALUE);
/* void *data_to_compress1 = generate_random_test_data(samples, data_type, &MAX_USED_BITS_V1); */
/* void *data_to_compress2 = generate_random_test_data(samples, data_type, &MAX_USED_BITS_V1); */
/* void *updated_model = calloc(1, cmp_cal_size_of_data(samples, data_type)); */
/* memset(updated_model, 0, MAX_DATA_TO_COMPRESS_SIZE); */
size = generate_random_collection(NULL, data_type, samples, &MAX_USED_BITS_V1);
if (!rdcu_supported_data_type_is_used(data_type))
continue;
size = gen_ima_data(NULL, data_type, samples, &MAX_USED_BITS_V1);
TEST_ASSERT(size <= MAX_DATA_TO_COMPRESS_SIZE);
size = generate_random_collection(data_to_compress1, data_type, samples, &MAX_USED_BITS_V1);
size = gen_ima_data(data_to_compress1, data_type, samples, &MAX_USED_BITS_V1);
TEST_ASSERT(size <= MAX_DATA_TO_COMPRESS_SIZE);
size = generate_random_collection(data_to_compress2, data_type, samples, &MAX_USED_BITS_V1);
size = gen_ima_data(data_to_compress2, data_type, samples, &MAX_USED_BITS_V1);
TEST_ASSERT(size <= MAX_DATA_TO_COMPRESS_SIZE);
/* for (cmp_mode = CMP_MODE_RAW; cmp_mode <= CMP_MODE_STUFF; cmp_mode++) { */
for (cmp_mode = CMP_MODE_RAW; cmp_mode <= CMP_MODE_DIFF_MULTI; cmp_mode++) {
/* printf("cmp_mode: %i\n", cmp_mode); */
......@@ -791,7 +796,7 @@ void test_random_compression_decompression(void)
CMP_LOSSLESS);
TEST_ASSERT_NOT_EQUAL_INT(cfg.data_type, DATA_TYPE_UNKNOWN);
generate_random_cmp_par(&cfg);
generate_random_cmp_cfg(&cfg);
if (!model_mode_is_used(cmp_mode))
cmp_buffer_size = cmp_cfg_icu_buffers(&cfg, data_to_compress1,
......@@ -812,8 +817,11 @@ void test_random_compression_decompression(void)
}
#define N_SAMPLES 5
void test_random_compression_decompression2(void)
/**
* @test icu_compress_data
*/
void test_random_compression_decompress_rdcu_data(void)
{
struct cmp_cfg cfg;
struct cmp_info info = {0};
......@@ -821,7 +829,11 @@ void test_random_compression_decompression2(void)
int s, i, cmp_size_bits;
void *compressed_data;
uint16_t *decompressed_data;
enum {N_SAMPLES = 5};
uint16_t data[N_SAMPLES] = {0, UINT16_MAX, INT16_MAX, 42, 23};
enum {
CMP_BUFFER_FAKTOR = 2 /* compression data buffer size / data to compress buffer size */
};
cfg = cmp_cfg_icu_create(DATA_TYPE_IMAGETTE, CMP_MODE_RAW, 8, CMP_LOSSLESS);
TEST_ASSERT_NOT_EQUAL_INT(cfg.data_type, DATA_TYPE_UNKNOWN);
......@@ -846,173 +858,204 @@ void test_random_compression_decompression2(void)
info.rdcu_cmp_adr_used = cfg.rdcu_buffer_adr;
s = decompress_rdcu_data(compressed_data, &info, NULL, NULL, NULL);
TEST_ASSERT(s > 0);
TEST_ASSERT_EQUAL(sizeof(data), s);
decompressed_data = malloc((size_t)s);
s = decompress_rdcu_data(compressed_data, &info, NULL, NULL, decompressed_data);
TEST_ASSERT(s > 0);
TEST_ASSERT_EQUAL(sizeof(data), s);
for (i = 0; i < N_SAMPLES; i++)
TEST_ASSERT_EQUAL_HEX16(data[i], decompressed_data[i]);
free(compressed_data);
free(decompressed_data);
}
#if 0
int icu_compress_chunk(void *chunk, size_t chunk_size, void *model, void *dst,
size_t dst_capacity);
void no_test_chunk(void)
{
size_t s, i;
struct todo chunk_struct[3];
uint8_t *buf;
uint8_t *dst;
cmp_rand_seed(0);
chunk_struct[0].data_type = DATA_TYPE_F_FX;
chunk_struct[0].samples = 10;
chunk_struct[1].data_type = DATA_TYPE_S_FX;
chunk_struct[1].samples = 3;
static int32_t chunk_round_trip(void *data, uint32_t data_size,
void *model, void *up_model,
uint32_t *cmp_data, uint32_t cmp_data_capacity,
struct cmp_par *cmp_par, int use_decmp_buf, int use_decmp_up_model)
{
int32_t cmp_size;
void *model_cpy = NULL;
chunk_struct[2].data_type = DATA_TYPE_SMEARING;
chunk_struct[2].samples = 4;
/* if in-place model update is used (up_model == model), the model
* needed for decompression is destroyed; therefore we make a copy
*/
if (model) {
if (up_model == model) {
model_cpy = cmp_test_malloc(data_size);
memcpy(model_cpy, model, data_size);
} else {
model_cpy = model;
}
}
s = generate_random_chunk(NULL, chunk_struct, ARRAY_SIZE(chunk_struct), &MAX_USED_BITS_V1);
printf("s: %zu\n", s);
cmp_size = compress_chunk(data, data_size, model, up_model,
cmp_data, cmp_data_capacity, cmp_par);
TEST_ASSERT(cmp_size != CMP_ERROR_HIGH_VALUE);
buf = malloc(s);
s = generate_random_chunk(buf, chunk_struct, ARRAY_SIZE(chunk_struct), &MAX_USED_BITS_V1);
printf("data to compress (s: %zu)\n", s);
for (i = 0; i < s; ++i) {
printf("%02X", buf[i]);
if ((i + 1) % 2 == 0)
printf("\n");
#if 0
{ /* Compress a second time and check for determinism */
int32_t cSize2;
void *compressed2 = NULL;
void *up_model2 = NULL;
if (compressed)
compressed2 = FUZZ_malloc(compressedCapacity);
if (up_model)
up_model2 = FUZZ_malloc(srcSize);
cSize2 = compress_chunk((void *)src, srcSize, (void *)model, up_model2,
compressed2, compressedCapacity, cmp_par);
FUZZ_ASSERT(cSize == cSize2);
FUZZ_ASSERT_MSG(!FUZZ_memcmp(compressed, compressed2, cSize), "Not deterministic!");
FUZZ_ASSERT_MSG(!FUZZ_memcmp(up_model, compressed2, cSize), "NO deterministic!");
free(compressed2);
free(up_model2);
}
dst = malloc(s+1000);
s = icu_compress_chunk(buf, s, NULL, dst, s+1000);
printf("\n\ncompressed data (s: %zu)\n", s);
for (i = 0; i < s; ++i) {
printf("%02X", dst[i]);
if ((i + 1) % 2 == 0)
printf("\n");
#endif
if (cmp_size >= 0 && cmp_data) {
void *decmp_data = NULL;
void *up_model_decmp = NULL;
int decmp_size;
decmp_size = decompress_cmp_entiy((struct cmp_entity *)cmp_data, model_cpy, NULL, NULL);
TEST_ASSERT(decmp_size >= 0);
TEST_ASSERT_EQUAL((uint32_t)decmp_size, data_size);
if (use_decmp_buf)
decmp_data = cmp_test_malloc(data_size);
if (use_decmp_up_model)
up_model_decmp = cmp_test_malloc(data_size);
decmp_size = decompress_cmp_entiy((struct cmp_entity *)cmp_data, model_cpy,
up_model_decmp, decmp_data);
TEST_ASSERT(decmp_size >= 0);
TEST_ASSERT((uint32_t)decmp_size == data_size);
if (use_decmp_buf) {
TEST_ASSERT_EQUAL_HEX8_ARRAY(data, decmp_data, data_size);
TEST_ASSERT(!memcmp(data, decmp_data, data_size));
/*
* the model is only updated when the decompressed_data
* buffer is set
*/
if (up_model && up_model_decmp)
TEST_ASSERT(!memcmp(up_model, up_model_decmp, data_size));
}
free(dst);
free(buf);
free(decmp_data);
free(up_model_decmp);
}
#endif
#include <byteorder.h>
size_t set_cmp_size(uint8_t *p, uint16_t v)
{
v -= COLLECTION_HDR_SIZE;
memset(p, v >> 8, 1);
memset(p+1, v & 0xFF, 1);
return sizeof(uint16_t);
if (up_model == model)
free(model_cpy);
return cmp_size;
}
uint16_t get_cmp_size(uint8_t *p)
/**
* @brief random compression decompression round trip test
*
* We generate random data and compress them with random parameters.
* We decompress the compression entity and compare the decompressed data with
* the original data.
*
* @test compress_chunk
* @test decompress_cmp_entiy
*/
void test_random_chunk_round_trip(void)
{
return ((uint16_t)p[0]<<8) + p[1];
enum cmp_data_type data_type;
enum cmp_mode cmp_mode;
enum { MAX_DATA_TO_COMPRESS_SIZE = CMP_ENTITY_MAX_ORIGINAL_SIZE};
void *data = malloc(CMP_ENTITY_MAX_ORIGINAL_SIZE);
void *model = malloc(MAX_DATA_TO_COMPRESS_SIZE);
void *updated_model = calloc(1, MAX_DATA_TO_COMPRESS_SIZE);
uint32_t cmp_data_capacity = CMP_ENTITY_MAX_SIZE-NON_IMAGETTE_HEADER_SIZE;
void *cmp_data = malloc(cmp_data_capacity);
for (data_type = 1; data_type <= DATA_TYPE_F_CAM_BACKGROUND; data_type++) {
/* printf("%s\n", data_type2string(data_type)); */
/* generate random data*/
size_t size;
uint32_t samples = cmp_rand_between(1, UINT16_MAX/size_of_a_sample(data_type));
size = generate_random_collection(NULL, data_type, samples, &MAX_USED_BITS_SAFE);
TEST_ASSERT(size <= MAX_DATA_TO_COMPRESS_SIZE);
size = generate_random_collection(data, data_type, samples, &MAX_USED_BITS_SAFE);
TEST_ASSERT(size <= MAX_DATA_TO_COMPRESS_SIZE);
size = generate_random_collection(model, data_type, samples, &MAX_USED_BITS_SAFE);
TEST_ASSERT(size <= MAX_DATA_TO_COMPRESS_SIZE);
for (cmp_mode = CMP_MODE_RAW; cmp_mode <= CMP_MODE_DIFF_MULTI; cmp_mode++) {
struct cmp_par par;
int32_t cmp_size;
generate_random_cmp_par(&par);
par.cmp_mode = cmp_mode;
par.lossy_par = CMP_LOSSLESS;
cmp_size = chunk_round_trip(data, (uint32_t)size, model, updated_model,
cmp_data, cmp_data_capacity,
&par, 1, model_mode_is_used(par.cmp_mode));
/* No chunk is defined for fast cadence subservices */
if (data_type == DATA_TYPE_F_FX || data_type == DATA_TYPE_F_FX_EFX ||
data_type == DATA_TYPE_F_FX_NCOB || data_type == DATA_TYPE_F_FX_EFX_NCOB_ECOB)
TEST_ASSERT(cmp_size == -1);
else
TEST_ASSERT(cmp_size > 0);
}
#if 0
remove this
void no_test_new_format(void)
{
uint32_t data_size = cmp_cal_size_of_data(3, DATA_TYPE_L_FX_EFX_NCOB_ECOB);
data_size += cmp_cal_size_of_data(2, DATA_TYPE_L_FX_EFX_NCOB_ECOB);
data_size += cmp_cal_size_of_data(5, DATA_TYPE_L_FX);
data_size += cmp_cal_size_of_data(2, DATA_TYPE_L_FX);
data_size += 3*sizeof(uint16_t);
uint32_t ent_size = cmp_ent_create(NULL, DATA_TYPE_L_FX, 1, data_size);
void *ent = calloc(1, ent_size);
ent_size = cmp_ent_create(ent, DATA_TYPE_L_FX, 1, data_size);
char *p = cmp_ent_get_data_buf(ent);
p +=2;
uint16_t s = generate_random_collection(p, DATA_TYPE_L_FX, 2, &MAX_USED_BITS_V1);
p += set_cmp_size(p-2, s);
p += s;
s = generate_random_collection(p, DATA_TYPE_L_FX, 5, &MAX_USED_BITS_V1);
p += set_cmp_size(p-2, s);
p += s;
s = generate_random_collection(p, DATA_TYPE_L_FX_EFX_NCOB_ECOB, 2, &MAX_USED_BITS_V1);
p += set_cmp_size(p-2, s);
p += s;
s = generate_random_collection(p, DATA_TYPE_L_FX_EFX_NCOB_ECOB, 2, &MAX_USED_BITS_V1);
p+=s;
int num_of_coll =4;
uint8_t *d_p = cmp_ent_get_data_buf(ent);
uint32_t sum =0;
s =0;
for (int c = 1; c <= num_of_coll ; c++) {
uint16_t cmp_col_size;
if (c == num_of_coll)
cmp_col_size = cmp_ent_get_cmp_data_size(ent)- sum;
else{
cmp_col_size = get_cmp_size(&d_p[s]);
sum += cmp_col_size;
s+=2;
}
uint16_t col_size = cmp_col_get_data_length(&d_p[s]);
printf("cmp_col_sizel: %X col_size: %X\n", cmp_col_size, col_size);
for (int i = s-2; i < s+col_size +COLLECTION_HDR_SIZE; ++i) {
printf("%02X ",((uint8_t *)d_p)[i]);
if ((i + 1) % 2 == 0)
printf("\n");
}
TEST_ASSERT(cmp_col_size == col_size);
s+=col_size+COLLECTION_HDR_SIZE;
}
free(data);
free(model);
free(updated_model);
free(cmp_data);
}
#endif
#if 0
/* #include "../../lib/common/byteorder.h" */
void NOOO_test_cmp_collection_raw(void)
/**
* @test compress_chunk
* @test decompress_cmp_entiy
*/
void test_cmp_collection_raw(void)
{
struct collection_hdr *col = NULL;
uint32_t samples = 2;
size_t col_size, dst_capacity = 0;
uint32_t dst_capacity = 0;
struct s_fx *data;
uint32_t *dst = NULL;
int dst_capacity_used = 0;
struct cmp_par par = {0};
const size_t exp_col_size = COLLECTION_HDR_SIZE+2*sizeof(struct s_fx);
const size_t exp_cmp_size_byte = exp_col_size;
const uint32_t col_size = COLLECTION_HDR_SIZE+2*sizeof(struct s_fx);
const size_t exp_cmp_size_byte = GENERIC_HEADER_SIZE + col_size;
int cmp_size_byte;
par.cmp_mode = CMP_MODE_RAW;
col_size = generate_random_collection(col, DATA_TYPE_S_FX, samples, &MAX_USED_BITS_SAFE);
TEST_ASSERT_EQUAL(exp_col_size, col_size);
col = malloc(col_size);
TEST_ASSERT_NOT_NULL(col);
col_size = generate_random_collection(col, DATA_TYPE_S_FX, samples, &MAX_USED_BITS_SAFE);
TEST_ASSERT_EQUAL(exp_col_size, col_size);
col = malloc(col_size); TEST_ASSERT_NOT_NULL(col);
generate_random_collection_hdr(col, DATA_TYPE_S_FX, samples);
data = (struct s_fx *)col->entry;
data[0].exp_flags = 0;
data[0].fx = 0;
data[1].exp_flags = 0xF0;
data[1].fx = 0xABCDE0FF;
dst_capacity = (size_t)cmp_collection(col, NULL, dst, dst_capacity, &par, dst_capacity_used);
TEST_ASSERT_EQUAL_INT(exp_cmp_size_byte, dst_capacity);
cmp_size_byte = compress_chunk(col, col_size, NULL, NULL, dst, dst_capacity, &par);
TEST_ASSERT_EQUAL_INT(exp_cmp_size_byte, cmp_size_byte);
dst_capacity = (uint32_t)cmp_size_byte;
dst = malloc(dst_capacity);
TEST_ASSERT_NOT_NULL(dst);
dst_capacity_used = cmp_collection(col, NULL, dst, dst_capacity, &par, dst_capacity_used);
TEST_ASSERT_EQUAL_INT(exp_cmp_size_byte, dst_capacity_used);
cmp_size_byte = compress_chunk(col, col_size, NULL, NULL, dst, dst_capacity, &par);
TEST_ASSERT_EQUAL_INT(exp_cmp_size_byte, cmp_size_byte);
{
uint8_t *p = (uint8_t *)dst;
uint8_t *p = (uint8_t *)dst+GENERIC_HEADER_SIZE;
struct collection_hdr *raw_cmp_col = (struct collection_hdr *)p;
struct s_fx *raw_cmp_data = (void *)raw_cmp_col->entry;
......@@ -1023,62 +1066,69 @@ void NOOO_test_cmp_collection_raw(void)
TEST_ASSERT_EQUAL_HEX(data[1].exp_flags, raw_cmp_data[1].exp_flags);
TEST_ASSERT_EQUAL_HEX(data[1].fx, be32_to_cpu(raw_cmp_data[1].fx));
}
{ /* decompress the data */
int decmp_size;
uint8_t *decompressed_data;
memset(dst, 0, dst_capacity);
decmp_size = decompress_cmp_entiy((struct cmp_entity *)dst, NULL, NULL, NULL);
TEST_ASSERT_EQUAL_INT(col_size, decmp_size);
decompressed_data = malloc((size_t)decmp_size); TEST_ASSERT_TRUE(decompressed_data);
decmp_size = decompress_cmp_entiy((struct cmp_entity *)dst, NULL, NULL, decompressed_data);
TEST_ASSERT_EQUAL_INT(col_size, decmp_size);
TEST_ASSERT_EQUAL_HEX8_ARRAY(col, decompressed_data, decmp_size);
free(decompressed_data);
}
/* error case: buffer for the compressed data is to small */
dst_capacity -= 1;
dst_capacity_used = cmp_collection(col, NULL, dst, dst_capacity, &par, dst_capacity_used);
TEST_ASSERT_EQUAL_INT(CMP_ERROR_SMALL_BUF, dst_capacity_used);
TEST_ASSERT_EQUAL_INT(CMP_ERROR_SMALL_BUF, compress_chunk(col, col_size, NULL, NULL, dst, dst_capacity, &par));
free(col);
free(dst);
}
void NOOO_test_cmp_collection_diff(void)
/**
* @test compress_chunk
* @test decompress_cmp_entiy
*/
void test_cmp_collection_diff(void)
{
struct collection_hdr *col = NULL;
uint32_t *dst = NULL;
size_t dst_capacity = 0;
int dst_capacity_used = 33;
uint32_t dst_capacity = 0;
struct cmp_par par = {0};
const uint16_t cmp_size_byte_exp = 2;
{ /* generate test data */
struct s_fx *data;
uint32_t samples = 2;
size_t col_size;
const size_t exp_col_size = COLLECTION_HDR_SIZE+samples*sizeof(*data);
const uint32_t samples = 2;
const uint32_t col_size = COLLECTION_HDR_SIZE+samples*sizeof(*data);
col_size = generate_random_collection(col, DATA_TYPE_S_FX, samples, &MAX_USED_BITS_SAFE);
TEST_ASSERT_EQUAL(exp_col_size, col_size);
col = malloc(col_size); TEST_ASSERT_NOT_NULL(col);
col_size = generate_random_collection(col, DATA_TYPE_S_FX, samples, &MAX_USED_BITS_SAFE);
TEST_ASSERT_EQUAL(exp_col_size, col_size);
/* generate test data */
col = malloc(col_size); TEST_ASSERT_NOT_NULL(col);
generate_random_collection_hdr(col, DATA_TYPE_S_FX, samples);
data = (struct s_fx *)col->entry;
data[0].exp_flags = 0;
data[0].fx = 0;
data[1].exp_flags = 1;
data[1].fx = 1;
}
{ /* compress data */
int cmp_size_byte;
const int exp_cmp_size_byte = dst_capacity_used + CMP_COLLECTION_FILD_SIZE
+ COLLECTION_HDR_SIZE + cmp_size_byte_exp;;
const int exp_cmp_size_byte = NON_IMAGETTE_HEADER_SIZE + CMP_COLLECTION_FILD_SIZE
+ COLLECTION_HDR_SIZE + cmp_size_byte_exp;
par.cmp_mode = CMP_MODE_DIFF_ZERO;
par.s_exp_flags = 1;
par.s_fx = 1;
cmp_size_byte = cmp_collection(col, NULL, dst, dst_capacity, &par, dst_capacity_used);
cmp_size_byte = compress_chunk(col, col_size, NULL, NULL, dst, dst_capacity, &par);
TEST_ASSERT_EQUAL_INT(exp_cmp_size_byte, cmp_size_byte);
dst_capacity = (size_t)ROUND_UP_TO_MULTIPLE_OF_4(cmp_size_byte);
dst_capacity = (uint32_t)ROUND_UP_TO_MULTIPLE_OF_4(cmp_size_byte);
dst = malloc(dst_capacity); TEST_ASSERT_NOT_NULL(dst);
memset(dst, 0xFF, dst_capacity);
cmp_size_byte = cmp_collection(col, NULL, dst, dst_capacity, &par, dst_capacity_used);
cmp_size_byte = compress_chunk(col, col_size, NULL, NULL, dst, dst_capacity, &par);
TEST_ASSERT_EQUAL_INT(exp_cmp_size_byte, cmp_size_byte);
}
......@@ -1086,8 +1136,8 @@ void NOOO_test_cmp_collection_diff(void)
uint8_t *p = (uint8_t *)dst;
uint16_t cmp_collection_size_exp = cpu_to_be16(cmp_size_byte_exp);
TEST_ASSERT_EACH_EQUAL_HEX8(0xFF, p, dst_capacity_used);
p += dst_capacity_used;
/* TODO: check the entity header */
p += NON_IMAGETTE_HEADER_SIZE;
TEST_ASSERT_EQUAL_HEX8_ARRAY(&cmp_collection_size_exp, p, CMP_COLLECTION_FILD_SIZE);
p += CMP_COLLECTION_FILD_SIZE;
......@@ -1097,68 +1147,72 @@ void NOOO_test_cmp_collection_diff(void)
TEST_ASSERT_EQUAL_HEX8(0xAE, *p++);
TEST_ASSERT_EQUAL_HEX8(0xE0, *p++);
TEST_ASSERT_EQUAL_HEX8(0x00, *p++);
TEST_ASSERT_EQUAL_HEX8(0x00, *p++);
TEST_ASSERT_EQUAL_HEX8(0x00, *p++);
TEST_ASSERT_EQUAL_size_t(dst_capacity, p - (uint8_t *)dst);
}
{ /* decompress the data */
int decmp_size;
uint8_t *decompressed_data;
decmp_size = decompress_cmp_entiy((struct cmp_entity *)dst, NULL, NULL, NULL);
TEST_ASSERT_EQUAL_INT(col_size, decmp_size);
decompressed_data = malloc((size_t)decmp_size); TEST_ASSERT_TRUE(decompressed_data);
decmp_size = decompress_cmp_entiy((struct cmp_entity *)dst, NULL, NULL, decompressed_data);
TEST_ASSERT_EQUAL_INT(col_size, decmp_size);
TEST_ASSERT_EQUAL_HEX8_ARRAY(col, decompressed_data, decmp_size);
free(decompressed_data);
}
/* error cases dst buffer to small */
dst_capacity -= 1;
dst_capacity_used = cmp_collection(col, NULL, dst, dst_capacity, &par, dst_capacity_used);
TEST_ASSERT_EQUAL_INT(CMP_ERROR_SMALL_BUF, dst_capacity_used);
TEST_ASSERT_EQUAL_INT(CMP_ERROR_SMALL_BUF, compress_chunk(col, col_size, NULL, NULL, dst, dst_capacity, &par));
free(col);
free(dst);
}
void NOOO_test_cmp_collection_worst_case(void)
/**
* @test compress_chunk
* @test decompress_cmp_entiy
*/
void test_cmp_collection_worst_case(void)
{
struct collection_hdr *col = NULL;
uint32_t *dst = NULL;
size_t dst_capacity = 0;
int dst_capacity_used = 4;
uint32_t dst_capacity = 0;
struct cmp_par par = {0};
const uint16_t cmp_size_byte_exp = 2*sizeof(struct s_fx);
int cmp_size_byte;
{ /* generate test data */
struct s_fx *data;
uint32_t samples = 2;
size_t col_size;
const size_t exp_col_size = COLLECTION_HDR_SIZE+samples*sizeof(*data);
const uint32_t col_size = COLLECTION_HDR_SIZE+samples*sizeof(*data);
col_size = generate_random_collection(col, DATA_TYPE_S_FX, samples, &MAX_USED_BITS_SAFE);
TEST_ASSERT_EQUAL(exp_col_size, col_size);
/* generate test data */
col = malloc(col_size); TEST_ASSERT_NOT_NULL(col);
col_size = generate_random_collection(col, DATA_TYPE_S_FX, samples, &MAX_USED_BITS_SAFE);
TEST_ASSERT_EQUAL(exp_col_size, col_size);
generate_random_collection_hdr(col, DATA_TYPE_S_FX, samples);
data = (struct s_fx *)col->entry;
data[0].exp_flags = 0x4;
data[0].fx = 0x0000000E;
data[1].exp_flags = 0x4;
data[1].fx = 0x00000016;
;
}
{ /* compress data */
const int exp_cmp_size_byte = dst_capacity_used + CMP_COLLECTION_FILD_SIZE
+ COLLECTION_HDR_SIZE + cmp_size_byte_exp;;
const int exp_cmp_size_byte = NON_IMAGETTE_HEADER_SIZE + CMP_COLLECTION_FILD_SIZE
+ COLLECTION_HDR_SIZE + cmp_size_byte_exp;
par.cmp_mode = CMP_MODE_DIFF_ZERO;
par.s_exp_flags = 1;
par.s_fx = 1;
cmp_size_byte = cmp_collection(col, NULL, dst, dst_capacity, &par, dst_capacity_used);
cmp_size_byte = compress_chunk(col, col_size, NULL, NULL, dst, dst_capacity, &par);
TEST_ASSERT_EQUAL_INT(exp_cmp_size_byte, cmp_size_byte);
dst_capacity = 1000;
dst_capacity = (uint32_t)cmp_size_byte;
dst = malloc(dst_capacity); TEST_ASSERT_NOT_NULL(dst);
memset(dst, 0xFF, dst_capacity);
cmp_size_byte = cmp_collection(col, NULL, dst, dst_capacity, &par, dst_capacity_used);
cmp_size_byte = compress_chunk(col, col_size, NULL, NULL, dst, dst_capacity, &par);
TEST_ASSERT_EQUAL_INT(exp_cmp_size_byte, cmp_size_byte);
}
......@@ -1166,8 +1220,8 @@ void NOOO_test_cmp_collection_worst_case(void)
uint8_t *p = (uint8_t *)dst;
uint16_t cmp_collection_size_exp = cpu_to_be16(cmp_size_byte_exp);
TEST_ASSERT_EACH_EQUAL_HEX8(0xFF, p, dst_capacity_used);
p += dst_capacity_used;
/* TODO: check the entity header */
p += NON_IMAGETTE_HEADER_SIZE;
TEST_ASSERT_EQUAL_HEX8_ARRAY(&cmp_collection_size_exp, p, CMP_COLLECTION_FILD_SIZE);
p += CMP_COLLECTION_FILD_SIZE;
......@@ -1188,19 +1242,121 @@ void NOOO_test_cmp_collection_worst_case(void)
TEST_ASSERT_EQUAL_size_t(cmp_size_byte, p - (uint8_t *)dst);
}
{ /* decompress the data */
int decmp_size;
uint8_t *decompressed_data;
decmp_size = decompress_cmp_entiy((struct cmp_entity *)dst, NULL, NULL, NULL);
TEST_ASSERT_EQUAL_INT(col_size, decmp_size);
decompressed_data = malloc((size_t)decmp_size); TEST_ASSERT_TRUE(decompressed_data);
decmp_size = decompress_cmp_entiy((struct cmp_entity *)dst, NULL, NULL, decompressed_data);
TEST_ASSERT_EQUAL_INT(col_size, decmp_size);
TEST_ASSERT_EQUAL_HEX8_ARRAY(col, decompressed_data, decmp_size);
free(decompressed_data);
}
#endif
free(dst);
free(col);
}
/**
* @test compress_chunk
* @test decompress_cmp_entiy
*/
void test_cmp_collection_imagette_worst_case(void)
{
struct collection_hdr *col = NULL;
uint32_t *dst = NULL;
struct cmp_par par = {0};
uint16_t const cmp_size_byte_exp = 10*sizeof(uint16_t);
int cmp_size_byte;
uint32_t const col_size = COLLECTION_HDR_SIZE + cmp_size_byte_exp;
{ /* generate test data */
uint16_t *data;
col = malloc(col_size); TEST_ASSERT_NOT_NULL(col);
generate_random_collection_hdr(col, DATA_TYPE_IMAGETTE, 10);
data = (void *)col->entry;
data[0] = 0x0102;
data[1] = 0x0304;
data[2] = 0x0506;
data[3] = 0x0708;
data[4] = 0x090A;
data[5] = 0x0B0C;
data[6] = 0x0D0E;
data[7] = 0x0F10;
data[8] = 0x1112;
data[9] = 0x1314;
}
{ /* compress data */
uint32_t dst_capacity = 0;
const int exp_cmp_size_byte = NON_IMAGETTE_HEADER_SIZE + CMP_COLLECTION_FILD_SIZE
+ COLLECTION_HDR_SIZE + cmp_size_byte_exp;
par.cmp_mode = CMP_MODE_DIFF_MULTI;
par.nc_imagette = 62;
cmp_size_byte = compress_chunk(col, col_size, NULL, NULL, dst, dst_capacity, &par);
TEST_ASSERT_EQUAL_INT(exp_cmp_size_byte, cmp_size_byte);
dst_capacity = (uint32_t)cmp_size_byte;
dst = malloc(dst_capacity); TEST_ASSERT_NOT_NULL(dst);
memset(dst, 0xFF, dst_capacity);
cmp_size_byte = compress_chunk(col, col_size, NULL, NULL, dst, dst_capacity, &par);
TEST_ASSERT_EQUAL_INT(exp_cmp_size_byte, cmp_size_byte);
}
{ /* check the compressed data */
uint32_t i;
uint8_t *p = (uint8_t *)dst;
uint16_t cmp_collection_size_exp = cpu_to_be16(cmp_size_byte_exp);
/* TODO: check the entity header */
p += NON_IMAGETTE_HEADER_SIZE;
void test_cmp_chunk_raw2(void)
TEST_ASSERT_EQUAL_HEX8_ARRAY(&cmp_collection_size_exp, p, CMP_COLLECTION_FILD_SIZE);
p += CMP_COLLECTION_FILD_SIZE;
TEST_ASSERT(memcmp(col, p, COLLECTION_HDR_SIZE) == 0);
p += COLLECTION_HDR_SIZE;
for (i = 1; i <= col_size-COLLECTION_HDR_SIZE; ++i)
TEST_ASSERT_EQUAL_HEX8(i, *p++);
TEST_ASSERT_EQUAL_size_t(cmp_size_byte, p - (uint8_t *)dst);
}
{ /* decompress the data */
int decmp_size;
uint8_t *decompressed_data;
decmp_size = decompress_cmp_entiy((struct cmp_entity *)dst, NULL, NULL, NULL);
TEST_ASSERT_EQUAL_INT(col_size, decmp_size);
decompressed_data = malloc((size_t)decmp_size); TEST_ASSERT_TRUE(decompressed_data);
decmp_size = decompress_cmp_entiy((struct cmp_entity *)dst, NULL, NULL, decompressed_data);
TEST_ASSERT_EQUAL_INT(col_size, decmp_size);
TEST_ASSERT_EQUAL_HEX8_ARRAY(col, decompressed_data, decmp_size);
free(decompressed_data);
}
}
/**
* @test compress_chunk
* @test decompress_cmp_entiy
*/
void test_cmp_decmp_chunk_raw(void)
{
struct cmp_par par = {0};
struct chunk_def chunk_def[2] = {{DATA_TYPE_S_FX, 2}, {DATA_TYPE_S_FX_EFX_NCOB_ECOB, 3}};
size_t chunk_size;
uint32_t chunk_size;
size_t chunk_size_exp = 2*sizeof(struct s_fx) + 3*sizeof(struct s_fx_efx_ncob_ecob) + 2*COLLECTION_HDR_SIZE;
void *chunk = NULL;
uint32_t *dst = NULL;
int dst_capacity = 0;
uint32_t dst_capacity = 0;
/* generate test data */
chunk_size = generate_random_chunk(chunk, chunk_def, ARRAY_SIZE(chunk_def), &MAX_USED_BITS_SAFE);
......@@ -1212,37 +1368,33 @@ void test_cmp_chunk_raw2(void)
/* "compress" data */
{
size_t cmp_size_byte_exp = GENERIC_HEADER_SIZE + chunk_size_exp;
size_t cmp_size_exp = GENERIC_HEADER_SIZE + chunk_size_exp;
int cmp_size;
par.cmp_mode = CMP_MODE_RAW;
dst_capacity = compress_chunk(chunk, chunk_size, NULL, NULL, dst, dst_capacity, &par);
TEST_ASSERT_EQUAL_INT(cmp_size_byte_exp, dst_capacity);
dst = calloc(1, dst_capacity);
TEST_ASSERT_NOT_NULL(dst);
dst_capacity = compress_chunk(chunk, chunk_size, NULL, NULL, dst, dst_capacity, &par);
TEST_ASSERT_EQUAL_INT(cmp_size_byte_exp, dst_capacity);
cmp_size = compress_chunk(chunk, chunk_size, NULL, NULL, dst, dst_capacity, &par);
TEST_ASSERT_EQUAL_INT(cmp_size_exp, cmp_size);
dst_capacity = (uint32_t)cmp_size;
dst = malloc(dst_capacity); TEST_ASSERT_NOT_NULL(dst);
cmp_size = compress_chunk(chunk, chunk_size, NULL, NULL, dst, dst_capacity, &par);
TEST_ASSERT_EQUAL_INT(cmp_size_exp, dst_capacity);
}
/* check results */
{
uint8_t *p = (uint8_t *)dst;
/* uint16_t cmp_collection_size_exp = cpu_to_be16(2*sizeof(struct s_fx)); */
struct collection_hdr *col = (struct collection_hdr *)chunk;
struct s_fx *cmp_data_raw_1;
struct s_fx *data = (void *)col->entry;
int i;
/* TODO: Check header */
TEST_ASSERT_EQUAL_HEX(chunk_size, cmp_ent_get_original_size(dst));
TEST_ASSERT_EQUAL_HEX(chunk_size+GENERIC_HEADER_SIZE, cmp_ent_get_size(dst));
/* TODO: Check entity header */
TEST_ASSERT_EQUAL_HEX(chunk_size, cmp_ent_get_original_size((struct cmp_entity *)dst));
TEST_ASSERT_EQUAL_HEX(chunk_size+GENERIC_HEADER_SIZE, cmp_ent_get_size((struct cmp_entity *)dst));
p += GENERIC_HEADER_SIZE;
/* TEST_ASSERT(memcmp(p, &cmp_collection_size_exp, CMP_COLLECTION_FILD_SIZE) == 0); */
/* p += CMP_COLLECTION_FILD_SIZE; */
TEST_ASSERT(memcmp(col, p, COLLECTION_HDR_SIZE) == 0);
p += COLLECTION_HDR_SIZE;
......@@ -1254,10 +1406,6 @@ void test_cmp_chunk_raw2(void)
p += 2*sizeof(struct s_fx);
/* check 2nd collection */
/* cmp_collection_size_exp = cpu_to_be16(3*sizeof(struct s_fx_efx_ncob_ecob)); */
/* TEST_ASSERT(memcmp(p, &cmp_collection_size_exp, CMP_COLLECTION_FILD_SIZE) == 0); */
/* p += CMP_COLLECTION_FILD_SIZE; */
col = (struct collection_hdr *) ((char *)col + cmp_col_get_size(col));
TEST_ASSERT(memcmp(col, p, COLLECTION_HDR_SIZE) == 0);
p += COLLECTION_HDR_SIZE;
......@@ -1279,20 +1427,21 @@ void test_cmp_chunk_raw2(void)
void *decompressed_data = NULL;
int decmp_size = decompress_cmp_entiy((void *)dst, NULL, NULL, decompressed_data);
TEST_ASSERT_EQUAL_size_t(chunk_size, decmp_size);
decompressed_data = malloc((size_t)decmp_size); TEST_ASSERT_NOT_NULL(decompressed_data);
decmp_size = decompress_cmp_entiy((void *)dst, NULL, NULL, decompressed_data);
TEST_ASSERT_EQUAL_INT(chunk_size, decmp_size);
TEST_ASSERT_EQUAL_HEX8_ARRAY(chunk, decompressed_data, chunk_size);
free(decompressed_data);
}
{ /* error case: buffer to small for compressed data */
int cmp_size;
/* error cases */
memset(dst, 0, dst_capacity);
/* buffer to small for compressed data */
dst_capacity -= 1;
dst_capacity = compress_chunk(chunk, chunk_size, NULL, NULL, dst, dst_capacity, &par);
TEST_ASSERT_EQUAL_INT(CMP_ERROR_SMALL_BUF, dst_capacity);
cmp_size = compress_chunk(chunk, chunk_size, NULL, NULL, dst, dst_capacity, &par);
TEST_ASSERT_EQUAL_INT(CMP_ERROR_SMALL_BUF, cmp_size);
}
free(chunk);
}
......@@ -1316,8 +1465,8 @@ void test_cmp_decmp_chunk_worst_case(void)
chunk_size = (uint32_t)generate_random_chunk(chunk, chunk_def, ARRAY_SIZE(chunk_def), &MAX_USED_BITS_SAFE);
TEST_ASSERT_EQUAL_size_t(CHUNK_SIZE_EXP, chunk_size);
/* "compress" data */
{
{ /* "compress" data */
size_t cmp_size_byte_exp = NON_IMAGETTE_HEADER_SIZE + 2*CMP_COLLECTION_FILD_SIZE + CHUNK_SIZE_EXP;
par.cmp_mode = CMP_MODE_DIFF_ZERO;
......@@ -1333,8 +1482,7 @@ void test_cmp_decmp_chunk_worst_case(void)
TEST_ASSERT_EQUAL_INT(cmp_size_byte_exp, cmp_size_byte);
}
/* check results */
{
{ /* check results */
uint8_t *p = (uint8_t *)dst;
uint16_t cmp_collection_size_exp = cpu_to_be16(2*sizeof(struct s_fx));
struct collection_hdr *col = (struct collection_hdr *)chunk;
......@@ -1342,7 +1490,7 @@ void test_cmp_decmp_chunk_worst_case(void)
struct s_fx *data = (void *)col->entry;
int i;
/* TODO: Check header */
/* TODO: Check entity header */
p += NON_IMAGETTE_HEADER_SIZE;
TEST_ASSERT_EQUAL_HEX8_ARRAY(&cmp_collection_size_exp, p, CMP_COLLECTION_FILD_SIZE);
......@@ -1383,18 +1531,17 @@ void test_cmp_decmp_chunk_worst_case(void)
{
void *decompressed_data = NULL;
int decmp_size = decompress_cmp_entiy((void *)dst, NULL, NULL, decompressed_data);
TEST_ASSERT_EQUAL_size_t(chunk_size, decmp_size);
decompressed_data = malloc((size_t)decmp_size); TEST_ASSERT_NOT_NULL(decompressed_data);
decmp_size = decompress_cmp_entiy((void *)dst, NULL, NULL, decompressed_data);
TEST_ASSERT_EQUAL_INT(chunk_size, decmp_size);
TEST_ASSERT_EQUAL_HEX8_ARRAY(chunk, decompressed_data, chunk_size);
free(decompressed_data);
}
/* error cases */
memset(dst, 0, sizeof(dst));
/* buffer to small for compressed data */
/* error case: buffer to small for compressed data */
cmp_size_byte = compress_chunk(chunk, chunk_size, NULL, NULL, dst, chunk_size, &par);
TEST_ASSERT_EQUAL_INT(CMP_ERROR_SMALL_BUF, cmp_size_byte);
......@@ -1405,13 +1552,11 @@ void test_cmp_decmp_chunk_worst_case(void)
void test_cmp_decmp_diff(void)
{
struct chunk_def chunk_def[2] = {{DATA_TYPE_S_FX, 2}, {DATA_TYPE_S_FX_EFX_NCOB_ECOB, 3}};
size_t chunk_size;
uint32_t chunk_size;
void *chunk = NULL;
uint32_t *dst = NULL;
int dst_capacity = 0;
/* generate test data */
{
{ /* generate test data */
struct s_fx *col_data1;
struct s_fx_efx_ncob_ecob *col_data2;
struct collection_hdr *col;
......@@ -1456,10 +1601,10 @@ void test_cmp_decmp_diff(void)
col_data2[2].ecob_y = 2;
}
/* compress data */
{
{ /* compress data */
struct cmp_par par = {0};
uint32_t dst_capacity = 0;
int cmp_size;
par.cmp_mode = CMP_MODE_DIFF_ZERO;
par.s_exp_flags = 1;
......@@ -1469,13 +1614,13 @@ void test_cmp_decmp_diff(void)
par.s_ecob = 5;
dst_capacity = compress_chunk(chunk, chunk_size, NULL, NULL, dst, dst_capacity, &par);
TEST_ASSERT_GREATER_THAN_INT(0, dst_capacity);
/* TODO: */ dst_capacity = ROUND_UP_TO_MULTIPLE_OF_4(dst_capacity);
cmp_size = compress_chunk(chunk, chunk_size, NULL, NULL, dst, dst_capacity, &par);
TEST_ASSERT_GREATER_THAN_INT(0, cmp_size);
dst_capacity = (uint32_t)ROUND_UP_TO_MULTIPLE_OF_4(cmp_size);
dst = malloc(dst_capacity);
TEST_ASSERT_NOT_NULL(dst);
dst_capacity = compress_chunk(chunk, chunk_size, NULL, NULL, dst, dst_capacity, &par);
TEST_ASSERT_GREATER_THAN_INT(0, dst_capacity);
cmp_size = compress_chunk(chunk, chunk_size, NULL, NULL, dst, dst_capacity, &par);
TEST_ASSERT_GREATER_THAN_INT(0, cmp_size);
}
{
void *decompressed_data = NULL;
......@@ -1488,5 +1633,7 @@ void test_cmp_decmp_diff(void)
TEST_ASSERT_EQUAL_INT(chunk_size, decmp_size);
TEST_ASSERT_EQUAL_HEX8_ARRAY(chunk, decompressed_data, chunk_size);
free(decompressed_data);
}
free(dst);
}
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment