cuberite/libdeflate
1
0
Fork 0
mirror of https://github.com/cuberite/libdeflate.git synced 2025-09-10 12:58:30 -04:00
Code Issues Packages Projects Releases Wiki Activity

Generalize test_zlib to test_trailing_bytes

Browse Source 
Do the same test for DEFLATE and gzip.
This commit is contained in:
Eric Biggers 2020-04-17 21:10:23 -07:00
parent a5cb1d7765
commit 21ccbd2e2f
3 changed files with 155 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -217,7 +217,7 @@ TEST_PROG_SRC := programs/benchmark.c \
programs/test_checksums.c \
programs/test_incomplete_codes.c \
programs/test_slow_decompression.c \
programs/test_zlib.c
programs/test_trailing_bytes.c
NONTEST_PROGRAMS := $(NONTEST_PROG_SRC:programs/%.c=%$(PROG_SUFFIX))
DEFAULT_TARGETS += $(NONTEST_PROGRAMS)

154
programs/test_trailing_bytes.c Normal file
View File

@ -0,0 +1,154 @@
/*
* test_trailing_bytes.c
*
* Test that decompression correctly stops at the end of the first DEFLATE,
* zlib, or gzip stream, and doesn't process any additional trailing bytes.
*/
#include "test_util.h"
static const struct {
size_t (LIBDEFLATEAPI *compress)(
struct libdeflate_compressor *compressor,
const void *in, size_t in_nbytes,
void *out, size_t out_nbytes_avail);
enum libdeflate_result (LIBDEFLATEAPI *decompress)(
struct libdeflate_decompressor *decompressor,
const void *in, size_t in_nbytes,
void *out, size_t out_nbytes_avail,
size_t *actual_out_nbytes_ret);
enum libdeflate_result (LIBDEFLATEAPI *decompress_ex)(
struct libdeflate_decompressor *decompressor,
const void *in, size_t in_nbytes,
void *out, size_t out_nbytes_avail,
size_t *actual_in_nbytes_ret,
size_t *actual_out_nbytes_ret);
} codecs[] = {
{
.compress = libdeflate_deflate_compress,
.decompress = libdeflate_deflate_decompress,
.decompress_ex = libdeflate_deflate_decompress_ex,
}, {
.compress = libdeflate_zlib_compress,
.decompress = libdeflate_zlib_decompress,
.decompress_ex = libdeflate_zlib_decompress_ex,
}, {
.compress = libdeflate_gzip_compress,
.decompress = libdeflate_gzip_decompress,
.decompress_ex = libdeflate_gzip_decompress_ex,
}
};
int
tmain(int argc, tchar *argv[])
{
const size_t original_nbytes = 32768;
const size_t compressed_nbytes_total = 32768;
/*
* Don't use the full buffer for compressed data, because we want to
* test whether decompression can deal with additional trailing bytes.
*
* Note: we can't use a guarded buffer (i.e. a buffer where the byte
* after compressed_nbytes is unmapped) because the decompressor may
* read a few bytes beyond the end of the stream (but ultimately not
* actually use those bytes) as long as they are within the buffer.
*/
const size_t compressed_nbytes_avail = 30000;
size_t i;
u8 *original;
u8 *compressed;
u8 *decompressed;
struct libdeflate_compressor *c;
struct libdeflate_decompressor *d;
size_t compressed_nbytes;
enum libdeflate_result res;
size_t actual_compressed_nbytes;
size_t actual_decompressed_nbytes;
program_invocation_name = get_filename(argv[0]);
ASSERT(compressed_nbytes_avail < compressed_nbytes_total);
/* Prepare some dummy data to compress */
original = xmalloc(original_nbytes);
ASSERT(original != NULL);
for (i = 0; i < original_nbytes; i++)
original[i] = (i % 123) + (i % 1023);
compressed = xmalloc(compressed_nbytes_total);
ASSERT(compressed != NULL);
memset(compressed, 0, compressed_nbytes_total);
decompressed = xmalloc(original_nbytes);
ASSERT(decompressed != NULL);
c = libdeflate_alloc_compressor(6);
ASSERT(c != NULL);
d = libdeflate_alloc_decompressor();
ASSERT(d != NULL);
for (i = 0; i < ARRAY_LEN(codecs); i++) {
compressed_nbytes = codecs[i].compress(c, original,
original_nbytes,
compressed,
compressed_nbytes_avail);
ASSERT(compressed_nbytes > 0);
ASSERT(compressed_nbytes <= compressed_nbytes_avail);
/* Test decompress() of stream that fills the whole buffer */
actual_decompressed_nbytes = 0;
memset(decompressed, 0, original_nbytes);
res = codecs[i].decompress(d, compressed, compressed_nbytes,
decompressed, original_nbytes,
&actual_decompressed_nbytes);
ASSERT(res == LIBDEFLATE_SUCCESS);
ASSERT(actual_decompressed_nbytes == original_nbytes);
ASSERT(memcmp(decompressed, original, original_nbytes) == 0);
/* Test decompress_ex() of stream that fills the whole buffer */
actual_compressed_nbytes = actual_decompressed_nbytes = 0;
memset(decompressed, 0, original_nbytes);
res = codecs[i].decompress_ex(d, compressed, compressed_nbytes,
decompressed, original_nbytes,
&actual_compressed_nbytes,
&actual_decompressed_nbytes);
ASSERT(res == LIBDEFLATE_SUCCESS);
ASSERT(actual_compressed_nbytes == compressed_nbytes);
ASSERT(actual_decompressed_nbytes == original_nbytes);
ASSERT(memcmp(decompressed, original, original_nbytes) == 0);
/* Test decompress() of stream with trailing bytes */
actual_decompressed_nbytes = 0;
memset(decompressed, 0, original_nbytes);
res = codecs[i].decompress(d, compressed,
compressed_nbytes_total,
decompressed, original_nbytes,
&actual_decompressed_nbytes);
ASSERT(res == LIBDEFLATE_SUCCESS);
ASSERT(actual_decompressed_nbytes == original_nbytes);
ASSERT(memcmp(decompressed, original, original_nbytes) == 0);
/* Test decompress_ex() of stream with trailing bytes */
actual_compressed_nbytes = actual_decompressed_nbytes = 0;
memset(decompressed, 0, original_nbytes);
res = codecs[i].decompress_ex(d, compressed,
compressed_nbytes_total,
decompressed, original_nbytes,
&actual_compressed_nbytes,
&actual_decompressed_nbytes);
ASSERT(res == LIBDEFLATE_SUCCESS);
ASSERT(actual_compressed_nbytes == compressed_nbytes);
ASSERT(actual_decompressed_nbytes == original_nbytes);
ASSERT(memcmp(decompressed, original, original_nbytes) == 0);
}
printf("Trailing bytes decompression tests passed!\n");
free(original);
free(compressed);
free(decompressed);
libdeflate_free_compressor(c);
libdeflate_free_decompressor(d);
return 0;
}

106
programs/test_zlib.c
View File

@ -1,106 +0,0 @@
/*
* test_zlib.c
*
* Verify that libdeflate_zlib_decompress and libdeflate_zlib_decompress_ex can
* correctly decompress the results of libdeflate_zlib_compress. Also checks
* whether decompression correctly handles additional trailing bytes in the
* compressed buffer.
*/
#include <stdlib.h>
#include "test_util.h"
static void
test_decompress(u8 const* compressed, size_t compressed_nbytes,
u8 const* expected, size_t expected_nbytes)
{
struct libdeflate_decompressor* d = libdeflate_alloc_decompressor();
ASSERT(d != NULL);
size_t decompressed_nbytes = expected_nbytes;
u8 *decompressed = xmalloc(decompressed_nbytes);
size_t actual_decompressed_nbytes = 0;
enum libdeflate_result res =
libdeflate_zlib_decompress(d, compressed, compressed_nbytes,
decompressed, decompressed_nbytes,
&actual_decompressed_nbytes);
ASSERT(res == LIBDEFLATE_SUCCESS);
ASSERT(actual_decompressed_nbytes == expected_nbytes);
ASSERT(memcmp(expected, decompressed, expected_nbytes) == 0);
free(decompressed);
libdeflate_free_decompressor(d);
}
static void
test_decompress_ex(u8 const* compressed, size_t compressed_nbytes,
size_t expected_actual_compressed_nbytes,
u8 const* expected, size_t expected_nbytes)
{
struct libdeflate_decompressor* d = libdeflate_alloc_decompressor();
ASSERT(d != NULL);
size_t decompressed_nbytes = expected_nbytes;
u8 *decompressed = xmalloc(decompressed_nbytes);
size_t actual_compressed_nbytes = 0;
size_t actual_decompressed_nbytes = 0;
enum libdeflate_result res =
libdeflate_zlib_decompress_ex(d, compressed, compressed_nbytes,
decompressed, decompressed_nbytes,
&actual_compressed_nbytes,
&actual_decompressed_nbytes);
ASSERT(res == LIBDEFLATE_SUCCESS);
ASSERT(actual_compressed_nbytes == expected_actual_compressed_nbytes);
ASSERT(actual_decompressed_nbytes == expected_nbytes);
ASSERT(memcmp(expected, decompressed, expected_nbytes) == 0);
free(decompressed);
libdeflate_free_decompressor(d);
}
int
tmain(int argc, tchar *argv[])
{
program_invocation_name = get_filename(argv[0]);
size_t original_nbytes = 32768;
u8 *original = xmalloc(original_nbytes);
/* Prepare some dummy data to compress */
for (size_t i = 0; i < original_nbytes; ++i) {
original[i] = (i % 123) + (i % 1023);
}
size_t compressed_nbytes_total = 32768;
u8 *compressed = xmalloc(compressed_nbytes_total);
memset(compressed, 0x00, compressed_nbytes_total);
/*
* Don't use the full buffer for compressed data, because we want to
* test whether decompression can deal with additional trailing bytes.
*/
size_t compressed_nbytes_avail = 30000;
ASSERT(compressed_nbytes_avail < compressed_nbytes_total);
struct libdeflate_compressor* c = libdeflate_alloc_compressor(6);
ASSERT(c != NULL);
size_t compressed_nbytes =
libdeflate_zlib_compress(c, original, original_nbytes,
compressed, compressed_nbytes_avail);
ASSERT(compressed_nbytes > 0);
libdeflate_free_compressor(c);
test_decompress(compressed, compressed_nbytes, original, original_nbytes);
test_decompress(compressed, compressed_nbytes_total, original, original_nbytes);
test_decompress_ex(compressed, compressed_nbytes_total, compressed_nbytes,
original, original_nbytes);
printf("libdeflate_zlib_* tests passed!\n");
free(compressed);
free(original);
return 0;
}