diff --git a/include/cmp_support.h b/include/cmp_support.h
index d9146077b315e9d696d8aae7b6e5711e1f678700..2ea2a3e3e85ca1fdb015f77ab7e2c455a1b23d2d 100644
--- a/include/cmp_support.h
+++ b/include/cmp_support.h
@@ -91,7 +91,7 @@
 #define CMP_DEF_IMA_DIFF_RDCU_UP_MODEL_ADR	0x000000 /* not needed for 1d-differencing cmp_mode */
 #define CMP_DEF_IMA_DIFF_RDCU_BUFFER_ADR	0x600000
 
-enum {ICU_CHECK, RDCU_CHECK}; /* option for the cmp_cfg_imagette_is_invalid() function */
+enum check_opt {ICU_CHECK, RDCU_CHECK}; /* options for configuration check functions */
 
 
 /* defined compression data product types */
@@ -249,10 +249,10 @@ int ilog_2(uint32_t x);
 
 unsigned int cmp_bit_to_4byte(unsigned int cmp_size_bit);
 
-int cmp_cfg_is_invalid(const struct cmp_cfg *cfg);
-int cmp_cfg_icu_gen_par_is_invalid(const struct cmp_cfg *cfg);
+int cmp_cfg_icu_is_invalid(const struct cmp_cfg *cfg);
+int cmp_cfg_gen_par_is_invalid(const struct cmp_cfg *cfg, enum check_opt opt);
 int cmp_cfg_icu_buffers_is_invalid(const struct cmp_cfg *cfg);
-int cmp_cfg_imagette_is_invalid(const struct cmp_cfg *cfg, int rdcu_check);
+int cmp_cfg_imagette_is_invalid(const struct cmp_cfg *cfg, enum check_opt opt);
 int cmp_cfg_fx_cob_is_invalid(const struct cmp_cfg *cfg);
 int cmp_cfg_aux_is_invalid(const struct cmp_cfg *cfg);
 uint32_t cmp_ima_max_spill(unsigned int golomb_par);
diff --git a/lib/cmp_icu.c b/lib/cmp_icu.c
index 5995afb13f27b09cc7cd652c5ec87a9dc9a781c7..c98d0f1ffb94114f2218db41251bfd040bb65c37 100644
--- a/lib/cmp_icu.c
+++ b/lib/cmp_icu.c
@@ -88,7 +88,7 @@ struct cmp_cfg cmp_cfg_icu_create(enum cmp_data_type data_type, enum cmp_mode cm
 	cfg.model_value = model_value;
 	cfg.round = lossy_par;
 
-	if (cmp_cfg_icu_gen_par_is_invalid(&cfg))
+	if (cmp_cfg_gen_par_is_invalid(&cfg, ICU_CHECK))
 		cfg.data_type = DATA_TYPE_UNKNOWN;
 
 	return cfg;
@@ -171,10 +171,7 @@ int cmp_cfg_icu_imagette(struct cmp_cfg *cfg, uint32_t cmp_par,
 	cfg->golomb_par = cmp_par;
 	cfg->spill = spillover_par;
 
-	if (cmp_cfg_imagette_is_invalid(cfg, ICU_CHECK))
-		return -1;
-
-	return 0;
+	return cmp_cfg_imagette_is_invalid(cfg, ICU_CHECK);
 }
 
 
@@ -225,10 +222,7 @@ int cmp_cfg_fx_cob(struct cmp_cfg *cfg,
 	cfg->spill_ecob = spillover_ecob;
 	cfg->spill_fx_cob_variance = spillover_fx_cob_variance;
 
-	if (cmp_cfg_fx_cob_is_invalid(cfg))
-		return -1;
-
-	return 0;
+	return cmp_cfg_fx_cob_is_invalid(cfg);
 }
 
 
@@ -266,10 +260,7 @@ int cmp_cfg_aux(struct cmp_cfg *cfg,
 	cfg->spill_variance = spillover_variance;
 	cfg->spill_pixels_error = spillover_pixels_error;
 
-	if (cmp_cfg_aux_is_invalid(cfg))
-		return -1;
-
-	return 0;
+	return cmp_cfg_aux_is_invalid(cfg);
 }
 
 
@@ -2347,7 +2338,7 @@ int icu_compress_data(const struct cmp_cfg *cfg)
 		if (cfg->samples > cfg->buffer_length)
 			return CMP_ERROR_SMALL_BUF;
 
-	if (cmp_cfg_is_invalid(cfg))
+	if (cmp_cfg_icu_is_invalid(cfg))
 		return -1;
 
 	if (raw_mode_is_used(cfg->cmp_mode)) {
diff --git a/lib/cmp_rdcu.c b/lib/cmp_rdcu.c
index b7893397b4a87ca4b950b1c37368bb1d7336160c..40b52a73ba8c231dd61998518e911c84403f2401 100644
--- a/lib/cmp_rdcu.c
+++ b/lib/cmp_rdcu.c
@@ -81,56 +81,6 @@ static void sync(void)
 }
 
 
-/**
- * @brief check if the compression data product type, compression mode, model
- *	value and the lossy rounding parameters are valid for an RDCU compression
- *
- * @param cfg	pointer to a compression configuration containing the compression
- *	data product type, compression mode, model value and the rounding parameters
- *
- * @returns 0 if the compression data type, compression mode, model value and
- *	the lossy rounding parameters are valid for an RDCU compression, non-zero
- *	if parameters are invalid
- */
-
-static int rdcu_cfg_gen_par_is_invalid(const struct cmp_cfg *cfg)
-{
-	int cfg_invalid = 0;
-
-	if (!cfg)
-		return -1;
-
-	if (!cmp_imagette_data_type_is_used(cfg->data_type)) {
-		debug_print("Error: The selected compression data type is not supported for RDCU compression");
-		cfg_invalid++;
-	}
-
-	if (cfg->cmp_mode > MAX_RDCU_CMP_MODE) {
-		debug_print("Error: selected cmp_mode: %u is not supported. Largest supported mode is: %u.\n",
-			    cfg->cmp_mode, MAX_RDCU_CMP_MODE);
-		cfg_invalid++;
-	}
-
-	if (cfg->model_value > MAX_MODEL_VALUE) {
-		debug_print("Error: selected model_value: %" PRIu32 " is invalid. Largest supported value is: %u.\n",
-			    cfg->model_value, MAX_MODEL_VALUE);
-		cfg_invalid++;
-	}
-
-	if (cfg->round > MAX_RDCU_ROUND) {
-		debug_print("Error: selected round parameter: %" PRIu32 " is not supported. Largest supported value is: %u.\n",
-			    cfg->round, MAX_RDCU_ROUND);
-		cfg_invalid++;
-	}
-
-#ifdef SKIP_CMP_PAR_CHECK
-	return 0;
-#endif
-
-	return -cfg_invalid;
-}
-
-
 /**
  * @brief create an RDCU compression configuration
  *
@@ -155,7 +105,7 @@ struct cmp_cfg rdcu_cfg_create(enum cmp_data_type data_type, enum cmp_mode cmp_m
 	cfg.model_value = model_value;
 	cfg.round = lossy_par;
 
-	if (rdcu_cfg_gen_par_is_invalid(&cfg))
+	if (cmp_cfg_gen_par_is_invalid(&cfg, RDCU_CHECK))
 		cfg.data_type = DATA_TYPE_UNKNOWN;
 
 	return cfg;
@@ -163,26 +113,26 @@ struct cmp_cfg rdcu_cfg_create(enum cmp_data_type data_type, enum cmp_mode cmp_m
 
 
 /**
- * @brief check if a buffer is in inside the RDCU SRAM
+ * @brief check if a buffer is in outside the RDCU SRAM
  *
  * @param addr	start address of the buffer
  * @param size	length of the buffer in bytes
  *
- * @returns 1 if buffer in inside the RDCU SRAM, 0 when the buffer is outside
+ * @returns 0 if buffer in inside the RDCU SRAM, 1 when the buffer is outside
  */
 
-static int in_sram_range(uint32_t addr, uint32_t size)
+static int outside_sram_range(uint32_t addr, uint32_t size)
 {
+	if (addr + size > RDCU_SRAM_END)
+		return 1;
+
 	if (addr > RDCU_SRAM_END)
-		return 0;
+		return 1;
 
 	if (size > RDCU_SRAM_SIZE)
-		return 0;
-
-	if (addr + size > RDCU_SRAM_END)
-		return 0;
+		return 1;
 
-	return 1;
+	return 0;
 }
 
 
@@ -224,7 +174,7 @@ static int rdcu_cfg_buffers_is_invalid(const struct cmp_cfg *cfg)
 
 	if (cfg->cmp_mode == CMP_MODE_RAW) {
 		if (cfg->buffer_length < cfg->samples) {
-			debug_print("rdcu_buffer_length is smaller than samples parameter. There is not enough space to copy the data in RAW mode.\n");
+			debug_print("rdcu_buffer_length is smaller than the samples parameter. There is not enough space to copy the data in RAW mode.\n");
 			cfg_invalid++;
 		}
 	}
@@ -239,12 +189,12 @@ static int rdcu_cfg_buffers_is_invalid(const struct cmp_cfg *cfg)
 		cfg_invalid++;
 	}
 
-	if (!in_sram_range(cfg->rdcu_data_adr, cfg->samples * IMA_SAM2BYT)) {
+	if (outside_sram_range(cfg->rdcu_data_adr, cfg->samples * IMA_SAM2BYT)) {
 		debug_print("Error: The RDCU data to compress buffer is outside the RDCU SRAM address space.\n");
 		cfg_invalid++;
 	}
 
-	if (!in_sram_range(cfg->rdcu_buffer_adr, cfg->buffer_length * IMA_SAM2BYT)) {
+	if (outside_sram_range(cfg->rdcu_buffer_adr, cfg->buffer_length * IMA_SAM2BYT)) {
 		debug_print("Error: The RDCU compressed data buffer is outside the RDCU SRAM address space.\n");
 		cfg_invalid++;
 	}
@@ -259,7 +209,7 @@ static int rdcu_cfg_buffers_is_invalid(const struct cmp_cfg *cfg)
 
 	if (model_mode_is_used(cfg->cmp_mode)) {
 		if (cfg->model_buf && cfg->model_buf == cfg->input_buf) {
-			debug_print("Error: The model buffer (model_buf) and the data to be compressed (input_buf) are equal.");
+			debug_print("Error: The model buffer (model_buf) and the data to be compressed (input_buf) are equal.\n");
 			cfg_invalid++;
 		}
 
@@ -268,7 +218,7 @@ static int rdcu_cfg_buffers_is_invalid(const struct cmp_cfg *cfg)
 			cfg_invalid++;
 		}
 
-		if (!in_sram_range(cfg->rdcu_model_adr, cfg->samples * IMA_SAM2BYT)) {
+		if (outside_sram_range(cfg->rdcu_model_adr, cfg->samples * IMA_SAM2BYT)) {
 			debug_print("Error: The RDCU model buffer is outside the RDCU SRAM address space.\n");
 			cfg_invalid++;
 		}
@@ -298,7 +248,7 @@ static int rdcu_cfg_buffers_is_invalid(const struct cmp_cfg *cfg)
 				cfg_invalid++;
 			}
 
-			if (!in_sram_range(cfg->rdcu_new_model_adr,
+			if (outside_sram_range(cfg->rdcu_new_model_adr,
 					   cfg->samples * IMA_SAM2BYT)) {
 				debug_print("Error: The RDCU updated model buffer is outside the RDCU SRAM address space.\n");
 				cfg_invalid++;
@@ -335,16 +285,10 @@ static int rdcu_cfg_buffers_is_invalid(const struct cmp_cfg *cfg)
 		}
 	}
 
-	if (cfg->icu_new_model_buf)
-		debug_print("Warning: ICU updated model buffer is set. This buffer is not used for an RDCU compression.\n");
-
-	if (cfg->icu_output_buf)
-		debug_print("Warning: ICU compressed data buffer is set. This buffer is not used for an RDCU compression.\n");
-
 #ifdef SKIP_CMP_PAR_CHECK
 	return 0;
 #endif
-	return -cfg_invalid;
+	return cfg_invalid;
 }
 
 
@@ -392,90 +336,7 @@ int rdcu_cfg_buffers(struct cmp_cfg *cfg, uint16_t *data_to_compress,
 	cfg->rdcu_buffer_adr = rdcu_buffer_adr;
 	cfg->buffer_length = rdcu_buffer_lenght;
 
-	if (rdcu_cfg_buffers_is_invalid(cfg))
-		return -1;
-
-	return 0;
-}
-
-
-/**
- * @brief check if the Golomb and spillover threshold parameter combination is
- *	invalid for an RDCU compression
- * @note also checked the adaptive Golomb and spillover threshold parameter combinations
- *
- * @param cfg	a pointer to a compression configuration
- *
- * @returns 0 if (adaptive) Golomb spill threshold parameter combinations are
- *	valid, otherwise the configuration is invalid
- */
-
-static int rdcu_cfg_imagette_is_invalid(const struct cmp_cfg *cfg)
-{
-	int cfg_invalid = 0;
-
-	if (cfg->golomb_par < MIN_IMA_GOLOMB_PAR ||
-	    cfg->golomb_par > MAX_IMA_GOLOMB_PAR) {
-		debug_print("Error: The selected Golomb parameter: %" PRIu32 " is not supported. The Golomb parameter has to be between [%u, %u].\n",
-			    cfg->golomb_par, MIN_IMA_GOLOMB_PAR, MAX_IMA_GOLOMB_PAR);
-		cfg_invalid++;
-	}
-
-	if (cfg->ap1_golomb_par < MIN_IMA_GOLOMB_PAR ||
-	    cfg->ap1_golomb_par > MAX_IMA_GOLOMB_PAR) {
-		debug_print("Error: The selected adaptive 1 Golomb parameter: %" PRIu32 " is not supported. The Golomb parameter has to be between [%u, %u].\n",
-			    cfg->ap1_golomb_par, MIN_IMA_GOLOMB_PAR, MAX_IMA_GOLOMB_PAR);
-		cfg_invalid++;
-	}
-
-	if (cfg->ap2_golomb_par < MIN_IMA_GOLOMB_PAR ||
-	    cfg->ap2_golomb_par > MAX_IMA_GOLOMB_PAR) {
-		debug_print("Error: The selected adaptive 2 Golomb parameter: %" PRIu32 " is not supported. The Golomb parameter has to be between [%u, %u].\n",
-			    cfg->ap2_golomb_par, MIN_IMA_GOLOMB_PAR, MAX_IMA_GOLOMB_PAR);
-		cfg_invalid++;
-	}
-
-	if (cfg->spill < MIN_IMA_SPILL) {
-		debug_print("Error: The selected spillover threshold value: %" PRIu32 " is too small. Smallest possible spillover value is: %u.\n",
-			    cfg->spill, MIN_IMA_SPILL);
-		cfg_invalid++;
-	}
-
-	if (cfg->spill > cmp_ima_max_spill(cfg->golomb_par)) {
-		debug_print("Error: The selected spillover threshold value: %" PRIu32 " is too large for the selected Golomb parameter: %" PRIu32 ", the largest possible spillover value is: %" PRIu32 ".\n",
-			    cfg->spill, cfg->golomb_par, cmp_ima_max_spill(cfg->golomb_par));
-		cfg_invalid++;
-	}
-
-	if (cfg->ap1_spill < MIN_IMA_SPILL) {
-		debug_print("Error: The selected adaptive 1 spillover threshold value: %" PRIu32 " is too small. Smallest possible spillover value is: %u.\n",
-			    cfg->ap1_spill, MIN_IMA_SPILL);
-		cfg_invalid++;
-	}
-
-	if (cfg->ap1_spill > cmp_ima_max_spill(cfg->ap1_golomb_par)) {
-		debug_print("Error: The selected adaptive 1 spillover threshold value: %" PRIu32 " is too large for the selected adaptive 1 Golomb parameter: %" PRIu32 ", the largest possible adaptive 1 spillover value is: %" PRIu32 ".\n",
-			    cfg->ap1_spill, cfg->ap1_golomb_par, cmp_ima_max_spill(cfg->ap1_golomb_par));
-		cfg_invalid++;
-	}
-
-	if (cfg->ap2_spill < MIN_IMA_SPILL) {
-		debug_print("Error: The selected adaptive 2 spillover threshold value: %" PRIu32 " is too small. Smallest possible spillover value is: %u.\n",
-			    cfg->ap2_spill, MIN_IMA_SPILL);
-		cfg_invalid++;
-	}
-
-	if (cfg->ap2_spill > cmp_ima_max_spill(cfg->ap2_golomb_par)) {
-		debug_print("Error: The selected adaptive 2 spillover threshold value: %" PRIu32 " is too large for the selected adaptive 2 Golomb parameter: %" PRIu32 ", the largest possible adaptive 2 spillover value is: %" PRIu32 ".\n",
-			    cfg->ap2_spill, cfg->ap2_golomb_par, cmp_ima_max_spill(cfg->ap2_golomb_par));
-		cfg_invalid++;
-	}
-
-#ifdef SKIP_CMP_PAR_CHECK
-	return 0;
-#endif
-
-	return -cfg_invalid;
+	return rdcu_cfg_buffers_is_invalid(cfg);
 }
 
 
@@ -511,10 +372,7 @@ int rdcu_cfg_imagette(struct cmp_cfg *cfg,
 	cfg->ap2_golomb_par = ap2_golomb_par;
 	cfg->ap2_spill = ap2_spillover_par;
 
-	if (rdcu_cfg_imagette_is_invalid(cfg))
-		return -1;
-
-	return 0;
+	return cmp_cfg_imagette_is_invalid(cfg, RDCU_CHECK);
 }
 
 
@@ -538,29 +396,32 @@ int rdcu_cmp_cfg_is_invalid(const struct cmp_cfg *cfg)
 	}
 
 	if (!cfg->input_buf)
-		debug_print("Warning: The data to compress buffer is set to NULL. No data will be transferred to the rdcu_data_adr in the RDCU-SRAM.\n");
+		debug_print("Warning: The data to compress buffer is set to NULL. No data will be transferred to the rdcu_data_adr in the RDCU SRAM.\n");
 
 	if (model_mode_is_used(cfg->cmp_mode)) {
 		if (!cfg->model_buf)
-			debug_print("Warning: The model buffer is set to NULL. No model data will be transferred to the rdcu_model_adr in the RDCU-SRAM.\n");
+			debug_print("Warning: The model buffer is set to NULL. No model data will be transferred to the rdcu_model_adr in the RDCU SRAM.\n");
 	}
 
-	if (cfg->input_buf && cfg->samples == 0)
+	if (cfg->samples == 0)
 		debug_print("Warning: The samples parameter is set to 0. No data will be compressed.\n");
 
+	if (cfg->icu_new_model_buf)
+		debug_print("Warning: ICU updated model buffer is set. This buffer is not used for an RDCU compression.\n");
+
+	if (cfg->icu_output_buf)
+		debug_print("Warning: ICU compressed data buffer is set. This buffer is not used for an RDCU compression.\n");
+
 	if (cfg->buffer_length == 0) {
 		debug_print("Error: The buffer_length is set to 0. There is no place to store the compressed data.\n");
 		cfg_invalid++;
 	}
 
-	if (rdcu_cfg_gen_par_is_invalid(cfg))
-		cfg_invalid++;
-	if (rdcu_cfg_buffers_is_invalid(cfg))
-		cfg_invalid++;
-	if (rdcu_cfg_imagette_is_invalid(cfg))
-		cfg_invalid++;
+	cfg_invalid += cmp_cfg_gen_par_is_invalid(cfg, RDCU_CHECK);
+	cfg_invalid += rdcu_cfg_buffers_is_invalid(cfg);
+	cfg_invalid += cmp_cfg_imagette_is_invalid(cfg, RDCU_CHECK);
 
-	return -cfg_invalid;
+	return cfg_invalid;
 }
 
 
@@ -975,7 +836,7 @@ int rdcu_compress_data_parallel(const struct cmp_cfg *cfg,
 		cmp_size_4byte = ((last_info->cmp_size >> 3) + 3) & ~0x3U;
 
 		/* parallel read compressed data and write input data from sram
-		 * to mirror*/
+		 * to mirror */
 		if (rdcu_sync_sram_mirror_parallel(last_info->rdcu_cmp_adr_used,
 				cmp_size_4byte, cfg->rdcu_data_adr, samples_4byte,
 				rdcu_get_data_mtu()))
diff --git a/lib/cmp_support.c b/lib/cmp_support.c
index 4a90564d4fb21a449081c4a26b2c4e8d3567f9bf..eb1c730e6ba31cf3558094341574d75702e756ca 100644
--- a/lib/cmp_support.c
+++ b/lib/cmp_support.c
@@ -441,44 +441,77 @@ unsigned int cmp_bit_to_4byte(unsigned int cmp_size_bit)
 
 /**
  * @brief check if the compression data type, compression mode, model value and
- *	the lossy rounding parameters are invalid for a ICU compression
+ *	the lossy rounding parameters are invalid for a RDCU or ICU compression
  *
- * @param cfg	pointer to the compressor configuration
+ * @param cfg	pointer to a compression configuration containing the compression
+ *	data product type, compression mode, model value and the rounding parameters
+ * @param opt		check options:
+ *			RDCU_CHECK for RDCU compression check
+ *			ICU_CHECK for ICU compression check
  *
- * @returns 0 if generic compression parameters are valid, otherwise invalid
+ * @returns 0 if the compression data type, compression mode, model value and
+ *	the lossy rounding parameters are valid for an RDCU or ICU compression,
+ *	non-zero if parameters are invalid
  */
 
-int cmp_cfg_icu_gen_par_is_invalid(const struct cmp_cfg *cfg)
+int cmp_cfg_gen_par_is_invalid(const struct cmp_cfg *cfg, enum check_opt opt)
 {
 	int cfg_invalid = 0;
+	int invalid_data_type;
+	int unsupported_cmp_mode;
+	int check_model_value;
+	uint32_t max_round_value;
+	char *str = "";
 
 	if (!cfg)
-		return 0;
+		return 1;
 
-	if (cmp_data_type_is_invalid(cfg->data_type)) {
-		debug_print("Error: selected compression data type is not supported.\n");
+	switch (opt) {
+	case RDCU_CHECK:
+		/* the RDCU can only compress imagette data */
+		invalid_data_type = !cmp_imagette_data_type_is_used(cfg->data_type);
+		unsupported_cmp_mode = !rdcu_supported_cmp_mode_is_used(cfg->cmp_mode);
+		max_round_value = MAX_RDCU_ROUND;
+		/* for the RDCU the model vale has to be always in the allowed range */
+		check_model_value = 1;
+		str = " for a RDCU compression";
+		break;
+	case ICU_CHECK:
+		invalid_data_type = cmp_data_type_is_invalid(cfg->data_type);
+		unsupported_cmp_mode = !cmp_mode_is_supported(cfg->cmp_mode);
+		max_round_value = MAX_ICU_ROUND;
+		check_model_value = model_mode_is_used(cfg->cmp_mode);
+		break;
+	}
+
+	if (invalid_data_type) {
+		debug_print("Error: selected compression data type is not supported%s.\n", str);
 		cfg_invalid++;
 	}
 
-	if (cfg->cmp_mode > CMP_MODE_STUFF) {
-		debug_print("Error: selected cmp_mode: %i is not supported.\n", cfg->cmp_mode);
+	if (unsupported_cmp_mode) {
+		debug_print("Error: selected cmp_mode: %i is not supported%s.\n", cfg->cmp_mode, str);
 		cfg_invalid++;
 	}
 
-	if (model_mode_is_used(cfg->cmp_mode)) {
+	if (check_model_value) {
 		if (cfg->model_value > MAX_MODEL_VALUE) {
-			debug_print("Error: selected model_value: %" PRIu32 " is invalid. Largest supported value is: %u.\n",
+			debug_print("Error: selected model_value: %" PRIu32 " is invalid. The largest supported value is: %u.\n",
 				    cfg->model_value, MAX_MODEL_VALUE);
 			cfg_invalid++;
 		}
 	}
 
-	if (cfg->round > MAX_ICU_ROUND) {
-		debug_print("Error: selected lossy parameter: %" PRIu32 " is not supported. Largest supported value is: %u.\n",
-			    cfg->round, MAX_ICU_ROUND);
+	if (cfg->round > max_round_value) {
+		debug_print("Error: selected lossy parameter: %" PRIu32 " is not supported%s. The largest supported value is: %u.\n",
+			    cfg->round, str, max_round_value);
 		cfg_invalid++;
 	}
 
+#ifdef SKIP_CMP_PAR_CHECK
+	return 0;
+#endif
+
 	return cfg_invalid;
 }
 
@@ -496,7 +529,7 @@ int cmp_cfg_icu_buffers_is_invalid(const struct cmp_cfg *cfg)
 	int cfg_invalid = 0;
 
 	if (!cfg)
-		return 0;
+		return 1;
 
 	if (cfg->input_buf == NULL) {
 		debug_print("Error: The data_to_compress buffer for the data to be compressed is NULL.\n");
@@ -578,9 +611,6 @@ static int cmp_pars_are_invalid(uint32_t cmp_par, uint32_t spill, enum cmp_mode
 	uint32_t min_spill;
 	uint32_t max_spill;
 
-	if (!par_name)
-		par_name = "";
-
 	/* The maximum compression parameter for imagette data are smaller to
 	 * fit into the imagette compression entity header */
 	if (cmp_imagette_data_type_is_used(data_type)) {
@@ -605,17 +635,17 @@ static int cmp_pars_are_invalid(uint32_t cmp_par, uint32_t spill, enum cmp_mode
 	case CMP_MODE_MODEL_ZERO:
 	case CMP_MODE_MODEL_MULTI:
 		if (cmp_par < min_golomb_par || cmp_par > max_golomb_par) {
-			debug_print("Error: The selected %s compression parameter: %" PRIu32 " is not supported. The compression parameter has to be between [%" PRIu32 ", %" PRIu32 "].\n",
+			debug_print("Error: The selected %s compression parameter: %" PRIu32 " is not supported in the selected compression mode. The compression parameter has to be between [%" PRIu32 ", %" PRIu32 "] in this mode.\n",
 				    par_name, cmp_par, min_golomb_par, max_golomb_par);
 			cfg_invalid++;
 		}
 		if (spill < min_spill) {
-			debug_print("Error: The selected %s spillover threshold value: %" PRIu32 " is too small. Smallest possible spillover value is: %" PRIu32 ".\n",
+			debug_print("Error: The selected %s spillover threshold value: %" PRIu32 " is too small. The smallest possible spillover value is: %" PRIu32 ".\n",
 				    par_name, spill, min_spill);
 			cfg_invalid++;
 		}
 		if (spill > max_spill) {
-			debug_print("Error: The selected %s spillover threshold value: %" PRIu32 " is too large for the selected %s compression parameter: %" PRIu32 ", the largest possible spillover value in the selected compression mode is: %" PRIu32 ".\n",
+			debug_print("Error: The selected %s spillover threshold value: %" PRIu32 " is too large for the selected %s compression parameter: %" PRIu32 ". The largest possible spillover value in the selected compression mode is: %" PRIu32 ".\n",
 				    par_name, spill, par_name, cmp_par, max_spill);
 			cfg_invalid++;
 		}
@@ -623,7 +653,7 @@ static int cmp_pars_are_invalid(uint32_t cmp_par, uint32_t spill, enum cmp_mode
 		break;
 	case CMP_MODE_STUFF:
 		if (cmp_par > MAX_STUFF_CMP_PAR) {
-			debug_print("Error: The selected %s stuff mode compression parameter: %" PRIu32 " is too large, the largest possible value in the selected compression mode is: %u.\n",
+			debug_print("Error: The selected %s stuff mode compression parameter: %" PRIu32 " is too large. The largest possible value in the selected compression mode is: %u.\n",
 				    par_name, cmp_par, MAX_STUFF_CMP_PAR);
 			cfg_invalid++;
 		}
@@ -642,19 +672,20 @@ static int cmp_pars_are_invalid(uint32_t cmp_par, uint32_t spill, enum cmp_mode
  * @brief check if the imagette specific compression parameters are invalid
  *
  * @param cfg		pointer to the compressor configuration
- * @param rdcu_check	set to non-zero if a check for a imagette RDCU compression
- *			should be done; zero for imagette ICU compression
+ * @param opt		check options:
+ *			RDCU_CHECK for a imagette RDCU compression check
+ *			ICU_CHECK for a imagette ICU compression check
  *
  * @returns 0 if the imagette specific parameters are valid, otherwise invalid
  */
 
-int cmp_cfg_imagette_is_invalid(const struct cmp_cfg *cfg, int rdcu_check)
+int cmp_cfg_imagette_is_invalid(const struct cmp_cfg *cfg, enum check_opt opt)
 {
 	int cfg_invalid = 0;
 	enum cmp_mode cmp_mode;
 
 	if (!cfg)
-		return 0;
+		return 1;
 
 	if (!cmp_imagette_data_type_is_used(cfg->data_type)) {
 		debug_print("Error: The compression data type is not an imagette compression data type.\n");
@@ -662,7 +693,7 @@ int cmp_cfg_imagette_is_invalid(const struct cmp_cfg *cfg, int rdcu_check)
 	}
 
 	/* The RDCU needs valid compression parameters also in RAW_MODE */
-	if (rdcu_check && cfg->cmp_mode == CMP_MODE_RAW)
+	if (opt == RDCU_CHECK && cfg->cmp_mode == CMP_MODE_RAW)
 		cmp_mode = CMP_MODE_MODEL_ZERO;
 	else
 		cmp_mode = cfg->cmp_mode;
@@ -671,7 +702,7 @@ int cmp_cfg_imagette_is_invalid(const struct cmp_cfg *cfg, int rdcu_check)
 					    cfg->data_type, "imagette");
 
 	/* for the RDCU the adaptive parameters have to be always valid */
-	if (rdcu_check || cmp_ap_imagette_data_type_is_used(cfg->data_type)) {
+	if (opt == RDCU_CHECK || cmp_ap_imagette_data_type_is_used(cfg->data_type)) {
 		cfg_invalid += cmp_pars_are_invalid(cfg->ap1_golomb_par, cfg->ap1_spill,
 				cmp_mode, cfg->data_type, "adaptive 1 imagette");
 		cfg_invalid += cmp_pars_are_invalid(cfg->ap2_golomb_par, cfg->ap2_spill,
@@ -783,7 +814,7 @@ int cmp_cfg_fx_cob_is_invalid(const struct cmp_cfg *cfg)
 	struct fx_cob_par needed_pars;
 
 	if (!cfg)
-		return 0;
+		return 1;
 
 	if (!cmp_fx_cob_data_type_is_used(cfg->data_type)) {
 		debug_print("Error: The compression data type is not a flux/center of brightness compression data type.\n");
@@ -792,7 +823,7 @@ int cmp_cfg_fx_cob_is_invalid(const struct cmp_cfg *cfg)
 
 	cmp_cfg_fx_cob_get_need_pars(cfg->data_type, &needed_pars);
 
-	if (needed_pars.fx)
+	if (needed_pars.fx) /* this is always true because every flux/center of brightness  data type contains a flux parameter */
 		cfg_invalid += cmp_pars_are_invalid(cfg->cmp_par_fx, cfg->spill_fx,
 						    cfg->cmp_mode, cfg->data_type, "flux");
 	if (needed_pars.exp_flags)
@@ -830,7 +861,7 @@ int cmp_cfg_aux_is_invalid(const struct cmp_cfg *cfg)
 	int cfg_invalid = 0;
 
 	if (!cfg)
-		return 0;
+		return 1;
 
 	if (!cmp_aux_data_type_is_used(cfg->data_type)) {
 		debug_print("Error: The compression data type is not an auxiliary science compression data type.\n");
@@ -852,21 +883,21 @@ int cmp_cfg_aux_is_invalid(const struct cmp_cfg *cfg)
 
 
 /**
- * @brief check if a compression configuration is invalid
+ * @brief check if a compression configuration is invalid for ICU compression
  *
  * @param cfg	pointer to the compressor configuration
  *
  * @returns 0 if the compression configuration is valid, otherwise invalid
  */
 
-int cmp_cfg_is_invalid(const struct cmp_cfg *cfg)
+int cmp_cfg_icu_is_invalid(const struct cmp_cfg *cfg)
 {
 	int cfg_invalid = 0;
 
 	if (!cfg)
-		return 0;
+		return 1;
 
-	cfg_invalid += cmp_cfg_icu_gen_par_is_invalid(cfg);
+	cfg_invalid += cmp_cfg_gen_par_is_invalid(cfg, ICU_CHECK);
 
 	cfg_invalid += cmp_cfg_icu_buffers_is_invalid(cfg);
 
diff --git a/test/cmp_icu/test_cmp_icu.c b/test/cmp_icu/test_cmp_icu.c
index 6126542fd1ac859bd1501db1e4b04a20f07a6cac..09c0720009713c3f7439490ec793541b913c3e5b 100644
--- a/test/cmp_icu/test_cmp_icu.c
+++ b/test/cmp_icu/test_cmp_icu.c
@@ -4418,7 +4418,7 @@ void test_support_function_call_NULL(void)
 	TEST_ASSERT_TRUE(cmp_cfg_imagette_is_invalid(NULL, ICU_CHECK));
 	TEST_ASSERT_TRUE(cmp_cfg_fx_cob_is_invalid(NULL));
 	TEST_ASSERT_TRUE(cmp_cfg_aux_is_invalid(NULL));
-	TEST_ASSERT_TRUE(cmp_cfg_is_invalid(NULL));
+	TEST_ASSERT_TRUE(cmp_cfg_icu_is_invalid(NULL));
 	TEST_ASSERT_TRUE(cmp_cfg_fx_cob_get_need_pars(DATA_TYPE_S_FX, NULL));
 }
 
diff --git a/test/cmp_rdcu/meson.build b/test/cmp_rdcu/meson.build
new file mode 100644
index 0000000000000000000000000000000000000000..9c51877aabb3fdeca82b456ec8626ad0bf1c9aeb
--- /dev/null
+++ b/test/cmp_rdcu/meson.build
@@ -0,0 +1,12 @@
+test_case = files('test_cmp_rdcu.c')
+test_runner = test_runner_generator.process(test_case)
+
+test_cmp_rdcu = executable('test_cmp_rdcu',
+   test_case, test_runner,
+   include_directories : incdir,
+   link_with : cmp_lib,
+   dependencies : unity_dep,
+   build_by_default : false
+)
+
+test('Hardware Compressor Control Library Tests', test_cmp_rdcu)
diff --git a/test/cmp_rdcu/test_cmp_rdcu.c b/test/cmp_rdcu/test_cmp_rdcu.c
new file mode 100644
index 0000000000000000000000000000000000000000..c4b3b7dde1515580992b8b3d5f007646f70f51d7
--- /dev/null
+++ b/test/cmp_rdcu/test_cmp_rdcu.c
@@ -0,0 +1,752 @@
+/**
+ * @file test_cmp_rdcu.c
+ * @author Dominik Loidolt (dominik.loidolt@univie.ac.at),
+ * @date   2022
+ *
+ * @copyright GPLv2
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * @brief hardware compressor control library tests
+ */
+
+#include <stdint.h>
+
+#include <unity.h>
+#include <cmp_rdcu.h>
+#include <rdcu_cmd.h>
+
+
+/**
+ * @test rdcu_cfg_create
+ */
+
+void test_rdcu_cfg_create(void)
+{
+	struct cmp_cfg cfg;
+	enum cmp_data_type data_type;
+	enum cmp_mode cmp_mode;
+	uint32_t model_value, lossy_par;
+
+	/* wrong data type tests */
+	data_type = DATA_TYPE_UNKNOWN; /* not valid data type */
+	cmp_mode = CMP_MODE_RAW;
+	model_value = 0;
+	lossy_par = CMP_LOSSLESS;
+	cfg = rdcu_cfg_create(data_type, cmp_mode, model_value, lossy_par);
+	TEST_ASSERT_EQUAL(DATA_TYPE_UNKNOWN, cfg.data_type);
+
+	/* data_type not supported by RDCU */
+	data_type = DATA_TYPE_OFFSET;
+	cfg = rdcu_cfg_create(data_type, cmp_mode, model_value, lossy_par);
+	TEST_ASSERT_EQUAL(DATA_TYPE_UNKNOWN, cfg.data_type);
+
+	data_type = -1; /* not valid data type */
+	cfg = rdcu_cfg_create(data_type, cmp_mode, model_value, lossy_par);
+	TEST_ASSERT_EQUAL(DATA_TYPE_UNKNOWN, cfg.data_type);
+
+	 /*now it should work */
+	data_type = DATA_TYPE_F_CAM_IMAGETTE_ADAPTIVE;
+	cfg = rdcu_cfg_create(data_type, cmp_mode, model_value, lossy_par);
+	TEST_ASSERT_EQUAL(data_type, cfg.data_type);
+	TEST_ASSERT_EQUAL(cmp_mode, cfg.cmp_mode);
+	TEST_ASSERT_EQUAL(model_value, cfg.model_value);
+	TEST_ASSERT_EQUAL(lossy_par, cfg.round);
+
+
+	/* wrong compression mode tests */
+	cmp_mode = CMP_MODE_STUFF; /* not a RDCU compression mode */
+	cfg = rdcu_cfg_create(data_type, cmp_mode, model_value, lossy_par);
+	TEST_ASSERT_EQUAL(DATA_TYPE_UNKNOWN, cfg.data_type);
+
+	cmp_mode = -1;
+	cfg = rdcu_cfg_create(data_type, cmp_mode, model_value, lossy_par);
+	TEST_ASSERT_EQUAL(DATA_TYPE_UNKNOWN, cfg.data_type);
+
+	/* this should work */
+	cmp_mode = 4;
+	cfg = rdcu_cfg_create(data_type, cmp_mode, model_value, lossy_par);
+	TEST_ASSERT_EQUAL(data_type, cfg.data_type);
+	TEST_ASSERT_EQUAL(cmp_mode, cfg.cmp_mode);
+	TEST_ASSERT_EQUAL(model_value, cfg.model_value);
+	TEST_ASSERT_EQUAL(lossy_par, cfg.round);
+
+
+	/* wrong model_value tests */
+	cmp_mode = CMP_MODE_DIFF_ZERO;
+	model_value = MAX_MODEL_VALUE + 1;
+	cfg = rdcu_cfg_create(data_type, cmp_mode, model_value, lossy_par);
+	TEST_ASSERT_EQUAL(DATA_TYPE_UNKNOWN, cfg.data_type);
+
+	cmp_mode = CMP_MODE_RAW;
+	model_value = -1U;
+	cfg = rdcu_cfg_create(data_type, cmp_mode, model_value, lossy_par);
+	TEST_ASSERT_EQUAL(DATA_TYPE_UNKNOWN, cfg.data_type);
+
+	/* this should work */
+	model_value = MAX_MODEL_VALUE;
+	cfg = rdcu_cfg_create(data_type, cmp_mode, model_value, lossy_par);
+	TEST_ASSERT_EQUAL(data_type, cfg.data_type);
+	TEST_ASSERT_EQUAL(cmp_mode, cfg.cmp_mode);
+	TEST_ASSERT_EQUAL(model_value, cfg.model_value);
+	TEST_ASSERT_EQUAL(lossy_par, cfg.round);
+
+
+	/* wrong lossy_par tests */
+	lossy_par = MAX_RDCU_ROUND + 1;
+	cfg = rdcu_cfg_create(data_type, cmp_mode, model_value, lossy_par);
+	TEST_ASSERT_EQUAL(DATA_TYPE_UNKNOWN, cfg.data_type);
+
+	lossy_par = -1U;
+	cfg = rdcu_cfg_create(data_type, cmp_mode, model_value, lossy_par);
+	TEST_ASSERT_EQUAL(DATA_TYPE_UNKNOWN, cfg.data_type);
+
+	/* this should work */
+	lossy_par = MAX_RDCU_ROUND;
+	cfg = rdcu_cfg_create(data_type, cmp_mode, model_value, lossy_par);
+	TEST_ASSERT_EQUAL(data_type, cfg.data_type);
+	TEST_ASSERT_EQUAL(cmp_mode, cfg.cmp_mode);
+	TEST_ASSERT_EQUAL(model_value, cfg.model_value);
+	TEST_ASSERT_EQUAL(lossy_par, cfg.round);
+
+
+	/* wrong data type  test */
+	for (data_type = 0; data_type <= DATA_TYPE_F_CAM_BACKGROUND; data_type++) {
+		cfg = rdcu_cfg_create(data_type, CMP_MODE_DIFF_MULTI, MAX_MODEL_VALUE, CMP_LOSSLESS);
+		if (data_type == DATA_TYPE_IMAGETTE ||
+		    data_type == DATA_TYPE_IMAGETTE_ADAPTIVE ||
+		    data_type == DATA_TYPE_SAT_IMAGETTE ||
+		    data_type == DATA_TYPE_SAT_IMAGETTE_ADAPTIVE ||
+		    data_type == DATA_TYPE_F_CAM_IMAGETTE ||
+		    data_type == DATA_TYPE_F_CAM_IMAGETTE_ADAPTIVE) {
+			TEST_ASSERT_EQUAL(data_type, cfg.data_type);
+			TEST_ASSERT_EQUAL(CMP_MODE_DIFF_MULTI, cfg.cmp_mode);
+			TEST_ASSERT_EQUAL(MAX_MODEL_VALUE, cfg.model_value);
+			TEST_ASSERT_EQUAL(CMP_LOSSLESS, cfg.round);
+		} else {
+			TEST_ASSERT_EQUAL(DATA_TYPE_UNKNOWN, cfg.data_type);
+		}
+	}
+}
+
+
+/**
+ * @test rdcu_cfg_buffers
+ */
+
+void test_rdcu_cfg_buffers_raw_diff(void)
+{
+	int error;
+	struct cmp_cfg cfg;
+	uint16_t data_to_compress[4] = {0x23, 0x42, 0xFF, 0x32};
+	uint32_t data_samples = 4;
+	uint32_t rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr;
+	uint32_t rdcu_buffer_adr, rdcu_buffer_lenght;
+
+
+	/* test a RAW mode buffer configuration */
+	cfg = rdcu_cfg_create(DATA_TYPE_IMAGETTE_ADAPTIVE, CMP_MODE_RAW,
+			      MAX_MODEL_VALUE, CMP_LOSSLESS);
+
+	rdcu_model_adr = 0x0;
+	rdcu_new_model_adr = 0x0;
+	rdcu_data_adr = 0x0;
+	rdcu_buffer_adr = 0x8;
+	rdcu_buffer_lenght = 4;
+	error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, NULL,
+				 rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr,
+				 rdcu_buffer_adr, rdcu_buffer_lenght);
+	TEST_ASSERT_FALSE(error);
+	TEST_ASSERT_EQUAL(data_to_compress, cfg.input_buf);
+	TEST_ASSERT_EQUAL(data_samples, cfg.samples);
+	TEST_ASSERT_EQUAL(NULL, cfg.model_buf);
+	TEST_ASSERT_EQUAL(rdcu_data_adr, cfg.rdcu_data_adr);
+	TEST_ASSERT_EQUAL(rdcu_model_adr, cfg.rdcu_model_adr);
+	TEST_ASSERT_EQUAL(rdcu_new_model_adr, cfg.rdcu_new_model_adr);
+	TEST_ASSERT_EQUAL(rdcu_buffer_adr, cfg.rdcu_buffer_adr);
+	TEST_ASSERT_EQUAL(rdcu_buffer_lenght, cfg.buffer_length);
+
+	/* set input buffer to NULL */
+	error = rdcu_cfg_buffers(&cfg, NULL, data_samples, NULL,
+				 rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr,
+				 rdcu_buffer_adr, rdcu_buffer_lenght);
+	TEST_ASSERT_FALSE(error);
+
+	/* error: destination buffer to small */
+	rdcu_data_adr = 0x0;
+	rdcu_buffer_adr = 0x8;
+	rdcu_buffer_lenght = 3;
+	error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, NULL,
+				 rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr,
+				 rdcu_buffer_adr, rdcu_buffer_lenght);
+	TEST_ASSERT_EQUAL(1, error);
+
+	/* error: data and compressed buffer overlap */
+	rdcu_data_adr = 0x0;
+	rdcu_buffer_adr = 0x4;
+	rdcu_buffer_lenght = 4;
+	error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, NULL,
+				 rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr,
+				 rdcu_buffer_adr, rdcu_buffer_lenght);
+	TEST_ASSERT_EQUAL(1, error);
+
+	/* get a diff config */
+	cfg = rdcu_cfg_create(DATA_TYPE_IMAGETTE, CMP_MODE_DIFF_MULTI,
+			      MAX_MODEL_VALUE, CMP_LOSSLESS);
+	rdcu_data_adr = 0x4;
+	rdcu_buffer_adr = 0x0;
+	rdcu_buffer_lenght = 4;
+	error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, NULL,
+				 rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr,
+				 rdcu_buffer_adr, rdcu_buffer_lenght);
+	TEST_ASSERT_EQUAL(1, error);
+
+	/* error: data or SRAM addresses out of allowed range */
+	rdcu_data_adr = RDCU_SRAM_END & ~0x3UL;
+	rdcu_buffer_adr = 0x8;
+	rdcu_buffer_lenght = 4;
+	error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, NULL,
+				 rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr,
+				 rdcu_buffer_adr, rdcu_buffer_lenght);
+	TEST_ASSERT_EQUAL(1, error);
+
+	rdcu_data_adr = 0x0;
+	rdcu_buffer_adr = 0x8;
+	rdcu_buffer_lenght = RDCU_SRAM_SIZE;
+	error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, NULL,
+				 rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr,
+				 rdcu_buffer_adr, rdcu_buffer_lenght);
+	TEST_ASSERT_EQUAL(1, error);
+
+	rdcu_data_adr = 0xFFFFFFFC;
+	rdcu_buffer_adr = 0x8;
+	rdcu_buffer_lenght = 4;
+	error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, NULL,
+				 rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr,
+				 rdcu_buffer_adr, rdcu_buffer_lenght);
+	TEST_ASSERT_EQUAL(1, error);
+
+	rdcu_data_adr = 0x0;
+	rdcu_buffer_adr = 0x8;
+	rdcu_buffer_lenght = UINT32_MAX;
+	error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, NULL,
+				 rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr,
+				 rdcu_buffer_adr, rdcu_buffer_lenght);
+	TEST_ASSERT_EQUAL(1, error);
+
+	/* error: data and buffer addresses are not 4 byte aligned */
+	rdcu_data_adr = 0x2;
+	rdcu_buffer_adr = 0x10;
+	rdcu_buffer_lenght = 4;
+	error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, NULL,
+				 rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr,
+				 rdcu_buffer_adr, rdcu_buffer_lenght);
+	TEST_ASSERT_EQUAL(1, error);
+
+	rdcu_data_adr = 0x0;
+	rdcu_buffer_adr = 0x9;
+	rdcu_buffer_lenght = 4;
+	error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, NULL,
+				 rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr,
+				 rdcu_buffer_adr, rdcu_buffer_lenght);
+	TEST_ASSERT_EQUAL(1, error);
+
+	/* error: cfg = NULL */
+	error = rdcu_cfg_buffers(NULL, data_to_compress, data_samples, NULL,
+				 rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr,
+				 rdcu_buffer_adr, rdcu_buffer_lenght);
+	TEST_ASSERT_EQUAL(-1, error);
+}
+
+
+/**
+ * @test rdcu_cfg_buffers
+ */
+
+void test_rdcu_cfg_buffers_model(void)
+{
+	int error;
+	struct cmp_cfg cfg;
+	uint16_t data_to_compress[4] = {0x23, 0x42, 0xFF, 0x32};
+	uint16_t model_of_data[4] = {0xFF, 0x12, 0x34, 0xAB};
+	uint32_t data_samples = 4;
+	uint32_t rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr;
+	uint32_t rdcu_buffer_adr, rdcu_buffer_lenght;
+
+
+	/* test a RAW mode buffer configuration */
+	cfg = rdcu_cfg_create(DATA_TYPE_IMAGETTE, CMP_MODE_MODEL_MULTI,
+			      MAX_MODEL_VALUE, CMP_LOSSLESS);
+
+	rdcu_data_adr = 0x0;
+	rdcu_model_adr = 0x8;
+	rdcu_new_model_adr = 0x10;
+	rdcu_buffer_adr = 0x18;
+	rdcu_buffer_lenght = 4;
+	error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, model_of_data,
+				 rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr,
+				 rdcu_buffer_adr, rdcu_buffer_lenght);
+	TEST_ASSERT_FALSE(error);
+	TEST_ASSERT_EQUAL(data_to_compress, cfg.input_buf);
+	TEST_ASSERT_EQUAL(data_samples, cfg.samples);
+	TEST_ASSERT_EQUAL(model_of_data, cfg.model_buf);
+	TEST_ASSERT_EQUAL(rdcu_data_adr, cfg.rdcu_data_adr);
+	TEST_ASSERT_EQUAL(rdcu_model_adr, cfg.rdcu_model_adr);
+	TEST_ASSERT_EQUAL(rdcu_new_model_adr, cfg.rdcu_new_model_adr);
+	TEST_ASSERT_EQUAL(rdcu_buffer_adr, cfg.rdcu_buffer_adr);
+	TEST_ASSERT_EQUAL(rdcu_buffer_lenght, cfg.buffer_length);
+
+	/* data and model buffers are NULL */
+	rdcu_new_model_adr = rdcu_model_adr;
+	error = rdcu_cfg_buffers(&cfg, NULL, data_samples, NULL,
+				 rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr,
+				 rdcu_buffer_adr, rdcu_buffer_lenght);
+	TEST_ASSERT_FALSE(error);
+
+	/* error: data and model buffer are the same */
+	error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, data_to_compress,
+				 rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr,
+				 rdcu_buffer_adr, rdcu_buffer_lenght);
+	TEST_ASSERT_EQUAL(1, error);
+
+	/* error: model address not 4 byte aligned */
+	rdcu_data_adr = 0x0;
+	rdcu_model_adr = 0xA; /* not 4 byte aligned */
+	rdcu_new_model_adr = rdcu_model_adr;
+	rdcu_buffer_adr = 0x14;
+	rdcu_buffer_lenght = 4;
+	error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, model_of_data,
+				 rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr,
+				 rdcu_buffer_adr, rdcu_buffer_lenght);
+	TEST_ASSERT_EQUAL(1, error);
+
+	/* error: model address not in SRAM range */
+	rdcu_data_adr = 0x0;
+	rdcu_model_adr = 0xFFFFFFFC; /* not in SRAM range */
+	rdcu_new_model_adr = rdcu_model_adr;
+	rdcu_buffer_adr = 0x10;
+	rdcu_buffer_lenght = 4;
+	error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, model_of_data,
+				 rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr,
+				 rdcu_buffer_adr, rdcu_buffer_lenght);
+	TEST_ASSERT_EQUAL(1, error);
+
+	/* error: data and model rdcu buffers overlaps */
+	rdcu_data_adr = 0x0;
+	rdcu_model_adr = 0x4; /* overlaps with data buffer */
+	rdcu_new_model_adr = rdcu_model_adr;
+	rdcu_buffer_adr = 0x10;
+	rdcu_buffer_lenght = 4;
+	error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, model_of_data,
+				 rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr,
+				 rdcu_buffer_adr, rdcu_buffer_lenght);
+	TEST_ASSERT_EQUAL(1, error);
+
+	/* error: compressed buffer and model rdcu buffers overlaps */
+	rdcu_data_adr = 0x0;
+	rdcu_model_adr = 0xC; /* overlaps with compressed data buffer */
+	rdcu_new_model_adr = rdcu_model_adr;
+	rdcu_buffer_adr = 0x10;
+	rdcu_buffer_lenght = 4;
+	error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, model_of_data,
+				 rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr,
+				 rdcu_buffer_adr, rdcu_buffer_lenght);
+	TEST_ASSERT_EQUAL(1, error);
+
+	/** test with the updated_model buffer **/
+
+	/* error: updated_model address not 4 byte aligned */
+	rdcu_data_adr = 0x0;
+	rdcu_model_adr = 0x8;
+	rdcu_new_model_adr = 0x11; /* not 4 byte aligned */
+	rdcu_buffer_adr = 0x1C;
+	rdcu_buffer_lenght = 4;
+	error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, model_of_data,
+				 rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr,
+				 rdcu_buffer_adr, rdcu_buffer_lenght);
+	TEST_ASSERT_EQUAL(1, error);
+
+	/* error: updated_model address not in SRAM range */
+	rdcu_data_adr = 0x0;
+	rdcu_model_adr = 0x8;
+	rdcu_new_model_adr = 0xFFFFFFFC; /* not in SRAM range */
+	rdcu_buffer_adr = 0x18;
+	rdcu_buffer_lenght = 4;
+	error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, model_of_data,
+				 rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr,
+				 rdcu_buffer_adr, rdcu_buffer_lenght);
+	TEST_ASSERT_EQUAL(1, error);
+
+	/* error: data and updated model rdcu buffers overlaps */
+	rdcu_data_adr = 0x8;
+	rdcu_model_adr = 0x0;
+	rdcu_new_model_adr = 0xC; /* overlaps with data buffer */
+	rdcu_buffer_adr = 0x18;
+	rdcu_buffer_lenght = 4;
+	error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, model_of_data,
+				 rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr,
+				 rdcu_buffer_adr, rdcu_buffer_lenght);
+	TEST_ASSERT_EQUAL(1, error);
+
+	/* error: compressed buffer and updated_model rdcu buffers overlaps */
+	rdcu_data_adr = 0x0;
+	rdcu_model_adr = 0x8;
+	rdcu_new_model_adr = 0x14; /* overlaps with compressed data buffer */
+	rdcu_buffer_adr = 0x18;
+	rdcu_buffer_lenght = 4;
+	error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, model_of_data,
+				 rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr,
+				 rdcu_buffer_adr, rdcu_buffer_lenght);
+	TEST_ASSERT_EQUAL(1, error);
+
+	/* error: model and updated_model rdcu buffers overlaps */
+	rdcu_data_adr = 0x0;
+	rdcu_model_adr = 0x8;
+	rdcu_new_model_adr = 0xC; /* overlaps with model buffer */
+	rdcu_buffer_adr = 0x18;
+	rdcu_buffer_lenght = 4;
+	error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, model_of_data,
+				 rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr,
+				 rdcu_buffer_adr, rdcu_buffer_lenght);
+	TEST_ASSERT_EQUAL(1, error);
+
+}
+
+
+/**
+ * @test rdcu_cfg_imagette
+ */
+
+void test_rdcu_cfg_imagette(void)
+{
+	int error;
+	struct cmp_cfg cfg = rdcu_cfg_create(DATA_TYPE_IMAGETTE, CMP_MODE_RAW,
+					     10, CMP_LOSSLESS);
+	uint32_t golomb_par, spillover_par, ap1_golomb_par, ap1_spillover_par,
+		 ap2_golomb_par, ap2_spillover_par;
+
+	golomb_par = MIN_IMA_GOLOMB_PAR;
+	spillover_par = MIN_IMA_SPILL;
+	ap1_golomb_par = MIN_IMA_GOLOMB_PAR;
+	ap1_spillover_par = MIN_IMA_SPILL;
+	ap2_golomb_par = MIN_IMA_GOLOMB_PAR;
+	ap2_spillover_par = MIN_IMA_SPILL;
+
+	error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par,
+				  ap1_golomb_par, ap1_spillover_par,
+				  ap2_golomb_par, ap2_spillover_par);
+	TEST_ASSERT_FALSE(error);
+	TEST_ASSERT_EQUAL(golomb_par, cfg.golomb_par);
+	TEST_ASSERT_EQUAL(spillover_par, cfg.spill);
+	TEST_ASSERT_EQUAL(ap1_golomb_par, cfg.ap1_golomb_par);
+	TEST_ASSERT_EQUAL(ap1_spillover_par, cfg.ap1_spill);
+	TEST_ASSERT_EQUAL(ap2_golomb_par, cfg.ap2_golomb_par);
+	TEST_ASSERT_EQUAL(ap2_spillover_par, cfg.ap2_spill);
+
+
+	/* wrong golomb_par */
+	golomb_par = MIN_IMA_GOLOMB_PAR - 1;
+	error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par,
+				  ap1_golomb_par, ap1_spillover_par,
+				  ap2_golomb_par, ap2_spillover_par);
+	TEST_ASSERT_TRUE(error);
+
+	golomb_par = MAX_IMA_GOLOMB_PAR + 1;
+	error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par,
+				  ap1_golomb_par, ap1_spillover_par,
+				  ap2_golomb_par, ap2_spillover_par);
+	TEST_ASSERT_TRUE(error);
+
+	/* this should work */
+	golomb_par = MAX_IMA_GOLOMB_PAR;
+	error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par,
+				  ap1_golomb_par, ap1_spillover_par,
+				  ap2_golomb_par, ap2_spillover_par);
+	TEST_ASSERT_FALSE(error);
+	TEST_ASSERT_EQUAL(golomb_par, cfg.golomb_par);
+	TEST_ASSERT_EQUAL(spillover_par, cfg.spill);
+	TEST_ASSERT_EQUAL(ap1_golomb_par, cfg.ap1_golomb_par);
+	TEST_ASSERT_EQUAL(ap1_spillover_par, cfg.ap1_spill);
+	TEST_ASSERT_EQUAL(ap2_golomb_par, cfg.ap2_golomb_par);
+	TEST_ASSERT_EQUAL(ap2_spillover_par, cfg.ap2_spill);
+
+
+	/* wrong ap1_golomb_par */
+	ap1_golomb_par = MIN_IMA_GOLOMB_PAR - 1;
+	error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par,
+				  ap1_golomb_par, ap1_spillover_par,
+				  ap2_golomb_par, ap2_spillover_par);
+	TEST_ASSERT_TRUE(error);
+
+	ap1_golomb_par = MAX_IMA_GOLOMB_PAR + 1;
+	error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par,
+				  ap1_golomb_par, ap1_spillover_par,
+				  ap2_golomb_par, ap2_spillover_par);
+	TEST_ASSERT_TRUE(error);
+
+	/* this should work */
+	ap1_golomb_par = MAX_IMA_GOLOMB_PAR;
+	error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par,
+				  ap1_golomb_par, ap1_spillover_par,
+				  ap2_golomb_par, ap2_spillover_par);
+	TEST_ASSERT_FALSE(error);
+	TEST_ASSERT_EQUAL(golomb_par, cfg.golomb_par);
+	TEST_ASSERT_EQUAL(spillover_par, cfg.spill);
+	TEST_ASSERT_EQUAL(ap1_golomb_par, cfg.ap1_golomb_par);
+	TEST_ASSERT_EQUAL(ap1_spillover_par, cfg.ap1_spill);
+	TEST_ASSERT_EQUAL(ap2_golomb_par, cfg.ap2_golomb_par);
+	TEST_ASSERT_EQUAL(ap2_spillover_par, cfg.ap2_spill);
+
+
+	/* wrong ap2_golomb_par */
+	cfg.cmp_mode = CMP_MODE_DIFF_ZERO;
+	ap2_golomb_par = MIN_IMA_GOLOMB_PAR - 1;
+	error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par,
+				  ap1_golomb_par, ap1_spillover_par,
+				  ap2_golomb_par, ap2_spillover_par);
+	TEST_ASSERT_TRUE(error);
+
+	ap2_golomb_par = MAX_IMA_GOLOMB_PAR + 1;
+	error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par,
+				  ap1_golomb_par, ap1_spillover_par,
+				  ap2_golomb_par, ap2_spillover_par);
+	TEST_ASSERT_TRUE(error);
+
+	/* this should work */
+	ap2_golomb_par = MAX_IMA_GOLOMB_PAR;
+	error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par,
+				  ap1_golomb_par, ap1_spillover_par,
+				  ap2_golomb_par, ap2_spillover_par);
+	TEST_ASSERT_FALSE(error);
+	TEST_ASSERT_EQUAL(golomb_par, cfg.golomb_par);
+	TEST_ASSERT_EQUAL(spillover_par, cfg.spill);
+	TEST_ASSERT_EQUAL(ap1_golomb_par, cfg.ap1_golomb_par);
+	TEST_ASSERT_EQUAL(ap1_spillover_par, cfg.ap1_spill);
+	TEST_ASSERT_EQUAL(ap2_golomb_par, cfg.ap2_golomb_par);
+	TEST_ASSERT_EQUAL(ap2_spillover_par, cfg.ap2_spill);
+
+
+	/* wrong spillover_par */
+	golomb_par = MIN_IMA_GOLOMB_PAR;
+	spillover_par = cmp_ima_max_spill(golomb_par)+1;
+	error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par,
+				  ap1_golomb_par, ap1_spillover_par,
+				  ap2_golomb_par, ap2_spillover_par);
+	golomb_par = MAX_IMA_GOLOMB_PAR;
+	spillover_par = cmp_ima_max_spill(golomb_par)+1;
+	error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par,
+				  ap1_golomb_par, ap1_spillover_par,
+				  ap2_golomb_par, ap2_spillover_par);
+
+	golomb_par = MIN_IMA_GOLOMB_PAR;
+	spillover_par = MIN_IMA_SPILL - 1;
+	error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par,
+				  ap1_golomb_par, ap1_spillover_par,
+				  ap2_golomb_par, ap2_spillover_par);
+	TEST_ASSERT_EQUAL(1, error);
+
+	/* this should work */
+	golomb_par = MAX_IMA_GOLOMB_PAR;
+	spillover_par = cmp_ima_max_spill(golomb_par);
+	error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par,
+				  ap1_golomb_par, ap1_spillover_par,
+				  ap2_golomb_par, ap2_spillover_par);
+	TEST_ASSERT_FALSE(error);
+	TEST_ASSERT_EQUAL(golomb_par, cfg.golomb_par);
+	TEST_ASSERT_EQUAL(spillover_par, cfg.spill);
+	TEST_ASSERT_EQUAL(ap1_golomb_par, cfg.ap1_golomb_par);
+	TEST_ASSERT_EQUAL(ap1_spillover_par, cfg.ap1_spill);
+	TEST_ASSERT_EQUAL(ap2_golomb_par, cfg.ap2_golomb_par);
+	TEST_ASSERT_EQUAL(ap2_spillover_par, cfg.ap2_spill);
+
+
+	/* wrong ap1_spillover_par */
+	ap1_golomb_par = MIN_IMA_GOLOMB_PAR;
+	ap1_spillover_par = cmp_ima_max_spill(golomb_par)+1;
+	error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par,
+				  ap1_golomb_par, ap1_spillover_par,
+				  ap2_golomb_par, ap2_spillover_par);
+	ap1_golomb_par = MAX_IMA_GOLOMB_PAR;
+	ap1_spillover_par = cmp_ima_max_spill(golomb_par)+1;
+	error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par,
+				  ap1_golomb_par, ap1_spillover_par,
+				  ap2_golomb_par, ap2_spillover_par);
+
+	ap1_golomb_par = MIN_IMA_GOLOMB_PAR;
+	ap1_spillover_par = MIN_IMA_SPILL - 1;
+	error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par,
+				  ap1_golomb_par, ap1_spillover_par,
+				  ap2_golomb_par, ap2_spillover_par);
+	TEST_ASSERT_EQUAL(1, error);
+
+	/* this should work */
+	ap1_golomb_par = MAX_IMA_GOLOMB_PAR;
+	ap1_spillover_par = cmp_ima_max_spill(golomb_par);
+	error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par,
+				  ap1_golomb_par, ap1_spillover_par,
+				  ap2_golomb_par, ap2_spillover_par);
+	TEST_ASSERT_FALSE(error);
+	TEST_ASSERT_EQUAL(golomb_par, cfg.golomb_par);
+	TEST_ASSERT_EQUAL(spillover_par, cfg.spill);
+	TEST_ASSERT_EQUAL(ap1_golomb_par, cfg.ap1_golomb_par);
+	TEST_ASSERT_EQUAL(ap1_spillover_par, cfg.ap1_spill);
+	TEST_ASSERT_EQUAL(ap2_golomb_par, cfg.ap2_golomb_par);
+	TEST_ASSERT_EQUAL(ap2_spillover_par, cfg.ap2_spill);
+
+
+	/* wrong ap2_spillover_par */
+	ap2_golomb_par = MIN_IMA_GOLOMB_PAR;
+	ap2_spillover_par = cmp_ima_max_spill(golomb_par)+1;
+	error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par,
+				  ap1_golomb_par, ap1_spillover_par,
+				  ap2_golomb_par, ap2_spillover_par);
+	ap2_golomb_par = MAX_IMA_GOLOMB_PAR;
+	ap2_spillover_par = cmp_ima_max_spill(golomb_par)+1;
+	error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par,
+				  ap1_golomb_par, ap1_spillover_par,
+				  ap2_golomb_par, ap2_spillover_par);
+
+	ap2_golomb_par = MIN_IMA_GOLOMB_PAR;
+	ap2_spillover_par = MIN_IMA_SPILL - 1;
+	error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par,
+				  ap1_golomb_par, ap1_spillover_par,
+				  ap2_golomb_par, ap2_spillover_par);
+	TEST_ASSERT_EQUAL(1, error);
+
+	/* this should work */
+	ap2_golomb_par = MAX_IMA_GOLOMB_PAR;
+	ap2_spillover_par = cmp_ima_max_spill(golomb_par);
+	error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par,
+				  ap1_golomb_par, ap1_spillover_par,
+				  ap2_golomb_par, ap2_spillover_par);
+	TEST_ASSERT_FALSE(error);
+	TEST_ASSERT_EQUAL(golomb_par, cfg.golomb_par);
+	TEST_ASSERT_EQUAL(spillover_par, cfg.spill);
+	TEST_ASSERT_EQUAL(ap1_golomb_par, cfg.ap1_golomb_par);
+	TEST_ASSERT_EQUAL(ap1_spillover_par, cfg.ap1_spill);
+	TEST_ASSERT_EQUAL(ap2_golomb_par, cfg.ap2_golomb_par);
+	TEST_ASSERT_EQUAL(ap2_spillover_par, cfg.ap2_spill); /* cfg = NULL test */ error = rdcu_cfg_imagette(NULL, golomb_par, spillover_par,
+				  ap1_golomb_par, ap1_spillover_par, ap2_golomb_par, ap2_spillover_par);
+	TEST_ASSERT_EQUAL(-1, error);
+}
+
+
+/**
+ * @test rdcu_cmp_cfg_is_invalid
+ */
+
+void test_rdcu_cmp_cfg_is_invalid(void)
+{
+	int error;
+	struct cmp_cfg cfg;
+	uint16_t data[1] = {1};
+	uint16_t model[1] = {2};
+
+	/* diff test */
+	cfg = rdcu_cfg_create(DATA_TYPE_IMAGETTE, CMP_DEF_IMA_DIFF_CMP_MODE,
+			      CMP_DEF_IMA_DIFF_MODEL_VALUE, CMP_DEF_IMA_DIFF_LOSSY_PAR);
+	error = rdcu_cfg_buffers(&cfg, data, 1, NULL, CMP_DEF_IMA_DIFF_RDCU_DATA_ADR,
+				 CMP_DEF_IMA_DIFF_RDCU_MODEL_ADR, CMP_DEF_IMA_DIFF_RDCU_UP_MODEL_ADR,
+				 CMP_DEF_IMA_DIFF_RDCU_BUFFER_ADR, 1);
+	TEST_ASSERT_FALSE(error);
+	error = rdcu_cfg_imagette(&cfg,
+				  CMP_DEF_IMA_DIFF_GOLOMB_PAR, CMP_DEF_IMA_DIFF_SPILL_PAR,
+				  CMP_DEF_IMA_DIFF_AP1_GOLOMB_PAR, CMP_DEF_IMA_DIFF_AP1_SPILL_PAR,
+				  CMP_DEF_IMA_DIFF_AP2_GOLOMB_PAR, CMP_DEF_IMA_DIFF_AP2_SPILL_PAR);
+	TEST_ASSERT_FALSE(error);
+	error = rdcu_cmp_cfg_is_invalid(&cfg);
+	TEST_ASSERT_FALSE(error);
+
+	/* model test */
+	cfg = rdcu_cfg_create(DATA_TYPE_IMAGETTE, CMP_DEF_IMA_MODEL_CMP_MODE,
+			      CMP_DEF_IMA_MODEL_MODEL_VALUE, CMP_DEF_IMA_MODEL_LOSSY_PAR);
+	error = rdcu_cfg_buffers(&cfg, data, 1, model, CMP_DEF_IMA_MODEL_RDCU_DATA_ADR,
+				 CMP_DEF_IMA_MODEL_RDCU_MODEL_ADR, CMP_DEF_IMA_MODEL_RDCU_UP_MODEL_ADR,
+				 CMP_DEF_IMA_MODEL_RDCU_BUFFER_ADR, 1);
+	TEST_ASSERT_FALSE(error);
+	error = rdcu_cfg_imagette(&cfg,
+				  CMP_DEF_IMA_MODEL_GOLOMB_PAR, CMP_DEF_IMA_MODEL_SPILL_PAR,
+				  CMP_DEF_IMA_MODEL_AP1_GOLOMB_PAR, CMP_DEF_IMA_MODEL_AP1_SPILL_PAR,
+				  CMP_DEF_IMA_MODEL_AP2_GOLOMB_PAR, CMP_DEF_IMA_MODEL_AP2_SPILL_PAR);
+	TEST_ASSERT_FALSE(error);
+	error = rdcu_cmp_cfg_is_invalid(&cfg);
+	TEST_ASSERT_FALSE(error);
+
+	/* test warnings */
+	cfg = rdcu_cfg_create(DATA_TYPE_IMAGETTE, CMP_DEF_IMA_MODEL_CMP_MODE,
+			      CMP_DEF_IMA_MODEL_MODEL_VALUE, CMP_DEF_IMA_MODEL_LOSSY_PAR);
+	error = rdcu_cfg_buffers(&cfg, NULL, 0, NULL, CMP_DEF_IMA_MODEL_RDCU_DATA_ADR,
+				 CMP_DEF_IMA_MODEL_RDCU_MODEL_ADR, CMP_DEF_IMA_MODEL_RDCU_UP_MODEL_ADR,
+				 CMP_DEF_IMA_MODEL_RDCU_BUFFER_ADR, 1);
+	error = rdcu_cfg_imagette(&cfg,
+				  CMP_DEF_IMA_MODEL_GOLOMB_PAR, CMP_DEF_IMA_MODEL_SPILL_PAR,
+				  CMP_DEF_IMA_MODEL_AP1_GOLOMB_PAR, CMP_DEF_IMA_MODEL_AP1_SPILL_PAR,
+				  CMP_DEF_IMA_MODEL_AP2_GOLOMB_PAR, CMP_DEF_IMA_MODEL_AP2_SPILL_PAR);
+	cfg.icu_new_model_buf = data;
+	cfg.icu_output_buf = (void *)model;
+	error = rdcu_cmp_cfg_is_invalid(&cfg);
+	TEST_ASSERT_FALSE(error);
+
+	/* error: cfg is NULL */
+	error = rdcu_cmp_cfg_is_invalid(NULL);
+	TEST_ASSERT_TRUE(error);
+
+	/* error: buffer length = 0 */
+	cfg = rdcu_cfg_create(DATA_TYPE_IMAGETTE, CMP_DEF_IMA_MODEL_CMP_MODE,
+			      CMP_DEF_IMA_MODEL_MODEL_VALUE, CMP_DEF_IMA_MODEL_LOSSY_PAR);
+	error = rdcu_cfg_buffers(&cfg, data, 1, model, CMP_DEF_IMA_MODEL_RDCU_DATA_ADR,
+				 CMP_DEF_IMA_MODEL_RDCU_MODEL_ADR, CMP_DEF_IMA_MODEL_RDCU_UP_MODEL_ADR,
+				 CMP_DEF_IMA_MODEL_RDCU_BUFFER_ADR, 0);
+	error = rdcu_cfg_imagette(&cfg,
+				  CMP_DEF_IMA_MODEL_GOLOMB_PAR, CMP_DEF_IMA_MODEL_SPILL_PAR,
+				  CMP_DEF_IMA_MODEL_AP1_GOLOMB_PAR, CMP_DEF_IMA_MODEL_AP1_SPILL_PAR,
+				  CMP_DEF_IMA_MODEL_AP2_GOLOMB_PAR, CMP_DEF_IMA_MODEL_AP2_SPILL_PAR);
+	error = rdcu_cmp_cfg_is_invalid(&cfg);
+	TEST_ASSERT_TRUE(error);
+
+	/* error: wrong gen par */
+	cfg = rdcu_cfg_create(DATA_TYPE_IMAGETTE, CMP_DEF_IMA_DIFF_CMP_MODE,
+			      MAX_MODEL_VALUE+1, CMP_DEF_IMA_DIFF_LOSSY_PAR);
+	cfg.data_type = DATA_TYPE_IMAGETTE;
+	error = rdcu_cfg_buffers(&cfg, data, 1, NULL, CMP_DEF_IMA_DIFF_RDCU_DATA_ADR,
+				 CMP_DEF_IMA_DIFF_RDCU_MODEL_ADR, CMP_DEF_IMA_DIFF_RDCU_UP_MODEL_ADR,
+				 CMP_DEF_IMA_DIFF_RDCU_BUFFER_ADR, 1);
+	error = rdcu_cfg_imagette(&cfg,
+				  CMP_DEF_IMA_DIFF_GOLOMB_PAR, CMP_DEF_IMA_DIFF_SPILL_PAR,
+				  CMP_DEF_IMA_DIFF_AP1_GOLOMB_PAR, CMP_DEF_IMA_DIFF_AP1_SPILL_PAR,
+				  CMP_DEF_IMA_DIFF_AP2_GOLOMB_PAR, CMP_DEF_IMA_DIFF_AP2_SPILL_PAR);
+	error = rdcu_cmp_cfg_is_invalid(&cfg);
+	TEST_ASSERT_TRUE(error);
+
+	/* error: wrong buffers config */
+	cfg = rdcu_cfg_create(DATA_TYPE_IMAGETTE, CMP_DEF_IMA_DIFF_CMP_MODE,
+			      CMP_DEF_IMA_DIFF_MODEL_VALUE, CMP_DEF_IMA_DIFF_LOSSY_PAR);
+	error = rdcu_cfg_buffers(&cfg, data, 1, NULL, RDCU_SRAM_END+4,
+				 CMP_DEF_IMA_DIFF_RDCU_MODEL_ADR, CMP_DEF_IMA_DIFF_RDCU_UP_MODEL_ADR,
+				 CMP_DEF_IMA_DIFF_RDCU_BUFFER_ADR, 1);
+	error = rdcu_cfg_imagette(&cfg,
+				  CMP_DEF_IMA_DIFF_GOLOMB_PAR, CMP_DEF_IMA_DIFF_SPILL_PAR,
+				  CMP_DEF_IMA_DIFF_AP1_GOLOMB_PAR, CMP_DEF_IMA_DIFF_AP1_SPILL_PAR,
+				  CMP_DEF_IMA_DIFF_AP2_GOLOMB_PAR, CMP_DEF_IMA_DIFF_AP2_SPILL_PAR);
+	error = rdcu_cmp_cfg_is_invalid(&cfg);
+	TEST_ASSERT_TRUE(error);
+
+	/* error: wrong compression parameter test */
+	cfg = rdcu_cfg_create(DATA_TYPE_IMAGETTE, CMP_DEF_IMA_DIFF_CMP_MODE,
+			      CMP_DEF_IMA_DIFF_MODEL_VALUE, CMP_DEF_IMA_DIFF_LOSSY_PAR);
+	error = rdcu_cfg_buffers(&cfg, data, 1, NULL, CMP_DEF_IMA_DIFF_RDCU_DATA_ADR,
+				 CMP_DEF_IMA_DIFF_RDCU_MODEL_ADR, CMP_DEF_IMA_DIFF_RDCU_UP_MODEL_ADR,
+				 CMP_DEF_IMA_DIFF_RDCU_BUFFER_ADR, 1);
+	error = rdcu_cfg_imagette(&cfg,
+				  MAX_IMA_GOLOMB_PAR+1, CMP_DEF_IMA_DIFF_SPILL_PAR,
+				  CMP_DEF_IMA_DIFF_AP1_GOLOMB_PAR, CMP_DEF_IMA_DIFF_AP1_SPILL_PAR,
+				  CMP_DEF_IMA_DIFF_AP2_GOLOMB_PAR, CMP_DEF_IMA_DIFF_AP2_SPILL_PAR);
+	error = rdcu_cmp_cfg_is_invalid(&cfg);
+	TEST_ASSERT_TRUE(error);
+}
diff --git a/test/meson.build b/test/meson.build
index 36fee6ce08454a4e3db2b9cf0092bbdb9274a460..ff30bdfab4896c831abe21b220acb66b32308409 100644
--- a/test/meson.build
+++ b/test/meson.build
@@ -39,3 +39,4 @@ unity_dep = dependency('unity', fallback : ['unity', 'unity_dep'])
 subdir('cmp_icu')
 subdir('cmp_data_types')
 subdir('cmp_entity')
+subdir('cmp_rdcu')