diff --git a/lib/cmp_chunk.h b/lib/cmp_chunk.h
index 8e1c2c10b85cae30f371d29586d918c5edaca1ca..60835076c051f11796b5f18e83a7c143617f8ab8 100644
--- a/lib/cmp_chunk.h
+++ b/lib/cmp_chunk.h
@@ -222,7 +222,7 @@ unsigned int cmp_is_error(uint32_t code);
* @returns a pointer to a string literal that describes the error code.
*/
-const char* cmp_get_error_name(uint32_t code);
+const char *cmp_get_error_name(uint32_t code);
/**
@@ -244,7 +244,7 @@ enum cmp_error cmp_get_error_code(uint32_t code);
* @returns a pointer to a string literal that describes the error code.
*/
-const char* cmp_get_error_string(enum cmp_error code);
+const char *cmp_get_error_string(enum cmp_error code);
#endif /* CMP_CHUNK_H */
diff --git a/programs/cmp_io.c b/programs/cmp_io.c
index 0bfd803855e7bb1298e939739ec3d0d8bf04b997..5ef3edf4112fcc6b64665fc21ad57a8492b00275 100644
--- a/programs/cmp_io.c
+++ b/programs/cmp_io.c
@@ -486,11 +486,11 @@ const char *data_type2string(enum cmp_data_type data_type)
* themselves are not modified.
*/
-int case_insensitive_compare(const char* s1, const char* s2)
+int case_insensitive_compare(const char *s1, const char *s2)
{
size_t i;
- for (i=0; ; ++i) {
+ for (i = 0; ; ++i) {
unsigned int x1 = (unsigned char)s1[i];
unsigned int x2 = (unsigned char)s2[i];
int r;
@@ -504,7 +504,8 @@ int case_insensitive_compare(const char* s1, const char* s2)
if (r)
return r;
- if (!x1) return 0;
+ if (!x1)
+ return 0;
}
}
diff --git a/programs/cmp_io.h b/programs/cmp_io.h
index 86d0cb593c1538098145b5c778ac4cbe9401dbc2..0d2540c5e4366bd83613d2b85bc53b611bb4fb74 100644
--- a/programs/cmp_io.h
+++ b/programs/cmp_io.h
@@ -78,6 +78,6 @@ int cmp_mode_parse(const char *cmp_mode_str, enum cmp_mode *cmp_mode);
enum cmp_data_type string2data_type(const char *data_type_str);
const char *data_type2string(enum cmp_data_type data_type);
-int case_insensitive_compare(const char* s1, const char* s2);
+int case_insensitive_compare(const char *s1, const char *s2);
#endif /* CMP_IO_H */
diff --git a/programs/cmp_tool.c b/programs/cmp_tool.c
index ab1d8e375c9bb2343ae45f2e265ccd195b9967f5..bae19f9d93878f1a37552b06ece78c03c4a6840d 100644
--- a/programs/cmp_tool.c
+++ b/programs/cmp_tool.c
@@ -67,7 +67,7 @@
/* find a good set of compression parameters for a given dataset */
static int guess_cmp_pars(struct rdcu_cfg *rcfg, struct cmp_par *chunk_par,
- uint32_t input_size, const char *guess_cmp_mode, const
+ uint32_t input_size, const char *guess_option, const
char *guess_level_str);
/* compress chunk data and write the results to files */
@@ -164,7 +164,7 @@ int main(int argc, char **argv)
const char *info_file_name = NULL;
const char *data_file_name = NULL;
const char *model_file_name = NULL;
- char *guess_option = NULL;
+ const char *guess_option = NULL;
const char *guess_level_str = NULL;
const char *program_name = argv[0];
diff --git a/test/bench/bench.c b/test/bench/bench.c
index 879370be020b3a74eee9315309d400a1b44e4406..c25e6ddeab05dc22cd07a899ff67785af430d04b 100644
--- a/test/bench/bench.c
+++ b/test/bench/bench.c
@@ -45,7 +45,7 @@
#define TIMELOOP_NANOSEC (1 * 1000000000ULL) /* 1 second */
#define MB_UNIT 1000000
-enum bench_name {MEMCPY_BENCH, CMP_CHUNK_BENCH=32 };
+enum bench_name {MEMCPY_BENCH, CMP_CHUNK_BENCH = 32};
/* TODO: replace with default config? */
const struct cmp_par DIFF_CMP_PAR = {
@@ -213,6 +213,7 @@ static int bench_mem(unsigned int benchNb, const void *src, size_t srcSize,
void *const avoidStrictAliasingPtr = &dstBuff;
BMK_benchParams_t bp;
BMK_runTime_t bestResult;
+
bestResult.sumOfReturn = 0;
bestResult.nanoSecPerRun = (double)TIMELOOP_NANOSEC * 2000000000; /* hopefully large enough : must be larger than any potential measurement */
CONTROL(tfs != NULL);
@@ -231,7 +232,7 @@ static int bench_mem(unsigned int benchNb, const void *src, size_t srcSize,
bp.dstCapacities = &dstBuffSize;
bp.blockResults = NULL;
- while(1) {
+ while (1) {
BMK_runOutcome_t const bOutcome = BMK_benchTimedFn(tfs, bp);
BMK_runTime_t newResult;
@@ -260,7 +261,7 @@ static int bench_mem(unsigned int benchNb, const void *src, size_t srcSize,
static int bench_ref_data(void)
{
- int i,d, err = -1;
+ int i, d, err = -1;
enum {
SHORT_CADENCE,
NB_DATA_SETS
diff --git a/test/bench/benchfn.c b/test/bench/benchfn.c
index 5f768c33c79daca1dad916e5a17889c9bb95d6a0..7b01db3a018d6e6b99803e7fb95fa1c236cdf954 100644
--- a/test/bench/benchfn.c
+++ b/test/bench/benchfn.c
@@ -39,7 +39,7 @@
***************************************/
#if defined(DEBUGLEVEL) && (DEBUGLEVEL >= 1)
# include <stdio.h> /* fprintf */
- __extension__
+__extension__
# define DISPLAY(...) fprintf(stderr, __VA_ARGS__)
# define DEBUGOUTPUT(...) \
{ \
@@ -47,6 +47,7 @@
DISPLAY(__VA_ARGS__); \
}
#else
+__extension__
# define DEBUGOUTPUT(...)
#endif
@@ -95,6 +96,7 @@ size_t BMK_extract_errorResult(BMK_runOutcome_t outcome)
static BMK_runOutcome_t BMK_runOutcome_error(size_t errorResult)
{
BMK_runOutcome_t b;
+
memset(&b, 0, sizeof(b));
b.error_tag_never_ever_use_directly = 1;
b.error_result_never_ever_use_directly = errorResult;
@@ -104,6 +106,7 @@ static BMK_runOutcome_t BMK_runOutcome_error(size_t errorResult)
static BMK_runOutcome_t BMK_setValid_runTime(BMK_runTime_t runTime)
{
BMK_runOutcome_t outcome;
+
outcome.error_tag_never_ever_use_directly = 0;
outcome.internal_never_ever_use_directly = runTime;
return outcome;
@@ -119,11 +122,12 @@ static BMK_runOutcome_t BMK_setValid_runTime(BMK_runTime_t runTime)
BMK_runOutcome_t BMK_benchFunction(BMK_benchParams_t p, unsigned int nbLoops)
{
size_t dstSize = 0;
- nbLoops += !nbLoops; /* minimum nbLoops is 1 */
+ nbLoops += !nbLoops; /* minimum nbLoops is 1 */
/* init */
{
size_t i;
+
for (i = 0; i < p.blockCount; i++)
memset(p.dstBuffers[i], 0xE5, p.dstCapacities[i]); /* warm up and erase result buffer */
@@ -136,6 +140,7 @@ BMK_runOutcome_t BMK_benchFunction(BMK_benchParams_t p, unsigned int nbLoops)
{
UTIL_time_t const clockStart = UTIL_getTime();
unsigned int loopNb, blockNb;
+
if (p.initFn != NULL)
p.initFn(p.initPayload);
for (loopNb = 0; loopNb < nbLoops; loopNb++) {
@@ -154,7 +159,7 @@ BMK_runOutcome_t BMK_benchFunction(BMK_benchParams_t p, unsigned int nbLoops)
if ((p.errorFn != NULL) && (p.errorFn(res))) {
RETURN_QUIET_ERROR(BMK_runOutcome_error(res),
"Function benchmark failed on block %u (of size %u) with error %i",
- blockNb, (unsigned int)p.srcSizes [blockNb], (int)res);
+ blockNb, (unsigned int)p.srcSizes[blockNb], (int)res);
}
dstSize += res;
}
@@ -164,6 +169,7 @@ BMK_runOutcome_t BMK_benchFunction(BMK_benchParams_t p, unsigned int nbLoops)
{
PTime const totalTime = UTIL_clockSpanNano(clockStart);
BMK_runTime_t rt;
+
rt.nanoSecPerRun = (double)totalTime / nbLoops;
rt.sumOfReturn = dstSize;
return BMK_setValid_runTime(rt);
@@ -185,6 +191,7 @@ struct BMK_timedFnState_s {
BMK_timedFnState_t *BMK_createTimedFnState(unsigned int total_ms, unsigned int run_ms)
{
BMK_timedFnState_t *const r = (BMK_timedFnState_t *)malloc(sizeof(*r));
+
if (r == NULL)
return NULL; /* malloc() error */
BMK_resetTimedFnState(r, total_ms, run_ms);
@@ -199,13 +206,14 @@ void BMK_freeTimedFnState(BMK_timedFnState_t *state)
BMK_timedFnState_t *BMK_initStatic_timedFnState(void *buffer, size_t size,
unsigned int total_ms, unsigned int run_ms)
{
- typedef char check_size [2 * (sizeof(BMK_timedFnState_shell) >= sizeof(struct BMK_timedFnState_s)) - 1]; /* static assert : a compilation failure indicates that BMK_timedFnState_shell is not large enough */
+ typedef char check_size[2 * (sizeof(BMK_timedFnState_shell) >= sizeof(struct BMK_timedFnState_s)) - 1]; /* static assert : a compilation failure indicates that BMK_timedFnState_shell is not large enough */
typedef struct {
check_size c;
BMK_timedFnState_t tfs;
} tfs_align; /* force tfs to be aligned at its next best position */
- size_t const tfs_alignment = offsetof( tfs_align, tfs); /* provides the minimal alignment restriction for BMK_timedFnState_t */
+ size_t const tfs_alignment = offsetof(tfs_align, tfs); /* provides the minimal alignment restriction for BMK_timedFnState_t */
BMK_timedFnState_t *const r = (BMK_timedFnState_t *)buffer;
+
if (buffer == NULL)
return NULL;
if (size < sizeof(struct BMK_timedFnState_s))
@@ -268,10 +276,12 @@ BMK_runOutcome_t BMK_benchTimedFn(BMK_timedFnState_t *cont, BMK_benchParams_t p)
/* estimate nbLoops for next run to last approximately 1 second */
if (loopDuration_ns > ((double)runBudget_ns / 50)) {
double const fastestRun_ns = MIN(bestRunTime.nanoSecPerRun, newRunTime.nanoSecPerRun);
+
cont->nbLoops = (unsigned int)((double)runBudget_ns / fastestRun_ns) + 1;
} else {
/* previous run was too short : blindly increase workload by x multiplier */
const unsigned int multiplier = 10;
+
assert(cont->nbLoops < ((unsigned int)-1) / multiplier); /* avoid overflow */
cont->nbLoops *= multiplier;
}
@@ -281,9 +291,9 @@ BMK_runOutcome_t BMK_benchTimedFn(BMK_timedFnState_t *cont, BMK_benchParams_t p)
assert(completed == 0);
continue;
} else {
- if (newRunTime.nanoSecPerRun < bestRunTime.nanoSecPerRun) {
+ if (newRunTime.nanoSecPerRun < bestRunTime.nanoSecPerRun)
bestRunTime = newRunTime;
- }
+
completed = 1;
}
}
diff --git a/test/bench/leon3_grtimer_longcount.c b/test/bench/leon3_grtimer_longcount.c
index 771c97e010b57f6e165a197547349eec13c55c59..c88640457972b41e3b2d1eaf3525901c11f43102 100644
--- a/test/bench/leon3_grtimer_longcount.c
+++ b/test/bench/leon3_grtimer_longcount.c
@@ -100,16 +100,13 @@ void grtimer_longcount_get_uptime(struct grtimer_unit *rtu,
t0c = ioread32be(&rtu->timer[0].value);
t1c = ioread32be(&rtu->timer[1].value);
- if ((t0a >= t0b) && (t1a >= t1b))
- {
- t0 = t0a;
- t1 = t1a;
- }
- else
- {
- t0 = t0c;
- t1 = t1c;
- }
+ if ((t0a >= t0b) && (t1a >= t1b)) {
+ t0 = t0a;
+ t1 = t1a;
+ } else {
+ t0 = t0c;
+ t1 = t1c;
+ }
r0 = ioread32be(&rtu->timer[0].reload);
r1 = ioread32be(&rtu->timer[1].reload);
diff --git a/test/bench/timefn.c b/test/bench/timefn.c
index 620f7b05dc15b06327774e5aaf7c2bb5c9198bcc..3680cd1e64dada410829610d3223e5a47ef7c430 100644
--- a/test/bench/timefn.c
+++ b/test/bench/timefn.c
@@ -47,7 +47,7 @@ UTIL_time_t UTIL_getTime(void)
{
static struct grtimer_unit *rtu = (struct grtimer_unit *)LEON3_BASE_ADDRESS_GRTIMER;
static struct grtimer_uptime start;
- static int init = 0;
+ static int init;
if (!init) {
int32_t const err = grtimer_longcount_start(rtu, GRTIMER_RELOAD,
@@ -77,7 +77,7 @@ UTIL_time_t UTIL_getTime(void)
UTIL_time_t UTIL_getTime(void)
{
static LARGE_INTEGER ticksPerSecond;
- static int init = 0;
+ static int init;
if (!init) {
if (!QueryPerformanceFrequency(&ticksPerSecond)) {
@@ -89,6 +89,7 @@ UTIL_time_t UTIL_getTime(void)
{
UTIL_time_t r;
LARGE_INTEGER x;
+
QueryPerformanceCounter(&x);
r.t = (PTime)(x.QuadPart * 1000000000ULL / ticksPerSecond.QuadPart);
return r;
@@ -102,7 +103,7 @@ UTIL_time_t UTIL_getTime(void)
UTIL_time_t UTIL_getTime(void)
{
static mach_timebase_info_data_t rate;
- static int init = 0;
+ static int init;
if (!init) {
mach_timebase_info(&rate);
@@ -110,6 +111,7 @@ UTIL_time_t UTIL_getTime(void)
}
{
UTIL_time_t r;
+
r.t = mach_absolute_time() * (PTime)rate.numer /
(PTime)rate.denom;
return r;
@@ -136,6 +138,7 @@ UTIL_time_t UTIL_getTime(void)
}
{
UTIL_time_t r;
+
r.t = (PTime)time.tv_sec * 1000000000ULL + (PTime)time.tv_nsec;
return r;
}
@@ -148,8 +151,8 @@ UTIL_time_t UTIL_getTime(void)
* However, some versions of Android manage to simultanously define TIME_UTC
* and lack timespec_get() support...
*/
-#elif (defined(__STDC_VERSION__) && \
- (__STDC_VERSION__ >= 201112L) /* C11 */) && \
+#elif (defined(__STDC_VERSION__) && \
+ (__STDC_VERSION__ >= 201112L) /* C11 */) && \
defined(TIME_UTC) && !defined(__ANDROID__)
#include <stdlib.h> /* abort */
@@ -162,12 +165,14 @@ UTIL_time_t UTIL_getTime(void)
* reason, likely a limitation of timespec_get() for some target
*/
struct timespec time = { 0, 0 };
+
if (timespec_get(&time, TIME_UTC) != TIME_UTC) {
perror("timefn::timespec_get(TIME_UTC)");
abort();
}
{
UTIL_time_t r;
+
r.t = (PTime)time.tv_sec * 1000000000ULL + (PTime)time.tv_nsec;
return r;
}
@@ -178,6 +183,7 @@ UTIL_time_t UTIL_getTime(void)
UTIL_time_t UTIL_getTime(void)
{
UTIL_time_t r;
+
r.t = (PTime)clock() * 1000000000ULL / CLOCKS_PER_SEC;
return r;
}
@@ -201,12 +207,14 @@ PTime UTIL_getSpanTimeMicro(UTIL_time_t begin, UTIL_time_t end)
PTime UTIL_clockSpanMicro(UTIL_time_t clockStart)
{
UTIL_time_t const clockEnd = UTIL_getTime();
+
return UTIL_getSpanTimeMicro(clockStart, clockEnd);
}
PTime UTIL_clockSpanNano(UTIL_time_t clockStart)
{
UTIL_time_t const clockEnd = UTIL_getTime();
+
return UTIL_getSpanTimeNano(clockStart, clockEnd);
}
@@ -214,6 +222,7 @@ void UTIL_waitForNextTick(void)
{
UTIL_time_t const clockStart = UTIL_getTime();
UTIL_time_t clockEnd;
+
do {
clockEnd = UTIL_getTime();
} while (UTIL_getSpanTimeNano(clockStart, clockEnd) == 0);
diff --git a/test/cmp_data_types/test_cmp_data_types.c b/test/cmp_data_types/test_cmp_data_types.c
index 1bc0de4df864819bc211e465d5467d80a3b1ba34..51e8f538fa5cbb0fc9ea988eca51f0b52a0ada18 100644
--- a/test/cmp_data_types/test_cmp_data_types.c
+++ b/test/cmp_data_types/test_cmp_data_types.c
@@ -141,9 +141,9 @@ void test_cmp_col_get_and_set(void)
err = cmp_col_set_data_length(NULL, 0x0A0B);
TEST_ASSERT_TRUE(err);
- for (i = 0; i < sizeof(struct collection_hdr); i++) {
+ for (i = 0; i < sizeof(struct collection_hdr); i++)
TEST_ASSERT_EQUAL_HEX8(i, u8_p[i]);
- }
+
free(col);
}
@@ -710,7 +710,7 @@ void test_cmp_input_big_to_cpu_endianness_error_cases(void)
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] );
+ TEST_ASSERT_EQUAL(i, ((uint8_t *)data_ap)[i]);
data_type = DATA_TYPE_SAT_IMAGETTE_ADAPTIVE;
data_ap[0] = 0x0001;
@@ -718,7 +718,7 @@ void test_cmp_input_big_to_cpu_endianness_error_cases(void)
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] );
+ TEST_ASSERT_EQUAL(i, ((uint8_t *)data_ap)[i]);
data_type = DATA_TYPE_F_CAM_IMAGETTE_ADAPTIVE;
data_ap[0] = 0x0001;
@@ -726,7 +726,7 @@ void test_cmp_input_big_to_cpu_endianness_error_cases(void)
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] );
+ TEST_ASSERT_EQUAL(i, ((uint8_t *)data_ap)[i]);
}
}
diff --git a/test/cmp_decmp/test_cmp_decmp.c b/test/cmp_decmp/test_cmp_decmp.c
index b89320c6ef55dd9860d6880d6500d676998f6685..c4ce8d9e4d558e165afb0ae6398b6466c15eedf5 100644
--- a/test/cmp_decmp/test_cmp_decmp.c
+++ b/test/cmp_decmp/test_cmp_decmp.c
@@ -69,6 +69,7 @@ void setUp(void)
if (!n) {
uint32_t high = seed >> 32;
uint32_t low = seed & 0xFFFFFFFF;
+
n = 1;
cmp_rand_seed(seed);
printf("seed: 0x%08"PRIx32"%08"PRIx32"\n", high, low);
@@ -132,14 +133,15 @@ static uint32_t gen_geometric_data(uint32_t n_bits, void *extra)
* @returns random number following a uniform distribution, masked with n_bits
*/
-static uint32_t gen_uniform_data(uint32_t n_bits, void* unused UNUSED)
+static uint32_t gen_uniform_data(uint32_t n_bits, void *unused UNUSED)
{
return cmp_rand_nbits(n_bits);
}
static size_t gen_ima_data(uint16_t *data, enum cmp_data_type data_type,
- uint32_t samples, uint32_t (*gen_data_f)(uint32_t, void*),
+ uint32_t samples,
+ uint32_t (*gen_data_f)(uint32_t max_data_bits, void *extra),
void *extra)
{
uint32_t i;
@@ -818,7 +820,7 @@ void test_random_round_trip_like_rdcu_compression(void)
int run;
for (run = 0; run < 2; run++) {
- uint32_t (*gen_data_f)(uint32_t, void*);
+ uint32_t (*gen_data_f)(uint32_t max_data_bits, void *extra);
void *extra;
double p = 0.01;
size_t size;
@@ -964,7 +966,7 @@ void test_random_collection_round_trip(void)
TEST_ASSERT_NOT_NULL(cmp_data);
for (run = 0; run < 2; run++) {
- uint32_t (*gen_data_f)(uint32_t, void*);
+ uint32_t (*gen_data_f)(uint32_t max_data_bits, void *extra);
void *extra;
double p = 0.01;
@@ -1463,6 +1465,7 @@ void test_cmp_decmp_chunk_raw(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);
diff --git a/test/cmp_entity/test_cmp_entity.c b/test/cmp_entity/test_cmp_entity.c
index ef4f3d9e4dc87671f7d19525f7274f4c939de2a6..2fd053cff29246908e62d9c937e3e1dfa1e55b59 100644
--- a/test/cmp_entity/test_cmp_entity.c
+++ b/test/cmp_entity/test_cmp_entity.c
@@ -1488,253 +1488,253 @@ void test_cmp_ent_get_cmp_data_size(void)
void test_cmp_ent_write_rdcu_cmp_pars(void)
{
- int error;
- uint32_t size;
- struct cmp_entity *ent;
- struct cmp_info info;
- struct rdcu_cfg rcfg;
-
- info.cmp_mode_used = CMP_MODE_DIFF_ZERO;
- info.spill_used = 42;
- info.golomb_par_used = 23;
- info.samples_used = 9;
- info.cmp_size = 96;
- info.model_value_used = 6;
- info.round_used = 1;
- info.cmp_err = 0;
-
- /* create a imagette compression entity */
- size = cmp_ent_create(NULL, DATA_TYPE_IMAGETTE, info.cmp_mode_used == CMP_MODE_RAW, 12);
- TEST_ASSERT_NOT_EQUAL_INT(0, size);
- ent = malloc(size); TEST_ASSERT_NOT_NULL(ent);
- size = cmp_ent_create(ent, DATA_TYPE_IMAGETTE, info.cmp_mode_used == CMP_MODE_RAW, 12);
- TEST_ASSERT_NOT_EQUAL_INT(0, size);
-
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, NULL);
- TEST_ASSERT_FALSE(error);
-
- TEST_ASSERT_EQUAL_INT(DATA_TYPE_IMAGETTE, cmp_ent_get_data_type(ent));
- TEST_ASSERT_EQUAL_INT(0, cmp_ent_get_data_type_raw_bit(ent));
- TEST_ASSERT_EQUAL_INT(12, cmp_ent_get_cmp_data_size(ent));
-
- TEST_ASSERT_EQUAL_INT(info.samples_used * sizeof(uint16_t), cmp_ent_get_original_size(ent));
- TEST_ASSERT_EQUAL_INT(info.cmp_mode_used, cmp_ent_get_cmp_mode(ent));
- TEST_ASSERT_EQUAL_INT(info.model_value_used, cmp_ent_get_model_value(ent));
- TEST_ASSERT_EQUAL_INT(0, cmp_ent_get_reserved(ent));
- TEST_ASSERT_EQUAL_INT(info.round_used, cmp_ent_get_lossy_cmp_par(ent));
-
- TEST_ASSERT_EQUAL_INT(info.spill_used, cmp_ent_get_ima_spill(ent));
- TEST_ASSERT_EQUAL_INT(info.golomb_par_used, cmp_ent_get_ima_golomb_par(ent));
-
- free(ent);
-
- /* raw mode test */
- /* create a raw imagette compression entity */
- info.cmp_mode_used = CMP_MODE_RAW;
- size = cmp_ent_create(NULL, DATA_TYPE_IMAGETTE, info.cmp_mode_used == CMP_MODE_RAW, 12);
- TEST_ASSERT_NOT_EQUAL_INT(0, size);
- ent = malloc(size); TEST_ASSERT_NOT_NULL(ent);
- size = cmp_ent_create(ent, DATA_TYPE_IMAGETTE, info.cmp_mode_used == CMP_MODE_RAW, 12);
- TEST_ASSERT_NOT_EQUAL_INT(0, size);
-
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, NULL);
- TEST_ASSERT_FALSE(error);
-
- TEST_ASSERT_EQUAL_INT(DATA_TYPE_IMAGETTE, cmp_ent_get_data_type(ent));
- TEST_ASSERT_EQUAL_INT(1, cmp_ent_get_data_type_raw_bit(ent));
- TEST_ASSERT_EQUAL_INT(12, cmp_ent_get_cmp_data_size(ent));
-
- TEST_ASSERT_EQUAL_INT(info.samples_used * sizeof(uint16_t), cmp_ent_get_original_size(ent));
- TEST_ASSERT_EQUAL_INT(info.cmp_mode_used, cmp_ent_get_cmp_mode(ent));
- TEST_ASSERT_EQUAL_INT(info.model_value_used, cmp_ent_get_model_value(ent));
- TEST_ASSERT_EQUAL_INT(0, cmp_ent_get_reserved(ent));
- TEST_ASSERT_EQUAL_INT(info.round_used, cmp_ent_get_lossy_cmp_par(ent));
-
- free(ent);
-
- /* adaptive configuration */
- info.cmp_mode_used = CMP_MODE_MODEL_MULTI;
- rcfg.ap1_golomb_par = 0xFF;
- rcfg.ap1_spill = 1;
- rcfg.ap2_golomb_par = 0x32;
- rcfg.ap2_spill = 201;
-
- /* create a adaptive imagette compression entity */
- size = cmp_ent_create(NULL, DATA_TYPE_IMAGETTE_ADAPTIVE, info.cmp_mode_used == CMP_MODE_RAW, 12);
- TEST_ASSERT_NOT_EQUAL_INT(0, size);
- ent = malloc(size); TEST_ASSERT_NOT_NULL(ent);
- size = cmp_ent_create(ent, DATA_TYPE_IMAGETTE_ADAPTIVE, info.cmp_mode_used == CMP_MODE_RAW, 12);
- TEST_ASSERT_NOT_EQUAL_INT(0, size);
-
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
- TEST_ASSERT_FALSE(error);
-
- TEST_ASSERT_EQUAL_INT(DATA_TYPE_IMAGETTE_ADAPTIVE, cmp_ent_get_data_type(ent));
- TEST_ASSERT_EQUAL_INT(0, cmp_ent_get_data_type_raw_bit(ent));
- TEST_ASSERT_EQUAL_INT(12, cmp_ent_get_cmp_data_size(ent));
-
- TEST_ASSERT_EQUAL_INT(info.samples_used * sizeof(uint16_t), cmp_ent_get_original_size(ent));
- TEST_ASSERT_EQUAL_INT(info.cmp_mode_used, cmp_ent_get_cmp_mode(ent));
- TEST_ASSERT_EQUAL_INT(info.model_value_used, cmp_ent_get_model_value(ent));
- TEST_ASSERT_EQUAL_INT(0, cmp_ent_get_reserved(ent));
- TEST_ASSERT_EQUAL_INT(info.round_used, cmp_ent_get_lossy_cmp_par(ent));
-
- TEST_ASSERT_EQUAL_INT(info.spill_used, cmp_ent_get_ima_spill(ent));
- TEST_ASSERT_EQUAL_INT(info.golomb_par_used, cmp_ent_get_ima_golomb_par(ent));
- TEST_ASSERT_EQUAL_INT(rcfg.ap1_spill, cmp_ent_get_ima_ap1_spill(ent));
- TEST_ASSERT_EQUAL_INT(rcfg.ap1_golomb_par, cmp_ent_get_ima_ap1_golomb_par(ent));
- TEST_ASSERT_EQUAL_INT(rcfg.ap2_spill, cmp_ent_get_ima_ap2_spill(ent));
- TEST_ASSERT_EQUAL_INT(rcfg.ap2_golomb_par, cmp_ent_get_ima_ap2_golomb_par(ent));
-
-
- /** error cases **/
-
- /* ent = NULL */
- error = cmp_ent_write_rdcu_cmp_pars(NULL, &info, &rcfg);
- TEST_ASSERT_TRUE(error);
-
- /* info = NULL */
- error = cmp_ent_write_rdcu_cmp_pars(ent, NULL, &rcfg);
- TEST_ASSERT_TRUE(error);
-
- /* cfg = NULL and adaptive data type */
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, NULL);
- TEST_ASSERT_TRUE(error);
-
- /* compressed data are to big for the compression entity */
- info.cmp_size = 12*8 + 1;
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
- TEST_ASSERT_TRUE(error);
- info.cmp_size = 1;
-
- /* wrong data_type */
- cmp_ent_set_data_type(ent, DATA_TYPE_S_FX, 0);
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
- TEST_ASSERT_TRUE(error);
- cmp_ent_set_data_type(ent, DATA_TYPE_F_CAM_IMAGETTE_ADAPTIVE, 0);
- /* this should work */
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
- TEST_ASSERT_FALSE(error);
-
- /* original_size to high */
- info.samples_used = 0x800000;
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
- TEST_ASSERT_TRUE(error);
- info.samples_used = 0x7FFFFF;
- /* this should work */
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
- TEST_ASSERT_FALSE(error);
-
- /* cmp_mode to high */
- info.cmp_mode_used = 0x100;
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
- TEST_ASSERT_TRUE(error);
- info.cmp_mode_used = 0xFF;
- /* this should work */
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
- TEST_ASSERT_FALSE(error);
-
- TEST_ASSERT_EQUAL_INT(1, sizeof(info.model_value_used));
- TEST_ASSERT_EQUAL_INT(1, sizeof(info.round_used));
+ int error;
+ uint32_t size;
+ struct cmp_entity *ent;
+ struct cmp_info info;
+ struct rdcu_cfg rcfg;
+
+ info.cmp_mode_used = CMP_MODE_DIFF_ZERO;
+ info.spill_used = 42;
+ info.golomb_par_used = 23;
+ info.samples_used = 9;
+ info.cmp_size = 96;
+ info.model_value_used = 6;
+ info.round_used = 1;
+ info.cmp_err = 0;
+
+ /* create a imagette compression entity */
+ size = cmp_ent_create(NULL, DATA_TYPE_IMAGETTE, info.cmp_mode_used == CMP_MODE_RAW, 12);
+ TEST_ASSERT_NOT_EQUAL_INT(0, size);
+ ent = malloc(size); TEST_ASSERT_NOT_NULL(ent);
+ size = cmp_ent_create(ent, DATA_TYPE_IMAGETTE, info.cmp_mode_used == CMP_MODE_RAW, 12);
+ TEST_ASSERT_NOT_EQUAL_INT(0, size);
+
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, NULL);
+ TEST_ASSERT_FALSE(error);
+
+ TEST_ASSERT_EQUAL_INT(DATA_TYPE_IMAGETTE, cmp_ent_get_data_type(ent));
+ TEST_ASSERT_EQUAL_INT(0, cmp_ent_get_data_type_raw_bit(ent));
+ TEST_ASSERT_EQUAL_INT(12, cmp_ent_get_cmp_data_size(ent));
+
+ TEST_ASSERT_EQUAL_INT(info.samples_used * sizeof(uint16_t), cmp_ent_get_original_size(ent));
+ TEST_ASSERT_EQUAL_INT(info.cmp_mode_used, cmp_ent_get_cmp_mode(ent));
+ TEST_ASSERT_EQUAL_INT(info.model_value_used, cmp_ent_get_model_value(ent));
+ TEST_ASSERT_EQUAL_INT(0, cmp_ent_get_reserved(ent));
+ TEST_ASSERT_EQUAL_INT(info.round_used, cmp_ent_get_lossy_cmp_par(ent));
+
+ TEST_ASSERT_EQUAL_INT(info.spill_used, cmp_ent_get_ima_spill(ent));
+ TEST_ASSERT_EQUAL_INT(info.golomb_par_used, cmp_ent_get_ima_golomb_par(ent));
+
+ free(ent);
+
+ /* raw mode test */
+ /* create a raw imagette compression entity */
+ info.cmp_mode_used = CMP_MODE_RAW;
+ size = cmp_ent_create(NULL, DATA_TYPE_IMAGETTE, info.cmp_mode_used == CMP_MODE_RAW, 12);
+ TEST_ASSERT_NOT_EQUAL_INT(0, size);
+ ent = malloc(size); TEST_ASSERT_NOT_NULL(ent);
+ size = cmp_ent_create(ent, DATA_TYPE_IMAGETTE, info.cmp_mode_used == CMP_MODE_RAW, 12);
+ TEST_ASSERT_NOT_EQUAL_INT(0, size);
+
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, NULL);
+ TEST_ASSERT_FALSE(error);
+
+ TEST_ASSERT_EQUAL_INT(DATA_TYPE_IMAGETTE, cmp_ent_get_data_type(ent));
+ TEST_ASSERT_EQUAL_INT(1, cmp_ent_get_data_type_raw_bit(ent));
+ TEST_ASSERT_EQUAL_INT(12, cmp_ent_get_cmp_data_size(ent));
+
+ TEST_ASSERT_EQUAL_INT(info.samples_used * sizeof(uint16_t), cmp_ent_get_original_size(ent));
+ TEST_ASSERT_EQUAL_INT(info.cmp_mode_used, cmp_ent_get_cmp_mode(ent));
+ TEST_ASSERT_EQUAL_INT(info.model_value_used, cmp_ent_get_model_value(ent));
+ TEST_ASSERT_EQUAL_INT(0, cmp_ent_get_reserved(ent));
+ TEST_ASSERT_EQUAL_INT(info.round_used, cmp_ent_get_lossy_cmp_par(ent));
+
+ free(ent);
+
+ /* adaptive configuration */
+ info.cmp_mode_used = CMP_MODE_MODEL_MULTI;
+ rcfg.ap1_golomb_par = 0xFF;
+ rcfg.ap1_spill = 1;
+ rcfg.ap2_golomb_par = 0x32;
+ rcfg.ap2_spill = 201;
+
+ /* create a adaptive imagette compression entity */
+ size = cmp_ent_create(NULL, DATA_TYPE_IMAGETTE_ADAPTIVE, info.cmp_mode_used == CMP_MODE_RAW, 12);
+ TEST_ASSERT_NOT_EQUAL_INT(0, size);
+ ent = malloc(size); TEST_ASSERT_NOT_NULL(ent);
+ size = cmp_ent_create(ent, DATA_TYPE_IMAGETTE_ADAPTIVE, info.cmp_mode_used == CMP_MODE_RAW, 12);
+ TEST_ASSERT_NOT_EQUAL_INT(0, size);
+
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
+ TEST_ASSERT_FALSE(error);
+
+ TEST_ASSERT_EQUAL_INT(DATA_TYPE_IMAGETTE_ADAPTIVE, cmp_ent_get_data_type(ent));
+ TEST_ASSERT_EQUAL_INT(0, cmp_ent_get_data_type_raw_bit(ent));
+ TEST_ASSERT_EQUAL_INT(12, cmp_ent_get_cmp_data_size(ent));
+
+ TEST_ASSERT_EQUAL_INT(info.samples_used * sizeof(uint16_t), cmp_ent_get_original_size(ent));
+ TEST_ASSERT_EQUAL_INT(info.cmp_mode_used, cmp_ent_get_cmp_mode(ent));
+ TEST_ASSERT_EQUAL_INT(info.model_value_used, cmp_ent_get_model_value(ent));
+ TEST_ASSERT_EQUAL_INT(0, cmp_ent_get_reserved(ent));
+ TEST_ASSERT_EQUAL_INT(info.round_used, cmp_ent_get_lossy_cmp_par(ent));
+
+ TEST_ASSERT_EQUAL_INT(info.spill_used, cmp_ent_get_ima_spill(ent));
+ TEST_ASSERT_EQUAL_INT(info.golomb_par_used, cmp_ent_get_ima_golomb_par(ent));
+ TEST_ASSERT_EQUAL_INT(rcfg.ap1_spill, cmp_ent_get_ima_ap1_spill(ent));
+ TEST_ASSERT_EQUAL_INT(rcfg.ap1_golomb_par, cmp_ent_get_ima_ap1_golomb_par(ent));
+ TEST_ASSERT_EQUAL_INT(rcfg.ap2_spill, cmp_ent_get_ima_ap2_spill(ent));
+ TEST_ASSERT_EQUAL_INT(rcfg.ap2_golomb_par, cmp_ent_get_ima_ap2_golomb_par(ent));
+
+
+ /** error cases **/
+
+ /* ent = NULL */
+ error = cmp_ent_write_rdcu_cmp_pars(NULL, &info, &rcfg);
+ TEST_ASSERT_TRUE(error);
+
+ /* info = NULL */
+ error = cmp_ent_write_rdcu_cmp_pars(ent, NULL, &rcfg);
+ TEST_ASSERT_TRUE(error);
+
+ /* cfg = NULL and adaptive data type */
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, NULL);
+ TEST_ASSERT_TRUE(error);
+
+ /* compressed data are to big for the compression entity */
+ info.cmp_size = 12*8 + 1;
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
+ TEST_ASSERT_TRUE(error);
+ info.cmp_size = 1;
+
+ /* wrong data_type */
+ cmp_ent_set_data_type(ent, DATA_TYPE_S_FX, 0);
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
+ TEST_ASSERT_TRUE(error);
+ cmp_ent_set_data_type(ent, DATA_TYPE_F_CAM_IMAGETTE_ADAPTIVE, 0);
+ /* this should work */
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
+ TEST_ASSERT_FALSE(error);
+
+ /* original_size to high */
+ info.samples_used = 0x800000;
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
+ TEST_ASSERT_TRUE(error);
+ info.samples_used = 0x7FFFFF;
+ /* this should work */
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
+ TEST_ASSERT_FALSE(error);
+
+ /* cmp_mode to high */
+ info.cmp_mode_used = 0x100;
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
+ TEST_ASSERT_TRUE(error);
+ info.cmp_mode_used = 0xFF;
+ /* this should work */
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
+ TEST_ASSERT_FALSE(error);
+
+ TEST_ASSERT_EQUAL_INT(1, sizeof(info.model_value_used));
+ TEST_ASSERT_EQUAL_INT(1, sizeof(info.round_used));
#if 0
- /* max model_value to high */
- info.model_value_used = 0x100;
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &cfg);
- TEST_ASSERT_TRUE(error);
- info.model_value_used = 0xFF;
- /* this should work */
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &cfg);
- TEST_ASSERT_FALSE(error);
-
- /* max lossy_cmp_par to high */
- info.round = 0x10000;
- error = cmp_ent_write_cmp_pars(ent, &cfg, cmp_size_bits);
- TEST_ASSERT_TRUE(error);
- info.round = 0xFFFF;
- /* this should work */
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &cfg);
- TEST_ASSERT_FALSE(error);
+ /* max model_value to high */
+ info.model_value_used = 0x100;
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &cfg);
+ TEST_ASSERT_TRUE(error);
+ info.model_value_used = 0xFF;
+ /* this should work */
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &cfg);
+ TEST_ASSERT_FALSE(error);
+
+ /* max lossy_cmp_par to high */
+ info.round = 0x10000;
+ error = cmp_ent_write_cmp_pars(ent, &cfg, cmp_size_bits);
+ TEST_ASSERT_TRUE(error);
+ info.round = 0xFFFF;
+ /* this should work */
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &cfg);
+ TEST_ASSERT_FALSE(error);
#endif
- /* spill to high */
- info.spill_used = 0x10000;
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
- TEST_ASSERT_TRUE(error);
- info.spill_used = 0xFFFF;
- /* this should work */
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
- TEST_ASSERT_FALSE(error);
-
- /* golomb_par to high */
- info.golomb_par_used = 0x100;
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
- TEST_ASSERT_TRUE(error);
- info.golomb_par_used = 0xFF;
- /* this should work */
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
- TEST_ASSERT_FALSE(error);
-
- /* adaptive 1 spill to high */
- rcfg.ap1_spill = 0x10000;
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
- TEST_ASSERT_TRUE(error);
- rcfg.ap1_spill = 0xFFFF;
- /* this should work */
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
- TEST_ASSERT_FALSE(error);
-
- /* adaptive 1 golomb_par to high */
- rcfg.ap1_golomb_par = 0x100;
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
- TEST_ASSERT_TRUE(error);
- rcfg.ap1_golomb_par = 0xFF;
- /* this should work */
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
- TEST_ASSERT_FALSE(error);
-
- /* adaptive 2 spill to high */
- rcfg.ap2_spill = 0x10000;
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
- TEST_ASSERT_TRUE(error);
- rcfg.ap2_spill = 0xFFFF;
- /* this should work */
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
- TEST_ASSERT_FALSE(error);
-
- /* adaptive 2 golomb_par to high */
- rcfg.ap2_golomb_par = 0x100;
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
- TEST_ASSERT_TRUE(error);
- rcfg.ap2_golomb_par = 0xFF;
- /* this should work */
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
- TEST_ASSERT_FALSE(error);
-
- /* The entity's raw data bit is not set, but the configuration contains raw data */
- info.cmp_mode_used = CMP_MODE_RAW;
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
- TEST_ASSERT_TRUE(error);
- info.cmp_mode_used = CMP_MODE_MODEL_MULTI;
- /* this should work */
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
- TEST_ASSERT_FALSE(error);
-
- /* The entity's raw data bit is set, but the configuration contains no raw data */
- cmp_ent_set_data_type(ent, DATA_TYPE_IMAGETTE_ADAPTIVE, 1); /* set raw bit */
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
- TEST_ASSERT_TRUE(error);
- cmp_ent_set_data_type(ent, DATA_TYPE_F_CAM_IMAGETTE_ADAPTIVE, 0);
- /* this should work */
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
- TEST_ASSERT_FALSE(error);
-
- /* compression error set */
- info.cmp_err = 1;
- error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
- TEST_ASSERT_TRUE(error);
- info.cmp_err = 0;
-
- free(ent);
+ /* spill to high */
+ info.spill_used = 0x10000;
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
+ TEST_ASSERT_TRUE(error);
+ info.spill_used = 0xFFFF;
+ /* this should work */
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
+ TEST_ASSERT_FALSE(error);
+
+ /* golomb_par to high */
+ info.golomb_par_used = 0x100;
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
+ TEST_ASSERT_TRUE(error);
+ info.golomb_par_used = 0xFF;
+ /* this should work */
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
+ TEST_ASSERT_FALSE(error);
+
+ /* adaptive 1 spill to high */
+ rcfg.ap1_spill = 0x10000;
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
+ TEST_ASSERT_TRUE(error);
+ rcfg.ap1_spill = 0xFFFF;
+ /* this should work */
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
+ TEST_ASSERT_FALSE(error);
+
+ /* adaptive 1 golomb_par to high */
+ rcfg.ap1_golomb_par = 0x100;
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
+ TEST_ASSERT_TRUE(error);
+ rcfg.ap1_golomb_par = 0xFF;
+ /* this should work */
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
+ TEST_ASSERT_FALSE(error);
+
+ /* adaptive 2 spill to high */
+ rcfg.ap2_spill = 0x10000;
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
+ TEST_ASSERT_TRUE(error);
+ rcfg.ap2_spill = 0xFFFF;
+ /* this should work */
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
+ TEST_ASSERT_FALSE(error);
+
+ /* adaptive 2 golomb_par to high */
+ rcfg.ap2_golomb_par = 0x100;
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
+ TEST_ASSERT_TRUE(error);
+ rcfg.ap2_golomb_par = 0xFF;
+ /* this should work */
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
+ TEST_ASSERT_FALSE(error);
+
+ /* The entity's raw data bit is not set, but the configuration contains raw data */
+ info.cmp_mode_used = CMP_MODE_RAW;
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
+ TEST_ASSERT_TRUE(error);
+ info.cmp_mode_used = CMP_MODE_MODEL_MULTI;
+ /* this should work */
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
+ TEST_ASSERT_FALSE(error);
+
+ /* The entity's raw data bit is set, but the configuration contains no raw data */
+ cmp_ent_set_data_type(ent, DATA_TYPE_IMAGETTE_ADAPTIVE, 1); /* set raw bit */
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
+ TEST_ASSERT_TRUE(error);
+ cmp_ent_set_data_type(ent, DATA_TYPE_F_CAM_IMAGETTE_ADAPTIVE, 0);
+ /* this should work */
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
+ TEST_ASSERT_FALSE(error);
+
+ /* compression error set */
+ info.cmp_err = 1;
+ error = cmp_ent_write_rdcu_cmp_pars(ent, &info, &rcfg);
+ TEST_ASSERT_TRUE(error);
+ info.cmp_err = 0;
+
+ free(ent);
}
diff --git a/test/cmp_icu/test_cmp_icu.c b/test/cmp_icu/test_cmp_icu.c
index 7aef7eadf8b3eb8ebf431673a126488f81b88a88..f6c72696d79bea0cf14854282b19da730e2ec00e 100644
--- a/test/cmp_icu/test_cmp_icu.c
+++ b/test/cmp_icu/test_cmp_icu.c
@@ -1579,6 +1579,7 @@ void test_compress_data_internal_error_cases(void)
uint16_t data[2] = {0, 0};
uint32_t dst[3] = {0};
+
cfg.data_type = DATA_TYPE_IMAGETTE;
cfg.src = data;
cfg.samples = 2;
@@ -1774,6 +1775,7 @@ void test_compress_chunk_raw_two_col(void)
(uint8_t *)cmp_ent_get_data_buf(ent) + 2*COLLECTION_HDR_SIZE +
DATA_SIZE_1);
int i;
+
TEST_ASSERT_EQUAL_UINT(CHUNK_SIZE, cmp_ent_get_cmp_data_size(ent));
TEST_ASSERT_EQUAL_UINT(CHUNK_SIZE, cmp_ent_get_original_size(ent));
TEST_ASSERT_EQUAL_UINT(cmp_par.cmp_mode, cmp_ent_get_cmp_mode(ent));
@@ -1887,7 +1889,7 @@ void test_compress_chunk_aux(void)
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_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));
@@ -1901,7 +1903,7 @@ void test_compress_chunk_aux(void)
/* wrong model value */
cmp_par.cmp_mode = CMP_MODE_MODEL_ZERO;
- cmp_par.model_value = MAX_MODEL_VALUE +1 ;
+ 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));
@@ -2001,6 +2003,7 @@ void test_compress_chunk_error_cases(void)
struct collection_hdr *col1 = (struct collection_hdr *)chunk;
struct s_fx *data1 = (struct s_fx *)col1->entry;
struct s_fx_efx_ncob_ecob *data2;
+
memset(col1, 0, COLLECTION_HDR_SIZE);
TEST_ASSERT_FALSE(cmp_col_set_subservice(col1, SST_NCxx_S_SCIENCE_S_FX));
TEST_ASSERT_FALSE(cmp_col_set_data_length(col1, DATA_SIZE_1));
@@ -2117,7 +2120,7 @@ void test_compress_chunk_error_cases(void)
/* chunk buffer and dst are the same */
cmp_size = compress_chunk(chunk, CHUNK_SIZE, chunk_model,
- updated_chunk_model, (void*)chunk, dst_capacity,
+ updated_chunk_model, (void *)chunk, dst_capacity,
&cmp_par);
TEST_ASSERT_EQUAL_INT(CMP_ERROR_PAR_BUFFERS, cmp_get_error_code(cmp_size));
@@ -2166,6 +2169,7 @@ void test_compress_chunk_error_cases(void)
cmp_par.lossy_par = 0x1;
{
size_t i;
+
for (i = 0; i < ARRAY_SIZE(dst); i++)
TEST_ASSERT_EQUAL_HEX(0xFFFFFFFF, dst[i]);
}
@@ -2314,7 +2318,7 @@ void test_COMPRESS_CHUNK_BOUND(void)
chunk_size);
TEST_ASSERT_EQUAL(bound_exp, bound);
- chunk_size = 42*COLLECTION_HDR_SIZE ;
+ chunk_size = 42*COLLECTION_HDR_SIZE;
num_col = 42;
bound = COMPRESS_CHUNK_BOUND(chunk_size, num_col);
bound_exp = ROUND_UP_TO_4(NON_IMAGETTE_HEADER_SIZE + 42*CMP_COLLECTION_FILD_SIZE +
@@ -2366,7 +2370,7 @@ void test_compress_chunk_cmp_size_bound(void)
uint32_t chunk_size;
uint32_t bound, bound_exp;
struct collection_hdr *col2 = (struct collection_hdr *)
- (chunk+COLLECTION_HDR_SIZE +CHUNK_SIZE_1);
+ (chunk+COLLECTION_HDR_SIZE + CHUNK_SIZE_1);
TEST_ASSERT_FALSE(cmp_col_set_data_length((struct collection_hdr *)chunk, 0));
diff --git a/test/cmp_tool/gen_test_data.c b/test/cmp_tool/gen_test_data.c
index 05c1ddab03ad7067e7e9465b80bd78bf1f3691de..ae0d7ccddb000901e35df327a93aa708fe2cd965 100644
--- a/test/cmp_tool/gen_test_data.c
+++ b/test/cmp_tool/gen_test_data.c
@@ -17,22 +17,22 @@ int main(int argc, char *argv[])
for (i = 1; i < argc; i++) {
if (strstr(argv[i], "ref_short_cadence_1_cmp")) {
fp = fopen(argv[i], "wb");
- if(!fp)
+ if (!fp)
return 1;
s = fwrite(ref_short_cadence_1_cmp, 1, ref_short_cadence_1_cmp_len, fp);
fclose(fp);
- if (s!=ref_short_cadence_1_cmp_len)
+ if (s != ref_short_cadence_1_cmp_len)
return 1;
} else if (strstr(argv[i], "ref_short_cadence_2_cmp")) {
fp = fopen(argv[i], "wb");
- if(!fp)
+ if (!fp)
return 1;
s = fwrite(ref_short_cadence_2_cmp, 1, ref_short_cadence_2_cmp_len, fp);
fclose(fp);
- if (s!=ref_short_cadence_2_cmp_len)
+ if (s != ref_short_cadence_2_cmp_len)
return 1;
} else {
- fprintf(stderr,"Unknown test data\n");
+ fprintf(stderr, "Unknown test data\n");
return 1;
}
}
diff --git a/test/decmp/test_decmp.c b/test/decmp/test_decmp.c
index 93d3952683932a435123cc408258c5d9384076b5..c1881fb4b31898c1dedfad2a8633c04244898456 100644
--- a/test/decmp/test_decmp.c
+++ b/test/decmp/test_decmp.c
@@ -974,12 +974,12 @@ void test_cmp_decmp_rdcu_raw(void)
cmp_size = compress_like_rdcu(&rcfg, &info);
TEST_ASSERT_EQUAL_UINT(sizeof(data)*CHAR_BIT, cmp_size);
- s = cmp_ent_create(NULL, DATA_TYPE_IMAGETTE , rcfg.cmp_mode == CMP_MODE_RAW,
+ s = cmp_ent_create(NULL, DATA_TYPE_IMAGETTE, rcfg.cmp_mode == CMP_MODE_RAW,
cmp_bit_to_byte(cmp_size));
TEST_ASSERT_TRUE(s);
ent = malloc(s);
TEST_ASSERT_TRUE(ent);
- s = cmp_ent_create(ent, DATA_TYPE_IMAGETTE , rcfg.cmp_mode == CMP_MODE_RAW,
+ s = cmp_ent_create(ent, DATA_TYPE_IMAGETTE, rcfg.cmp_mode == CMP_MODE_RAW,
cmp_bit_to_byte(cmp_size));
TEST_ASSERT_TRUE(s);
TEST_ASSERT_FALSE(cmp_ent_write_rdcu_cmp_pars(ent, &info, NULL));
diff --git a/test/fuzz/fuzz_compression.c b/test/fuzz/fuzz_compression.c
index e894ebc2e8b89425833fa9772f39be1768f25842..9b9b981750af2f6b70975fe7ddb3cbe8af6d9764 100644
--- a/test/fuzz/fuzz_compression.c
+++ b/test/fuzz/fuzz_compression.c
@@ -46,6 +46,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *src, size_t size)
/* Give a random portion of src data to the producer, to use for
parameter generation. The rest will be used for data/model */
FUZZ_dataProducer_t *producer = (FUZZ_dataProducer_t *)FUZZ_dataProducer_create(src, size);
+
size = FUZZ_dataProducer_reserveDataPrefix(producer);
FUZZ_dataProducer_cmp_par(producer, &cmp_par);
@@ -132,7 +133,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *src, size_t size)
default:
FUZZ_ASSERT(0);
}
- if (!cmp_is_error(return_value) && model != up_model){
+ if (!cmp_is_error(return_value) && model != up_model) {
uint32_t return_value2;
return_value2 = compress_chunk(src, (uint32_t)size, model, up_model,
diff --git a/test/fuzz/fuzz_data_producer.c b/test/fuzz/fuzz_data_producer.c
index 1ee59944a44d2b2754d5ca343542c7493c47f1d1..f4e6990bde9b2780b0afa8ed28adffdf347520dd 100644
--- a/test/fuzz/fuzz_data_producer.c
+++ b/test/fuzz/fuzz_data_producer.c
@@ -25,88 +25,96 @@
#include "fuzz_data_producer.h"
#include <cmp_chunk.h>
-struct FUZZ_dataProducer_s{
- const uint8_t *data;
- size_t size;
+struct FUZZ_dataProducer_s {
+ const uint8_t *data;
+ size_t size;
};
-FUZZ_dataProducer_t *FUZZ_dataProducer_create(const uint8_t *data, size_t size) {
- FUZZ_dataProducer_t *producer = FUZZ_malloc(sizeof(FUZZ_dataProducer_t));
+FUZZ_dataProducer_t *FUZZ_dataProducer_create(const uint8_t *data, size_t size)
+{
+ FUZZ_dataProducer_t *producer = FUZZ_malloc(sizeof(FUZZ_dataProducer_t));
- producer->data = data;
- producer->size = size;
- return producer;
+ producer->data = data;
+ producer->size = size;
+ return producer;
}
-void FUZZ_dataProducer_free(FUZZ_dataProducer_t *producer) { free(producer); }
+void FUZZ_dataProducer_free(FUZZ_dataProducer_t *producer)
+{
+ free(producer);
+}
uint32_t FUZZ_dataProducer_uint32Range(FUZZ_dataProducer_t *producer, uint32_t min,
- uint32_t max) {
- uint32_t range = max - min;
- uint32_t rolling = range;
- uint32_t result = 0;
+ uint32_t max)
+{
+ uint32_t range = max - min;
+ uint32_t rolling = range;
+ uint32_t result = 0;
- FUZZ_ASSERT(min <= max);
+ FUZZ_ASSERT(min <= max);
- while (rolling > 0 && producer->size > 0) {
- uint8_t next = *(producer->data + producer->size - 1);
- producer->size -= 1;
- result = (result << 8) | next;
- rolling >>= 8;
- }
+ while (rolling > 0 && producer->size > 0) {
+ uint8_t next = *(producer->data + producer->size - 1);
- if (range == 0xffffffff) {
- return result;
- }
+ producer->size -= 1;
+ result = (result << 8) | next;
+ rolling >>= 8;
+ }
- return min + result % (range + 1);
+ if (range == 0xffffffff)
+ return result;
+
+ return min + result % (range + 1);
}
-uint32_t FUZZ_dataProducer_uint32(FUZZ_dataProducer_t *producer) {
- return FUZZ_dataProducer_uint32Range(producer, 0, 0xffffffff);
+uint32_t FUZZ_dataProducer_uint32(FUZZ_dataProducer_t *producer)
+{
+ return FUZZ_dataProducer_uint32Range(producer, 0, 0xffffffff);
}
int32_t FUZZ_dataProducer_int32Range(FUZZ_dataProducer_t *producer,
- int32_t min, int32_t max)
+ int32_t min, int32_t max)
{
- FUZZ_ASSERT(min <= max);
+ FUZZ_ASSERT(min <= max);
- if (min < 0)
- return (int)FUZZ_dataProducer_uint32Range(producer, 0, max - min) + min;
+ if (min < 0)
+ return (int)FUZZ_dataProducer_uint32Range(producer, 0, max - min) + min;
- return FUZZ_dataProducer_uint32Range(producer, min, max);
+ return FUZZ_dataProducer_uint32Range(producer, min, max);
}
-size_t FUZZ_dataProducer_remainingBytes(FUZZ_dataProducer_t *producer){
- return producer->size;
+size_t FUZZ_dataProducer_remainingBytes(FUZZ_dataProducer_t *producer)
+{
+ return producer->size;
}
void FUZZ_dataProducer_rollBack(FUZZ_dataProducer_t *producer, size_t remainingBytes)
{
- FUZZ_ASSERT(remainingBytes >= producer->size);
- producer->size = remainingBytes;
+ FUZZ_ASSERT(remainingBytes >= producer->size);
+ producer->size = remainingBytes;
}
-int FUZZ_dataProducer_empty(FUZZ_dataProducer_t *producer) {
- return producer->size == 0;
+int FUZZ_dataProducer_empty(FUZZ_dataProducer_t *producer)
+{
+ return producer->size == 0;
}
size_t FUZZ_dataProducer_contract(FUZZ_dataProducer_t *producer, size_t newSize)
{
- size_t remaining;
+ size_t remaining;
- newSize = newSize > producer->size ? producer->size : newSize;
- remaining = producer->size - newSize;
- producer->data = producer->data + remaining;
- producer->size = newSize;
- return remaining;
+ newSize = newSize > producer->size ? producer->size : newSize;
+ remaining = producer->size - newSize;
+ producer->data = producer->data + remaining;
+ producer->size = newSize;
+ return remaining;
}
size_t FUZZ_dataProducer_reserveDataPrefix(FUZZ_dataProducer_t *producer)
{
- size_t producerSliceSize = FUZZ_dataProducer_uint32Range(
- producer, 0, producer->size);
- return FUZZ_dataProducer_contract(producer, producerSliceSize);
+ size_t producerSliceSize = FUZZ_dataProducer_uint32Range(
+ producer, 0, producer->size);
+ return FUZZ_dataProducer_contract(producer, producerSliceSize);
}
void FUZZ_dataProducer_cmp_par(FUZZ_dataProducer_t *producer, struct cmp_par *cmp_par)
diff --git a/test/fuzz/fuzz_decompression.c b/test/fuzz/fuzz_decompression.c
index 85ec62e172cd60de227d091477735ad3edc6643b..220c65686a1bdc6b74781215768b83c6e4756efd 100644
--- a/test/fuzz/fuzz_decompression.c
+++ b/test/fuzz/fuzz_decompression.c
@@ -36,6 +36,7 @@ int decompress_cmp_entiy_save(const struct cmp_entity *ent, size_t ent_size, con
if (ent && (decompressed_data || up_model_buf)) {
int decmp_size_ent = decompress_cmp_entiy(ent, model_of_data, NULL, NULL);
+
if (decmp_size < (size_t)decmp_size_ent || decmp_size_ent < 0)
return -1;
}
@@ -55,6 +56,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *src, size_t size)
/* Give a random portion of src data to the producer, to use for
parameter generation. The rest will be used for data/model */
FUZZ_dataProducer_t *producer = (FUZZ_dataProducer_t *)FUZZ_dataProducer_create(src, size);
+
size = FUZZ_dataProducer_reserveDataPrefix(producer);
FUZZ_ASSERT(size <= UINT32_MAX);
@@ -64,11 +66,10 @@ int LLVMFuzzerTestOneInput(const uint8_t *src, size_t size)
if (ent_size)
ent = (const struct cmp_entity *)src;
- if (FUZZ_dataProducer_uint32Range(producer, 0, 1)) {
+ if (FUZZ_dataProducer_uint32Range(producer, 0, 1))
model_of_data = src + ent_size;
- } else {
+ else
model_of_data = NULL;
- }
switch (FUZZ_dataProducer_int32Range(producer, 0, 2)) {
diff --git a/test/fuzz/fuzz_helpers.c b/test/fuzz/fuzz_helpers.c
index fab2f0bcce7f0e00c040deeafb6f8f5f7501dafb..160b153e6f4ac69db6cf5411e567bb09c1bb91e1 100644
--- a/test/fuzz/fuzz_helpers.c
+++ b/test/fuzz/fuzz_helpers.c
@@ -17,12 +17,13 @@
#include "fuzz_helpers.h"
-void* FUZZ_malloc(size_t size)
+void *FUZZ_malloc(size_t size)
{
- if (size > 0) {
- void* const mem = malloc(size);
- FUZZ_ASSERT(mem);
- return mem;
- }
- return NULL;
+ if (size > 0) {
+ void *const mem = malloc(size);
+
+ FUZZ_ASSERT(mem);
+ return mem;
+ }
+ return NULL;
}
diff --git a/test/fuzz/fuzz_round_trip.c b/test/fuzz/fuzz_round_trip.c
index 88079bbc1f2628a9819726bf3c7bd509de36ebdd..0ffca732d2e89e50787184c0042105c040f10ebc 100644
--- a/test/fuzz/fuzz_round_trip.c
+++ b/test/fuzz/fuzz_round_trip.c
@@ -45,6 +45,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *src, size_t size)
/* Give a random portion of src data to the producer, to use for
parameter generation. The rest will be used for (de)compression */
FUZZ_dataProducer_t *producer = (FUZZ_dataProducer_t *)FUZZ_dataProducer_create(src, size);
+
size = FUZZ_dataProducer_reserveDataPrefix(producer);
/* 1/2 of the cases we use a model */
@@ -76,8 +77,8 @@ int LLVMFuzzerTestOneInput(const uint8_t *src, size_t size)
use_decmp_up_model = FUZZ_dataProducer_int32Range(producer, 0, 1);
return_value = chunk_round_trip(src, (uint32_t)size, model, up_model, cmp_data,
- cmp_data_capacity, cmp_par_ptr,
- use_decmp_buf, use_decmp_up_model);
+ cmp_data_capacity, cmp_par_ptr,
+ use_decmp_buf, use_decmp_up_model);
switch (cmp_get_error_code(return_value)) {
case CMP_ERROR_NO_ERROR:
case CMP_ERROR_GENERIC:
diff --git a/test/test_common/chunk_round_trip.c b/test/test_common/chunk_round_trip.c
index fa538f9297a5358f49dc46dac735ec9e193b50f0..bc6f9b9a5a364bdb635f8680fee341a9843df40b 100644
--- a/test/test_common/chunk_round_trip.c
+++ b/test/test_common/chunk_round_trip.c
@@ -41,14 +41,15 @@
* @returns a pointer to the allocated memory, or NULL if allocation fails
*/
-static void* TEST_malloc(size_t size)
+static void *TEST_malloc(size_t size)
{
- if (size > 0) {
- void* const mem = malloc(size);
- TEST_ASSERT(mem);
- return mem;
- }
- return NULL;
+ if (size > 0) {
+ void *mem = malloc(size);
+
+ TEST_ASSERT(mem);
+ return mem;
+ }
+ return NULL;
}
@@ -113,16 +114,16 @@ uint32_t chunk_round_trip(const void *chunk, uint32_t chunk_size,
if (!cmp_is_error(cmp_size)) { /* secound run wich dst = NULL */
uint32_t cmp_size2;
/* reset model if in-place update was used */
- if (chunk_model && updated_chunk_model == chunk_model) {
+ if (chunk_model && updated_chunk_model == chunk_model)
memcpy(updated_chunk_model, model_cpy, chunk_size);
- }
+
cmp_size2 = compress_chunk(chunk, chunk_size, chunk_model, updated_chunk_model,
NULL, dst_capacity, cmp_par);
- if (cmp_get_error_code(cmp_size) == CMP_ERROR_SMALL_BUFFER) {
+ if (cmp_get_error_code(cmp_size) == CMP_ERROR_SMALL_BUFFER)
TEST_ASSERT(!cmp_is_error(cmp_size));
- } else {
+ else
TEST_ASSERT(cmp_size == cmp_size2);
- }
+
}