From ecce8b136c50dbf483e4f5402a2b4a2d3f7d3c52 Mon Sep 17 00:00:00 2001
From: Andrea Mazzoleni <amadvance@gmail.com>
Date: Thu, 21 May 2026 11:00:50 +0200
Subject: [PATCH] Drop the test-run option from the official binary

---
 Makefile.am        | 646 +++++++++++++++++++++++----------------------
 cmdline/checker.c  |   8 +
 cmdline/snapraid.c |  22 +-
 3 files changed, 353 insertions(+), 323 deletions(-)
 create mode 100644 cmdline/checker.c

diff --git a/Makefile.am b/Makefile.am
index ebddca80..2d1023f1 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,5 +1,5 @@
 bin_PROGRAMS = snapraid
-check_PROGRAMS = mktest mkstream
+check_PROGRAMS = mktest mkstream checker
 
 AM_CPPFLAGS = -DSYSCONFDIR="\"${sysconfdir}\""
 
@@ -129,6 +129,11 @@ mkstream_SOURCES = \
 	cmdline/stream.c \
 	raid/memory.c
 
+# Checker binary share the snapraid variables, with the exception of the checker.c source
+checker_SOURCES = $(snapraid_SOURCES:cmdline/snapraid.c=cmdline/checker.c)
+checker_LDFLAGS = $(snapraid_LDFLAGS)
+checker_LDADD = $(snapraid_LDADD)
+
 # Add the .version file in the distribution
 dist-hook:
 	$(srcdir)/autover.sh > $(distdir)/.version
@@ -293,6 +298,7 @@ PAR4 = $(srcdir)/test/test-par4.conf
 PAR5 = $(srcdir)/test/test-par5.conf
 PAR6 = $(srcdir)/test/test-par6.conf
 MSG = @echo =====
+SNAPRAID = ./checker$(EXEEXT)
 
 fastcheck: mktest
 	rm -rf bench
@@ -306,25 +312,25 @@ fastcheck: mktest
 	mkdir bench/disk6
 	mkdir bench/pool
 	$(MSG) Stream
-	$(TESTENV) ./snapraid$(EXEEXT) --test-skip-device -H
-	$(TESTENV) ./snapraid$(EXEEXT) --test-skip-device -V
-	$(TESTENV) ./snapraid$(EXEEXT) test
+	$(TESTENV) $(SNAPRAID) --test-skip-device -H
+	$(TESTENV) $(SNAPRAID) --test-skip-device -V
+	$(TESTENV) $(SNAPRAID) test
 	$(MSG) Create some files
 	$(TESTENV) ./mktest$(EXEEXT) generate 1 6 $(CHECKCOUNT) $(CHECKSIZE)
 	echo DUP > bench/disk1/DUP1
 	echo DUP > bench/disk1/DUP2
 	echo -n > bench/disk1/ZERO
 	$(MSG) Some commands with a not empty array
-	$(FAILENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_COMMON) -c $(CONF) --test-expect-need-sync diff > output.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_COMMON) -c $(CONF) sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(CONF) dup -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(CONF) list -l test.log > output.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(CONF) test-rewrite
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(CONF) read
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) status -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) -a check
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) test-dry
+	$(FAILENV) $(SNAPRAID) $(CHECKFLAGS_COMMON) -c $(CONF) --test-expect-need-sync diff > output.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_COMMON) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) dup -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) list -l test.log > output.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) test-rewrite
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) read
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -a check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) test-dry
 	$(MSG) Regression test completed with SUCCESS!
 	$(MSG) Please ignore any error message printed above, they are expected!
 	$(MSG) Everything OK
@@ -348,7 +354,7 @@ if HAVE_THREAD_CHECKER
 	$(TESTENV) ./mktest$(EXEEXT) generate 1 6 $(CHECKCOUNT) $(CHECKSIZE)
 	$(MSG) Some commands that use threads
 # First sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 # Remove, move and add some more
 	rm bench/disk4/a/9*
 	rm bench/disk5/a/9*
@@ -358,76 +364,76 @@ if HAVE_THREAD_CHECKER
 	mv bench/disk3/a/9* bench/disk6/a
 	$(TESTENV) ./mktest$(EXEEXT) change 2 500 bench/disk2/b/* bench/disk3/b/*
 # Sync again
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 # Other commands that uses threads
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) test-rewrite
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) scrub -p full
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) scrub -p full --test-io-cache 3
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) scrub -p full --test-io-cache 128
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync -F --test-io-cache 1
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) scrub -p full --test-io-cache 1
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) test-rewrite
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) scrub -p full
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) scrub -p full --test-io-cache 3
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) scrub -p full --test-io-cache 128
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync -F --test-io-cache 1
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) scrub -p full --test-io-cache 1
 else
 #### COMMAND LINE ####
 	$(MSG) Pre test
-	$(TESTENV) ./snapraid$(EXEEXT) --test-skip-device -H
-	$(TESTENV) ./snapraid$(EXEEXT) --test-skip-device -V
-	$(TESTENV) ./snapraid$(EXEEXT) test
+	$(TESTENV) $(SNAPRAID) --test-skip-device -H
+	$(TESTENV) $(SNAPRAID) --test-skip-device -V
+	$(TESTENV) $(SNAPRAID) test
 	$(TESTENV) ./mktest$(EXEEXT)
 if !HAVE_MEMORY_CHECKER
 if HAVE_EMULATOR
 	$(MSG) Speed
 # Run the self test in AVX2
-	$(TESTENV_AVX2) ./snapraid$(EXEEXT) --test-skip-device -c $(CONF) status
+	$(TESTENV_AVX2) $(SNAPRAID) --test-skip-device -c $(CONF) status
 # Run the speed test in different architectures
-	$(TESTENV_SSE2) ./snapraid$(EXEEXT) --test-skip-device -T
-	$(TESTENV_SSSE3) ./snapraid$(EXEEXT) --test-skip-device -T
-	$(TESTENV_SSE42) ./snapraid$(EXEEXT) --test-skip-device -T
-	$(TESTENV_AVX2) ./snapraid$(EXEEXT) --test-skip-device -T
+	$(TESTENV_SSE2) $(SNAPRAID) --test-skip-device -T
+	$(TESTENV_SSSE3) $(SNAPRAID) --test-skip-device -T
+	$(TESTENV_SSE42) $(SNAPRAID) --test-skip-device -T
+	$(TESTENV_AVX2) $(SNAPRAID) --test-skip-device -T
 else
 # Run the self test natively
-	$(TESTENV) ./snapraid$(EXEEXT) --test-skip-device -c $(CONF) status
+	$(TESTENV) $(SNAPRAID) --test-skip-device -c $(CONF) status
 # Run the speed test natively
-	$(TESTENV) ./snapraid$(EXEEXT) --test-skip-device -T
+	$(TESTENV) $(SNAPRAID) --test-skip-device -T
 endif
 endif
 #### EMPTY ####
 	$(MSG) Some commands with empty array
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(CONF) diff
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(CONF) dup
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(CONF) list > output.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) status
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) status -l ">&1"
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) status -l ">&2"
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) status -l ">>test.log"
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) status -l test-%D-%T.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) up
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) down -d parity -d disk1
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) devices
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(CONF) probe --test-fake-device
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(CONF) probe --test-fake-device -s
-	$(FAILENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(CONF) smart --test-fake-device --test-expect-failure
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) diff
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) dup
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) list > output.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status -l ">&1"
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status -l ">&2"
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status -l ">>test.log"
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status -l test-%D-%T.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) up
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) down -d parity -d disk1
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) devices
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) probe --test-fake-device
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) probe --test-fake-device -s
+	$(FAILENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) smart --test-fake-device --test-expect-failure
 if HAVE_POSIX
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR1) pool
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) pool
 endif
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) -a check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -a check
 #### CONTROLLED ####
 	$(MSG) Filesystem allocation test
 	dd bs=1 count=8192 if=/dev/zero of=bench/disk1/TEST
 # Copy the file to trigger the copy optimization check
 	cp -a bench/disk1/TEST bench/disk2/TEST
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 # Now delete the file, and do a partial sync to force a deallocation in the middle of a file
 	rm bench/disk1/TEST
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) -E -S 1 -B 1 sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -E -S 1 -B 1 sync
 # Now force a deallocation at the end
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) -E -S 7 -B 1 sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -E -S 7 -B 1 sync
 	rm bench/disk2/TEST
 # Have the sync to fail for empty disk
-	$(FAILENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync --test-expect-failure
+	$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync --test-expect-failure
 # Now sync will complete with -E
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) -E sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -E sync
 	$(MSG) Filesystem fragmentation test
 	dd bs=1 count=8192 if=/dev/zero of=bench/disk1/TEST1
 	dd bs=1 count=8192 if=/dev/zero of=bench/disk1/TEST2
@@ -435,26 +441,26 @@ endif
 	dd bs=1 count=8192 if=/dev/zero of=bench/disk1/TEST4
 	dd bs=1 count=8192 if=/dev/zero of=bench/disk1/TEST5
 	dd bs=1 count=8192 if=/dev/zero of=bench/disk1/TEST6
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 # Now delete some files, and create a bigger one to fill the holes
 	rm bench/disk1/TEST1
 	rm bench/disk1/TEST3
 	rm bench/disk1/TEST5
 	dd bs=1 count=65536 if=/dev/zero of=bench/disk1/TESTX
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync -l ">&1"
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync -l ">&1"
 	rm -r bench/disk1/TEST*
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) -E sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -E sync
 # Now enforce copy detection of a file without parity
 # Create a file in a high number disk
 	dd bs=1 count=8192 if=/dev/urandom of=bench/disk6/STEP1
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync --bw-limit 1M
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync --bw-limit 1M
 # Create two new copies. The one in disk1 will copy
 # the hash from the one in disk6, and the one in disk2
 # will copy the hash from the one in disk1, that
 # doesn't have parity
 	cp -a bench/disk6/STEP1 bench/disk1/STEP1
 	cp -a bench/disk6/STEP1 bench/disk2/STEP1
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 # Now create, duplicate, move and partial sync
 	dd bs=1 count=8192 if=/dev/zero of=bench/disk1/INVA1
 	dd bs=1 count=8192 if=/dev/zero of=bench/disk1/INVA2
@@ -462,7 +468,7 @@ endif
 	dd bs=1 count=8192 if=/dev/zero of=bench/disk1/MOVE1
 	cp -a bench/disk1/MOVE1 bench/disk1/MOVE2
 	cp -a bench/disk1/MOVE1 bench/disk1/MOVE3
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 	mv bench/disk1/MOVE2 bench/disk2/MOVE2
 	mv bench/disk1/MOVE3 bench/disk3/MOVE3
 	dd bs=1 count=8192 if=/dev/zero of=bench/disk4/MOVE4
@@ -471,19 +477,19 @@ endif
 	cp -a bench/disk1/INVA3 bench/disk1/EXTRA3
 	rm bench/disk1/INVA1
 	touch bench/disk1/INVA2
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-kill-after-sync sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-kill-after-sync sync
 # Diff should report the need of a sync for invalid parity
-	$(FAILENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(PAR1) --test-expect-need-sync diff
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) status
+	$(FAILENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(PAR1) --test-expect-need-sync diff
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status
 	mv bench/disk2/MOVE2 bench/disk4/MOVE4
 	mv bench/disk3/MOVE3 bench/disk5/MOVE5
 	mv bench/disk4/MOVE4 bench/disk6/MOVE6
 	rm bench/disk1/EXTRA1
 	touch bench/disk1/EXTRA2
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) -E sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -E sync
 # Change UUID
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-fake-uuid sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-fake-uuid sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 #### NOT EMPTY ####
 	$(MSG) Create some files
 	$(TESTENV) ./mktest$(EXEEXT) generate 1 6 $(CHECKCOUNT) $(CHECKSIZE)
@@ -492,70 +498,70 @@ endif
 	echo -n > bench/disk1/ZERO
 	$(MSG) Some commands with a not empty array
 # Run a sync using physical offset
-	$(FAILENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_PHYSICAL) -c $(CONF) --test-expect-need-sync diff > output.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_PHYSICAL) -c $(CONF) sync
+	$(FAILENV) $(SNAPRAID) $(CHECKFLAGS_PHYSICAL) -c $(CONF) --test-expect-need-sync diff > output.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_PHYSICAL) -c $(CONF) sync
 # Now reset the array, as we normally test with alpha order and murmur3
 	rm bench/content bench/?-content
 # Now rebuild the array with alpha order and murmur3 and do some commands
 # Later we will convert it to spooky2 to test both hashes
-	$(FAILENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(CONF) --test-expect-need-sync diff > output.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-force-murmur3 --test-force-autosave-at 100 sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(CONF) dup -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(CONF) list -l test.log > output.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(CONF) test-rewrite
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(CONF) read
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) status -l test.log
+	$(FAILENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) --test-expect-need-sync diff > output.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-force-murmur3 --test-force-autosave-at 100 sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) dup -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) list -l test.log > output.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) test-rewrite
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) read
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status -l test.log
 if HAVE_POSIX
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR1) pool
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) pool
 endif
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR1) check
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) -a check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -a check
 	$(MSG) Dry
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) test-dry
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) test-dry
 # Thermal test
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(THERMAL) --test-fake-device test-dry
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(THERMAL) --test-fake-device test-dry
 	$(MSG) Copy detection
 # Create a file and sync with it
 	echo 123 > bench/disk1/COPY
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 # Corrupt and move it to another disk
 	$(TESTENV) ./mktest$(EXEEXT) damage 1 1 1 bench/disk1/COPY
 	mv bench/disk1/COPY bench/disk2/COPY
 # Now sync with failure as the data won't match. We have two points of failure, pre-hash and sync
-	$(FAILENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-expect-failure -h sync
-	$(FAILENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-expect-failure sync
+	$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-expect-failure -h sync
+	$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-expect-failure sync
 # Now sync with force-nocopy
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --force-nocopy sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --force-nocopy sync
 	$(MSG) Nano
 	touch -t 200102011234.56 bench/disk1/a/a*
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) touch
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) touch
 	$(MSG) Check the --gen-conf command
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --gen-conf bench/content
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --gen-conf bench/content
 	$(MSG) Filter
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(CONF) -d disk1 check > output.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) -d disk1 check > output.log
 if HAVE_POSIX
 # Only in real unix, as with MingW the * trigger path replacement
 # Like /b/a* -> B:/a* and SnapRAID then complain
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(CONF) -f \\*a -f a/ -f /b/a\\* check > output.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) -f \\*a -f a/ -f /b/a\\* check > output.log
 endif
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(CONF) --test-expect-failure -f . check > output.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(CONF) --test-expect-failure -f ./ check > output.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) --test-expect-failure -f . check > output.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) --test-expect-failure -f ./ check > output.log
 	$(MSG) Delete some files and sync
 	rm bench/disk4/a/9*
 	rm bench/disk5/a/9*
 	rm bench/disk6/a/9*
-	$(FAILENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(CONF) --test-expect-need-sync diff > output.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(CONF) sync -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(FAILENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) --test-expect-need-sync diff > output.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) sync -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 	$(MSG) Move some files, sync and check
 	mv bench/disk1/a/9* bench/disk4/a
 	mv bench/disk2/a/9* bench/disk5/a
 	mv bench/disk3/a/9* bench/disk6/a
-	$(FAILENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(CONF) --test-expect-need-sync diff > output.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(FAILENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) --test-expect-need-sync diff > output.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 #### MORE FILES ####
 	$(MSG) Create some more files, hardlinks and empty directories, delete others, sync PAR1 and check
 	rm bench/disk4/a/8*
@@ -576,15 +582,15 @@ if HAVE_POSIX
 	ln -s bench/disk1/target1 bench/disk1/file_symlink2
 	ln -s bench/disk1/target1 bench/disk1/file_symlink3
 endif
-	$(FAILENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(PAR1) --test-expect-need-sync diff > output.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-skip-fallocate -c $(PAR1) sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) status
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-io-advise-none -c $(PAR1) sync -F --test-io-cache 1
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-io-advise-sequential -c $(PAR1) sync -F --test-io-stats
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-io-advise-flush -c $(PAR1) sync -F --test-io-cache 1
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-io-advise-flush-window -c $(PAR1) sync -F
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-io-advise-discard-window -c $(PAR1) sync -F
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-io-advise-direct -c $(PAR1) sync -F
+	$(FAILENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(PAR1) --test-expect-need-sync diff > output.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-skip-fallocate -c $(PAR1) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-io-advise-none -c $(PAR1) sync -F --test-io-cache 1
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-io-advise-sequential -c $(PAR1) sync -F --test-io-stats
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-io-advise-flush -c $(PAR1) sync -F --test-io-cache 1
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-io-advise-flush-window -c $(PAR1) sync -F
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-io-advise-discard-window -c $(PAR1) sync -F
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-io-advise-direct -c $(PAR1) sync -F
 #### CHANGE LINKS ####
 # Use a different size ("22" instead of "1") to ensure to recognize the file different
 # even if it gets the same timestamp in case subsecond timestamp is no available
@@ -595,132 +601,132 @@ if HAVE_POSIX
 	rm bench/disk1/file_symlink1
 	ln -s bench/disk1/target2 bench/disk1/file_symlink1
 endif
-	$(FAILENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR1) --test-expect-need-sync diff > output.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR1) sync -l ">&1"
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR1) check -l ">&1"
+	$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) --test-expect-need-sync diff > output.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) sync -l ">&1"
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) check -l ">&1"
 #### MISC COMMANDS ####
 	$(MSG) Some commands with a not empty array
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(PAR1) dup
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(PAR1) list --test-fmt file > output.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(PAR1) list --test-fmt disk > output.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(PAR1) list --test-fmt path > output.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(PAR1) locate --test-fmt file > output.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) -c $(PAR1) locate -t 10K --test-fmt path > output.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(PAR1) dup
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(PAR1) list --test-fmt file > output.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(PAR1) list --test-fmt disk > output.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(PAR1) list --test-fmt path > output.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(PAR1) locate --test-fmt file > output.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(PAR1) locate -t 10K --test-fmt path > output.log
 if HAVE_POSIX
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR1) pool
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) pool
 endif
 	$(MSG) Extend PAR1 to max parity with fix and check
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-recoverable -c $(CONF) check -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) fix -d 2-parity -d 3-parity -d 4-parity -d 5-parity -d 6-parity -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check -l ">&1"
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(CONF) check -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) fix -d 2-parity -d 3-parity -d 4-parity -d 5-parity -d 6-parity -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check -l ">&1"
 	$(MSG) Fix with unaccessible parity and disk
-	$(FAILENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(NOACCESS) fix --test-expect-failure
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(NOACCESS) fix --force-device --test-expect-recoverable -l test.log
+	$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(NOACCESS) fix --test-expect-failure
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(NOACCESS) fix --force-device --test-expect-recoverable -l test.log
 	$(MSG) Rename a disk
-	$(FAILENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(RENAME) --test-match-first-uuid sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-match-first-uuid sync
+	$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(RENAME) --test-match-first-uuid sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-match-first-uuid sync
 #### SCRUB ####
 	$(MSG) Scrub some times
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-force-scrub-at 100 scrub
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) status
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-force-scrub-at 1000 scrub
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) status
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-force-scrub-at 100000 scrub
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) status
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-force-scrub-at 100 scrub
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-force-scrub-at 1000 scrub
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-force-scrub-at 100000 scrub
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status
 #### SYNC WITH RUNTIME CHANGE ####
 	$(MSG) Modify files during a sync
 	echo RUN > bench/disk1/RUN-RM
-	$(FAILENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-run "rm bench/disk1/RUN-RM" --test-expect-failure sync
+	$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-run "rm bench/disk1/RUN-RM" --test-expect-failure sync
 	echo RUN > bench/disk1/RUN-CHMOD
 if HAVE_POSIX
 # Doesn't run this test as root because the root user override permissions
 	if test "$$EUID" -ne 0; then \
-		$(FAILENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-run "chmod a-r bench/disk1/RUN-CHMOD" --test-expect-failure sync; \
+		$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-run "chmod a-r bench/disk1/RUN-CHMOD" --test-expect-failure sync; \
 	fi
 endif
 	echo RUN > bench/disk1/RUN-SIZE
-	$(FAILENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-run "echo RUNRUN > bench/disk1/RUN-SIZE" --test-expect-failure sync
+	$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-run "echo RUNRUN > bench/disk1/RUN-SIZE" --test-expect-failure sync
 	echo RUN > bench/disk1/RUN-TOUCH
-	$(FAILENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-run "touch -t 200001011200 bench/disk1/RUN-TOUCH" --test-expect-failure sync
+	$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-run "touch -t 200001011200 bench/disk1/RUN-TOUCH" --test-expect-failure sync
 	echo RUN > bench/disk1/RUN-INODE
 	cp -p bench/disk1/RUN-INODE bench/disk1/RUN-INODE-COPY
-	$(FAILENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-run "mv bench/disk1/RUN-INODE-COPY bench/disk1/RUN-INODE" --test-expect-failure sync
+	$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-run "mv bench/disk1/RUN-INODE-COPY bench/disk1/RUN-INODE" --test-expect-failure sync
 	rm bench/disk1/RUN-CHMOD
 	rm bench/disk1/RUN-SIZE
 	rm bench/disk1/RUN-TOUCH
 	rm bench/disk1/RUN-INODE
 	echo HASH > bench/disk1/HASH-RM
-	$(FAILENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-run "rm bench/disk1/HASH-RM" --test-expect-failure -h sync
+	$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-run "rm bench/disk1/HASH-RM" --test-expect-failure -h sync
 	echo HASH > bench/disk1/HASH-CHMOD
 if HAVE_POSIX
 # Doesn't run this test as root because the root user override permissions
 	if test "$$EUID" -ne 0; then \
-		$(FAILENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-run "chmod a-r bench/disk1/HASH-CHMOD" --test-expect-failure -h sync; \
+		$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-run "chmod a-r bench/disk1/HASH-CHMOD" --test-expect-failure -h sync; \
 	fi
 endif
 	echo HASH > bench/disk1/HASH-SIZE
-	$(FAILENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-run "echo HASHHASH > bench/disk1/HASH-SIZE" --test-expect-failure -h sync
+	$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-run "echo HASHHASH > bench/disk1/HASH-SIZE" --test-expect-failure -h sync
 	echo HASH > bench/disk1/HASH-TOUCH
-	$(FAILENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-run "touch -t 200001011200 bench/disk1/HASH-TOUCH" --test-expect-failure -h sync
+	$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-run "touch -t 200001011200 bench/disk1/HASH-TOUCH" --test-expect-failure -h sync
 	echo HASH > bench/disk1/HASH-INODE
 	cp -p bench/disk1/HASH-INODE bench/disk1/HASH-INODE-COPY
-	$(FAILENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-run "mv bench/disk1/HASH-INODE-COPY bench/disk1/HASH-INODE" --test-expect-failure -h sync
+	$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-run "mv bench/disk1/HASH-INODE-COPY bench/disk1/HASH-INODE" --test-expect-failure -h sync
 	rm bench/disk1/HASH-CHMOD
 	rm bench/disk1/HASH-SIZE
 	rm bench/disk1/HASH-TOUCH
 	rm bench/disk1/HASH-INODE
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 #### SILENT ERRORS ####
 	$(MSG) Silently corrupt some files, scrub and fix filtering for error. Test scrub patterns.
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 	$(TESTENV) ./mktest$(EXEEXT) damage 1 1 1 bench/disk1/a/*
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-expect-recoverable --test-force-scrub-at 100000 scrub
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) status
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) fix -e
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --percentage bad scrub
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --plan 1.5 scrub
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) -o 0 scrub
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) -p full scrub
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) -p new scrub
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-expect-recoverable --test-force-scrub-at 100000 scrub
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) fix -e
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --percentage bad scrub
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --plan 1.5 scrub
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -o 0 scrub
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -p full scrub
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -p new scrub
 	$(MSG) Silently corrupt some files, and sync with error presents
 	$(TESTENV) ./mktest$(EXEEXT) write 2 1 1 bench/disk1/a/*
 	$(TESTENV) ./mktest$(EXEEXT) damage 3 1 1 bench/disk2/a/*
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-expect-recoverable sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) status
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-expect-recoverable sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status
 # Note that this fix -e command doesn't fix all the errors because
 # only the blocks touched by the sync are marked bad
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) fix -e
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check --test-expect-recoverable
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) fix
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) -p full scrub
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) fix -e
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check --test-expect-recoverable
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) fix
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -p full scrub
 	$(MSG) Full sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) -F sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -F sync
 	$(MSG) Realloc partial/full sync
 # Full realloc to compact the parity
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --force-realloc sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --force-realloc sync
 	cat bench/parity.* > bench/saved-parity-before
 # Create a big file
 	dd bs=1024 count=1024 if=/dev/urandom of=bench/disk1/REALLOC1
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 	cat bench/parity.* > bench/saved-parity-first-file
 # Create another big file
 	dd bs=1024 count=1024 if=/dev/urandom of=bench/disk1/REALLOC2
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 	cat bench/parity.* > bench/saved-parity-second-file
 # Now remove the first one creating a hole
 	rm bench/disk1/REALLOC1
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --tail 10k locate
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --tail 10k locate
 	cat bench/parity.* > bench/saved-parity-hole
 # Reallocate the second file
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --force-realloc-tail 10k sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --tail 10k locate
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --force-realloc-tail 10k sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --tail 10k locate
 	cat bench/parity.* > bench/saved-parity-remove-hole
 # Remove also the second file
 	rm bench/disk1/REALLOC2
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --tail 10k locate
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --tail 10k locate
 	cat bench/parity.* > bench/saved-parity-after
 # Adding files should grow the parity
 	@ [ $$(wc -c < bench/saved-parity-before) -lt $$(wc -c < bench/saved-parity-first-file) ] || exit 1
@@ -739,46 +745,46 @@ endif
 	mkdir bench/disk1/e
 	cp -pR bench/disk2/a/c* bench/disk1/c
 	cp -pR bench/disk2/a/d* bench/disk1/d
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-kill-after-sync sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-kill-after-sync sync
 	rm -r bench/disk1/c
 	cp -pR bench/disk2/a/e* bench/disk1/e
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 	$(MSG) Abort sync with both deletions and additions. And delete and add some more and sync again.
 # Note that here we are depending of the previous state leaving dirs "d" and "e"
 	mkdir bench/disk1/f
 	cp -pR bench/disk3/a/f* bench/disk1/f
 	rm -r bench/disk1/d
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-kill-after-sync sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-kill-after-sync sync
 	mkdir bench/disk1/g
 	cp -pR bench/disk4/a/g* bench/disk1/g
 	rm -r bench/disk1/e
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 	rm -r bench/disk1/f
 	rm -r bench/disk1/g
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 	$(MSG) Make a hole in the disk array and sync with --force-empty
 	mv bench/disk2 bench/disk2.old
 	mkdir bench/disk2
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --force-empty sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --force-empty sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 	$(MSG) Use with the hole
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(HOLE) sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(HOLE) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(HOLE) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(HOLE) check
 	rm -r bench/disk1/a
 	rm -r bench/disk3/a
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(HOLE) fix -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(HOLE) check
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(HOLE) test-dry
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(HOLE) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(HOLE) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(HOLE) test-dry
 	$(MSG) Fill the hole with a new disk
 	rm -r bench/disk2
 	mv bench/disk2.old bench/disk2
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 	$(MSG) Corrupt the content file
 	$(TESTENV) ./mktest$(EXEEXT) write 1 100 100 bench/content
-	$(FAILENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-failure -c $(CONF) sync
+	$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-failure -c $(CONF) sync
 	rm bench/content
 #### AGAIN MORE FILES ####
 	$(MSG) Delete some files, create some new, sync and check
@@ -787,41 +793,41 @@ endif
 	rm bench/disk3/a/3*
 	rm bench/disk4/a/4*
 	$(TESTENV) ./mktest$(EXEEXT) generate 3 6 $(CHECKCOUNT) $(CHECKSIZE)
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 	$(MSG) Move some files, sync and check
 	mv bench/disk1/a/7* bench/disk1/b/
 	mv bench/disk2/a/7* bench/disk2/b/
 	mv bench/disk3/a/7* bench/disk3/b/
 	mv bench/disk4/a/7* bench/disk4/b/
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 #### SNAPRAIDIGNORE
 	echo "a*" > bench/disk1/a/.snapraidignore
 	echo "b*" > bench/disk1/.snapraidignore
 	echo "c/" > bench/disk1/.snapraidignore
 	echo "/d/" > bench/disk1/.snapraidignore
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 if !HAVE_MEMORY_CHECKER
 #### RECOVER 1 ####
 	$(MSG) Delete one disk, fix and check with PAR1
 	rm -r bench/disk3
 	mkdir bench/disk3
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR1) check -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR1) fix -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR1) check -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 #### RECOVER 2 ####
 	$(MSG) Delete two disks, fix and check with PAR2
 	rm -r bench/disk1
 	mkdir bench/disk1
 	rm -r bench/disk2
 	mkdir bench/disk2
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR1) fix -l test-fail-strategy1.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR2) check -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR1) fix -l test-fail-strategy1.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR2) check -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 #### RECOVER 3 ####
 	$(MSG) Delete three disks, fix and check with PAR3
 	rm -r bench/disk1
@@ -830,14 +836,14 @@ if !HAVE_MEMORY_CHECKER
 	mkdir bench/disk2
 	rm -r bench/disk3
 	mkdir bench/disk3
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR2) fix -l test-fail-strategy2.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR3) check -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR3) fix -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR2) fix -l test-fail-strategy2.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR3) check -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR3) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 #### RECOVER Z ####
 	$(MSG) Compute PARZ - keeping PAR1 and PAR2 as they are
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PARZ) fix -d 3-parity -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PARZ) fix -d 3-parity -l test.log
 	$(MSG) Delete three disks, fix and check with PARZ
 	rm -r bench/disk3
 	mkdir bench/disk3
@@ -845,10 +851,10 @@ if !HAVE_MEMORY_CHECKER
 	mkdir bench/disk4
 	rm -r bench/disk5
 	mkdir bench/disk5
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-recoverable -c $(PARZ) check -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PARZ) fix -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PARZ) check -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PARZ) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 #### RECOVER 4 ####
 	$(MSG) Delete four disks, fix and check with PAR4
 	rm -r bench/disk3
@@ -859,11 +865,11 @@ if !HAVE_MEMORY_CHECKER
 	mkdir bench/disk5
 	rm -r bench/disk6
 	mkdir bench/disk6
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR3) fix -l test-fail-strategy3.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR4) check -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR4) fix -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR3) fix -l test-fail-strategy3.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR4) check -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR4) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 #### RECOVER 5 ####
 	$(MSG) Delete five disks, fix and check with PAR5
 	rm -r bench/disk1
@@ -876,11 +882,11 @@ if !HAVE_MEMORY_CHECKER
 	mkdir bench/disk5
 	rm -r bench/disk6
 	mkdir bench/disk6
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR4) fix -l test-fail-strategy4.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR5) check -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR5) fix -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR4) fix -l test-fail-strategy4.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR5) check -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR5) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 #### RECOVER 6 ####
 	$(MSG) Delete six disks, fix and check with PAR6
 	rm -r bench/disk1
@@ -895,11 +901,11 @@ if !HAVE_MEMORY_CHECKER
 	mkdir bench/disk5
 	rm -r bench/disk6
 	mkdir bench/disk6
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR5) fix -l test-fail-strategy5.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR6) check -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR6) fix -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR5) fix -l test-fail-strategy5.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR6) check -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR6) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 endif
 #### MULTI STEP ####
 	$(MSG) Delete some files and create some new, sync and check in multiple steps
@@ -907,130 +913,130 @@ endif
 	rm bench/disk2/a/5*
 	rm bench/disk3/a/6*
 	rm bench/disk4/a/6*
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) -B 10 sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -B 10 sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check -l test.log
 	$(TESTENV) ./mktest$(EXEEXT) generate 4 6 $(CHECKCOUNT) $(CHECKSIZE)
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) -B 100 sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) -B 1000 sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -B 100 sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -B 1000 sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 	$(MSG) Rehash to spooky2 and rehash even blocks
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-force-spooky2 rehash
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-force-scrub-even scrub
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) status
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-force-spooky2 rehash
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-force-scrub-even scrub
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 	$(MSG) Full sync to complete rehash
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) -F sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -F sync
 	$(MSG) Delete files from three disks and check/fix with import by data in PAR2
 	rm -r bench/disk1/a
 	rm -r bench/disk2/a
 	mv bench/disk3/a bench/a
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-import-content bench/a -c $(PAR2) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-import-content bench/a -c $(PAR2) fix -l test.log
 	rm -r bench/a
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 	$(MSG) Delete files from three disks and check/fix with import by timestamp in PAR2
 	rm -r bench/disk1/a
 	rm -r bench/disk2/a
 	mv bench/disk3/a bench/a
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -i bench/a -c $(PAR2) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -i bench/a -c $(PAR2) fix -l test.log
 	rm -r bench/a
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 	$(MSG) Delete files from three disks and check/fix with automatic import in PAR2
 	rm -r bench/disk1/a
 	rm -r bench/disk2/a
 	mv bench/disk3/a bench/disk1/a_from_disk3
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
 	rm -r bench/disk1/a_from_disk3
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 #### SYNC ABORT ####
 	$(MSG) Abort sync late with additions, delete them and recover with PAR2
 	$(MSG) This triggers the recovering with q using p to check the validity
 	cp -pR bench/disk1/a bench/disk1/a_copy
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-kill-after-sync -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-kill-after-sync -c $(CONF) sync
 	rm -r bench/disk1/a_copy
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
 	rm -r bench/disk1/a_copy
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 	$(MSG) Abort sync early with additions, delete them and recover with PAR2
 	$(MSG) This triggers the recovering with q using p to check the validity, but failing for new blocks being filled with zero
 	cp -pR bench/disk1/a bench/disk1/a_copy
 # Ensure that there is at least one zero filled file
 	dd bs=1 count=8192 if=/dev/zero of=bench/disk1/a_copy/ZERO_FILLED
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -B 1 --test-kill-after-sync -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -B 1 --test-kill-after-sync -c $(CONF) sync
 	rm -r bench/disk1/a_copy
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR2) fix -l test-fail-earlysyncadd.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR2) fix -l test-fail-earlysyncadd.log
 	rm -r bench/disk1/a_copy
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 	$(MSG) Abort sync late with additions with prehash and then delete the new additions and sync again
 	cp -pR bench/disk1/a bench/disk1/a_copy
 	cp -pR bench/disk2/a bench/disk2/a_copy
 	cp -pR bench/disk3/a bench/disk3/a_copy
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-kill-after-sync -c $(CONF) -h sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-kill-after-sync -c $(CONF) -h sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 	rm -r bench/disk1/a_copy
 	rm -r bench/disk2/a_copy
 	rm -r bench/disk3/a_copy
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 	$(MSG) Abort sync late with additions and then delete the new additions and sync again
 	cp -pR bench/disk1/a bench/disk1/a_copy
 	cp -pR bench/disk2/a bench/disk2/a_copy
 	cp -pR bench/disk3/a bench/disk3/a_copy
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-kill-after-sync -c $(CONF) sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-kill-after-sync -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 	rm -r bench/disk1/a_copy
 	rm -r bench/disk2/a_copy
 	rm -r bench/disk3/a_copy
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 	$(MSG) Abort sync late with additions and then delete some unchanged stuff and fix with PAR1
 	cp -pR bench/disk1/b bench/disk1/b_copy
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR1) --test-kill-after-sync sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) --test-kill-after-sync sync
 	rm -r bench/disk2
 	mkdir bench/disk2
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR1) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) fix -l test.log
 	$(MSG) Fixes again to restore all the parity
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) fix -l test.log
 	rm -r bench/disk1/b_copy
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
 	$(MSG) Abort sync late with more deletions than additions and then delete some unchanged stuff and fix with PAR1
 	cp -pR bench/disk1/a bench/disk1/a_copy
 	mv bench/disk1/a bench/a
 	mv bench/disk1/b bench/b
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) --test-kill-after-sync sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-kill-after-sync sync
 	rm -r bench/disk2
 	mkdir bench/disk2
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR1) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) fix -l test.log
 	$(MSG) Fixes again to restore all the parity
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) fix -l test.log
 	-rm -r bench/disk1/a
 	-rm -r bench/disk1/b
 	rm -r bench/disk1/a_copy
 	mv bench/a bench/disk1/a
 	mv bench/b bench/disk1/b
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 	$(MSG) Abort sync early with more deletions than additions and then delete some unchanged stuff and fix with PAR2
 	cp -pR bench/disk1/a bench/disk1/a_copy
 	mv bench/disk1/a bench/a
 	mv bench/disk1/b bench/b
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) -B 1 --test-kill-after-sync sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -B 1 --test-kill-after-sync sync
 	rm -r bench/disk2
 	mkdir bench/disk2
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR1) fix -l test-fail-earlysyncdel.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR1) fix -l test-fail-earlysyncdel.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
 	-rm -r bench/disk1/a
 	-rm -r bench/disk1/b
 	rm -r bench/disk1/a_copy
 	mv bench/a bench/disk1/a
 	mv bench/b bench/disk1/b
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 #### RECOVER MISSING ####
 	$(MSG) Delete some files, fix with -m and check with PAR1
 	rm bench/disk1/a/8*
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR1) check -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR1) -m fix -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR1) check -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) -m fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 	$(MSG) Delete some dirs in six disk, fix with -m and check
 	rm -r bench/disk1/b
 	rm -r bench/disk2/b
@@ -1038,92 +1044,92 @@ endif
 	rm -r bench/disk4/b
 	rm -r bench/disk5/b
 	rm -r bench/disk6/b
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR5) fix -l test-full5.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-recoverable -c $(CONF) check -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) -m fix -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR5) fix -l test-full5.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(CONF) check -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -m fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 #### RECOVER BY DISK ####
 	$(MSG) Delete some dirs in two disks, fix and check with PAR2 using the -d option for each disk
 	rm -r bench/disk2/b
 	rm -r bench/disk5/b
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR1) check -l test-full1.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR2) -d disk2 fix -l test-part1.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR2) -d disk5 fix -l test-part2.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR1) check -l test-full1.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) -d disk2 fix -l test-part1.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) -d disk5 fix -l test-part2.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 #### RECOVER PARITY ####
 	$(MSG) Delete the parity, fix and check with PAR1
 	rm bench/parity*
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR1) check -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR1) fix -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) check -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 	$(MSG) Delete the parity and the 2-parity, fix and check with PAR2
 	rm bench/parity*
 	rm bench/2-parity*
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 	$(MSG) Delete the parity and a disk, fix and check with PAR2
 	rm bench/parity*
 	rm -r bench/disk2/b
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 	$(MSG) Delete the 2-parity and a disk, fix and check with PAR2
 	rm bench/2-parity*
 	rm -r bench/disk3/a
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 	$(MSG) Corrupt the parity, fix and check with PAR1
 	$(TESTENV) ./mktest$(EXEEXT) write 1 100 10000 bench/parity*
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR1) check -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR1) -a check
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR1) fix -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR1) check -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) -a check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 	$(MSG) Corrupt the parity and the 2-parity, fix and check with PAR2
 	$(TESTENV) ./mktest$(EXEEXT) write 2 100 10000 bench/parity*
 	$(TESTENV) ./mktest$(EXEEXT) write 2 100 10000 bench/2-parity*
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR2) check -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) -a check
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR2) check -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -a check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 #### RECOVER FILES AND PARITY ####
 	$(MSG) Corrupt some files, fix and check with PAR1
 	$(TESTENV) ./mktest$(EXEEXT) change 3 500 bench/disk2/b/*
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR1) -a check -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR1) check -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR1) fix -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR1) -a check -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR1) check -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 	$(MSG) Corrupt some files, fix and check with PAR2 in verbose mode
 	$(TESTENV) ./mktest$(EXEEXT) change 4 500 bench/disk2/b/*
 	$(TESTENV) ./mktest$(EXEEXT) change 4 500 bench/disk3/b/*
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) --test-expect-unrecoverable -c $(PAR1) check -l test.log > /dev/null
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS_VERBOSE) --test-expect-unrecoverable -c $(PAR1) fix -l test-fail-corrupt-verbose.log > /dev/null
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR2) -a check -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR2) check -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) --test-expect-unrecoverable -c $(PAR1) check -l test.log > /dev/null
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) --test-expect-unrecoverable -c $(PAR1) fix -l test-fail-corrupt-verbose.log > /dev/null
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR2) -a check -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR2) check -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 	$(MSG) Corrupt some files, fix and check with PAR2
 	$(TESTENV) ./mktest$(EXEEXT) change 5 500 bench/disk2/b/*
 	$(TESTENV) ./mktest$(EXEEXT) change 5 500 bench/disk3/b/*
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR1) check -l test-fail-corrupt-data.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR2) check -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR1) check -l test-fail-corrupt-data.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR2) check -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 	$(MSG) Corrupt the parity and some files, fix and check with PAR2
 	$(TESTENV) ./mktest$(EXEEXT) write 6 100 10000 bench/parity*
 	$(TESTENV) ./mktest$(EXEEXT) change 6 500 bench/disk1/a/*
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR1) check -l test-fail-corrupt-parity.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR2) check -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR1) check -l test-fail-corrupt-parity.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR2) check -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 	$(MSG) Corrupt the 2-parity and some files, fix and check with PAR2
 	$(TESTENV) ./mktest$(EXEEXT) write 7 100 10000 bench/2-parity*
 	$(TESTENV) ./mktest$(EXEEXT) change 7 500 bench/disk1/a/*
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR1) check -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR2) check -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR1) check -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR2) check -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 	$(MSG) Sync after all the fixes
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) sync
-	$(TESTENV) ./snapraid$(EXEEXT) $(CHECKFLAGS) -c $(CONF) check
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
+	$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
 endif
 	$(MSG) Regression test completed with SUCCESS!
 	$(MSG) Please ignore any error message printed above, they are expected!
diff --git a/cmdline/checker.c b/cmdline/checker.c
new file mode 100644
index 00000000..56ce10e4
--- /dev/null
+++ b/cmdline/checker.c
@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2011 Andrea Mazzoleni
+
+/* enable the --test-run option */
+#define HAVE_CHECKER 1
+
+#include "snapraid.c"
+
diff --git a/cmdline/snapraid.c b/cmdline/snapraid.c
index d3017e06..beb9af7b 100644
--- a/cmdline/snapraid.c
+++ b/cmdline/snapraid.c
@@ -800,8 +800,10 @@ static struct option long_options[] = {
 	/* Exit generic need sync */
 	{ "test-expect-need-sync", 0, 0, OPT_TEST_EXPECT_NEED_SYNC },
 
+#if HAVE_CHECKER
 	/* Run some command after loading the state and before the command */
 	{ "test-run", 1, 0, OPT_TEST_RUN },
+#endif
 
 	/* Use the FindFirst/Next approach in Windows to list files */
 	{ "test-force-scan-winfind", 0, 0, OPT_TEST_FORCE_SCAN_WINFIND },
@@ -987,7 +989,9 @@ int snapraid_main(int argc, char* argv[])
 	const char* log_file;
 	int lock;
 	const char* gen_conf;
+#if HAVE_CHECKER
 	const char* run;
+#endif
 	int speedtest;
 	int speed_test_period;
 	int speed_test_disks_number;
@@ -1024,7 +1028,9 @@ int snapraid_main(int argc, char* argv[])
 	lock = 0;
 	gen_conf = 0;
 	speedtest = 0;
+#if HAVE_CHECKER
 	run = 0;
+#endif
 
 	opterr = 0;
 	while ((c =
@@ -1357,9 +1363,11 @@ int snapraid_main(int argc, char* argv[])
 			exit_success = 1;
 			exit_sync_needed = 0;
 			break;
+#if HAVE_CHECKER
 		case OPT_TEST_RUN :
 			run = optarg;
 			break;
+#endif
 		case OPT_TEST_FORCE_SCAN_WINFIND :
 			opt.force_scan_winfind = 1;
 			break;
@@ -1878,16 +1886,24 @@ int snapraid_main(int argc, char* argv[])
 		/* intercept signals while operating */
 		signal_init();
 
+#if HAVE_CHECKER
 		/* run a test command if required */
 		if (run != 0) {
-			ret = system(run); /* ignore error */
-			if (ret != 0) {
+			ret = system(run);
+			if (ret == -1) {
 				/* LCOV_EXCL_START */
-				log_fatal(errno, "Error executing command '%s'.\n", run);
+				log_fatal(errno, "Failed to run '%s'.\n", run);
 				exit(EXIT_FAILURE);
 				/* LCOV_EXCL_STOP */
 			}
+			if (ret != 0) {
+				/* LCOV_EXCL_START */
+				log_fatal(EEXTERNAL, "Failed to run '%s' with return code %xh.\n", run, ret);
+				return -1;
+				/* LCOV_EXCL_STOP */
+			}
 		}
+#endif
 
 		/* waits some time to ensure that any concurrent modification done at the files, */
 		/* using the same mtime read by the scan process, will be read by sync. */