deflate-ruby 1.0.1 → 1.0.2

data/ext/deflate_ruby/libdeflate/programs/test_incomplete_codes.c

@@ -1,385 +0,0 @@
-/*
- * test_incomplete_codes.c
- *
- * Test that the decompressor accepts incomplete Huffman codes in certain
- * specific cases.
- */
-
-#include "test_util.h"
-
-static void
-verify_decompression_libdeflate(const u8 *in, size_t in_nbytes,
-				u8 *out, size_t out_nbytes_avail,
-				const u8 *expected_out,
-				size_t expected_out_nbytes)
-{
-	struct libdeflate_decompressor *d;
-	enum libdeflate_result res;
-	size_t actual_out_nbytes;
-
-	d = libdeflate_alloc_decompressor();
-	ASSERT(d != NULL);
-
-	res = libdeflate_deflate_decompress(d, in, in_nbytes,
-					    out, out_nbytes_avail,
-					    &actual_out_nbytes);
-	ASSERT(res == LIBDEFLATE_SUCCESS);
-	ASSERT(actual_out_nbytes == expected_out_nbytes);
-	ASSERT(memcmp(out, expected_out, actual_out_nbytes) == 0);
-
-	libdeflate_free_decompressor(d);
-}
-
-static void
-verify_decompression_zlib(const u8 *in, size_t in_nbytes,
-			  u8 *out, size_t out_nbytes_avail,
-			  const u8 *expected_out, size_t expected_out_nbytes)
-{
-	z_stream z;
-	int res;
-	size_t actual_out_nbytes;
-
-	memset(&z, 0, sizeof(z));
-	res = inflateInit2(&z, -15);
-	ASSERT(res == Z_OK);
-
-	z.next_in = (void *)in;
-	z.avail_in = in_nbytes;
-	z.next_out = (void *)out;
-	z.avail_out = out_nbytes_avail;
-	res = inflate(&z, Z_FINISH);
-	ASSERT(res == Z_STREAM_END);
-	actual_out_nbytes = out_nbytes_avail - z.avail_out;
-	ASSERT(actual_out_nbytes == expected_out_nbytes);
-	ASSERT(memcmp(out, expected_out, actual_out_nbytes) == 0);
-
-	inflateEnd(&z);
-}
-
-static void
-verify_decompression(const u8 *in, size_t in_nbytes,
-		     u8 *out, size_t out_nbytes_avail,
-		     const u8 *expected_out, size_t expected_out_nbytes)
-{
-	verify_decompression_libdeflate(in, in_nbytes, out, out_nbytes_avail,
-					expected_out, expected_out_nbytes);
-	verify_decompression_zlib(in, in_nbytes, out, out_nbytes_avail,
-				  expected_out, expected_out_nbytes);
-
-}
-
-/* Test that an empty offset code is accepted. */
-static void
-test_empty_offset_code(void)
-{
-	static const u8 expected_out[] = { 'A', 'B', 'A', 'A' };
-	u8 in[128];
-	u8 out[128];
-	struct output_bitstream os = { .next = in, .end = in + sizeof(in) };
-	int i;
-
-	/*
-	 * Generate a DEFLATE stream containing a "dynamic Huffman" block
-	 * containing literals, but no offsets; and having an empty offset code
-	 * (all codeword lengths set to 0).
-	 *
-	 * Litlen code:
-	 *	litlensym_A			freq=3 len=1 codeword= 0
-	 *	litlensym_B			freq=1 len=2 codeword=01
-	 *	litlensym_256 (end-of-block)	freq=1 len=2 codeword=11
-	 * Offset code:
-	 *	(empty)
-	 *
-	 * Litlen and offset codeword lengths:
-	 *	[0..'A'-1]	= 0	presym_18
-	 *	['A']		= 1	presym_1
-	 *	['B']		= 2	presym_2
-	 *	['B'+1..255]	= 0	presym_18 presym_18
-	 *	[256]		= 2	presym_2
-	 *	[257]		= 0	presym_0
-	 *
-	 * Precode:
-	 *	presym_0	freq=1 len=3 codeword=011
-	 *	presym_1	freq=1 len=3 codeword=111
-	 *	presym_2	freq=2 len=2 codeword= 01
-	 *	presym_18	freq=3 len=1 codeword=  0
-	 */
-
-	ASSERT(put_bits(&os, 1, 1));	/* BFINAL: 1 */
-	ASSERT(put_bits(&os, 2, 2));	/* BTYPE: DYNAMIC_HUFFMAN */
-	ASSERT(put_bits(&os, 0, 5));	/* num_litlen_syms: 0 + 257 */
-	ASSERT(put_bits(&os, 0, 5));	/* num_offset_syms: 0 + 1 */
-	ASSERT(put_bits(&os, 14, 4));	/* num_explicit_precode_lens: 14 + 4 */
-
-	/*
-	 * Precode codeword lengths: order is
-	 * [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]
-	 */
-	for (i = 0; i < 2; i++)		/* presym_{16,17}: len=0 */
-		ASSERT(put_bits(&os, 0, 3));
-	ASSERT(put_bits(&os, 1, 3));	/* presym_18: len=1 */
-	ASSERT(put_bits(&os, 3, 3));	/* presym_0: len=3 */
-	for (i = 0; i < 11; i++)	/* presym_{8,...,13}: len=0 */
-		ASSERT(put_bits(&os, 0, 3));
-	ASSERT(put_bits(&os, 2, 3));	/* presym_2: len=2 */
-	ASSERT(put_bits(&os, 0, 3));	/* presym_14: len=0 */
-	ASSERT(put_bits(&os, 3, 3));	/* presym_1: len=3 */
-
-	/* Litlen and offset codeword lengths */
-	ASSERT(put_bits(&os, 0x0, 1) &&
-	       put_bits(&os, 54, 7));	/* presym_18, 65 zeroes */
-	ASSERT(put_bits(&os, 0x7, 3));	/* presym_1 */
-	ASSERT(put_bits(&os, 0x1, 2));	/* presym_2 */
-	ASSERT(put_bits(&os, 0x0, 1) &&
-	       put_bits(&os, 89, 7));	/* presym_18, 100 zeroes */
-	ASSERT(put_bits(&os, 0x0, 1) &&
-	       put_bits(&os, 78, 7));	/* presym_18, 89 zeroes */
-	ASSERT(put_bits(&os, 0x1, 2));	/* presym_2 */
-	ASSERT(put_bits(&os, 0x3, 3));	/* presym_0 */
-
-	/* Litlen symbols */
-	ASSERT(put_bits(&os, 0x0, 1));	/* litlensym_A */
-	ASSERT(put_bits(&os, 0x1, 2));	/* litlensym_B */
-	ASSERT(put_bits(&os, 0x0, 1));	/* litlensym_A */
-	ASSERT(put_bits(&os, 0x0, 1));	/* litlensym_A */
-	ASSERT(put_bits(&os, 0x3, 2));	/* litlensym_256 (end-of-block) */
-
-	ASSERT(flush_bits(&os));
-
-	verify_decompression(in, os.next - in, out, sizeof(out),
-			     expected_out, sizeof(expected_out));
-}
-
-/* Test that a litrunlen code containing only one symbol is accepted. */
-static void
-test_singleton_litrunlen_code(void)
-{
-	u8 in[128];
-	u8 out[128];
-	struct output_bitstream os = { .next = in, .end = in + sizeof(in) };
-	int i;
-
-	/*
-	 * Litlen code:
-	 *	litlensym_256 (end-of-block)	freq=1 len=1 codeword=0
-	 * Offset code:
-	 *	(empty)
-	 *
-	 * Litlen and offset codeword lengths:
-	 *	[0..256]	= 0	presym_18 presym_18
-	 *	[256]		= 1	presym_1
-	 *	[257]		= 0	presym_0
-	 *
-	 * Precode:
-	 *	presym_0	freq=1 len=2 codeword=01
-	 *	presym_1	freq=1 len=2 codeword=11
-	 *	presym_18	freq=2 len=1 codeword= 0
-	 */
-
-	ASSERT(put_bits(&os, 1, 1));	/* BFINAL: 1 */
-	ASSERT(put_bits(&os, 2, 2));	/* BTYPE: DYNAMIC_HUFFMAN */
-	ASSERT(put_bits(&os, 0, 5));	/* num_litlen_syms: 0 + 257 */
-	ASSERT(put_bits(&os, 0, 5));	/* num_offset_syms: 0 + 1 */
-	ASSERT(put_bits(&os, 14, 4));	/* num_explicit_precode_lens: 14 + 4 */
-
-	/*
-	 * Precode codeword lengths: order is
-	 * [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]
-	 */
-	for (i = 0; i < 2; i++)		/* presym_{16,17}: len=0 */
-		ASSERT(put_bits(&os, 0, 3));
-	ASSERT(put_bits(&os, 1, 3));	/* presym_18: len=1 */
-	ASSERT(put_bits(&os, 2, 3));	/* presym_0: len=2 */
-	for (i = 0; i < 13; i++)	/* presym_{8,...,14}: len=0 */
-		ASSERT(put_bits(&os, 0, 3));
-	ASSERT(put_bits(&os, 2, 3));	/* presym_1: len=2 */
-
-	/* Litlen and offset codeword lengths */
-	for (i = 0; i < 2; i++) {
-		ASSERT(put_bits(&os, 0, 1) &&	/* presym_18, 128 zeroes */
-		       put_bits(&os, 117, 7));
-	}
-	ASSERT(put_bits(&os, 0x3, 2));	/* presym_1 */
-	ASSERT(put_bits(&os, 0x1, 2));	/* presym_0 */
-
-	/* Litlen symbols */
-	ASSERT(put_bits(&os, 0x0, 1));	/* litlensym_256 (end-of-block) */
-
-	ASSERT(flush_bits(&os));
-
-	verify_decompression(in, os.next - in, out, sizeof(out), in, 0);
-}
-
-/* Test that an offset code containing only one symbol is accepted. */
-static void
-test_singleton_offset_code(void)
-{
-	static const u8 expected_out[] = { 255, 255, 255, 255 };
-	u8 in[128];
-	u8 out[128];
-	struct output_bitstream os = { .next = in, .end = in + sizeof(in) };
-	int i;
-
-	ASSERT(put_bits(&os, 1, 1));	/* BFINAL: 1 */
-	ASSERT(put_bits(&os, 2, 2));	/* BTYPE: DYNAMIC_HUFFMAN */
-
-	/*
-	 * Litlen code:
-	 *	litlensym_255			freq=1 len=1 codeword= 0
-	 *	litlensym_256 (end-of-block)	freq=1 len=2 codeword=01
-	 *	litlensym_257 (len 3)		freq=1 len=2 codeword=11
-	 * Offset code:
-	 *	offsetsym_0 (offset 0)		freq=1 len=1 codeword=0
-	 *
-	 * Litlen and offset codeword lengths:
-	 *	[0..254] = 0	presym_{18,18}
-	 *	[255]	 = 1	presym_1
-	 *	[256]	 = 1	presym_2
-	 *	[257]	 = 1	presym_2
-	 *	[258]	 = 1	presym_1
-	 *
-	 * Precode:
-	 *	presym_1	freq=2 len=2 codeword=01
-	 *	presym_2	freq=2 len=2 codeword=11
-	 *	presym_18	freq=2 len=1 codeword= 0
-	 */
-
-	ASSERT(put_bits(&os, 1, 5));	/* num_litlen_syms: 1 + 257 */
-	ASSERT(put_bits(&os, 0, 5));	/* num_offset_syms: 0 + 1 */
-	ASSERT(put_bits(&os, 14, 4));	/* num_explicit_precode_lens: 14 + 4 */
-	/*
-	 * Precode codeword lengths: order is
-	 * [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]
-	 */
-	for (i = 0; i < 2; i++)		/* presym_{16,17}: len=0 */
-		ASSERT(put_bits(&os, 0, 3));
-	ASSERT(put_bits(&os, 1, 3));	/* presym_18: len=1 */
-	for (i = 0; i < 12; i++)	/* presym_{0,...,13}: len=0 */
-		ASSERT(put_bits(&os, 0, 3));
-	ASSERT(put_bits(&os, 2, 3));	/* presym_2: len=2 */
-	ASSERT(put_bits(&os, 0, 3));	/* presym_14: len=0 */
-	ASSERT(put_bits(&os, 2, 3));	/* presym_1: len=2 */
-
-	/* Litlen and offset codeword lengths */
-	ASSERT(put_bits(&os, 0x0, 1) &&	/* presym_18, 128 zeroes */
-	       put_bits(&os, 117, 7));
-	ASSERT(put_bits(&os, 0x0, 1) &&	/* presym_18, 127 zeroes */
-	       put_bits(&os, 116, 7));
-	ASSERT(put_bits(&os, 0x1, 2));	/* presym_1 */
-	ASSERT(put_bits(&os, 0x3, 2));	/* presym_2 */
-	ASSERT(put_bits(&os, 0x3, 2));	/* presym_2 */
-	ASSERT(put_bits(&os, 0x1, 2));	/* presym_1 */
-
-	/* Literal */
-	ASSERT(put_bits(&os, 0x0, 1));	/* litlensym_255 */
-
-	/* Match */
-	ASSERT(put_bits(&os, 0x3, 2));	/* litlensym_257 */
-	ASSERT(put_bits(&os, 0x0, 1));	/* offsetsym_0 */
-
-	/* End of block */
-	ASSERT(put_bits(&os, 0x1, 2));	/* litlensym_256 */
-
-	ASSERT(flush_bits(&os));
-
-	verify_decompression(in, os.next - in, out, sizeof(out),
-			     expected_out, sizeof(expected_out));
-}
-
-/* Test that an offset code containing only one symbol is accepted, even if that
- * symbol is not symbol 0.  The codeword should be '0' in either case. */
-static void
-test_singleton_offset_code_notsymzero(void)
-{
-	static const u8 expected_out[] = { 254, 255, 254, 255, 254 };
-	u8 in[128];
-	u8 out[128];
-	struct output_bitstream os = { .next = in, .end = in + sizeof(in) };
-	int i;
-
-	ASSERT(put_bits(&os, 1, 1));	/* BFINAL: 1 */
-	ASSERT(put_bits(&os, 2, 2));	/* BTYPE: DYNAMIC_HUFFMAN */
-
-	/*
-	 * Litlen code:
-	 *	litlensym_254			len=2 codeword=00
-	 *	litlensym_255			len=2 codeword=10
-	 *	litlensym_256 (end-of-block)	len=2 codeword=01
-	 *	litlensym_257 (len 3)		len=2 codeword=11
-	 * Offset code:
-	 *	offsetsym_1 (offset 2)		len=1 codeword=0
-	 *
-	 * Litlen and offset codeword lengths:
-	 *	[0..253] = 0	presym_{18,18}
-	 *	[254]	 = 2	presym_2
-	 *	[255]	 = 2	presym_2
-	 *	[256]	 = 2	presym_2
-	 *	[257]	 = 2	presym_2
-	 *	[258]	 = 0	presym_0
-	 *	[259]	 = 1	presym_1
-	 *
-	 * Precode:
-	 *	presym_0	len=2 codeword=00
-	 *	presym_1	len=2 codeword=10
-	 *	presym_2	len=2 codeword=01
-	 *	presym_18	len=2 codeword=11
-	 */
-
-	ASSERT(put_bits(&os, 1, 5));	/* num_litlen_syms: 1 + 257 */
-	ASSERT(put_bits(&os, 1, 5));	/* num_offset_syms: 1 + 1 */
-	ASSERT(put_bits(&os, 14, 4));	/* num_explicit_precode_lens: 14 + 4 */
-	/*
-	 * Precode codeword lengths: order is
-	 * [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]
-	 */
-	for (i = 0; i < 2; i++)		/* presym_{16,17}: len=0 */
-		ASSERT(put_bits(&os, 0, 3));
-	ASSERT(put_bits(&os, 2, 3));	/* presym_18: len=2 */
-	ASSERT(put_bits(&os, 2, 3));	/* presym_0: len=2 */
-	for (i = 0; i < 11; i++)	/* presym_{8,...,13}: len=0 */
-		ASSERT(put_bits(&os, 0, 3));
-	ASSERT(put_bits(&os, 2, 3));	/* presym_2: len=2 */
-	ASSERT(put_bits(&os, 0, 3));	/* presym_14: len=0 */
-	ASSERT(put_bits(&os, 2, 3));	/* presym_1: len=2 */
-
-	/* Litlen and offset codeword lengths */
-	ASSERT(put_bits(&os, 0x3, 2) &&	/* presym_18, 128 zeroes */
-	       put_bits(&os, 117, 7));
-	ASSERT(put_bits(&os, 0x3, 2) &&	/* presym_18, 126 zeroes */
-	       put_bits(&os, 115, 7));
-	ASSERT(put_bits(&os, 0x1, 2));	/* presym_2 */
-	ASSERT(put_bits(&os, 0x1, 2));	/* presym_2 */
-	ASSERT(put_bits(&os, 0x1, 2));	/* presym_2 */
-	ASSERT(put_bits(&os, 0x1, 2));	/* presym_2 */
-	ASSERT(put_bits(&os, 0x0, 2));	/* presym_0 */
-	ASSERT(put_bits(&os, 0x2, 2));	/* presym_1 */
-
-	/* Literals */
-	ASSERT(put_bits(&os, 0x0, 2));	/* litlensym_254 */
-	ASSERT(put_bits(&os, 0x2, 2));	/* litlensym_255 */
-
-	/* Match */
-	ASSERT(put_bits(&os, 0x3, 2));	/* litlensym_257 */
-	ASSERT(put_bits(&os, 0x0, 1));	/* offsetsym_1 */
-
-	/* End of block */
-	ASSERT(put_bits(&os, 0x1, 2));	/* litlensym_256 */
-
-	ASSERT(flush_bits(&os));
-
-	verify_decompression(in, os.next - in, out, sizeof(out),
-			     expected_out, sizeof(expected_out));
-}
-
-int
-tmain(int argc, tchar *argv[])
-{
-	begin_program(argv);
-
-	test_empty_offset_code();
-	test_singleton_litrunlen_code();
-	test_singleton_offset_code();
-	test_singleton_offset_code_notsymzero();
-
-	return 0;
-}

data/ext/deflate_ruby/libdeflate/programs/test_invalid_streams.c

@@ -1,130 +0,0 @@
-/*
- * test_invalid_streams.c
- *
- * Test that invalid DEFLATE streams are rejected with LIBDEFLATE_BAD_DATA.
- *
- * This isn't actually very important, since DEFLATE doesn't have built-in error
- * detection, so corruption of a DEFLATE stream can only be reliably detected
- * using a separate checksum anyway.  As long as the DEFLATE decompressor
- * handles all streams safely (no crashes, etc.), in practice it is fine for it
- * to automatically remap invalid streams to valid streams, instead of returning
- * an error.  Corruption detection is the responsibility of the zlib or gzip
- * layer, or the application when an external checksum is used.
- *
- * Nevertheless, to reduce surprises when people intentionally compare zlib's
- * and libdeflate's handling of invalid DEFLATE streams, libdeflate implements
- * zlib's strict behavior when decoding DEFLATE, except when it would have a
- * significant performance cost.
- */
-
-#include "test_util.h"
-
-static void
-assert_decompression_error(const u8 *in, size_t in_nbytes)
-{
-	struct libdeflate_decompressor *d;
-	z_stream z;
-	u8 out[128];
-	const size_t out_nbytes_avail = sizeof(out);
-	size_t actual_out_nbytes;
-	enum libdeflate_result res;
-
-	/* libdeflate */
-	d = libdeflate_alloc_decompressor();
-	ASSERT(d != NULL);
-	res = libdeflate_deflate_decompress(d, in, in_nbytes,
-					    out, out_nbytes_avail,
-					    &actual_out_nbytes);
-	ASSERT(res == LIBDEFLATE_BAD_DATA);
-	libdeflate_free_decompressor(d);
-
-	/* zlib, as a control */
-	memset(&z, 0, sizeof(z));
-	res = inflateInit2(&z, -15);
-	ASSERT(res == Z_OK);
-	z.next_in = (void *)in;
-	z.avail_in = in_nbytes;
-	z.next_out = (void *)out;
-	z.avail_out = out_nbytes_avail;
-	res = inflate(&z, Z_FINISH);
-	ASSERT(res == Z_DATA_ERROR);
-	inflateEnd(&z);
-}
-
-/*
- * Test that DEFLATE decompression returns an error if a block header contains
- * too many encoded litlen and offset codeword lengths.
- */
-static void
-test_too_many_codeword_lengths(void)
-{
-	u8 in[128];
-	struct output_bitstream os = { .next = in, .end = in + sizeof(in) };
-	int i;
-
-	ASSERT(put_bits(&os, 1, 1));	/* BFINAL: 1 */
-	ASSERT(put_bits(&os, 2, 2));	/* BTYPE: DYNAMIC_HUFFMAN */
-
-	/*
-	 * Litlen code:
-	 *	litlensym_255			len=1 codeword=0
-	 *	litlensym_256 (end-of-block)	len=1 codeword=1
-	 * Offset code:
-	 *	(empty)
-	 *
-	 * Litlen and offset codeword lengths:
-	 *	[0..254] = 0	presym_{18,18}
-	 *	[255]	 = 1	presym_1
-	 *	[256]	 = 1	presym_1
-	 *	[257...] = 0	presym_18 [TOO MANY]
-	 *
-	 * Precode:
-	 *	presym_1	len=1 codeword=0
-	 *	presym_18	len=1 codeword=1
-	 */
-
-	ASSERT(put_bits(&os, 0, 5));	/* num_litlen_syms: 0 + 257 */
-	ASSERT(put_bits(&os, 0, 5));	/* num_offset_syms: 0 + 1 */
-	ASSERT(put_bits(&os, 14, 4));	/* num_explicit_precode_lens: 14 + 4 */
-
-	/*
-	 * Precode codeword lengths: order is
-	 * [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]
-	 */
-	for (i = 0; i < 2; i++)		/* presym_{16,17}: len=0 */
-		ASSERT(put_bits(&os, 0, 3));
-	ASSERT(put_bits(&os, 1, 3));	/* presym_18: len=1 */
-	ASSERT(put_bits(&os, 0, 3));	/* presym_0: len=0 */
-	for (i = 0; i < 13; i++)	/* presym_{8,...,14}: len=0 */
-		ASSERT(put_bits(&os, 0, 3));
-	ASSERT(put_bits(&os, 1, 3));	/* presym_1: len=1 */
-
-	/* Litlen and offset codeword lengths */
-	ASSERT(put_bits(&os, 0x1, 1) &&	/* presym_18, 128 zeroes */
-	       put_bits(&os, 117, 7));
-	ASSERT(put_bits(&os, 0x1, 1) &&	/* presym_18, 127 zeroes */
-	       put_bits(&os, 116, 7));
-	ASSERT(put_bits(&os, 0x0, 1));	/* presym_1 */
-	ASSERT(put_bits(&os, 0x0, 1));	/* presym_1 */
-	ASSERT(put_bits(&os, 0x1, 1) &&	/* presym_18, 128 zeroes [TOO MANY] */
-	       put_bits(&os, 117, 7));
-
-	/* Literal */
-	ASSERT(put_bits(&os, 0x0, 0));	/* litlensym_255 */
-
-	/* End of block */
-	ASSERT(put_bits(&os, 0x1, 1));	/* litlensym_256 */
-
-	ASSERT(flush_bits(&os));
-
-	assert_decompression_error(in, os.next - in);
-}
-
-int
-tmain(int argc, tchar *argv[])
-{
-	begin_program(argv);
-
-	test_too_many_codeword_lengths();
-	return 0;
-}

data/ext/deflate_ruby/libdeflate/programs/test_litrunlen_overflow.c

@@ -1,72 +0,0 @@
-/*
- * test_litrunlen_overflow.c
- *
- * Regression test for commit f2f0df727444 ("deflate_compress: fix corruption
- * with long literal run").  Try to compress a file longer than 65535 bytes
- * where no 2-byte sequence (3 would be sufficient) is repeated <= 32768 bytes
- * apart, and the distribution of bytes remains constant throughout, and yet not
- * all bytes are used so the data is still slightly compressible.  There will be
- * no matches in this data, but the compressor should still output a compressed
- * block, and this block should contain more than 65535 consecutive literals,
- * which triggered the bug.
- *
- * Note: on random data, this situation is extremely unlikely if the compressor
- * uses all matches it finds, since random data will on average have a 3-byte
- * match every (256**3)/32768 = 512 bytes.
- */
-
-#include "test_util.h"
-
-int
-tmain(int argc, tchar *argv[])
-{
-	const int data_size = 2 * 250 * 251;
-	u8 *orig_data, *compressed_data, *decompressed_data;
-	int i, stride, multiple, j = 0;
-	struct libdeflate_decompressor *d;
-	static const int levels[] = { 3, 6, 12 };
-
-	begin_program(argv);
-
-	orig_data = xmalloc(data_size);
-	compressed_data = xmalloc(data_size);
-	decompressed_data = xmalloc(data_size);
-
-	for (i = 0; i < 2; i++) {
-		for (stride = 1; stride < 251; stride++) {
-			for (multiple = 0; multiple < 251; multiple++)
-				orig_data[j++] = (stride * multiple) % 251;
-		}
-	}
-	ASSERT(j == data_size);
-
-	d = libdeflate_alloc_decompressor();
-	ASSERT(d != NULL);
-
-	for (i = 0; i < ARRAY_LEN(levels); i++) {
-		struct libdeflate_compressor *c;
-		size_t csize;
-		enum libdeflate_result res;
-
-		c = libdeflate_alloc_compressor(levels[i]);
-		ASSERT(c != NULL);
-
-		csize = libdeflate_deflate_compress(c, orig_data, data_size,
-						    compressed_data, data_size);
-		ASSERT(csize > 0 && csize < data_size);
-
-		res = libdeflate_deflate_decompress(d, compressed_data, csize,
-						    decompressed_data,
-						    data_size, NULL);
-		ASSERT(res == LIBDEFLATE_SUCCESS);
-		ASSERT(memcmp(orig_data, decompressed_data, data_size) == 0);
-
-		libdeflate_free_compressor(c);
-	}
-
-	libdeflate_free_decompressor(d);
-	free(orig_data);
-	free(compressed_data);
-	free(decompressed_data);
-	return 0;
-}

data/ext/deflate_ruby/libdeflate/programs/test_overread.c

@@ -1,95 +0,0 @@
-/*
- * test_overread.c
- *
- * Test that the decompressor doesn't produce an unbounded amount of output if
- * it runs out of input, even when implicit zeroes appended to the input would
- * continue producing output (as is the case when the input ends during a
- * DYNAMIC_HUFFMAN block where a literal has an all-zeroes codeword).
- *
- * This is a regression test for commit 3f21ec9d6121 ("deflate_decompress: error
- * out if overread count gets too large").
- */
-
-#include "test_util.h"
-
-static void
-generate_test_input(struct output_bitstream *os)
-{
-	int i;
-
-	put_bits(os, 0, 1);	/* BFINAL: 0 */
-	put_bits(os, 2, 2);	/* BTYPE: DYNAMIC_HUFFMAN */
-
-	/*
-	 * Write the Huffman codes.
-	 *
-	 * Litlen code:
-	 *	litlensym_0   (0)		len=1 codeword=0
-	 *	litlensym_256 (end-of-block)	len=1 codeword=1
-	 * Offset code:
-	 *	offsetsym_0 (unused)		len=1 codeword=0
-	 *
-	 * Litlen and offset codeword lengths:
-	 *	[0]	 = 1	presym_1
-	 *	[1..255] = 0	presym_{18,18}
-	 *	[256]	 = 1	presym_1
-	 *	[257]	 = 1	presym_1
-	 *
-	 * Precode:
-	 *	presym_1	len=1 codeword=0
-	 *	presym_18	len=1 codeword=1
-	 */
-	put_bits(os, 0, 5);	/* num_litlen_syms: 0 + 257 */
-	put_bits(os, 0, 5);	/* num_offset_syms: 0 + 1 */
-	put_bits(os, 14, 4);	/* num_explicit_precode_lens: 14 + 4 */
-	/*
-	 * Precode codeword lengths: order is
-	 * [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]
-	 */
-	put_bits(os, 0, 3);		/* presym_16: len=0 */
-	put_bits(os, 0, 3);		/* presym_17: len=0 */
-	put_bits(os, 1, 3);		/* presym_18: len=1 */
-	for (i = 0; i < 14; i++)	/* presym_{0,...,14}: len=0 */
-		put_bits(os, 0, 3);
-	put_bits(os, 1, 3);		/* presym_1: len=1 */
-
-	/* Litlen and offset codeword lengths */
-	put_bits(os, 0, 1);		/* presym_1 */
-	put_bits(os, 1, 1);		/* presym_18 ... */
-	put_bits(os, 117, 7);		/* ... 11 + 117 zeroes */
-	put_bits(os, 1, 1);		/* presym_18 ... */
-	put_bits(os, 116, 7);		/* ... 11 + 116 zeroes */
-	put_bits(os, 0, 1);		/* presym_1 */
-	put_bits(os, 0, 1);		/* presym_1 */
-
-	/* Implicit zeroes would generate endless literals from here. */
-
-	ASSERT(flush_bits(os));
-}
-
-int
-tmain(int argc, tchar *argv[])
-{
-	u8 cdata[16];
-	u8 udata[256];
-	struct output_bitstream os =
-		{ .next = cdata, .end = cdata + sizeof(cdata) };
-	struct libdeflate_decompressor *d;
-	enum libdeflate_result res;
-	size_t actual_out_nbytes;
-
-	begin_program(argv);
-
-	generate_test_input(&os);
-	d = libdeflate_alloc_decompressor();
-	ASSERT(d != NULL);
-
-	res = libdeflate_deflate_decompress(d, cdata, os.next - cdata,
-					    udata, sizeof(udata),
-					    &actual_out_nbytes);
-	/* Before the fix, the result was LIBDEFLATE_INSUFFICIENT_SPACE here. */
-	ASSERT(res == LIBDEFLATE_BAD_DATA);
-
-	libdeflate_free_decompressor(d);
-	return 0;
-}