Update the code to mostly match the new simpler file format

specification. Simplify things by removing most of the
support for known uncompressed size in most places.
There are some miscellaneous changes here and there too.

The API of liblzma has got many changes and still some
more will be done soon. While most of the code has been
updated, some things are not fixed (the command line tool
will choke with invalid filter chain, if nothing else).

Subblock filter is somewhat broken for now. It will be
updated once the encoded format of the Subblock filter
has been decided.

8 files changed, 776 insertions, 1190 deletions

diff --git a/tests/Makefile.am b/tests/Makefile.am
index 3ecddf59..f9f15c54 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -39,8 +39,7 @@ check_PROGRAMS = \
 	test_stream_flags \
 	test_filter_flags \
 	test_block_header \
-	test_index \
-	test_info
+	test_index
 
 TESTS = \
 	test_memlimit \
@@ -49,8 +48,6 @@ TESTS = \
 	test_filter_flags \
 	test_block_header \
 	test_index \
-	test_info \
-	test_files.sh \
 	test_compress.sh
 
 clean-local:
diff --git a/tests/test_block_header.c b/tests/test_block_header.c
index b38f4b24..658f7fe2 100644
--- a/tests/test_block_header.c
+++ b/tests/test_block_header.c
@@ -20,204 +20,124 @@
 #include "tests.h"
 
 
-static uint8_t buffer[4096];
-static lzma_stream strm = LZMA_STREAM_INIT;
+static void
+test4(void)
+{
+	known_options = (lzma_options_block){
+		.has_crc32 = false,
+		.has_eopm = true,
+		.is_metadata = false,
+		.compressed_size = 0,
+		.uncompressed_size = 0,
+		.compressed_reserve = LZMA_VLI_BYTES_MAX,
+		.uncompressed_reserve = LZMA_VLI_BYTES_MAX,
+		.padding = 0,
+	};
+	memcpy(known_options.filters, filters_powerpc,
+			sizeof(filters_powerpc));
+	expect(!code(21));
+
+	// Reserved bits
+	buffer[0] ^= 0x40;
+	expect(!decode_ret(1, LZMA_HEADER_ERROR));
+	buffer[0] ^= 0x40;
+
+	buffer[1] ^= 0x40;
+	expect(decode_ret(21, LZMA_HEADER_ERROR));
+	buffer[1] ^= 0x40;
+
+
+}
+*/
+
+static uint8_t buf[LZMA_BLOCK_HEADER_SIZE_MAX];
 static lzma_options_block known_options;
 static lzma_options_block decoded_options;
 
-// We want to test zero, one, and two filters in the chain.
-
-static const lzma_options_filter filters_none[1] = {
+static lzma_options_filter filters_none[1] = {
 	{
 		.id = LZMA_VLI_VALUE_UNKNOWN,
-		.options = NULL,
 	},
 };
 
-static const lzma_options_filter filters_powerpc[2] = {
+
+static lzma_options_filter filters_one[2] = {
 	{
-		.id = LZMA_FILTER_POWERPC,
-		.options = NULL,
+		.id = LZMA_FILTER_LZMA,
+		.options = (void *)(&lzma_preset_lzma[0]),
 	}, {
 		.id = LZMA_VLI_VALUE_UNKNOWN,
-		.options = NULL,
-	},
+	}
 };
 
-static const lzma_options_delta options_delta = {
-	.distance = 4,
-};
 
-static const lzma_options_filter filters_delta[3] = {
+static lzma_options_filter filters_four[5] = {
 	{
-		.id = LZMA_FILTER_DELTA,
-		.options = (void *)(&options_delta),
+		.id = LZMA_FILTER_X86,
+		.options = NULL,
 	}, {
-		.id = LZMA_FILTER_COPY,
+		.id = LZMA_FILTER_X86,
 		.options = NULL,
 	}, {
-		.id = LZMA_VLI_VALUE_UNKNOWN,
+		.id = LZMA_FILTER_X86,
 		.options = NULL,
-	},
+	}, {
+		.id = LZMA_FILTER_LZMA,
+		.options = (void *)(&lzma_preset_lzma[0]),
+	}, {
+		.id = LZMA_VLI_VALUE_UNKNOWN,
+	}
 };
 
 
-static void
-free_decoded_options(void)
-{
-	for (size_t i = 0; i < sizeof(decoded_options.filters)
-			/ sizeof(decoded_options.filters[0]); ++i) {
-		free(decoded_options.filters[i].options);
-		decoded_options.filters[i].options = NULL;
+static lzma_options_filter filters_five[6] = {
+	{
+		.id = LZMA_FILTER_X86,
+		.options = NULL,
+	}, {
+		.id = LZMA_FILTER_X86,
+		.options = NULL,
+	}, {
+		.id = LZMA_FILTER_X86,
+		.options = NULL,
+	}, {
+		.id = LZMA_FILTER_X86,
+		.options = NULL,
+	}, {
+		.id = LZMA_FILTER_LZMA,
+		.options = (void *)(&lzma_preset_lzma[0]),
+	}, {
+		.id = LZMA_VLI_VALUE_UNKNOWN,
 	}
-}
-
-
-static bool
-encode(uint32_t header_size)
-{
-	memcrap(buffer, sizeof(buffer));
-
-	if (lzma_block_header_size(&known_options) != LZMA_OK)
-		return true;
-
-	if (known_options.header_size != header_size)
-		return true;
-
-	if (lzma_block_header_encode(buffer, &known_options) != LZMA_OK)
-		return true;
-
-	return false;
-}
+};
 
 
-static bool
-decode_ret(uint32_t header_size, lzma_ret ret_ok)
+static void
+code(void)
 {
-	memcrap(&decoded_options, sizeof(decoded_options));
-	decoded_options.has_crc32 = known_options.has_crc32;
+	expect(lzma_block_header_encode(&known_options, buf) == LZMA_OK);
 
-	expect(lzma_block_header_decoder(&strm, &decoded_options) == LZMA_OK);
-
-	const bool ret = decoder_loop_ret(&strm, buffer, header_size, ret_ok);
-	free_decoded_options();
-	return ret;
-}
-
-
-static bool
-decode(uint32_t header_size)
-{
+	lzma_options_filter filters[LZMA_BLOCK_FILTERS_MAX + 1];
+	memcrap(filters, sizeof(filters));
 	memcrap(&decoded_options, sizeof(decoded_options));
-	decoded_options.has_crc32 = known_options.has_crc32;
-
-	expect(lzma_block_header_decoder(&strm, &decoded_options) == LZMA_OK);
-
-	const bool ret = decoder_loop(&strm, buffer, header_size);
-	free_decoded_options();
-	if (ret)
-		return true;
-
-	if (known_options.has_eopm != decoded_options.has_eopm)
-		return true;
-
-	if (known_options.is_metadata != decoded_options.is_metadata)
-		return true;
 
-	if (known_options.compressed_size == LZMA_VLI_VALUE_UNKNOWN
-			&& known_options.compressed_reserve != 0) {
-		if (decoded_options.compressed_size != 0)
-			return true;
-	} else if (known_options.compressed_size
-			!= decoded_options.compressed_size) {
-		return true;
-	}
-
-	if (known_options.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN
-			&& known_options.uncompressed_reserve != 0) {
-		if (decoded_options.uncompressed_size != 0)
-			return true;
-	} else if (known_options.uncompressed_size
-			!= decoded_options.uncompressed_size) {
-		return true;
-	}
-
-	if (known_options.compressed_reserve != 0
-			&& known_options.compressed_reserve
-				!= decoded_options.compressed_reserve)
-		return true;
-
-	if (known_options.uncompressed_reserve != 0
-			&& known_options.uncompressed_reserve
-				!= decoded_options.uncompressed_reserve)
-		return true;
-
-	if (known_options.padding != decoded_options.padding)
-		return true;
-
-	return false;
-}
-
-
-static bool
-code(uint32_t header_size)
-{
-	return encode(header_size) || decode(header_size);
-}
-
-
-static bool
-helper_loop(uint32_t unpadded_size, uint32_t multiple)
-{
-	for (int i = 0; i <= LZMA_BLOCK_HEADER_PADDING_MAX; ++i) {
-		known_options.padding = i;
-		if (code(unpadded_size + i))
-			return true;
-	}
-
-	for (int i = 0 - LZMA_BLOCK_HEADER_PADDING_MAX - 1;
-			i <= LZMA_BLOCK_HEADER_PADDING_MAX + 1; ++i) {
-		known_options.alignment = i;
-
-		uint32_t size = unpadded_size;
-		while ((size + known_options.alignment) % multiple)
-			++size;
-
-		known_options.padding = LZMA_BLOCK_HEADER_PADDING_AUTO;
-		if (code(size))
-			return true;
-
-	} while (++known_options.alignment
-			<= LZMA_BLOCK_HEADER_PADDING_MAX + 1);
+	decoded_options.header_size = known_options.header_size;
+	decoded_options.check = known_options.check;
+	decoded_options.filters = filters;
+	expect(lzma_block_header_decode(&decoded_options, NULL, buf)
+			== LZMA_OK);
 
-	return false;
-}
+	expect(known_options.compressed_size
+			== decoded_options.compressed_size);
+	expect(known_options.uncompressed_size
+			== decoded_options.uncompressed_size);
 
+	for (size_t i = 0; known_options.filters[i].id
+			!= LZMA_VLI_VALUE_UNKNOWN; ++i)
+		expect(known_options.filters[i].id == filters[i].id);
 
-static bool
-helper(uint32_t unpadded_size, uint32_t multiple)
-{
-	known_options.has_crc32 = false;
-	known_options.is_metadata = false;
-	if (helper_loop(unpadded_size, multiple))
-		return true;
-
-	known_options.has_crc32 = false;
-	known_options.is_metadata = true;
-	if (helper_loop(unpadded_size, multiple))
-		return true;
-
-	known_options.has_crc32 = true;
-	known_options.is_metadata = false;
-	if (helper_loop(unpadded_size + 4, multiple))
-		return true;
-
-	known_options.has_crc32 = true;
-	known_options.is_metadata = true;
-	if (helper_loop(unpadded_size + 4, multiple))
-		return true;
-
-	return false;
+	for (size_t i = 0; i < LZMA_BLOCK_FILTERS_MAX; ++i)
+		free(decoded_options.filters[i].options);
 }
 
 
@@ -225,128 +145,114 @@ static void
 test1(void)
 {
 	known_options = (lzma_options_block){
-		.has_eopm = true,
+		.check = LZMA_CHECK_NONE,
 		.compressed_size = LZMA_VLI_VALUE_UNKNOWN,
 		.uncompressed_size = LZMA_VLI_VALUE_UNKNOWN,
-		.compressed_reserve = 0,
-		.uncompressed_reserve = 0,
+		.filters = NULL,
 	};
-	memcpy(known_options.filters, filters_none, sizeof(filters_none));
-	expect(!helper(2, 1));
-
-	memcpy(known_options.filters, filters_powerpc,
-			sizeof(filters_powerpc));
-	expect(!helper(3, 4));
-
-	memcpy(known_options.filters, filters_delta, sizeof(filters_delta));
-	expect(!helper(5, 1));
 
-	known_options.padding = LZMA_BLOCK_HEADER_PADDING_MAX + 1;
 	expect(lzma_block_header_size(&known_options) == LZMA_PROG_ERROR);
-}
 
+	known_options.filters = filters_none;
+	expect(lzma_block_header_size(&known_options) == LZMA_PROG_ERROR);
 
-static void
-test2_helper(uint32_t unpadded_size, uint32_t multiple)
-{
-	known_options.has_eopm = true;
-	known_options.compressed_size = LZMA_VLI_VALUE_UNKNOWN;
-	known_options.uncompressed_size = LZMA_VLI_VALUE_UNKNOWN;
-	known_options.compressed_reserve = 1;
-	known_options.uncompressed_reserve = 1;
-	expect(!helper(unpadded_size + 2, multiple));
+	known_options.filters = filters_five;
+	expect(lzma_block_header_size(&known_options) == LZMA_PROG_ERROR);
 
-	known_options.compressed_reserve = LZMA_VLI_BYTES_MAX;
-	known_options.uncompressed_reserve = LZMA_VLI_BYTES_MAX;
-	expect(!helper(unpadded_size + 18, multiple));
+	known_options.filters = filters_one;
+	expect(lzma_block_header_size(&known_options) == LZMA_OK);
 
-	known_options.compressed_size = 1234;
-	known_options.uncompressed_size = 2345;
-	expect(!helper(unpadded_size + 18, multiple));
+	known_options.check = 999; // Some invalid value, which gets ignored.
+	expect(lzma_block_header_size(&known_options) == LZMA_OK);
 
-	known_options.compressed_reserve = 1;
-	known_options.uncompressed_reserve = 1;
+	known_options.compressed_size = 5; // Not a multiple of four.
 	expect(lzma_block_header_size(&known_options) == LZMA_PROG_ERROR);
-}
 
+	known_options.compressed_size = 0; // Cannot be zero.
+	expect(lzma_block_header_size(&known_options) == LZMA_PROG_ERROR);
 
-static void
-test2(void)
-{
-	memcpy(known_options.filters, filters_none, sizeof(filters_none));
-	test2_helper(2, 1);
-
-	memcpy(known_options.filters, filters_powerpc,
-			sizeof(filters_powerpc));
-	test2_helper(3, 4);
+	known_options.compressed_size = LZMA_VLI_VALUE_UNKNOWN;
+	known_options.uncompressed_size = 0;
+	expect(lzma_block_header_size(&known_options) == LZMA_OK);
 
-	memcpy(known_options.filters, filters_delta,
-			sizeof(filters_delta));
-	test2_helper(5, 1);
+	known_options.uncompressed_size = LZMA_VLI_VALUE_MAX + 1;
+	expect(lzma_block_header_size(&known_options) == LZMA_PROG_ERROR);
 }
 
 
 static void
-test3(void)
+test2(void)
 {
 	known_options = (lzma_options_block){
-		.has_crc32 = false,
-		.has_eopm = true,
-		.is_metadata = false,
+		.check = LZMA_CHECK_CRC32,
 		.compressed_size = LZMA_VLI_VALUE_UNKNOWN,
 		.uncompressed_size = LZMA_VLI_VALUE_UNKNOWN,
-		.compressed_reserve = 1,
-		.uncompressed_reserve = 1,
+		.filters = filters_four,
 	};
-	memcpy(known_options.filters, filters_none, sizeof(filters_none));
-
-	known_options.header_size = 3;
-	expect(lzma_block_header_encode(buffer, &known_options)
-			== LZMA_PROG_ERROR);
 
-	known_options.header_size = 4;
-	expect(lzma_block_header_encode(buffer, &known_options) == LZMA_OK);
+	expect(lzma_block_header_size(&known_options) == LZMA_OK);
+	code();
 
-	known_options.header_size = 5;
-	expect(lzma_block_header_encode(buffer, &known_options)
-			== LZMA_PROG_ERROR);
+	known_options.compressed_size = 123456;
+	known_options.uncompressed_size = 234567;
+	expect(lzma_block_header_size(&known_options) == LZMA_OK);
+	code();
 
-	// NOTE: This assumes that Filter ID 0x1F is not supported. Update
-	// this test to use some other ID if 0x1F becomes supported.
-	known_options.filters[0].id = 0x1F;
-	known_options.header_size = 5;
-	expect(lzma_block_header_encode(buffer, &known_options)
-			== LZMA_HEADER_ERROR);
+	// We can make the sizes smaller while keeping the header size
+	// the same.
+	known_options.compressed_size = 12;
+	known_options.uncompressed_size = 23;
+	code();
 }
 
 
 static void
-test4(void)
+test3(void)
 {
 	known_options = (lzma_options_block){
-		.has_crc32 = false,
-		.has_eopm = true,
-		.is_metadata = false,
-		.compressed_size = 0,
-		.uncompressed_size = 0,
-		.compressed_reserve = LZMA_VLI_BYTES_MAX,
-		.uncompressed_reserve = LZMA_VLI_BYTES_MAX,
-		.padding = 0,
+		.check = LZMA_CHECK_CRC32,
+		.compressed_size = LZMA_VLI_VALUE_UNKNOWN,
+		.uncompressed_size = LZMA_VLI_VALUE_UNKNOWN,
+		.filters = filters_one,
 	};
-	memcpy(known_options.filters, filters_powerpc,
-			sizeof(filters_powerpc));
-	expect(!code(21));
 
-	// Reserved bits
-	buffer[0] ^= 0x40;
-	expect(!decode_ret(1, LZMA_HEADER_ERROR));
-	buffer[0] ^= 0x40;
+	expect(lzma_block_header_size(&known_options) == LZMA_OK);
+	known_options.header_size += 4;
+	expect(lzma_block_header_encode(&known_options, buf) == LZMA_OK);
 
-	buffer[1] ^= 0x40;
-	expect(decode_ret(21, LZMA_HEADER_ERROR));
-	buffer[1] ^= 0x40;
+	lzma_options_filter filters[LZMA_BLOCK_FILTERS_MAX + 1];
+	decoded_options.header_size = known_options.header_size;
+	decoded_options.check = known_options.check;
+	decoded_options.filters = filters;
 
+	// Wrong size
+	++buf[0];
+	expect(lzma_block_header_decode(&decoded_options, NULL, buf)
+			== LZMA_PROG_ERROR);
+	--buf[0];
+
+	// Wrong CRC32
+	buf[known_options.header_size - 1] ^= 1;
+	expect(lzma_block_header_decode(&decoded_options, NULL, buf)
+			== LZMA_DATA_ERROR);
+	buf[known_options.header_size - 1] ^= 1;
+
+	// Unsupported filter
+	// NOTE: This may need updating when new IDs become supported.
+	buf[2] ^= 0x1F;
+	integer_write_32(buf + known_options.header_size - 4,
+			lzma_crc32(buf, known_options.header_size - 4, 0));
+	expect(lzma_block_header_decode(&decoded_options, NULL, buf)
+			== LZMA_HEADER_ERROR);
+	buf[2] ^= 0x1F;
 
+	// Non-nul Padding
+	buf[known_options.header_size - 4 - 1] ^= 1;
+	integer_write_32(buf + known_options.header_size - 4,
+			lzma_crc32(buf, known_options.header_size - 4, 0));
+	expect(lzma_block_header_decode(&decoded_options, NULL, buf)
+			== LZMA_HEADER_ERROR);
+	buf[known_options.header_size - 4 - 1] ^= 1;
 }
 
 
@@ -358,9 +264,6 @@ main(void)
 	test1();
 	test2();
 	test3();
-	test4();
-
-	lzma_end(&strm);
 
 	return 0;
 }
diff --git a/tests/test_compress.sh b/tests/test_compress.sh
index 5cf21cf4..e322d385 100755
--- a/tests/test_compress.sh
+++ b/tests/test_compress.sh
@@ -25,14 +25,10 @@ if test $? != 42 ; then
 fi
 
 test_lzma() {
-	################
-	# Non-streamed #
-	################
-
 	if $LZMA -c "$@" "$FILE" > tmp_compressed; then
 		:
 	else
-		echo "Non-streamed compressing failed: $* $FILE"
+		echo "Compressing failed: $* $FILE"
 		(exit 1)
 		exit 1
 	fi
@@ -40,7 +36,7 @@ test_lzma() {
 	if $LZMA -cd tmp_compressed > tmp_uncompressed ; then
 		:
 	else
-		echo "Decoding of non-streamed file failed: $* $FILE"
+		echo "Decoding failed: $* $FILE"
 		(exit 1)
 		exit 1
 	fi
@@ -48,7 +44,7 @@ test_lzma() {
 	if cmp tmp_uncompressed "$FILE" ; then
 		:
 	else
-		echo "Decoded non-streamed file does not match the original: $* $FILE"
+		echo "Decoded file does not match the original: $* $FILE"
 		(exit 1)
 		exit 1
 	fi
@@ -56,51 +52,7 @@ test_lzma() {
 	if $LZMADEC tmp_compressed > tmp_uncompressed ; then
 		:
 	else
-		echo "Decoding of non-streamed file failed: $* $FILE"
-		(exit 1)
-		exit 1
-	fi
-
-	if cmp tmp_uncompressed "$FILE" ; then
-		:
-	else
-		echo "Decoded non-streamed file does not match the original: $* $FILE"
-		(exit 1)
-		exit 1
-	fi
-
-	############
-	# Streamed #
-	############
-
-	if $LZMA -c "$@" < "$FILE" > tmp_compressed; then
-		:
-	else
-		echo "Streamed compressing failed: $* $FILE"
-		(exit 1)
-		exit 1
-	fi
-
-	if $LZMA -cd < tmp_compressed > tmp_uncompressed ; then
-		:
-	else
-		echo "Decoding of streamed file failed: $* $FILE"
-		(exit 1)
-		exit 1
-	fi
-
-	if cmp tmp_uncompressed "$FILE" ; then
-		:
-	else
-		echo "Decoded streamed file does not match the original: $* $FILE"
-		(exit 1)
-		exit 1
-	fi
-
-	if $LZMADEC < tmp_compressed > tmp_uncompressed ; then
-		:
-	else
-		echo "Decoding of streamed file failed: $* $FILE"
+		echo "Decoding failed: $* $FILE"
 		(exit 1)
 		exit 1
 	fi
@@ -108,7 +60,7 @@ test_lzma() {
 	if cmp tmp_uncompressed "$FILE" ; then
 		:
 	else
-		echo "Decoded streamed file does not match the original: $* $FILE"
+		echo "Decoded file does not match the original: $* $FILE"
 		(exit 1)
 		exit 1
 	fi
@@ -151,7 +103,6 @@ do
 	test_lzma -4
 
 	for ARGS in \
-		--copy \
 		--subblock \
 		--subblock=size=1 \
 		--subblock=size=1,rle=1 \
@@ -170,10 +121,8 @@ do
 		--armthumb \
 		--sparc
 	do
-		test_lzma $ARGS
-		test_lzma --subblock $ARGS
-		test_lzma $ARGS --subblock
-		test_lzma --subblock $ARGS --subblock
+		test_lzma $ARGS --lzma=dict=64KiB,fb=32,mode=fast
+		test_lzma --subblock $ARGS --lzma=dict=64KiB,fb=32,mode=fast
 	done
 
 	echo
diff --git a/tests/test_filter_flags.c b/tests/test_filter_flags.c
index bab344ae..8df6da6c 100644
--- a/tests/test_filter_flags.c
+++ b/tests/test_filter_flags.c
@@ -51,14 +51,14 @@ encode(uint32_t known_size)
 
 
 static bool
-decode_ret(uint32_t known_size, lzma_ret ret_ok)
+decode_ret(uint32_t known_size, lzma_ret expected_ret)
 {
 	memcrap(&decoded_flags, sizeof(decoded_flags));
 
-	if (lzma_filter_flags_decoder(&strm, &decoded_flags) != LZMA_OK)
-		return true;
-
-	if (decoder_loop_ret(&strm, buffer, known_size, ret_ok))
+	size_t pos = 0;
+	if (lzma_filter_flags_decode(&decoded_flags, NULL,
+				buffer, &pos, known_size) != expected_ret
+			|| pos != known_size)
 		return true;
 
 	return false;
@@ -68,7 +68,7 @@ decode_ret(uint32_t known_size, lzma_ret ret_ok)
 static bool
 decode(uint32_t known_size)
 {
-	if (decode_ret(known_size, LZMA_STREAM_END))
+	if (decode_ret(known_size, LZMA_OK))
 		return true;
 
 	if (known_flags.id != decoded_flags.id)
@@ -78,49 +78,7 @@ decode(uint32_t known_size)
 }
 
 
-static void
-test_copy(void)
-{
-	// Test 1 (good)
-	known_flags.id = LZMA_FILTER_COPY;
-	known_flags.options = NULL;
-
-	expect(!encode(1));
-	expect(!decode(1));
-	expect(decoded_flags.options == NULL);
-
-	// Test 2 (invalid encoder options)
-	known_flags.options = &known_flags;
-	expect(encode(99));
-
-	// Test 3 (good but unusual Filter Flags field)
-	buffer[0] = 0xE0;
-	buffer[1] = LZMA_FILTER_COPY;
-	expect(!decode(2));
-	expect(decoded_flags.options == NULL);
-
-	// Test 4 (invalid Filter Flags field)
-	buffer[0] = 0xE1;
-	buffer[1] = LZMA_FILTER_COPY;
-	buffer[2] = 0;
-	expect(!decode_ret(3, LZMA_HEADER_ERROR));
-
-	// Test 5 (good but weird Filter Flags field)
-	buffer[0] = 0xFF;
-	buffer[1] = LZMA_FILTER_COPY;
-	buffer[2] = 0;
-	expect(!decode(3));
-	expect(decoded_flags.options == NULL);
-
-	// Test 6 (invalid Filter Flags field)
-	buffer[0] = 0xFF;
-	buffer[1] = LZMA_FILTER_COPY;
-	buffer[2] = 1;
-	buffer[3] = 0;
-	expect(!decode_ret(4, LZMA_HEADER_ERROR));
-}
-
-
+#ifdef HAVE_FILTER_SUBBLOCK
 static void
 test_subblock(void)
 {
@@ -128,16 +86,16 @@ test_subblock(void)
 	known_flags.id = LZMA_FILTER_SUBBLOCK;
 	known_flags.options = NULL;
 
-	expect(!encode(1));
-	expect(!decode(1));
+	expect(!encode(2));
+	expect(!decode(2));
 	expect(decoded_flags.options != NULL);
 	expect(((lzma_options_subblock *)(decoded_flags.options))
 			->allow_subfilters);
 
 	// Test 2
 	known_flags.options = decoded_flags.options;
-	expect(!encode(1));
-	expect(!decode(1));
+	expect(!encode(2));
+	expect(!decode(2));
 	expect(decoded_flags.options != NULL);
 	expect(((lzma_options_subblock *)(decoded_flags.options))
 			->allow_subfilters);
@@ -146,14 +104,15 @@ test_subblock(void)
 	free(known_flags.options);
 
 	// Test 3
-	buffer[0] = 0xFF;
-	buffer[1] = LZMA_FILTER_SUBBLOCK;
-	buffer[2] = 1;
-	buffer[3] = 0;
-	expect(!decode_ret(4, LZMA_HEADER_ERROR));
+	buffer[0] = LZMA_FILTER_SUBBLOCK;
+	buffer[1] = 1;
+	buffer[2] = 0;
+	expect(!decode_ret(3, LZMA_HEADER_ERROR));
 }
+#endif
 
 
+#ifdef HAVE_FILTER_SIMPLE
 static void
 test_simple(void)
 {
@@ -161,16 +120,16 @@ test_simple(void)
 	known_flags.id = LZMA_FILTER_X86;
 	known_flags.options = NULL;
 
-	expect(!encode(1));
-	expect(!decode(1));
+	expect(!encode(2));
+	expect(!decode(2));
 	expect(decoded_flags.options == NULL);
 
 	// Test 2
 	lzma_options_simple options;
 	options.start_offset = 0;
 	known_flags.options = &options;
-	expect(!encode(1));
-	expect(!decode(1));
+	expect(!encode(2));
+	expect(!decode(2));
 	expect(decoded_flags.options == NULL);
 
 	// Test 3
@@ -185,8 +144,10 @@ test_simple(void)
 
 	free(decoded);
 }
+#endif
 
 
+#ifdef HAVE_FILTER_DELTA
 static void
 test_delta(void)
 {
@@ -202,8 +163,8 @@ test_delta(void)
 
 	// Test 3
 	options.distance = LZMA_DELTA_DISTANCE_MIN;
-	expect(!encode(2));
-	expect(!decode(2));
+	expect(!encode(3));
+	expect(!decode(3));
 	expect(((lzma_options_delta *)(decoded_flags.options))
 				->distance == options.distance);
 
@@ -211,8 +172,8 @@ test_delta(void)
 
 	// Test 4
 	options.distance = LZMA_DELTA_DISTANCE_MAX;
-	expect(!encode(2));
-	expect(!decode(2));
+	expect(!encode(3));
+	expect(!decode(3));
 	expect(((lzma_options_delta *)(decoded_flags.options))
 				->distance == options.distance);
 
@@ -222,8 +183,10 @@ test_delta(void)
 	options.distance = LZMA_DELTA_DISTANCE_MAX + 1;
 	expect(encode(99));
 }
+#endif
 
 
+#ifdef HAVE_FILTER_LZMA
 static void
 validate_lzma(void)
 {
@@ -271,12 +234,13 @@ test_lzma(void)
 	expect(encode(99));
 
 	// Test 4 (brute-force test some valid dictionary sizes)
+	options.dictionary_size = LZMA_DICTIONARY_SIZE_MIN;
 	while (options.dictionary_size != LZMA_DICTIONARY_SIZE_MAX) {
 		if (++options.dictionary_size == 5000)
 			options.dictionary_size = LZMA_DICTIONARY_SIZE_MAX - 5;
 
-		expect(!encode(3));
-		expect(!decode(3));
+		expect(!encode(4));
+		expect(!decode(4));
 		validate_lzma();
 
 		free(decoded_flags.options);
@@ -287,7 +251,7 @@ test_lzma(void)
 	expect(encode(99));
 
 	// Test 6 (brute-force test lc/lp/pb)
-	options.dictionary_size = 1;
+	options.dictionary_size = LZMA_DICTIONARY_SIZE_MIN;
 	for (uint32_t lc = LZMA_LITERAL_CONTEXT_BITS_MIN;
 			lc <= LZMA_LITERAL_CONTEXT_BITS_MAX; ++lc) {
 		for (uint32_t lp = LZMA_LITERAL_POS_BITS_MIN;
@@ -298,8 +262,8 @@ test_lzma(void)
 				options.literal_pos_bits = lp;
 				options.pos_bits = pb;
 
-				expect(!encode(3));
-				expect(!decode(3));
+				expect(!encode(4));
+				expect(!decode(4));
 				validate_lzma();
 
 				free(decoded_flags.options);
@@ -307,6 +271,7 @@ test_lzma(void)
 		}
 	}
 }
+#endif
 
 
 int
@@ -314,11 +279,18 @@ main(void)
 {
 	lzma_init();
 
-	test_copy();
+#ifdef HAVE_FILTER_SUBBLOCK
 	test_subblock();
+#endif
+#ifdef HAVE_FILTER_SIMPLE
 	test_simple();
+#endif
+#ifdef HAVE_FILTER_DELTA
 	test_delta();
+#endif
+#ifdef HAVE_FILTER_LZMA
 	test_lzma();
+#endif
 
 	lzma_end(&strm);
 
diff --git a/tests/test_index.c b/tests/test_index.c
index 105abb16..8623d9ab 100644
--- a/tests/test_index.c
+++ b/tests/test_index.c
@@ -3,7 +3,7 @@
 /// \file       test_index.c
 /// \brief      Tests functions handling the lzma_index structure
 //
-//  Copyright (C) 2007 Lasse Collin
+//  Copyright (C) 2007-2008 Lasse Collin
 //
 //  This library is free software; you can redistribute it and/or
 //  modify it under the terms of the GNU Lesser General Public
@@ -20,24 +20,504 @@
 #include "tests.h"
 
 
+static lzma_index *
+create_empty(void)
+{
+	lzma_index *i = lzma_index_init(NULL, NULL);
+	expect(i != NULL);
+	return i;
+}
+
+
+static lzma_index *
+create_small(void)
+{
+	lzma_index *i = lzma_index_init(NULL, NULL);
+	expect(i != NULL);
+	expect(lzma_index_append(i, NULL, 400, 555) == LZMA_OK);
+	expect(lzma_index_append(i, NULL, 600, 777) == LZMA_OK);
+	expect(lzma_index_append(i, NULL, 800, 999) == LZMA_OK);
+	return i;
+}
+
+
+static lzma_index *
+create_big(void)
+{
+	lzma_index *i = lzma_index_init(NULL, NULL);
+	expect(i != NULL);
+
+	lzma_vli total_size = 0;
+	lzma_vli uncompressed_size = 0;
+
+	// Add pseudo-random sizes (but always the same size values).
+	const size_t count = 5555;
+	uint32_t n = 11;
+	for (size_t j = 0; j < count; ++j) {
+		n = 7019 * n + 7607;
+		const uint32_t t = (n * 3011) & ~UINT32_C(3);
+		expect(lzma_index_append(i, NULL, t, n) == LZMA_OK);
+		total_size += t;
+		uncompressed_size += n;
+	}
+
+	expect(lzma_index_count(i) == count);
+	expect(lzma_index_total_size(i) == total_size);
+	expect(lzma_index_uncompressed_size(i) == uncompressed_size);
+	expect(lzma_index_total_size(i) + lzma_index_size(i)
+				+ 2 * LZMA_STREAM_HEADER_SIZE
+			== lzma_index_stream_size(i));
+
+	return i;
+}
+
+
+static void
+test_equal(void)
+{
+	lzma_index *a = create_empty();
+	lzma_index *b = create_small();
+	lzma_index *c = create_big();
+	expect(a && b && c);
+
+	expect(lzma_index_equal(a, a));
+	expect(lzma_index_equal(b, b));
+	expect(lzma_index_equal(c, c));
+
+	expect(!lzma_index_equal(a, b));
+	expect(!lzma_index_equal(a, c));
+	expect(!lzma_index_equal(b, c));
+
+	lzma_index_end(a, NULL);
+	lzma_index_end(b, NULL);
+	lzma_index_end(c, NULL);
+}
+
+
+static void
+test_overflow(void)
+{
+	// Integer overflow tests
+	lzma_index *i = create_empty();
+
+	expect(lzma_index_append(i, NULL, LZMA_VLI_VALUE_MAX - 5, 1234)
+			== LZMA_DATA_ERROR);
+
+	// TODO
+
+	lzma_index_end(i, NULL);
+}
+
+
+static void
+test_copy(const lzma_index *i)
+{
+	lzma_index *d = lzma_index_dup(i, NULL);
+	expect(d != NULL);
+	lzma_index_end(d, NULL);
+}
+
+
+static void
+test_read(lzma_index *i)
+{
+	lzma_index_record record;
+
+	// Try twice so we see that rewinding works.
+	for (size_t j = 0; j < 2; ++j) {
+		lzma_vli total_size = 0;
+		lzma_vli uncompressed_size = 0;
+		lzma_vli stream_offset = LZMA_STREAM_HEADER_SIZE;
+		lzma_vli uncompressed_offset = 0;
+		uint32_t count = 0;
+
+		while (!lzma_index_read(i, &record)) {
+			++count;
+
+			total_size += record.total_size;
+			uncompressed_size += record.uncompressed_size;
+
+			expect(record.stream_offset == stream_offset);
+			expect(record.uncompressed_offset
+					== uncompressed_offset);
+
+			stream_offset += record.total_size;
+			uncompressed_offset += record.uncompressed_size;
+		}
+
+		expect(lzma_index_total_size(i) == total_size);
+		expect(lzma_index_uncompressed_size(i) == uncompressed_size);
+		expect(lzma_index_count(i) == count);
+
+		lzma_index_rewind(i);
+	}
+}
+
+
+static void
+test_code(lzma_index *i)
+{
+	const size_t alloc_size = 128 * 1024;
+	uint8_t *buf = malloc(alloc_size);
+	expect(buf != NULL);
+
+	// Encode
+	lzma_stream strm = LZMA_STREAM_INIT;
+	expect(lzma_index_encoder(&strm, i) == LZMA_OK);
+	const lzma_vli index_size = lzma_index_size(i);
+	succeed(coder_loop(&strm, NULL, 0, buf, index_size,
+			LZMA_STREAM_END, LZMA_RUN));
+
+	// Decode
+	lzma_index *d;
+	expect(lzma_index_decoder(&strm, &d) == LZMA_OK);
+	succeed(decoder_loop(&strm, buf, index_size));
+
+	expect(lzma_index_equal(i, d));
+
+	lzma_index_end(d, NULL);
+	lzma_end(&strm);
+
+	// Decode with hashing
+	lzma_index_hash *h = lzma_index_hash_init(NULL, NULL);
+	expect(h != NULL);
+	lzma_index_rewind(i);
+	lzma_index_record r;
+	while (!lzma_index_read(i, &r))
+		expect(lzma_index_hash_append(h, r.total_size,
+				r.uncompressed_size) == LZMA_OK);
+	size_t pos = 0;
+	while (pos < index_size - 1)
+		expect(lzma_index_hash_decode(h, buf, &pos, pos + 1)
+				== LZMA_OK);
+	expect(lzma_index_hash_decode(h, buf, &pos, pos + 1)
+			== LZMA_STREAM_END);
+
+	lzma_index_hash_end(h, NULL);
+
+	free(buf);
+}
+
+
+static void
+test_many(lzma_index *i)
+{
+	test_copy(i);
+	test_read(i);
+	test_code(i);
+}
+
+
+static void
+test_cat(void)
+{
+	lzma_index *a, *b, *c;
+
+	// Empty Indexes
+	a = create_empty();
+	b = create_empty();
+	expect(lzma_index_cat(a, b, NULL, 0) == LZMA_OK);
+	expect(lzma_index_count(a) == 0);
+	expect(lzma_index_stream_size(a) == 2 * LZMA_STREAM_HEADER_SIZE + 8);
+	expect(lzma_index_file_size(a)
+			== 2 * (2 * LZMA_STREAM_HEADER_SIZE + 8));
+
+	b = create_empty();
+	expect(lzma_index_cat(a, b, NULL, 0) == LZMA_OK);
+	expect(lzma_index_count(a) == 0);
+	expect(lzma_index_stream_size(a) == 2 * LZMA_STREAM_HEADER_SIZE + 8);
+	expect(lzma_index_file_size(a)
+			== 3 * (2 * LZMA_STREAM_HEADER_SIZE + 8));
+
+	b = create_empty();
+	c = create_empty();
+	expect(lzma_index_cat(b, c, NULL, 4) == LZMA_OK);
+	expect(lzma_index_count(b) == 0);
+	expect(lzma_index_stream_size(b) == 2 * LZMA_STREAM_HEADER_SIZE + 8);
+	expect(lzma_index_file_size(b)
+			== 2 * (2 * LZMA_STREAM_HEADER_SIZE + 8) + 4);
+
+	expect(lzma_index_cat(a, b, NULL, 8) == LZMA_OK);
+	expect(lzma_index_count(a) == 0);
+	expect(lzma_index_stream_size(a) == 2 * LZMA_STREAM_HEADER_SIZE + 8);
+	expect(lzma_index_file_size(a)
+			== 5 * (2 * LZMA_STREAM_HEADER_SIZE + 8) + 4 + 8);
+
+	lzma_index_end(a, NULL);
+
+	// Small Indexes
+	a = create_small();
+	lzma_vli stream_size = lzma_index_stream_size(a);
+	b = create_small();
+	expect(lzma_index_cat(a, b, NULL, 4) == LZMA_OK);
+	expect(lzma_index_file_size(a) == stream_size * 2 + 4);
+	expect(lzma_index_stream_size(a) > stream_size);
+	expect(lzma_index_stream_size(a) < stream_size * 2);
+
+	b = create_small();
+	c = create_small();
+	expect(lzma_index_cat(b, c, NULL, 8) == LZMA_OK);
+	expect(lzma_index_cat(a, b, NULL, 12) == LZMA_OK);
+	expect(lzma_index_file_size(a) == stream_size * 4 + 4 + 8 + 12);
+
+	lzma_index_end(a, NULL);
+
+	// Big Indexes
+	a = create_big();
+	stream_size = lzma_index_stream_size(a);
+	b = create_big();
+	expect(lzma_index_cat(a, b, NULL, 4) == LZMA_OK);
+	expect(lzma_index_file_size(a) == stream_size * 2 + 4);
+	expect(lzma_index_stream_size(a) > stream_size);
+	expect(lzma_index_stream_size(a) < stream_size * 2);
+
+	b = create_big();
+	c = create_big();
+	expect(lzma_index_cat(b, c, NULL, 8) == LZMA_OK);
+	expect(lzma_index_cat(a, b, NULL, 12) == LZMA_OK);
+	expect(lzma_index_file_size(a) == stream_size * 4 + 4 + 8 + 12);
+
+	lzma_index_end(a, NULL);
+}
+
+
+static void
+test_locate(void)
+{
+	lzma_index_record r;
+	lzma_index *i = lzma_index_init(NULL, NULL);
+	expect(i != NULL);
+
+	// Cannot locate anything from an empty Index.
+	expect(lzma_index_locate(i, &r, 0));
+	expect(lzma_index_locate(i, &r, 555));
+
+	// One empty Record: nothing is found since there's no uncompressed
+	// data.
+	expect(lzma_index_append(i, NULL, 16, 0) == LZMA_OK);
+	expect(lzma_index_locate(i, &r, 0));
+
+	// Non-empty Record and we can find something.
+	expect(lzma_index_append(i, NULL, 32, 5) == LZMA_OK);
+	expect(!lzma_index_locate(i, &r, 0));
+	expect(r.total_size == 32);
+	expect(r.uncompressed_size == 5);
+	expect(r.stream_offset = LZMA_STREAM_HEADER_SIZE + 16);
+	expect(r.uncompressed_offset == 0);
+
+	// Still cannot find anything past the end.
+	expect(lzma_index_locate(i, &r, 5));
+
+	// Add the third Record.
+	expect(lzma_index_append(i, NULL, 40, 11) == LZMA_OK);
+
+	expect(!lzma_index_locate(i, &r, 0));
+	expect(r.total_size == 32);
+	expect(r.uncompressed_size == 5);
+	expect(r.stream_offset = LZMA_STREAM_HEADER_SIZE + 16);
+	expect(r.uncompressed_offset == 0);
+
+	expect(!lzma_index_read(i, &r));
+	expect(r.total_size == 40);
+	expect(r.uncompressed_size == 11);
+	expect(r.stream_offset = LZMA_STREAM_HEADER_SIZE + 16 + 32);
+	expect(r.uncompressed_offset == 5);
+
+	expect(!lzma_index_locate(i, &r, 2));
+	expect(r.total_size == 32);
+	expect(r.uncompressed_size == 5);
+	expect(r.stream_offset = LZMA_STREAM_HEADER_SIZE + 16);
+	expect(r.uncompressed_offset == 0);
+
+	expect(!lzma_index_locate(i, &r, 5));
+	expect(r.total_size == 40);
+	expect(r.uncompressed_size == 11);
+	expect(r.stream_offset = LZMA_STREAM_HEADER_SIZE + 16 + 32);
+	expect(r.uncompressed_offset == 5);
+
+	expect(!lzma_index_locate(i, &r, 5 + 11 - 1));
+	expect(r.total_size == 40);
+	expect(r.uncompressed_size == 11);
+	expect(r.stream_offset = LZMA_STREAM_HEADER_SIZE + 16 + 32);
+	expect(r.uncompressed_offset == 5);
+
+	expect(lzma_index_locate(i, &r, 5 + 11));
+	expect(lzma_index_locate(i, &r, 5 + 15));
+
+	// Large Index
+	i = lzma_index_init(i, NULL);
+	expect(i != NULL);
+
+	for (size_t n = 4; n <= 4 * 5555; n += 4)
+		expect(lzma_index_append(i, NULL, n + 8, n) == LZMA_OK);
+
+	expect(lzma_index_count(i) == 5555);
+
+	// First Record
+	expect(!lzma_index_locate(i, &r, 0));
+	expect(r.total_size == 4 + 8);
+	expect(r.uncompressed_size == 4);
+	expect(r.stream_offset = LZMA_STREAM_HEADER_SIZE);
+	expect(r.uncompressed_offset == 0);
+
+	expect(!lzma_index_locate(i, &r, 3));
+	expect(r.total_size == 4 + 8);
+	expect(r.uncompressed_size == 4);
+	expect(r.stream_offset = LZMA_STREAM_HEADER_SIZE);
+	expect(r.uncompressed_offset == 0);
+
+	// Second Record
+	expect(!lzma_index_locate(i, &r, 4));
+	expect(r.total_size == 2 * 4 + 8);
+	expect(r.uncompressed_size == 2 * 4);
+	expect(r.stream_offset = LZMA_STREAM_HEADER_SIZE + 4 + 8);
+	expect(r.uncompressed_offset == 4);
+
+	// Last Record
+	expect(!lzma_index_locate(i, &r, lzma_index_uncompressed_size(i) - 1));
+	expect(r.total_size == 4 * 5555 + 8);
+	expect(r.uncompressed_size == 4 * 5555);
+	expect(r.stream_offset = lzma_index_total_size(i)
+			+ LZMA_STREAM_HEADER_SIZE - 4 * 5555 - 8);
+	expect(r.uncompressed_offset
+			== lzma_index_uncompressed_size(i) - 4 * 5555);
+
+	// Allocation chunk boundaries. See INDEX_GROUP_SIZE in
+	// liblzma/common/index.c.
+	const size_t group_multiple = 256 * 4;
+	const size_t radius = 8;
+	const size_t start = group_multiple - radius;
+	lzma_vli ubase = 0;
+	lzma_vli tbase = 0;
+	size_t n;
+	for (n = 1; n < start; ++n) {
+		ubase += n * 4;
+		tbase += n * 4 + 8;
+	}
+
+	while (n < start + 2 * radius) {
+		expect(!lzma_index_locate(i, &r, ubase + n * 4));
+
+		expect(r.stream_offset == tbase + n * 4 + 8
+				+ LZMA_STREAM_HEADER_SIZE);
+		expect(r.uncompressed_offset == ubase + n * 4);
+
+		tbase += n * 4 + 8;
+		ubase += n * 4;
+		++n;
+
+		expect(r.total_size == n * 4 + 8);
+		expect(r.uncompressed_size == n * 4);
+	}
+
+	// Do it also backwards since lzma_index_locate() uses relative search.
+	while (n > start) {
+		expect(!lzma_index_locate(i, &r, ubase + (n - 1) * 4));
+
+		expect(r.total_size == n * 4 + 8);
+		expect(r.uncompressed_size == n * 4);
+
+		--n;
+		tbase -= n * 4 + 8;
+		ubase -= n * 4;
+
+		expect(r.stream_offset == tbase + n * 4 + 8
+				+ LZMA_STREAM_HEADER_SIZE);
+		expect(r.uncompressed_offset == ubase + n * 4);
+	}
+
+	// Test locating in concatend Index.
+	i = lzma_index_init(i, NULL);
+	expect(i != NULL);
+	for (n = 0; n < group_multiple; ++n)
+		expect(lzma_index_append(i, NULL, 8, 0) == LZMA_OK);
+	expect(lzma_index_append(i, NULL, 16, 1) == LZMA_OK);
+	expect(!lzma_index_locate(i, &r, 0));
+	expect(r.total_size == 16);
+	expect(r.uncompressed_size == 1);
+	expect(r.stream_offset
+			== LZMA_STREAM_HEADER_SIZE + group_multiple * 8);
+	expect(r.uncompressed_offset == 0);
+
+	lzma_index_end(i, NULL);
+}
+
+
+static void
+test_corrupt(void)
+{
+	const size_t alloc_size = 128 * 1024;
+	uint8_t *buf = malloc(alloc_size);
+	expect(buf != NULL);
+	lzma_stream strm = LZMA_STREAM_INIT;
+
+	lzma_index *i = create_empty();
+	expect(lzma_index_append(i, NULL, 7, 1) == LZMA_OK);
+	expect(lzma_index_encoder(&strm, i) == LZMA_OK);
+	succeed(coder_loop(&strm, NULL, 0, buf, 2, LZMA_PROG_ERROR, LZMA_RUN));
+	lzma_index_end(i, NULL);
+
+	i = create_empty();
+	expect(lzma_index_append(i, NULL, 0, 1) == LZMA_OK);
+	expect(lzma_index_encoder(&strm, i) == LZMA_OK);
+	succeed(coder_loop(&strm, NULL, 0, buf, 2, LZMA_PROG_ERROR, LZMA_RUN));
+	lzma_index_end(i, NULL);
+
+	// Create a valid Index and corrupt it in different ways.
+	i = create_small();
+	expect(lzma_index_encoder(&strm, i) == LZMA_OK);
+	succeed(coder_loop(&strm, NULL, 0, buf, 20,
+			LZMA_STREAM_END, LZMA_RUN));
+	lzma_index_end(i, NULL);
+
+	// Wrong Index Indicator
+	buf[0] ^= 1;
+	expect(lzma_index_decoder(&strm, &i) == LZMA_OK);
+	succeed(decoder_loop_ret(&strm, buf, 1, LZMA_DATA_ERROR));
+	buf[0] ^= 1;
+
+	// Wrong Number of Records and thus CRC32 fails.
+	--buf[1];
+	expect(lzma_index_decoder(&strm, &i) == LZMA_OK);
+	succeed(decoder_loop_ret(&strm, buf, 10, LZMA_DATA_ERROR));
+	++buf[1];
+
+	// Padding not NULs
+	buf[15] ^= 1;
+	expect(lzma_index_decoder(&strm, &i) == LZMA_OK);
+	succeed(decoder_loop_ret(&strm, buf, 16, LZMA_DATA_ERROR));
+
+	lzma_end(&strm);
+	free(buf);
+}
+
+
 int
 main(void)
 {
-	lzma_index my_index[3] = {
-		{ 22, 33, my_index + 1 },
-		{ 44, 55, my_index + 2 },
-		{ 66, 77, NULL },
-	};
+	lzma_init();
 
-	lzma_index *i = lzma_index_dup(my_index, NULL);
-	expect(i != NULL);
+	test_equal();
+
+	test_overflow();
+
+	lzma_index *i = create_empty();
+	test_many(i);
+	lzma_index_end(i, NULL);
+
+	i = create_small();
+	test_many(i);
+	lzma_index_end(i, NULL);
+
+	i = create_big();
+	test_many(i);
+	lzma_index_end(i, NULL);
 
-	expect(lzma_index_is_equal(my_index, i));
+	test_cat();
 
-	i->next->next->uncompressed_size = 99;
-	expect(!lzma_index_is_equal(my_index, i));
+	test_locate();
 
-	lzma_index_free(i, NULL);
+	test_corrupt();
 
 	return 0;
 }
diff --git a/tests/test_info.c b/tests/test_info.c
deleted file mode 100644
index 0de95431..00000000
--- a/tests/test_info.c
+++ /dev/null
@@ -1,717 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       test_info.c
-/// \brief      Tests functions handling the lzma_info structure
-//
-//  Copyright (C) 2007 Lasse Collin
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "tests.h"
-
-
-static lzma_info *info = NULL;
-static lzma_info_iter iter;
-
-static lzma_vli stream_start = 0;
-static lzma_vli header_metadata_size = LZMA_VLI_VALUE_UNKNOWN;
-static lzma_vli total_size = LZMA_VLI_VALUE_UNKNOWN;
-static lzma_vli uncompressed_size = LZMA_VLI_VALUE_UNKNOWN;
-static lzma_vli footer_metadata_size = LZMA_VLI_VALUE_UNKNOWN;
-
-static lzma_index my_index[3] = {
-	{ 22, 33, my_index + 1 },
-	{ 44, 55, my_index + 2 },
-	{ 66, 77, NULL },
-};
-
-static lzma_metadata my_metadata = {
-	.header_metadata_size = 11,
-	.total_size = 22 + 44 + 66,
-	.uncompressed_size = 33 + 55 + 77,
-	.index = my_index,
-	.extra = NULL,
-};
-
-
-static void
-reset(void)
-{
-	expect(lzma_info_init(info, NULL) == info);
-	stream_start = 0;
-	header_metadata_size = LZMA_VLI_VALUE_UNKNOWN;
-	total_size = LZMA_VLI_VALUE_UNKNOWN;
-	uncompressed_size = LZMA_VLI_VALUE_UNKNOWN;
-	footer_metadata_size = LZMA_VLI_VALUE_UNKNOWN;
-}
-
-
-static void
-validate(void)
-{
-	expect(lzma_info_size_get(info, LZMA_INFO_STREAM_START)
-			== stream_start);
-	expect(lzma_info_size_get(info, LZMA_INFO_HEADER_METADATA)
-			== header_metadata_size);
-	expect(lzma_info_size_get(info, LZMA_INFO_TOTAL) == total_size);
-	expect(lzma_info_size_get(info, LZMA_INFO_UNCOMPRESSED)
-			== uncompressed_size);
-	expect(lzma_info_size_get(info, LZMA_INFO_FOOTER_METADATA)
-			== footer_metadata_size);
-}
-
-
-static void
-test1(void)
-{
-	// Basics
-	expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START,
-			stream_start = 1234) == LZMA_OK);
-	validate();
-	expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA,
-			header_metadata_size = 2345) == LZMA_OK);
-	validate();
-	expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, total_size = 3456)
-			== LZMA_OK);
-	validate();
-	expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED,
-			uncompressed_size = 4567) == LZMA_OK);
-	validate();
-	expect(lzma_info_size_set(info, LZMA_INFO_FOOTER_METADATA,
-			footer_metadata_size = 5432) == LZMA_OK);
-	validate();
-
-	// Not everything allow zero size
-	reset();
-	expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START,
-			stream_start = 0) == LZMA_OK);
-	expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA,
-			header_metadata_size = 0) == LZMA_OK);
-	expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED,
-			uncompressed_size = 0) == LZMA_OK);
-	validate();
-
-	reset();
-	expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, 0)
-			== LZMA_PROG_ERROR);
-
-	reset();
-	expect(lzma_info_size_set(info, LZMA_INFO_FOOTER_METADATA, 0)
-			== LZMA_PROG_ERROR);
-
-	// Invalid sizes
-	reset();
-	expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START,
-			LZMA_VLI_VALUE_MAX + 1) == LZMA_PROG_ERROR);
-	reset();
-	expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA,
-			LZMA_VLI_VALUE_MAX + 1) == LZMA_PROG_ERROR);
-	reset();
-	expect(lzma_info_size_set(info, LZMA_INFO_TOTAL,
-			LZMA_VLI_VALUE_MAX + 1) == LZMA_PROG_ERROR);
-	reset();
-	expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED,
-			LZMA_VLI_VALUE_MAX + 1) == LZMA_PROG_ERROR);
-	reset();
-	expect(lzma_info_size_set(info, LZMA_INFO_FOOTER_METADATA,
-			LZMA_VLI_VALUE_MAX + 1) == LZMA_PROG_ERROR);
-
-	reset();
-}
-
-
-static bool
-test2_helper(lzma_vli *num, lzma_info_size type)
-{
-	expect(lzma_info_size_set(info, type, *num = 1234) == LZMA_OK);
-	validate();
-	const bool ret = lzma_info_size_set(info, type, 4321) != LZMA_OK;
-	reset();
-	return ret;
-}
-
-
-static void
-test2(void)
-{
-	// Excluding start offset of Stream, once a size has been set,
-	// trying to set some other known value fails.
-	expect(!test2_helper(&stream_start, LZMA_INFO_STREAM_START));
-	expect(test2_helper(&header_metadata_size, LZMA_INFO_HEADER_METADATA));
-	expect(test2_helper(&total_size, LZMA_INFO_TOTAL));
-	expect(test2_helper(&uncompressed_size, LZMA_INFO_UNCOMPRESSED));
-	expect(test2_helper(&footer_metadata_size, LZMA_INFO_FOOTER_METADATA));
-}
-
-
-static void
-test3_init(void)
-{
-	reset();
-	lzma_info_iter_begin(info, &iter);
-	expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
-}
-
-
-static void
-test3(void)
-{
-	// Setting the same sizes multiple times for the same Index Record
-	// is OK, but the values must always be the same.
-	test3_init();
-	expect(lzma_info_index_count_get(info) == 1);
-	expect(lzma_info_iter_set(&iter, 1234, 2345) == LZMA_OK);
-	expect(lzma_info_index_count_get(info) == 1);
-	expect(lzma_info_iter_set(&iter, 1234, 2345) == LZMA_OK);
-	expect(lzma_info_index_count_get(info) == 1);
-	expect(lzma_info_iter_set(&iter, 1111, 2345) == LZMA_DATA_ERROR);
-
-	// Cannot finish an empty Index.
-	test3_init();
-	expect(lzma_info_index_finish(info) == LZMA_DATA_ERROR);
-
-	test3_init();
-	expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
-	expect(lzma_info_index_count_get(info) == 2);
-	expect(lzma_info_iter_set(&iter, 1234, 2345) == LZMA_OK);
-	expect(lzma_info_index_count_get(info) == 2);
-	expect(lzma_info_index_finish(info) == LZMA_DATA_ERROR);
-
-	test3_init();
-	expect(lzma_info_iter_set(&iter, 1234, 2345) == LZMA_OK);
-	expect(lzma_info_index_count_get(info) == 1);
-	expect(lzma_info_index_finish(info) == LZMA_OK);
-	expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, 1234) == LZMA_OK);
-	expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED, 2345)
-			== LZMA_OK);
-	expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, 1111)
-			== LZMA_DATA_ERROR);
-
-	test3_init();
-	expect(lzma_info_iter_set(&iter, 1234, 2345) == LZMA_OK);
-	expect(lzma_info_index_count_get(info) == 1);
-	expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
-	expect(lzma_info_index_count_get(info) == 2);
-	expect(lzma_info_iter_set(&iter, 4321, 5432) == LZMA_OK);
-	expect(lzma_info_index_count_get(info) == 2);
-	expect(lzma_info_index_finish(info) == LZMA_OK);
-	expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, 1234 + 4321)
-			== LZMA_OK);
-	expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED, 2345 + 5432)
-			== LZMA_OK);
-	expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED, 1111)
-			== LZMA_DATA_ERROR);
-
-	test3_init();
-	expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, 1234 + 4321)
-			== LZMA_OK);
-	expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED, 2345 + 5432)
-			== LZMA_OK);
-	expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED, 1111)
-			== LZMA_DATA_ERROR);
-	expect(lzma_info_iter_set(&iter, 1234, 2345) == LZMA_OK);
-	expect(lzma_info_index_count_get(info) == 1);
-	expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
-	expect(lzma_info_index_count_get(info) == 2);
-	expect(lzma_info_iter_set(&iter, 4321, 5432) == LZMA_OK);
-	expect(lzma_info_index_count_get(info) == 2);
-	expect(lzma_info_index_finish(info) == LZMA_OK);
-
-	test3_init();
-	expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, 1000) == LZMA_OK);
-	expect(lzma_info_iter_set(&iter, 1001, 2001) == LZMA_DATA_ERROR);
-
-	test3_init();
-	expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED, 2000)
-			== LZMA_OK);
-	expect(lzma_info_iter_set(&iter, 1001, 2001) == LZMA_DATA_ERROR);
-
-	reset();
-}
-
-
-static void
-test4(void)
-{
-	// 4a
-	lzma_info_iter_begin(info, &iter);
-	expect(lzma_info_index_count_get(info) == 0);
-
-	expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
-	expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
-	expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
-	expect(iter.stream_offset == LZMA_VLI_VALUE_UNKNOWN);
-	expect(iter.uncompressed_offset == 0);
-	expect(lzma_info_index_count_get(info) == 1);
-
-	expect(lzma_info_iter_set(&iter, 22, 33) == LZMA_OK);
-	expect(iter.total_size == 22);
-	expect(iter.uncompressed_size == 33);
-	expect(iter.stream_offset == LZMA_VLI_VALUE_UNKNOWN);
-	expect(iter.uncompressed_offset == 0);
-	expect(lzma_info_index_count_get(info) == 1);
-
-	expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
-	expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
-	expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
-	expect(iter.stream_offset == LZMA_VLI_VALUE_UNKNOWN);
-	expect(iter.uncompressed_offset == 33);
-
-	// 4b
-	reset();
-	lzma_info_iter_begin(info, &iter);
-	expect(lzma_info_index_count_get(info) == 0);
-	expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START, 5) == LZMA_OK);
-	expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA, 11)
-			== LZMA_OK);
-
-	expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
-	expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
-	expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
-	expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11);
-	expect(iter.uncompressed_offset == 0);
-	expect(lzma_info_index_count_get(info) == 1);
-
-	expect(lzma_info_iter_set(&iter, 22, 33) == LZMA_OK);
-	expect(iter.total_size == 22);
-	expect(iter.uncompressed_size == 33);
-	expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11);
-	expect(iter.uncompressed_offset == 0);
-	expect(lzma_info_index_count_get(info) == 1);
-
-	expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
-	expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
-	expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
-	expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11 + 22);
-	expect(iter.uncompressed_offset == 33);
-	expect(lzma_info_index_count_get(info) == 2);
-
-	expect(lzma_info_iter_set(&iter, 44, 55) == LZMA_OK);
-	expect(iter.total_size == 44);
-	expect(iter.uncompressed_size == 55);
-	expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11 + 22);
-	expect(iter.uncompressed_offset == 33);
-	expect(lzma_info_index_count_get(info) == 2);
-
-	expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
-	expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
-	expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
-	expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
-			+ 11 + 22 + 44);
-	expect(iter.uncompressed_offset == 33 + 55);
-	expect(lzma_info_index_count_get(info) == 3);
-
-	expect(lzma_info_iter_set(&iter, 66, 77) == LZMA_OK);
-	expect(iter.total_size == 66);
-	expect(iter.uncompressed_size == 77);
-	expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
-			+ 11 + 22 + 44);
-	expect(iter.uncompressed_offset == 33 + 55);
-	expect(lzma_info_index_count_get(info) == 3);
-
-	expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
-	expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
-	expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
-	expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
-			+ 11 + 22 + 44 + 66);
-	expect(iter.uncompressed_offset == 33 + 55 + 77);
-	expect(lzma_info_index_count_get(info) == 4);
-
-	expect(lzma_info_iter_set(&iter, 88, 99) == LZMA_OK);
-	expect(iter.total_size == 88);
-	expect(iter.uncompressed_size == 99);
-	expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
-			+ 11 + 22 + 44 + 66);
-	expect(iter.uncompressed_offset == 33 + 55 + 77);
-	expect(lzma_info_index_count_get(info) == 4);
-
-	// 4c (continues from 4b)
-	lzma_info_iter_begin(info, &iter);
-	expect(lzma_info_index_count_get(info) == 4);
-
-	expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
-	expect(iter.total_size == 22);
-	expect(iter.uncompressed_size == 33);
-	expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11);
-	expect(iter.uncompressed_offset == 0);
-	expect(lzma_info_index_count_get(info) == 4);
-
-	expect(lzma_info_iter_set(&iter, 22, LZMA_VLI_VALUE_UNKNOWN)
-			== LZMA_OK);
-	expect(iter.total_size == 22);
-	expect(iter.uncompressed_size == 33);
-	expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11);
-	expect(iter.uncompressed_offset == 0);
-	expect(lzma_info_index_count_get(info) == 4);
-
-	expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
-	expect(iter.total_size == 44);
-	expect(iter.uncompressed_size == 55);
-	expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11 + 22);
-	expect(iter.uncompressed_offset == 33);
-	expect(lzma_info_index_count_get(info) == 4);
-
-	expect(lzma_info_iter_set(&iter, LZMA_VLI_VALUE_UNKNOWN, 55)
-			== LZMA_OK);
-	expect(iter.total_size == 44);
-	expect(iter.uncompressed_size == 55);
-	expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11 + 22);
-	expect(iter.uncompressed_offset == 33);
-	expect(lzma_info_index_count_get(info) == 4);
-
-	expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
-	expect(iter.total_size == 66);
-	expect(iter.uncompressed_size == 77);
-	expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
-			+ 11 + 22 + 44);
-	expect(iter.uncompressed_offset == 33 + 55);
-	expect(lzma_info_index_count_get(info) == 4);
-
-	expect(lzma_info_iter_set(&iter, LZMA_VLI_VALUE_UNKNOWN,
-			LZMA_VLI_VALUE_UNKNOWN) == LZMA_OK);
-	expect(iter.total_size == 66);
-	expect(iter.uncompressed_size == 77);
-	expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
-			+ 11 + 22 + 44);
-	expect(iter.uncompressed_offset == 33 + 55);
-	expect(lzma_info_index_count_get(info) == 4);
-
-	expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
-	expect(iter.total_size == 88);
-	expect(iter.uncompressed_size == 99);
-	expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
-			+ 11 + 22 + 44 + 66);
-	expect(iter.uncompressed_offset == 33 + 55 + 77);
-	expect(lzma_info_index_count_get(info) == 4);
-
-	expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
-	expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
-	expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
-	expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
-			+ 11 + 22 + 44 + 66 + 88);
-	expect(iter.uncompressed_offset == 33 + 55 + 77 + 99);
-	expect(lzma_info_index_count_get(info) == 5);
-
-	expect(lzma_info_iter_set(&iter, 1234, LZMA_VLI_VALUE_UNKNOWN)
-			== LZMA_OK);
-	expect(iter.total_size == 1234);
-	expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
-	expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
-			+ 11 + 22 + 44 + 66 + 88);
-	expect(iter.uncompressed_offset == 33 + 55 + 77 + 99);
-	expect(lzma_info_index_count_get(info) == 5);
-
-	// Test 4d (continues from 4c)
-	lzma_info_iter_begin(info, &iter);
-	for (size_t i = 0; i < 4; ++i)
-		expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
-	expect(lzma_info_iter_set(&iter, 88, 99) == LZMA_OK);
-	expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
-	expect(iter.total_size == 1234);
-	expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
-	expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
-			+ 11 + 22 + 44 + 66 + 88);
-	expect(iter.uncompressed_offset == 33 + 55 + 77 + 99);
-	expect(lzma_info_index_count_get(info) == 5);
-
-	expect(lzma_info_iter_set(&iter, LZMA_VLI_VALUE_UNKNOWN, 4321)
-			== LZMA_OK);
-	expect(iter.total_size == 1234);
-	expect(iter.uncompressed_size == 4321);
-	expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
-			+ 11 + 22 + 44 + 66 + 88);
-	expect(iter.uncompressed_offset == 33 + 55 + 77 + 99);
-	expect(lzma_info_index_count_get(info) == 5);
-
-	expect(lzma_info_index_finish(info) == LZMA_OK);
-	expect(lzma_info_index_count_get(info) == 5);
-
-	// Test 4e (continues from 4d)
-	lzma_info_iter_begin(info, &iter);
-	for (size_t i = 0; i < 5; ++i)
-		expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
-	expect(lzma_info_iter_set(&iter, 1234, 4321) == LZMA_OK);
-	expect(lzma_info_iter_next(&iter, NULL) == LZMA_DATA_ERROR);
-
-	reset();
-}
-
-
-static void
-test5(void)
-{
-	lzma_index *i;
-
-	expect(lzma_info_index_set(info, NULL, NULL, true)
-			== LZMA_PROG_ERROR);
-
-	reset();
-	expect(lzma_info_index_set(info, NULL, my_index, false) == LZMA_OK);
-	i = lzma_index_dup(my_index, NULL);
-	expect(i != NULL);
-	i->next->uncompressed_size = 99;
-	expect(lzma_info_index_set(info, NULL, i, true) == LZMA_DATA_ERROR);
-
-	reset();
-	expect(lzma_info_index_set(info, NULL, my_index, false) == LZMA_OK);
-	i = lzma_index_dup(my_index, NULL);
-	expect(i != NULL);
-	lzma_index_free(i->next->next, NULL);
-	i->next->next = NULL;
-	expect(lzma_info_index_set(info, NULL, i, true) == LZMA_DATA_ERROR);
-
-	reset();
-	expect(lzma_info_index_set(info, NULL, my_index, false) == LZMA_OK);
-	i = lzma_index_dup(my_index, NULL);
-	expect(i != NULL);
-	lzma_index_free(i->next->next, NULL);
-	i->next->next = lzma_index_dup(my_index, NULL);
-	expect(i->next->next != NULL);
-	expect(lzma_info_index_set(info, NULL, i, true) == LZMA_DATA_ERROR);
-
-	reset();
-	expect(lzma_info_size_set(info, LZMA_INFO_TOTAL,
-			total_size = 22 + 44 + 66) == LZMA_OK);
-	expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED,
-			uncompressed_size = 33 + 55 + 77) == LZMA_OK);
-	validate();
-	expect(lzma_info_index_set(info, NULL, my_index, false) == LZMA_OK);
-	validate();
-
-	reset();
-	expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, total_size = 77)
-			== LZMA_OK);
-	expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED,
-			uncompressed_size = 33 + 55 + 77) == LZMA_OK);
-	validate();
-	expect(lzma_info_index_set(info, NULL, my_index, false)
-			== LZMA_DATA_ERROR);
-
-	reset();
-	expect(lzma_info_size_set(info, LZMA_INFO_TOTAL,
-			total_size = 22 + 44 + 66) == LZMA_OK);
-	expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED,
-			uncompressed_size = 777777) == LZMA_OK);
-	validate();
-	expect(lzma_info_index_set(info, NULL, my_index, false)
-			== LZMA_DATA_ERROR);
-
-	reset();
-}
-
-
-static void
-test6(void)
-{
-	lzma_metadata metadata;
-
-	// Same complete Metadata in both Header and Footer
-	expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA,
-			my_metadata.header_metadata_size) == LZMA_OK);
-	expect(lzma_info_metadata_set(info, NULL, &my_metadata, true, false)
-			== LZMA_OK);
-	expect(lzma_info_metadata_set(info, NULL, &my_metadata, false, false)
-			== LZMA_OK);
-
-	// Header Metadata is not present but Size of Header Metadata is
-	// still present in Footer.
-	reset();
-	metadata = my_metadata;
-	metadata.header_metadata_size = 0;
-	expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA, 0)
-			== LZMA_OK);
-	expect(lzma_info_metadata_set(info, NULL, &metadata, true, false)
-			== LZMA_OK);
-	expect(lzma_info_metadata_set(info, NULL, &my_metadata, false, false)
-			== LZMA_DATA_ERROR);
-
-	// Header Metadata is present but Size of Header Metadata is missing
-	// from Footer.
-	reset();
-	metadata = my_metadata;
-	metadata.header_metadata_size = 0;
-	expect(lzma_info_metadata_set(info, NULL, &my_metadata, true, false)
-			== LZMA_OK);
-	expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA,
-			my_metadata.header_metadata_size) == LZMA_OK);
-	expect(lzma_info_metadata_set(info, NULL, &metadata, false, false)
-			== LZMA_DATA_ERROR);
-
-	// Index missing
-	reset();
-	metadata = my_metadata;
-	metadata.index = NULL;
-	expect(lzma_info_metadata_set(info, NULL, &metadata, true, false)
-			== LZMA_OK);
-	expect(lzma_info_metadata_set(info, NULL, &metadata, false, false)
-			== LZMA_DATA_ERROR);
-
-	// Index in Header Metadata but not in Footer Metadata
-	reset();
-	expect(lzma_info_metadata_set(info, NULL, &my_metadata, true, false)
-			== LZMA_OK);
-	expect(lzma_info_metadata_set(info, NULL, &metadata, false, false)
-			== LZMA_OK);
-
-	// Index in Header Metadata but not in Footer Metadata but
-	// Total Size is missing from Footer.
-	reset();
-	metadata.total_size = LZMA_VLI_VALUE_UNKNOWN;
-	expect(lzma_info_metadata_set(info, NULL, &my_metadata, true, false)
-			== LZMA_OK);
-	expect(lzma_info_metadata_set(info, NULL, &metadata, false, false)
-			== LZMA_DATA_ERROR);
-
-	// Total Size doesn't match the Index
-	reset();
-	metadata = my_metadata;
-	metadata.total_size = 9999;
-	expect(lzma_info_metadata_set(info, NULL, &metadata, true, false)
-			== LZMA_DATA_ERROR);
-
-	// Uncompressed Size doesn't match the Index
-	reset();
-	metadata = my_metadata;
-	metadata.uncompressed_size = 9999;
-	expect(lzma_info_metadata_set(info, NULL, &metadata, true, false)
-			== LZMA_DATA_ERROR);
-
-	reset();
-}
-
-
-static void
-test7(void)
-{
-	// No info yet, so we cannot locate anything.
-	expect(lzma_info_metadata_locate(info, true)
-			== LZMA_VLI_VALUE_UNKNOWN);
-	expect(lzma_info_metadata_locate(info, false)
-			== LZMA_VLI_VALUE_UNKNOWN);
-
-	// Setting the Stream start offset doesn't change this situation.
-	expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START, 5) == LZMA_OK);
-	expect(lzma_info_metadata_locate(info, true)
-			== LZMA_VLI_VALUE_UNKNOWN);
-	expect(lzma_info_metadata_locate(info, false)
-			== LZMA_VLI_VALUE_UNKNOWN);
-
-	// Setting the Size of Header Metadata known allows us to locate
-	// the Header Metadata Block.
-	expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA, 11)
-			== LZMA_OK);
-	expect(lzma_info_metadata_locate(info, true)
-			== 5 + LZMA_STREAM_HEADER_SIZE);
-	expect(lzma_info_metadata_locate(info, false)
-			== LZMA_VLI_VALUE_UNKNOWN);
-
-	// Adding a Data Block. As long as Index is not Finished, we cannot
-	// locate Footer Metadata Block.
-	lzma_info_iter_begin(info, &iter);
-	expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
-	expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11);
-	expect(iter.uncompressed_offset == 0);
-	expect(lzma_info_iter_set(&iter, 22, 33) == LZMA_OK);
-	expect(lzma_info_metadata_locate(info, true)
-			== 5 + LZMA_STREAM_HEADER_SIZE);
-	expect(lzma_info_metadata_locate(info, false)
-			== LZMA_VLI_VALUE_UNKNOWN);
-
-	// Once the Index is finished, we can locate Footer Metadata Block too.
-	expect(lzma_info_index_finish(info) == LZMA_OK);
-	expect(lzma_info_metadata_locate(info, true)
-			== 5 + LZMA_STREAM_HEADER_SIZE);
-	expect(lzma_info_metadata_locate(info, false)
-			== 5 + LZMA_STREAM_HEADER_SIZE + 11 + 22);
-
-	// A retry of most of the above but now with unknown Size of Header
-	// Metadata Block, which makes locating Footer Metadata Block
-	// impossible.
-	reset();
-	expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START, 5) == LZMA_OK);
-	expect(lzma_info_metadata_locate(info, true)
-			== LZMA_VLI_VALUE_UNKNOWN);
-	expect(lzma_info_metadata_locate(info, false)
-			== LZMA_VLI_VALUE_UNKNOWN);
-
-	expect(lzma_info_index_set(info, NULL, my_index, false) == LZMA_OK);
-	expect(lzma_info_metadata_locate(info, true)
-			== LZMA_VLI_VALUE_UNKNOWN);
-	expect(lzma_info_metadata_locate(info, false)
-			== LZMA_VLI_VALUE_UNKNOWN);
-
-	expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA, 11)
-			== LZMA_OK);
-	expect(lzma_info_metadata_locate(info, true)
-			== 5 + LZMA_STREAM_HEADER_SIZE);
-	expect(lzma_info_metadata_locate(info, false)
-			== LZMA_STREAM_HEADER_SIZE + 5 + 11 + 22 + 44 + 66);
-
-	reset();
-}
-
-
-static void
-test8(void)
-{
-	expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START, 5) == LZMA_OK);
-	expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA, 11)
-			== LZMA_OK);
-
-	lzma_info_iter_begin(info, &iter);
-	expect(lzma_info_iter_locate(&iter, NULL, 0, false)
-			== LZMA_DATA_ERROR);
-	expect(lzma_info_index_count_get(info) == 0);
-
-	lzma_info_iter_begin(info, &iter);
-	expect(lzma_info_iter_locate(&iter, NULL, 0, true) == LZMA_OK);
-	expect(lzma_info_index_count_get(info) == 1);
-	expect(lzma_info_iter_locate(&iter, NULL, 0, false) == LZMA_OK);
-	expect(lzma_info_index_count_get(info) == 1);
-
-	// TODO
-}
-
-
-/*
-static void
-test9(void)
-{
-	// TODO Various integer overflow checks
-}
-*/
-
-
-int
-main(void)
-{
-	lzma_init();
-
-	info = lzma_info_init(NULL, NULL);
-	if (info == NULL)
-		return 1;
-
-	validate();
-
-	test1();
-	test2();
-	test3();
-	test4();
-	test5();
-	test6();
-	test7();
-	test8();
-
-	lzma_info_free(info, NULL);
-	return 0;
-}
diff --git a/tests/test_stream_flags.c b/tests/test_stream_flags.c
index 99e55d5e..0de87cd1 100644
--- a/tests/test_stream_flags.c
+++ b/tests/test_stream_flags.c
@@ -1,7 +1,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 //
 /// \file       test_stream_flags.c
-/// \brief      Tests Stream Header and Stream tail coders
+/// \brief      Tests Stream Header and Stream Footer coders
 //
 //  Copyright (C) 2007 Lasse Collin
 //
@@ -22,37 +22,30 @@
 
 static lzma_stream_flags known_flags;
 static lzma_stream_flags decoded_flags;
-static uint8_t buffer[LZMA_STREAM_HEADER_SIZE + LZMA_STREAM_TAIL_SIZE];
-static lzma_stream strm = LZMA_STREAM_INIT;
+static uint8_t buffer[LZMA_STREAM_HEADER_SIZE];
 
 
 static bool
 validate(void)
 {
-	if (known_flags.check != decoded_flags.check
-			|| known_flags.has_crc32 != decoded_flags.has_crc32
-			|| known_flags.is_multi != decoded_flags.is_multi)
-		return true;
-
-	return false;
+	return !lzma_stream_flags_equal(&known_flags, &decoded_flags);
 }
 
 
 static bool
-test_header_decoder(size_t expected_size, lzma_ret expected_ret)
+test_header_decoder(lzma_ret expected_ret)
 {
 	memcrap(&decoded_flags, sizeof(decoded_flags));
 
-	if (lzma_stream_header_decoder(&strm, &decoded_flags) != LZMA_OK)
+	if (lzma_stream_header_decode(&decoded_flags, buffer) != expected_ret)
 		return true;
 
-	if (coder_loop(&strm, buffer, expected_size, NULL, 0,
-			expected_ret, LZMA_RUN))
-		return true;
-
-	if (expected_ret != LZMA_STREAM_END)
+	if (expected_ret != LZMA_OK)
 		return false;
 
+	// Header doesn't have Backward Size, so make
+	// lzma_stream_flags_equal() ignore it.
+	decoded_flags.backward_size = LZMA_VLI_VALUE_UNKNOWN;
 	return validate();
 }
 
@@ -61,36 +54,32 @@ static void
 test_header(void)
 {
 	memcrap(buffer, sizeof(buffer));
-	expect(lzma_stream_header_encode(buffer, &known_flags) == LZMA_OK);
-	succeed(test_header_decoder(LZMA_STREAM_HEADER_SIZE, LZMA_STREAM_END));
+	expect(lzma_stream_header_encode(&known_flags, buffer) == LZMA_OK);
+	succeed(test_header_decoder(LZMA_OK));
 }
 
 
 static bool
-test_tail_decoder(size_t expected_size, lzma_ret expected_ret)
+test_footer_decoder(lzma_ret expected_ret)
 {
 	memcrap(&decoded_flags, sizeof(decoded_flags));
 
-	if (lzma_stream_tail_decoder(&strm, &decoded_flags) != LZMA_OK)
-		return true;
-
-	if (coder_loop(&strm, buffer, expected_size, NULL, 0,
-			expected_ret, LZMA_RUN))
+	if (lzma_stream_footer_decode(&decoded_flags, buffer) != expected_ret)
 		return true;
 
-	if (expected_ret == LZMA_STREAM_END && validate())
-		return true;
+	if (expected_ret != LZMA_OK)
+		return false;
 
-	return false;
+	return validate();
 }
 
 
 static void
-test_tail(void)
+test_footer(void)
 {
 	memcrap(buffer, sizeof(buffer));
-	expect(lzma_stream_tail_encode(buffer, &known_flags) == LZMA_OK);
-	succeed(test_tail_decoder(LZMA_STREAM_TAIL_SIZE, LZMA_STREAM_END));
+	expect(lzma_stream_footer_encode(&known_flags, buffer) == LZMA_OK);
+	succeed(test_footer_decoder(LZMA_OK));
 }
 
 
@@ -98,21 +87,36 @@ static void
 test_encode_invalid(void)
 {
 	known_flags.check = LZMA_CHECK_ID_MAX + 1;
-	known_flags.has_crc32 = false;
-	known_flags.is_multi = false;
+	known_flags.backward_size = 1024;
 
-	expect(lzma_stream_header_encode(buffer, &known_flags)
+	expect(lzma_stream_header_encode(&known_flags, buffer)
 			== LZMA_PROG_ERROR);
 
-	expect(lzma_stream_tail_encode(buffer, &known_flags)
+	expect(lzma_stream_footer_encode(&known_flags, buffer)
 			== LZMA_PROG_ERROR);
 
 	known_flags.check = (lzma_check_type)(-1);
 
-	expect(lzma_stream_header_encode(buffer, &known_flags)
+	expect(lzma_stream_header_encode(&known_flags, buffer)
 			== LZMA_PROG_ERROR);
 
-	expect(lzma_stream_tail_encode(buffer, &known_flags)
+	expect(lzma_stream_footer_encode(&known_flags, buffer)
+			== LZMA_PROG_ERROR);
+
+	known_flags.check = LZMA_CHECK_NONE;
+	known_flags.backward_size = 0;
+
+	// Header encoder ignores backward_size.
+	expect(lzma_stream_header_encode(&known_flags, buffer) == LZMA_OK);
+
+	expect(lzma_stream_footer_encode(&known_flags, buffer)
+			== LZMA_PROG_ERROR);
+
+	known_flags.backward_size = LZMA_VLI_VALUE_MAX;
+
+	expect(lzma_stream_header_encode(&known_flags, buffer) == LZMA_OK);
+
+	expect(lzma_stream_footer_encode(&known_flags, buffer)
 			== LZMA_PROG_ERROR);
 }
 
@@ -121,43 +125,42 @@ static void
 test_decode_invalid(void)
 {
 	known_flags.check = LZMA_CHECK_NONE;
-	known_flags.has_crc32 = false;
-	known_flags.is_multi = false;
+	known_flags.backward_size = 1024;
 
-	expect(lzma_stream_header_encode(buffer, &known_flags) == LZMA_OK);
+	expect(lzma_stream_header_encode(&known_flags, buffer) == LZMA_OK);
 
 	// Test 1 (invalid Magic Bytes)
 	buffer[5] ^= 1;
-	succeed(test_header_decoder(6, LZMA_DATA_ERROR));
+	succeed(test_header_decoder(LZMA_FORMAT_ERROR));
 	buffer[5] ^= 1;
 
 	// Test 2a (valid CRC32)
-	uint32_t crc = lzma_crc32(buffer + 6, 1, 0);
-	for (size_t i = 0; i < 4; ++i)
-		buffer[7 + i] = crc >> (i * 8);
-	succeed(test_header_decoder(LZMA_STREAM_HEADER_SIZE, LZMA_STREAM_END));
+	uint32_t crc = lzma_crc32(buffer + 6, 2, 0);
+	integer_write_32(buffer + 8, crc);
+	succeed(test_header_decoder(LZMA_OK));
 
 	// Test 2b (invalid Stream Flags with valid CRC32)
 	buffer[6] ^= 0x20;
-	crc = lzma_crc32(buffer + 6, 1, 0);
-	for (size_t i = 0; i < 4; ++i)
-		buffer[7 + i] = crc >> (i * 8);
-	succeed(test_header_decoder(7, LZMA_HEADER_ERROR));
+	crc = lzma_crc32(buffer + 6, 2, 0);
+	integer_write_32(buffer + 8, crc);
+	succeed(test_header_decoder(LZMA_HEADER_ERROR));
 
 	// Test 3 (invalid CRC32)
-	expect(lzma_stream_header_encode(buffer, &known_flags) == LZMA_OK);
-	buffer[LZMA_STREAM_HEADER_SIZE - 1] ^= 1;
-	succeed(test_header_decoder(LZMA_STREAM_HEADER_SIZE, LZMA_DATA_ERROR));
+	expect(lzma_stream_header_encode(&known_flags, buffer) == LZMA_OK);
+	buffer[9] ^= 1;
+	succeed(test_header_decoder(LZMA_DATA_ERROR));
 
-	// Test 4 (invalid Stream Flags)
-	expect(lzma_stream_tail_encode(buffer, &known_flags) == LZMA_OK);
-	buffer[0] ^= 0x40;
-	succeed(test_tail_decoder(1, LZMA_HEADER_ERROR));
-	buffer[0] ^= 0x40;
+	// Test 4 (invalid Stream Flags with valid CRC32)
+	expect(lzma_stream_footer_encode(&known_flags, buffer) == LZMA_OK);
+	buffer[9] ^= 0x40;
+	crc = lzma_crc32(buffer + 4, 6, 0);
+	integer_write_32(buffer, crc);
+	succeed(test_footer_decoder(LZMA_HEADER_ERROR));
 
 	// Test 5 (invalid Magic Bytes)
-	buffer[2] ^= 1;
-	succeed(test_tail_decoder(3, LZMA_DATA_ERROR));
+	expect(lzma_stream_footer_encode(&known_flags, buffer) == LZMA_OK);
+	buffer[11] ^= 1;
+	succeed(test_footer_decoder(LZMA_FORMAT_ERROR));
 }
 
 
@@ -167,25 +170,16 @@ main(void)
 	lzma_init();
 
 	// Valid headers
+	known_flags.backward_size = 1024;
 	for (lzma_check_type check = LZMA_CHECK_NONE;
 			check <= LZMA_CHECK_ID_MAX; ++check) {
-		for (int has_crc32 = 0; has_crc32 <= 1; ++has_crc32) {
-			for (int is_multi = 0; is_multi <= 1; ++is_multi) {
-				known_flags.check = check;
-				known_flags.has_crc32 = has_crc32;
-				known_flags.is_multi = is_multi;
-
-				test_header();
-				test_tail();
-			}
-		}
+		test_header();
+		test_footer();
 	}
 
 	// Invalid headers
 	test_encode_invalid();
 	test_decode_invalid();
 
-	lzma_end(&strm);
-
 	return 0;
 }
diff --git a/tests/tests.h b/tests/tests.h
index c7b43fd0..89880552 100644
--- a/tests/tests.h
+++ b/tests/tests.h
@@ -21,13 +21,14 @@
 #define LZMA_TESTS_H
 
 #include "sysdefs.h"
+#include "integer.h"
 
 #include <stdio.h>
 
 #define memcrap(buf, size) memset(buf, 0xFD, size)
 
 #define expect(test) ((test) ? 0 : (fprintf(stderr, "%s:%u: %s\n", \
-	__FILE__, __LINE__, #test), exit(1), 0))
+	__FILE__, __LINE__, #test), abort(), 0))
 
 #define succeed(test) expect(!(test))
 
@@ -71,6 +72,14 @@ lzma_ret_sym(lzma_ret ret)
 	case LZMA_UNSUPPORTED_CHECK:
 		str = "LZMA_UNSUPPORTED_CHECK";
 		break;
+
+	case LZMA_FORMAT_ERROR:
+		str = "LZMA_FORMAT_ERROR";
+		break;
+
+	case LZMA_MEMLIMIT_ERROR:
+		str = "LZMA_MEMLIMIT_ERROR";
+		break;
 	}
 
 	return str;
@@ -121,8 +130,7 @@ coder_loop(lzma_stream *strm, uint8_t *in, size_t in_size,
 		if (strm->total_in != in_size || strm->total_out != out_size)
 			error = true;
 	} else {
-		if (strm->total_in + 1 != in_size
-				|| strm->total_out != out_size)
+		if (strm->total_in != in_size || strm->total_out != out_size)
 			error = true;
 	}