laag-xz 5.2.4.0

data/vendor/git.tukaani.org/xz/tests/test_check.c

@@ -0,0 +1,83 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       test_check.c
+/// \brief      Tests integrity checks
+///
+/// \todo       Add SHA256
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "tests.h"
+
+
+static const uint8_t test_string[9] = "123456789";
+static const uint8_t test_unaligned[12] = "xxx123456789";
+
+
+static bool
+test_crc32(void)
+{
+	static const uint32_t test_vector = 0xCBF43926;
+
+	// Test 1
+	uint32_t crc = lzma_crc32(test_string, sizeof(test_string), 0);
+	if (crc != test_vector)
+		return true;
+
+	// Test 2
+	crc = lzma_crc32(test_unaligned + 3, sizeof(test_string), 0);
+	if (crc != test_vector)
+		return true;
+
+	// Test 3
+	crc = 0;
+	for (size_t i = 0; i < sizeof(test_string); ++i)
+		crc = lzma_crc32(test_string + i, 1, crc);
+	if (crc != test_vector)
+		return true;
+
+	return false;
+}
+
+
+static bool
+test_crc64(void)
+{
+	static const uint64_t test_vector = 0x995DC9BBDF1939FA;
+
+	// Test 1
+	uint64_t crc = lzma_crc64(test_string, sizeof(test_string), 0);
+	if (crc != test_vector)
+		return true;
+
+	// Test 2
+	crc = lzma_crc64(test_unaligned + 3, sizeof(test_string), 0);
+	if (crc != test_vector)
+		return true;
+
+	// Test 3
+	crc = 0;
+	for (size_t i = 0; i < sizeof(test_string); ++i)
+		crc = lzma_crc64(test_string + i, 1, crc);
+	if (crc != test_vector)
+		return true;
+
+	return false;
+}
+
+
+int
+main(void)
+{
+	bool error = false;
+
+	error |= test_crc32();
+	error |= test_crc64();
+
+	return error ? 1 : 0;
+}

data/vendor/git.tukaani.org/xz/tests/test_compress.sh

@@ -0,0 +1,142 @@
+#!/bin/sh
+
+###############################################################################
+#
+# Author: Lasse Collin
+#
+# This file has been put into the public domain.
+# You can do whatever you want with this file.
+#
+###############################################################################
+
+# If xz wasn't built, this test is skipped.
+if test -x ../src/xz/xz ; then
+	:
+else
+	(exit 77)
+	exit 77
+fi
+
+# Find out if our shell supports functions.
+eval 'unset foo ; foo() { return 42; } ; foo'
+if test $? != 42 ; then
+	echo "/bin/sh doesn't support functions, skipping this test."
+	(exit 77)
+	exit 77
+fi
+
+test_xz() {
+	if $XZ -c "$@" "$FILE" > tmp_compressed; then
+		:
+	else
+		echo "Compressing failed: $* $FILE"
+		(exit 1)
+		exit 1
+	fi
+
+	if $XZ -cd tmp_compressed > tmp_uncompressed ; then
+		:
+	else
+		echo "Decompressing failed: $* $FILE"
+		(exit 1)
+		exit 1
+	fi
+
+	if cmp tmp_uncompressed "$FILE" ; then
+		:
+	else
+		echo "Decompressed file does not match" \
+				"the original: $* $FILE"
+		(exit 1)
+		exit 1
+	fi
+
+	if test -n "$XZDEC" ; then
+		if $XZDEC tmp_compressed > tmp_uncompressed ; then
+			:
+		else
+			echo "Decompressing failed: $* $FILE"
+			(exit 1)
+			exit 1
+		fi
+
+		if cmp tmp_uncompressed "$FILE" ; then
+			:
+		else
+			echo "Decompressed file does not match" \
+					"the original: $* $FILE"
+			(exit 1)
+			exit 1
+		fi
+	fi
+
+	# Show progress:
+	echo . | tr -d '\n\r'
+}
+
+XZ="../src/xz/xz --memlimit-compress=48MiB --memlimit-decompress=5MiB \
+		--no-adjust --threads=1 --check=crc64"
+XZDEC="../src/xzdec/xzdec" # No memory usage limiter available
+test -x ../src/xzdec/xzdec || XZDEC=
+
+# Create the required input files.
+if ./create_compress_files ; then
+	:
+else
+	rm -f compress_*
+	echo "Failed to create files to test compression."
+	(exit 1)
+	exit 1
+fi
+
+# Remove temporary now (in case they are something weird), and on exit.
+rm -f tmp_compressed tmp_uncompressed
+trap 'rm -f tmp_compressed tmp_uncompressed' 0
+
+# Compress and decompress each file with various filter configurations.
+# This takes quite a bit of time.
+echo "test_compress.sh:"
+for FILE in compress_generated_* "$srcdir"/compress_prepared_*
+do
+	MSG=`echo "x$FILE" | sed 's,^x,,; s,^.*/,,; s,^compress_,,'`
+	echo "  $MSG" | tr -d '\n\r'
+
+	# Don't test with empty arguments; it breaks some ancient
+	# proprietary /bin/sh versions due to $@ used in test_xz().
+	test_xz -1
+	test_xz -2
+	test_xz -3
+	test_xz -4
+
+	# Disabled until Subblock format is stable.
+#		--subblock \
+#		--subblock=size=1 \
+#		--subblock=size=1,rle=1 \
+#		--subblock=size=1,rle=4 \
+#		--subblock=size=4,rle=4 \
+#		--subblock=size=8,rle=4 \
+#		--subblock=size=8,rle=8 \
+#		--subblock=size=4096,rle=12 \
+#
+	for ARGS in \
+		--delta=dist=1 \
+		--delta=dist=4 \
+		--delta=dist=256 \
+		--x86 \
+		--powerpc \
+		--ia64 \
+		--arm \
+		--armthumb \
+		--sparc
+	do
+		test_xz $ARGS --lzma2=dict=64KiB,nice=32,mode=fast
+
+		# Disabled until Subblock format is stable.
+		# test_xz --subblock $ARGS --lzma2=dict=64KiB,nice=32,mode=fast
+	done
+
+	echo
+done
+
+(exit 0)
+exit 0

data/vendor/git.tukaani.org/xz/tests/test_files.sh

@@ -0,0 +1,57 @@
+#!/bin/sh
+
+###############################################################################
+#
+# Author: Lasse Collin
+#
+# This file has been put into the public domain.
+# You can do whatever you want with this file.
+#
+###############################################################################
+
+# If both xz and xzdec were not build, skip this test.
+XZ=../src/xz/xz
+XZDEC=../src/xzdec/xzdec
+test -x "$XZ" || XZ=
+test -x "$XZDEC" || XZDEC=
+if test -z "$XZ$XZDEC"; then
+	(exit 77)
+	exit 77
+fi
+
+for I in "$srcdir"/files/good-*.xz
+do
+	if test -z "$XZ" || "$XZ" -dc "$I" > /dev/null; then
+		:
+	else
+		echo "Good file failed: $I"
+		(exit 1)
+		exit 1
+	fi
+
+	if test -z "$XZDEC" || "$XZDEC" "$I" > /dev/null; then
+		:
+	else
+		echo "Good file failed: $I"
+		(exit 1)
+		exit 1
+	fi
+done
+
+for I in "$srcdir"/files/bad-*.xz
+do
+	if test -n "$XZ" && "$XZ" -dc "$I" > /dev/null 2>&1; then
+		echo "Bad file succeeded: $I"
+		(exit 1)
+		exit 1
+	fi
+
+	if test -n "$XZDEC" && "$XZDEC" "$I" > /dev/null 2>&1; then
+		echo "Bad file succeeded: $I"
+		(exit 1)
+		exit 1
+	fi
+done
+
+(exit 0)
+exit 0

data/vendor/git.tukaani.org/xz/tests/test_filter_flags.c

@@ -0,0 +1,258 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       test_filter_flags.c
+/// \brief      Tests Filter Flags coders
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "tests.h"
+
+
+static uint8_t buffer[4096];
+static lzma_filter known_flags;
+static lzma_filter decoded_flags;
+static lzma_stream strm = LZMA_STREAM_INIT;
+
+
+static bool
+encode(uint32_t known_size)
+{
+	memcrap(buffer, sizeof(buffer));
+
+	uint32_t tmp;
+	if (lzma_filter_flags_size(&tmp, &known_flags) != LZMA_OK)
+		return true;
+
+	if (tmp != known_size)
+		return true;
+
+	size_t out_pos = 0;
+	if (lzma_filter_flags_encode(&known_flags,
+			buffer, &out_pos, known_size) != LZMA_OK)
+		return true;
+
+	if (out_pos != known_size)
+		return true;
+
+	return false;
+}
+
+
+static bool
+decode_ret(uint32_t known_size, lzma_ret expected_ret)
+{
+	memcrap(&decoded_flags, sizeof(decoded_flags));
+
+	size_t pos = 0;
+	if (lzma_filter_flags_decode(&decoded_flags, NULL,
+				buffer, &pos, known_size) != expected_ret
+			|| pos != known_size)
+		return true;
+
+	return false;
+}
+
+
+static bool
+decode(uint32_t known_size)
+{
+	if (decode_ret(known_size, LZMA_OK))
+		return true;
+
+	if (known_flags.id != decoded_flags.id)
+		return true;
+
+	return false;
+}
+
+
+#if defined(HAVE_ENCODER_X86) && defined(HAVE_DECODER_X86)
+static void
+test_bcj(void)
+{
+	// Test 1
+	known_flags.id = LZMA_FILTER_X86;
+	known_flags.options = NULL;
+
+	expect(!encode(2));
+	expect(!decode(2));
+	expect(decoded_flags.options == NULL);
+
+	// Test 2
+	lzma_options_bcj options;
+	options.start_offset = 0;
+	known_flags.options = &options;
+	expect(!encode(2));
+	expect(!decode(2));
+	expect(decoded_flags.options == NULL);
+
+	// Test 3
+	options.start_offset = 123456;
+	known_flags.options = &options;
+	expect(!encode(6));
+	expect(!decode(6));
+	expect(decoded_flags.options != NULL);
+
+	lzma_options_bcj *decoded = decoded_flags.options;
+	expect(decoded->start_offset == options.start_offset);
+
+	free(decoded);
+}
+#endif
+
+
+#if defined(HAVE_ENCODER_DELTA) && defined(HAVE_DECODER_DELTA)
+static void
+test_delta(void)
+{
+	// Test 1
+	known_flags.id = LZMA_FILTER_DELTA;
+	known_flags.options = NULL;
+	expect(encode(99));
+
+	// Test 2
+	lzma_options_delta options = {
+		.type = LZMA_DELTA_TYPE_BYTE,
+		.dist = 0
+	};
+	known_flags.options = &options;
+	expect(encode(99));
+
+	// Test 3
+	options.dist = LZMA_DELTA_DIST_MIN;
+	expect(!encode(3));
+	expect(!decode(3));
+	expect(((lzma_options_delta *)(decoded_flags.options))->dist
+			== options.dist);
+
+	free(decoded_flags.options);
+
+	// Test 4
+	options.dist = LZMA_DELTA_DIST_MAX;
+	expect(!encode(3));
+	expect(!decode(3));
+	expect(((lzma_options_delta *)(decoded_flags.options))->dist
+			== options.dist);
+
+	free(decoded_flags.options);
+
+	// Test 5
+	options.dist = LZMA_DELTA_DIST_MAX + 1;
+	expect(encode(99));
+}
+#endif
+
+/*
+#ifdef HAVE_FILTER_LZMA
+static void
+validate_lzma(void)
+{
+	const lzma_options_lzma *known = known_flags.options;
+	const lzma_options_lzma *decoded = decoded_flags.options;
+
+	expect(known->dictionary_size <= decoded->dictionary_size);
+
+	if (known->dictionary_size == 1)
+		expect(decoded->dictionary_size == 1);
+	else
+		expect(known->dictionary_size + known->dictionary_size / 2
+				> decoded->dictionary_size);
+
+	expect(known->literal_context_bits == decoded->literal_context_bits);
+	expect(known->literal_pos_bits == decoded->literal_pos_bits);
+	expect(known->pos_bits == decoded->pos_bits);
+}
+
+
+static void
+test_lzma(void)
+{
+	// Test 1
+	known_flags.id = LZMA_FILTER_LZMA1;
+	known_flags.options = NULL;
+	expect(encode(99));
+
+	// Test 2
+	lzma_options_lzma options = {
+		.dictionary_size = 0,
+		.literal_context_bits = 0,
+		.literal_pos_bits = 0,
+		.pos_bits = 0,
+		.preset_dictionary = NULL,
+		.preset_dictionary_size = 0,
+		.mode = LZMA_MODE_INVALID,
+		.fast_bytes = 0,
+		.match_finder = LZMA_MF_INVALID,
+		.match_finder_cycles = 0,
+	};
+
+	// Test 3 (empty dictionary not allowed)
+	known_flags.options = &options;
+	expect(encode(99));
+
+	// Test 4 (brute-force test some valid dictionary sizes)
+	options.dictionary_size = LZMA_DICTIONARY_SIZE_MIN;
+	while (options.dictionary_size != LZMA_DICTIONARY_SIZE_MAX) {
+		if (++options.dictionary_size == 5000)
+			options.dictionary_size = LZMA_DICTIONARY_SIZE_MAX - 5;
+
+		expect(!encode(4));
+		expect(!decode(4));
+		validate_lzma();
+
+		free(decoded_flags.options);
+	}
+
+	// Test 5 (too big dictionary size)
+	options.dictionary_size = LZMA_DICTIONARY_SIZE_MAX + 1;
+	expect(encode(99));
+
+	// Test 6 (brute-force test lc/lp/pb)
+	options.dictionary_size = LZMA_DICTIONARY_SIZE_MIN;
+	for (uint32_t lc = LZMA_LITERAL_CONTEXT_BITS_MIN;
+			lc <= LZMA_LITERAL_CONTEXT_BITS_MAX; ++lc) {
+		for (uint32_t lp = LZMA_LITERAL_POS_BITS_MIN;
+				lp <= LZMA_LITERAL_POS_BITS_MAX; ++lp) {
+			for (uint32_t pb = LZMA_POS_BITS_MIN;
+					pb <= LZMA_POS_BITS_MAX; ++pb) {
+				if (lc + lp > LZMA_LITERAL_BITS_MAX)
+					continue;
+
+				options.literal_context_bits = lc;
+				options.literal_pos_bits = lp;
+				options.pos_bits = pb;
+
+				expect(!encode(4));
+				expect(!decode(4));
+				validate_lzma();
+
+				free(decoded_flags.options);
+			}
+		}
+	}
+}
+#endif
+*/
+
+int
+main(void)
+{
+#if defined(HAVE_ENCODER_X86) && defined(HAVE_DECODER_X86)
+	test_bcj();
+#endif
+#if defined(HAVE_ENCODER_DELTA) && defined(HAVE_DECODER_DELTA)
+	test_delta();
+#endif
+// #ifdef HAVE_FILTER_LZMA
+// 	test_lzma();
+// #endif
+
+	lzma_end(&strm);
+
+	return 0;
+}