diff --git a/lib/common/cmp_data_types.c b/lib/common/cmp_data_types.c
index 2ab46997efff58f31321cce4f25cdb96e18168ae..778195fd6b0816a7e0fe931469092d0cd46689ee 100644
--- a/lib/common/cmp_data_types.c
+++ b/lib/common/cmp_data_types.c
@@ -894,7 +894,6 @@ int be_to_cpu_data_type(void *data, uint32_t data_size_byte, enum cmp_data_type
be_to_cpus_f_fx_efx_ncob_ecob(data, samples);
break;
/* LCOV_EXCL_START */
- case DATA_TYPE_UNKNOWN:
default:
debug_print("Error: Can not swap endianness for this compression data type.");
return -1;
diff --git a/lib/rdcu_compress/cmp_rdcu_cfg.c b/lib/rdcu_compress/cmp_rdcu_cfg.c
index 09ab8286482af1d4fd55979b699ea65657e5f8ab..9db8354f51fa569accc9ddb995bcea369249ac95 100644
--- a/lib/rdcu_compress/cmp_rdcu_cfg.c
+++ b/lib/rdcu_compress/cmp_rdcu_cfg.c
@@ -158,7 +158,7 @@ static int rdcu_cfg_buffers_is_invalid(const struct rdcu_cfg *rcfg)
if (rcfg->cmp_mode == CMP_MODE_RAW) {
if (rcfg->buffer_length < rcfg->samples) {
- debug_print("rdcu_buffer_length is smaller than the samples parameter. There is not enough space to copy the data in RAW mode.");
+ debug_print("Error: rdcu_buffer_length is smaller than the samples parameter. There is not enough space to copy the data in RAW mode.");
rcfg_invalid++;
}
}
diff --git a/test/cmp_data_types/test_cmp_data_types.c b/test/cmp_data_types/test_cmp_data_types.c
index 0f43ed5f4634c47186dcd24e1991b74ea99ac4dc..1bc0de4df864819bc211e465d5467d80a3b1ba34 100644
--- a/test/cmp_data_types/test_cmp_data_types.c
+++ b/test/cmp_data_types/test_cmp_data_types.c
@@ -284,6 +284,27 @@ void test_be_to_cpu_chunk(void)
{
enum cmp_data_type data_type;
+ {
+ struct {
+ uint8_t hdr[COLLECTION_HDR_SIZE];
+ uint16_t entry[2];
+ } __attribute__((packed)) data = {0};
+
+ data_type = DATA_TYPE_IMAGETTE;
+ data.entry[0] = 0x0001;
+ data.entry[1] = 0x0203;
+ check_endianness(&data, sizeof(data), data_type);
+
+ data_type = DATA_TYPE_SAT_IMAGETTE;
+ data.entry[0] = 0x0001;
+ data.entry[1] = 0x0203;
+ check_endianness(&data, sizeof(data), data_type);
+
+ data_type = DATA_TYPE_F_CAM_IMAGETTE;
+ data.entry[0] = 0x0001;
+ data.entry[1] = 0x0203;
+ check_endianness(&data, sizeof(data), data_type);
+ }
{
struct {
uint8_t hdr[COLLECTION_HDR_SIZE];
@@ -678,4 +699,34 @@ void test_cmp_input_big_to_cpu_endianness_error_cases(void)
data_type = DATA_TYPE_UNKNOWN;
error = cmp_input_big_to_cpu_endianness(data, data_size_byte, data_type);
TEST_ASSERT_EQUAL(-1, error);
+
+ { /* test adaptive data types */
+ size_t i;
+ uint16_t data_ap[2];
+
+ data_type = DATA_TYPE_IMAGETTE_ADAPTIVE;
+ data_ap[0] = 0x0001;
+ data_ap[1] = 0x0203;
+ error = cmp_input_big_to_cpu_endianness(data_ap, sizeof(data_ap), data_type);
+ TEST_ASSERT_EQUAL(00, error);
+ for (i = 0; i < sizeof(data_ap); i++)
+ TEST_ASSERT_EQUAL(i, ((uint8_t*)data_ap)[i] );
+
+ data_type = DATA_TYPE_SAT_IMAGETTE_ADAPTIVE;
+ data_ap[0] = 0x0001;
+ data_ap[1] = 0x0203;
+ error = cmp_input_big_to_cpu_endianness(data_ap, sizeof(data_ap), data_type);
+ TEST_ASSERT_EQUAL(00, error);
+ for (i = 0; i < sizeof(data_ap); i++)
+ TEST_ASSERT_EQUAL(i, ((uint8_t*)data_ap)[i] );
+
+ data_type = DATA_TYPE_F_CAM_IMAGETTE_ADAPTIVE;
+ data_ap[0] = 0x0001;
+ data_ap[1] = 0x0203;
+ error = cmp_input_big_to_cpu_endianness(data_ap, sizeof(data_ap), data_type);
+ TEST_ASSERT_EQUAL(00, error);
+ for (i = 0; i < sizeof(data_ap); i++)
+ TEST_ASSERT_EQUAL(i, ((uint8_t*)data_ap)[i] );
+ }
+
}
diff --git a/test/cmp_entity/test_cmp_entity.c b/test/cmp_entity/test_cmp_entity.c
index 4746d32e74454b3802a49e03f7c2c8142dc05dc4..ef4f3d9e4dc87671f7d19525f7274f4c939de2a6 100644
--- a/test/cmp_entity/test_cmp_entity.c
+++ b/test/cmp_entity/test_cmp_entity.c
@@ -1344,6 +1344,62 @@ void test_cmp_ent_get_data_buf(void)
}
+/**
+ * @test cmp_ent_get_data_buf_const
+ */
+
+void test_cmp_ent_get_data_buf_const(void)
+{
+ enum cmp_data_type data_type;
+ struct cmp_entity ent = {0};
+ const char *adr;
+ uint32_t s, hdr_size;
+ int error;
+
+ for (data_type = DATA_TYPE_IMAGETTE;
+ data_type <= DATA_TYPE_F_CAM_BACKGROUND;
+ data_type++) {
+ s = cmp_ent_create(&ent, data_type, 0, 0);
+ TEST_ASSERT_NOT_EQUAL_INT(0, s);
+
+ adr = cmp_ent_get_data_buf_const(&ent);
+ TEST_ASSERT_NOT_NULL(adr);
+
+ hdr_size = cmp_ent_cal_hdr_size(data_type, 0);
+ TEST_ASSERT_EQUAL_INT(hdr_size, adr-(char *)&ent);
+ }
+
+ /* RAW mode test */
+ for (data_type = DATA_TYPE_IMAGETTE;
+ data_type <= DATA_TYPE_CHUNK;
+ data_type++) {
+ s = cmp_ent_create(&ent, data_type, 1, 0);
+ TEST_ASSERT_NOT_EQUAL_INT(0, s);
+
+ adr = cmp_ent_get_data_buf_const(&ent);
+ TEST_ASSERT_NOT_NULL(adr);
+
+ hdr_size = cmp_ent_cal_hdr_size(data_type, 1);
+ TEST_ASSERT_EQUAL_INT(hdr_size, adr-(char *)&ent);
+ }
+
+ /* ent = NULL test */
+ adr = cmp_ent_get_data_buf_const(NULL);
+ TEST_ASSERT_NULL(adr);
+
+ /* compression data type not supported test */
+ error = cmp_ent_set_data_type(&ent, DATA_TYPE_UNKNOWN, 0);
+ TEST_ASSERT_FALSE(error);
+ adr = cmp_ent_get_data_buf_const(&ent);
+ TEST_ASSERT_NULL(adr);
+
+ error = cmp_ent_set_data_type(&ent, (enum cmp_data_type)234, 1);
+ TEST_ASSERT_FALSE(error);
+ adr = cmp_ent_get_data_buf_const(&ent);
+ TEST_ASSERT_NULL(adr);
+}
+
+
/**
* @test cmp_ent_get_cmp_data
*/
diff --git a/test/cmp_icu/test_cmp_icu.c b/test/cmp_icu/test_cmp_icu.c
index 2d8322639201e831a5a4630af0532b4b21eaf8cf..f2cadf617fefee3ba39ecb568a1da3cd12d3adef 100644
--- a/test/cmp_icu/test_cmp_icu.c
+++ b/test/cmp_icu/test_cmp_icu.c
@@ -1259,7 +1259,7 @@ void test_compress_imagette_model(void)
uint16_t data[] = {0x0000, 0x0001, 0x0042, 0x8000, 0x7FFF, 0xFFFF, 0xFFFF};
uint16_t model[] = {0x0000, 0xFFFF, 0xF301, 0x8FFF, 0x0000, 0xFFFF, 0x0000};
uint16_t model_up[7] = {0};
- uint32_t output_buf[3] = {~0U, ~0U, ~0U};
+ uint32_t output_buf[4] = {~0U, ~0U, ~0U, ~0U};
struct rdcu_cfg rcfg = {0};
uint32_t model_value = 8;
uint32_t samples = 7;
@@ -1450,6 +1450,48 @@ void test_compress_imagette_error_cases(void)
cmp_size = compress_like_rdcu(&rcfg, NULL);
TEST_ASSERT_TRUE(cmp_is_error(cmp_size));
TEST_ASSERT_EQUAL_INT(CMP_ERROR_PAR_SPECIFIC, cmp_get_error_code(cmp_size));
+
+ /* test golomb_par to hight */
+ rcfg.cmp_mode = CMP_MODE_DIFF_ZERO;
+ rcfg.input_buf = data;
+ rcfg.samples = 2;
+ rcfg.golomb_par = MAX_CHUNK_CMP_PAR+1;
+ rcfg.spill = 8;
+ rcfg.icu_output_buf = (uint32_t *)output_buf;
+ rcfg.buffer_length = 4;
+
+ cmp_size = compress_like_rdcu(&rcfg, NULL);
+ TEST_ASSERT_TRUE(cmp_is_error(cmp_size));
+ TEST_ASSERT_EQUAL_INT(CMP_ERROR_PAR_SPECIFIC, cmp_get_error_code(cmp_size));
+
+ /* round to hight */
+ rcfg.cmp_mode = CMP_MODE_DIFF_ZERO;
+ rcfg.input_buf = data;
+ rcfg.samples = 2;
+ rcfg.golomb_par = MAX_CHUNK_CMP_PAR;
+ rcfg.spill = 8;
+ rcfg.icu_output_buf = (uint32_t *)output_buf;
+ rcfg.buffer_length = 4;
+ rcfg.round = MAX_ICU_ROUND+1;
+
+ cmp_size = compress_like_rdcu(&rcfg, NULL);
+ TEST_ASSERT_TRUE(cmp_is_error(cmp_size));
+ TEST_ASSERT_EQUAL_INT(CMP_ERROR_PAR_GENERIC, cmp_get_error_code(cmp_size));
+
+ /* model_value to hight */
+ rcfg.cmp_mode = CMP_MODE_MODEL_ZERO;
+ rcfg.input_buf = data;
+ rcfg.samples = 2;
+ rcfg.golomb_par = MAX_CHUNK_CMP_PAR;
+ rcfg.spill = 8;
+ rcfg.icu_output_buf = (uint32_t *)output_buf;
+ rcfg.buffer_length = 4;
+ rcfg.round = MAX_ICU_ROUND;
+ rcfg.model_value = MAX_MODEL_VALUE+1;
+
+ cmp_size = compress_like_rdcu(&rcfg, NULL);
+ TEST_ASSERT_TRUE(cmp_is_error(cmp_size));
+ TEST_ASSERT_EQUAL_INT(CMP_ERROR_PAR_GENERIC, cmp_get_error_code(cmp_size));
}
@@ -1844,6 +1886,26 @@ void test_compress_chunk_aux(void)
cmp_size = compress_chunk(chunk, CHUNK_SIZE, NULL, NULL, dst,
dst_capacity, &cmp_par);
TEST_ASSERT_EQUAL_INT(CMP_ERROR_PAR_SPECIFIC, cmp_get_error_code(cmp_size));
+
+ cmp_par.nc_background_outlier_pixels = MAX_CHUNK_CMP_PAR+1;
+ cmp_size = compress_chunk(chunk, CHUNK_SIZE, NULL, NULL, dst,
+ dst_capacity, &cmp_par);
+ TEST_ASSERT_EQUAL_INT(CMP_ERROR_PAR_SPECIFIC, cmp_get_error_code(cmp_size));
+
+ /* wrong cmp_mode */
+ cmp_par.nc_background_outlier_pixels = MAX_CHUNK_CMP_PAR;
+ cmp_par.cmp_mode = 5;
+ cmp_size = compress_chunk(chunk, CHUNK_SIZE, NULL, NULL, dst,
+ dst_capacity, &cmp_par);
+ TEST_ASSERT_EQUAL_INT(CMP_ERROR_PAR_GENERIC, cmp_get_error_code(cmp_size));
+
+ /* wrong model value */
+ cmp_par.cmp_mode = CMP_MODE_MODEL_ZERO;
+ cmp_par.model_value = MAX_MODEL_VALUE +1 ;
+ cmp_size = compress_chunk(chunk, CHUNK_SIZE, NULL, NULL, dst,
+ dst_capacity, &cmp_par);
+ TEST_ASSERT_EQUAL_INT(CMP_ERROR_PAR_GENERIC, cmp_get_error_code(cmp_size));
+ free(dst);
}
@@ -2430,16 +2492,43 @@ void test_support_function_call_NULL(void)
{
struct cmp_cfg cfg = {0};
- cfg.data_type = DATA_TYPE_IMAGETTE;
cfg.cmp_mode = CMP_MODE_DIFF_ZERO;
TEST_ASSERT_TRUE(cmp_cfg_gen_par_is_invalid(NULL));
+ TEST_ASSERT_TRUE(cmp_cfg_gen_par_is_invalid(&cfg));
+ cfg.data_type = DATA_TYPE_F_FX_EFX;
+ TEST_ASSERT_TRUE(cmp_cfg_imagette_is_invalid(&cfg));
TEST_ASSERT_TRUE(cmp_cfg_imagette_is_invalid(NULL));
+ cfg.data_type = DATA_TYPE_IMAGETTE;
TEST_ASSERT_TRUE(cmp_cfg_fx_cob_is_invalid(NULL));
+ TEST_ASSERT_TRUE(cmp_cfg_fx_cob_is_invalid(&cfg));
TEST_ASSERT_TRUE(cmp_cfg_aux_is_invalid(NULL));
TEST_ASSERT_TRUE(cmp_cfg_aux_is_invalid(&cfg));
+ TEST_ASSERT_FALSE(cmp_aux_data_type_is_used(DATA_TYPE_S_FX));
TEST_ASSERT_TRUE(cmp_cfg_fx_cob_get_need_pars(DATA_TYPE_S_FX, NULL));
TEST_ASSERT_TRUE(check_compression_buffers(NULL));
+ cfg.cmp_mode = 5;
+ TEST_ASSERT_TRUE(cmp_cfg_imagette_is_invalid(&cfg));
+}
+
+
+/*
+ * @test cmp_cfg_fx_cob_get_need_pars
+ */
+
+void test_missing_cmp_cfg_fx_cob_get_need_pars(void)
+{
+ struct fx_cob_par used_par;
+ enum cmp_data_type data_type;
+
+ data_type = DATA_TYPE_F_FX;
+ TEST_ASSERT_FALSE(cmp_cfg_fx_cob_get_need_pars(data_type, &used_par));
+ data_type = DATA_TYPE_F_FX_EFX;
+ TEST_ASSERT_FALSE(cmp_cfg_fx_cob_get_need_pars(data_type, &used_par));
+ data_type = DATA_TYPE_F_FX_NCOB;
+ TEST_ASSERT_FALSE(cmp_cfg_fx_cob_get_need_pars(data_type, &used_par));
+ data_type = DATA_TYPE_F_FX_EFX_NCOB_ECOB;
+ TEST_ASSERT_FALSE(cmp_cfg_fx_cob_get_need_pars(data_type, &used_par));
}
@@ -2475,11 +2564,10 @@ void test_print_cmp_info(void)
void test_buffer_overlaps(void)
{
- char buf_a[3];
- char buf_b[3];
+ char buf_a[3] = {0};
+ char buf_b[3] = {0};
int overlap;
-
overlap = buffer_overlaps(buf_a, sizeof(buf_a), buf_b, sizeof(buf_b));
TEST_ASSERT_FALSE(overlap);
overlap = buffer_overlaps(NULL, sizeof(buf_a), buf_b, sizeof(buf_b));
@@ -2499,3 +2587,20 @@ void test_buffer_overlaps(void)
}
+/**
+ * @test cmp_get_error_string
+ */
+
+void test_cmp_get_error_string(void)
+{
+ enum cmp_error code;
+ const char *str;
+
+ for (code = CMP_ERROR_NO_ERROR; code <= CMP_ERROR_MAX_CODE; code++) {
+ str = cmp_get_error_string(code);
+ TEST_ASSERT_NOT_EQUAL('\0', str[0]);
+
+ str = cmp_get_error_name((-code));
+ TEST_ASSERT_NOT_EQUAL('\0', str[0]);
+ }
+}