aboutsummaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--tests/Makefile.am5
-rw-r--r--tests/test_block_header.c411
-rwxr-xr-xtests/test_compress.sh65
-rw-r--r--tests/test_filter_flags.c116
-rw-r--r--tests/test_index.c504
-rw-r--r--tests/test_info.c717
-rw-r--r--tests/test_stream_flags.c134
-rw-r--r--tests/tests.h14
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;
}