Tests: Refactors existing filter flags tests.

Converts the existing filter flags tests into tuktests.

1 files changed, 457 insertions, 198 deletions

diff --git a/tests/test_filter_flags.c b/tests/test_filter_flags.c
index ccd9ae98..4ddffa7f 100644
--- a/tests/test_filter_flags.c
+++ b/tests/test_filter_flags.c
@@ -3,7 +3,8 @@
 /// \file       test_filter_flags.c
 /// \brief      Tests Filter Flags coders
 //
-//  Author:     Lasse Collin
+//  Authors:    Jia Tan
+//              Lasse Collin
 //
 //  This file has been put into the public domain.
 //  You can do whatever you want with this file.
@@ -11,248 +12,506 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "tests.h"
+// Including the internal header file for access to the
+// LZMA_FILTER_RESERVED_START macro
+#include "common/common.h"
 
 
-static uint8_t buffer[4096];
-static lzma_filter known_flags;
-static lzma_filter decoded_flags;
-static lzma_stream strm = LZMA_STREAM_INIT;
-
-
-static bool
-encode(uint32_t known_size)
-{
-	memcrap(buffer, sizeof(buffer));
+// Used to create filters and easily to set id and options
+#define INIT_FILTER(_id, _options) {\
+	.id = _id, \
+	.options = _options \
+}
 
-	uint32_t tmp;
-	if (lzma_filter_flags_size(&tmp, &known_flags) != LZMA_OK)
-		return true;
 
-	if (tmp != known_size)
-		return true;
+#if defined(HAVE_ENCODERS)
+// No tests are run without encoders, so init the global filters
+// only when the encoders are enabled.
+static lzma_filter lzma1_filter = INIT_FILTER(LZMA_FILTER_LZMA1, NULL);
+static lzma_filter lzma2_filter = INIT_FILTER(LZMA_FILTER_LZMA2, NULL);
+static lzma_filter delta_filter = INIT_FILTER(LZMA_FILTER_DELTA, NULL);
 
-	size_t out_pos = 0;
-	if (lzma_filter_flags_encode(&known_flags,
-			buffer, &out_pos, known_size) != LZMA_OK)
-		return true;
+static lzma_filter bcj_filters_encoders[] = {
+#ifdef HAVE_ENCODER_X86
+	INIT_FILTER(LZMA_FILTER_X86, NULL),
+#endif
+#ifdef HAVE_ENCODER_POWERPC
+	INIT_FILTER(LZMA_FILTER_POWERPC, NULL),
+#endif
+#ifdef HAVE_ENCODER_IA64
+	INIT_FILTER(LZMA_FILTER_IA64, NULL),
+#endif
+#ifdef HAVE_ENCODER_ARM
+	INIT_FILTER(LZMA_FILTER_ARM, NULL),
+#endif
+#ifdef HAVE_ENCODER_ARM64
+	INIT_FILTER(LZMA_FILTER_ARM64, NULL),
+#endif
+#ifdef HAVE_ENCODER_ARMTHUMB
+	INIT_FILTER(LZMA_FILTER_ARMTHUMB, NULL),
+#endif
+#ifdef HAVE_ENCODER_SPARC
+	INIT_FILTER(LZMA_FILTER_SPARC, NULL),
+#endif
+};
 
-	if (out_pos != known_size)
-		return true;
+// HAVE_ENCODERS ifdef not termianted here because decoders are
+// only used if encoders are, but encoders can still be used
+// even if decoders are not.
 
-	return false;
-}
+#ifdef HAVE_DECODERS
+static lzma_filter bcj_filters_decoders[] = {
+#ifdef HAVE_DECODER_X86
+	INIT_FILTER(LZMA_FILTER_X86, NULL),
+#endif
+#ifdef HAVE_DECODER_POWERPC
+	INIT_FILTER(LZMA_FILTER_POWERPC, NULL),
+#endif
+#ifdef HAVE_DECODER_IA64
+	INIT_FILTER(LZMA_FILTER_IA64, NULL),
+#endif
+#ifdef HAVE_DECODER_ARM
+	INIT_FILTER(LZMA_FILTER_ARM, NULL),
+#endif
+#ifdef HAVE_DECODER_ARM64
+	INIT_FILTER(LZMA_FILTER_ARM64, NULL),
+#endif
+#ifdef HAVE_DECODER_ARMTHUMB
+	INIT_FILTER(LZMA_FILTER_ARMTHUMB, NULL),
+#endif
+#ifdef HAVE_DECODER_SPARC
+	INIT_FILTER(LZMA_FILTER_SPARC, NULL),
+#endif
+};
+#endif
+#endif
 
 
-static bool
-decode_ret(uint32_t known_size, lzma_ret expected_ret)
+static void
+test_lzma_filter_flags_size(void)
 {
-	memcrap(&decoded_flags, sizeof(decoded_flags));
-
-	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;
-}
+#ifndef HAVE_ENCODERS
+	assert_skip("Encoder support disabled");
+#else
+	// For each supported filter, test that the size can be calculated
+	// and that the size calculated is reasonable. A reasonable size
+	// must be greater than 0, but less than the maximum size for the
+	// block header.
+	uint32_t size = 0;
+	if (lzma_filter_encoder_is_supported(LZMA_FILTER_LZMA1)) {
+		assert_lzma_ret(lzma_filter_flags_size(&size,
+				&lzma1_filter), LZMA_PROG_ERROR);
+	}
 
+	if (lzma_filter_encoder_is_supported(LZMA_FILTER_LZMA2)) {
+		assert_lzma_ret(lzma_filter_flags_size(&size,
+				&lzma2_filter), LZMA_OK);
+		assert_true(size != 0 && size < LZMA_BLOCK_HEADER_SIZE_MAX);
+	}
 
-static bool
-decode(uint32_t known_size)
-{
-	if (decode_ret(known_size, LZMA_OK))
-		return true;
+	for (uint32_t i = 0; i < ARRAY_SIZE(bcj_filters_encoders); i++) {
+		assert_lzma_ret(lzma_filter_flags_size(&size,
+				&bcj_filters_encoders[i]), LZMA_OK);
+		assert_true(size != 0 && size < LZMA_BLOCK_HEADER_SIZE_MAX);
+	}
 
-	if (known_flags.id != decoded_flags.id)
-		return true;
+	if (lzma_filter_encoder_is_supported(LZMA_FILTER_DELTA)) {
+		assert_lzma_ret(lzma_filter_flags_size(&size,
+				&delta_filter), LZMA_OK);
+		assert_true(size != 0 && size < LZMA_BLOCK_HEADER_SIZE_MAX);
+	}
 
-	return false;
+	// Test invalid filter ids
+	lzma_filter bad_filter = INIT_FILTER(2, NULL);
+
+	assert_lzma_ret(lzma_filter_flags_size(&size, &bad_filter),
+			LZMA_OPTIONS_ERROR);
+	bad_filter.id = LZMA_VLI_MAX;
+	assert_lzma_ret(lzma_filter_flags_size(&size, &bad_filter),
+			LZMA_PROG_ERROR);
+	bad_filter.id = LZMA_FILTER_RESERVED_START;
+	assert_lzma_ret(lzma_filter_flags_size(&size, &bad_filter),
+			LZMA_PROG_ERROR);
+#endif
 }
 
 
-#if defined(HAVE_ENCODER_X86) && defined(HAVE_DECODER_X86)
+// Helper function for test_lzma_filter_flags_encode.
+// The should_encode parameter represents if the encoding operation
+// is expected to fail.
+// Avoid data -> encode -> decode -> compare to data.
+// Instead create expected encoding and compare to result from
+// lzma_filter_flags_encode.
+// Filter flags for xz are encoded as:
+// |Filter ID (VLI)|Size of Properties (VLI)|Filter Properties|
+#if defined(HAVE_ENCODERS) && defined(HAVE_DECODERS)
 static void
-test_bcj(void)
+verify_filter_flags_encode(lzma_filter *filter, bool should_encode)
 {
-	// Test 1
-	known_flags.id = LZMA_FILTER_X86;
-	known_flags.options = NULL;
-
-	expect(!encode(2));
-	expect(!decode(2));
-	expect(decoded_flags.options == NULL);
-
-	// Test 2
-	lzma_options_bcj options;
-	options.start_offset = 0;
-	known_flags.options = &options;
-	expect(!encode(2));
-	expect(!decode(2));
-	expect(decoded_flags.options == NULL);
-
-	// Test 3
-	options.start_offset = 123456;
-	known_flags.options = &options;
-	expect(!encode(6));
-	expect(!decode(6));
-	expect(decoded_flags.options != NULL);
-
-	lzma_options_bcj *decoded = decoded_flags.options;
-	expect(decoded->start_offset == options.start_offset);
-
-	free(decoded);
+	uint32_t size = 0;
+	// First calculate the size of filter flags to know how much
+	// memory to allocate to hold the filter flags encoded
+	assert_lzma_ret(lzma_filter_flags_size(&size, filter), LZMA_OK);
+	uint8_t *encoded_out = tuktest_malloc(size * sizeof(uint8_t));
+	size_t out_pos = 0;
+	if(!should_encode) {
+		assert_false(lzma_filter_flags_encode(filter, encoded_out,
+				&out_pos, size) == LZMA_OK);
+		return;
+	}
+
+	// Next encode the filter flags for the provided filter
+	assert_lzma_ret(lzma_filter_flags_encode(filter, encoded_out,
+			&out_pos, size), LZMA_OK);
+	assert_uint_eq(size, out_pos);
+	// Next decode the vli for the filter ID and verify it matches
+	// the expected filter id
+	size_t filter_id_vli_size = 0;
+	lzma_vli filter_id = 0;
+	assert_lzma_ret(lzma_vli_decode(&filter_id, NULL, encoded_out,
+			&filter_id_vli_size, size), LZMA_OK);
+	assert_uint_eq(filter->id, filter_id);
+
+	// Next decode the size of properites and ensure it equals
+	// the expected size
+	// Expected size should be:
+	// total filter flag length - size of filter id VLI + size of
+	//                            property size VLI
+	// Not verifying the contents of Filter Properties since
+	// that belongs in a different test
+	size_t size_of_properties_vli_size = 0;
+	lzma_vli size_of_properties = 0;
+	assert_lzma_ret(lzma_vli_decode(&size_of_properties, NULL,
+			encoded_out + filter_id_vli_size,
+			&size_of_properties_vli_size, size), LZMA_OK);
+	assert_uint_eq(size - (size_of_properties_vli_size +
+			filter_id_vli_size), size_of_properties);
 }
 #endif
 
 
-#if defined(HAVE_ENCODER_DELTA) && defined(HAVE_DECODER_DELTA)
 static void
-test_delta(void)
+test_lzma_filter_flags_encode(void)
 {
-	// Test 1
-	known_flags.id = LZMA_FILTER_DELTA;
-	known_flags.options = NULL;
-	expect(encode(99));
-
-	// Test 2
-	lzma_options_delta options = {
-		.type = LZMA_DELTA_TYPE_BYTE,
-		.dist = 0
+#if !defined(HAVE_ENCODERS) || !defined(HAVE_DECODERS)
+	assert_skip("Encoder or decoder support disabled");
+#else
+	// No test for LZMA1 since the xz format does not support LZMA1
+	// and so the flags cannot be encoded for that filter
+	if (lzma_filter_encoder_is_supported(LZMA_FILTER_LZMA2)) {
+		// Test with NULL options that should fail
+		lzma_options_lzma *options = lzma2_filter.options;
+		lzma2_filter.options = NULL;
+		verify_filter_flags_encode(&lzma2_filter, false);
+		// Place options back in the filter, and test should pass
+		lzma2_filter.options = options;
+		verify_filter_flags_encode(&lzma2_filter, true);
+	}
+
+	lzma_options_bcj bcj_options = {
+		.start_offset = 200
 	};
-	known_flags.options = &options;
-	expect(encode(99));
-
-	// Test 3
-	options.dist = LZMA_DELTA_DIST_MIN;
-	expect(!encode(3));
-	expect(!decode(3));
-	expect(((lzma_options_delta *)(decoded_flags.options))->dist
-			== options.dist);
-
-	free(decoded_flags.options);
-
-	// Test 4
-	options.dist = LZMA_DELTA_DIST_MAX;
-	expect(!encode(3));
-	expect(!decode(3));
-	expect(((lzma_options_delta *)(decoded_flags.options))->dist
-			== options.dist);
-
-	free(decoded_flags.options);
-
-	// Test 5
-	options.dist = LZMA_DELTA_DIST_MAX + 1;
-	expect(encode(99));
-}
-#endif
 
-/*
-#ifdef HAVE_FILTER_LZMA
-static void
-validate_lzma(void)
-{
-	const lzma_options_lzma *known = known_flags.options;
-	const lzma_options_lzma *decoded = decoded_flags.options;
+	for (uint32_t i = 0; i < ARRAY_SIZE(bcj_filters_encoders); i++) {
+		// NULL options should pass for bcj filters
+		verify_filter_flags_encode(&bcj_filters_encoders[i], true);
+		lzma_filter bcj_with_options = INIT_FILTER(
+				bcj_filters_encoders[i].id, &bcj_options);
+		verify_filter_flags_encode(&bcj_with_options, true);
+	}
 
-	expect(known->dictionary_size <= decoded->dictionary_size);
+	if (lzma_filter_encoder_is_supported(LZMA_FILTER_DELTA)) {
+		lzma_options_delta delta_ops_below_min = {
+			.type = LZMA_DELTA_TYPE_BYTE,
+			.dist = LZMA_DELTA_DIST_MIN - 1
+		};
 
-	if (known->dictionary_size == 1)
-		expect(decoded->dictionary_size == 1);
-	else
-		expect(known->dictionary_size + known->dictionary_size / 2
-				> decoded->dictionary_size);
+		lzma_options_delta delta_ops_above_max = {
+			.type = LZMA_DELTA_TYPE_BYTE,
+			.dist = LZMA_DELTA_DIST_MAX + 1
+		};
 
-	expect(known->literal_context_bits == decoded->literal_context_bits);
-	expect(known->literal_pos_bits == decoded->literal_pos_bits);
-	expect(known->pos_bits == decoded->pos_bits);
+		verify_filter_flags_encode(&delta_filter, true);
+
+		lzma_filter delta_filter_bad_options = INIT_FILTER(
+				LZMA_FILTER_DELTA, &delta_ops_below_min);
+
+		// Next test error case using minimum - 1 delta distance
+		verify_filter_flags_encode(&delta_filter_bad_options, false);
+
+		// Next test error case using maximum + 1 delta distance
+		delta_filter_bad_options.options = &delta_ops_above_max;
+		verify_filter_flags_encode(&delta_filter_bad_options, false);
+
+		// Next test null case
+		delta_filter_bad_options.options = NULL;
+		verify_filter_flags_encode(&delta_filter_bad_options, false);
+	}
+
+	// Test expected failing cases
+	lzma_filter bad_filter = INIT_FILTER(LZMA_FILTER_RESERVED_START,
+			NULL);
+	size_t out_pos = 0;
+	size_t out_size = LZMA_BLOCK_HEADER_SIZE_MAX;
+	uint8_t out[LZMA_BLOCK_HEADER_SIZE_MAX];
+
+
+	// Filter id outside of valid range
+	assert_lzma_ret(lzma_filter_flags_encode(&bad_filter, out, &out_pos,
+			out_size), LZMA_PROG_ERROR);
+	out_pos = 0;
+	bad_filter.id = LZMA_VLI_MAX + 1;
+	assert_lzma_ret(lzma_filter_flags_encode(&bad_filter, out, &out_pos,
+			out_size), LZMA_PROG_ERROR);
+	out_pos = 0;
+
+	// Invalid filter id
+	bad_filter.id = 2;
+	assert_lzma_ret(lzma_filter_flags_encode(&bad_filter, out, &out_pos,
+			out_size), LZMA_OPTIONS_ERROR);
+	out_pos = 0;
+
+	// Out size too small
+	if (lzma_filter_encoder_is_supported(LZMA_FILTER_LZMA2)) {
+		uint32_t bad_size = 0;
+
+		// First test with 0 output size
+		assert_lzma_ret(lzma_filter_flags_encode(
+				&lzma2_filter, out, &out_pos, 0),
+				LZMA_PROG_ERROR);
+
+		// Next calculate the size needed to encode and
+		// use less than that
+		assert_lzma_ret(lzma_filter_flags_size(&bad_size,
+				&lzma2_filter), LZMA_OK);
+
+		assert_lzma_ret(lzma_filter_flags_encode(
+				&lzma2_filter, out, &out_pos,
+				bad_size - 1), LZMA_PROG_ERROR);
+		out_pos = 0;
+	}
+
+	// Invalid options
+	if (lzma_filter_encoder_is_supported(LZMA_FILTER_DELTA)) {
+		bad_filter.id = LZMA_FILTER_DELTA;
+		// First test with NULL options
+		assert_lzma_ret(lzma_filter_flags_encode(&bad_filter, out,
+				&out_pos, out_size), LZMA_PROG_ERROR);
+		out_pos = 0;
+
+		// Next test with invalid options
+		lzma_options_delta bad_options = {
+			.dist = LZMA_DELTA_DIST_MAX + 1,
+			.type = LZMA_DELTA_TYPE_BYTE
+		};
+		bad_filter.options = &bad_options;
+
+		assert_lzma_ret(lzma_filter_flags_encode(&bad_filter, out,
+				&out_pos, out_size), LZMA_PROG_ERROR);
+	}
+#endif
 }
 
 
+// Helper function for test_lzma_filter_flags_decode.
+// Encodes the filter_in without using lzma_filter_flags_encode.
+// Leaves the specific assertions of filter_out options to the caller
+// because it is agnostic to the type of options used in the call
+#if defined(HAVE_ENCODERS) && defined(HAVE_DECODERS)
 static void
-test_lzma(void)
+verify_filter_flags_decode(lzma_filter *filter_in, lzma_filter *filter_out)
 {
-	// Test 1
-	known_flags.id = LZMA_FILTER_LZMA1;
-	known_flags.options = NULL;
-	expect(encode(99));
-
-	// Test 2
-	lzma_options_lzma options = {
-		.dictionary_size = 0,
-		.literal_context_bits = 0,
-		.literal_pos_bits = 0,
-		.pos_bits = 0,
-		.preset_dictionary = NULL,
-		.preset_dictionary_size = 0,
-		.mode = LZMA_MODE_INVALID,
-		.fast_bytes = 0,
-		.match_finder = LZMA_MF_INVALID,
-		.match_finder_cycles = 0,
-	};
+	uint32_t total_size = 0;
+
+	assert_lzma_ret(lzma_filter_flags_size(&total_size, filter_in),
+			LZMA_OK);
+	uint8_t *filter_flag_buffer = tuktest_malloc(total_size);
+
+	uint32_t properties_size = 0;
+	size_t out_pos = 0, in_pos = 0;
+	assert_lzma_ret(lzma_properties_size(&properties_size, filter_in),
+			LZMA_OK);
+	assert_lzma_ret(lzma_vli_encode(filter_in->id, NULL,
+			filter_flag_buffer, &out_pos, total_size), LZMA_OK);
+	assert_lzma_ret(lzma_vli_encode(properties_size, NULL,
+			filter_flag_buffer, &out_pos, total_size),
+			LZMA_OK);
+	assert_lzma_ret(lzma_properties_encode(filter_in,
+			filter_flag_buffer + out_pos), LZMA_OK);
+	assert_lzma_ret(lzma_filter_flags_decode(filter_out, NULL,
+			filter_flag_buffer, &in_pos, total_size),
+			LZMA_OK);
+	assert_uint_eq(filter_in->id, filter_out->id);
+}
+#endif
 
-	// Test 3 (empty dictionary not allowed)
-	known_flags.options = &options;
-	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;
+static void
+test_lzma_filter_flags_decode(void)
+{
+#if !defined(HAVE_ENCODERS) || !defined(HAVE_DECODERS)
+	assert_skip("Encoder or decoder support disabled");
+#else
+	// For each filter, only run the decoder test if both the encoder
+	// and decoder is enabled. This is because verify_filter_flags_decode
+	// uses lzma_filter_flags_size, which requires the encoder.
+	if (lzma_filter_decoder_is_supported(LZMA_FILTER_LZMA2) &&
+			lzma_filter_encoder_is_supported(LZMA_FILTER_LZMA2)) {
+		lzma_filter lzma2_decoded = INIT_FILTER(LZMA_FILTER_LZMA2,
+				NULL);
+
+		verify_filter_flags_decode(&lzma2_filter, &lzma2_decoded);
+
+		lzma_options_lzma *expected = lzma2_filter.options;
+		lzma_options_lzma *decoded = lzma2_decoded.options;
+
+		// Only the dictionary size is encoded and decoded
+		// so only compare those
+		assert_uint_eq(decoded->dict_size, expected->dict_size);
+
+		// The decoded options must be freed by the caller
+		free(decoded);
+	}
 
-		expect(!encode(4));
-		expect(!decode(4));
-		validate_lzma();
+	for (uint32_t i = 0; i < ARRAY_SIZE(bcj_filters_decoders); i++) {
+		if (lzma_filter_encoder_is_supported(
+				bcj_filters_decoders[i].id)) {
+			lzma_filter bcj_decoded = INIT_FILTER(
+				bcj_filters_decoders[i].id, NULL);
+
+			lzma_filter bcj_encoded = INIT_FILTER(
+					bcj_filters_decoders[i].id, NULL);
+
+			// First test without options
+			verify_filter_flags_decode(&bcj_encoded,
+					&bcj_decoded);
+			assert_true(bcj_decoded.options == NULL);
+
+			// Next test with offset
+			lzma_options_bcj options = {
+				.start_offset = 200
+			};
+
+			bcj_encoded.options = &options;
+			verify_filter_flags_decode(&bcj_encoded,
+					&bcj_decoded);
+			lzma_options_bcj *decoded_ops = bcj_decoded.options;
+			assert_uint_eq(decoded_ops->start_offset,
+					options.start_offset);
+			free(decoded_ops);
+		}
+		
+	}
 
-		free(decoded_flags.options);
+	if (lzma_filter_decoder_is_supported(LZMA_FILTER_DELTA) &&
+			lzma_filter_encoder_is_supported(LZMA_FILTER_DELTA)) {
+		lzma_filter delta_decoded = INIT_FILTER(LZMA_FILTER_DELTA,
+				NULL);
+
+		verify_filter_flags_decode(&delta_filter, &delta_decoded);
+		lzma_options_delta *expected = delta_filter.options;
+		lzma_options_delta *decoded = delta_decoded.options;
+		assert_uint_eq(expected->dist, decoded->dist);
+		assert_uint_eq(expected->type, decoded->type);
+
+		free(decoded);
 	}
 
-	// Test 5 (too big dictionary size)
-	options.dictionary_size = LZMA_DICTIONARY_SIZE_MAX + 1;
-	expect(encode(99));
-
-	// Test 6 (brute-force test lc/lp/pb)
-	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;
-				lp <= LZMA_LITERAL_POS_BITS_MAX; ++lp) {
-			for (uint32_t pb = LZMA_POS_BITS_MIN;
-					pb <= LZMA_POS_BITS_MAX; ++pb) {
-				if (lc + lp > LZMA_LITERAL_BITS_MAX)
-					continue;
-
-				options.literal_context_bits = lc;
-				options.literal_pos_bits = lp;
-				options.pos_bits = pb;
-
-				expect(!encode(4));
-				expect(!decode(4));
-				validate_lzma();
-
-				free(decoded_flags.options);
-			}
-		}
+	// Test expected failing cases
+	uint8_t bad_encoded_filter[LZMA_BLOCK_HEADER_SIZE_MAX];
+	lzma_filter bad_filter;
+
+	// Filter outside of valid range
+	lzma_vli bad_filter_id = LZMA_FILTER_RESERVED_START;
+	size_t bad_encoded_out_pos = 0;
+	size_t in_pos = 0;
+
+	assert_lzma_ret(lzma_vli_encode(bad_filter_id, NULL,
+			bad_encoded_filter, &bad_encoded_out_pos,
+			LZMA_BLOCK_HEADER_SIZE_MAX), LZMA_OK);
+
+	assert_lzma_ret(lzma_filter_flags_decode(&bad_filter, NULL,
+			bad_encoded_filter, &in_pos,
+			LZMA_BLOCK_HEADER_SIZE_MAX), LZMA_DATA_ERROR);
+
+	bad_encoded_out_pos = 0;
+	in_pos = 0;
+
+	// Invalid filter Id
+	bad_filter_id = 2;
+	bad_encoded_out_pos = 0;
+	in_pos = 0;
+
+	assert_lzma_ret(lzma_vli_encode(bad_filter_id, NULL,
+			bad_encoded_filter, &bad_encoded_out_pos,
+			LZMA_BLOCK_HEADER_SIZE_MAX), LZMA_OK);
+
+	// Next encode propery size of 0
+	assert_lzma_ret(lzma_vli_encode(0, NULL,
+			bad_encoded_filter, &bad_encoded_out_pos,
+			LZMA_BLOCK_HEADER_SIZE_MAX), LZMA_OK);
+	// Decode should fail on bad filter id
+	assert_lzma_ret(lzma_filter_flags_decode(&bad_filter, NULL,
+			bad_encoded_filter, &in_pos,
+			LZMA_BLOCK_HEADER_SIZE_MAX), LZMA_OPTIONS_ERROR);
+	bad_encoded_out_pos = 0;
+	in_pos = 0;
+
+	// Outsize too small
+	// Encode the lzma2 filter normally, but then set
+	// the out size when decoding as too small
+	if (lzma_filter_encoder_is_supported(LZMA_FILTER_LZMA2) &&
+			lzma_filter_decoder_is_supported(LZMA_FILTER_LZMA2)) {
+		uint32_t filter_flag_size = 0;
+		assert_lzma_ret(lzma_filter_flags_size(&filter_flag_size,
+				&lzma2_filter), LZMA_OK);
+
+		assert_lzma_ret(lzma_filter_flags_encode(&lzma2_filter,
+				bad_encoded_filter, &bad_encoded_out_pos,
+				LZMA_BLOCK_HEADER_SIZE_MAX), LZMA_OK);
+
+		assert_lzma_ret(lzma_filter_flags_decode(&bad_filter, NULL,
+			bad_encoded_filter, &in_pos,
+			filter_flag_size - 1), LZMA_DATA_ERROR);
 	}
-}
 #endif
-*/
+}
+
 
-int
-main(void)
+extern int
+main(int argc, char **argv)
 {
-#if defined(HAVE_ENCODER_X86) && defined(HAVE_DECODER_X86)
-	test_bcj();
-#endif
-#if defined(HAVE_ENCODER_DELTA) && defined(HAVE_DECODER_DELTA)
-	test_delta();
-#endif
-// #ifdef HAVE_FILTER_LZMA
-// 	test_lzma();
-// #endif
+	tuktest_start(argc, argv);
+
+#ifdef HAVE_ENCODERS
+	// Only init filter options if encoder is supported because decoder
+	// tests requires encoder support, so the decoder tests will only
+	// run if for a given filter both the encoder and decoder are enabled.
+	if (lzma_filter_encoder_is_supported(LZMA_FILTER_LZMA1)) {
+		lzma_options_lzma *options = tuktest_malloc(
+				sizeof(lzma_options_lzma));
+		lzma_lzma_preset(options, LZMA_PRESET_DEFAULT);
+		lzma1_filter.options = options;
+	}
 
-	lzma_end(&strm);
+	if (lzma_filter_encoder_is_supported(LZMA_FILTER_LZMA2)) {
+		lzma_options_lzma *options = tuktest_malloc(
+				sizeof(lzma_options_lzma));
+		lzma_lzma_preset(options, LZMA_PRESET_DEFAULT);
+		lzma2_filter.options = options;
+		}
+
+	if (lzma_filter_encoder_is_supported(LZMA_FILTER_DELTA)) {
+		lzma_options_delta *options = tuktest_malloc(
+				sizeof(lzma_options_delta));
+		options->dist = LZMA_DELTA_DIST_MIN;
+		options->type = LZMA_DELTA_TYPE_BYTE;
+		delta_filter.options = options;
+	}
+#endif
 
-	return 0;
+	tuktest_run(test_lzma_filter_flags_size);
+	tuktest_run(test_lzma_filter_flags_encode);
+	tuktest_run(test_lzma_filter_flags_decode);
+	return tuktest_end();
 }