test-integration

#!/usr/bin/env bash
set -euo pipefail

source "$HOME/dotfiles/bin/src/capture.bash"

out=""
err=""
rc=0
: "${PRINTABLE_BINARY_MUTE_STATS:=}"

root_dir="$(pwd)"
prng_gen="${PAR2_PRNG_GEN:-$root_dir/zig-out/bin/prng-gen}"
seed="${PAR2_TEST_SEED:-1}"
seq=1

if command -v mktmp >/dev/null 2>&1; then
	tmpdir="$(mktmp --tmpdir)"
else
tmpdir="$(mktemp -d "${TMPDIR:-/tmp}/par2z.XXXXXX")"
	echo "warning: mktmp not found; using mktemp" >&2
fi
cleanup() {
	if [ -n "${tmpdir-}" ] && [ -d "$tmpdir" ]; then
		rm -rf "$tmpdir"
	fi
}
trap cleanup EXIT

printf '%s\n' "$seed" > "$tmpdir/seed.txt"

capture zig build
if [ "$rc" -ne 0 ]; then
	echo "zig build failed: $err" >&2
	exit 1
fi

if [ ! -x "$prng_gen" ]; then
	echo "prng-gen not found at $prng_gen" >&2
	exit 1
fi

gen_data() {
	local path="$1"
	local size="$2"
	capture "$prng_gen" "$path" "$size" "$seed" "$seq"
	if [ "$rc" -ne 0 ]; then
		echo "prng-gen failed: $err" >&2
		exit 1
	fi
	seq=$((seq + 1))
}

list_volumes() {
	local dir="$1"
	local base="$2"
	find "$dir" -maxdepth 1 -type f -name "$base.vol*.par2" -print | sed 's#.*/##' | sort
}

compare_volumes() {
	local label="$1"
	local dir_a="$2"
	local dir_b="$3"
	local base="$4"
	local a
	local b
	a="$(list_volumes "$dir_a" "$base")"
	b="$(list_volumes "$dir_b" "$base")"
	if [ "$a" != "$b" ]; then
		echo "volume layout mismatch: $label" >&2
		echo "par2 volumes:" >&2
		printf '%s\n' "$a" >&2
		echo "our volumes:" >&2
		printf '%s\n' "$b" >&2
		exit 1
	fi
}

corrupt_bytes() {
	local path="$1"
	local size="$2"
	local offset="$3"
	local tmp="$tmpdir/corrupt.bin"
	gen_data "$tmp" "$size"
	capture dd if="$tmp" of="$path" bs=1 count="$size" seek="$offset" conv=notrunc status=none
	if [ "$rc" -ne 0 ]; then
		echo "dd corrupt failed: $err" >&2
		exit 1
	fi
}

corrupt_byte() {
	local path="$1"
	local offset="$2"
	if ! printf '\xFF' | dd of="$path" bs=1 count=1 seek="$offset" conv=notrunc status=none; then
		echo "dd corrupt failed for byte patch" >&2
		exit 1
	fi
}

gen_data "$tmpdir/data.bin" 65536

capture par2 create -s4096 -c16 "$tmpdir/data.par2" "$tmpdir/data.bin"
if [ "$rc" -ne 0 ]; then
	echo "par2 create failed: $err" >&2
	exit 1
fi
cp "$tmpdir/data.bin" "$tmpdir/orig.bin"
rm "$tmpdir/data.bin"

capture -- /bin/bash -c "cd \"$tmpdir\" && \"$root_dir/zig-out/bin/par2z-cli\" recover -o \"$tmpdir/out\" data.par2"
if [ "$rc" -ne 0 ]; then
	echo "par2z-cli recover failed: $err" >&2
	exit 1
fi

orig_hash="$(openssl dgst -sha256 "$tmpdir/orig.bin" | awk '{print $NF}')"
recovered_hash="$(openssl dgst -sha256 "$tmpdir/out/data.bin" | awk '{print $NF}')"
if [ "$orig_hash" != "$recovered_hash" ]; then
	echo "hash mismatch for recovered full-missing case" >&2
	exit 1
fi
cp "$tmpdir/out/data.bin" "$tmpdir/data.bin"

capture -- /bin/bash -c "cd \"$tmpdir\" && par2 verify data.par2 data.bin"
if [ "$rc" -ne 0 ]; then
	echo "par2 verify failed: $err" >&2
	exit 1
fi

# Partial corruption case (less than protection)
gen_data "$tmpdir/data2.bin" 65536
capture par2 create -s4096 -r20 "$tmpdir/data2.par2" "$tmpdir/data2.bin"
if [ "$rc" -ne 0 ]; then
	echo "par2 create failed: $err" >&2
	exit 1
fi
cp "$tmpdir/data2.bin" "$tmpdir/orig2.bin"
corrupt_bytes "$tmpdir/data2.bin" 4096 4096
corrupt_bytes "$tmpdir/data2.bin" 4096 16384
capture -- /bin/bash -c "cd \"$tmpdir\" && \"$root_dir/zig-out/bin/par2z-cli\" recover -o \"$tmpdir/out2\" data2.par2 data2.bin"
if [ "$rc" -ne 0 ]; then
	echo "par2z-cli recover failed: $err" >&2
	exit 1
fi
orig2_hash="$(openssl dgst -sha256 "$tmpdir/orig2.bin" | awk '{print $NF}')"
recovered2_hash="$(openssl dgst -sha256 "$tmpdir/out2/data2.bin" | awk '{print $NF}')"
if [ "$orig2_hash" != "$recovered2_hash" ]; then
	echo "hash mismatch for partial-corruption case" >&2
	exit 1
fi
cp "$tmpdir/out2/data2.bin" "$tmpdir/data2.bin"
capture -- /bin/bash -c "cd \"$tmpdir\" && par2 verify data2.par2 data2.bin"
if [ "$rc" -ne 0 ]; then
	echo "par2 verify failed: $err" >&2
	exit 1
fi

# Corrupt data + par2 recovery data, then recover with par2 and par2z
gen_data "$tmpdir/mix.bin" 65536
cp "$tmpdir/mix.bin" "$tmpdir/mix.orig"
capture -- /bin/bash -c "cd \"$tmpdir\" && par2 create -s4096 -c5 -n4 mix.par2 mix.bin"
if [ "$rc" -ne 0 ]; then
	echo "par2 create failed for mixed corruption case: $err" >&2
	exit 1
fi
mkdir -p "$tmpdir/mix-par2" "$tmpdir/mix-ours"
cp "$tmpdir/mix.bin" "$tmpdir/mix-par2/mix.bin"
cp "$tmpdir/mix.bin" "$tmpdir/mix-ours/mix.bin"
for f in "$tmpdir"/mix*.par2; do
	[ -f "$f" ] || continue
	cp "$f" "$tmpdir/mix-par2/"
	cp "$f" "$tmpdir/mix-ours/"
done
corrupt_byte "$tmpdir/mix-par2/mix.bin" 4096
corrupt_byte "$tmpdir/mix-par2/mix.bin" 12288
corrupt_byte "$tmpdir/mix-ours/mix.bin" 4096
corrupt_byte "$tmpdir/mix-ours/mix.bin" 12288
mix_par2_vol="$(find "$tmpdir/mix-par2" -maxdepth 1 -name 'mix.vol*.par2' -print | head -n1 || true)"
mix_ours_vol="$(find "$tmpdir/mix-ours" -maxdepth 1 -name 'mix.vol*.par2' -print | head -n1 || true)"
if [ -z "$mix_par2_vol" ] || [ -z "$mix_ours_vol" ]; then
	echo "missing volume files for mixed corruption case" >&2
	exit 1
fi
corrupt_byte "$mix_par2_vol" 0
corrupt_byte "$mix_ours_vol" 0
capture -- /bin/bash -c "cd \"$tmpdir/mix-par2\" && par2 repair -q mix.par2 mix.bin"
if [ "$rc" -ne 0 ] && [ "$rc" -ne 5 ] && [ "$rc" -ne 6 ]; then
	echo "par2 repair failed for mixed corruption case: $err" >&2
	exit 1
fi
capture -- /bin/bash -c "cd \"$tmpdir/mix-ours\" && \"$root_dir/zig-out/bin/par2z-cli\" recover -q mix.par2 mix.bin"
if [ "$rc" -ne 0 ]; then
	echo "par2z-cli recover failed for mixed corruption case: $err" >&2
	exit 1
fi
mix_orig_hash="$(openssl dgst -sha256 "$tmpdir/mix.orig" | awk '{print $NF}')"
mix_par2_hash="$(openssl dgst -sha256 "$tmpdir/mix-par2/mix.bin" | awk '{print $NF}')"
mix_ours_hash="$(openssl dgst -sha256 "$tmpdir/mix-ours/mix.bin" | awk '{print $NF}')"
if [ "$mix_orig_hash" != "$mix_par2_hash" ] || [ "$mix_orig_hash" != "$mix_ours_hash" ]; then
	echo "hash mismatch for mixed corruption case" >&2
	exit 1
fi

# Create via our CLI and verify with par2 (and repair)
gen_data "$tmpdir/data3.bin" 32768
cp "$tmpdir/data3.bin" "$tmpdir/orig3.bin"
capture -- /bin/bash -c "cd \"$tmpdir\" && \"$root_dir/zig-out/bin/par2z-cli\" create --block-size 4096 --redundancy-percent 10 data3.par2 data3.bin"
if [ "$rc" -ne 0 ]; then
	echo "par2z-cli create failed: $err" >&2
	exit 1
fi
capture -- /bin/bash -c "cd \"$tmpdir\" && par2 verify data3.par2 data3.bin"
if [ "$rc" -ne 0 ]; then
	echo "par2 verify failed: $err" >&2
	exit 1
fi
corrupt_bytes "$tmpdir/data3.bin" 4096 4096
capture -- /bin/bash -c "cd \"$tmpdir\" && par2 repair -q data3.par2 data3.bin"
if [ "$rc" -ne 0 ]; then
	echo "par2 repair failed: $err" >&2
	exit 1
fi
orig3_hash="$(openssl dgst -sha256 "$tmpdir/orig3.bin" | awk '{print $NF}')"
recovered3_hash="$(openssl dgst -sha256 "$tmpdir/data3.bin" | awk '{print $NF}')"
if [ "$orig3_hash" != "$recovered3_hash" ]; then
	echo "hash mismatch for cli-create repair case" >&2
	exit 1
fi

# Create with optional packets and verify with par2
gen_data "$tmpdir/data4.bin" 16384
cp "$tmpdir/data4.bin" "$tmpdir/orig4.bin"
capture -- /bin/bash -c "cd \"$tmpdir\" && \"$root_dir/zig-out/bin/par2z-cli\" create --block-size 4096 --redundancy-percent 10 --include-input-slices --emit-packed data4.par2 data4.bin"
if [ "$rc" -ne 0 ]; then
	echo "par2z-cli create failed: $err" >&2
	exit 1
fi
capture -- /bin/bash -c "cd \"$tmpdir\" && par2 verify data4.par2 data4.bin"
if [ "$rc" -ne 0 ]; then
	echo "par2 verify failed for optional packets" >&2
	exit 1
fi
corrupt_bytes "$tmpdir/data4.bin" 4096 4096
capture -- /bin/bash -c "cd \"$tmpdir\" && par2 repair -q data4.par2 data4.bin"
if [ "$rc" -ne 0 ]; then
	echo "par2 repair failed for optional packets" >&2
	exit 1
fi
orig4_hash="$(openssl dgst -sha256 "$tmpdir/orig4.bin" | awk '{print $NF}')"
recovered4_hash="$(openssl dgst -sha256 "$tmpdir/data4.bin" | awk '{print $NF}')"
if [ "$orig4_hash" != "$recovered4_hash" ]; then
	echo "hash mismatch for optional packets case" >&2
	exit 1
fi

# Multi-file create via par2, recover via our CLI

# LuaJIT CLI integration (optional)
if command -v luajit >/dev/null 2>&1; then
	luajit_cli="$root_dir/zig-out/bin/par2z-cli-luajit"
	if [ ! -x "$luajit_cli" ]; then
		echo "par2z-cli-luajit not found at $luajit_cli" >&2
		exit 1
	fi
	gen_data "$tmpdir/lj.bin" 32768
	cp "$tmpdir/lj.bin" "$tmpdir/lj.orig.bin"
	capture -- /bin/bash -c "cd \"$tmpdir\" && \"$luajit_cli\" create --block-size 4096 --redundancy-percent 10 lj.par2 lj.bin"
	if [ "$rc" -ne 0 ]; then
		echo "par2z-cli-luajit create failed: $err" >&2
		exit 1
	fi
	capture -- /bin/bash -c "cd \"$tmpdir\" && \"$luajit_cli\" verify lj.par2 lj.bin"
	if [ "$rc" -ne 0 ]; then
		echo "par2z-cli-luajit verify failed: $err" >&2
		exit 1
	fi
	corrupt_bytes "$tmpdir/lj.bin" 4096 4096
	capture -- /bin/bash -c "cd \"$tmpdir\" && \"$luajit_cli\" recover lj.par2 lj.bin"
	if [ "$rc" -ne 0 ]; then
		echo "par2z-cli-luajit recover failed: $err" >&2
		exit 1
	fi
	lj_hash="$(openssl dgst -sha256 "$tmpdir/lj.bin" | awk '{print $NF}')"
	lj_orig_hash="$(openssl dgst -sha256 "$tmpdir/lj.orig.bin" | awk '{print $NF}')"
	if [ "$lj_hash" != "$lj_orig_hash" ]; then
		echo "hash mismatch for luajit cli case" >&2
		exit 1
	fi

	# LuaJIT CLI recurse (-R)
	mkdir -p "$tmpdir/ljr/sub"
	gen_data "$tmpdir/ljr/sub/r.bin" 1024
	capture -- /bin/bash -c "cd \"$tmpdir\" && \"$luajit_cli\" create -R --block-size 512 --recovery-blocks 2 ljr.par2 ljr"
	if [ "$rc" -ne 0 ]; then
		echo "par2z-cli-luajit create -R failed: $err" >&2
		exit 1
	fi
	capture -- /bin/bash -c "cd \"$tmpdir\" && par2 verify ljr.par2"
	if [ "$rc" -ne 0 ]; then
		echo "par2 verify failed for luajit -R output" >&2
		exit 1
	fi

	# LuaJIT CLI --stdout (single missing file)
	gen_data "$tmpdir/ljout.bin" 16384
	cp "$tmpdir/ljout.bin" "$tmpdir/ljout.orig.bin"
	capture -- /bin/bash -c "cd \"$tmpdir\" && \"$luajit_cli\" create --block-size 4096 --recovery-blocks 4 ljout.par2 ljout.bin"
	if [ "$rc" -ne 0 ]; then
		echo "par2z-cli-luajit create for stdout failed: $err" >&2
		exit 1
	fi
	rm -f "$tmpdir/ljout.bin"
	if ! (cd "$tmpdir" && "$luajit_cli" recover --stdout ljout.par2 > ljout.recovered.bin); then
		echo "par2z-cli-luajit recover --stdout failed" >&2
		exit 1
	fi
	ljout_hash="$(openssl dgst -sha256 "$tmpdir/ljout.recovered.bin" | awk '{print $NF}')"
	ljout_orig_hash="$(openssl dgst -sha256 "$tmpdir/ljout.orig.bin" | awk '{print $NF}')"
	if [ "$ljout_hash" != "$ljout_orig_hash" ]; then
		echo "hash mismatch for luajit --stdout case" >&2
		exit 1
	fi

	# LuaJIT CLI --tar (optional)
	if command -v tar >/dev/null 2>&1; then
		gen_data "$tmpdir/ljtar.bin" 8192
		if ! (cd "$tmpdir" && "$luajit_cli" create --block-size 4096 --recovery-blocks 2 --tar ljtar.par2 ljtar.bin > ljtar.tar); then
			echo "par2z-cli-luajit create --tar failed" >&2
			exit 1
		fi
		mkdir -p "$tmpdir/ljtar-out"
		if ! (cd "$tmpdir/ljtar-out" && tar -xf "$tmpdir/ljtar.tar"); then
			echo "tar extract failed for luajit create --tar" >&2
			exit 1
		fi
		capture -- /bin/bash -c "par2 verify -B \"$tmpdir\" \"$tmpdir/ljtar-out/ljtar.par2\" \"$tmpdir/ljtar.bin\""
		if [ "$rc" -ne 0 ]; then
			echo "par2 verify failed for luajit create --tar output" >&2
			exit 1
		fi
		cp "$tmpdir/ljtar.bin" "$tmpdir/ljtar.orig.bin"
		corrupt_bytes "$tmpdir/ljtar.bin" 1024 0
		if [ ! -f "$tmpdir/ljtar.bin" ]; then
			echo "luajit --tar missing corrupted input" >&2
			ls -la "$tmpdir" >&2
			exit 1
		fi
		if ! (cd "$tmpdir" && "$luajit_cli" recover --tar "$tmpdir/ljtar-out/ljtar.par2" ljtar.bin > ljtar-recover.tar); then
			echo "par2z-cli-luajit recover --tar failed" >&2
			exit 1
		fi
		mkdir -p "$tmpdir/ljtar-recover"
		if ! (cd "$tmpdir/ljtar-recover" && tar -xf "$tmpdir/ljtar-recover.tar"); then
			echo "tar extract failed for luajit recover --tar" >&2
			exit 1
		fi
		if [ ! -f "$tmpdir/ljtar-recover/ljtar.bin" ]; then
			echo "luajit recover --tar missing output file" >&2
			ls -la "$tmpdir/ljtar-recover" >&2
			exit 1
		fi
		ljtar_hash="$(openssl dgst -sha256 "$tmpdir/ljtar-recover/ljtar.bin" | awk '{print $NF}')"
		ljtar_orig_hash="$(openssl dgst -sha256 "$tmpdir/ljtar.orig.bin" | awk '{print $NF}')"
		if [ "$ljtar_hash" != "$ljtar_orig_hash" ]; then
			echo "hash mismatch for luajit recover --tar case" >&2
			exit 1
		fi
	fi
fi
gen_data "$tmpdir/multi-a.bin" 32768
gen_data "$tmpdir/multi-b.bin" 20000
cp "$tmpdir/multi-a.bin" "$tmpdir/multi-a.orig"
cp "$tmpdir/multi-b.bin" "$tmpdir/multi-b.orig"
capture par2 create -s4096 -c8 "$tmpdir/multi.par2" "$tmpdir/multi-a.bin" "$tmpdir/multi-b.bin"
if [ "$rc" -ne 0 ]; then
	echo "par2 create failed for multi-file" >&2
	exit 1
fi
rm "$tmpdir/multi-b.bin"
corrupt_bytes "$tmpdir/multi-a.bin" 4096 8192
capture -- /bin/bash -c "cd \"$tmpdir\" && \"$root_dir/zig-out/bin/par2z-cli\" recover -o \"$tmpdir/multi-out\" multi.par2 multi-a.bin"
if [ "$rc" -ne 0 ]; then
	echo "par2z-cli recover failed for multi-file" >&2
	exit 1
fi
multi_a_hash="$(openssl dgst -sha256 "$tmpdir/multi-a.orig" | awk '{print $NF}')"
multi_a_out_hash="$(openssl dgst -sha256 "$tmpdir/multi-out/multi-a.bin" | awk '{print $NF}')"
multi_b_hash="$(openssl dgst -sha256 "$tmpdir/multi-b.orig" | awk '{print $NF}')"
multi_b_out_hash="$(openssl dgst -sha256 "$tmpdir/multi-out/multi-b.bin" | awk '{print $NF}')"
if [ "$multi_a_hash" != "$multi_a_out_hash" ] || [ "$multi_b_hash" != "$multi_b_out_hash" ]; then
	echo "hash mismatch for multi-file recovery" >&2
	exit 1
fi

# Volume-only recovery (missing main)
gen_data "$tmpdir/volonly.bin" 65536
cp "$tmpdir/volonly.bin" "$tmpdir/volonly.orig"
capture par2 create -s4096 -c16 "$tmpdir/volonly.par2" "$tmpdir/volonly.bin"
if [ "$rc" -ne 0 ]; then
	echo "par2 create failed for volume-only" >&2
	exit 1
fi
rm "$tmpdir/volonly.par2"
rm "$tmpdir/volonly.bin"
vol_file="$(find "$tmpdir" -maxdepth 1 -name 'volonly.vol*.par2' -print | head -n1 || true)"
if [ -z "$vol_file" ]; then
	echo "missing volume file for volume-only case" >&2
	exit 1
fi
capture -- /bin/bash -c "cd \"$tmpdir\" && \"$root_dir/zig-out/bin/par2z-cli\" recover -o \"$tmpdir/volonly-out\" \"$vol_file\""
if [ "$rc" -ne 0 ]; then
	echo "par2z-cli recover failed for volume-only case" >&2
	exit 1
fi
vol_hash="$(openssl dgst -sha256 "$tmpdir/volonly.orig" | awk '{print $NF}')"
vol_out_hash="$(openssl dgst -sha256 "$tmpdir/volonly-out/volonly.bin" | awk '{print $NF}')"
if [ "$vol_hash" != "$vol_out_hash" ]; then
	echo "hash mismatch for volume-only recovery" >&2
	exit 1
fi

# Create via our CLI without RFSC, verify with par2
gen_data "$tmpdir/norfsc.bin" 32768
cp "$tmpdir/norfsc.bin" "$tmpdir/norfsc.orig"
capture -- /bin/bash -c "cd \"$tmpdir\" && \"$root_dir/zig-out/bin/par2z-cli\" create --block-size 4096 --redundancy-percent 10 --no-rfsc norfsc.par2 norfsc.bin"
if [ "$rc" -ne 0 ]; then
	echo "par2z-cli create failed for no-rfsc" >&2
	exit 1
fi
capture -- /bin/bash -c "cd \"$tmpdir\" && par2 verify norfsc.par2 norfsc.bin"
if [ "$rc" -ne 0 ]; then
	echo "par2 verify failed for no-rfsc" >&2
	exit 1
fi

# Basepath + recurse compatibility
mkdir -p "$tmpdir/base/sub"
gen_data "$tmpdir/base/sub/base.bin" 2048
gen_data "$tmpdir/outside.bin" 1024
capture -- /bin/bash -c "cd \"$tmpdir\" && \"$root_dir/zig-out/bin/par2z-cli\" create -s512 -c4 -R -B base base.par2 base outside.bin"
if [ "$rc" -ne 0 ]; then
	echo "par2z-cli create failed for basepath/recurse" >&2
	exit 1
fi
capture -- /bin/bash -c "cd \"$tmpdir\" && par2 verify -B base base.par2"
if [ "$rc" -ne 0 ]; then
	echo "par2 verify failed for basepath/recurse output" >&2
	exit 1
fi

# Recovery volume layout flags vs par2cmdline
vol_dir_par2="$tmpdir/vol-par2"
vol_dir_ours="$tmpdir/vol-ours"
mkdir -p "$vol_dir_par2" "$vol_dir_ours"
gen_data "$tmpdir/vol-data.bin" 16
cp "$tmpdir/vol-data.bin" "$vol_dir_par2/vol-data.bin"
cp "$tmpdir/vol-data.bin" "$vol_dir_ours/vol-data.bin"

run_par2_create() {
	local dir="$1"
	shift
	capture -- /bin/bash -c "cd \"$dir\" && par2 create -s4 -c20 $* test.par2 vol-data.bin"
	if [ "$rc" -ne 0 ]; then
		echo "par2 create failed for volume layout ($*)" >&2
		exit 1
	fi
}

run_ours_create() {
	local dir="$1"
	shift
	capture -- /bin/bash -c "cd \"$dir\" && \"$root_dir/zig-out/bin/par2z-cli\" create -s4 -c20 $* test.par2 vol-data.bin"
	if [ "$rc" -ne 0 ]; then
		echo "par2z-cli create failed for volume layout ($*)" >&2
		exit 1
	fi
}

run_par2_create "$vol_dir_par2"
run_ours_create "$vol_dir_ours"
compare_volumes "default" "$vol_dir_par2" "$vol_dir_ours" test

rm -f "$vol_dir_par2"/test.par2 "$vol_dir_ours"/test.par2
find "$vol_dir_par2" -maxdepth 1 -type f -name 'test.vol*.par2' -delete
find "$vol_dir_ours" -maxdepth 1 -type f -name 'test.vol*.par2' -delete
run_par2_create "$vol_dir_par2" "-u"
run_ours_create "$vol_dir_ours" "-u"
compare_volumes "uniform" "$vol_dir_par2" "$vol_dir_ours" test

rm -f "$vol_dir_par2"/test.par2 "$vol_dir_ours"/test.par2
find "$vol_dir_par2" -maxdepth 1 -type f -name 'test.vol*.par2' -delete
find "$vol_dir_ours" -maxdepth 1 -type f -name 'test.vol*.par2' -delete
run_par2_create "$vol_dir_par2" "-l"
run_ours_create "$vol_dir_ours" "-l"
compare_volumes "limit" "$vol_dir_par2" "$vol_dir_ours" test

rm -f "$vol_dir_par2"/test.par2 "$vol_dir_ours"/test.par2
find "$vol_dir_par2" -maxdepth 1 -type f -name 'test.vol*.par2' -delete
find "$vol_dir_ours" -maxdepth 1 -type f -name 'test.vol*.par2' -delete
run_par2_create "$vol_dir_par2" "-n3"
run_ours_create "$vol_dir_ours" "-n3"
compare_volumes "count3" "$vol_dir_par2" "$vol_dir_ours" test

rm -f "$vol_dir_par2"/test.par2 "$vol_dir_ours"/test.par2
find "$vol_dir_par2" -maxdepth 1 -type f -name 'test.vol*.par2' -delete
find "$vol_dir_ours" -maxdepth 1 -type f -name 'test.vol*.par2' -delete
run_par2_create "$vol_dir_par2" "-f5"
run_ours_create "$vol_dir_ours" "-f5"
compare_volumes "first5" "$vol_dir_par2" "$vol_dir_ours" test

rm -f "$vol_dir_par2"/test.par2 "$vol_dir_ours"/test.par2
find "$vol_dir_par2" -maxdepth 1 -type f -name 'test.vol*.par2' -delete
find "$vol_dir_ours" -maxdepth 1 -type f -name 'test.vol*.par2' -delete
run_par2_create "$vol_dir_par2" "-u -n3"
run_ours_create "$vol_dir_ours" "-u -n3"
compare_volumes "uniform-count3" "$vol_dir_par2" "$vol_dir_ours" test

echo "integration ok"