Refactor compression decompression round trip test suite

test/cmp_decmp/test_cmp_decmp.c

@@ -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);
 }