mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: "S. Biplab Raut" <Biplab.Raut@amd.com>
To: Michal Wilczynski <m.wilczynski@samsung.com>
Cc: Andrew Morton <akpm@linux-foundation.org>,
	Gao Xiang <xiang@kernel.org>,
	linux-erofs@lists.ozlabs.org,
	Yann Collet <yann.collet.73@gmail.com>,
	Nick Terrell <terrelln@meta.com>,
	Brendan Higgins <brendan.higgins@linux.dev>,
	David Gow <david@davidgow.net>, Rae Moar <raemoar63@gmail.com>,
	kunit-dev@googlegroups.com, linux-kselftest@vger.kernel.org,
	linux-kernel@vger.kernel.org
Subject: [PATCH] lib/lz4: add KUnit tests for compression and decompression
Date: Wed, 18 Nov 2026 18:23:43 +0000	[thread overview]
Message-ID: <20261118182343.1628236-1-Biplab.Raut@amd.com> (raw)
In-Reply-To: <20261106-lz4-vendor-upstream-v2-0-ee04c3f0d7dc@samsung.com>

lib/lz4 has no in-tree tests, and this series replaces both the
compressor and the decompressor.  Add KUnit suites for the behaviour
callers rely on.

lz4_decompress:
 - round-trips through LZ4_decompress_safe() and
   LZ4_decompress_safe_partial() with exact, oversized and partial
   capacities;
 - truncated and corrupted blocks never write past the destination,
   through either entry point.  The input sits at the end of its
   allocation, so KASAN also reports over-reads;
 - an offset-0 match decodes the same whatever the buffer held before;
 - literal and match lengths longer than the output are rejected.  On
   32-bit, lengths whose extension bytes sum to SIZE_MAX are rejected
   rather than wrapped;
 - in-place decoding within LZ4_DECOMPRESS_INPLACE_MARGIN() leaves the
   output intact.  A fixed block that corrupts with the old +32 margin
   covers the vendored decoder's 32-byte wild copies, and a port of
   upstream's worst-case test covers the 64-byte copies its decoder
   makes since v1.11.0.

lz4_compress:
 - LZ4_compress_default() fits LZ4_COMPRESSBOUND(), and with a smaller
   buffer fails rather than overflowing;
 - LZ4_compress_fast() across documented acceleration boundaries;
 - LZ4_compress_destSize() output decodes to exactly the consumed
   prefix;
 - the dictionary paths of zram's lz4 and lz4hc backends;
 - LZ4_compress_HC() across supported levels, including the kernel's
   clamp boundary, with full and limited output.

Work memory is allocated at exactly LZ4_MEM_COMPRESS, LZ4HC_MEM_COMPRESS
and LZ4_MEM_DECOMPRESS bytes, so KASAN reports an implementation that
outgrows them.

Without this series, the 32-bit length case fails on i386 ("long match
accepted: ret=31"): the old decoder wraps the match length to 18 bytes
and accepts the block.

Signed-off-by: S. Biplab Raut <Biplab.Raut@amd.com>
---

Michal, this goes on top of your v2: it uses LZ4_MEM_DECOMPRESS and the
opaque stream types, so please fold it into v3 if you find it useful.

The tests are deterministic regression tests.  Every randomized case
uses a fixed seed, so each run checks the same inputs and any failure
reproduces exactly.  The in-place suite has two fixed cases:

 - a block that corrupts with the old (compressedSize >> 8) + 32 margin
   under a 32-byte fast loop, the case patch 12 fixes;

 - a port of upstream's decompress_safe_inPlace_worstCase test [1]:
   fixed noise with a 65-byte match at offset 65, for every source size
   from 300 to 4096.

On patch 12 and the +65 margin: since v1.11.0, upstream's decoder makes
64-byte wild copies on x86-64, aarch64 and ppc64, and upstream has raised
its margin to (compressedSize >> 8) + 65 to match [1].  That fix is on
the dev branch for v1.11.2; the released v1.11.0 and v1.11.1 headers
still say +32.  Your v1.10.0 import uses the 32-byte loop, so +36 is
right for this series.  A later re-sync to v1.11.0 or newer needs the
kernel's margin raised to +65 in the same patch, whatever the upstream
header at that tag says.

I checked that the worst-case test catches this, using a userspace
build of the same test.  Against upstream dev's decoder, all 3797 sizes
fail at +36 and none fail at +65.  Against your vendored v1.10.0
decoder, none fail at +36.

The HC cases are built only when LZ4HC_COMPRESS is reachable.

With your v2 applied on v7.3-rc4, the suite passes on UML (17 passed,
one 32-bit-only skip), on i386 (18 passed), and on x86_64 with KASAN and
KASAN_VMALLOC (17 passed, the same skip).  A UML build without
LZ4HC_COMPRESS passes 15 tests with the same skip.

[1] https://github.com/lz4/lz4/pull/2104

 lib/Kconfig               |  15 +
 lib/lz4/.kunitconfig      |   5 +
 lib/lz4/Makefile          |   1 +
 lib/lz4/tests/Makefile    |   2 +
 lib/lz4/tests/lz4_kunit.c | 911 ++++++++++++++++++++++++++++++++++++++
 5 files changed, 934 insertions(+)
 create mode 100644 lib/lz4/.kunitconfig
 create mode 100644 lib/lz4/tests/Makefile
 create mode 100644 lib/lz4/tests/lz4_kunit.c

diff --git a/lib/Kconfig b/lib/Kconfig
index 4e6b34c3346d..74e272a4173b 100644
--- a/lib/Kconfig
+++ b/lib/Kconfig
@@ -199,6 +199,21 @@ config LZ4HC_COMPRESS
 config LZ4_DECOMPRESS
 	tristate
 
+config LZ4_KUNIT_TEST
+	tristate "KUnit tests for the LZ4 compression library" if !KUNIT_ALL_TESTS
+	depends on KUNIT && LZ4_COMPRESS && LZ4_DECOMPRESS
+	default KUNIT_ALL_TESTS
+	help
+	  KUnit tests for lib/lz4: block round-trips, malformed and over-long
+	  input, in-place decompression within LZ4_DECOMPRESS_INPLACE_MARGIN(),
+	  the dictionary paths zram uses and, when LZ4HC_COMPRESS is enabled,
+	  the HC compressor.
+
+	  For more information on KUnit and unit tests in general,
+	  please refer to the KUnit documentation in Documentation/dev-tools/kunit/.
+
+	  If unsure, say N.
+
 config ZSTD_COMMON
 	select XXHASH
 	tristate
diff --git a/lib/lz4/.kunitconfig b/lib/lz4/.kunitconfig
new file mode 100644
index 000000000000..34f775556620
--- /dev/null
+++ b/lib/lz4/.kunitconfig
@@ -0,0 +1,5 @@
+CONFIG_KUNIT=y
+CONFIG_CRYPTO=y
+CONFIG_CRYPTO_LZ4=y
+CONFIG_CRYPTO_LZ4HC=y
+CONFIG_LZ4_KUNIT_TEST=y
diff --git a/lib/lz4/Makefile b/lib/lz4/Makefile
index 5cbbe10beedc..89bdb729672e 100644
--- a/lib/lz4/Makefile
+++ b/lib/lz4/Makefile
@@ -10,6 +10,7 @@ ccflags-y += -I $(src)/freestanding
 obj-$(CONFIG_LZ4_COMPRESS)	+= lz4_compress.o
 obj-$(CONFIG_LZ4HC_COMPRESS)	+= lz4hc_compress.o
 obj-$(CONFIG_LZ4_DECOMPRESS)	+= lz4_decompress.o
+obj-$(CONFIG_LZ4_KUNIT_TEST)	+= tests/
 
 # lz4hc.c pulls in lz4.c's common definitions, which include two decoder
 # tables nothing here uses when LZ4_FAST_DEC_LOOP is off.
diff --git a/lib/lz4/tests/Makefile b/lib/lz4/tests/Makefile
new file mode 100644
index 000000000000..cd5186b52372
--- /dev/null
+++ b/lib/lz4/tests/Makefile
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: GPL-2.0-only
+obj-$(CONFIG_LZ4_KUNIT_TEST) += lz4_kunit.o
diff --git a/lib/lz4/tests/lz4_kunit.c b/lib/lz4/tests/lz4_kunit.c
new file mode 100644
index 000000000000..d44a68142b51
--- /dev/null
+++ b/lib/lz4/tests/lz4_kunit.c
@@ -0,0 +1,911 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * KUnit tests for the LZ4 compression library.
+ *
+ * Copyright (C) 2026 Advanced Micro Devices, Inc.
+ */
+#include <kunit/test.h>
+#include <linux/array_size.h>
+#include <linux/limits.h>
+#include <linux/lz4.h>
+#include <linux/minmax.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+
+#define LZ4_KUNIT_MAX_SIZE	8192
+#define LZ4_KUNIT_GUARD		64
+#define LZ4_KUNIT_POISON	0xab
+#define LZ4_KUNIT_PAGE		4096
+#define LZ4_KUNIT_DICT_SIZE	8192
+#define LZ4_KUNIT_INPLACE_MIN	300
+#define LZ4_KUNIT_INPLACE_MAX	4096
+#define LZ4_KUNIT_INPLACE_OFFSET	65
+
+/* Work per randomized case.  The seeds are fixed, so every run is the same. */
+#define LZ4_KUNIT_ROUNDTRIP_ITERS	4000
+#define LZ4_KUNIT_MALFORMED_ITERS	4000
+#define LZ4_KUNIT_CORRUPT_BYTES		3
+#define LZ4_KUNIT_INPLACE_ITERS		30000
+#define LZ4_KUNIT_COMPRESS_ITERS	1500
+#define LZ4_KUNIT_ACCEL_ITERS		200
+#define LZ4_KUNIT_DICT_ITERS		500
+#define LZ4_KUNIT_HC_LEVEL_ITERS	60
+#define LZ4_KUNIT_HC_DICT_ITERS		100
+
+KUNIT_DEFINE_ACTION_WRAPPER(lz4_kunit_kvfree, kvfree, const void *);
+
+/* zeroed, and freed when the case ends even if an assertion aborts it */
+static void *lz4_kunit_alloc(struct kunit *test, size_t size)
+{
+	void *p = kvzalloc(size, GFP_KERNEL);
+
+	KUNIT_ASSERT_NOT_NULL(test, p);
+	KUNIT_ASSERT_EQ(test, 0,
+			kunit_add_action_or_reset(test, lz4_kunit_kvfree, p));
+	return p;
+}
+
+/* deterministic xorshift32, so every run sees the same streams */
+static u32 prng(u32 *s)
+{
+	u32 x = *s;
+
+	x ^= x << 13;
+	x ^= x >> 17;
+	x ^= x << 5;
+	return (*s = x);
+}
+
+/*
+ * Structured data that makes the compressor emit every token shape: short
+ * and long literal runs, short and long matches, and offsets below 8, 8..15
+ * and beyond.  @lit_pct is the percentage of literal runs.
+ */
+static void gen(u8 *buf, int size, u32 *s, int lit_pct)
+{
+	int pos = 0;
+
+	while (pos < size) {
+		int mtype = prng(s) % 100;
+		int i;
+
+		if (pos == 0 || mtype < lit_pct) {
+			int lit = 1 + prng(s) % 40;
+
+			if ((prng(s) & 7) == 0)
+				lit += prng(s) % 300;
+			lit = min(lit, size - pos);
+			for (i = 0; i < lit; i++)
+				buf[pos + i] = prng(s);
+			pos += lit;
+		} else {
+			int off, len;
+
+			switch (prng(s) & 3) {
+			case 0:
+				off = 1 + prng(s) % 7;
+				break;
+			case 1:
+				off = 8 + prng(s) % 8;
+				break;
+			default:
+				off = 1 + prng(s) % min(pos, 65535);
+				break;
+			}
+			off = min(off, pos);
+			len = 4 + prng(s) % 40;
+			if ((prng(s) & 7) == 0)
+				len += prng(s) % 400;
+			len = min(len, size - pos);
+			for (i = 0; i < len; i++)
+				buf[pos + i] = buf[pos - off + i];
+			pos += len;
+		}
+	}
+}
+
+enum { FILL_RANDOM, FILL_MIXED, FILL_ZERO, FILL_SHAPES };
+
+static void fill(u8 *buf, int size, u32 *s, int shape)
+{
+	int i;
+
+	switch (shape) {
+	case FILL_RANDOM:
+		for (i = 0; i < size; i++)
+			buf[i] = prng(s);
+		break;
+	case FILL_MIXED:
+		gen(buf, size, s, 10 + prng(s) % 85);
+		break;
+	default:
+		memset(buf, 0, size);
+		break;
+	}
+}
+
+static void fill_fixed_noise(u8 *buf, int size)
+{
+	u32 s = 0x5eed1234;
+	int i;
+
+	for (i = 0; i < size; i++)
+		buf[i] = prng(&s);
+}
+
+static void poison(u8 *p, int cap)
+{
+	memset(p + cap, LZ4_KUNIT_POISON, LZ4_KUNIT_GUARD);
+}
+
+static bool guard_ok(const u8 *p, int cap)
+{
+	return !memchr_inv(p + cap, LZ4_KUNIT_POISON, LZ4_KUNIT_GUARD);
+}
+
+/*
+ * Copy @n bytes to the very end of the @cap-byte allocation @buf, so that
+ * KASAN reports any read past the end of the compressed input.
+ */
+static const u8 *at_tail(u8 *buf, int cap, const u8 *src, int n)
+{
+	memcpy(buf + cap - n, src, n);
+	return buf + cap - n;
+}
+
+static int lz4_comp(const u8 *src, u8 *dst, int n, int cap, void *wrk)
+{
+	return LZ4_compress_default((const char *)src, (char *)dst, n, cap,
+				    wrk);
+}
+
+static int lz4_dec(const u8 *src, u8 *dst, int csize, int cap)
+{
+	return LZ4_decompress_safe((const char *)src, (char *)dst, csize, cap);
+}
+
+static int lz4_dec_partial(const u8 *src, u8 *dst, int csize, int target,
+			   int cap)
+{
+	return LZ4_decompress_safe_partial((const char *)src, (char *)dst,
+					   csize, target, cap);
+}
+
+static bool decodes_to(const u8 *c, int csize, const u8 *ref, int size,
+		       u8 *dst)
+{
+	return lz4_dec(c, dst, csize, size) == size && !memcmp(dst, ref, size);
+}
+
+/* ---- decompression ---------------------------------------------------- */
+
+static void lz4_decompress_test_roundtrip(struct kunit *test)
+{
+	const int max = LZ4_KUNIT_MAX_SIZE, cbound = LZ4_COMPRESSBOUND(max);
+	u8 *src = lz4_kunit_alloc(test, max);
+	u8 *comp = lz4_kunit_alloc(test, cbound);
+	u8 *in = lz4_kunit_alloc(test, cbound);
+	u8 *dst = lz4_kunit_alloc(test, max + 64 + LZ4_KUNIT_GUARD);
+	void *wrk = lz4_kunit_alloc(test, LZ4_MEM_COMPRESS);
+	u32 s = 0x1234567;
+	int fails = 0, it;
+
+	for (it = 0; it < LZ4_KUNIT_ROUNDTRIP_ITERS; it++) {
+		int size = 1 + prng(&s) % max;
+		int csize, r, k;
+		const u8 *c;
+
+		gen(src, size, &s, 10 + prng(&s) % 85);
+		csize = lz4_comp(src, comp, size, cbound, wrk);
+		if (csize <= 0) {
+			fails++;
+			continue;
+		}
+		c = at_tail(in, cbound, comp, csize);
+
+		poison(dst, size);
+		r = lz4_dec(c, dst, csize, size);
+		if (r != size || memcmp(dst, src, size) || !guard_ok(dst, size))
+			fails++;
+
+		poison(dst, size + 37);
+		r = lz4_dec(c, dst, csize, size + 37);
+		if (r != size || memcmp(dst, src, size) ||
+		    !guard_ok(dst, size + 37))
+			fails++;
+
+		k = 1 + prng(&s) % size;
+		poison(dst, k);
+		r = lz4_dec_partial(c, dst, csize, k, k);
+		if (r != k || memcmp(dst, src, k) || !guard_ok(dst, k))
+			fails++;
+
+		poison(dst, size);
+		r = lz4_dec_partial(c, dst, csize, k, size);
+		if (r < k || r > size || memcmp(dst, src, r) ||
+		    !guard_ok(dst, size))
+			fails++;
+	}
+
+	KUNIT_EXPECT_EQ_MSG(test, fails, 0, "round-trip failures: %d", fails);
+}
+
+static void lz4_decompress_test_malformed(struct kunit *test)
+{
+	const int max = LZ4_KUNIT_MAX_SIZE, cbound = LZ4_COMPRESSBOUND(max);
+	u8 *src = lz4_kunit_alloc(test, max);
+	u8 *comp = lz4_kunit_alloc(test, cbound);
+	u8 *in = lz4_kunit_alloc(test, cbound);
+	u8 *dst = lz4_kunit_alloc(test, max + LZ4_KUNIT_GUARD);
+	void *wrk = lz4_kunit_alloc(test, LZ4_MEM_COMPRESS);
+	u32 s = 0x0badc0de;
+	int bad = 0, it;
+
+	for (it = 0; it < LZ4_KUNIT_MALFORMED_ITERS; it++) {
+		int size = 16 + prng(&s) % (max - 16);
+		int csize, clen, k, i, r;
+		const u8 *c;
+
+		gen(src, size, &s, 10 + prng(&s) % 85);
+		csize = lz4_comp(src, comp, size, cbound, wrk);
+		if (csize <= 0)
+			continue;
+
+		clen = 1 + prng(&s) % csize;
+		for (i = 0; i < LZ4_KUNIT_CORRUPT_BYTES; i++)
+			comp[prng(&s) % clen] = prng(&s);
+		c = at_tail(in, cbound, comp, clen);
+
+		/* any result is acceptable except writing past the capacity */
+		poison(dst, size);
+		r = lz4_dec(c, dst, clen, size);
+		if (r > size || !guard_ok(dst, size))
+			bad++;
+
+		k = 1 + prng(&s) % size;
+		poison(dst, size);
+		r = lz4_dec_partial(c, dst, clen, k, size);
+		if (r > size || !guard_ok(dst, size))
+			bad++;
+	}
+
+	KUNIT_EXPECT_EQ_MSG(test, bad, 0, "malformed input overran dst: %d", bad);
+}
+
+/*
+ * Offset 0 makes match == op.  Decode the same stream into buffers
+ * pre-filled with 0x00 and 0xff: if the decoder accepts it, the output must
+ * not depend on stale buffer contents.  Literal runs that are multiples of
+ * 32 end the fast loop's wild copy exactly at op.
+ */
+static int build_offset0_block(u8 *comp, int l1, int total)
+{
+	int lf = total - (l1 + 4);
+	int p = 0, i, rem;
+
+	comp[p++] = 0xf0;			/* extended literals, ML 0 */
+	for (rem = l1 - 15; rem >= 255; rem -= 255)
+		comp[p++] = 0xff;
+	comp[p++] = rem;
+	for (i = 0; i < l1; i++)
+		comp[p++] = 0x41 + (i & 31);
+	comp[p++] = 0x00;			/* offset 0 */
+	comp[p++] = 0x00;
+	comp[p++] = 0xf0;			/* last literals */
+	for (rem = lf - 15; rem >= 255; rem -= 255)
+		comp[p++] = 0xff;
+	comp[p++] = rem;
+	for (i = 0; i < lf; i++)
+		comp[p++] = 0x61 + (i & 31);
+	return p;
+}
+
+static void lz4_decompress_test_offset0(struct kunit *test)
+{
+	static const int l1s[] = { 32, 64, 96 };
+	const int total = 400;
+	u8 *comp = lz4_kunit_alloc(test, 512);
+	u8 *d0 = lz4_kunit_alloc(test, total + LZ4_KUNIT_GUARD);
+	u8 *df = lz4_kunit_alloc(test, total + LZ4_KUNIT_GUARD);
+	unsigned int k;
+	int bad = 0;
+
+	for (k = 0; k < ARRAY_SIZE(l1s); k++) {
+		int csize = build_offset0_block(comp, l1s[k], total);
+		int r0, rf;
+
+		memset(d0, 0x00, total);
+		memset(df, 0xff, total);
+		poison(d0, total);
+		poison(df, total);
+		r0 = lz4_dec(comp, d0, csize, total);
+		rf = lz4_dec(comp, df, csize, total);
+		if (r0 != rf || (r0 > 0 && memcmp(d0, df, r0)) ||
+		    !guard_ok(d0, total) || !guard_ok(df, total))
+			bad++;
+	}
+
+	KUNIT_EXPECT_EQ_MSG(test, bad, 0, "offset-0 stale read: %d", bad);
+}
+
+/*
+ * A literal run of 15 + 255 * @ext bytes.  On 32-bit, @ext == SIZE_MAX / 255
+ * makes that 15 + SIZE_MAX, which wraps to 14: a decoder that wraps sees the
+ * 14 trailing bytes as the whole run and accepts the block.
+ */
+static int build_long_literals(u8 *p, size_t ext)
+{
+	int n = 0;
+
+	p[n++] = 0xf0;
+	memset(p + n, 0xff, ext);
+	n += ext;
+	p[n++] = 0x00;
+	memset(p + n, 'L', 14);
+	return n + 14;
+}
+
+/* 8 literals, then a match of 4 + 15 + 255 * @ext bytes at offset 1 */
+static int build_long_match(u8 *p, size_t ext)
+{
+	int n = 0;
+
+	p[n++] = 0x8f;
+	memset(p + n, 'M', 8);
+	n += 8;
+	p[n++] = 0x01;
+	p[n++] = 0x00;
+	memset(p + n, 0xff, ext);
+	n += ext;
+	p[n++] = 0x00;
+	p[n++] = 0x50;				/* last 5 literals */
+	memset(p + n, 'L', 5);
+	return n + 5;
+}
+
+static void expect_rejected(struct kunit *test, const u8 *c, int csize,
+			    const char *what)
+{
+	const int cap = 4096;
+	u8 *dst = lz4_kunit_alloc(test, cap + LZ4_KUNIT_GUARD);
+	int r;
+
+	poison(dst, cap);
+	r = lz4_dec(c, dst, csize, cap);
+	KUNIT_EXPECT_LT_MSG(test, r, 0, "%s accepted: ret=%d", what, r);
+	KUNIT_EXPECT_TRUE_MSG(test, guard_ok(dst, cap), "%s overran dst", what);
+
+	/* partial decoding may stop early, but must stay within capacity */
+	poison(dst, cap);
+	r = lz4_dec_partial(c, dst, csize, cap, cap);
+	KUNIT_EXPECT_LE_MSG(test, r, cap, "%s partial: ret=%d", what, r);
+	KUNIT_EXPECT_TRUE_MSG(test, guard_ok(dst, cap),
+			      "%s partial overran dst", what);
+}
+
+/* @buf holds ext + 18 bytes; both streams end exactly at its end */
+static void expect_long_lengths_rejected(struct kunit *test, u8 *buf,
+					 size_t ext)
+{
+	expect_rejected(test, buf + 2, build_long_literals(buf + 2, ext),
+			"long literal run");
+	expect_rejected(test, buf, build_long_match(buf, ext), "long match");
+}
+
+static void lz4_decompress_test_overlong(struct kunit *test)
+{
+	const size_t ext = 20000;		/* ~5 MB against 4 KB */
+
+	expect_long_lengths_rejected(test, lz4_kunit_alloc(test, ext + 18), ext);
+}
+
+static void lz4_decompress_test_length_wrap(struct kunit *test)
+{
+	const size_t ext = SIZE_MAX / 255;	/* 255 * ext == SIZE_MAX */
+
+	if (IS_ENABLED(CONFIG_64BIT))
+		kunit_skip(test, "needs a 32-bit size_t");
+
+	expect_long_lengths_rejected(test, lz4_kunit_alloc(test, ext + 18), ext);
+}
+
+/*
+ * In-place decoding: a buffer of
+ *   decompressedSize + LZ4_DECOMPRESS_INPLACE_MARGIN(compressedSize)
+ * bytes with the compressed data at its tail.  The margin must cover the
+ * decoder's widest wild copy, or the writer clobbers input it has not read.
+ *
+ * inplace_vec[] decodes to 384 bytes and corrupts in place with the
+ * historical (compressedSize >> 8) + 32 margin under a decoder whose fast
+ * loop copies 32 bytes at a time.
+ */
+static const u8 inplace_vec[] = {
+	0xff, 0x3a, 0xd0, 0x4f, 0xfc, 0xf8, 0x51, 0x87, 0x29, 0x7a, 0x58, 0x6e,
+	0x7d, 0x89, 0x2c, 0x16, 0x6d, 0x17, 0xb7, 0x27, 0x7e, 0x08, 0x4b, 0xdb,
+	0xaf, 0x7f, 0x7a, 0x19, 0xdb, 0xf1, 0x8a, 0xcb, 0xc9, 0x21, 0x83, 0xc5,
+	0x26, 0xd9, 0x37, 0x5c, 0x2d, 0xf3, 0x39, 0x59, 0xb9, 0x9e, 0x8b, 0x9a,
+	0xb7, 0x05, 0xd4, 0x4f, 0x8d, 0x36, 0x72, 0xab, 0x6d, 0x31, 0x94, 0x64,
+	0x8e, 0x39, 0x3b, 0x68, 0x51, 0xa9, 0x7c, 0x58, 0xb1, 0x03, 0x57, 0x0f,
+	0x4b, 0x27, 0xcf, 0x18, 0x00, 0x0e, 0xf0, 0xff, 0x08, 0x15, 0x20, 0x99,
+	0x5c, 0x28, 0xe4, 0xb0, 0x4b, 0xc3, 0x89, 0x6a, 0x02, 0xc2, 0x91, 0xdc,
+	0xfd, 0xe2, 0x36, 0x4c, 0x45, 0x97, 0x46, 0xf0, 0x20, 0xe2, 0x6b, 0xee,
+	0x9d, 0xbf, 0x44, 0x38, 0x74, 0xe3, 0x36, 0xc8, 0x8e, 0xc5, 0x5f, 0x84,
+	0xcb, 0x1a, 0x4a, 0x6e, 0x72, 0x66, 0x57, 0x77, 0x73, 0xdf, 0x37, 0xbd,
+	0xa0, 0x3b, 0xd9, 0x26, 0x76, 0xc4, 0x5c, 0x94, 0xa0, 0x8f, 0x0b, 0x81,
+	0xdf, 0xe1, 0xe6, 0x5a, 0x5e, 0xf0, 0x9d, 0xa9, 0x9f, 0xe6, 0x07, 0xf3,
+	0x8d, 0x64, 0xfd, 0x62, 0x17, 0x74, 0x2b, 0xdb, 0x72, 0xea, 0x72, 0x1b,
+	0x53, 0x75, 0x25, 0xab, 0xda, 0xe1, 0xe4, 0x96, 0x27, 0x20, 0xc3, 0xcc,
+	0x68, 0x3d, 0x59, 0x30, 0xbf, 0xb6, 0x0f, 0xcb, 0x56, 0x0a, 0x31, 0xbe,
+	0x18, 0xf8, 0x24, 0x14, 0xe4, 0x6e, 0x96, 0x22, 0xd0, 0x06, 0xdf, 0x91,
+	0x85, 0xa2, 0x8e, 0x1b, 0x05, 0x95, 0x7d, 0x1e, 0x51, 0x8a, 0x81, 0xc7,
+	0xad, 0x39, 0xf6, 0xb9, 0xf5, 0xe4, 0x38, 0x8e, 0x30, 0x22, 0x76, 0x4f,
+	0xa2, 0x1a, 0xcf, 0xa0, 0xea, 0x6c, 0x4e, 0x0d, 0x7d, 0xa3, 0xac, 0x69,
+	0xa8, 0x54, 0xe3, 0xbb, 0x89, 0x41, 0x27, 0x7e, 0x29, 0xba, 0x19, 0xa8,
+	0x40, 0xce, 0x29, 0x5c, 0x92, 0xba, 0x47, 0x51, 0x9c, 0x5a, 0x4f, 0xaf,
+	0xce, 0xa7, 0x9d, 0x1a, 0xfd, 0xcd, 0xb7, 0x44, 0x2a, 0x62, 0x3d, 0x54,
+	0x9b, 0x19, 0xbc, 0x24, 0x4a, 0xc0, 0x6a, 0x5d, 0xac, 0xb1, 0x4f, 0x08,
+	0x00, 0xb1, 0x95, 0x04, 0xae, 0x40, 0xed, 0xfc, 0x69, 0xd5, 0x6e, 0x13,
+	0xa9, 0xb7, 0x3d, 0x67, 0xdf, 0xb6, 0x60, 0x8a, 0x3c, 0x62, 0xcb, 0x50,
+	0x13, 0x96, 0x85, 0x62, 0x80, 0xb1, 0xe7, 0x14, 0x60, 0xe4, 0xc9, 0x78,
+	0xe1, 0x43, 0x4f, 0xdf, 0x39, 0xa0, 0x1e, 0x28, 0x8a, 0xaa, 0x41, 0x94,
+	0x86, 0x4b, 0xdf, 0xba, 0xf3, 0x69, 0x8d, 0xa8, 0x36, 0xfa, 0xd9, 0xaa,
+	0x8e, 0xe3, 0xc5, 0xde, 0xee, 0x45, 0x10, 0x4f, 0xb0, 0x53, 0xdc,
+};
+
+#define INPLACE_VEC_OUT 384
+
+static bool inplace_ok(const u8 *comp, int csize, const u8 *ref, int size,
+		       u8 *buf, int bufcap)
+{
+	int n = size + LZ4_DECOMPRESS_INPLACE_MARGIN(csize);
+	int r;
+
+	if (bufcap < LZ4_KUNIT_GUARD ||
+	    n > bufcap - LZ4_KUNIT_GUARD)
+		return false;
+
+	memset(buf, 0, n);
+	poison(buf, n);
+	memcpy(buf + n - csize, comp, csize);
+	r = lz4_dec(buf + n - csize, buf, csize, size);
+	return r == size && !memcmp(buf, ref, size) && guard_ok(buf, n);
+}
+
+static void lz4_decompress_test_inplace(struct kunit *test)
+{
+	const int max = LZ4_KUNIT_MAX_SIZE, cbound = LZ4_COMPRESSBOUND(max);
+	const int bufcap = max + 256;
+	u8 *src = lz4_kunit_alloc(test, max);
+	u8 *ref = lz4_kunit_alloc(test, max);
+	u8 *comp = lz4_kunit_alloc(test, cbound);
+	u8 *buf = lz4_kunit_alloc(test, bufcap);
+	void *wrk = lz4_kunit_alloc(test, LZ4_MEM_COMPRESS);
+	u32 s = 0x51ab1e00;
+	int fails = 0, it;
+
+	KUNIT_ASSERT_EQ(test, INPLACE_VEC_OUT,
+			lz4_dec(inplace_vec, ref, sizeof(inplace_vec),
+				INPLACE_VEC_OUT));
+	KUNIT_EXPECT_TRUE_MSG(test,
+			      inplace_ok(inplace_vec, sizeof(inplace_vec), ref,
+					 INPLACE_VEC_OUT, buf, bufcap),
+			      "vector corrupts in place at margin %d",
+			      LZ4_DECOMPRESS_INPLACE_MARGIN((int)sizeof(inplace_vec)));
+
+	for (it = 0; it < LZ4_KUNIT_INPLACE_ITERS; it++) {
+		int size = 64 + prng(&s) % (max - 64);
+		int csize;
+
+		gen(src, size, &s, 10 + prng(&s) % 85);
+		csize = lz4_comp(src, comp, size, cbound, wrk);
+		if (csize <= 0 || !decodes_to(comp, csize, src, size, ref))
+			continue;
+		if (!inplace_ok(comp, csize, ref, size, buf, bufcap))
+			fails++;
+	}
+
+	KUNIT_EXPECT_EQ_MSG(test, fails, 0,
+			    "in-place corruption at LZ4_DECOMPRESS_INPLACE_MARGIN: %d",
+			    fails);
+}
+
+/*
+ * This mirrors upstream's decompress_safe_inPlace_worstCase test, added with
+ * the +65 margin fix for the 64-byte wild copies of its v1.11.0 decoder.  A
+ * 65-byte match at offset 65 makes such a copy visible when the in-place
+ * margin is too small.
+ */
+static void lz4_decompress_test_inplace_worst_case(struct kunit *test)
+{
+	const int max = LZ4_KUNIT_INPLACE_MAX;
+	const int cbound = LZ4_COMPRESSBOUND(max);
+	const int bufcap = max +
+		LZ4_DECOMPRESS_INPLACE_MARGIN(cbound) + LZ4_KUNIT_GUARD;
+	u8 *src = lz4_kunit_alloc(test, max);
+	u8 *ref = lz4_kunit_alloc(test, max);
+	u8 *comp = lz4_kunit_alloc(test, cbound);
+	u8 *buf = lz4_kunit_alloc(test, bufcap);
+	void *wrk = lz4_kunit_alloc(test, LZ4_MEM_COMPRESS);
+	int fails = 0, size;
+
+	for (size = LZ4_KUNIT_INPLACE_MIN; size <= max; size++) {
+		int csize, r;
+
+		fill_fixed_noise(src, size);
+		memcpy(src + LZ4_KUNIT_INPLACE_OFFSET, src,
+		       LZ4_KUNIT_INPLACE_OFFSET);
+		csize = lz4_comp(src, comp, size, cbound, wrk);
+		if (csize <= 0 || csize >= size) {
+			fails++;
+			continue;
+		}
+
+		r = lz4_dec(comp, ref, csize, size);
+		if (r != size || memcmp(ref, src, size)) {
+			fails++;
+			continue;
+		}
+
+		if (!inplace_ok(comp, csize, ref, size, buf, bufcap))
+			fails++;
+	}
+
+	KUNIT_EXPECT_EQ_MSG(test, fails, 0,
+			    "in-place worst-case failures: %d", fails);
+}
+
+/* ---- compression ------------------------------------------------------ */
+
+static void lz4_compress_test_bound(struct kunit *test)
+{
+	const int max = LZ4_KUNIT_MAX_SIZE, cbound = LZ4_COMPRESSBOUND(max);
+	u8 *src = lz4_kunit_alloc(test, max);
+	u8 *comp = lz4_kunit_alloc(test, cbound + LZ4_KUNIT_GUARD);
+	u8 *dst = lz4_kunit_alloc(test, max);
+	void *wrk = lz4_kunit_alloc(test, LZ4_MEM_COMPRESS);
+	u32 s = 0xb0b0cafe;
+	int fails = 0, it, r;
+
+	r = lz4_comp(src, comp, 0, cbound, wrk);
+	KUNIT_ASSERT_GT(test, r, 0);
+	KUNIT_EXPECT_EQ(test, lz4_dec(comp, dst, r, 0), 0);
+
+	for (it = 0; it < LZ4_KUNIT_COMPRESS_ITERS; it++) {
+		int size = 1 + prng(&s) % max;
+		int bound = LZ4_COMPRESSBOUND(size);
+
+		fill(src, size, &s, it % FILL_SHAPES);
+		poison(comp, bound);
+		r = lz4_comp(src, comp, size, bound, wrk);
+		if (r <= 0 || r > bound || !guard_ok(comp, bound) ||
+		    !decodes_to(comp, r, src, size, dst))
+			fails++;
+	}
+
+	KUNIT_EXPECT_EQ_MSG(test, fails, 0, "LZ4_COMPRESSBOUND failures: %d",
+			    fails);
+}
+
+static void lz4_compress_test_limited(struct kunit *test)
+{
+	const int max = LZ4_KUNIT_MAX_SIZE, cbound = LZ4_COMPRESSBOUND(max);
+	u8 *src = lz4_kunit_alloc(test, max);
+	u8 *comp = lz4_kunit_alloc(test, cbound);
+	u8 *out = lz4_kunit_alloc(test, cbound + LZ4_KUNIT_GUARD);
+	u8 *dst = lz4_kunit_alloc(test, max);
+	void *wrk = lz4_kunit_alloc(test, LZ4_MEM_COMPRESS);
+	u32 s = 0x11d1ed00;
+	int fails = 0, it;
+
+	for (it = 0; it < LZ4_KUNIT_COMPRESS_ITERS; it++) {
+		int size = 16 + prng(&s) % (max - 16);
+		int full, cap, r;
+
+		fill(src, size, &s, it % FILL_SHAPES);
+		full = lz4_comp(src, comp, size, cbound, wrk);
+		if (full <= 0) {
+			fails++;
+			continue;
+		}
+		switch (it & 3) {
+		case 0:
+			cap = prng(&s) % 16;
+			break;
+		case 1:
+			cap = full / 2;
+			break;
+		case 2:
+			cap = full - 1;
+			break;
+		default:
+			cap = full;
+			break;
+		}
+
+		/* too small a buffer may fail (0), but never overflow */
+		poison(out, cap);
+		r = lz4_comp(src, out, size, cap, wrk);
+		if (r < 0 || r > cap || !guard_ok(out, cap) ||
+		    (r > 0 && !decodes_to(out, r, src, size, dst)))
+			fails++;
+	}
+
+	KUNIT_EXPECT_EQ_MSG(test, fails, 0, "limited-output failures: %d", fails);
+}
+
+static void lz4_compress_test_accel(struct kunit *test)
+{
+	/* 65537 is the upstream acceleration clamp used by zram. */
+	static const int accel[] = { 1, 2, 8, 65537 };
+	const int max = LZ4_KUNIT_MAX_SIZE, cbound = LZ4_COMPRESSBOUND(max);
+	u8 *src = lz4_kunit_alloc(test, max);
+	u8 *comp = lz4_kunit_alloc(test, cbound + LZ4_KUNIT_GUARD);
+	u8 *dst = lz4_kunit_alloc(test, max);
+	void *wrk = lz4_kunit_alloc(test, LZ4_MEM_COMPRESS);
+	u32 s = 0xacce1000;
+	unsigned int i;
+	int fails = 0, it;
+
+	for (i = 0; i < ARRAY_SIZE(accel); i++) {
+		for (it = 0; it < LZ4_KUNIT_ACCEL_ITERS; it++) {
+			int size = 1 + prng(&s) % max;
+			int bound = LZ4_COMPRESSBOUND(size);
+			int r;
+
+			fill(src, size, &s, it % FILL_SHAPES);
+			poison(comp, bound);
+			r = LZ4_compress_fast((const char *)src, (char *)comp,
+					      size, bound, accel[i], wrk);
+			if (r <= 0 || r > bound || !guard_ok(comp, bound) ||
+			    !decodes_to(comp, r, src, size, dst))
+				fails++;
+		}
+	}
+
+	KUNIT_EXPECT_EQ_MSG(test, fails, 0, "LZ4_compress_fast failures: %d",
+			    fails);
+}
+
+static void lz4_compress_test_destsize(struct kunit *test)
+{
+	const int max = LZ4_KUNIT_MAX_SIZE, cbound = LZ4_COMPRESSBOUND(max);
+	u8 *src = lz4_kunit_alloc(test, max);
+	u8 *comp = lz4_kunit_alloc(test, cbound + LZ4_KUNIT_GUARD);
+	u8 *dst = lz4_kunit_alloc(test, max);
+	void *wrk = lz4_kunit_alloc(test, LZ4_MEM_COMPRESS);
+	u32 s = 0xde575123;
+	int fails = 0, it;
+
+	for (it = 0; it < LZ4_KUNIT_COMPRESS_ITERS; it++) {
+		int size = 1 + prng(&s) % max;
+		int target, consumed = size, r;
+
+		fill(src, size, &s, it % FILL_SHAPES);
+		if (it & 1)
+			target = 1 + prng(&s) % 64;
+		else
+			target = 1 + prng(&s) % LZ4_COMPRESSBOUND(size);
+
+		/* the output must decode to exactly the consumed prefix */
+		poison(comp, target);
+		r = LZ4_compress_destSize((const char *)src, (char *)comp,
+					  &consumed, target, wrk);
+		if (r < 0 || r > target || !guard_ok(comp, target) ||
+		    consumed < 0 || consumed > size ||
+		    (r > 0 && !decodes_to(comp, r, src, consumed, dst)))
+			fails++;
+	}
+
+	KUNIT_EXPECT_EQ_MSG(test, fails, 0, "LZ4_compress_destSize failures: %d",
+			    fails);
+}
+
+/* a page that mostly repeats dictionary content */
+static void fill_from_dict(u8 *page, const u8 *dict, u32 *s)
+{
+	int pos = 0;
+
+	while (pos < LZ4_KUNIT_PAGE) {
+		int len = 16 + prng(s) % 200;
+		int off = prng(s) % (LZ4_KUNIT_DICT_SIZE - len);
+		int i;
+
+		len = min(len, LZ4_KUNIT_PAGE - pos);
+		if (prng(s) & 3)
+			memcpy(page + pos, dict + off, len);
+		else
+			for (i = 0; i < len; i++)
+				page[pos + i] = prng(s);
+		pos += len;
+	}
+}
+
+static int decode_with_dict(LZ4_streamDecode_t *dstrm, const u8 *dict,
+			    const u8 *c, int csize, u8 *out)
+{
+	if (LZ4_setStreamDecode(dstrm, (const char *)dict,
+				LZ4_KUNIT_DICT_SIZE) != 1)
+		return -1;
+	return LZ4_decompress_safe_continue(dstrm, (const char *)c, (char *)out,
+					    csize, LZ4_KUNIT_PAGE);
+}
+
+/* zram's lz4 backend: copy a primed stream per page, decode with the dict */
+static void lz4_compress_test_dict_stream(struct kunit *test)
+{
+	const int cbound = LZ4_COMPRESSBOUND(LZ4_KUNIT_PAGE);
+	u8 *dict = lz4_kunit_alloc(test, LZ4_KUNIT_DICT_SIZE);
+	u8 *page = lz4_kunit_alloc(test, LZ4_KUNIT_PAGE);
+	u8 *comp = lz4_kunit_alloc(test, cbound);
+	u8 *out = lz4_kunit_alloc(test, LZ4_KUNIT_PAGE);
+	LZ4_stream_t *primed = lz4_kunit_alloc(test, LZ4_MEM_COMPRESS);
+	LZ4_stream_t *cstrm = lz4_kunit_alloc(test, LZ4_MEM_COMPRESS);
+	LZ4_streamDecode_t *dstrm = lz4_kunit_alloc(test, LZ4_MEM_DECOMPRESS);
+	int fails = 0, it;
+	u32 s = 0xd1c7d1c7;
+
+	gen(dict, LZ4_KUNIT_DICT_SIZE, &s, 50);
+	KUNIT_ASSERT_EQ(test, LZ4_KUNIT_DICT_SIZE,
+			LZ4_loadDict(primed, (const char *)dict,
+				     LZ4_KUNIT_DICT_SIZE));
+
+	for (it = 0; it < LZ4_KUNIT_DICT_ITERS; it++) {
+		int c, r;
+
+		fill_from_dict(page, dict, &s);
+		memcpy(cstrm, primed, LZ4_MEM_COMPRESS);
+		c = LZ4_compress_fast_continue(cstrm, (const char *)page,
+					       (char *)comp, LZ4_KUNIT_PAGE,
+					       cbound, 1);
+		if (c <= 0) {
+			fails++;
+			continue;
+		}
+
+		r = decode_with_dict(dstrm, dict, comp, c, out);
+		if (r != LZ4_KUNIT_PAGE || memcmp(out, page, LZ4_KUNIT_PAGE))
+			fails++;
+
+		r = LZ4_decompress_safe_usingDict((const char *)comp,
+						  (char *)out, c,
+						  LZ4_KUNIT_PAGE,
+						  (const char *)dict,
+						  LZ4_KUNIT_DICT_SIZE);
+		if (r != LZ4_KUNIT_PAGE || memcmp(out, page, LZ4_KUNIT_PAGE))
+			fails++;
+	}
+
+	KUNIT_EXPECT_EQ_MSG(test, fails, 0, "dictionary round-trip failures: %d",
+			    fails);
+}
+
+#if IS_REACHABLE(CONFIG_LZ4HC_COMPRESS)
+static void lz4hc_compress_test_levels(struct kunit *test)
+{
+	static const int levels[] = {
+		1, 2, 3, 4, 9, 10, 11, 12, 13, 14, 15, LZ4HC_MAX_CLEVEL
+	};
+	const int max = LZ4_KUNIT_MAX_SIZE, cbound = LZ4_COMPRESSBOUND(max);
+	u8 *src, *comp, *dst;
+	void *wrk;
+	u32 s = 0x4c5a3448;
+	unsigned int i;
+	int fails = 0, it;
+
+	src = lz4_kunit_alloc(test, max);
+	comp = lz4_kunit_alloc(test, cbound + LZ4_KUNIT_GUARD);
+	dst = lz4_kunit_alloc(test, max);
+	wrk = lz4_kunit_alloc(test, LZ4HC_MEM_COMPRESS);
+
+	for (i = 0; i < ARRAY_SIZE(levels); i++) {
+		for (it = 0; it < LZ4_KUNIT_HC_LEVEL_ITERS; it++) {
+			int size = 1 + prng(&s) % max;
+			int bound = LZ4_COMPRESSBOUND(size);
+			int r, cap;
+
+			fill(src, size, &s, it % FILL_SHAPES);
+			poison(comp, bound);
+			r = LZ4_compress_HC((const char *)src, (char *)comp,
+					    size, bound, levels[i], wrk);
+			if (r <= 0 || r > bound || !guard_ok(comp, bound) ||
+			    !decodes_to(comp, r, src, size, dst)) {
+				fails++;
+				continue;
+			}
+
+			cap = r / 2;
+			poison(comp, cap);
+			r = LZ4_compress_HC((const char *)src, (char *)comp,
+					    size, cap, levels[i], wrk);
+			if (r < 0 || r > cap || !guard_ok(comp, cap) ||
+			    (r > 0 && !decodes_to(comp, r, src, size, dst)))
+				fails++;
+		}
+	}
+
+	KUNIT_EXPECT_EQ_MSG(test, fails, 0, "LZ4_compress_HC failures: %d",
+			    fails);
+}
+
+/* zram's lz4hc backend: reset once, reload the dict before every page */
+static void lz4hc_compress_test_dict_stream(struct kunit *test)
+{
+	const int cbound = LZ4_COMPRESSBOUND(LZ4_KUNIT_PAGE);
+	u8 *dict, *page, *comp, *out;
+	LZ4_streamHC_t *cstrm;
+	LZ4_streamDecode_t *dstrm;
+	u32 s = 0x4cd1c700;
+	int fails = 0, it;
+
+	dict = lz4_kunit_alloc(test, LZ4_KUNIT_DICT_SIZE);
+	page = lz4_kunit_alloc(test, LZ4_KUNIT_PAGE);
+	comp = lz4_kunit_alloc(test, cbound);
+	out = lz4_kunit_alloc(test, LZ4_KUNIT_PAGE);
+	cstrm = lz4_kunit_alloc(test, LZ4HC_MEM_COMPRESS);
+	dstrm = lz4_kunit_alloc(test, LZ4_MEM_DECOMPRESS);
+
+	gen(dict, LZ4_KUNIT_DICT_SIZE, &s, 50);
+	LZ4_resetStreamHC(cstrm, 9);
+
+	for (it = 0; it < LZ4_KUNIT_HC_DICT_ITERS; it++) {
+		int c, r;
+
+		fill_from_dict(page, dict, &s);
+		if (LZ4_loadDictHC(cstrm, (const char *)dict,
+				   LZ4_KUNIT_DICT_SIZE) != LZ4_KUNIT_DICT_SIZE) {
+			fails++;
+			continue;
+		}
+		c = LZ4_compress_HC_continue(cstrm, (const char *)page,
+					     (char *)comp, LZ4_KUNIT_PAGE,
+					     cbound);
+		r = c > 0 ? decode_with_dict(dstrm, dict, comp, c, out) : -1;
+		if (r != LZ4_KUNIT_PAGE || memcmp(out, page, LZ4_KUNIT_PAGE))
+			fails++;
+	}
+
+	KUNIT_EXPECT_EQ_MSG(test, fails, 0,
+			    "HC dictionary round-trip failures: %d", fails);
+}
+#endif
+
+static struct kunit_case lz4_decompress_test_cases[] = {
+	KUNIT_CASE(lz4_decompress_test_roundtrip),
+	KUNIT_CASE(lz4_decompress_test_malformed),
+	KUNIT_CASE(lz4_decompress_test_offset0),
+	KUNIT_CASE(lz4_decompress_test_overlong),
+	KUNIT_CASE_SLOW(lz4_decompress_test_length_wrap),
+	KUNIT_CASE(lz4_decompress_test_inplace),
+	KUNIT_CASE_SLOW(lz4_decompress_test_inplace_worst_case),
+	{}
+};
+
+static struct kunit_suite lz4_decompress_test_suite = {
+	.name = "lz4_decompress",
+	.test_cases = lz4_decompress_test_cases,
+};
+
+static struct kunit_case lz4_compress_test_cases[] = {
+	KUNIT_CASE(lz4_compress_test_bound),
+	KUNIT_CASE(lz4_compress_test_limited),
+	KUNIT_CASE(lz4_compress_test_accel),
+	KUNIT_CASE(lz4_compress_test_destsize),
+	KUNIT_CASE(lz4_compress_test_dict_stream),
+#if IS_REACHABLE(CONFIG_LZ4HC_COMPRESS)
+	KUNIT_CASE(lz4hc_compress_test_levels),
+	KUNIT_CASE(lz4hc_compress_test_dict_stream),
+#endif
+	{}
+};
+
+static struct kunit_suite lz4_compress_test_suite = {
+	.name = "lz4_compress",
+	.test_cases = lz4_compress_test_cases,
+};
+
+kunit_test_suites(&lz4_decompress_test_suite, &lz4_compress_test_suite);
+
+MODULE_DESCRIPTION("KUnit tests for the LZ4 compression library");
+MODULE_AUTHOR("S. Biplab Raut <Biplab.Raut@amd.com>");
+MODULE_LICENSE("GPL");
-- 
2.43.0


      parent reply	other threads:[~2026-11-18 18:23 UTC|newest]

Thread overview: 29+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
     [not found] <CGME20261106144247eucas1p15bdd0704f32d1cb3b19f9d2296a0cbc3@eucas1p1.samsung.com>
2026-11-06 14:42 ` [PATCH v2 00/15] lib/lz4: stop forking upstream LZ4, vendor it instead Michal Wilczynski
     [not found]   ` <CGME20261106144249eucas1p1ca5f03b764c6305120da3e8b65f76ed1@eucas1p1.samsung.com>
2026-11-06 14:42     ` [PATCH v2 01/15] lib/decompress_unlz4: use LZ4_decompress_safe_partial() before boot Michal Wilczynski
     [not found]   ` <CGME20261106144250eucas1p23dbd9566bcf265bb48728cedff315031@eucas1p2.samsung.com>
2026-11-06 14:42     ` [PATCH v2 02/15] lib/lz4: remove LZ4_decompress_fast() and its variants Michal Wilczynski
     [not found]   ` <CGME20261106144252eucas1p272c9e37d66ad385db070f941879aecb1@eucas1p2.samsung.com>
2026-11-06 14:42     ` [PATCH v2 03/15] zram: lz4hc: reset the dictionary stream once, not per page Michal Wilczynski
     [not found]   ` <CGME20261106144254eucas1p12df3a03a5f8e74ca4a04931ae80812bf@eucas1p1.samsung.com>
2026-11-06 14:42     ` [PATCH v2 04/15] lib/lz4: import upstream LZ4 sources verbatim Michal Wilczynski
     [not found]   ` <CGME20261106144256eucas1p1beb947272dc94f916c8c8131722a480d@eucas1p1.samsung.com>
2026-11-06 14:42     ` [PATCH v2 05/15] lib/lz4: backport upstream's -Wmissing-prototypes fix Michal Wilczynski
     [not found]   ` <CGME20261106144258eucas1p1f59ead3e337482e074bfb26f4553e70d@eucas1p1.samsung.com>
2026-11-06 14:42     ` [PATCH v2 06/15] lib/lz4: backport upstream's aarch64 fast decode loop enablement Michal Wilczynski
     [not found]   ` <CGME20261106144259eucas1p27d26efbc44beac102c03ec07ebed4310@eucas1p2.samsung.com>
2026-11-06 14:42     ` [PATCH v2 07/15] lib/lz4: backport upstream's match length limit fix Michal Wilczynski
     [not found]   ` <CGME20261106144301eucas1p1882c2f6ac262ef7c10c3e0cabe333a6b@eucas1p1.samsung.com>
2026-11-06 14:42     ` [PATCH v2 08/15] lib/lz4: add the build environment for the vendored sources Michal Wilczynski
     [not found]   ` <CGME20261106144303eucas1p10d145c55d4e168ac6d2d12758125a532@eucas1p1.samsung.com>
2026-11-06 14:42     ` [PATCH v2 09/15] arch: boot: put the LZ4 freestanding headers on the decompressor path Michal Wilczynski
     [not found]   ` <CGME20261106144305eucas1p17b3b27d403dc7d13b85cdd9a4bea83b9@eucas1p1.samsung.com>
2026-11-06 14:42     ` [PATCH v2 10/15] lib/lz4: switch the compressor to the vendored sources Michal Wilczynski
2026-11-07  1:40       ` kernel test robot
2026-11-10  5:36       ` Sergey Senozhatsky
2026-11-12 12:02         ` Michal Wilczynski
2026-11-18 18:35       ` S. Biplab Raut
     [not found]   ` <CGME20261106144306eucas1p17d110f5e01991516acd49252f81845b2@eucas1p1.samsung.com>
2026-11-06 14:42     ` [PATCH v2 11/15] lib/lz4: switch the HC " Michal Wilczynski
2026-11-18 18:35       ` S. Biplab Raut
     [not found]   ` <CGME20261106144309eucas1p2a9bfcc1cf81779d473fb073e7d9139b7@eucas1p2.samsung.com>
2026-11-06 14:42     ` [PATCH v2 12/15] lib/lz4: widen LZ4_DECOMPRESS_INPLACE_MARGIN for the fast decode loop Michal Wilczynski
2026-11-11 22:02       ` Gao Xiang
2026-11-12 12:40         ` Michal Wilczynski
2026-11-18 18:35       ` S. Biplab Raut
     [not found]   ` <CGME20261106144310eucas1p1d60fe5c2e0170c49f38a3142bb1d8f94@eucas1p1.samsung.com>
2026-11-06 14:42     ` [PATCH v2 13/15] lib/lz4: switch the decompressor to the vendored sources Michal Wilczynski
2026-11-10  5:39       ` Sergey Senozhatsky
2026-11-12 12:06         ` Michal Wilczynski
2026-11-18 18:35       ` S. Biplab Raut
     [not found]   ` <CGME20261106144312eucas1p26109d26cecef034bf7734283cb04b211@eucas1p2.samsung.com>
2026-11-06 14:42     ` [PATCH v2 14/15] lib/lz4: replace lz4_kernel_api.h's prototypes with <linux/lz4.h> Michal Wilczynski
     [not found]   ` <CGME20261106144313eucas1p18ebd11c40d0e1e68730aac1800b2502f@eucas1p1.samsung.com>
2026-11-06 14:42     ` [PATCH v2 15/15] MAINTAINERS: add an entry for the LZ4 compression library Michal Wilczynski
2026-11-12 11:25   ` [PATCH v2 00/15] lib/lz4: stop forking upstream LZ4, vendor it instead Michal Wilczynski
2026-11-18 18:23   ` S. Biplab Raut [this message]

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20261118182343.1628236-1-Biplab.Raut@amd.com \
    --to=biplab.raut@amd.com \
    --cc=akpm@linux-foundation.org \
    --cc=brendan.higgins@linux.dev \
    --cc=david@davidgow.net \
    --cc=kunit-dev@googlegroups.com \
    --cc=linux-erofs@lists.ozlabs.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux-kselftest@vger.kernel.org \
    --cc=m.wilczynski@samsung.com \
    --cc=raemoar63@gmail.com \
    --cc=terrelln@meta.com \
    --cc=xiang@kernel.org \
    --cc=yann.collet.73@gmail.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®