Skip to content
GitLab
Explore
Sign in
Primary navigation
Search or go to…
Project
C
cmp_tool
Manage
Activity
Members
Labels
Plan
Issues
Issue boards
Milestones
Wiki
Code
Merge requests
Repository
Branches
Commits
Tags
Repository graph
Compare revisions
Snippets
Deploy
Releases
Package registry
Model registry
Operate
Terraform modules
Monitor
Incidents
Service Desk
Analyze
Value stream analytics
Contributor analytics
Repository analytics
Model experiments
Help
Help
Support
GitLab documentation
Compare GitLab plans
GitLab community forum
Contribute to GitLab
Provide feedback
Terms and privacy
Keyboard shortcuts
?
Snippets
Groups
Projects
Show more breadcrumbs
Dominik Loidolt
cmp_tool
Commits
fc7ff4a8
Commit
fc7ff4a8
authored
10 months ago
by
Dominik Loidolt
Browse files
Options
Downloads
Patches
Plain Diff
Adding test cases to improve the code coverage of the compression code
parent
1de9c880
No related branches found
No related tags found
1 merge request
!34
Update cmp_tool to version v0.13
Changes
1
Show whitespace changes
Inline
Side-by-side
Showing
1 changed file
test/cmp_icu/test_cmp_icu.c
+187
-256
187 additions, 256 deletions
test/cmp_icu/test_cmp_icu.c
with
187 additions
and
256 deletions
test/cmp_icu/test_cmp_icu.c
+
187
−
256
View file @
fc7ff4a8
...
@@ -515,7 +515,7 @@ void test_put_n_bits32(void)
...
@@ -515,7 +515,7 @@ void test_put_n_bits32(void)
/* re-init input arrays after clobbering */
/* re-init input arrays after clobbering */
init_PB32_arrays
(
testarray0
,
testarray1
);
init_PB32_arrays
(
testarray0
,
testarray1
);
/*
**
error cases
**
*/
/* error cases */
/* n too large */
/* n too large */
v
=
0x0
;
n
=
33
;
o
=
1
;
v
=
0x0
;
n
=
33
;
o
=
1
;
rval
=
put_n_bits32
(
v
,
n
,
o
,
testarray0
,
l
);
rval
=
put_n_bits32
(
v
,
n
,
o
,
testarray0
,
l
);
...
@@ -1004,17 +1004,41 @@ void test_encode_value_multi(void)
...
@@ -1004,17 +1004,41 @@ void test_encode_value_multi(void)
TEST_ASSERT_EQUAL_HEX
(
0
,
bitstream
[
1
]);
TEST_ASSERT_EQUAL_HEX
(
0
,
bitstream
[
1
]);
}
}
#if 0
/**
* @brief put the value unencoded with setup->cmp_par_1 bits without any changes
* in the bitstream
*
* @param value value to put unchanged in the bitstream
* (setup->cmp_par_1 how many bits of the value are used)
* @param unused this parameter is ignored
* @param stream_len length of the bitstream in bits
* @param setup pointer to the encoder setup
*
* @returns the bit length of the bitstream with the added unencoded value on
* success; negative on error
*/
static
uint32_t
encode_value_none
(
uint32_t
value
,
uint32_t
unused
,
uint32_t
stream_len
,
const
struct
encoder_setup
*
setup
)
{
(
void
)(
unused
);
return
put_n_bits32
(
value
,
setup
->
encoder_par1
,
stream_len
,
setup
->
bitstream_adr
,
setup
->
max_stream_len
);
}
/**
/**
* @test encode_value
* @test encode_value
*/
*/
void
no_
test_encode_value(void)
void
test_encode_value
(
void
)
{
{
struct
encoder_setup
setup
=
{
0
};
struct
encoder_setup
setup
=
{
0
};
uint32_t
bitstream
[
4
]
=
{
0
};
uint32_t
bitstream
[
4
]
=
{
0
};
uint32_t
data
,
model
;
uint32_t
data
,
model
;
int cmp_size;
u
int
32_t
cmp_size
;
setup
.
encode_method_f
=
encode_value_none
;
setup
.
encode_method_f
=
encode_value_none
;
setup
.
bitstream_adr
=
bitstream
;
setup
.
bitstream_adr
=
bitstream
;
...
@@ -1028,7 +1052,7 @@ void no_test_encode_value(void)
...
@@ -1028,7 +1052,7 @@ void no_test_encode_value(void)
data
=
0
;
model
=
0
;
data
=
0
;
model
=
0
;
cmp_size
=
encode_value
(
data
,
model
,
cmp_size
,
&
setup
);
cmp_size
=
encode_value
(
data
,
model
,
cmp_size
,
&
setup
);
TEST_ASSERT_EQUAL_INT(32, cmp_size);
TEST_ASSERT_EQUAL_
U
INT
(
32
,
cmp_size
);
TEST_ASSERT_EQUAL_HEX
(
0
,
bitstream
[
0
]);
TEST_ASSERT_EQUAL_HEX
(
0
,
bitstream
[
0
]);
TEST_ASSERT_EQUAL_HEX
(
0
,
bitstream
[
1
]);
TEST_ASSERT_EQUAL_HEX
(
0
,
bitstream
[
1
]);
TEST_ASSERT_EQUAL_HEX
(
0
,
bitstream
[
2
]);
TEST_ASSERT_EQUAL_HEX
(
0
,
bitstream
[
2
]);
...
@@ -1036,7 +1060,7 @@ void no_test_encode_value(void)
...
@@ -1036,7 +1060,7 @@ void no_test_encode_value(void)
data
=
UINT32_MAX
;
model
=
0
;
data
=
UINT32_MAX
;
model
=
0
;
cmp_size
=
encode_value
(
data
,
model
,
cmp_size
,
&
setup
);
cmp_size
=
encode_value
(
data
,
model
,
cmp_size
,
&
setup
);
TEST_ASSERT_EQUAL_INT(64, cmp_size);
TEST_ASSERT_EQUAL_
U
INT
(
64
,
cmp_size
);
TEST_ASSERT_EQUAL_HEX
(
0
,
bitstream
[
0
]);
TEST_ASSERT_EQUAL_HEX
(
0
,
bitstream
[
0
]);
TEST_ASSERT_EQUAL_HEX
(
0xFFFFFFFF
,
bitstream
[
1
]);
TEST_ASSERT_EQUAL_HEX
(
0xFFFFFFFF
,
bitstream
[
1
]);
TEST_ASSERT_EQUAL_HEX
(
0
,
bitstream
[
2
]);
TEST_ASSERT_EQUAL_HEX
(
0
,
bitstream
[
2
]);
...
@@ -1046,7 +1070,7 @@ void no_test_encode_value(void)
...
@@ -1046,7 +1070,7 @@ void no_test_encode_value(void)
setup
.
lossy_par
=
1
;
setup
.
lossy_par
=
1
;
data
=
UINT32_MAX
;
model
=
0
;
data
=
UINT32_MAX
;
model
=
0
;
cmp_size
=
encode_value
(
data
,
model
,
cmp_size
,
&
setup
);
cmp_size
=
encode_value
(
data
,
model
,
cmp_size
,
&
setup
);
TEST_ASSERT_EQUAL_INT(96, cmp_size);
TEST_ASSERT_EQUAL_
U
INT
(
96
,
cmp_size
);
TEST_ASSERT_EQUAL_HEX
(
0
,
bitstream
[
0
]);
TEST_ASSERT_EQUAL_HEX
(
0
,
bitstream
[
0
]);
TEST_ASSERT_EQUAL_HEX
(
0xFFFFFFFF
,
be32_to_cpu
(
bitstream
[
1
]));
TEST_ASSERT_EQUAL_HEX
(
0xFFFFFFFF
,
be32_to_cpu
(
bitstream
[
1
]));
TEST_ASSERT_EQUAL_HEX
(
0x7FFFFFFF
,
be32_to_cpu
(
bitstream
[
2
]));
TEST_ASSERT_EQUAL_HEX
(
0x7FFFFFFF
,
be32_to_cpu
(
bitstream
[
2
]));
...
@@ -1055,7 +1079,7 @@ void no_test_encode_value(void)
...
@@ -1055,7 +1079,7 @@ void no_test_encode_value(void)
setup
.
lossy_par
=
2
;
setup
.
lossy_par
=
2
;
data
=
0x3
;
model
=
0
;
data
=
0x3
;
model
=
0
;
cmp_size
=
encode_value
(
data
,
model
,
cmp_size
,
&
setup
);
cmp_size
=
encode_value
(
data
,
model
,
cmp_size
,
&
setup
);
TEST_ASSERT_EQUAL_INT(128, cmp_size);
TEST_ASSERT_EQUAL_
U
INT
(
128
,
cmp_size
);
TEST_ASSERT_EQUAL_HEX
(
0
,
bitstream
[
0
]);
TEST_ASSERT_EQUAL_HEX
(
0
,
bitstream
[
0
]);
TEST_ASSERT_EQUAL_HEX
(
0xFFFFFFFF
,
bitstream
[
1
]);
TEST_ASSERT_EQUAL_HEX
(
0xFFFFFFFF
,
bitstream
[
1
]);
TEST_ASSERT_EQUAL_HEX
(
0x7FFFFFFF
,
be32_to_cpu
(
bitstream
[
2
]));
TEST_ASSERT_EQUAL_HEX
(
0x7FFFFFFF
,
be32_to_cpu
(
bitstream
[
2
]));
...
@@ -1063,7 +1087,7 @@ void no_test_encode_value(void)
...
@@ -1063,7 +1087,7 @@ void no_test_encode_value(void)
/* small buffer error bitstream can not hold more data*/
/* small buffer error bitstream can not hold more data*/
cmp_size
=
encode_value
(
data
,
model
,
cmp_size
,
&
setup
);
cmp_size
=
encode_value
(
data
,
model
,
cmp_size
,
&
setup
);
TEST_ASSERT_EQUAL_INT(CMP_ERROR_SMALL_BUF, cmp_size);
TEST_ASSERT_EQUAL_
U
INT
(
CMP_ERROR_SMALL_BUF
_
,
cmp_get_error_code
(
cmp_size
)
)
;
/* reset bitstream */
/* reset bitstream */
bitstream
[
0
]
=
0
;
bitstream
[
0
]
=
0
;
...
@@ -1079,7 +1103,7 @@ void no_test_encode_value(void)
...
@@ -1079,7 +1103,7 @@ void no_test_encode_value(void)
data
=
0
;
model
=
0
;
data
=
0
;
model
=
0
;
cmp_size
=
encode_value
(
data
,
model
,
cmp_size
,
&
setup
);
cmp_size
=
encode_value
(
data
,
model
,
cmp_size
,
&
setup
);
TEST_ASSERT_EQUAL_INT(31, cmp_size);
TEST_ASSERT_EQUAL_
U
INT
(
31
,
cmp_size
);
TEST_ASSERT_EQUAL_HEX
(
0
,
bitstream
[
0
]);
TEST_ASSERT_EQUAL_HEX
(
0
,
bitstream
[
0
]);
TEST_ASSERT_EQUAL_HEX
(
0
,
bitstream
[
1
]);
TEST_ASSERT_EQUAL_HEX
(
0
,
bitstream
[
1
]);
TEST_ASSERT_EQUAL_HEX
(
0
,
bitstream
[
2
]);
TEST_ASSERT_EQUAL_HEX
(
0
,
bitstream
[
2
]);
...
@@ -1087,7 +1111,7 @@ void no_test_encode_value(void)
...
@@ -1087,7 +1111,7 @@ void no_test_encode_value(void)
data
=
0x7FFFFFFF
;
model
=
0
;
data
=
0x7FFFFFFF
;
model
=
0
;
cmp_size
=
encode_value
(
data
,
model
,
cmp_size
,
&
setup
);
cmp_size
=
encode_value
(
data
,
model
,
cmp_size
,
&
setup
);
TEST_ASSERT_EQUAL_INT(62, cmp_size);
TEST_ASSERT_EQUAL_
U
INT
(
62
,
cmp_size
);
TEST_ASSERT_EQUAL_HEX
(
0x00000001
,
be32_to_cpu
(
bitstream
[
0
]));
TEST_ASSERT_EQUAL_HEX
(
0x00000001
,
be32_to_cpu
(
bitstream
[
0
]));
TEST_ASSERT_EQUAL_HEX
(
0xFFFFFFFC
,
be32_to_cpu
(
bitstream
[
1
]));
TEST_ASSERT_EQUAL_HEX
(
0xFFFFFFFC
,
be32_to_cpu
(
bitstream
[
1
]));
TEST_ASSERT_EQUAL_HEX
(
0
,
bitstream
[
2
]);
TEST_ASSERT_EQUAL_HEX
(
0
,
bitstream
[
2
]);
...
@@ -1097,7 +1121,7 @@ void no_test_encode_value(void)
...
@@ -1097,7 +1121,7 @@ void no_test_encode_value(void)
setup
.
lossy_par
=
1
;
setup
.
lossy_par
=
1
;
data
=
UINT32_MAX
;
model
=
UINT32_MAX
;
data
=
UINT32_MAX
;
model
=
UINT32_MAX
;
cmp_size
=
encode_value
(
data
,
model
,
cmp_size
,
&
setup
);
cmp_size
=
encode_value
(
data
,
model
,
cmp_size
,
&
setup
);
TEST_ASSERT_EQUAL_INT(93, cmp_size);
TEST_ASSERT_EQUAL_
U
INT
(
93
,
cmp_size
);
TEST_ASSERT_EQUAL_HEX
(
0x00000001
,
be32_to_cpu
(
bitstream
[
0
]));
TEST_ASSERT_EQUAL_HEX
(
0x00000001
,
be32_to_cpu
(
bitstream
[
0
]));
TEST_ASSERT_EQUAL_HEX
(
0xFFFFFFFF
,
be32_to_cpu
(
bitstream
[
1
]));
TEST_ASSERT_EQUAL_HEX
(
0xFFFFFFFF
,
be32_to_cpu
(
bitstream
[
1
]));
TEST_ASSERT_EQUAL_HEX
(
0xFFFFFFF8
,
be32_to_cpu
(
bitstream
[
2
]));
TEST_ASSERT_EQUAL_HEX
(
0xFFFFFFF8
,
be32_to_cpu
(
bitstream
[
2
]));
...
@@ -1107,16 +1131,15 @@ void no_test_encode_value(void)
...
@@ -1107,16 +1131,15 @@ void no_test_encode_value(void)
setup
.
lossy_par
=
0
;
setup
.
lossy_par
=
0
;
data
=
UINT32_MAX
;
model
=
0
;
data
=
UINT32_MAX
;
model
=
0
;
cmp_size
=
encode_value
(
data
,
model
,
cmp_size
,
&
setup
);
cmp_size
=
encode_value
(
data
,
model
,
cmp_size
,
&
setup
);
TEST_ASSERT_EQUAL_INT(CMP_ERROR_
HIGH
_VALUE
,
cmp_size);
TEST_ASSERT_EQUAL_
U
INT
(
CMP_ERROR_
DATA
_VALUE
_TOO_LARGE
,
cmp_get_error_code
(
cmp_size
)
)
;
/* model are bigger than max_data_bits */
/* model are bigger than max_data_bits */
setup
.
lossy_par
=
0
;
setup
.
lossy_par
=
0
;
cmp_size
=
93
;
cmp_size
=
93
;
data
=
0
;
model
=
UINT32_MAX
;
data
=
0
;
model
=
UINT32_MAX
;
cmp_size
=
encode_value
(
data
,
model
,
cmp_size
,
&
setup
);
cmp_size
=
encode_value
(
data
,
model
,
cmp_size
,
&
setup
);
TEST_ASSERT_EQUAL_INT(CMP_ERROR_
HIGH
_VALUE
,
cmp_size);
TEST_ASSERT_EQUAL_
U
INT
(
CMP_ERROR_
DATA
_VALUE
_TOO_LARGE
,
cmp_get_error_code
(
cmp_size
)
)
;
}
}
#endif
/**
/**
...
@@ -1429,90 +1452,6 @@ void test_compress_imagette_error_cases(void)
...
@@ -1429,90 +1452,6 @@ void test_compress_imagette_error_cases(void)
TEST_ASSERT_EQUAL_INT
(
CMP_ERROR_PAR_SPECIFIC
,
cmp_get_error_code
((
uint32_t
)
cmp_size
));
TEST_ASSERT_EQUAL_INT
(
CMP_ERROR_PAR_SPECIFIC
,
cmp_get_error_code
((
uint32_t
)
cmp_size
));
}
}
#if 0
/**
* @test compress_multi_entry_hdr
*/
void no_test_compress_multi_entry_hdr(void)
{
int stream_len;
uint8_t data[COLLECTION_HDR_SIZE];
uint8_t model[COLLECTION_HDR_SIZE];
uint8_t up_model[COLLECTION_HDR_SIZE];
uint8_t cmp_data[COLLECTION_HDR_SIZE];
uint8_t *data_p = NULL;
uint8_t *model_p = NULL;
uint8_t *up_model_p = NULL;
memset(data, 0x42, sizeof(data));
/* no data; no cmp_data no model test */
/* no data; no model; no up_model; no cmp_data */
stream_len = compress_multi_entry_hdr((void **)&data_p, (void **)&model_p,
(void **)&up_model_p, NULL);
TEST_ASSERT_EQUAL_INT(96, stream_len);
/* no model; no up_model */
data_p = data;
stream_len = compress_multi_entry_hdr((void **)&data_p, (void **)&model_p,
(void **)&up_model_p, cmp_data);
TEST_ASSERT_EQUAL_INT(96, stream_len);
TEST_ASSERT_FALSE(memcmp(cmp_data, data, COLLECTION_HDR_SIZE));
TEST_ASSERT_EQUAL(data_p-data, COLLECTION_HDR_SIZE);
/* no up_model */
memset(cmp_data, 0, sizeof(cmp_data));
data_p = data;
model_p = model;
up_model_p = NULL;
stream_len = compress_multi_entry_hdr((void **)&data_p, (void **)&model_p,
(void **)&up_model_p, cmp_data);
TEST_ASSERT_EQUAL_INT(96, stream_len);
TEST_ASSERT_FALSE(memcmp(cmp_data, data, COLLECTION_HDR_SIZE));
TEST_ASSERT_EQUAL(data_p-data, COLLECTION_HDR_SIZE);
TEST_ASSERT_EQUAL(model_p-model, COLLECTION_HDR_SIZE);
/* all buffer test */
memset(cmp_data, 0, sizeof(cmp_data));
data_p = data;
model_p = model;
up_model_p = up_model;
stream_len = compress_multi_entry_hdr((void **)&data_p, (void **)&model_p,
(void **)&up_model_p, cmp_data);
TEST_ASSERT_EQUAL_INT(96, stream_len);
TEST_ASSERT_FALSE(memcmp(cmp_data, data, COLLECTION_HDR_SIZE));
TEST_ASSERT_FALSE(memcmp(up_model, data, COLLECTION_HDR_SIZE));
TEST_ASSERT_EQUAL(data_p-data, COLLECTION_HDR_SIZE);
TEST_ASSERT_EQUAL(model_p-model, COLLECTION_HDR_SIZE);
TEST_ASSERT_EQUAL(up_model_p-up_model, COLLECTION_HDR_SIZE);
/* all buffer test; no cmp_data */
memset(cmp_data, 0, sizeof(cmp_data));
data_p = data;
model_p = model;
up_model_p = up_model;
stream_len = compress_multi_entry_hdr((void **)&data_p, (void **)&model_p,
(void **)&up_model_p, NULL);
TEST_ASSERT_EQUAL_INT(96, stream_len);
TEST_ASSERT_FALSE(memcmp(up_model, data, COLLECTION_HDR_SIZE));
TEST_ASSERT_EQUAL(data_p-data, COLLECTION_HDR_SIZE);
TEST_ASSERT_EQUAL(model_p-model, COLLECTION_HDR_SIZE);
TEST_ASSERT_EQUAL(up_model_p-up_model, COLLECTION_HDR_SIZE);
/* no data, use up_model test */
memset(cmp_data, 0, sizeof(cmp_data));
data_p = NULL;
model_p = model;
up_model_p = up_model;
stream_len = compress_multi_entry_hdr((void **)&data_p, (void **)&model_p,
(void **)&up_model_p, NULL);
TEST_ASSERT_EQUAL_INT(96, stream_len);
TEST_ASSERT_EQUAL(model_p-model, COLLECTION_HDR_SIZE);
TEST_ASSERT_EQUAL(up_model_p-up_model, COLLECTION_HDR_SIZE);
}
#endif
/**
/**
* @test pad_bitstream
* @test pad_bitstream
...
@@ -1587,6 +1526,66 @@ void test_pad_bitstream(void)
...
@@ -1587,6 +1526,66 @@ void test_pad_bitstream(void)
}
}
/**
* @test compress_data_internal
*/
void
test_compress_data_internal_error_cases
(
void
)
{
struct
cmp_cfg
cfg
=
{
0
};
uint32_t
cmp_size
;
uint16_t
data
[
2
]
=
{
0
,
0
};
uint32_t
dst
[
3
]
=
{
0
};
cfg
.
data_type
=
DATA_TYPE_IMAGETTE
;
cfg
.
src
=
data
;
cfg
.
samples
=
2
;
cfg
.
dst
=
dst
;
cfg
.
stream_size
=
sizeof
(
dst
);
cmp_size
=
compress_data_internal
(
&
cfg
,
-
2U
);
TEST_ASSERT_EQUAL_INT
(
-
2U
,
cmp_size
);
cmp_size
=
compress_data_internal
(
&
cfg
,
7
);
TEST_ASSERT_EQUAL_INT
(
CMP_ERROR_GENERIC
,
cmp_get_error_code
(
cmp_size
));
cmp_size
=
compress_data_internal
(
&
cfg
,
7
);
TEST_ASSERT_EQUAL_INT
(
CMP_ERROR_GENERIC
,
cmp_get_error_code
(
cmp_size
));
cfg
.
data_type
=
DATA_TYPE_UNKNOWN
;
cmp_size
=
compress_data_internal
(
&
cfg
,
0
);
TEST_ASSERT_EQUAL_INT
(
CMP_ERROR_INT_DATA_TYPE_UNSUPPORTED
,
cmp_get_error_code
(
cmp_size
));
cfg
.
cmp_mode
=
CMP_MODE_DIFF_MULTI
;
cmp_size
=
compress_data_internal
(
&
cfg
,
0
);
TEST_ASSERT_EQUAL_INT
(
CMP_ERROR_INT_DATA_TYPE_UNSUPPORTED
,
cmp_get_error_code
(
cmp_size
));
cmp_size
=
compress_data_internal
(
&
cfg
,
0
);
TEST_ASSERT_EQUAL_INT
(
CMP_ERROR_INT_DATA_TYPE_UNSUPPORTED
,
cmp_get_error_code
(
cmp_size
));
cfg
.
data_type
=
DATA_TYPE_F_FX_EFX
;
cmp_size
=
compress_data_internal
(
&
cfg
,
0
);
TEST_ASSERT_EQUAL_INT
(
CMP_ERROR_INT_DATA_TYPE_UNSUPPORTED
,
cmp_get_error_code
(
cmp_size
));
cfg
.
data_type
=
DATA_TYPE_F_FX_NCOB
;
cmp_size
=
compress_data_internal
(
&
cfg
,
0
);
TEST_ASSERT_EQUAL_INT
(
CMP_ERROR_INT_DATA_TYPE_UNSUPPORTED
,
cmp_get_error_code
(
cmp_size
));
cfg
.
data_type
=
DATA_TYPE_F_FX_EFX_NCOB_ECOB
;
cmp_size
=
compress_data_internal
(
&
cfg
,
0
);
TEST_ASSERT_EQUAL_INT
(
CMP_ERROR_INT_DATA_TYPE_UNSUPPORTED
,
cmp_get_error_code
(
cmp_size
));
cfg
.
data_type
=
DATA_TYPE_F_FX_EFX_NCOB_ECOB
;
cmp_size
=
compress_data_internal
(
&
cfg
,
0
);
TEST_ASSERT_EQUAL_INT
(
CMP_ERROR_INT_DATA_TYPE_UNSUPPORTED
,
cmp_get_error_code
(
cmp_size
));
cfg
.
data_type
=
101
;
cmp_size
=
compress_data_internal
(
&
cfg
,
0
);
TEST_ASSERT_EQUAL_INT
(
CMP_ERROR_INT_DATA_TYPE_UNSUPPORTED
,
cmp_get_error_code
(
cmp_size
));
}
/**
/**
* @test compress_chunk
* @test compress_chunk
*/
*/
...
@@ -1657,6 +1656,10 @@ void test_compress_chunk_raw_singel_col(void)
...
@@ -1657,6 +1656,10 @@ void test_compress_chunk_raw_singel_col(void)
}
}
/**
* @test compress_chunk
*/
void
test_compress_chunk_raw_two_col
(
void
)
void
test_compress_chunk_raw_two_col
(
void
)
{
{
enum
{
DATA_SIZE_1
=
2
*
sizeof
(
struct
s_fx
),
enum
{
DATA_SIZE_1
=
2
*
sizeof
(
struct
s_fx
),
...
@@ -1773,137 +1776,75 @@ void test_compress_chunk_raw_two_col(void)
...
@@ -1773,137 +1776,75 @@ void test_compress_chunk_raw_two_col(void)
}
}
#if 0
/**
void NOOO_test_compress_chunk_model(void)
* @test compress_chunk
*/
void
test_compress_chunk_aux
(
void
)
{
{
enum { DATA_SIZE_1 =
1
*sizeof(struct
background
),
enum
{
DATA_SIZE_1
=
2
*
sizeof
(
struct
offset
),
DATA_SIZE_2 =
2
*sizeof(struct
offset
),
DATA_SIZE_2
=
3
*
sizeof
(
struct
background
),
CHUNK_SIZE
=
2
*
COLLECTION_HDR_SIZE
+
DATA_SIZE_1
+
DATA_SIZE_2
CHUNK_SIZE
=
2
*
COLLECTION_HDR_SIZE
+
DATA_SIZE_1
+
DATA_SIZE_2
};
};
uint8_t chunk[CHUNK_SIZE];
uint8_t
chunk
[
CHUNK_SIZE
+
100
];
uint8_t chunk_model[CHUNK_SIZE];
uint8_t chunk_up_model[CHUNK_SIZE];
struct
collection_hdr
*
col1
=
(
struct
collection_hdr
*
)
chunk
;
struct
collection_hdr
*
col1
=
(
struct
collection_hdr
*
)
chunk
;
struct
collection_hdr
*
col2
;
struct
collection_hdr
*
col2
;
struct
background
*data1 = (struct
background
*)col1->entry;
struct
offset
*
data1
=
(
struct
offset
*
)
col1
->
entry
;
struct
offset
*data2;
struct
background
*
data2
;
struct
cmp_par
cmp_par
=
{
0
};
struct
cmp_par
cmp_par
=
{
0
};
uint32_t
*
dst
;
uint32_t
*
dst
;
uint32_t
cmp_size
;
uint32_t
cmp_size
;
uint32_t
dst_capacity
=
0
;
uint32_t
dst_capacity
=
0
;
uint32_t chunk_size;
/* create a chunk with two collection */
/* create a chunk with two collection */
memset
(
col1
,
0
,
COLLECTION_HDR_SIZE
);
memset
(
col1
,
0
,
COLLECTION_HDR_SIZE
);
TEST_ASSERT_FALSE(cmp_col_set_subservice(col1, SST_NCxx_S_SCIENCE_
BACKGROUND
));
TEST_ASSERT_FALSE
(
cmp_col_set_subservice
(
col1
,
SST_NCxx_S_SCIENCE_
OFFSET
));
TEST_ASSERT_FALSE
(
cmp_col_set_data_length
(
col1
,
DATA_SIZE_1
));
TEST_ASSERT_FALSE
(
cmp_col_set_data_length
(
col1
,
DATA_SIZE_1
));
data1
[
0
].
mean
=
0
;
data1
[
0
].
mean
=
0
;
data1
[
0
].
variance
=
1
;
data1
[
0
].
variance
=
1
;
data1[0].outlier_pixels = 0xF0;
data1
[
1
].
mean
=
0xF0
;
data1
[
1
].
variance
=
0xABCDE0FF
;
col2
=
(
struct
collection_hdr
*
)(
chunk
+
COLLECTION_HDR_SIZE
+
DATA_SIZE_1
);
col2
=
(
struct
collection_hdr
*
)(
chunk
+
COLLECTION_HDR_SIZE
+
DATA_SIZE_1
);
memset
(
col2
,
0
,
COLLECTION_HDR_SIZE
);
memset
(
col2
,
0
,
COLLECTION_HDR_SIZE
);
TEST_ASSERT_FALSE(cmp_col_set_subservice(col2, SST_NCxx_S_SCIENCE_
OFFSET
));
TEST_ASSERT_FALSE
(
cmp_col_set_subservice
(
col2
,
SST_NCxx_S_SCIENCE_
BACKGROUND
));
TEST_ASSERT_FALSE
(
cmp_col_set_data_length
(
col2
,
DATA_SIZE_2
));
TEST_ASSERT_FALSE
(
cmp_col_set_data_length
(
col2
,
DATA_SIZE_2
));
data2 = (struct
offset
*)col2->entry;
data2
=
(
struct
background
*
)
col2
->
entry
;
data2
[
0
].
mean
=
1
;
data2
[
0
].
mean
=
1
;
data2
[
0
].
variance
=
2
;
data2
[
0
].
variance
=
2
;
data2[1].mean = 3;
data2
[
0
].
outlier_pixels
=
3
;
data2[1].variance = 4;
/* create a model with two collection */
col1 = (struct collection_hdr *)chunk_model;
memset(col1, 0, COLLECTION_HDR_SIZE);
TEST_ASSERT_FALSE(cmp_col_set_subservice(col1, SST_NCxx_S_SCIENCE_BACKGROUND));
TEST_ASSERT_FALSE(cmp_col_set_data_length(col1, DATA_SIZE_1));
data1[0].mean = 1;
data1[0].variance = 2;
data1[0].outlier_pixels = 0xFFFF;
col2 = (struct collection_hdr *)(chunk + COLLECTION_HDR_SIZE + DATA_SIZE_1);
memset(col2, 0, COLLECTION_HDR_SIZE);
TEST_ASSERT_FALSE(cmp_col_set_subservice(col2, SST_NCxx_S_SCIENCE_OFFSET));
TEST_ASSERT_FALSE(cmp_col_set_data_length(col2, DATA_SIZE_2));
data2 = (struct offset *)col2->entry;
data2[0].mean = 0;
data2[0].variance = 0;
data2
[
1
].
mean
=
0
;
data2
[
1
].
mean
=
0
;
data2[1].variance = 0xEFFFFFFF;
data2
[
1
].
variance
=
0
;
data2
[
1
].
outlier_pixels
=
0
;
data2
[
2
].
mean
=
0xF
;
data2
[
2
].
variance
=
0xFFFF
;
data2
[
2
].
outlier_pixels
=
0xFFFF
;
/* compress the data */
/* compress the data */
cmp_par.cmp_mode = CMP_MODE_MODEL_ZERO;
cmp_par
.
cmp_mode
=
CMP_MODE_DIFF_MULTI
;
cmp_par.model_value = 14;
cmp_par
.
nc_offset_mean
=
1
;
cmp_par
.
nc_offset_mean
=
1
;
cmp_par.nc_offset_variance = 2;
cmp_par
.
nc_offset_variance
=
UINT16_MAX
;
cmp_par.nc_background_mean = 3;
cmp_par.nc_background_variance = 4;
cmp_par.nc_background_outlier_pixels = 5;
dst = NULL;
chunk_size = COLLECTION_HDR_SIZE + DATA_SIZE_1;
cmp_par
.
nc_background_mean
=
UINT16_MAX
;
cmp_par
.
nc_background_variance
=
1
;
cmp_par
.
nc_background_outlier_pixels
=
42
;
dst
=
NULL
;
cmp_size = compress_chunk(chunk,
chunk_size, chunk_model, chunk_up_model
, dst,
cmp_size
=
compress_chunk
(
chunk
,
CHUNK_SIZE
,
NULL
,
NULL
,
dst
,
dst_capacity
,
&
cmp_par
);
dst_capacity
,
&
cmp_par
);
TEST_ASSERT_EQUAL_INT(
NON_IMAGETTE_HEADER_SIZE + COLLECTION_HDR_SIZE +
4, cmp_size);
TEST_ASSERT_EQUAL_INT
(
12
4
,
cmp_size
);
dst_capacity = cmp_size;
dst_capacity
=
ROUND_UP_TO_4
(
cmp_size
)
;
dst
=
malloc
(
dst_capacity
);
TEST_ASSERT_NOT_NULL
(
dst
);
dst
=
malloc
(
dst_capacity
);
TEST_ASSERT_NOT_NULL
(
dst
);
cmp_size
=
compress_chunk
(
chunk
,
CHUNK_SIZE
,
NULL
,
NULL
,
dst
,
cmp_size
=
compress_chunk
(
chunk
,
CHUNK_SIZE
,
NULL
,
NULL
,
dst
,
dst_capacity
,
&
cmp_par
);
dst_capacity
,
&
cmp_par
);
TEST_ASSERT_EQUAL_INT(GENERIC_HEADER_SIZE + CHUNK_SIZE, cmp_size);
TEST_ASSERT_EQUAL_INT
(
124
,
cmp_size
);
/* test results */
{ struct cmp_entity *ent = (struct cmp_entity *)dst;
struct s_fx *raw_cmp_data1 = (struct s_fx *)(
(uint8_t *)cmp_ent_get_data_buf(ent) + COLLECTION_HDR_SIZE);
struct s_fx_efx_ncob_ecob *raw_cmp_data2 = (struct s_fx_efx_ncob_ecob *)(
(uint8_t *)cmp_ent_get_data_buf(ent) + 2*COLLECTION_HDR_SIZE +
DATA_SIZE_1);
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));
TEST_ASSERT_TRUE(cmp_ent_get_data_type_raw_bit(ent));
TEST_ASSERT_EQUAL_INT(DATA_TYPE_CHUNK, cmp_ent_get_data_type(ent));
TEST_ASSERT_EQUAL_HEX8_ARRAY(col1, cmp_ent_get_data_buf(ent), COLLECTION_HDR_SIZE);
/* int i; */
/* for (i = 0; i < 2; i++) { */
/* TEST_ASSERT_EQUAL_HEX(data1[i].exp_flags, raw_cmp_data1[i].exp_flags); */
/* TEST_ASSERT_EQUAL_HEX(data1[i].fx, be32_to_cpu(raw_cmp_data1[i].fx)); */
/* } */
/* TEST_ASSERT_EQUAL_HEX8_ARRAY(col1, cmp_ent_get_data_buf(ent), COLLECTION_HDR_SIZE); */
/* for (i = 0; i < 2; i++) { */
/* TEST_ASSERT_EQUAL_HEX(data1[i].exp_flags, raw_cmp_data1[i].exp_flags); */
/* TEST_ASSERT_EQUAL_HEX(data1[i].fx, be32_to_cpu(raw_cmp_data1[i].fx)); */
/* } */
/* TEST_ASSERT_EQUAL_HEX8_ARRAY(col2, (uint8_t *)cmp_ent_get_data_buf(ent)+cmp_col_get_size(col1), COLLECTION_HDR_SIZE); */
/* for (i = 0; i < 2; i++) { */
/* TEST_ASSERT_EQUAL_HEX(data2[i].exp_flags, raw_cmp_data2[i].exp_flags); */
/* TEST_ASSERT_EQUAL_HEX(data2[i].fx, be32_to_cpu(raw_cmp_data2[i].fx)); */
/* TEST_ASSERT_EQUAL_HEX(data2[i].efx, be32_to_cpu(raw_cmp_data2[i].efx)); */
/* TEST_ASSERT_EQUAL_HEX(data2[i].ncob_x, be32_to_cpu(raw_cmp_data2[i].ncob_x)); */
/* TEST_ASSERT_EQUAL_HEX(data2[i].ncob_y, be32_to_cpu(raw_cmp_data2[i].ncob_y)); */
/* TEST_ASSERT_EQUAL_HEX(data2[i].ecob_x, be32_to_cpu(raw_cmp_data2[i].ecob_x)); */
/* TEST_ASSERT_EQUAL_HEX(data2[i].ecob_y, be32_to_cpu(raw_cmp_data2[i].ecob_y)); */
/* } */
}
free(dst);
/* error case: dst buffer to small */
/* error case wrong cmp_par */
dst_capacity -= 1;
cmp_par
.
nc_background_outlier_pixels
=
0
;
dst = malloc(dst_capacity); TEST_ASSERT_NOT_NULL(dst);
cmp_size
=
compress_chunk
(
chunk
,
CHUNK_SIZE
,
NULL
,
NULL
,
dst
,
cmp_size
=
compress_chunk
(
chunk
,
CHUNK_SIZE
,
NULL
,
NULL
,
dst
,
dst_capacity
,
&
cmp_par
);
dst_capacity
,
&
cmp_par
);
TEST_ASSERT_EQUAL_INT(CMP_ERROR_SMALL_BUF_, cmp_get_error_code(cmp_size));
TEST_ASSERT_EQUAL_INT
(
CMP_ERROR_PAR_SPECIFIC
,
cmp_get_error_code
(
cmp_size
));
free(dst);
}
}
/* TODO: chunk tests
* collection with 0 length;
* collection with wrong mix collections;
*/
#endif
/**
/**
...
@@ -1961,62 +1902,6 @@ void test_collection_zero_data_length(void)
...
@@ -1961,62 +1902,6 @@ void test_collection_zero_data_length(void)
}
}
/**
* @test compress_chunk
*/
#if 0
void nootest_collection_zero_data_length_2(void)
{
enum { DATA_SIZE = 4,
CHUNK_SIZE = COLLECTION_HDR_SIZE + DATA_SIZE + COLLECTION_HDR_SIZE
};
uint8_t chunk[CHUNK_SIZE];
struct collection_hdr *col = (struct collection_hdr *)chunk;
uint16_t *data = (struct s_fx *)col->entry;
struct cmp_par cmp_par = {0};
uint32_t *dst;
int cmp_size;
uint32_t dst_capacity = 43; /* random non zero value */
/* create a chunk with a single collection */
memset(col, 0, COLLECTION_HDR_SIZE);
TEST_ASSERT_FALSE(cmp_col_set_subservice(col, SST_NCxx_S_SCIENCE_IMAGETTE));
/* compress the data */
cmp_par.cmp_mode = CMP_MODE_DIFF_MULTI;
dst = NULL;
cmp_size = compress_chunk(chunk, CHUNK_SIZE, NULL, NULL, dst,
dst_capacity, &cmp_par);
TEST_ASSERT_EQUAL_INT(NON_IMAGETTE_HEADER_SIZE + CHUNK_SIZE + CMP_COLLECTION_FILD_SIZE, cmp_size);
dst_capacity = (uint32_t)cmp_size;
dst = malloc(dst_capacity); TEST_ASSERT_NOT_NULL(dst);
cmp_size = compress_chunk(chunk, CHUNK_SIZE, NULL, NULL, dst,
dst_capacity, &cmp_par);
TEST_ASSERT_EQUAL_INT(NON_IMAGETTE_HEADER_SIZE + CHUNK_SIZE + CMP_COLLECTION_FILD_SIZE, cmp_size);
/* test results */
{ struct cmp_entity *ent = (struct cmp_entity *)dst;
TEST_ASSERT_EQUAL_UINT(CHUNK_SIZE+CMP_COLLECTION_FILD_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));
TEST_ASSERT_FALSE(cmp_ent_get_data_type_raw_bit(ent));
TEST_ASSERT_EQUAL_INT(DATA_TYPE_CHUNK, cmp_ent_get_data_type(ent));
TEST_ASSERT_EQUAL_HEX8_ARRAY(col, cmp_ent_get_data_buf(ent)+CMP_COLLECTION_FILD_SIZE, COLLECTION_HDR_SIZE);
}
/* error case: dst buffer to small */
dst_capacity -= 1;
cmp_size = compress_chunk(chunk, CHUNK_SIZE, NULL, NULL, dst,
dst_capacity, &cmp_par);
TEST_ASSERT_EQUAL_INT(CMP_ERROR_SMALL_BUF, cmp_size);
free(dst);
}
#endif
static
int
n_timestamp_fail
;
/* fail after n calls */
static
int
n_timestamp_fail
;
/* fail after n calls */
static
uint64_t
get_timstamp_test
(
void
)
static
uint64_t
get_timstamp_test
(
void
)
{
{
...
@@ -2030,6 +1915,7 @@ static uint64_t get_timstamp_test(void)
...
@@ -2030,6 +1915,7 @@ static uint64_t get_timstamp_test(void)
return
1ULL
<<
48
;
/* invalid time stamp */
return
1ULL
<<
48
;
/* invalid time stamp */
}
}
/**
/**
* @test compress_chunk
* @test compress_chunk
*/
*/
...
@@ -2206,7 +2092,7 @@ void test_compress_chunk_error_cases(void)
...
@@ -2206,7 +2092,7 @@ void test_compress_chunk_error_cases(void)
TEST_ASSERT_EQUAL_INT
(
CMP_ERROR_COL_SUBSERVICE_UNSUPPORTED
,
cmp_get_error_code
(
cmp_size
));
TEST_ASSERT_EQUAL_INT
(
CMP_ERROR_COL_SUBSERVICE_UNSUPPORTED
,
cmp_get_error_code
(
cmp_size
));
TEST_ASSERT_FALSE
(
cmp_col_set_subservice
((
struct
collection_hdr
*
)
chunk
,
SST_NCxx_S_SCIENCE_S_FX
));
TEST_ASSERT_FALSE
(
cmp_col_set_subservice
((
struct
collection_hdr
*
)
chunk
,
SST_NCxx_S_SCIENCE_S_FX
));
/* error:
TODO
*/
/* error:
collection size no a multiple of the data size
*/
TEST_ASSERT_FALSE
(
cmp_col_set_data_length
(
col2
,
DATA_SIZE_2
-
1
));
TEST_ASSERT_FALSE
(
cmp_col_set_data_length
(
col2
,
DATA_SIZE_2
-
1
));
cmp_size
=
compress_chunk
(
chunk
,
CHUNK_SIZE
-
1
,
chunk_model
,
cmp_size
=
compress_chunk
(
chunk
,
CHUNK_SIZE
-
1
,
chunk_model
,
updated_chunk_model
,
NULL
,
dst_capacity
,
updated_chunk_model
,
NULL
,
dst_capacity
,
...
@@ -2410,9 +2296,15 @@ void test_COMPRESS_CHUNK_BOUND(void)
...
@@ -2410,9 +2296,15 @@ void test_COMPRESS_CHUNK_BOUND(void)
void
test_compress_chunk_cmp_size_bound
(
void
)
void
test_compress_chunk_cmp_size_bound
(
void
)
{
{
uint8_t
chunk
[
2
*
COLLECTION_HDR_SIZE
+
42
+
3
]
=
{
0
};
enum
{
CHUNK_SIZE_1
=
42
,
CHUNK_SIZE_2
=
3
};
uint8_t
chunk
[
2
*
COLLECTION_HDR_SIZE
+
CHUNK_SIZE_1
+
CHUNK_SIZE_2
]
=
{
0
};
uint32_t
chunk_size
;
uint32_t
chunk_size
;
uint32_t
bound
,
bound_exp
;
uint32_t
bound
,
bound_exp
;
struct
collection_hdr
*
col2
=
(
struct
collection_hdr
*
)
(
chunk
+
COLLECTION_HDR_SIZE
+
CHUNK_SIZE_1
);
TEST_ASSERT_FALSE
(
cmp_col_set_data_length
((
struct
collection_hdr
*
)
chunk
,
0
));
TEST_ASSERT_FALSE
(
cmp_col_set_data_length
((
struct
collection_hdr
*
)
chunk
,
0
));
...
@@ -2436,8 +2328,8 @@ void test_compress_chunk_cmp_size_bound(void)
...
@@ -2436,8 +2328,8 @@ void test_compress_chunk_cmp_size_bound(void)
bound_exp
=
ROUND_UP_TO_4
(
NON_IMAGETTE_HEADER_SIZE
+
COLLECTION_HDR_SIZE
+
CMP_COLLECTION_FILD_SIZE
);
bound_exp
=
ROUND_UP_TO_4
(
NON_IMAGETTE_HEADER_SIZE
+
COLLECTION_HDR_SIZE
+
CMP_COLLECTION_FILD_SIZE
);
TEST_ASSERT_EQUAL
(
bound_exp
,
bound
);
TEST_ASSERT_EQUAL
(
bound_exp
,
bound
);
chunk_size
=
COLLECTION_HDR_SIZE
+
42
;
chunk_size
=
COLLECTION_HDR_SIZE
+
CHUNK_SIZE_1
;
TEST_ASSERT_FALSE
(
cmp_col_set_data_length
((
struct
collection_hdr
*
)
chunk
,
42
));
TEST_ASSERT_FALSE
(
cmp_col_set_data_length
((
struct
collection_hdr
*
)
chunk
,
CHUNK_SIZE_1
));
bound
=
compress_chunk_cmp_size_bound
(
chunk
,
chunk_size
);
bound
=
compress_chunk_cmp_size_bound
(
chunk
,
chunk_size
);
bound_exp
=
ROUND_UP_TO_4
(
NON_IMAGETTE_HEADER_SIZE
+
CMP_COLLECTION_FILD_SIZE
+
bound_exp
=
ROUND_UP_TO_4
(
NON_IMAGETTE_HEADER_SIZE
+
CMP_COLLECTION_FILD_SIZE
+
chunk_size
);
chunk_size
);
...
@@ -2448,15 +2340,50 @@ void test_compress_chunk_cmp_size_bound(void)
...
@@ -2448,15 +2340,50 @@ void test_compress_chunk_cmp_size_bound(void)
TEST_ASSERT_TRUE
(
cmp_is_error
(
bound
));
TEST_ASSERT_TRUE
(
cmp_is_error
(
bound
));
TEST_ASSERT_EQUAL_INT
(
CMP_ERROR_CHUNK_NULL
,
cmp_get_error_code
(
bound
));
TEST_ASSERT_EQUAL_INT
(
CMP_ERROR_CHUNK_NULL
,
cmp_get_error_code
(
bound
));
TEST_ASSERT_FALSE
(
cmp_col_set_data_length
((
struct
collection_hdr
*
)(
chunk
+
chunk_size
),
3
));
/* two collections */
TEST_ASSERT_FALSE
(
cmp_col_set_data_length
(
col2
,
CHUNK_SIZE_2
));
chunk_size
=
sizeof
(
chunk
);
chunk_size
=
sizeof
(
chunk
);
bound
=
compress_chunk_cmp_size_bound
(
chunk
,
chunk_size
);
bound
=
compress_chunk_cmp_size_bound
(
chunk
,
chunk_size
);
bound_exp
=
ROUND_UP_TO_4
(
NON_IMAGETTE_HEADER_SIZE
+
2
*
CMP_COLLECTION_FILD_SIZE
+
bound_exp
=
ROUND_UP_TO_4
(
NON_IMAGETTE_HEADER_SIZE
+
2
*
CMP_COLLECTION_FILD_SIZE
+
chunk_size
);
chunk_size
);
TEST_ASSERT_EQUAL
(
bound_exp
,
bound
);
TEST_ASSERT_EQUAL
(
bound_exp
,
bound
);
TEST_ASSERT_FALSE
(
cmp_col_set_data_length
(
col2
,
0
));
chunk_size
=
2
*
COLLECTION_HDR_SIZE
+
CHUNK_SIZE_1
;
bound
=
compress_chunk_cmp_size_bound
(
chunk
,
chunk_size
);
bound_exp
=
ROUND_UP_TO_4
(
NON_IMAGETTE_HEADER_SIZE
+
2
*
CMP_COLLECTION_FILD_SIZE
+
chunk_size
);
TEST_ASSERT_EQUAL
(
bound_exp
,
bound
);
/* wrong chunk_size */
TEST_ASSERT_FALSE
(
cmp_col_set_data_length
(
col2
,
0
));
chunk_size
=
1
+
2
*
COLLECTION_HDR_SIZE
+
CHUNK_SIZE_1
;
bound
=
compress_chunk_cmp_size_bound
(
chunk
,
chunk_size
);
TEST_ASSERT_TRUE
(
cmp_is_error
(
bound
));
TEST_ASSERT_EQUAL_INT
(
CMP_ERROR_CHUNK_SIZE_INCONSISTENT
,
cmp_get_error_code
(
bound
));
{
/* containing only zero data size collections */
size_t
i
;
uint8_t
*
chunk_big
;
size_t
const
max_chunk_size
=
CMP_ENTITY_MAX_ORIGINAL_SIZE
-
NON_IMAGETTE_HEADER_SIZE
-
CMP_COLLECTION_FILD_SIZE
;
chunk_big
=
malloc
(
max_chunk_size
);
for
(
i
=
0
;
i
<
max_chunk_size
-
COLLECTION_HDR_SIZE
;
i
=
i
+
COLLECTION_HDR_SIZE
)
TEST_ASSERT_FALSE
(
cmp_col_set_data_length
((
struct
collection_hdr
*
)
&
chunk_big
[
i
],
0
));
bound
=
compress_chunk_cmp_size_bound
(
chunk_big
,
i
);
TEST_ASSERT_EQUAL_INT
(
CMP_ERROR_CHUNK_TOO_LARGE
,
cmp_get_error_code
(
bound
));
free
(
chunk_big
);
}
}
}
/**
* @test compress_chunk_set_model_id_and_counter
*/
void
test_compress_chunk_set_model_id_and_counter
(
void
)
void
test_compress_chunk_set_model_id_and_counter
(
void
)
{
{
uint32_t
ret
;
uint32_t
ret
;
...
@@ -2491,6 +2418,10 @@ void test_compress_chunk_set_model_id_and_counter(void)
...
@@ -2491,6 +2418,10 @@ void test_compress_chunk_set_model_id_and_counter(void)
ret
=
compress_chunk_set_model_id_and_counter
(
NULL
,
dst_size
,
model_id
,
model_counter
);
ret
=
compress_chunk_set_model_id_and_counter
(
NULL
,
dst_size
,
model_id
,
model_counter
);
TEST_ASSERT_TRUE
(
cmp_is_error
(
ret
));
TEST_ASSERT_TRUE
(
cmp_is_error
(
ret
));
TEST_ASSERT_EQUAL
(
CMP_ERROR_ENTITY_NULL
,
cmp_get_error_code
(
ret
));
TEST_ASSERT_EQUAL
(
CMP_ERROR_ENTITY_NULL
,
cmp_get_error_code
(
ret
));
ret
=
compress_chunk_set_model_id_and_counter
(
&
dst
,
CMP_ERROR
(
PAR_GENERIC
),
model_id
,
model_counter
);
TEST_ASSERT_TRUE
(
cmp_is_error
(
ret
));
TEST_ASSERT_EQUAL
(
CMP_ERROR_PAR_GENERIC
,
cmp_get_error_code
(
ret
));
}
}
...
...
This diff is collapsed.
Click to expand it.
Preview
0%
Loading
Try again
or
attach a new file
.
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Save comment
Cancel
Please
register
or
sign in
to comment