Reintegrate test code with library code

Signed-off-by: David Oberhollenzer <david.oberhollenzer@sigma-star.at>

6 files changed, 975 insertions, 0 deletions

diff --git a/lib/sqfs/Makemodule.am b/lib/sqfs/Makemodule.am
index dfd88c9..3500aad 100644
--- a/lib/sqfs/Makemodule.am
+++ b/lib/sqfs/Makemodule.am
@@ -103,3 +103,26 @@ sqfsinclude_HEADERS = $(LIBSQFS_HEARDS)
 lib_LTLIBRARIES += libsquashfs.la
 
 pkgconfig_DATA += lib/sqfs/libsquashfs1.pc
+
+test_abi_SOURCES = lib/sqfs/test/abi.c
+test_abi_LDADD = libsquashfs.la libcompat.a
+
+test_table_SOURCES = lib/sqfs/test/table.c
+test_table_LDADD = libsquashfs.la libcompat.a
+
+test_xattr_writer_SOURCES = lib/sqfs/test/xattr_writer.c
+test_xattr_writer_LDADD = libsquashfs.la libcompat.a
+
+xattr_benchmark_SOURCES = lib/sqfs/test/xattr_benchmark.c
+xattr_benchmark_LDADD = libcommon.a libsquashfs.la libcompat.a
+
+test_get_node_path_SOURCES = lib/sqfs/test/get_node_path.c
+test_get_node_path_LDADD = libcommon.a libsquashfs.la libcompat.a
+
+LIBSQFS_TESTS = \
+	test_abi test_table test_xattr_writer test_get_node_path
+
+noinst_PROGRAMS += xattr_benchmark
+
+check_PROGRAMS += $(LIBSQFS_TESTS)
+TESTS += $(LIBSQFS_TESTS)
diff --git a/lib/sqfs/test/abi.c b/lib/sqfs/test/abi.c
new file mode 100644
index 0000000..0eaf5df
--- /dev/null
+++ b/lib/sqfs/test/abi.c
@@ -0,0 +1,174 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+/*
+ * abi.c
+ *
+ * Copyright (C) 2019 David Oberhollenzer <goliath@infraroot.at>
+ */
+#include "config.h"
+
+#include "sqfs/block_processor.h"
+#include "sqfs/compressor.h"
+#include "sqfs/block.h"
+#include "util/test.h"
+
+#include <stddef.h>
+
+static void test_compressor_opt_struct(void)
+{
+	sqfs_compressor_config_t cfg;
+
+	TEST_EQUAL_UI(sizeof(cfg.id), sizeof(sqfs_u16));
+	TEST_EQUAL_UI(sizeof(cfg.flags), sizeof(sqfs_u16));
+	TEST_EQUAL_UI(sizeof(cfg.block_size), sizeof(sqfs_u32));
+	TEST_EQUAL_UI(sizeof(cfg.level), sizeof(sqfs_u32));
+	TEST_EQUAL_UI(sizeof(cfg.opt), (2 * sizeof(sqfs_u64)));
+
+	TEST_EQUAL_UI(sizeof(cfg.opt.gzip), sizeof(cfg.opt));
+	TEST_EQUAL_UI(sizeof(cfg.opt.lzo), sizeof(cfg.opt));
+	TEST_EQUAL_UI(sizeof(cfg.opt.xz), sizeof(cfg.opt));
+	TEST_EQUAL_UI(sizeof(cfg.opt.padd0), sizeof(cfg.opt));
+
+	TEST_EQUAL_UI(offsetof(sqfs_compressor_config_t, id), 0);
+	TEST_EQUAL_UI(offsetof(sqfs_compressor_config_t, flags),
+		      sizeof(sqfs_u16));
+	TEST_EQUAL_UI(offsetof(sqfs_compressor_config_t, block_size),
+		      sizeof(sqfs_u32));
+	TEST_EQUAL_UI(offsetof(sqfs_compressor_config_t, level),
+		      (2 * sizeof(sqfs_u32)));
+
+	if (__alignof__(sqfs_compressor_config_t) == __alignof__(sqfs_u32)) {
+		TEST_EQUAL_UI(offsetof(sqfs_compressor_config_t, opt),
+			      (3 * sizeof(sqfs_u32)));
+	} else if (__alignof__(sqfs_compressor_config_t) == __alignof__(sqfs_u64)) {
+		TEST_EQUAL_UI(offsetof(sqfs_compressor_config_t, opt),
+			      (4 * sizeof(sqfs_u32)));
+	}
+}
+
+static const char *names[] = {
+	[SQFS_COMP_GZIP] = "gzip",
+	[SQFS_COMP_LZMA] = "lzma",
+	[SQFS_COMP_LZO] = "lzo",
+	[SQFS_COMP_XZ] = "xz",
+	[SQFS_COMP_LZ4] = "lz4",
+	[SQFS_COMP_ZSTD] = "zstd",
+};
+
+static void test_compressor_names(void)
+{
+	const char *str;
+	int i, id;
+
+	for (i = SQFS_COMP_MIN; i <= SQFS_COMP_MAX; ++i) {
+		str = sqfs_compressor_name_from_id(i);
+		TEST_STR_EQUAL(str, names[i]);
+
+		id = sqfs_compressor_id_from_name(str);
+		TEST_EQUAL_I(id, i);
+	}
+}
+
+static void test_blockproc_stats(void)
+{
+	sqfs_block_processor_stats_t stats;
+	size_t off;
+
+	TEST_EQUAL_UI(sizeof(stats.size), sizeof(size_t));
+	TEST_EQUAL_UI(sizeof(stats.input_bytes_read), sizeof(sqfs_u64));
+	TEST_EQUAL_UI(sizeof(stats.output_bytes_generated), sizeof(sqfs_u64));
+	TEST_EQUAL_UI(sizeof(stats.data_block_count), sizeof(sqfs_u64));
+	TEST_EQUAL_UI(sizeof(stats.frag_block_count), sizeof(sqfs_u64));
+	TEST_EQUAL_UI(sizeof(stats.sparse_block_count), sizeof(sqfs_u64));
+	TEST_EQUAL_UI(sizeof(stats.total_frag_count), sizeof(sqfs_u64));
+	TEST_EQUAL_UI(sizeof(stats.actual_frag_count), sizeof(sqfs_u64));
+
+	if (__alignof__(stats) == __alignof__(sqfs_u32)) {
+		TEST_ASSERT(sizeof(stats) >=
+			    (sizeof(sqfs_u32) + 7 * sizeof(sqfs_u64)));
+	} else if (__alignof__(stats) == __alignof__(sqfs_u64)) {
+		TEST_ASSERT(sizeof(stats) >= (8 * sizeof(sqfs_u64)));
+	}
+
+	TEST_EQUAL_UI(offsetof(sqfs_block_processor_stats_t, size), 0);
+
+	if (sizeof(size_t) < sizeof(sqfs_u64) &&
+	    (__alignof__(sqfs_block_processor_stats_t) ==
+	     __alignof__(sqfs_u64))) {
+		off = sizeof(sqfs_u64);
+	} else {
+		off = sizeof(stats.size);
+	}
+
+	TEST_EQUAL_UI(offsetof(sqfs_block_processor_stats_t,
+			       input_bytes_read), off);
+	off += sizeof(sqfs_u64);
+
+	TEST_EQUAL_UI(offsetof(sqfs_block_processor_stats_t,
+			       output_bytes_generated), off);
+	off += sizeof(sqfs_u64);
+
+	TEST_EQUAL_UI(offsetof(sqfs_block_processor_stats_t,
+			       data_block_count), off);
+	off += sizeof(sqfs_u64);
+
+	TEST_EQUAL_UI(offsetof(sqfs_block_processor_stats_t,
+			       frag_block_count), off);
+	off += sizeof(sqfs_u64);
+
+	TEST_EQUAL_UI(offsetof(sqfs_block_processor_stats_t,
+			       sparse_block_count), off);
+	off += sizeof(sqfs_u64);
+
+	TEST_EQUAL_UI(offsetof(sqfs_block_processor_stats_t,
+			       total_frag_count), off);
+	off += sizeof(sqfs_u64);
+
+	TEST_EQUAL_UI(offsetof(sqfs_block_processor_stats_t,
+			       actual_frag_count), off);
+}
+
+static void test_blockproc_desc(void)
+{
+	sqfs_block_processor_desc_t desc;
+
+	TEST_ASSERT(sizeof(desc) >= (4 * sizeof(sqfs_u32) +
+				     5 * sizeof(void *)));
+
+	TEST_EQUAL_UI(sizeof(desc.size), sizeof(sqfs_u32));
+	TEST_EQUAL_UI(sizeof(desc.max_block_size), sizeof(sqfs_u32));
+	TEST_EQUAL_UI(sizeof(desc.num_workers), sizeof(sqfs_u32));
+	TEST_EQUAL_UI(sizeof(desc.max_backlog), sizeof(sqfs_u32));
+	TEST_EQUAL_UI(sizeof(desc.cmp), sizeof(void *));
+	TEST_EQUAL_UI(sizeof(desc.wr), sizeof(void *));
+	TEST_EQUAL_UI(sizeof(desc.tbl), sizeof(void *));
+	TEST_EQUAL_UI(sizeof(desc.file), sizeof(void *));
+	TEST_EQUAL_UI(sizeof(desc.uncmp), sizeof(void *));
+
+	TEST_EQUAL_UI(offsetof(sqfs_block_processor_desc_t, size), 0);
+	TEST_EQUAL_UI(offsetof(sqfs_block_processor_desc_t, max_block_size),
+		      sizeof(sqfs_u32));
+	TEST_EQUAL_UI(offsetof(sqfs_block_processor_desc_t, num_workers),
+		      (2 * sizeof(sqfs_u32)));
+	TEST_EQUAL_UI(offsetof(sqfs_block_processor_desc_t, max_backlog),
+		      (3 * sizeof(sqfs_u32)));
+	TEST_EQUAL_UI(offsetof(sqfs_block_processor_desc_t, cmp),
+		      (4 * sizeof(sqfs_u32)));
+	TEST_EQUAL_UI(offsetof(sqfs_block_processor_desc_t, wr),
+		      (4 * sizeof(sqfs_u32) + sizeof(void *)));
+	TEST_EQUAL_UI(offsetof(sqfs_block_processor_desc_t, tbl),
+		      (4 * sizeof(sqfs_u32) + 2 * sizeof(void *)));
+	TEST_EQUAL_UI(offsetof(sqfs_block_processor_desc_t, file),
+		      (4 * sizeof(sqfs_u32) + 3 * sizeof(void *)));
+	TEST_EQUAL_UI(offsetof(sqfs_block_processor_desc_t, uncmp),
+		      (4 * sizeof(sqfs_u32) + 4 * sizeof(void *)));
+}
+
+int main(int argc, char **argv)
+{
+	(void)argc; (void)argv;
+	test_compressor_opt_struct();
+	test_compressor_names();
+	test_blockproc_stats();
+	test_blockproc_desc();
+	return EXIT_SUCCESS;
+}
diff --git a/lib/sqfs/test/get_node_path.c b/lib/sqfs/test/get_node_path.c
new file mode 100644
index 0000000..c76cc1c
--- /dev/null
+++ b/lib/sqfs/test/get_node_path.c
@@ -0,0 +1,132 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+/*
+ * get_node_path.c
+ *
+ * Copyright (C) 2022 David Oberhollenzer <goliath@infraroot.at>
+ */
+#include "config.h"
+#include "compat.h"
+#include "util/test.h"
+
+#include "sqfs/dir_reader.h"
+#include "sqfs/error.h"
+
+int main(int argc, char **argv)
+{
+	sqfs_tree_node_t *n0, *n1, *n2;
+	char *str;
+	int ret;
+	(void)argc;
+	(void)argv;
+
+	n0 = calloc(1, sizeof(*n0) + 16);
+	TEST_NOT_NULL(n0);
+
+	n1 = calloc(1, sizeof(*n1) + 16);
+	TEST_NOT_NULL(n1);
+
+	n2 = calloc(1, sizeof(*n2) + 16);
+	TEST_NOT_NULL(n2);
+
+	/* no parent -> must return "/" */
+	ret = sqfs_tree_node_get_path(n0, &str);
+	TEST_EQUAL_I(ret, 0);
+	TEST_NOT_NULL(str);
+	TEST_STR_EQUAL(str, "/");
+	sqfs_free(str);
+
+	/* hiearchy levels */
+	n1->parent = n0;
+	n0->children = n1;
+	strcpy((char *)n1->name, "bar");
+
+	n2->parent = n1;
+	n1->children = n2;
+	strcpy((char *)n2->name, "baz");
+
+	ret = sqfs_tree_node_get_path(n1, &str);
+	TEST_EQUAL_I(ret, 0);
+	TEST_NOT_NULL(str);
+	TEST_STR_EQUAL(str, "/bar");
+	sqfs_free(str);
+
+	ret = sqfs_tree_node_get_path(n2, &str);
+	TEST_EQUAL_I(ret, 0);
+	TEST_NOT_NULL(str);
+	TEST_STR_EQUAL(str, "/bar/baz");
+	sqfs_free(str);
+
+	/* root node must not have a name */
+	strcpy((char *)n0->name, "foo");
+
+	ret = sqfs_tree_node_get_path(n2, &str);
+	TEST_EQUAL_I(ret, SQFS_ERROR_ARG_INVALID);
+	TEST_NULL(str);
+	n0->name[0] = '\0';
+
+	ret = sqfs_tree_node_get_path(n2, &str);
+	TEST_EQUAL_I(ret, 0);
+	TEST_NOT_NULL(str);
+	TEST_STR_EQUAL(str, "/bar/baz");
+	sqfs_free(str);
+
+	/* non-root nodes must have names */
+	n1->name[0] = '\0';
+
+	ret = sqfs_tree_node_get_path(n2, &str);
+	TEST_EQUAL_I(ret, SQFS_ERROR_CORRUPTED);
+	TEST_NULL(str);
+	n1->name[0] = 'b';
+
+	ret = sqfs_tree_node_get_path(n2, &str);
+	TEST_EQUAL_I(ret, 0);
+	TEST_NOT_NULL(str);
+	TEST_STR_EQUAL(str, "/bar/baz");
+	sqfs_free(str);
+
+	/* some names are illegal */
+	strcpy((char *)n1->name, "..");
+	ret = sqfs_tree_node_get_path(n2, &str);
+	TEST_EQUAL_I(ret, SQFS_ERROR_CORRUPTED);
+	TEST_NULL(str);
+
+	strcpy((char *)n1->name, ".");
+	ret = sqfs_tree_node_get_path(n2, &str);
+	TEST_EQUAL_I(ret, SQFS_ERROR_CORRUPTED);
+	TEST_NULL(str);
+
+	strcpy((char *)n1->name, "a/b");
+	ret = sqfs_tree_node_get_path(n2, &str);
+	TEST_EQUAL_I(ret, SQFS_ERROR_CORRUPTED);
+	TEST_NULL(str);
+
+	strcpy((char *)n1->name, "bar");
+	ret = sqfs_tree_node_get_path(n2, &str);
+	TEST_EQUAL_I(ret, 0);
+	TEST_NOT_NULL(str);
+	TEST_STR_EQUAL(str, "/bar/baz");
+	sqfs_free(str);
+
+	/* link loops must be detected */
+	n0->parent = n2;
+	strcpy((char *)n0->name, "foo");
+
+	ret = sqfs_tree_node_get_path(n2, &str);
+	TEST_EQUAL_I(ret, SQFS_ERROR_LINK_LOOP);
+	TEST_NULL(str);
+
+	n0->parent = NULL;
+	n0->name[0] = '\0';
+
+	ret = sqfs_tree_node_get_path(n2, &str);
+	TEST_EQUAL_I(ret, 0);
+	TEST_NOT_NULL(str);
+	TEST_STR_EQUAL(str, "/bar/baz");
+	sqfs_free(str);
+
+	/* cleanup */
+	free(n0);
+	free(n1);
+	free(n2);
+	return EXIT_SUCCESS;
+}
diff --git a/lib/sqfs/test/table.c b/lib/sqfs/test/table.c
new file mode 100644
index 0000000..3e44fa3
--- /dev/null
+++ b/lib/sqfs/test/table.c
@@ -0,0 +1,199 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+/*
+ * table.c
+ *
+ * Copyright (C) 2021 David Oberhollenzer <goliath@infraroot.at>
+ */
+#include "config.h"
+#include "compat.h"
+#include "util/test.h"
+
+#include "sqfs/compressor.h"
+#include "sqfs/error.h"
+#include "sqfs/table.h"
+#include "sqfs/io.h"
+
+static sqfs_u8 file_data[32768];
+static size_t file_used = 0;
+
+static int dummy_read_at(sqfs_file_t *file, sqfs_u64 offset,
+			 void *buffer, size_t size)
+{
+	(void)file;
+
+	if (offset >= sizeof(file_data))
+		return SQFS_ERROR_OUT_OF_BOUNDS;
+
+	if (size > (sizeof(file_data) - offset))
+		return SQFS_ERROR_OUT_OF_BOUNDS;
+
+	memset(buffer, 0, size);
+
+	if (offset < file_used) {
+		if (size > (file_used - offset))
+			size = file_used - offset;
+
+		memcpy(buffer, file_data + offset, size);
+	}
+	return 0;
+}
+
+static int dummy_write_at(sqfs_file_t *file, sqfs_u64 offset,
+			  const void *buffer, size_t size)
+{
+	(void)file;
+
+	if (offset >= sizeof(file_data))
+		return SQFS_ERROR_OUT_OF_BOUNDS;
+
+	if (size > (sizeof(file_data) - offset))
+		return SQFS_ERROR_OUT_OF_BOUNDS;
+
+	if (offset > file_used)
+		memset(file_data + file_used, 0, offset - file_used);
+
+	if ((offset + size) > file_used)
+		file_used = offset + size;
+
+	memcpy(file_data + offset, buffer, size);
+	return 0;
+}
+
+static sqfs_u64 dummy_get_size(const sqfs_file_t *file)
+{
+	(void)file;
+	return file_used;
+}
+
+static sqfs_s32 dummy_compress(sqfs_compressor_t *cmp, const sqfs_u8 *in,
+			       sqfs_u32 size, sqfs_u8 *out, sqfs_u32 outsize)
+{
+	(void)cmp;
+	memcpy(out, in, outsize < size ? outsize : size);
+	return 0;
+}
+
+static sqfs_s32 dummy_uncompress(sqfs_compressor_t *cmp, const sqfs_u8 *in,
+				 sqfs_u32 size, sqfs_u8 *out, sqfs_u32 outsize)
+{
+	(void)cmp;
+	if (outsize < size)
+		return 0;
+	memcpy(out, in, size);
+	return size;
+}
+
+static sqfs_file_t dummy_file = {
+	{ 1, NULL, NULL },
+	dummy_read_at,
+	dummy_write_at,
+	dummy_get_size,
+	NULL,
+};
+
+static sqfs_compressor_t dummy_compressor = {
+	{ 1, NULL, NULL },
+	NULL,
+	NULL,
+	NULL,
+	dummy_compress,
+};
+
+static sqfs_compressor_t dummy_uncompressor = {
+	{ 1, NULL, NULL },
+	NULL,
+	NULL,
+	NULL,
+	dummy_uncompress,
+};
+
+/*****************************************************************************/
+
+static sqfs_u64 table[4000];
+
+int main(int argc, char **argv)
+{
+	sqfs_u64 start, value, locations[4], *copy;
+	sqfs_u16 hdr;
+	size_t i;
+	int ret;
+	(void)argc; (void)argv;
+
+	/* fill the table with data */
+	for (i = 0; i < sizeof(table) / sizeof(table[0]); ++i)
+		table[i] = i;
+
+	/* serialize the table */
+	ret = sqfs_write_table(&dummy_file, &dummy_compressor,
+			       table, sizeof(table), &start);
+	TEST_EQUAL_I(ret, 0);
+
+	TEST_EQUAL_UI(file_used, (3 * (8192 + 2) + (7424 + 2) + 4 * sizeof(sqfs_u64)));
+	TEST_EQUAL_UI(start, (3 * (8192 + 2) + (7424 + 2)));
+
+	/* check the location list */
+	memcpy(locations, file_data + start, sizeof(locations));
+	for (i = 0; i < 4; ++i)
+		locations[i] = le64toh(locations[i]);
+
+	TEST_EQUAL_UI(locations[0], 0);
+	TEST_EQUAL_UI(locations[1], (1 * (8192 + 2)));
+	TEST_EQUAL_UI(locations[2], (2 * (8192 + 2)));
+	TEST_EQUAL_UI(locations[3], (3 * (8192 + 2)));
+
+	/* check the individual blocks */
+	memcpy(&hdr, file_data + locations[0], sizeof(hdr));
+	hdr = le16toh(hdr);
+	TEST_EQUAL_UI(hdr, (0x8000 | 8192));
+
+	for (i = 0; i < 8192; i += sizeof(sqfs_u64)) {
+		memcpy(&value, (file_data + locations[0] + 2) + i,
+		       sizeof(value));
+
+		TEST_EQUAL_UI(value, i / sizeof(sqfs_u64));
+	}
+
+	memcpy(&hdr, file_data + locations[1], sizeof(hdr));
+	hdr = le16toh(hdr);
+	TEST_EQUAL_UI(hdr, (0x8000 | 8192));
+
+	for (i = 0; i < 8192; i += sizeof(sqfs_u64)) {
+		memcpy(&value, (file_data + locations[1] + 2) + i,
+		       sizeof(value));
+
+		TEST_EQUAL_UI(value, (1024 + i / sizeof(sqfs_u64)));
+	}
+
+	memcpy(&hdr, file_data + locations[2], sizeof(hdr));
+	hdr = le16toh(hdr);
+	TEST_EQUAL_UI(hdr, (0x8000 | 8192));
+
+	for (i = 0; i < 8192; i += sizeof(sqfs_u64)) {
+		memcpy(&value, (file_data + locations[2] + 2) + i,
+		       sizeof(value));
+
+		TEST_EQUAL_UI(value, (2048 + i / sizeof(sqfs_u64)));
+	}
+
+	memcpy(&hdr, file_data + locations[3], sizeof(hdr));
+	hdr = le16toh(hdr);
+	TEST_EQUAL_UI(hdr, (0x8000 | 7424));
+
+	for (i = 0; i < 7424; i += sizeof(sqfs_u64)) {
+		memcpy(&value, (file_data + locations[3] + 2) + i,
+		       sizeof(value));
+
+		TEST_EQUAL_UI(value, (3072 + i / sizeof(sqfs_u64)));
+	}
+
+	/* read the table back */
+	ret = sqfs_read_table(&dummy_file, &dummy_uncompressor,
+			      sizeof(table), start, 0, start, (void **)&copy);
+	TEST_EQUAL_I(ret, 0);
+
+	ret = memcmp(copy, table, sizeof(table));
+	TEST_EQUAL_I(ret, 0);
+
+	free(copy);
+	return EXIT_SUCCESS;
+}
diff --git a/lib/sqfs/test/xattr_benchmark.c b/lib/sqfs/test/xattr_benchmark.c
new file mode 100644
index 0000000..072dd06
--- /dev/null
+++ b/lib/sqfs/test/xattr_benchmark.c
@@ -0,0 +1,124 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+/*
+ * xattr_benchmark.c
+ *
+ * Copyright (C) 2021 David Oberhollenzer <goliath@infraroot.at>
+ */
+#include "config.h"
+#include "compat.h"
+#include "common.h"
+
+#include "sqfs/xattr_writer.h"
+#include "sqfs/xattr.h"
+
+#include <stdlib.h>
+#include <getopt.h>
+#include <string.h>
+#include <stdio.h>
+
+static struct option long_opts[] = {
+	{ "block-count", required_argument, NULL, 'b' },
+	{ "groups-size", required_argument, NULL, 'g' },
+	{ "version", no_argument, NULL, 'V' },
+	{ "help", no_argument, NULL, 'h' },
+	{ NULL, 0, NULL, 0 },
+};
+
+static const char *short_opts = "g:b:hV";
+
+static const char *help_string =
+"Usage: xattr_benchmark [OPTIONS...]\n"
+"\n"
+"Possible options:\n"
+"\n"
+"  --block-count, -b <count>  How many unique xattr blocks to generate.\n"
+"  --group-size, -g <count>   Number of key-value pairs to generate for each\n"
+"                             xattr block.\n"
+"\n";
+
+int main(int argc, char **argv)
+{
+	long blkidx, grpidx, block_count = 0, group_size = 0;
+	sqfs_xattr_writer_t *xwr;
+	sqfs_u32 id;
+	int ret;
+
+	for (;;) {
+		int i = getopt_long(argc, argv, short_opts, long_opts, NULL);
+		if (i == -1)
+			break;
+
+		switch (i) {
+		case 'b':
+			block_count = strtol(optarg, NULL, 0);
+			break;
+		case 'g':
+			group_size = strtol(optarg, NULL, 0);
+			break;
+		case 'h':
+			fputs(help_string, stdout);
+			return EXIT_SUCCESS;
+		case 'V':
+			print_version("xattr_benchmark");
+			return EXIT_SUCCESS;
+		default:
+			goto fail_arg;
+		}
+	}
+
+	if (block_count <= 0) {
+		fputs("A block count > 0 must be specified.\n", stderr);
+		goto fail_arg;
+	}
+
+	if (group_size <= 0) {
+		fputs("A group size > 0 must be specified.\n", stderr);
+		goto fail_arg;
+	}
+
+	/* setup writer */
+	xwr = sqfs_xattr_writer_create(0);
+
+	/* generate blocks */
+	for (blkidx = 0; blkidx < block_count; ++blkidx) {
+		ret = sqfs_xattr_writer_begin(xwr, 0);
+		if (ret < 0) {
+			sqfs_perror(NULL, "begin xattr block", ret);
+			goto fail;
+		}
+
+		for (grpidx = 0; grpidx < group_size; ++grpidx) {
+			char key[64], value[64];
+
+			snprintf(key, sizeof(key), "user.group%ld.key%ld",
+				 blkidx, grpidx);
+
+			snprintf(value, sizeof(value), "group%ld/value%ld",
+				 blkidx, grpidx);
+
+			ret = sqfs_xattr_writer_add(xwr, key, value,
+						    strlen(value));
+
+			if (ret < 0) {
+				sqfs_perror(NULL, "add to xattr block", ret);
+				goto fail;
+			}
+		}
+
+		ret = sqfs_xattr_writer_end(xwr, &id);
+		if (ret < 0) {
+			sqfs_perror(NULL, "end xattr block", ret);
+			goto fail;
+		}
+	}
+
+	/* cleanup */
+	sqfs_drop(xwr);
+	return EXIT_SUCCESS;
+fail:
+	sqfs_drop(xwr);
+	return EXIT_FAILURE;
+fail_arg:
+	fputs("Try `xattr_benchmark --help' for more information.\n", stderr);
+	return EXIT_FAILURE;
+}
diff --git a/lib/sqfs/test/xattr_writer.c b/lib/sqfs/test/xattr_writer.c
new file mode 100644
index 0000000..f7d0734
--- /dev/null
+++ b/lib/sqfs/test/xattr_writer.c
@@ -0,0 +1,323 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+/*
+ * xattr_writer.c
+ *
+ * Copyright (C) 2021 David Oberhollenzer <goliath@infraroot.at>
+ */
+#include "config.h"
+#include "compat.h"
+#include "util/test.h"
+
+#include "sqfs/xattr_writer.h"
+#include "sqfs/compressor.h"
+#include "sqfs/xattr.h"
+#include "sqfs/error.h"
+#include "sqfs/super.h"
+#include "sqfs/io.h"
+
+static sqfs_u8 file_data[1024];
+static size_t file_used = 0;
+
+static int dummy_write_at(sqfs_file_t *file, sqfs_u64 offset,
+			  const void *buffer, size_t size)
+{
+	(void)file;
+
+	if (offset >= sizeof(file_data))
+		return SQFS_ERROR_OUT_OF_BOUNDS;
+
+	if (size > (sizeof(file_data) - offset))
+		return SQFS_ERROR_OUT_OF_BOUNDS;
+
+	if (offset > file_used)
+		memset(file_data + file_used, 0, offset - file_used);
+
+	if ((offset + size) > file_used)
+		file_used = offset + size;
+
+	memcpy(file_data + offset, buffer, size);
+	return 0;
+}
+
+static sqfs_u64 dummy_get_size(const sqfs_file_t *file)
+{
+	(void)file;
+	return file_used;
+}
+
+static sqfs_s32 dummy_compress(sqfs_compressor_t *cmp, const sqfs_u8 *in,
+			       sqfs_u32 size, sqfs_u8 *out, sqfs_u32 outsize)
+{
+	(void)cmp;
+	memcpy(out, in, outsize < size ? outsize : size);
+	return 0;
+}
+
+static sqfs_file_t dummy_file = {
+	{ 1, NULL, NULL },
+	NULL,
+	dummy_write_at,
+	dummy_get_size,
+	NULL,
+};
+
+static sqfs_compressor_t dummy_compressor = {
+	{ 1, NULL, NULL },
+	NULL,
+	NULL,
+	NULL,
+	dummy_compress,
+};
+
+/*****************************************************************************/
+
+int main(int argc, char **argv)
+{
+	size_t offset, ool_value_offset, id_offset;
+	sqfs_xattr_id_table_t idtbl;
+	sqfs_xattr_writer_t *xwr;
+	sqfs_xattr_value_t value;
+	sqfs_xattr_entry_t key;
+	sqfs_xattr_id_t desc;
+	sqfs_super_t super;
+	char strbuf[32];
+	sqfs_u16 hdr;
+	sqfs_u64 ref;
+	sqfs_u32 id;
+	int ret;
+	(void)argc; (void)argv;
+
+	/* setup */
+	xwr = sqfs_xattr_writer_create(0);
+	TEST_NOT_NULL(xwr);
+
+	/* record a block of key/value pairs */
+	ret = sqfs_xattr_writer_begin(xwr, 0);
+	TEST_EQUAL_I(ret, 0);
+
+	ret = sqfs_xattr_writer_add(xwr, "user.foobar", "test", 4);
+	TEST_EQUAL_I(ret, 0);
+
+	ret = sqfs_xattr_writer_add(xwr, "security.selinux", "Xwhatever", 9);
+	TEST_EQUAL_I(ret, 0);
+
+	ret = sqfs_xattr_writer_end(xwr, &id);
+	TEST_EQUAL_I(ret, 0);
+	TEST_EQUAL_UI(id, 0);
+
+	/* record a second, different block */
+	ret = sqfs_xattr_writer_begin(xwr, 0);
+	TEST_EQUAL_I(ret, 0);
+
+	ret = sqfs_xattr_writer_add(xwr, "user.foobar", "bla", 3);
+	TEST_EQUAL_I(ret, 0);
+
+	ret = sqfs_xattr_writer_add(xwr, "security.selinux", "blub", 4);
+	TEST_EQUAL_I(ret, 0);
+
+	ret = sqfs_xattr_writer_end(xwr, &id);
+	TEST_EQUAL_I(ret, 0);
+	TEST_EQUAL_UI(id, 1);
+
+	/* same as first block after sorting and gets the same ID */
+	ret = sqfs_xattr_writer_begin(xwr, 0);
+	TEST_EQUAL_I(ret, 0);
+
+	ret = sqfs_xattr_writer_add(xwr, "security.selinux", "Xwhatever", 9);
+	TEST_EQUAL_I(ret, 0);
+
+	ret = sqfs_xattr_writer_add(xwr, "user.foobar", "test", 4);
+	TEST_EQUAL_I(ret, 0);
+
+	ret = sqfs_xattr_writer_end(xwr, &id);
+	TEST_EQUAL_I(ret, 0);
+	TEST_EQUAL_UI(id, 0);
+
+	/* the third assignment overwrites the first, making
+	   the block identical to the second one */
+	ret = sqfs_xattr_writer_begin(xwr, 0);
+	TEST_EQUAL_I(ret, 0);
+
+	ret = sqfs_xattr_writer_add(xwr, "user.foobar", "mimimi", 6);
+	TEST_EQUAL_I(ret, 0);
+
+	ret = sqfs_xattr_writer_add(xwr, "security.selinux", "blub", 4);
+	TEST_EQUAL_I(ret, 0);
+
+	ret = sqfs_xattr_writer_add(xwr, "user.foobar", "bla", 3);
+	TEST_EQUAL_I(ret, 0);
+
+	ret = sqfs_xattr_writer_end(xwr, &id);
+	TEST_EQUAL_I(ret, 0);
+	TEST_EQUAL_UI(id, 1);
+
+	/* add another block with the same value, so it gets stored OOL */
+	ret = sqfs_xattr_writer_begin(xwr, 0);
+	TEST_EQUAL_I(ret, 0);
+
+	ret = sqfs_xattr_writer_add(xwr, "security.selinux", "Xwhatever", 9);
+	TEST_EQUAL_I(ret, 0);
+
+	ret = sqfs_xattr_writer_end(xwr, &id);
+	TEST_EQUAL_I(ret, 0);
+	TEST_EQUAL_UI(id, 2);
+
+	/* serialize */
+	sqfs_super_init(&super, 131072, 0, SQFS_COMP_GZIP);
+	ret = sqfs_xattr_writer_flush(xwr, &dummy_file, &super,
+				      &dummy_compressor);
+	TEST_EQUAL_I(ret, 0);
+
+	TEST_EQUAL_UI(file_used, 177);
+
+	/* meta data block holding the key-value-pairs */
+	memcpy(&hdr, file_data, sizeof(hdr));
+	hdr = le16toh(hdr);
+	TEST_EQUAL_UI(hdr, (0x8000 | 101));
+	offset = 2;
+
+	memcpy(&key, file_data + offset, sizeof(key));
+	key.type = le16toh(key.type);
+	key.size = le16toh(key.size);
+	offset += sizeof(key);
+	TEST_EQUAL_UI(key.type, SQFS_XATTR_USER);
+	TEST_EQUAL_UI(key.size, 6);
+	memset(strbuf, '\0', sizeof(strbuf));
+	memcpy(strbuf, file_data + offset, key.size);
+	TEST_STR_EQUAL(strbuf, "foobar");
+	offset += key.size;
+
+	memcpy(&value, file_data + offset, sizeof(value));
+	value.size = le32toh(value.size);
+	offset += sizeof(value);
+	TEST_EQUAL_UI(value.size, 4);
+	memset(strbuf, '\0', sizeof(strbuf));
+	memcpy(strbuf, file_data + offset, value.size);
+	TEST_STR_EQUAL(strbuf, "test");
+	offset += value.size;
+
+	memcpy(&key, file_data + offset, sizeof(key));
+	key.type = le16toh(key.type);
+	key.size = le16toh(key.size);
+	offset += sizeof(key);
+	TEST_EQUAL_UI(key.type, SQFS_XATTR_SECURITY);
+	TEST_EQUAL_UI(key.size, 7);
+	memset(strbuf, '\0', sizeof(strbuf));
+	memcpy(strbuf, file_data + offset, key.size);
+	TEST_STR_EQUAL(strbuf, "selinux");
+	offset += key.size;
+
+	ool_value_offset = offset;
+
+	memcpy(&value, file_data + offset, sizeof(value));
+	value.size = le32toh(value.size);
+	offset += sizeof(value);
+	TEST_EQUAL_UI(value.size, 9);
+	memset(strbuf, '\0', sizeof(strbuf));
+	memcpy(strbuf, file_data + offset, value.size);
+	TEST_STR_EQUAL(strbuf, "Xwhatever");
+	offset += value.size;
+
+	memcpy(&key, file_data + offset, sizeof(key));
+	key.type = le16toh(key.type);
+	key.size = le16toh(key.size);
+	offset += sizeof(key);
+	TEST_EQUAL_UI(key.type, SQFS_XATTR_USER);
+	TEST_EQUAL_UI(key.size, 6);
+	memset(strbuf, '\0', sizeof(strbuf));
+	memcpy(strbuf, file_data + offset, key.size);
+	TEST_STR_EQUAL(strbuf, "foobar");
+	offset += key.size;
+
+	memcpy(&value, file_data + offset, sizeof(value));
+	value.size = le32toh(value.size);
+	offset += sizeof(value);
+	TEST_EQUAL_UI(value.size, 3);
+	memset(strbuf, '\0', sizeof(strbuf));
+	memcpy(strbuf, file_data + offset, value.size);
+	TEST_STR_EQUAL(strbuf, "bla");
+	offset += value.size;
+
+	memcpy(&key, file_data + offset, sizeof(key));
+	key.type = le16toh(key.type);
+	key.size = le16toh(key.size);
+	offset += sizeof(key);
+	TEST_EQUAL_UI(key.type, SQFS_XATTR_SECURITY);
+	TEST_EQUAL_UI(key.size, 7);
+	memset(strbuf, '\0', sizeof(strbuf));
+	memcpy(strbuf, file_data + offset, key.size);
+	TEST_STR_EQUAL(strbuf, "selinux");
+	offset += key.size;
+
+	memcpy(&value, file_data + offset, sizeof(value));
+	value.size = le32toh(value.size);
+	offset += sizeof(value);
+	TEST_EQUAL_UI(value.size, 4);
+	memset(strbuf, '\0', sizeof(strbuf));
+	memcpy(strbuf, file_data + offset, value.size);
+	TEST_STR_EQUAL(strbuf, "blub");
+	offset += value.size;
+
+	memcpy(&key, file_data + offset, sizeof(key));
+	key.type = le16toh(key.type);
+	key.size = le16toh(key.size);
+	offset += sizeof(key);
+	TEST_EQUAL_UI(key.type, (SQFS_XATTR_SECURITY | SQFS_XATTR_FLAG_OOL));
+	TEST_EQUAL_UI(key.size, 7);
+	memset(strbuf, '\0', sizeof(strbuf));
+	memcpy(strbuf, file_data + offset, key.size);
+	TEST_STR_EQUAL(strbuf, "selinux");
+	offset += key.size;
+
+	memcpy(&value, file_data + offset, sizeof(value));
+	value.size = le32toh(value.size);
+	offset += sizeof(value);
+	TEST_EQUAL_UI(value.size, 8);
+	memcpy(&ref, file_data + offset, sizeof(ref));
+	ref = le64toh(ref);
+	TEST_EQUAL_UI(ref, (ool_value_offset - 2));
+	offset += value.size;
+
+	/* meta data block holding the ID descriptions */
+	id_offset = offset;
+
+	memcpy(&hdr, file_data + offset, sizeof(hdr));
+	TEST_EQUAL_UI(le16toh(hdr), (0x8000 | (16 * 3)));
+	offset += sizeof(hdr);
+
+	memcpy(&desc, file_data + offset, sizeof(desc));
+	TEST_EQUAL_UI(le64toh(desc.xattr), 0);
+	TEST_EQUAL_UI(le32toh(desc.count), 2);
+	TEST_EQUAL_UI(le32toh(desc.size), 42);
+	offset += sizeof(desc);
+
+	memcpy(&desc, file_data + offset, sizeof(desc));
+	TEST_EQUAL_UI(le64toh(desc.xattr), 42);
+	TEST_EQUAL_UI(le32toh(desc.count), 2);
+	TEST_EQUAL_UI(le32toh(desc.size), 36);
+	offset += sizeof(desc);
+
+	memcpy(&desc, file_data + offset, sizeof(desc));
+	TEST_EQUAL_UI(le64toh(desc.xattr), 78);
+	TEST_EQUAL_UI(le32toh(desc.count), 1);
+	TEST_EQUAL_UI(le32toh(desc.size), 23);
+	offset += sizeof(desc);
+
+	/* the xattr table itself */
+	TEST_EQUAL_UI(super.xattr_id_table_start, offset);
+
+	memcpy(&idtbl, file_data + offset, sizeof(idtbl));
+	TEST_EQUAL_UI(le64toh(idtbl.xattr_table_start), 0);
+	TEST_EQUAL_UI(le32toh(idtbl.xattr_ids), 3);
+	offset += sizeof(idtbl);
+
+	memcpy(&ref, file_data + offset, sizeof(ref));
+	TEST_EQUAL_UI(le64toh(ref), id_offset);
+	offset += sizeof(ref);
+
+	TEST_EQUAL_UI(offset, file_used);
+
+	/* cleanup */
+	sqfs_drop(xwr);
+	return EXIT_SUCCESS;
+}