aboutsummaryrefslogtreecommitdiff
path: root/tests/test_block_header.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--tests/test_block_header.c486
1 files changed, 370 insertions, 116 deletions
diff --git a/tests/test_block_header.c b/tests/test_block_header.c
index 2f0184ac..6b42df22 100644
--- a/tests/test_block_header.c
+++ b/tests/test_block_header.c
@@ -3,7 +3,8 @@
/// \file test_block_header.c
/// \brief Tests Block Header coders
//
-// Author: Lasse Collin
+// Authors: Lasse Collin
+// Jia Tan
//
// This file has been put into the public domain.
// You can do whatever you want with this file.
@@ -13,12 +14,10 @@
#include "tests.h"
-static uint8_t buf[LZMA_BLOCK_HEADER_SIZE_MAX];
-static lzma_block known_options;
-static lzma_block decoded_options;
-
static lzma_options_lzma opt_lzma;
+
+#ifdef HAVE_ENCODERS
static lzma_filter filters_none[1] = {
{
.id = LZMA_VLI_UNKNOWN,
@@ -75,163 +74,423 @@ static lzma_filter filters_five[6] = {
.id = LZMA_VLI_UNKNOWN,
}
};
+#endif
static void
-code(void)
+test_lzma_block_header_size(void)
{
- assert_lzma_ret(lzma_block_header_encode(&known_options, buf),
- LZMA_OK);
+#ifndef HAVE_ENCODERS
+ assert_skip("Encoder support disabled");
+#else
+ if (!lzma_filter_encoder_is_supported(LZMA_FILTER_X86))
+ assert_skip("x86 BCJ encoder is disabled");
+
+ lzma_block block = {
+ .version = 0,
+ .filters = filters_one,
+ .compressed_size = LZMA_VLI_UNKNOWN,
+ .uncompressed_size = LZMA_VLI_UNKNOWN,
+ .check = LZMA_CHECK_CRC32
+ };
- lzma_filter filters[LZMA_FILTERS_MAX + 1];
- memcrap(filters, sizeof(filters));
- memcrap(&decoded_options, sizeof(decoded_options));
+ // Test that all initial options are valid
+ assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
+ assert_uint(block.header_size, >=, LZMA_BLOCK_HEADER_SIZE_MIN);
+ assert_uint(block.header_size, <=, LZMA_BLOCK_HEADER_SIZE_MAX);
+ assert_uint_eq(block.header_size % 4, 0);
+
+ // Test invalid version number
+ for (uint32_t i = 2; i < 20; i++) {
+ block.version = i;
+ assert_lzma_ret(lzma_block_header_size(&block),
+ LZMA_OPTIONS_ERROR);
+ }
- decoded_options.header_size = known_options.header_size;
- decoded_options.check = known_options.check;
- decoded_options.filters = filters;
- assert_lzma_ret(lzma_block_header_decode(&decoded_options, NULL, buf),
- LZMA_OK);
+ block.version = 1;
+
+ // Test invalid compressed size
+ block.compressed_size = 0;
+ assert_lzma_ret(lzma_block_header_size(&block), LZMA_PROG_ERROR);
+
+ block.compressed_size = LZMA_VLI_MAX + 1;
+ assert_lzma_ret(lzma_block_header_size(&block), LZMA_PROG_ERROR);
+ block.compressed_size = LZMA_VLI_UNKNOWN;
+
+ // Test invalid uncompressed size
+ block.uncompressed_size = LZMA_VLI_MAX + 1;
+ assert_lzma_ret(lzma_block_header_size(&block), LZMA_PROG_ERROR);
+ block.uncompressed_size = LZMA_VLI_MAX;
+
+ // Test invalid filters
+ block.filters = NULL;
+ assert_lzma_ret(lzma_block_header_size(&block), LZMA_PROG_ERROR);
+
+ block.filters = filters_none;
+ assert_lzma_ret(lzma_block_header_size(&block), LZMA_PROG_ERROR);
+
+ block.filters = filters_five;
+ assert_lzma_ret(lzma_block_header_size(&block), LZMA_PROG_ERROR);
+
+ block.filters = filters_one;
+
+ // Test setting compressed_size to something valid
+ block.compressed_size = 4096;
+ assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
+ assert_uint(block.header_size, >=, LZMA_BLOCK_HEADER_SIZE_MIN);
+ assert_uint(block.header_size, <=, LZMA_BLOCK_HEADER_SIZE_MAX);
+ assert_uint_eq(block.header_size % 4, 0);
+
+ // Test setting uncompressed_size to something valid
+ block.uncompressed_size = 4096;
+ assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
+ assert_uint(block.header_size, >=, LZMA_BLOCK_HEADER_SIZE_MIN);
+ assert_uint(block.header_size, <=, LZMA_BLOCK_HEADER_SIZE_MAX);
+ assert_uint_eq(block.header_size % 4, 0);
+
+ // This should pass, but header_size will be an invalid value
+ // because the total block size will not be able to fit in a valid
+ // lzma_vli. This way a temporary value can be used to reserve
+ // space for the header and later the actual value can be set.
+ block.compressed_size = LZMA_VLI_MAX;
+ assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
+ assert_uint(block.header_size, >=, LZMA_BLOCK_HEADER_SIZE_MIN);
+ assert_uint(block.header_size, <=, LZMA_BLOCK_HEADER_SIZE_MAX);
+ assert_uint_eq(block.header_size % 4, 0);
+
+ // Use an invalid value for a filter option. This should still pass
+ // because the size of the LZMA2 properties is known by liblzma
+ // without reading any of the options so it doesn't validate them.
+ lzma_options_lzma bad_ops;
+ assert_false(lzma_lzma_preset(&bad_ops, 1));
+ bad_ops.pb = 0x1000;
+
+ lzma_filter bad_filters[2] = {
+ {
+ .id = LZMA_FILTER_LZMA2,
+ .options = &bad_ops
+ },
+ {
+ .id = LZMA_VLI_UNKNOWN,
+ .options = NULL
+ }
+ };
- assert_uint_eq(decoded_options.compressed_size,
- known_options.compressed_size);
- assert_uint_eq(decoded_options.uncompressed_size,
- known_options.uncompressed_size);
+ block.filters = bad_filters;
- for (size_t i = 0; known_options.filters[i].id
- != LZMA_VLI_UNKNOWN; ++i)
- assert_uint_eq(filters[i].id, known_options.filters[i].id);
+ assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
+ assert_uint(block.header_size, >=, LZMA_BLOCK_HEADER_SIZE_MIN);
+ assert_uint(block.header_size, <=, LZMA_BLOCK_HEADER_SIZE_MAX);
+ assert_uint_eq(block.header_size % 4, 0);
- for (size_t i = 0; i < LZMA_FILTERS_MAX; ++i)
- free(decoded_options.filters[i].options);
+ // Use an invalid block option. The check type isn't stored in
+ // the Block Header and so _header_size ignores it.
+ block.check = 0x1000;
+ block.ignore_check = false;
+
+ assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
+ assert_uint(block.header_size, >=, LZMA_BLOCK_HEADER_SIZE_MIN);
+ assert_uint(block.header_size, <=, LZMA_BLOCK_HEADER_SIZE_MAX);
+ assert_uint_eq(block.header_size % 4, 0);
+#endif
}
static void
-test1(void)
+test_lzma_block_header_encode(void)
{
- known_options = (lzma_block){
- .check = LZMA_CHECK_NONE,
+#if !defined(HAVE_ENCODERS) || !defined(HAVE_DECODERS)
+ assert_skip("Encoder or decoder support disabled");
+#else
+
+ if (!lzma_filter_encoder_is_supported(LZMA_FILTER_X86)
+ || !lzma_filter_decoder_is_supported(LZMA_FILTER_X86))
+ assert_skip("x86 BCJ encoder and/or decoder "
+ "is disabled");
+
+ lzma_block block = {
+ .version = 1,
+ .filters = filters_one,
.compressed_size = LZMA_VLI_UNKNOWN,
.uncompressed_size = LZMA_VLI_UNKNOWN,
- .filters = NULL,
+ .check = LZMA_CHECK_CRC32,
};
- assert_lzma_ret(lzma_block_header_size(&known_options),
- LZMA_PROG_ERROR);
+ // Ensure all block options are valid before changes are tested
+ assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
- known_options.filters = filters_none;
- assert_lzma_ret(lzma_block_header_size(&known_options),
- LZMA_PROG_ERROR);
+ uint8_t out[LZMA_BLOCK_HEADER_SIZE_MAX];
- known_options.filters = filters_five;
- assert_lzma_ret(lzma_block_header_size(&known_options),
+ // Test invalid block version
+ for (uint32_t i = 2; i < 20; i++) {
+ block.version = i;
+ assert_lzma_ret(lzma_block_header_encode(&block, out),
+ LZMA_PROG_ERROR);
+ }
+
+ block.version = 1;
+
+ // Test invalid header size (< min, > max, % 4 != 0)
+ block.header_size = LZMA_BLOCK_HEADER_SIZE_MIN - 4;
+ assert_lzma_ret(lzma_block_header_encode(&block, out),
+ LZMA_PROG_ERROR);
+ block.header_size = LZMA_BLOCK_HEADER_SIZE_MIN + 2;
+ assert_lzma_ret(lzma_block_header_encode(&block, out),
LZMA_PROG_ERROR);
+ block.header_size = LZMA_BLOCK_HEADER_SIZE_MAX + 4;
+ assert_lzma_ret(lzma_block_header_encode(&block, out),
+ LZMA_PROG_ERROR);
+ assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
- known_options.filters = filters_one;
- assert_lzma_ret(lzma_block_header_size(&known_options), LZMA_OK);
+ // Test invalid compressed_size
+ block.compressed_size = 0;
+ assert_lzma_ret(lzma_block_header_encode(&block, out),
+ LZMA_PROG_ERROR);
+ block.compressed_size = LZMA_VLI_MAX + 1;
+ assert_lzma_ret(lzma_block_header_encode(&block, out),
+ LZMA_PROG_ERROR);
- // Some invalid value, which gets ignored.
- known_options.check = (lzma_check)(99);
- assert_lzma_ret(lzma_block_header_size(&known_options), LZMA_OK);
+ // This test passes test_lzma_block_header_size, but should
+ // fail here because there is not enough space to encode the
+ // proper block size because the total size is too big to fit
+ // in an lzma_vli
+ block.compressed_size = LZMA_VLI_MAX;
+ assert_lzma_ret(lzma_block_header_encode(&block, out),
+ LZMA_PROG_ERROR);
+ block.compressed_size = LZMA_VLI_UNKNOWN;
- known_options.compressed_size = 5;
- assert_lzma_ret(lzma_block_header_size(&known_options), LZMA_OK);
+ // Test invalid uncompressed size
+ block.uncompressed_size = LZMA_VLI_MAX + 1;
+ assert_lzma_ret(lzma_block_header_encode(&block, out),
+ LZMA_PROG_ERROR);
+ block.uncompressed_size = LZMA_VLI_UNKNOWN;
- known_options.compressed_size = 0; // Cannot be zero.
- assert_lzma_ret(lzma_block_header_size(&known_options),
+ // Test invalid block check
+ block.check = 0x1000;
+ block.ignore_check = false;
+ assert_lzma_ret(lzma_block_header_encode(&block, out),
LZMA_PROG_ERROR);
+ block.check = LZMA_CHECK_CRC32;
- // LZMA_VLI_MAX is too big to keep the total size of the Block
- // a valid VLI, but lzma_block_header_size() is not meant
- // to validate it. (lzma_block_header_encode() must validate it.)
- known_options.compressed_size = LZMA_VLI_MAX;
- assert_lzma_ret(lzma_block_header_size(&known_options), LZMA_OK);
+ // Test invalid filters
+ block.filters = NULL;
+ assert_lzma_ret(lzma_block_header_encode(&block, out),
+ LZMA_PROG_ERROR);
- known_options.compressed_size = LZMA_VLI_UNKNOWN;
- known_options.uncompressed_size = 0;
- assert_lzma_ret(lzma_block_header_size(&known_options), LZMA_OK);
+ block.filters = filters_none;
+ assert_lzma_ret(lzma_block_header_encode(&block, out),
+ LZMA_PROG_ERROR);
- known_options.uncompressed_size = LZMA_VLI_MAX + 1;
- assert_lzma_ret(lzma_block_header_size(&known_options),
+ block.filters = filters_five;
+ block.header_size = LZMA_BLOCK_HEADER_SIZE_MAX - 4;
+ assert_lzma_ret(lzma_block_header_encode(&block, out),
LZMA_PROG_ERROR);
+
+ // Test valid encoding and verify bytes of block header.
+ // More complicated tests for encoding headers are included
+ // in test_lzma_block_header_decode.
+ block.filters = filters_one;
+ assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
+ assert_lzma_ret(lzma_block_header_encode(&block, out), LZMA_OK);
+
+ // First read block header size from out and verify
+ // that it == (encoded size + 1) * 4
+ uint32_t header_size = (out[0] + 1U) * 4;
+ assert_uint_eq(header_size, block.header_size);
+
+ // Next read block flags
+ uint8_t flags = out[1];
+
+ // Should have number of filters = 1
+ assert_uint_eq((flags & 0x3) + 1, 1);
+
+ // Bits 2-7 must be empty not set
+ assert_uint_eq(flags & (0xFF - 0x3), 0);
+
+ // Verify filter flags
+ // Decode Filter ID
+ lzma_vli filter_id = 0;
+ size_t pos = 2;
+ assert_lzma_ret(lzma_vli_decode(&filter_id, NULL, out,
+ &pos, header_size), LZMA_OK);
+ assert_uint_eq(filter_id, filters_one[0].id);
+
+ // Decode Size of Properties
+ lzma_vli prop_size = 0;
+ assert_lzma_ret(lzma_vli_decode(&prop_size, NULL, out,
+ &pos, header_size), LZMA_OK);
+
+ // LZMA2 has 1 byte prop size
+ assert_uint_eq(prop_size, 1);
+ uint8_t expected_filter_props = 0;
+ assert_lzma_ret(lzma_properties_encode(filters_one,
+ &expected_filter_props), LZMA_OK);
+ assert_uint_eq(out[pos], expected_filter_props);
+ pos++;
+
+ // Check null-padding
+ for (size_t i = pos; i < header_size - 4; i++)
+ assert_uint_eq(out[i], 0);
+
+ // Check CRC32
+ assert_uint_eq(read32le(&out[header_size - 4]), lzma_crc32(out,
+ header_size - 4, 0));
+#endif
}
+#if defined(HAVE_ENCODERS) && defined(HAVE_DECODERS)
+// Helper function to compare two lzma_block structures field by field
static void
-test2(void)
+compare_blocks(lzma_block *block_expected, lzma_block *block_actual)
{
- known_options = (lzma_block){
- .check = LZMA_CHECK_CRC32,
- .compressed_size = LZMA_VLI_UNKNOWN,
- .uncompressed_size = LZMA_VLI_UNKNOWN,
- .filters = filters_four,
- };
-
- assert_lzma_ret(lzma_block_header_size(&known_options), LZMA_OK);
- code();
-
- known_options.compressed_size = 123456;
- known_options.uncompressed_size = 234567;
- assert_lzma_ret(lzma_block_header_size(&known_options), LZMA_OK);
- code();
+ assert_uint_eq(block_actual->version, block_expected->version);
+ assert_uint_eq(block_actual->compressed_size,
+ block_expected->compressed_size);
+ assert_uint_eq(block_actual->uncompressed_size,
+ block_expected->uncompressed_size);
+ assert_uint_eq(block_actual->check, block_expected->check);
+ assert_uint_eq(block_actual->header_size, block_expected->header_size);
+
+ // Compare filter IDs
+ assert_true(block_expected->filters && block_actual->filters);
+ lzma_filter expected_filter = block_expected->filters[0];
+ uint32_t filter_count = 0;
+ while (expected_filter.id != LZMA_VLI_UNKNOWN) {
+ assert_uint_eq(block_actual->filters[filter_count].id,
+ expected_filter.id);
+ expected_filter = block_expected->filters[++filter_count];
+ }
- // We can make the sizes smaller while keeping the header size
- // the same.
- known_options.compressed_size = 12;
- known_options.uncompressed_size = 23;
- code();
+ assert_uint_eq(block_actual->filters[filter_count].id,
+ LZMA_VLI_UNKNOWN);
}
+#endif
static void
-test3(void)
+test_lzma_block_header_decode(void)
{
- known_options = (lzma_block){
- .check = LZMA_CHECK_CRC32,
+#if !defined(HAVE_ENCODERS) || !defined(HAVE_DECODERS)
+ assert_skip("Encoder or decoder support disabled");
+#else
+ if (!lzma_filter_encoder_is_supported(LZMA_FILTER_X86)
+ || !lzma_filter_decoder_is_supported(LZMA_FILTER_X86))
+ assert_skip("x86 BCJ encoder and/or decoder "
+ "is disabled");
+
+ lzma_block block = {
+ .filters = filters_one,
.compressed_size = LZMA_VLI_UNKNOWN,
.uncompressed_size = LZMA_VLI_UNKNOWN,
- .filters = filters_one,
+ .check = LZMA_CHECK_CRC32,
+ .version = 0
};
- assert_lzma_ret(lzma_block_header_size(&known_options), LZMA_OK);
- known_options.header_size += 4;
- assert_lzma_ret(lzma_block_header_encode(&known_options, buf),
+ assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
+
+ // Encode block header with simple options
+ uint8_t out[LZMA_BLOCK_HEADER_SIZE_MAX];
+ assert_lzma_ret(lzma_block_header_encode(&block, out), LZMA_OK);
+
+ // Decode block header and check that the options match
+ lzma_filter decoded_filters[LZMA_FILTERS_MAX + 1];
+ lzma_block decoded_block = {
+ .version = 0,
+ .filters = decoded_filters,
+ .check = LZMA_CHECK_CRC32
+ };
+ decoded_block.header_size = lzma_block_header_size_decode(out[0]);
+
+ assert_lzma_ret(lzma_block_header_decode(&decoded_block, NULL, out),
+ LZMA_OK);
+ compare_blocks(&block, &decoded_block);
+
+ // Reset output buffer and decoded_block
+ memzero(out, LZMA_BLOCK_HEADER_SIZE_MAX);
+ memzero(&decoded_block, sizeof(lzma_block));
+ decoded_block.filters = decoded_filters;
+ decoded_block.check = LZMA_CHECK_CRC32;
+
+ // Test with compressed size set
+ block.compressed_size = 4096;
+ assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
+ assert_lzma_ret(lzma_block_header_encode(&block, out), LZMA_OK);
+ decoded_block.header_size = lzma_block_header_size_decode(out[0]);
+ assert_lzma_ret(lzma_block_header_decode(&decoded_block, NULL, out),
+ LZMA_OK);
+ compare_blocks(&block, &decoded_block);
+
+ memzero(out, LZMA_BLOCK_HEADER_SIZE_MAX);
+ memzero(&decoded_block, sizeof(lzma_block));
+ decoded_block.filters = decoded_filters;
+ decoded_block.check = LZMA_CHECK_CRC32;
+
+ // Test with uncompressed size set
+ block.uncompressed_size = 4096;
+ assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
+ assert_lzma_ret(lzma_block_header_encode(&block, out), LZMA_OK);
+ decoded_block.header_size = lzma_block_header_size_decode(out[0]);
+ assert_lzma_ret(lzma_block_header_decode(&decoded_block, NULL, out),
+ LZMA_OK);
+ compare_blocks(&block, &decoded_block);
+
+ memzero(out, LZMA_BLOCK_HEADER_SIZE_MAX);
+ memzero(&decoded_block, sizeof(lzma_block));
+ decoded_block.filters = decoded_filters;
+ decoded_block.check = LZMA_CHECK_CRC32;
+
+ // Test with multiple filters
+ block.filters = filters_four;
+ assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
+ assert_lzma_ret(lzma_block_header_encode(&block, out), LZMA_OK);
+ decoded_block.header_size = lzma_block_header_size_decode(out[0]);
+ assert_lzma_ret(lzma_block_header_decode(&decoded_block, NULL, out),
LZMA_OK);
+ compare_blocks(&block, &decoded_block);
- lzma_filter filters[LZMA_FILTERS_MAX + 1];
- decoded_options.header_size = known_options.header_size;
- decoded_options.check = known_options.check;
- decoded_options.filters = filters;
+ memzero(&decoded_block, sizeof(lzma_block));
+ decoded_block.filters = decoded_filters;
+ decoded_block.check = LZMA_CHECK_CRC32;
+ decoded_block.header_size = lzma_block_header_size_decode(out[0]);
- // Wrong size
- ++buf[0];
- assert_lzma_ret(lzma_block_header_decode(&decoded_options, NULL, buf),
+ // Test with too high version. The decoder will set it to a version
+ // that it supports.
+ decoded_block.version = 2;
+ assert_lzma_ret(lzma_block_header_decode(&decoded_block, NULL, out),
+ LZMA_OK);
+ assert_uint_eq(decoded_block.version, 1);
+
+ // Test bad check type
+ decoded_block.check = LZMA_CHECK_ID_MAX + 1;
+ assert_lzma_ret(lzma_block_header_decode(&decoded_block, NULL, out),
LZMA_PROG_ERROR);
- --buf[0];
+ decoded_block.check = LZMA_CHECK_CRC32;
- // Wrong CRC32
- buf[known_options.header_size - 1] ^= 1;
- assert_lzma_ret(lzma_block_header_decode(&decoded_options, NULL, buf),
+ // Test bad check value
+ out[decoded_block.header_size - 1] -= 10;
+ assert_lzma_ret(lzma_block_header_decode(&decoded_block, NULL, out),
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;
- write32le(buf + known_options.header_size - 4,
- lzma_crc32(buf, known_options.header_size - 4, 0));
- assert_lzma_ret(lzma_block_header_decode(&decoded_options, NULL, buf),
+ out[decoded_block.header_size - 1] += 10;
+
+ // Test non-NULL padding
+ out[decoded_block.header_size - 5] = 1;
+
+ // Recompute CRC32
+ write32le(&out[decoded_block.header_size - 4], lzma_crc32(out,
+ decoded_block.header_size - 4, 0));
+ assert_lzma_ret(lzma_block_header_decode(&decoded_block, NULL, out),
LZMA_OPTIONS_ERROR);
- buf[2] ^= 0x1F;
- // Non-nul Padding
- buf[known_options.header_size - 4 - 1] ^= 1;
- write32le(buf + known_options.header_size - 4,
- lzma_crc32(buf, known_options.header_size - 4, 0));
- assert_lzma_ret(lzma_block_header_decode(&decoded_options, NULL, buf),
+ // Test unsupported flags
+ out[1] = 0xFF;
+
+ // Recompute CRC32
+ write32le(&out[decoded_block.header_size - 4], lzma_crc32(out,
+ decoded_block.header_size - 4, 0));
+ assert_lzma_ret(lzma_block_header_decode(&decoded_block, NULL, out),
LZMA_OPTIONS_ERROR);
- buf[known_options.header_size - 4 - 1] ^= 1;
+#endif
}
@@ -240,17 +499,12 @@ main(int argc, char **argv)
{
tuktest_start(argc, argv);
- if (!lzma_filter_encoder_is_supported(LZMA_FILTER_X86)
- || !lzma_filter_decoder_is_supported(LZMA_FILTER_X86))
- tuktest_early_skip("x86 BCJ encoder and/or decoder "
- "is disabled");
-
if (lzma_lzma_preset(&opt_lzma, 1))
tuktest_error("lzma_lzma_preset() failed");
- tuktest_run(test1);
- tuktest_run(test2);
- tuktest_run(test3);
+ tuktest_run(test_lzma_block_header_size);
+ tuktest_run(test_lzma_block_header_encode);
+ tuktest_run(test_lzma_block_header_decode);
return tuktest_end();
}