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

Increase the reserved max_used_bits version

Introduction of the CMP_MAX_USED_BITS_RESERVED_VERSIONS constant
parent 80a5d8f2
No related branches found
No related tags found
1 merge request!26Adapt cmp_tool to the chunk decompression
...@@ -22,6 +22,10 @@ ...@@ -22,6 +22,10 @@
#include <stdint.h> #include <stdint.h>
/* Up to this number (not included), the maximum used bits registry versions cannot be used by the user. */
#define CMP_MAX_USED_BITS_RESERVED_VERSIONS 32
/* predefined maximum used bits registry constants */ /* predefined maximum used bits registry constants */
extern const struct cmp_max_used_bits MAX_USED_BITS_SAFE; extern const struct cmp_max_used_bits MAX_USED_BITS_SAFE;
extern const struct cmp_max_used_bits MAX_USED_BITS_V1; extern const struct cmp_max_used_bits MAX_USED_BITS_V1;
......
...@@ -79,9 +79,10 @@ int cmp_max_used_bits_list_add(struct cmp_max_used_bits const *item) ...@@ -79,9 +79,10 @@ int cmp_max_used_bits_list_add(struct cmp_max_used_bits const *item)
if (!item) if (!item)
return -1; return -1;
if (item->version <= 16) if (item->version < CMP_MAX_USED_BITS_RESERVED_VERSIONS)
return -1; return -1;
/* check for an existing entry */
list_for_each_entry(item_ptr, &max_used_bits_list, list) { list_for_each_entry(item_ptr, &max_used_bits_list, list) {
if (item_ptr->data.version == item->version) { if (item_ptr->data.version == item->version) {
item_ptr->data = *item; /* replace existing list entry */ item_ptr->data = *item; /* replace existing list entry */
......
...@@ -1420,7 +1420,7 @@ void test_cmp_ent_write_cmp_pars(void) ...@@ -1420,7 +1420,7 @@ void test_cmp_ent_write_cmp_pars(void)
cfg.cmp_par_mean = 7; cfg.cmp_par_mean = 7;
cfg.cmp_par_variance = 8; cfg.cmp_par_variance = 8;
cfg.cmp_par_pixels_error = 9; cfg.cmp_par_pixels_error = 9;
cfg.max_used_bits = NULL; /* test without max_used_bits registry */ cfg.max_used_bits = cmp_max_used_bits_list_get(42);
/* create a compression entity */ /* create a compression entity */
size = cmp_ent_create(NULL, cfg.data_type, cfg.cmp_mode == CMP_MODE_RAW, 12); size = cmp_ent_create(NULL, cfg.data_type, cfg.cmp_mode == CMP_MODE_RAW, 12);
...@@ -1439,7 +1439,7 @@ void test_cmp_ent_write_cmp_pars(void) ...@@ -1439,7 +1439,7 @@ void test_cmp_ent_write_cmp_pars(void)
TEST_ASSERT_EQUAL_INT(cmp_cal_size_of_data(cfg.samples, cfg.data_type), cmp_ent_get_original_size(ent)); TEST_ASSERT_EQUAL_INT(cmp_cal_size_of_data(cfg.samples, cfg.data_type), cmp_ent_get_original_size(ent));
TEST_ASSERT_EQUAL_INT(cfg.cmp_mode, cmp_ent_get_cmp_mode(ent)); TEST_ASSERT_EQUAL_INT(cfg.cmp_mode, cmp_ent_get_cmp_mode(ent));
TEST_ASSERT_EQUAL_INT(cfg.model_value, cmp_ent_get_model_value(ent)); TEST_ASSERT_EQUAL_INT(cfg.model_value, cmp_ent_get_model_value(ent));
TEST_ASSERT_EQUAL_INT(0, cmp_ent_get_max_used_bits_version(ent)); TEST_ASSERT_EQUAL_INT(max_used_bits.version, cmp_ent_get_max_used_bits_version(ent));
TEST_ASSERT_EQUAL_INT(cfg.round, cmp_ent_get_lossy_cmp_par(ent)); TEST_ASSERT_EQUAL_INT(cfg.round, cmp_ent_get_lossy_cmp_par(ent));
...@@ -1460,7 +1460,6 @@ void test_cmp_ent_write_cmp_pars(void) ...@@ -1460,7 +1460,6 @@ void test_cmp_ent_write_cmp_pars(void)
TEST_ASSERT_FALSE(error); TEST_ASSERT_FALSE(error);
cfg.icu_output_buf = cmp_ent_get_data_buf(ent); /* quick fix that both cfg are equal */ cfg.icu_output_buf = cmp_ent_get_data_buf(ent); /* quick fix that both cfg are equal */
cfg.buffer_length = 12; /* quick fix that both cfg are equal */ cfg.buffer_length = 12; /* quick fix that both cfg are equal */
cfg.max_used_bits = &MAX_USED_BITS_SAFE; /* quick fix that both cfg are equal */
TEST_ASSERT_EQUAL_MEMORY(&cfg, &cfg_read, sizeof(struct cmp_cfg)); TEST_ASSERT_EQUAL_MEMORY(&cfg, &cfg_read, sizeof(struct cmp_cfg));
free(ent); free(ent);
......
...@@ -18,12 +18,12 @@ ...@@ -18,12 +18,12 @@
#include <string.h> #include <string.h>
#include <dlfcn.h>
#include <unity.h> #include <unity.h>
#include <cmp_max_used_bits_list.h> #include <cmp_max_used_bits_list.h>
#ifndef __sparc__
/* if set the mock malloc will fail (return NULL) */ /* if set the mock malloc will fail (return NULL) */
static int malloc_fail; static int malloc_fail;
...@@ -32,6 +32,7 @@ static int malloc_fail; ...@@ -32,6 +32,7 @@ static int malloc_fail;
* mock of the malloc function; can controlled with the global malloc_fail variable * mock of the malloc function; can controlled with the global malloc_fail variable
* see:https://jayconrod.com/posts/23/tutorial--function-interposition-in-linux * see:https://jayconrod.com/posts/23/tutorial--function-interposition-in-linux
*/ */
#include <dlfcn.h>
void* malloc(size_t size) void* malloc(size_t size)
{ {
...@@ -49,6 +50,7 @@ void* malloc(size_t size) ...@@ -49,6 +50,7 @@ void* malloc(size_t size)
fprintf(stderr, "malloc(%zu)\n", size); fprintf(stderr, "malloc(%zu)\n", size);
return real_malloc(size); return real_malloc(size);
} }
#endif
/** /**
...@@ -60,31 +62,31 @@ void* malloc(size_t size) ...@@ -60,31 +62,31 @@ void* malloc(size_t size)
void test_cmp_max_used_bits_list(void) void test_cmp_max_used_bits_list(void)
{ {
struct cmp_max_used_bits i_17, i_21, i_22, i_23, i_255, i_0; struct cmp_max_used_bits i_32, i_34, i_35, i_36, i_255, i_0;
struct cmp_max_used_bits *p; struct cmp_max_used_bits *p;
int return_val; int return_val;
/* set up max_used_bits item */ /* set up max_used_bits item */
memset(&i_17, 17, sizeof(struct cmp_max_used_bits)); memset(&i_32, 32, sizeof(struct cmp_max_used_bits));
i_17.version = 17; i_32.version = 32;
memset(&i_21, 21, sizeof(struct cmp_max_used_bits)); memset(&i_34, 34, sizeof(struct cmp_max_used_bits));
i_21.version = 21; i_34.version = 34;
memset(&i_22, 22, sizeof(struct cmp_max_used_bits)); memset(&i_35, 35, sizeof(struct cmp_max_used_bits));
i_22.version = 22; i_35.version = 35;
memset(&i_23, 23, sizeof(struct cmp_max_used_bits)); memset(&i_36, 36, sizeof(struct cmp_max_used_bits));
i_23.version = 23; i_36.version = 36;
memset(&i_255, 0xFF, sizeof(struct cmp_max_used_bits)); memset(&i_255, 0xFF, sizeof(struct cmp_max_used_bits));
i_255.version = 255; i_255.version = 255;
memset(&i_0, 0, sizeof(struct cmp_max_used_bits)); memset(&i_0, 0, sizeof(struct cmp_max_used_bits));
i_0.version = 0; i_0.version = 0;
return_val = cmp_max_used_bits_list_add(&i_17); return_val = cmp_max_used_bits_list_add(&i_32);
TEST_ASSERT_EQUAL_INT(return_val, 0); TEST_ASSERT_EQUAL_INT(return_val, 0);
return_val = cmp_max_used_bits_list_add(&i_21); return_val = cmp_max_used_bits_list_add(&i_34);
TEST_ASSERT_EQUAL_INT(return_val, 0); TEST_ASSERT_EQUAL_INT(return_val, 0);
return_val = cmp_max_used_bits_list_add(&i_22); return_val = cmp_max_used_bits_list_add(&i_35);
TEST_ASSERT_EQUAL_INT(return_val, 0); TEST_ASSERT_EQUAL_INT(return_val, 0);
return_val = cmp_max_used_bits_list_add(&i_23); return_val = cmp_max_used_bits_list_add(&i_36);
TEST_ASSERT_EQUAL_INT(return_val, 0); TEST_ASSERT_EQUAL_INT(return_val, 0);
return_val = cmp_max_used_bits_list_add(&i_255); return_val = cmp_max_used_bits_list_add(&i_255);
TEST_ASSERT_EQUAL_INT(return_val, 0); TEST_ASSERT_EQUAL_INT(return_val, 0);
...@@ -94,29 +96,29 @@ void test_cmp_max_used_bits_list(void) ...@@ -94,29 +96,29 @@ void test_cmp_max_used_bits_list(void)
TEST_ASSERT_EQUAL_INT(return_val, -1); TEST_ASSERT_EQUAL_INT(return_val, -1);
return_val = cmp_max_used_bits_list_add(&i_0); return_val = cmp_max_used_bits_list_add(&i_0);
TEST_ASSERT_EQUAL_INT(return_val, -1); TEST_ASSERT_EQUAL_INT(return_val, -1);
i_0.version = 16; i_0.version = CMP_MAX_USED_BITS_RESERVED_VERSIONS-1;
return_val = cmp_max_used_bits_list_add(&i_0); return_val = cmp_max_used_bits_list_add(&i_0);
TEST_ASSERT_EQUAL_INT(return_val, -1); TEST_ASSERT_EQUAL_INT(return_val, -1);
p = cmp_max_used_bits_list_get(17); p = cmp_max_used_bits_list_get(32);
TEST_ASSERT_EQUAL_INT(p->version, 17); TEST_ASSERT_EQUAL_INT(p->version, 32);
TEST_ASSERT(!memcmp(p, &i_17, sizeof(struct cmp_max_used_bits))); TEST_ASSERT(!memcmp(p, &i_32, sizeof(struct cmp_max_used_bits)));
p = cmp_max_used_bits_list_get(23); p = cmp_max_used_bits_list_get(36);
TEST_ASSERT_EQUAL_INT(p->version, 23); TEST_ASSERT_EQUAL_INT(p->version, 36);
TEST_ASSERT(!memcmp(p, &i_23, sizeof(struct cmp_max_used_bits))); TEST_ASSERT(!memcmp(p, &i_36, sizeof(struct cmp_max_used_bits)));
p = cmp_max_used_bits_list_get(22); p = cmp_max_used_bits_list_get(35);
TEST_ASSERT_EQUAL_INT(p->version, 22); TEST_ASSERT_EQUAL_INT(p->version, 35);
TEST_ASSERT(!memcmp(p, &i_22, sizeof(struct cmp_max_used_bits))); TEST_ASSERT(!memcmp(p, &i_35, sizeof(struct cmp_max_used_bits)));
p = cmp_max_used_bits_list_get(255); p = cmp_max_used_bits_list_get(255);
TEST_ASSERT_EQUAL_INT(p->version, 255); TEST_ASSERT_EQUAL_INT(p->version, 255);
TEST_ASSERT(!memcmp(p, &i_255, sizeof(struct cmp_max_used_bits))); TEST_ASSERT(!memcmp(p, &i_255, sizeof(struct cmp_max_used_bits)));
p = cmp_max_used_bits_list_get(21); p = cmp_max_used_bits_list_get(34);
TEST_ASSERT_EQUAL_INT(p->version, 21); TEST_ASSERT_EQUAL_INT(p->version, 34);
TEST_ASSERT(!memcmp(p, &i_21, sizeof(struct cmp_max_used_bits))); TEST_ASSERT(!memcmp(p, &i_34, sizeof(struct cmp_max_used_bits)));
p = cmp_max_used_bits_list_get(0); p = cmp_max_used_bits_list_get(0);
TEST_ASSERT_EQUAL_INT(p->version, 0); TEST_ASSERT_EQUAL_INT(p->version, 0);
...@@ -135,30 +137,30 @@ void test_cmp_max_used_bits_list(void) ...@@ -135,30 +137,30 @@ void test_cmp_max_used_bits_list(void)
/* overwrite a list item */ /* overwrite a list item */
memset(&i_22, 0x42, sizeof(struct cmp_max_used_bits)); memset(&i_35, 0x42, sizeof(struct cmp_max_used_bits));
i_22.version = 22; i_35.version = 35;
return_val = cmp_max_used_bits_list_add(&i_22); return_val = cmp_max_used_bits_list_add(&i_35);
TEST_ASSERT_EQUAL_INT(return_val, 1); TEST_ASSERT_EQUAL_INT(return_val, 1);
p = cmp_max_used_bits_list_get(22); p = cmp_max_used_bits_list_get(35);
TEST_ASSERT_EQUAL_INT(p->version, 22); TEST_ASSERT_EQUAL_INT(p->version, 35);
TEST_ASSERT(!memcmp(p, &i_22, sizeof(struct cmp_max_used_bits))); TEST_ASSERT(!memcmp(p, &i_35, sizeof(struct cmp_max_used_bits)));
/* delete item */ /* delete item */
cmp_max_used_bits_list_delet(22); cmp_max_used_bits_list_delet(35);
p = cmp_max_used_bits_list_get(22); p = cmp_max_used_bits_list_get(35);
TEST_ASSERT_NULL(p); TEST_ASSERT_NULL(p);
cmp_max_used_bits_list_delet(21); cmp_max_used_bits_list_delet(34);
p = cmp_max_used_bits_list_get(21); p = cmp_max_used_bits_list_get(34);
TEST_ASSERT_NULL(p); TEST_ASSERT_NULL(p);
/* empty item */ /* empty item */
cmp_max_used_bits_list_empty(); cmp_max_used_bits_list_empty();
p = cmp_max_used_bits_list_get(23); p = cmp_max_used_bits_list_get(36);
TEST_ASSERT_NULL(p); TEST_ASSERT_NULL(p);
cmp_max_used_bits_list_empty(); cmp_max_used_bits_list_empty();
p = cmp_max_used_bits_list_get(21); p = cmp_max_used_bits_list_get(34);
TEST_ASSERT_NULL(p); TEST_ASSERT_NULL(p);
p = cmp_max_used_bits_list_get(0); p = cmp_max_used_bits_list_get(0);
...@@ -169,18 +171,20 @@ void test_cmp_max_used_bits_list(void) ...@@ -169,18 +171,20 @@ void test_cmp_max_used_bits_list(void)
TEST_ASSERT_EQUAL_INT(p->version, 1); TEST_ASSERT_EQUAL_INT(p->version, 1);
TEST_ASSERT(!memcmp(p, &MAX_USED_BITS_V1, sizeof(struct cmp_max_used_bits))); TEST_ASSERT(!memcmp(p, &MAX_USED_BITS_V1, sizeof(struct cmp_max_used_bits)));
return_val = cmp_max_used_bits_list_add(&i_23); return_val = cmp_max_used_bits_list_add(&i_36);
TEST_ASSERT_EQUAL_INT(return_val, 0); TEST_ASSERT_EQUAL_INT(return_val, 0);
p = cmp_max_used_bits_list_get(23); p = cmp_max_used_bits_list_get(36);
TEST_ASSERT_EQUAL_INT(p->version, 23); TEST_ASSERT_EQUAL_INT(p->version, 36);
TEST_ASSERT(!memcmp(p, &i_23, sizeof(struct cmp_max_used_bits))); TEST_ASSERT(!memcmp(p, &i_36, sizeof(struct cmp_max_used_bits)));
cmp_max_used_bits_list_empty(); cmp_max_used_bits_list_empty();
/* error case */ /* error case */
#ifndef __sparc__
malloc_fail = 1; malloc_fail = 1;
return_val = cmp_max_used_bits_list_add(&i_23); return_val = cmp_max_used_bits_list_add(&i_36);
TEST_ASSERT_EQUAL_INT(return_val, -1); TEST_ASSERT_EQUAL_INT(return_val, -1);
malloc_fail = 0; malloc_fail = 0;
#endif
} }
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment