summaryrefslogtreecommitdiffstats
path: root/tests/test_index.c
diff options
context:
space:
mode:
Diffstat (limited to 'tests/test_index.c')
-rw-r--r--tests/test_index.c192
1 files changed, 134 insertions, 58 deletions
diff --git a/tests/test_index.c b/tests/test_index.c
index a14b33d..ba1b978 100644
--- a/tests/test_index.c
+++ b/tests/test_index.c
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: 0BSD
+
///////////////////////////////////////////////////////////////////////////////
//
/// \file test_index.c
@@ -8,10 +10,6 @@
// Authors: Jia Tan
// Lasse Collin
//
-//
-// This file has been put into the public domain.
-// You can do whatever you want with this file.
-//
///////////////////////////////////////////////////////////////////////////////
#include "tests.h"
@@ -25,8 +23,11 @@
#define MEMLIMIT (UINT64_C(1) << 20)
+#ifdef HAVE_ENCODERS
static uint8_t *decode_buffer;
static size_t decode_buffer_size = 0;
+#endif
+
static lzma_index *decode_test_index;
@@ -44,8 +45,11 @@ test_lzma_index_memusage(void)
assert_uint_eq(lzma_index_memusage((lzma_vli)UINT32_MAX + 1, 1),
UINT64_MAX);
- // The maximum number of Blocks should be LZMA_VLI_MAX
- assert_uint_eq(lzma_index_memusage(1, LZMA_VLI_MAX), UINT64_MAX);
+ // While the number of blocks is lzma_vli, the real maximum value is
+ // much smaller than LZMA_VLI_MAX. Just check that it fails with a
+ // huge but valid VLI and that it succeeds with a smaller one.
+ assert_uint_eq(lzma_index_memusage(1, LZMA_VLI_MAX / 5), UINT64_MAX);
+ assert_uint(lzma_index_memusage(1, LZMA_VLI_MAX / 11), <, UINT64_MAX);
// Number of Streams must be non-zero
assert_uint_eq(lzma_index_memusage(0, 1), UINT64_MAX);
@@ -100,7 +104,7 @@ test_lzma_index_memused(void)
static void
test_lzma_index_append(void)
{
- // Basic input-ouput test done here.
+ // Basic input-output test done here.
// Less trivial tests for this function are done throughout
// other tests.
@@ -135,7 +139,7 @@ test_lzma_index_append(void)
lzma_index_end(idx, NULL);
// Test compressed .xz file size growing too large. This also tests
- // a failing assert fixed in 68bda971bb8b666a009331455fcedb4e18d837a4.
+ // a failing assert fixed in ae5c07b22a6b3766b84f409f1b6b5c100469068a.
// Should result in LZMA_DATA_ERROR.
idx = lzma_index_init(NULL);
@@ -224,28 +228,28 @@ test_lzma_index_checks(void)
assert_lzma_ret(lzma_index_stream_flags(idx, &stream_flags),
LZMA_OK);
assert_uint_eq(lzma_index_checks(idx),
- UINT32_C(1) << LZMA_CHECK_NONE);
+ LZMA_INDEX_CHECK_MASK_NONE);
// Set the check type to CRC32 and repeat
stream_flags.check = LZMA_CHECK_CRC32;
assert_lzma_ret(lzma_index_stream_flags(idx, &stream_flags),
LZMA_OK);
assert_uint_eq(lzma_index_checks(idx),
- UINT32_C(1) << LZMA_CHECK_CRC32);
+ LZMA_INDEX_CHECK_MASK_CRC32);
// Set the check type to CRC64 and repeat
stream_flags.check = LZMA_CHECK_CRC64;
assert_lzma_ret(lzma_index_stream_flags(idx, &stream_flags),
LZMA_OK);
assert_uint_eq(lzma_index_checks(idx),
- UINT32_C(1) << LZMA_CHECK_CRC64);
+ LZMA_INDEX_CHECK_MASK_CRC64);
// Set the check type to SHA256 and repeat
stream_flags.check = LZMA_CHECK_SHA256;
assert_lzma_ret(lzma_index_stream_flags(idx, &stream_flags),
LZMA_OK);
assert_uint_eq(lzma_index_checks(idx),
- UINT32_C(1) << LZMA_CHECK_SHA256);
+ LZMA_INDEX_CHECK_MASK_SHA256);
// Create second lzma_index and cat to first
lzma_index *second = lzma_index_init(NULL);
@@ -257,14 +261,14 @@ test_lzma_index_checks(void)
LZMA_OK);
assert_uint_eq(lzma_index_checks(second),
- UINT32_C(1) << LZMA_CHECK_CRC32);
+ LZMA_INDEX_CHECK_MASK_CRC32);
assert_lzma_ret(lzma_index_cat(idx, second, NULL), LZMA_OK);
// Index should now have both CRC32 and SHA256
assert_uint_eq(lzma_index_checks(idx),
- (UINT32_C(1) << LZMA_CHECK_CRC32) |
- (UINT32_C(1) << LZMA_CHECK_SHA256));
+ LZMA_INDEX_CHECK_MASK_CRC32 |
+ LZMA_INDEX_CHECK_MASK_SHA256);
// Change the check type of the second Stream to SHA256
stream_flags.check = LZMA_CHECK_SHA256;
@@ -273,7 +277,7 @@ test_lzma_index_checks(void)
// Index should now have only SHA256
assert_uint_eq(lzma_index_checks(idx),
- UINT32_C(1) << LZMA_CHECK_SHA256);
+ LZMA_INDEX_CHECK_MASK_SHA256);
// Test with a third Stream
lzma_index *third = lzma_index_init(NULL);
@@ -284,14 +288,14 @@ test_lzma_index_checks(void)
LZMA_OK);
assert_uint_eq(lzma_index_checks(third),
- UINT32_C(1) << LZMA_CHECK_CRC64);
+ LZMA_INDEX_CHECK_MASK_CRC64);
assert_lzma_ret(lzma_index_cat(idx, third, NULL), LZMA_OK);
// Index should now have CRC64 and SHA256
assert_uint_eq(lzma_index_checks(idx),
- (UINT32_C(1) << LZMA_CHECK_CRC64) |
- (UINT32_C(1) << LZMA_CHECK_SHA256));
+ LZMA_INDEX_CHECK_MASK_CRC64 |
+ LZMA_INDEX_CHECK_MASK_SHA256);
lzma_index_end(idx, NULL);
}
@@ -467,15 +471,18 @@ test_lzma_index_stream_size(void)
// Next, append a few Blocks and retest
assert_lzma_ret(lzma_index_append(idx, NULL, 1000, 1), LZMA_OK);
- assert_lzma_ret(lzma_index_append(idx, NULL, 1000, 1), LZMA_OK);
- assert_lzma_ret(lzma_index_append(idx, NULL, 1000, 1), LZMA_OK);
+ assert_lzma_ret(lzma_index_append(idx, NULL, 999, 1), LZMA_OK);
+ assert_lzma_ret(lzma_index_append(idx, NULL, 997, 1), LZMA_OK);
// Stream size should be:
// Size of Stream Header - 12 bytes
- // Size of all Blocks - 3000 bytes
+ // Size of all Blocks - 3000 bytes [*]
// Size of Index - 16 bytes
// Size of Stream Footer - 12 bytes
// Total: 3040 bytes
+ //
+ // [*] Block size is a multiple of 4 bytes so 999 and 997 get
+ // rounded up to 1000 bytes.
assert_uint_eq(lzma_index_stream_size(idx), 3040);
lzma_index *second = lzma_index_init(NULL);
@@ -520,10 +527,10 @@ test_lzma_index_total_size(void)
assert_lzma_ret(lzma_index_append(idx, NULL, 1000, 1), LZMA_OK);
assert_uint_eq(lzma_index_total_size(idx), 1000);
- assert_lzma_ret(lzma_index_append(idx, NULL, 1000, 1), LZMA_OK);
+ assert_lzma_ret(lzma_index_append(idx, NULL, 999, 1), LZMA_OK);
assert_uint_eq(lzma_index_total_size(idx), 2000);
- assert_lzma_ret(lzma_index_append(idx, NULL, 1000, 1), LZMA_OK);
+ assert_lzma_ret(lzma_index_append(idx, NULL, 997, 1), LZMA_OK);
assert_uint_eq(lzma_index_total_size(idx), 3000);
// Create second lzma_index and append Blocks to it.
@@ -545,6 +552,16 @@ test_lzma_index_total_size(void)
// from both Streams
assert_uint_eq(lzma_index_total_size(idx), 3200);
+ // Test sizes that aren't multiples of four bytes
+ assert_lzma_ret(lzma_index_append(idx, NULL, 11, 1), LZMA_OK);
+ assert_uint_eq(lzma_index_total_size(idx), 3212);
+
+ assert_lzma_ret(lzma_index_append(idx, NULL, 11, 1), LZMA_OK);
+ assert_uint_eq(lzma_index_total_size(idx), 3224);
+
+ assert_lzma_ret(lzma_index_append(idx, NULL, 9, 1), LZMA_OK);
+ assert_uint_eq(lzma_index_total_size(idx), 3236);
+
lzma_index_end(idx, NULL);
}
@@ -560,8 +577,8 @@ test_lzma_index_file_size(void)
assert_uint_eq(lzma_index_file_size(idx), 32);
assert_lzma_ret(lzma_index_append(idx, NULL, 1000, 1), LZMA_OK);
- assert_lzma_ret(lzma_index_append(idx, NULL, 1000, 1), LZMA_OK);
- assert_lzma_ret(lzma_index_append(idx, NULL, 1000, 1), LZMA_OK);
+ assert_lzma_ret(lzma_index_append(idx, NULL, 999, 1), LZMA_OK);
+ assert_lzma_ret(lzma_index_append(idx, NULL, 997, 1), LZMA_OK);
assert_uint_eq(lzma_index_file_size(idx), 3040);
@@ -690,6 +707,7 @@ test_lzma_index_iter_rewind(void)
assert_false(lzma_index_iter_next(&iter,
LZMA_INDEX_ITER_BLOCK));
assert_uint_eq(iter.block.number_in_file, i + 1);
+ assert_uint_eq(iter.block.number_in_stream, i + 1);
}
// Rewind back to the beginning and iterate over the Blocks again
@@ -700,6 +718,7 @@ test_lzma_index_iter_rewind(void)
assert_false(lzma_index_iter_next(&iter,
LZMA_INDEX_ITER_BLOCK));
assert_uint_eq(iter.block.number_in_file, i + 1);
+ assert_uint_eq(iter.block.number_in_stream, i + 1);
}
// Next concatenate two more lzma_indexes, iterate over them,
@@ -919,8 +938,9 @@ test_lzma_index_iter_next(void)
// Verify both Blocks
// Next call to iterate Block should return true because the
- // first Block can already be read from the LZMA_INDEX_ITER_STREAM
- // call.
+ // first Block can already be read from the earlier *successful*
+ // LZMA_INDEX_ITER_STREAM call; the previous failed call doesn't
+ // modify the iterator.
assert_true(lzma_index_iter_next(&iter, LZMA_INDEX_ITER_BLOCK));
// Rewind to test LZMA_INDEX_ITER_ANY
@@ -1046,13 +1066,14 @@ test_lzma_index_iter_locate(void)
lzma_index_iter_init(&iter, idx);
for (uint32_t n = 4; n <= 4 * 5555; n += 4)
- assert_lzma_ret(lzma_index_append(idx, NULL, n + 8, n),
+ assert_lzma_ret(lzma_index_append(idx, NULL, n + 7, n),
LZMA_OK);
assert_uint_eq(lzma_index_block_count(idx), 5555);
// First Record
assert_false(lzma_index_iter_locate(&iter, 0));
+ assert_uint_eq(iter.block.unpadded_size, 4 + 7);
assert_uint_eq(iter.block.total_size, 4 + 8);
assert_uint_eq(iter.block.uncompressed_size, 4);
assert_uint_eq(iter.block.compressed_file_offset,
@@ -1060,6 +1081,7 @@ test_lzma_index_iter_locate(void)
assert_uint_eq(iter.block.uncompressed_file_offset, 0);
assert_false(lzma_index_iter_locate(&iter, 3));
+ assert_uint_eq(iter.block.unpadded_size, 4 + 7);
assert_uint_eq(iter.block.total_size, 4 + 8);
assert_uint_eq(iter.block.uncompressed_size, 4);
assert_uint_eq(iter.block.compressed_file_offset,
@@ -1068,6 +1090,7 @@ test_lzma_index_iter_locate(void)
// Second Record
assert_false(lzma_index_iter_locate(&iter, 4));
+ assert_uint_eq(iter.block.unpadded_size, 2 * 4 + 7);
assert_uint_eq(iter.block.total_size, 2 * 4 + 8);
assert_uint_eq(iter.block.uncompressed_size, 2 * 4);
assert_uint_eq(iter.block.compressed_file_offset,
@@ -1077,6 +1100,7 @@ test_lzma_index_iter_locate(void)
// Last Record
assert_false(lzma_index_iter_locate(
&iter, lzma_index_uncompressed_size(idx) - 1));
+ assert_uint_eq(iter.block.unpadded_size, 4 * 5555 + 7);
assert_uint_eq(iter.block.total_size, 4 * 5555 + 8);
assert_uint_eq(iter.block.uncompressed_size, 4 * 5555);
assert_uint_eq(iter.block.compressed_file_offset,
@@ -1142,6 +1166,7 @@ test_lzma_index_iter_locate(void)
for (n = 0; n < group_multiple; ++n)
assert_lzma_ret(lzma_index_append(idx, NULL, 8, 0),
LZMA_OK);
+
assert_lzma_ret(lzma_index_append(idx, NULL, 16, 1), LZMA_OK);
assert_false(lzma_index_iter_locate(&iter, 0));
assert_uint_eq(iter.block.total_size, 16);
@@ -1171,17 +1196,17 @@ test_lzma_index_cat(void)
assert_lzma_ret(lzma_index_cat(dest, NULL, NULL), LZMA_PROG_ERROR);
assert_lzma_ret(lzma_index_cat(NULL, src, NULL), LZMA_PROG_ERROR);
- // Check for uncompressed size overflow
+ // Check for compressed size overflow
assert_lzma_ret(lzma_index_append(dest, NULL,
(UNPADDED_SIZE_MAX / 2) + 1, 1), LZMA_OK);
assert_lzma_ret(lzma_index_append(src, NULL,
(UNPADDED_SIZE_MAX / 2) + 1, 1), LZMA_OK);
assert_lzma_ret(lzma_index_cat(dest, src, NULL), LZMA_DATA_ERROR);
- // Check for compressed size overflow
lzma_index_end(src, NULL);
lzma_index_end(dest, NULL);
+ // Check for uncompressed size overflow
dest = lzma_index_init(NULL);
assert_true(dest != NULL);
@@ -1189,9 +1214,9 @@ test_lzma_index_cat(void)
assert_true(src != NULL);
assert_lzma_ret(lzma_index_append(dest, NULL,
- UNPADDED_SIZE_MIN, LZMA_VLI_MAX - 1), LZMA_OK);
+ UNPADDED_SIZE_MIN, (LZMA_VLI_MAX / 2) + 1), LZMA_OK);
assert_lzma_ret(lzma_index_append(src, NULL,
- UNPADDED_SIZE_MIN, LZMA_VLI_MAX - 1), LZMA_OK);
+ UNPADDED_SIZE_MIN, (LZMA_VLI_MAX / 2) + 1), LZMA_OK);
assert_lzma_ret(lzma_index_cat(dest, src, NULL), LZMA_DATA_ERROR);
lzma_index_end(dest, NULL);
@@ -1263,13 +1288,17 @@ my_alloc(void *opaque, size_t a, size_t b)
{
(void)opaque;
+ assert_true(SIZE_MAX / a >= b);
+
static unsigned count = 0;
- if (++count > 2)
+ if (count >= 2)
return NULL;
+ ++count;
return malloc(a * b);
}
+
static const lzma_allocator test_index_dup_alloc = { &my_alloc, NULL, NULL };
@@ -1326,6 +1355,7 @@ test_lzma_index_dup(void)
lzma_index_end(idx, NULL);
}
+
#if defined(HAVE_ENCODERS) && defined(HAVE_DECODERS)
static void
verify_index_buffer(const lzma_index *idx, const uint8_t *buffer,
@@ -1459,31 +1489,30 @@ test_lzma_index_encoder(void)
#endif
}
+
static void
generate_index_decode_buffer(void)
{
#ifdef HAVE_ENCODERS
decode_test_index = lzma_index_init(NULL);
- if (decode_test_index == NULL)
- return;
+ assert_true(decode_test_index != NULL);
// Add 4 Blocks
for (uint32_t i = 1; i < 5; i++)
- if (lzma_index_append(decode_test_index, NULL,
- 0x1000 * i, 0x100 * i) != LZMA_OK)
- return;
+ assert_lzma_ret(lzma_index_append(decode_test_index, NULL,
+ 0x1000 * i, 0x100 * i), LZMA_OK);
- size_t size = lzma_index_size(decode_test_index);
+ const size_t size = (size_t)lzma_index_size(decode_test_index);
decode_buffer = tuktest_malloc(size);
- if (lzma_index_buffer_encode(decode_test_index,
- decode_buffer, &decode_buffer_size, size) != LZMA_OK)
- decode_buffer_size = 0;
+ assert_lzma_ret(lzma_index_buffer_encode(decode_test_index,
+ decode_buffer, &decode_buffer_size, size), LZMA_OK);
+ assert_true(decode_buffer_size != 0);
#endif
}
-#ifdef HAVE_DECODERS
+#if defined(HAVE_ENCODERS) && defined(HAVE_DECODERS)
static void
decode_index(const uint8_t *buffer, const size_t size, lzma_stream *strm,
lzma_ret expected_error)
@@ -1498,11 +1527,10 @@ decode_index(const uint8_t *buffer, const size_t size, lzma_stream *strm,
static void
test_lzma_index_decoder(void)
{
-#ifndef HAVE_DECODERS
- assert_skip("Decoder support disabled");
+#if !defined(HAVE_ENCODERS) || !defined(HAVE_DECODERS)
+ assert_skip("Encoder or decoder support disabled");
#else
- if (decode_buffer_size == 0)
- assert_skip("Could not initialize decode test buffer");
+ assert_true(decode_buffer_size != 0);
lzma_stream strm = LZMA_STREAM_INIT;
@@ -1510,11 +1538,21 @@ test_lzma_index_decoder(void)
LZMA_PROG_ERROR);
assert_lzma_ret(lzma_index_decoder(&strm, NULL, MEMLIMIT),
LZMA_PROG_ERROR);
- assert_lzma_ret(lzma_index_decoder(NULL, &decode_test_index,
- MEMLIMIT), LZMA_PROG_ERROR);
+
+ // If the first argument (lzma_stream *strm) is NULL then
+ // *idx must still become NULL since the API docs say that
+ // it's done if an error occurs. This was fixed in
+ // 71eed2520e2eecae89bade9dceea16e56cfa2ea0.
+ lzma_index *idx_allocated = lzma_index_init(NULL);
+ lzma_index *idx = idx_allocated;
+ assert_lzma_ret(lzma_index_decoder(NULL, &idx, MEMLIMIT),
+ LZMA_PROG_ERROR);
+ assert_true(idx == NULL);
+
+ lzma_index_end(idx_allocated, NULL);
+ idx_allocated = NULL;
// Do actual decode
- lzma_index *idx;
assert_lzma_ret(lzma_index_decoder(&strm, &idx, MEMLIMIT),
LZMA_OK);
@@ -1579,8 +1617,8 @@ test_lzma_index_buffer_encode(void)
#if !defined(HAVE_ENCODERS) || !defined(HAVE_DECODERS)
assert_skip("Encoder or decoder support disabled");
#else
- // More simple test than test_lzma_index_encoder() because
- // currently lzma_index_buffer_encode() is mostly a wrapper
+ // These are simpler test than in test_lzma_index_encoder()
+ // because lzma_index_buffer_encode() is mostly a wrapper
// around lzma_index_encoder() anyway.
lzma_index *idx = lzma_index_init(NULL);
assert_true(idx != NULL);
@@ -1607,6 +1645,9 @@ test_lzma_index_buffer_encode(void)
0), LZMA_PROG_ERROR);
out_pos = 0;
assert_lzma_ret(lzma_index_buffer_encode(idx, buffer, &out_pos,
+ 0), LZMA_BUF_ERROR);
+ assert_uint_eq(out_pos, 0);
+ assert_lzma_ret(lzma_index_buffer_encode(idx, buffer, &out_pos,
1), LZMA_BUF_ERROR);
// Do encoding
@@ -1625,11 +1666,10 @@ test_lzma_index_buffer_encode(void)
static void
test_lzma_index_buffer_decode(void)
{
-#ifndef HAVE_DECODERS
- assert_skip("Decoder support disabled");
+#if !defined(HAVE_ENCODERS) || !defined(HAVE_DECODERS)
+ assert_skip("Encoder or decoder support disabled");
#else
- if (decode_buffer_size == 0)
- assert_skip("Could not initialize decode test buffer");
+ assert_true(decode_buffer_size != 0);
// Simple test since test_lzma_index_decoder() covers most of the
// lzma_index_buffer_decode() code anyway.
@@ -1638,34 +1678,70 @@ test_lzma_index_buffer_decode(void)
assert_lzma_ret(lzma_index_buffer_decode(NULL, NULL, NULL, NULL,
NULL, 0), LZMA_PROG_ERROR);
- lzma_index *idx;
uint64_t memlimit = MEMLIMIT;
size_t in_pos = 0;
+ lzma_index *idx_allocated = lzma_index_init(NULL);
+ lzma_index *idx = idx_allocated;
assert_lzma_ret(lzma_index_buffer_decode(&idx, NULL, NULL, NULL,
NULL, 0), LZMA_PROG_ERROR);
+ assert_true(idx == NULL);
+ idx = idx_allocated;
assert_lzma_ret(lzma_index_buffer_decode(&idx, &memlimit, NULL,
NULL, NULL, 0), LZMA_PROG_ERROR);
+ assert_true(idx == NULL);
+ idx = idx_allocated;
assert_lzma_ret(lzma_index_buffer_decode(&idx, &memlimit, NULL,
decode_buffer, NULL, 0), LZMA_PROG_ERROR);
+ assert_true(idx == NULL);
+ idx = idx_allocated;
assert_lzma_ret(lzma_index_buffer_decode(&idx, &memlimit, NULL,
decode_buffer, NULL, 0), LZMA_PROG_ERROR);
+ assert_true(idx == NULL);
+ idx = idx_allocated;
assert_lzma_ret(lzma_index_buffer_decode(&idx, &memlimit, NULL,
decode_buffer, &in_pos, 0), LZMA_DATA_ERROR);
+ assert_true(idx == NULL);
in_pos = 1;
+ idx = idx_allocated;
assert_lzma_ret(lzma_index_buffer_decode(&idx, &memlimit, NULL,
decode_buffer, &in_pos, 0), LZMA_PROG_ERROR);
+ assert_true(idx == NULL);
+
+ // Test too short input
in_pos = 0;
+ idx = idx_allocated;
+ assert_lzma_ret(lzma_index_buffer_decode(&idx, &memlimit, NULL,
+ decode_buffer, &in_pos, decode_buffer_size - 1),
+ LZMA_DATA_ERROR);
+ assert_true(idx == NULL);
+
+ lzma_index_end(idx_allocated, NULL);
+ idx_allocated = NULL;
// Test expected successful decode
+ in_pos = 0;
assert_lzma_ret(lzma_index_buffer_decode(&idx, &memlimit, NULL,
decode_buffer, &in_pos, decode_buffer_size), LZMA_OK);
+ assert_uint_eq(in_pos, decode_buffer_size);
+ assert_true(index_is_equal(decode_test_index, idx));
+
+ lzma_index_end(idx, NULL);
+
+ // Test too much input. This won't read past
+ // the end of the allocated array (decode_buffer_size bytes).
+ in_pos = 0;
+ assert_lzma_ret(lzma_index_buffer_decode(&idx, &memlimit, NULL,
+ decode_buffer, &in_pos, decode_buffer_size + 16),
+ LZMA_OK);
+
+ assert_uint_eq(in_pos, decode_buffer_size);
assert_true(index_is_equal(decode_test_index, idx));
lzma_index_end(idx, NULL);