picnoir/Systemd
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

journal: add the "repeating sequence" test case

Browse source 
This was the case that caused various problems that were fixed in
preceding patches, so it is good to add a test that uses it directly.

In "may_fail" test cases try again with a bigger buffer.

Instead of allocating various buffers on the stack, malloc them.
This is more reliable in case of big buffers, and allows tools like
valgrind and address sanitizer to find overflows more easily.
This commit is contained in:
Zbigniew Jędrzejewski-Szmek 2015-12-13 14:33:17 -05:00
parent e3cc7fc45b
commit ae5e1b19e7
1 changed files with 54 additions and 35 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

89
src/journal/test-compress.c
View file

@ -104,42 +104,45 @@ static void test_decompress_startswith(int compression,
size_t data_len,
bool may_fail) {
char compressed[512];
size_t csize, usize = 0;
_cleanup_free_ char *decompressed = NULL;
char *compressed;
_cleanup_free_ char *compressed1 = NULL, *compressed2 = NULL, *decompressed = NULL;
size_t csize, usize = 0, len;
int r;
log_info("/* testing decompress_startswith with %s on %s text*/",
log_info("/* testing decompress_startswith with %s on %.20s text*/",
object_compressed_to_string(compression), data);
r = compress(data, data_len, compressed, sizeof(compressed), &csize);
#define BUFSIZE_1 512
#define BUFSIZE_2 20000
compressed = compressed1 = malloc(BUFSIZE_1);
assert_se(compressed1);
r = compress(data, data_len, compressed, BUFSIZE_1, &csize);
if (r == -ENOBUFS) {
log_info_errno(r, "compression failed: %m");
assert_se(may_fail);
return;
compressed = compressed2 = malloc(BUFSIZE_2);
assert_se(compressed2);
r = compress(data, data_len, compressed, BUFSIZE_2, &csize);
assert(r == 0);
}
assert_se(r == 0);
assert_se(decompress_sw(compressed,
csize,
(void **) &decompressed,
&usize,
data, strlen(data), '\0') > 0);
assert_se(decompress_sw(compressed,
csize,
(void **) &decompressed,
&usize,
data, strlen(data), 'w') == 0);
assert_se(decompress_sw(compressed,
csize,
(void **) &decompressed,
&usize,
"barbarbar", 9, ' ') == 0);
assert_se(decompress_sw(compressed,
csize,
(void **) &decompressed,
&usize,
data, strlen(data), '\0') > 0);
len = strlen(data);
r = decompress_sw(compressed, csize, (void **) &decompressed, &usize, data, len, '\0');
assert_se(r > 0);
r = decompress_sw(compressed, csize, (void **) &decompressed, &usize, data, len, 'w');
assert_se(r == 0);
r = decompress_sw(compressed, csize, (void **) &decompressed, &usize, "barbarbar", 9, ' ');
assert_se(r == 0);
r = decompress_sw(compressed, csize, (void **) &decompressed, &usize, data, len - 1, data[len-1]);
assert_se(r > 0);
r = decompress_sw(compressed, csize, (void **) &decompressed, &usize, data, len - 1, 'w');
assert_se(r == 0);
r = decompress_sw(compressed, csize, (void **) &decompressed, &usize, data, len, '\0');
assert_se(r > 0);
}
static void test_compress_stream(int compression,
@ -206,34 +209,36 @@ static void test_lz4_decompress_partial(void) {
char buf[20000];
size_t buf_size = sizeof(buf), compressed;
int r;
_cleanup_free_ char *huge = NULL;
char huge[4096*1024];
memset(huge, 'x', sizeof(huge));
#define HUGE_SIZE (4096*1024)
huge = malloc(HUGE_SIZE);
memset(huge, 'x', HUGE_SIZE);
memcpy(huge, "HUGE=", 5);
r = LZ4_compress_limitedOutput(huge, buf, sizeof(huge), buf_size);
r = LZ4_compress_limitedOutput(huge, buf, HUGE_SIZE, buf_size);
assert_se(r >= 0);
compressed = r;
log_info("Compressed %zu → %zu", sizeof(huge), compressed);
log_info("Compressed %i → %zu", HUGE_SIZE, compressed);
r = LZ4_decompress_safe(buf, huge, r, sizeof(huge));
r = LZ4_decompress_safe(buf, huge, r, HUGE_SIZE);
assert_se(r >= 0);
log_info("Decompressed → %i", r);
r = LZ4_decompress_safe_partial(buf, huge,
compressed,
12, (int) sizeof(huge));
12, HUGE_SIZE);
assert_se(r >= 0);
log_info("Decompressed partial %i/%zu → %i", 12, sizeof(huge), r);
log_info("Decompressed partial %i/%i → %i", 12, HUGE_SIZE, r);
/* We expect this to fail, because that's how current lz4 works. If this
* call succeeds, then lz4 has been fixed, and we need to change our code.
*/
r = LZ4_decompress_safe_partial(buf, huge,
compressed,
12, (int) sizeof(huge) - 1);
12, HUGE_SIZE-1);
assert_se(r < 0);
log_info("Decompressed partial %i/%zu → %i", 12, sizeof(huge), r);
log_info("Decompressed partial %i/%i → %i", 12, HUGE_SIZE-1, r);
}
#endif
@ -244,6 +249,11 @@ int main(int argc, char *argv[]) {
char data[512] = "random\0";
char huge[4096*1024];
memset(huge, 'x', sizeof(huge));
memcpy(huge, "HUGE=", 5);
char_array_0(huge);
log_set_max_level(LOG_DEBUG);
random_bytes(data + 7, sizeof(data) - 7);
@ -253,12 +263,17 @@ int main(int argc, char *argv[]) {
text, sizeof(text), false);
test_compress_decompress(OBJECT_COMPRESSED_XZ, compress_blob_xz, decompress_blob_xz,
data, sizeof(data), true);
test_decompress_startswith(OBJECT_COMPRESSED_XZ,
compress_blob_xz, decompress_startswith_xz,
text, sizeof(text), false);
test_decompress_startswith(OBJECT_COMPRESSED_XZ,
compress_blob_xz, decompress_startswith_xz,
data, sizeof(data), true);
test_decompress_startswith(OBJECT_COMPRESSED_XZ,
compress_blob_xz, decompress_startswith_xz,
huge, sizeof(huge), true);
test_compress_stream(OBJECT_COMPRESSED_XZ, "xzcat",
compress_stream_xz, decompress_stream_xz, argv[0]);
#else
@ -270,12 +285,16 @@ int main(int argc, char *argv[]) {
text, sizeof(text), false);
test_compress_decompress(OBJECT_COMPRESSED_LZ4, compress_blob_lz4, decompress_blob_lz4,
data, sizeof(data), true);
test_decompress_startswith(OBJECT_COMPRESSED_LZ4,
compress_blob_lz4, decompress_startswith_lz4,
text, sizeof(text), false);
test_decompress_startswith(OBJECT_COMPRESSED_LZ4,
compress_blob_lz4, decompress_startswith_lz4,
data, sizeof(data), true);
test_decompress_startswith(OBJECT_COMPRESSED_LZ4,
compress_blob_lz4, decompress_startswith_lz4,
huge, sizeof(huge), true);
test_compress_stream(OBJECT_COMPRESSED_LZ4, "lz4cat",
compress_stream_lz4, decompress_stream_lz4, argv[0]);