diff --git a/.github/workflows/ci_linux.yml b/.github/workflows/ci_linux.yml
index cbb6561..b0d519d 100644
--- a/.github/workflows/ci_linux.yml
+++ b/.github/workflows/ci_linux.yml
@@ -1,140 +1,65 @@
-name: CI on Linux
+# SPDX-FileCopyrightText: 2006-2023, Knut Reinert & Freie Universität Berlin
+# SPDX-FileCopyrightText: 2016-2023, Knut Reinert & MPI für molekulare Genetik
+# SPDX-License-Identifier: CC0-1.0
+
+name: Linux
 
 on:
   push:
     branches:
-      - 'master'
       - 'main'
   pull_request:
+  workflow_dispatch:
 
 concurrency:
   group: linux-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
+  cancel-in-progress: ${{ github.event_name != 'push' }}
 
 env:
-  CMAKE_VERSION: 3.10.3
-  SEQAN3_NO_VERSION_CHECK: 1
   TZ: Europe/Berlin
 
 defaults:
   run:
-    shell: bash -ex {0}
+    shell: bash -Eexuo pipefail {0}
 
 jobs:
   build:
-    name: ${{ matrix.name }}
-    runs-on: ubuntu-22.04
-    timeout-minutes: 120
+    runs-on: ubuntu-latest
+    name: ${{ matrix.compiler }}
+    if: github.repository_owner == 'seqan' || github.event_name == 'workflow_dispatch'
     strategy:
-      fail-fast: true
+      fail-fast: false
       matrix:
-        include:
-          - name: "Coverage gcc12"
-            cxx: "g++-12"
-            cc: "gcc-12"
-            build: coverage
-            build_type: Coverage
-
-          - name: "gcc12"
-            cxx: "g++-12"
-            cc: "gcc-12"
-            build_type: Release
-
-          - name: "gcc11"
-            cxx: "g++-11"
-            cc: "gcc-11"
-            build_type: Release
-
-          - name: "gcc10"
-            cxx: "g++-10"
-            cc: "gcc-10"
-            build_type: Release
-
+        compiler: ["clang-18", "clang-17", "gcc-14", "gcc-13", "gcc-12", "intel"]
+    container:
+      image: ghcr.io/seqan/${{ matrix.compiler }}
+      volumes:
+        - /home/runner:/home/runner
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          path: needle
-          fetch-depth: 2
-          submodules: recursive
-
-      - name: Add package source
-        run: bash ./needle/lib/seqan3/.github/workflows/scripts/configure_apt.sh
-
-      - name: Install CMake
-        run: bash ./needle/lib/seqan3/.github/workflows/scripts/install_cmake.sh
-
-      - name: Install ccache
-        run: sudo apt-get install --yes ccache
-
-      - name: Install compiler ${{ matrix.cxx }}
-        run: sudo apt-get install --yes ${{ matrix.cxx }}
-
-      - name: Install lcov
-        if: matrix.build == 'coverage'
-        run: |
-          sudo apt-get install --yes lcov
-          sudo update-alternatives --install /usr/bin/gcov gcov /usr/bin/gcov-12 100
+        uses: actions/checkout@v4
 
       - name: Load ccache
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
-          path: .ccache
-          key: ${{ runner.os }}-${{ matrix.name }}-ccache-${{ github.ref }}-${{ github.run_number }}
-          # Restoring: From current branch, otherwise from base branch, otherwise from any branch.
-          restore-keys: |
-            ${{ runner.os }}-${{ matrix.name }}-ccache-${{ github.ref }}
-            ${{ runner.os }}-${{ matrix.name }}-ccache-${{ github.base_ref }}
-            ${{ runner.os }}-${{ matrix.name }}-ccache-
-
-      - name: Tool versions
-        run: |
-          env cmake --version
-          env ${{ matrix.cxx }} --version
+          path: /home/runner/.ccache
+          save-always: true
+          key: ccache-${{ runner.os }}-${{ github.workflow }}-${{ matrix.compiler }}-${{ github.ref }}
 
       - name: Configure tests
-        env:
-          CXX: ${{ matrix.cxx }}
-          CC: ${{ matrix.cc }}
         run: |
-          mkdir build
-          cd build
-          cmake ../needle -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DCMAKE_CXX_FLAGS="${{ matrix.cxx_flags }} -Wno-interference-size"
+          mkdir build && cd build
+          cmake .. -DCMAKE_BUILD_TYPE=Release
+          make gtest_main
 
       - name: Build tests
-        env:
-          CCACHE_BASEDIR: ${{ github.workspace }}
-          CCACHE_DIR: ${{ github.workspace }}/.ccache
-          CCACHE_COMPRESS: true
-          CCACHE_COMPRESSLEVEL: 6
-          CCACHE_MAXSIZE: 500M
-        run: |
-          ccache -p || true
-          cd build
-          make -k -j2 api_test cli_test
-          ccache -s || true
-
-      - name: Generate coverage baseline
-        if: matrix.build == 'coverage'
+        working-directory: build
         run: |
-          lcov --directory ./build/ --zerocounters
-          lcov --directory ./build/ --capture --initial --output-file ./build/coverage_report.baseline
+          ccache -z
+          make -k tests
+          ccache -svvx
 
       - name: Run tests
-        run: |
-          cd build
-          ctest . -j2 --output-on-failure
+        working-directory: build
+        run: ctest -j --output-on-failure --test-dir test
 
-      - name: Generate coverage report
-        if: matrix.build == 'coverage'
-        run: |
-          lcov --directory ./build/ --capture --output-file ./build/coverage_report.captured
-          lcov -a ./build/coverage_report.baseline -a ./build/coverage_report.captured --output-file ./build/coverage_report.total
-          lcov --remove ./build/coverage_report.total '/usr/*' '${{ github.workspace }}/needle/lib/*' '${{ github.workspace }}/needle/test/*' '${{ github.workspace }}/build/vendor/*' --output-file ./build/coverage_report
-
-      - name: Submit coverage report
-        if: matrix.build == 'coverage'
-        uses: codecov/codecov-action@v2
-        with:
-          files: ${{ github.workspace }}/build/coverage_report
-          root_dir: ${{ github.workspace }}/needle
diff --git a/.github/workflows/ci_macos.yml b/.github/workflows/ci_macos.yml
index 3e74e3b..bdd7397 100644
--- a/.github/workflows/ci_macos.yml
+++ b/.github/workflows/ci_macos.yml
@@ -1,115 +1,59 @@
-name: CI on macOS
+# SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
+# SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
+# SPDX-License-Identifier: CC0-1.0
+
+name: macOS
 
 on:
   push:
     branches:
-      - 'master'
       - 'main'
   pull_request:
+  workflow_dispatch:
 
 concurrency:
   group: macos-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
+  cancel-in-progress: ${{ github.event_name != 'push' }}
 
 env:
-  CMAKE_VERSION: 3.10.3
-  SEQAN3_NO_VERSION_CHECK: 1
   TZ: Europe/Berlin
 
 defaults:
   run:
-    shell: bash -ex {0}
+    shell: bash -Eeuxo pipefail {0}
 
 jobs:
   build:
-    name: ${{ matrix.name }}
-    runs-on: macos-12
-    timeout-minutes: 120
+    name: ${{ matrix.compiler }}
+    runs-on: macos-14
+    if: github.repository_owner == 'seqan' || github.event_name == 'workflow_dispatch'
     strategy:
-      fail-fast: true
+      fail-fast: false
       matrix:
-        include:
-          - name: "gcc12"
-            cxx: "g++-12"
-            cc: "gcc-12"
-            build_type: Release
-
-          - name: "gcc11"
-            cxx: "g++-11"
-            cc: "gcc-11"
-            build_type: Release
-
-          - name: "gcc10"
-            cxx: "g++-10"
-            cc: "gcc-10"
-            build_type: Release
-
+        compiler: ["clang-18", "clang-17", "gcc-14", "gcc-13", "gcc-12"]
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          path: needle
-          fetch-depth: 2
-          submodules: recursive
-
-      - name: Configure Homebrew
-        uses: Homebrew/actions/setup-homebrew@master
+        uses: actions/checkout@v4
 
-      - name: Install CMake
-        run: bash ./needle/lib/seqan3/.github/workflows/scripts/install_cmake.sh
-
-      - name: Install ccache
-        run: bash ./needle/lib/seqan3/.github/workflows/scripts/install_via_brew.sh ccache
-
-      - name: Install compiler ${{ matrix.cxx }}
-        run: bash ./needle/lib/seqan3/.github/workflows/scripts/install_via_brew.sh gcc $(echo "${{ matrix.cxx }}" | sed "s/g++-//g")
-
-      - name: Load ccache
-        uses: actions/cache@v3
+      - name: Setup toolchain
+        uses: seqan/actions/setup-toolchain@main
         with:
-          path: .ccache
-          key: ${{ runner.os }}-${{ matrix.name }}-ccache-${{ github.ref }}-${{ github.run_number }}
-          # Restoring: From current branch, otherwise from base branch, otherwise from any branch.
-          restore-keys: |
-            ${{ runner.os }}-${{ matrix.name }}-ccache-${{ github.ref }}
-            ${{ runner.os }}-${{ matrix.name }}-ccache-${{ github.base_ref }}
-            ${{ runner.os }}-${{ matrix.name }}-ccache-
-
-      - name: Tool versions
-        run: |
-          env cmake --version
-          env ${{ matrix.cxx }} --version
-          sudo xcode-select -s '/Applications/Xcode_13.4.1.app/Contents/Developer' # https://github.com/actions/runner-images/issues/6350
+          compiler: ${{ matrix.compiler }}
+          ccache_size: 75M
 
       - name: Configure tests
-        env:
-          CXX: ${{ matrix.cxx }}
-          CC: ${{ matrix.cc }}
         run: |
-          mkdir build
-          cd build
-          cmake ../needle -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DCMAKE_CXX_FLAGS="${{ matrix.cxx_flags }} -Wno-interference-size"
+          mkdir build && cd build
+          cmake .. -DCMAKE_BUILD_TYPE=Release
+          make gtest_main
 
-      - name: Build application
-        env:
-          CCACHE_BASEDIR: ${{ github.workspace }}
-          CCACHE_DIR: ${{ github.workspace }}/.ccache
-          CCACHE_COMPRESS: true
-          CCACHE_COMPRESSLEVEL: 6
-          CCACHE_MAXSIZE: 500M
+      - name: Build tests
+        working-directory: build
         run: |
-          ccache -p || true
-          cd build
-          make -k -j3
-          ccache -s || true
+          ccache -z
+          make -k tests
+          ccache -svvx
 
-      - name: Build and run tests
-        env:
-          CCACHE_BASEDIR: ${{ github.workspace }}
-          CCACHE_DIR: ${{ github.workspace }}/.ccache
-          CCACHE_COMPRESS: true
-          CCACHE_COMPRESSLEVEL: 6
-          CCACHE_MAXSIZE: 500M
-        run: |
-          cd build
-          ctest . -j3 --output-on-failure
+      - name: Run tests
+        working-directory: build
+        run: ctest -j --output-on-failure --test-dir test
diff --git a/.github/workflows/ci_misc.yml b/.github/workflows/ci_misc.yml
deleted file mode 100644
index 7ea63ad..0000000
--- a/.github/workflows/ci_misc.yml
+++ /dev/null
@@ -1,137 +0,0 @@
-name: CI misc
-
-on:
-  push:
-    branches:
-      - 'master'
-      - 'main'
-  pull_request:
-
-concurrency:
-  group: misc-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-env:
-  SEQAN3_NO_VERSION_CHECK: 1
-  TZ: Europe/Berlin
-
-defaults:
-  run:
-    shell: bash -ex {0}
-
-jobs:
-  build:
-    name: ${{ matrix.name }}
-    runs-on: ubuntu-22.04
-    timeout-minutes: 120
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - name: "Documentation"
-            build: documentation
-            build_threads: 2
-            test_threads: 2
-            cmake: 3.10.3
-            doxygen: 1.9.4
-            requires_toolchain: false
-            requires_ccache: false
-            skip_build_tests: true
-            skip_run_tests: false
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          path: needle
-          fetch-depth: 2
-          submodules: recursive
-
-      - name: Add package source
-        run: bash ./needle/lib/seqan3/.github/workflows/scripts/configure_apt.sh
-
-      - name: Install CMake
-        env:
-          BUILD: ${{ matrix.build }}
-          CMAKE_VERSION: ${{ matrix.cmake }}
-        run: bash ./needle/lib/seqan3/.github/workflows/scripts/install_cmake.sh
-
-      - name: Install Doxygen
-        if: matrix.build == 'documentation'
-        env:
-          DOXYGEN_VERSION: ${{ matrix.doxygen }}
-        run: bash ./needle/lib/seqan3/.github/workflows/scripts/install_doxygen.sh
-
-      - name: Install ccache
-        if: matrix.requires_ccache
-        run: sudo apt-get install --yes ccache
-
-      - name: Install compiler ${{ matrix.cxx }}
-        if: matrix.requires_toolchain
-        run: sudo apt-get install --yes ${{ matrix.cxx }}
-
-      - name: Load ccache
-        if: matrix.requires_ccache
-        uses: actions/cache@v3
-        with:
-          path: .ccache
-          key: ${{ matrix.name }}-ccache-${{ github.ref }}-${{ github.run_number }}
-          # Restoring: From current branch, otherwise from base branch, otherwise from any branch.
-          restore-keys: |
-            ${{ matrix.name }}-ccache-${{ github.ref }}
-            ${{ matrix.name }}-ccache-${{ github.base_ref }}
-            ${{ matrix.name }}-ccache-
-
-      - name: Tool versions
-        run: |
-          env cmake --version
-          env doxygen --version || true
-          env ${{ matrix.cxx }} --version || true
-
-      - name: Configure tests
-        env:
-          CXX: ${{ matrix.cxx }}
-          CC: ${{ matrix.cc }}
-        run: |
-          mkdir build
-          cd build
-          cmake ../needle -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DCMAKE_CXX_FLAGS="${{ matrix.cxx_flags }} -Wno-interference-size"
-
-      - name: Build tests
-        if: ${{!matrix.skip_build_tests}}
-        env:
-          CCACHE_BASEDIR: ${{ github.workspace }}
-          CCACHE_DIR: ${{ github.workspace }}/.ccache
-          CCACHE_COMPRESS: true
-          CCACHE_COMPRESSLEVEL: 6
-          CCACHE_MAXSIZE: 500M
-        run: |
-          ccache -p || true
-          cd build
-          make -k -j${{ matrix.build_threads }}
-          ccache -s || true
-
-      - name: Run tests
-        if: ${{!matrix.skip_run_tests}}
-        run: |
-          cd build
-          if [[ "${{ matrix.build }}" =~ ^(documentation)$ ]]; then
-            make -k -j2 doc 2>doxygen_warnings.txt
-            cat doxygen_warnings.txt
-            test ! -s doxygen_warnings.txt
-          else
-            ctest . -j${{ matrix.test_threads }} --output-on-failure
-          fi
-
-      - name: Package documentation
-        if: matrix.build == 'documentation'
-        continue-on-error: true
-        run: tar -zcf documentation.tar.gz build
-
-      - name: Upload documentation
-        if: matrix.build == 'documentation'
-        continue-on-error: true
-        uses: actions/upload-artifact@v3
-        with:
-          name: documentation
-          path: documentation.tar.gz
diff --git a/.github/workflows/ci_sanitizer.yml b/.github/workflows/ci_sanitizer.yml
new file mode 100644
index 0000000..58f44f7
--- /dev/null
+++ b/.github/workflows/ci_sanitizer.yml
@@ -0,0 +1,99 @@
+# SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
+# SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
+# SPDX-License-Identifier: CC0-1.0
+
+name: Sanitizer
+
+on:
+  schedule:
+    - cron: "0 6 * * SAT"
+  workflow_dispatch:
+
+concurrency:
+  group: sanitizer-actions
+  cancel-in-progress: true
+
+env:
+  TZ: Europe/Berlin
+  ASAN_OPTIONS: strict_string_checks=1:detect_stack_use_after_return=1:check_initialization_order=1:strict_init_order=1:detect_leaks=1
+  TSAN_OPTIONS: ignore_noninstrumented_modules=1
+  UBSAN_OPTIONS: print_stacktrace=1
+
+defaults:
+  run:
+    shell: bash -Eeuxo pipefail {0}
+
+jobs:
+  build:
+    name: ${{ matrix.name }} ${{ matrix.build_type }} ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    if: github.repository_owner == 'seqan' || github.event_name == 'workflow_dispatch'
+    strategy:
+      fail-fast: false
+      matrix:
+        name: [ASan, TSan, UBSan]
+        os: [ubuntu-latest, macos-14]
+        build_type: [Release, RelWithDebInfo, Debug]
+        exclude:
+          - name: "TSan"
+            os: macos-14
+        include:
+          - name: "ASan"
+            os: ubuntu-latest
+            cxx_flags: "-fno-omit-frame-pointer -fsanitize=address -Wno-maybe-uninitialized"
+
+          - name: "ASan"
+            os: macos-14
+            cxx_flags: "-fno-omit-frame-pointer -fsanitize=address"
+
+          - name: "TSan"
+            cxx_flags: "-fno-omit-frame-pointer -fsanitize=thread"
+
+          - name: "UBSan"
+            os: ubuntu-latest
+            cxx_flags: "-fno-omit-frame-pointer -fsanitize=undefined,float-divide-by-zero"
+
+          - name: "UBSan"
+            os: macos-14
+            cxx_flags: "-fno-omit-frame-pointer -fsanitize=undefined,float-divide-by-zero,local-bounds,nullability -fno-sanitize=function -Wno-pass-failed"
+
+          - os: macos-14
+            compiler: clang-18
+
+          - os: ubuntu-latest
+            compiler: gcc-14
+            image: ghcr.io/seqan/gcc-14
+
+          - name: "TSan"
+            os: ubuntu-latest
+            compiler: clang-18
+            image: ghcr.io/seqan/clang-18
+    container:
+      image: ${{ matrix.image || '' }}
+      volumes:
+        - /home/runner:/home/runner
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup compiler
+        if: contains(matrix.os, 'macos')
+        uses: seqan/actions/setup-compiler@main
+        with:
+          compiler: ${{ matrix.compiler }}
+
+      - name: Configure tests
+        run: |
+          mkdir build && cd build
+          cmake .. -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} \
+                   -DCMAKE_CXX_FLAGS="${{ matrix.cxx_flags }}"
+          make gtest_main
+
+      - name: Build tests
+        working-directory: build
+        run: make -k tests
+
+      - name: Run tests
+        working-directory: build
+        run: ctest -j1 --output-on-failure --test-dir test
+
diff --git a/.gitmodules b/.gitmodules
deleted file mode 100644
index a31955e..0000000
--- a/.gitmodules
+++ /dev/null
@@ -1,7 +0,0 @@
-[submodule "lib/seqan3"]
-	path = lib/seqan3
-	url = https://github.com/seqan/seqan3.git
-	branch = master
-[submodule "lib/robin-hood-hashing"]
-	path = lib/robin-hood-hashing
-	url = https://github.com/martinus/robin-hood-hashing
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6fb36bf..37bf56a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,52 +1,45 @@
-cmake_minimum_required (VERSION 3.10)
-
-## CUSTOMISE
+cmake_minimum_required (VERSION 3.25)
 
 # Define the application name and version.
-project (needle VERSION 1.0.3)
-
-## BUILD
-
-# Make Release default build type
-if (NOT CMAKE_BUILD_TYPE)
-    set (CMAKE_BUILD_TYPE Release CACHE STRING
-         "Choose the type of build, options are: Debug Release Coverage RelWithDebInfo MinSizeRel."
-         FORCE)
-endif ()
-
-# Specify the directories where to store the built archives, libraries and executables
-set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib")
-set (CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib")
-set (CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
-
-# Messages
-string (ASCII 27 Esc)
-set (FontBold "${Esc}[1m")
-set (FontReset "${Esc}[m")
-
-# Dependency: SeqAn3.
-find_package (SeqAn3 QUIET REQUIRED HINTS lib/seqan3/build_system)
-
-# Use ccache.
-include ("${SEQAN3_CLONE_DIR}/test/cmake/seqan3_require_ccache.cmake")
-seqan3_require_ccache ()
-
-# Dependency: robin_hood.
-add_subdirectory(lib/robin-hood-hashing)
-
-# Add the application.
+project (needle
+         LANGUAGES CXX
+         VERSION 1.0.3
+         DESCRIPTION "A fast and space-efficient pre-filter for estimating the quantification of very large collections of nucleotide sequences"
+)
+
+# This allows including `*.cmake` files from the `cmake` directory without specifying the full path.
+list (APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake")
+
+# Specify the directories where to store the built archives, libraries and executables.
+include (output_directories)
+
+# Add packages.
+# We use CPM for package management: https://github.com/cpm-cmake/CPM.cmake
+# The added packages (e.g., hibf, sharg, seqan3) are defined in the `cmake/package-lock.cmake` file.
+include (CPM)
+CPMUsePackageLock (${CMAKE_CURRENT_LIST_DIR}/cmake/package-lock.cmake)
+
+# Use ccache if available. This speeds up the build process by caching files that have been compiled before.
+CPMGetPackage (use_ccache)
+CPMGetPackage (seqan3)
+CPMGetPackage (robin-hood)
+
+# Add the application. This will include `src/CMakeLists.txt`.
 add_subdirectory (src)
-message (STATUS "${FontBold}You can run `make` to build the application.${FontReset}")
 
+# An option to disable configuring and building the tests. Tests are enabled by default.
+# If your project-name (line 8 of this file) is `app-template`, the option will be `app-template_TEST`.
+# It can be used when calling CMake: `cmake .. -Dapp-template_TEST=OFF`.
+# It is good practice to allow disabling tests. If another project includes your application,
+# it might not want to build your tests.
+option (${PROJECT_NAME}_TEST "Enable testing for ${PROJECT_NAME}." ON)
 
-## DOCUMENTATION
-
-add_subdirectory (doc EXCLUDE_FROM_ALL)
-
-## TEST
+if (${PROJECT_NAME}_TEST)
+    # Add the tests. This will include `test/CMakeLists.txt`.
+    add_subdirectory (test EXCLUDE_FROM_ALL)
+endif ()
 
-enable_testing ()
-add_subdirectory (test EXCLUDE_FROM_ALL)
+# add_subdirectory (doc EXCLUDE_FROM_ALL)
 
 ## PACKAGE
 # Change version in this file: project (needle VERSION x.x.x)
@@ -74,15 +67,15 @@ add_subdirectory (test EXCLUDE_FROM_ALL)
 # This should be done in a clean directory, because everything in the needle checkout will be packaged, i.e., also
 # local build directories if they exist.
 
-set (CPACK_GENERATOR "TXZ")
+# set (CPACK_GENERATOR "TXZ")
 
-set (CPACK_PACKAGE_VERSION "${needle_VERSION}")
-set (CPACK_PACKAGE_VENDOR "seqan")
-set (CPACK_PACKAGE_CHECKSUM "SHA256")
-set (CPACK_RESOURCE_FILE_LICENSE "${needle_SOURCE_DIR}/LICENSE.md")
-set (CPACK_RESOURCE_FILE_README "${needle_SOURCE_DIR}/README.md")
+# set (CPACK_PACKAGE_VERSION "${needle_VERSION}")
+# set (CPACK_PACKAGE_VENDOR "seqan")
+# set (CPACK_PACKAGE_CHECKSUM "SHA256")
+# set (CPACK_RESOURCE_FILE_LICENSE "${needle_SOURCE_DIR}/LICENSE.md")
+# set (CPACK_RESOURCE_FILE_README "${needle_SOURCE_DIR}/README.md")
 
-set (CPACK_SOURCE_GENERATOR "TXZ")
-set (CPACK_SOURCE_IGNORE_FILES "\\\\.git($|/)")
+# set (CPACK_SOURCE_GENERATOR "TXZ")
+# set (CPACK_SOURCE_IGNORE_FILES "\\\\.git($|/)")
 
-include (CPack)
+# include (CPack)
diff --git a/CMakeLists.txt.in b/CMakeLists.txt.in
deleted file mode 100644
index c6247af..0000000
--- a/CMakeLists.txt.in
+++ /dev/null
@@ -1,15 +0,0 @@
-cmake_minimum_required(VERSION 2.8.2)
-
-project(googletest-download NONE)
-
-include(ExternalProject)
-ExternalProject_Add(googletest
-  GIT_REPOSITORY    https://github.com/google/googletest.git
-  GIT_TAG           master
-  SOURCE_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-src"
-  BINARY_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-build"
-  CONFIGURE_COMMAND ""
-  BUILD_COMMAND     ""
-  INSTALL_COMMAND   ""
-  TEST_COMMAND      ""
-)
diff --git a/cmake/CPM.cmake b/cmake/CPM.cmake
new file mode 100644
index 0000000..baf2d8c
--- /dev/null
+++ b/cmake/CPM.cmake
@@ -0,0 +1,24 @@
+# SPDX-License-Identifier: MIT
+#
+# SPDX-FileCopyrightText: Copyright (c) 2019-2023 Lars Melchior and contributors
+
+set(CPM_DOWNLOAD_VERSION 0.40.2)
+set(CPM_HASH_SUM "c8cdc32c03816538ce22781ed72964dc864b2a34a310d3b7104812a5ca2d835d")
+
+if(CPM_SOURCE_CACHE)
+  set(CPM_DOWNLOAD_LOCATION "${CPM_SOURCE_CACHE}/cpm/CPM_${CPM_DOWNLOAD_VERSION}.cmake")
+elseif(DEFINED ENV{CPM_SOURCE_CACHE})
+  set(CPM_DOWNLOAD_LOCATION "$ENV{CPM_SOURCE_CACHE}/cpm/CPM_${CPM_DOWNLOAD_VERSION}.cmake")
+else()
+  set(CPM_DOWNLOAD_LOCATION "${CMAKE_BINARY_DIR}/cmake/CPM_${CPM_DOWNLOAD_VERSION}.cmake")
+endif()
+
+# Expand relative path. This is important if the provided path contains a tilde (~)
+get_filename_component(CPM_DOWNLOAD_LOCATION ${CPM_DOWNLOAD_LOCATION} ABSOLUTE)
+
+file(DOWNLOAD
+     https://github.com/cpm-cmake/CPM.cmake/releases/download/v${CPM_DOWNLOAD_VERSION}/CPM.cmake
+     ${CPM_DOWNLOAD_LOCATION} EXPECTED_HASH SHA256=${CPM_HASH_SUM}
+)
+
+include(${CPM_DOWNLOAD_LOCATION})
diff --git a/cmake/output_directories.cmake b/cmake/output_directories.cmake
new file mode 100644
index 0000000..0fc7229
--- /dev/null
+++ b/cmake/output_directories.cmake
@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
+# SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
+# SPDX-License-Identifier: CC0-1.0
+
+set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib")
+set (CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib")
+set (CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}")
diff --git a/cmake/package-lock.cmake b/cmake/package-lock.cmake
new file mode 100644
index 0000000..e13cd33
--- /dev/null
+++ b/cmake/package-lock.cmake
@@ -0,0 +1,50 @@
+# SPDX-FileCopyrightText: 2006-2023, Knut Reinert & Freie Universität Berlin
+# SPDX-FileCopyrightText: 2016-2023, Knut Reinert & MPI für molekulare Genetik
+# SPDX-License-Identifier: CC0-1.0
+
+# CPM Package Lock
+# This file should be committed to version control
+
+# seqan3
+set (NEEDLE_SEQAN3_VERSION d4a7c88fde0311e12e98e7822da772b99c887cb5)
+CPMDeclarePackage (seqan3
+                   NAME seqan3
+                   GIT_TAG ${NEEDLE_SEQAN3_VERSION}
+                   GITHUB_REPOSITORY seqan/seqan3
+                   SYSTEM TRUE
+                   EXCLUDE_FROM_ALL TRUE
+                   OPTIONS "INSTALL_SEQAN3 OFF" "CMAKE_MESSAGE_LOG_LEVEL WARNING"
+)
+
+# googletest
+set (NEEDLE_GOOGLETEST_VERSION 1.15.2)
+CPMDeclarePackage (googletest
+                   NAME googletest
+                   VERSION ${NEEDLE_GOOGLETEST_VERSION}
+                   GITHUB_REPOSITORY google/googletest
+                   SYSTEM TRUE
+                   OPTIONS "BUILD_GMOCK OFF" "INSTALL_GTEST OFF" "CMAKE_MESSAGE_LOG_LEVEL WARNING"
+                           "CMAKE_CXX_STANDARD 20"
+)
+
+# robin-hood-hashing
+set (NEEDLE_ROBIN_HOOD_VERSION 7697343363af4cc3f42cab17be49e6af9ab181e2)
+CPMDeclarePackage (robin-hood
+                   NAME robin-hood
+                   GIT_TAG ${NEEDLE_ROBIN_HOOD_VERSION}
+                   GITHUB_REPOSITORY martinus/robin-hood-hashing
+                   SYSTEM TRUE
+                   EXCLUDE_FROM_ALL TRUE
+                   OPTIONS "CMAKE_MESSAGE_LOG_LEVEL WARNING"
+)
+
+# use_ccache
+set (USE_CCACHE_VERSION d2a54ef555b6fc2d496a4c9506dbeb7cf899ce37)
+CPMDeclarePackage (use_ccache
+                   NAME use_ccache
+                   GIT_TAG ${USE_CCACHE_VERSION}
+                   GITHUB_REPOSITORY seqan/cmake-scripts
+                   SOURCE_SUBDIR ccache
+                   SYSTEM TRUE
+                   EXCLUDE_FROM_ALL TRUE
+)
diff --git a/cmake/test/add_local_data.cmake b/cmake/test/add_local_data.cmake
new file mode 100644
index 0000000..d8cf413
--- /dev/null
+++ b/cmake/test/add_local_data.cmake
@@ -0,0 +1,23 @@
+# SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
+# SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
+# SPDX-License-Identifier: CC0-1.0
+
+set (DATASOURCES_DATA_DIR "${${PROJECT_NAME}_SOURCE_DIR}/test/data")
+
+file (GLOB_RECURSE datasources
+      LIST_DIRECTORIES false
+      RELATIVE ${DATASOURCES_DATA_DIR}
+      CONFIGURE_DEPENDS ${DATASOURCES_DATA_DIR}/*
+)
+list (REMOVE_ITEM datasources datasources.cmake README.md)
+list (FILTER datasources EXCLUDE REGEX "\.license")
+
+foreach (datasource IN LISTS datasources)
+    get_filename_component (datasource_name "${datasource}" NAME)
+    file (SHA256 ${DATASOURCES_DATA_DIR}/${datasource} datasource_hash)
+
+    declare_datasource (FILE ${datasource_name}
+                        URL ${DATASOURCES_DATA_DIR}/${datasource}
+                        URL_HASH SHA256=${datasource_hash}
+    )
+endforeach ()
diff --git a/cmake/test/config.cmake b/cmake/test/config.cmake
new file mode 100644
index 0000000..90652fe
--- /dev/null
+++ b/cmake/test/config.cmake
@@ -0,0 +1,66 @@
+# SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
+# SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
+# SPDX-License-Identifier: CC0-1.0
+
+CPMGetPackage (googletest)
+
+list (APPEND CMAKE_CTEST_ARGUMENTS "--output-on-failure") # Must be before `enable_testing ()`.
+enable_testing ()
+
+# Set directories for test output files, input data and binaries.
+file (MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/output)
+add_definitions (-DOUTPUTDIR=\"${CMAKE_CURRENT_BINARY_DIR}/output/\")
+add_definitions (-DDATADIR=\"${CMAKE_CURRENT_BINARY_DIR}/data/\")
+add_definitions (-DBINDIR=\"${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/\")
+add_definitions (-DAPPNAME=\"${PROJECT_NAME}\")
+
+# Add the test interface library.
+if (NOT TARGET ${PROJECT_NAME}_test)
+    add_library (${PROJECT_NAME}_test INTERFACE)
+    target_compile_options (${PROJECT_NAME}_lib PUBLIC "-pedantic" "-Wall" "-Wextra" "-Werror")
+
+
+    if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+        # Disable bogus warnings in GCC12.
+        if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 12 AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 13)
+            target_compile_options (${PROJECT_NAME}_test INTERFACE "-Wno-array-bounds" "-Wno-stringop-overread")
+        endif ()
+
+        # Warn about failed return value optimization.
+        if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 14)
+            target_compile_options (${PROJECT_NAME}_lib PUBLIC "-Wnrvo")
+        endif ()
+    endif ()
+
+    target_link_libraries (${PROJECT_NAME}_test INTERFACE "${PROJECT_NAME}_lib" "GTest::gtest_main")
+
+    # !Workaround: Get seqan3 test include dir from seqan3 target
+    find_path (SEQAN3_TEST_INCLUDE_DIR
+           NAMES seqan3/test/tmp_directory.hpp
+           HINTS "${seqan3_SOURCE_DIR}/test/include"
+    )
+    target_include_directories (${PROJECT_NAME}_test SYSTEM INTERFACE "${SEQAN3_TEST_INCLUDE_DIR}")
+
+    add_library (${PROJECT_NAME}::test ALIAS ${PROJECT_NAME}_test)
+endif ()
+
+# Add the check target that builds and runs tests.
+add_custom_target (check COMMAND ${CMAKE_CTEST_COMMAND} ${CMAKE_CTEST_ARGUMENTS})
+add_custom_target (tests)
+
+macro (add_app_test test_filename)
+    file (RELATIVE_PATH source_file "${CMAKE_SOURCE_DIR}" "${CMAKE_CURRENT_LIST_DIR}/${test_filename}")
+    get_filename_component (target "${source_file}" NAME_WE)
+
+    add_executable (${target} ${test_filename})
+    target_link_libraries (${target} ${PROJECT_NAME}::test)
+
+    add_dependencies (${target} ${PROJECT_NAME})
+    add_dependencies (check ${target})
+    add_dependencies (tests ${target})
+
+    add_test (NAME ${target} COMMAND ${target})
+
+    unset (source_file)
+    unset (target)
+endmacro ()
diff --git a/cmake/test/declare_datasource.cmake b/cmake/test/declare_datasource.cmake
new file mode 100644
index 0000000..7955c4b
--- /dev/null
+++ b/cmake/test/declare_datasource.cmake
@@ -0,0 +1,69 @@
+# SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
+# SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
+# SPDX-License-Identifier: CC0-1.0
+
+include (ExternalProject)
+
+# Example call:
+#
+# ```cmake
+# declare_datasource (
+#   FILE pdb100d.ent.gz # build/data/pdb100d.ent.gz
+#   URL ftp://ftp.wwpdb.org/pub/pdb/data/structures/divided/pdb/00/pdb100d.ent.gz # 16KiloByte
+#   URL_HASH SHA256=c2b8f884568b07f58519966e256e2f3aa440508e8013bd10e0ee338e138e62a0)
+# ```
+#
+# Options:
+#
+# declare_datasource (FILE <datasource name> URL <url1> [<url2>...] [URL_HASH <algo>=<hashValue>] [<option>...])
+#
+# FILE <datasource name> (required):
+#    The name of the downloaded file (must be unique across all declared datasources).
+#    This will put the file into the ``<build>/data/<datasource name>`` folder.
+#
+# URL <url1> [<url2>...] (required):
+#    List of paths and/or URL(s) of the external datasource. When more than one URL is given, they are tried in
+#    turn until one succeeds. A URL may be an ordinary path in the local file system (in which case it must be the only
+#    URL provided) or any downloadable URL supported by the file(DOWNLOAD) command. A local filesystem path may refer to
+#    either an existing directory or to an archive file, whereas a URL is expected to point to a file which can be
+#    treated as an archive.
+#
+# URL_HASH <algo>=<hashValue> (optional):
+#    Hash of the archive file to be downloaded. The argument should be of the form <algo>=<hashValue> where algo can be
+#    any of the hashing algorithms supported by the file() command. Specifying this option is strongly recommended for
+#    URL downloads, as it ensures the integrity of the downloaded content. It is also used as a check for a previously
+#    downloaded file, allowing connection to the remote location to be avoided altogether if the local directory already
+#    has a file from an earlier download that matches the specified hash.
+#
+# This uses under the hood ExternalProject's and you can pass any viable option of ExternalProject to this function and
+# overwrite the default behaviour. See https://cmake.org/cmake/help/latest/module/ExternalProject.html for more
+# information.
+function (declare_datasource)
+    set (options "")
+    set (one_value_args FILE URL_HASH)
+    set (multi_value_args URL)
+
+    cmake_parse_arguments (ARG "${options}" "${one_value_args}" "${multi_value_args}" ${ARGN})
+
+    string (TOLOWER "datasource--${ARG_FILE}" datasource_name)
+
+    # create data folder
+    file (MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/data)
+
+    ExternalProject_Add ("${datasource_name}"
+                         URL "${ARG_URL}"
+                         URL_HASH "${ARG_URL_HASH}"
+                         DOWNLOAD_NAME "${ARG_FILE}"
+                         CONFIGURE_COMMAND ""
+                         BUILD_COMMAND ""
+                         INSTALL_COMMAND ${CMAKE_COMMAND} -E create_symlink <DOWNLOADED_FILE>
+                                         ${CMAKE_CURRENT_BINARY_DIR}/data/${ARG_FILE}
+                         TEST_COMMAND ""
+                         PREFIX "${CMAKE_CURRENT_BINARY_DIR}/_datasources"
+                         DOWNLOAD_NO_EXTRACT TRUE # don't extract archive files like .tar.gz.
+                         EXCLUDE_FROM_ALL TRUE
+                         ${ARG_UNPARSED_ARGUMENTS}
+    )
+
+    add_dependencies (${PROJECT_NAME}_test "${datasource_name}")
+endfunction ()
diff --git a/doc/CMakeLists.txt b/doc/CMakeLists.txt
index 0092fc1..6580539 100644
--- a/doc/CMakeLists.txt
+++ b/doc/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.9)
+cmake_minimum_required (VERSION 3.25)
 
 # Find doxygen.
 find_package (Doxygen 1.9.4 QUIET)
diff --git a/include/shared.h b/include/shared.h
index 0a9bab4..5b9c535 100644
--- a/include/shared.h
+++ b/include/shared.h
@@ -75,7 +75,7 @@ struct estimate_ibf_arguments : min_arguments
  *  \param args   arguments to load
  *  \param ipath Path, where the arguments can be found.
  */
-static void load_args(estimate_ibf_arguments & args, std::filesystem::path ipath)
+[[maybe_unused]] static void load_args(estimate_ibf_arguments & args, std::filesystem::path ipath)
 {
     std::ifstream is{ipath, std::ios::binary};
     cereal::BinaryInputArchive iarchive{is};
@@ -86,7 +86,7 @@ static void load_args(estimate_ibf_arguments & args, std::filesystem::path ipath
  *  \param args  arguments to store
  *  \param opath Path, where the arguments should be stored.
  */
-static void store_args(estimate_ibf_arguments const & args, std::filesystem::path opath)
+[[maybe_unused]] static void store_args(estimate_ibf_arguments const & args, std::filesystem::path opath)
 {
     std::ofstream os{opath, std::ios::binary};
     cereal::BinaryOutputArchive oarchive{os};
@@ -124,5 +124,5 @@ void store_ibf(IBFType const & ibf,
 {
     std::ofstream os{opath, std::ios::binary};
     cereal::BinaryOutputArchive oarchive{os};
-    oarchive(seqan3::interleaved_bloom_filter(ibf));
+    oarchive(ibf);
 }
diff --git a/lib/robin-hood-hashing b/lib/robin-hood-hashing
deleted file mode 160000
index 915b7ab..0000000
--- a/lib/robin-hood-hashing
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 915b7abb5674f19439e36bf265669503f057b8fa
diff --git a/lib/seqan3 b/lib/seqan3
deleted file mode 160000
index 84938ed..0000000
--- a/lib/seqan3
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 84938edfa87a8f4a7b27032ac79a80f7422eb603
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 2e08676..e001b75 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,11 +1,10 @@
-cmake_minimum_required (VERSION 3.9)
+cmake_minimum_required (VERSION 3.25)
 
-find_package(OpenMP REQUIRED)
+find_package(OpenMP REQUIRED COMPONENTS CXX)
 add_library ("${PROJECT_NAME}_lib" STATIC ibf.cpp estimate.cpp)
 target_link_libraries ("${PROJECT_NAME}_lib" PUBLIC seqan3::seqan3)
-target_link_libraries ("${PROJECT_NAME}_lib" PUBLIC robin_hood)
+target_link_libraries ("${PROJECT_NAME}_lib" PUBLIC robin_hood::robin_hood)
 target_link_libraries("${PROJECT_NAME}_lib" PUBLIC OpenMP::OpenMP_CXX)
-
 target_include_directories ("${PROJECT_NAME}_lib" PUBLIC ../include)
 
 add_executable ("${PROJECT_NAME}" main.cpp)
diff --git a/src/estimate.cpp b/src/estimate.cpp
index 9896f12..1680bbf 100644
--- a/src/estimate.cpp
+++ b/src/estimate.cpp
@@ -53,7 +53,7 @@ void check_ibf(min_arguments const & args, IBFType const & ibf, std::vector<uint
     float minimiser_pos = minimiser_length/2.0;
 
     // Check every experiment by going over the number of bins in the ibf.
-    for(int j = 0; j < counter.size(); j++)
+    for(size_t j = 0; j < counter.size(); j++)
     {
         if (std::find(deleted.begin(), deleted.end(), j) != deleted.end())
             continue;
@@ -62,7 +62,7 @@ void check_ibf(min_arguments const & args, IBFType const & ibf, std::vector<uint
         // Check, if considering previously seen minimisers and minimisers found ar current level equal to or are greater
         // than the minimiser_pow, which gives the median position.
         // If ań estimation took already place (estimations_i[j]!=0), a second estimation is not performed.
-        if (((prev_counts[j] + counter[j]) >= minimiser_pos) & (estimations_i[j] == 0))
+        if (((prev_counts[j] + counter[j]) >= minimiser_pos) && (estimations_i[j] == 0))
         {
             // If there was no previous level, because we are looking at the last level.
             if constexpr(last_exp)
@@ -82,7 +82,7 @@ void check_ibf(min_arguments const & args, IBFType const & ibf, std::vector<uint
             }
 
             // Perform normalization by dividing through the threshold of the first level. Only works, if multiple expressions were used.
-            if constexpr (normalization & multiple_expressions)
+            if constexpr (normalization && multiple_expressions)
                 estimations_i[j] = estimations_i[j]/expressions[1][j];
         }
         else
@@ -101,7 +101,7 @@ void read_levels(std::vector<std::vector<float_or_int>> & expressions, std::file
     fin.open(filename);
     auto stream_view = seqan3::detail::istreambuf(fin);
     auto stream_it = std::ranges::begin(stream_view);
-    int j{0};
+    size_t j{0};
     std::vector<float_or_int> empty_vector{};
 
     std::string buffer{};
@@ -195,7 +195,7 @@ void estimate(estimate_ibf_arguments & args, IBFType & ibf, std::filesystem::pat
     counter.assign(ibf.bin_count(), 0);
     counter_est.assign(ibf.bin_count(), 0);
 
-    for (int i = 0; i < seqs.size(); ++i)
+    for (size_t i = 0; i < seqs.size(); ++i)
     {
         estimations.push_back(counter_est);
         prev_counts.push_back(counter);
@@ -205,9 +205,9 @@ void estimate(estimate_ibf_arguments & args, IBFType & ibf, std::filesystem::pat
 
     // Go over the sequences
     #pragma omp parallel for
-    for (int i = 0; i < seqs.size(); ++i)
+    for (size_t i = 0; i < seqs.size(); ++i)
     {
-        if constexpr (samplewise & normalization_method)
+        if constexpr (samplewise && normalization_method)
             check_ibf<IBFType, true, true>(args, ibf, estimations[i], seqs[i], prev_counts[i],
                                            expressions,args.number_expression_thresholds - 1,
                                            fprs[args.number_expression_thresholds - 1], deleted);
@@ -234,9 +234,9 @@ void estimate(estimate_ibf_arguments & args, IBFType & ibf, std::filesystem::pat
 
         // Go over the sequences
         #pragma omp parallel for
-        for (int i = 0; i < seqs.size(); ++i)
+        for (size_t i = 0; i < seqs.size(); ++i)
         {
-            if constexpr (samplewise & normalization_method)
+            if constexpr (samplewise && normalization_method)
                 check_ibf<IBFType, false, true>(args, ibf, estimations[i], seqs[i], prev_counts[i],
                                       expressions, j, fprs[j], deleted);
             else if constexpr (samplewise)
@@ -254,10 +254,10 @@ void estimate(estimate_ibf_arguments & args, IBFType & ibf, std::filesystem::pat
     // Write output file.
     std::ofstream outfile;
     outfile.open(std::string{file_out});
-    for (int i = 0; i <  seqs.size(); ++i)
+    for (size_t i = 0; i <  seqs.size(); ++i)
     {
         outfile << ids[i] << "\t";
-        for (int j = 0; j < ibf.bin_count(); ++j)
+        for (size_t j = 0; j < ibf.bin_count(); ++j)
              outfile << estimations[i][j] << "\t";
 
         outfile << "\n";
diff --git a/src/ibf.cpp b/src/ibf.cpp
index 07d9b4a..67706ab 100644
--- a/src/ibf.cpp
+++ b/src/ibf.cpp
@@ -118,7 +118,7 @@ void fill_hash_table(min_arguments const & args,
     {
         for (auto && minHash : seqan3::views::minimiser_hash(seq, args.shape, args.w_size, args.s))
         {
-            if ((only_include & (include_set_table.contains(minHash))) | (!only_include) & !(exclude_set_table.contains(minHash)))
+            if ((only_include && include_set_table.contains(minHash)) || (!only_include && !exclude_set_table.contains(minHash)))
             {
                 auto it = hash_table.find(minHash);
                 // If minHash is already in hash table, increase count in hash table
@@ -158,9 +158,7 @@ void fill_hash_table_parallel(min_arguments const & args,
                               uint8_t cutoff = 0)
 {
     using value_t = typename robin_hood::unordered_node_map<uint64_t, uint16_t>::value_type;
-    using value_t2 = typename robin_hood::unordered_node_map<uint64_t, uint8_t>::value_type;
     using local_hash_table_t = robin_hood::unordered_node_map<uint64_t, std::atomic<uint16_t>>;
-    using local_cutoff_table_t = robin_hood::unordered_node_map<uint64_t, std::atomic<uint8_t>>;
 
     // Step 1: load file in batches
     // Step 2: construct minimiser hash values
@@ -172,7 +170,6 @@ void fill_hash_table_parallel(min_arguments const & args,
     // Run thread: block execution and load next 10000 sequences.
 
     auto seq_file_it = std::ranges::begin(fin);
-    size_t chunk_count{};
     using sequence_t = seqan3::dna4_vector;
 
     auto load_next_chunk = [&] ()
@@ -210,7 +207,7 @@ void fill_hash_table_parallel(min_arguments const & args,
             // minimiser_it now points to the first non equal position
             size_t const minimiser_count = std::ranges::distance(minimiser_it, next_minimiser_it);
 
-            if ((only_include && (include_set_table.contains(current_minimiser))) || (!only_include) && !(exclude_set_table.contains(current_minimiser)))
+            if ((only_include && (include_set_table.contains(current_minimiser))) || (!only_include && !exclude_set_table.contains(current_minimiser)))
             {
                 if (auto it = local_hash_table.find(current_minimiser); it != local_hash_table.end()) // update
                 {
@@ -237,11 +234,9 @@ void fill_hash_table_parallel(min_arguments const & args,
     std::vector<local_hash_table_t> thread_local_hash_tables{};
     thread_local_hash_tables.resize(thread_count);
     bool is_merged{false};
-    bool fill_queue{true};
 
-    seqan3::detail::latch sync_point{thread_count};
-    seqan3::detail::latch sync_point_2{thread_count};
-    std::atomic<size_t> remaining_minimisers_size{};
+    seqan3::detail::latch sync_point{static_cast<std::ptrdiff_t>(thread_count)};
+    seqan3::detail::latch sync_point_2{static_cast<std::ptrdiff_t>(thread_count)};
     std::mutex load_mutex{};
     std::vector<std::pair<size_t, size_t>> intervals{};
     std::optional<seqan3::contrib::fixed_buffer_queue<std::pair<size_t, size_t>>> queue;
@@ -311,7 +306,7 @@ void fill_hash_table_parallel(min_arguments const & args,
                     // minimiser_it now points to the first non equal position
                     size_t const minimiser_count = std::ranges::distance(minimiser_it, next_minimiser_it);
 
-                    if ((only_include && (include_set_table.contains(current_minimiser))) || (!only_include) && !(exclude_set_table.contains(current_minimiser)))
+                    if ((only_include && (include_set_table.contains(current_minimiser))) || (!only_include && !exclude_set_table.contains(current_minimiser)))
                     {
                         if (auto it = hash_table.find(current_minimiser); it != hash_table.end()) // update
                         {
@@ -410,10 +405,9 @@ void count(min_arguments const & args, std::vector<std::filesystem::path> sequen
     robin_hood::unordered_set<uint64_t> include_set_table{};
     robin_hood::unordered_set<uint64_t> exclude_set_table{};
     std::vector<uint64_t> counter{};
-    uint64_t exp{};
+    uint64_t expression{};
     std::ifstream infile;
     std::ofstream outfile;
-    int j;
 
     // Read minimiser from binary
     infile.open(genome_file, std::ios::binary);
@@ -443,7 +437,6 @@ void count(min_arguments const & args, std::vector<std::filesystem::path> sequen
         cutoff_table.clear();
 
         outfile.open(std::string{args.path_out} + std::string{sequence_files[i].stem()} + ".count.out");
-        j = 0;
         seqan3::sequence_file_input<my_traits,  seqan3::fields<seqan3::field::id, seqan3::field::seq>> fin2{include_file};
         for (auto & [id, seq] : fin2)
         {
@@ -452,10 +445,9 @@ void count(min_arguments const & args, std::vector<std::filesystem::path> sequen
                 for (auto && minHash : seqan3::views::minimiser_hash(seq, args.shape, args.w_size, args.s))
                     counter.push_back(hash_table[minHash]);
                 std::nth_element(counter.begin(), counter.begin() + counter.size()/2, counter.end());
-                exp =  counter[counter.size()/2];
+                expression = counter[counter.size()/2];
+                outfile << id << "\t" << expression << "\n";
                 counter.clear();
-                outfile << id << "\t" << exp << "\n";
-                ++j;
             }
         }
         outfile.close();
@@ -465,22 +457,21 @@ void count(min_arguments const & args, std::vector<std::filesystem::path> sequen
 
 void read_binary(std::filesystem::path filename, robin_hood::unordered_node_map<uint64_t, uint16_t> & hash_table)
 {
-    std::ifstream fin;
+    std::ifstream fin{filename, std::ios::binary};
+
+    // Skip the first 22 bytes:
+    //   8 num_of_minimisers
+    //   1 cutoff
+    //   1 args.k
+    //   4 args.w_size
+    //   8 args.s
+    fin.ignore(22);
 
-    uint8_t small_buffer;
-    uint32_t window;
-    uint64_t buffer;
-    fin.open(filename, std::ios::binary);
-    fin.read((char*)&buffer, sizeof(buffer));
-    fin.read((char*)&small_buffer, sizeof(small_buffer));
-    fin.read((char*)&small_buffer, sizeof(small_buffer));
-    fin.read((char*)&window, sizeof(window));
-    fin.read((char*)&buffer, sizeof(buffer));
     bool ungapped;
     fin.read((char*)&ungapped, sizeof(ungapped));
     if (!ungapped)
     {
-        fin.read((char*)&buffer, sizeof(buffer));
+        fin.ignore(8); // args.shape
     }
 
     uint64_t minimiser;
@@ -499,22 +490,13 @@ void read_binary_start(min_arguments & args,
                  std::filesystem::path filename,
                  uint64_t & num_of_minimisers, uint8_t & cutoff)
 {
-    std::ifstream fin;
+    std::ifstream fin{filename, std::ios::binary};
 
-    uint32_t window;
-    uint64_t buffer;
-    uint8_t small_buffer;
-    fin.open(filename, std::ios::binary);
-    fin.read((char*)&buffer, sizeof(buffer));
-    num_of_minimisers = buffer;
-
-    fin.read((char*)&small_buffer, sizeof(small_buffer));
-    cutoff = small_buffer;
+    fin.read((char*)&num_of_minimisers, sizeof(num_of_minimisers));
+    fin.read((char*)&cutoff, sizeof(cutoff));
     fin.read((char*)&args.k, sizeof(args.k));
-    fin.read((char*)&window, sizeof(window));
-    args.w_size = seqan3::window_size{window};
-    fin.read((char*)&buffer, sizeof(buffer));
-    args.s = seqan3::seed{buffer};
+    fin.read((char*)&args.w_size, sizeof(args.w_size));
+    fin.read((char*)&args.s, sizeof(args.s));
 
     bool ungapped;
     fin.read((char*)&ungapped, sizeof(ungapped));
@@ -524,8 +506,7 @@ void read_binary_start(min_arguments & args,
     }
     else
     {
-        fin.read((char*)&buffer, sizeof(buffer));
-        args.shape = seqan3::bin_literal{buffer};
+        fin.read((char*)&args.shape, sizeof(args.shape));
     }
 
     fin.close();
@@ -539,11 +520,11 @@ void check_expression(std::vector<uint16_t> & expression_thresholds, uint8_t & n
     sort(expression_thresholds.begin(), expression_thresholds.end());
 
      // If no expression levels are given and the no number of expression levels is specified, throw.
-    if ((number_expression_thresholds == 0) & (expression_thresholds.size() == 0))
+    if ((number_expression_thresholds == 0) && (expression_thresholds.size() == 0))
     {
         throw std::invalid_argument{"Error. Please set the expression levels OR give the number of expression levels."};
     }
-    else if ((expression_by_genome_file != "") & (expression_thresholds.size() > 0))
+    else if ((expression_by_genome_file != "") && (expression_thresholds.size() > 0))
     {
         throw std::invalid_argument{"Error. The determination of expression levels can not be used with individual levels"
                                     " already given. Please set the expression levels without the option "
@@ -553,7 +534,7 @@ void check_expression(std::vector<uint16_t> & expression_thresholds, uint8_t & n
     {
         number_expression_thresholds = expression_thresholds.size();
     }
-    else if ((number_expression_thresholds != expression_thresholds.size()) & (expression_thresholds.size() > 0))
+    else if ((number_expression_thresholds != expression_thresholds.size()) && (expression_thresholds.size() > 0))
     {
         throw std::invalid_argument{"Error. Please set the expression levels OR give the number of expression levels."};
     }
@@ -573,7 +554,7 @@ void check_cutoffs_samples(std::vector<std::filesystem::path> const & sequence_f
         cutoffs.assign(samples.size(), cutoffs[0]);
 
     // If sum of minimiser_args.samples is not equal to number of files, throw error
-    else if (std::accumulate(samples.rbegin(), samples.rend(), 0) != sequence_files.size())
+    else if (std::accumulate(samples.rbegin(), samples.rend(), size_t{}) != sequence_files.size())
         throw std::invalid_argument{"Error. Incorrect command line input for multiple-samples."};
 }
 
@@ -588,7 +569,8 @@ void check_fpr(uint8_t const number_expression_thresholds, std::vector<double> &
     // If only one ibf size is given, set it for all thresholds.
     if (fprs.size() == 1)
     {
-        fprs.assign(number_expression_thresholds, fprs[0]);
+        double const fpr = fprs[0];
+        fprs.assign(number_expression_thresholds, fpr);
     }
     else if (fprs.size() != number_expression_thresholds)
     {
@@ -607,7 +589,7 @@ void get_expression_thresholds(uint8_t const number_expression_thresholds,
     std::vector<uint16_t> counts;
     for (auto && elem : hash_table)
     {
-        if (all | genome.contains(elem.first))
+        if (all || genome.contains(elem.first))
             counts.push_back(elem.second);
     }
 
@@ -626,7 +608,7 @@ void get_expression_thresholds(uint8_t const number_expression_thresholds,
     expression_thresholds.push_back(exp);
     sizes.push_back(prev_pos);
 
-    while((expression_thresholds.size() < number_expression_thresholds) & (prev_exp < max_elem) & (dev < counts.size()))
+    while((expression_thresholds.size() < number_expression_thresholds) && (prev_exp < max_elem) && (dev < counts.size()))
     {
         std::nth_element(counts.begin() + prev_pos, counts.begin() +  prev_pos + counts.size()/dev, counts.end());
         exp = counts[prev_pos + counts.size()/dev];
@@ -679,7 +661,7 @@ void get_filsize_per_expression_level(std::filesystem::path filename, uint8_t co
     while(fin.read((char*)&minimiser, sizeof(minimiser)))
     {
         fin.read((char*)&minimiser_count, sizeof(minimiser_count));
-        if (all | genome.contains(minimiser))
+        if (all || genome.contains(minimiser))
         {
             // Find the level with the smallest greater value than the minimiser occurrence, in the level before that the
             // minimiser is going to be stored.
@@ -696,7 +678,7 @@ void get_filsize_per_expression_level(std::filesystem::path filename, uint8_t co
 template<bool samplewise, bool minimiser_files_given = true>
 void ibf_helper(std::vector<std::filesystem::path> const & minimiser_files,
                 std::vector<double> const & fprs,
-                estimate_ibf_arguments & ibf_args, std::vector<uint8_t> & cutoffs = {},
+                estimate_ibf_arguments & ibf_args, std::vector<uint8_t> & cutoffs,
                 size_t num_hash = 1, std::filesystem::path expression_by_genome_file = "",
                 minimiser_arguments const & minimiser_args = {})
 {
@@ -781,7 +763,7 @@ void ibf_helper(std::vector<std::filesystem::path> const & minimiser_files,
         if constexpr (samplewise)
         {
             uint64_t diff{1};
-            for (std::size_t c = 0; c < ibf_args.number_expression_thresholds - 1; c++)
+            for (int c = 0; c < ibf_args.number_expression_thresholds - 1; c++)
             {
                 diff = diff * 2;
                 sizes[i].push_back(filesize/diff);
@@ -796,7 +778,7 @@ void ibf_helper(std::vector<std::filesystem::path> const & minimiser_files,
         else
         {
             float diff{1};
-            for (std::size_t c = 0; c < ibf_args.number_expression_thresholds - 1; c++)
+            for (int c = 0; c < ibf_args.number_expression_thresholds - 1; c++)
             {
                 diff = ibf_args.expression_thresholds[c+1]/ibf_args.expression_thresholds[c];
                 sizes[i].push_back(filesize/diff);
@@ -847,7 +829,7 @@ void ibf_helper(std::vector<std::filesystem::path> const & minimiser_files,
         else
         {
             unsigned file_iterator = std::accumulate(minimiser_args.samples.begin(), minimiser_args.samples.begin() + i, 0);
-            for (unsigned f = 0; f < minimiser_args.samples[i]; f++)
+            for (int f = 0; f < minimiser_args.samples[i]; f++)
             {
                seqan3::sequence_file_input<my_traits, seqan3::fields<seqan3::field::seq>> fin{minimiser_files[file_iterator+f]};
                if (minimiser_args.ram_friendly)
@@ -1023,7 +1005,7 @@ void read_levels(std::vector<std::vector<float_or_int>> & expressions, std::file
     fin.open(filename);
     auto stream_view = seqan3::detail::istreambuf(fin);
     auto stream_it = std::ranges::begin(stream_view);
-    int j{0};
+    size_t j{0};
     std::vector<float_or_int> empty_vector{};
 
     std::string buffer{};
@@ -1057,7 +1039,7 @@ void read_levels(std::vector<std::vector<float_or_int>> & expressions, std::file
 // Actual insertion
 template<bool samplewise, bool minimiser_files_given = true>
 void insert_helper(std::vector<std::filesystem::path> const & minimiser_files,
-                   estimate_ibf_arguments & ibf_args, std::filesystem::path path_in, std::vector<uint8_t> & cutoffs = {},
+                   estimate_ibf_arguments & ibf_args, std::filesystem::path path_in, std::vector<uint8_t> & cutoffs,
                    std::filesystem::path expression_by_genome_file = "",
                    minimiser_arguments const & minimiser_args = {})
 {
@@ -1186,7 +1168,7 @@ void insert_helper(std::vector<std::filesystem::path> const & minimiser_files,
             filesize = std::filesystem::file_size(minimiser_files[file_iterator]) * minimiser_args.samples[i] * (is_fasta ? 2 : 1) / (is_compressed ? 1 : 3);
             filesize = filesize/((cutoffs[i] + 1) * (is_fasta ? 1 : 2));
 
-            for (unsigned f = 0; f < minimiser_args.samples[i]; f++)
+            for (int f = 0; f < minimiser_args.samples[i]; f++)
             {
                seqan3::sequence_file_input<my_traits, seqan3::fields<seqan3::field::seq>> fin{minimiser_files[file_iterator+f]};
                if (minimiser_args.ram_friendly)
@@ -1370,7 +1352,7 @@ void delete_bin(std::vector<uint64_t> const & delete_files,
     load_args(ibf_args, std::string{path_in} + "IBF_Data");
 
     std::vector<seqan3::bin_index> bins_to_delete{};
-    for (int i = 0; i< delete_files.size(); i++)
+    for (size_t i = 0; i< delete_files.size(); i++)
         bins_to_delete.push_back(seqan3::bin_index{delete_files[i]});
 
     omp_set_num_threads(ibf_args.threads);
@@ -1393,11 +1375,11 @@ void delete_bin(std::vector<uint64_t> const & delete_files,
             filename = ibf_args.path_out.string() + "IBF_Level_" + std::to_string(i);
         else
             filename = ibf_args.path_out.string() + "IBF_" + std::to_string(ibf_args.expression_thresholds[i]);
-        
+
 	if (ibf_args.compressed)
         {
-            seqan3::interleaved_bloom_filter<seqan3::data_layout::compressed> ibf{ibf};
-            store_ibf(ibf, filename);
+            seqan3::interleaved_bloom_filter<seqan3::data_layout::compressed> ibfc{std::move(ibf)};
+            store_ibf(ibfc, filename);
         }
         else
         {
@@ -1408,9 +1390,9 @@ void delete_bin(std::vector<uint64_t> const & delete_files,
     // Store deleted bins
     std::ofstream outfile;
     outfile.open(std::string{ibf_args.path_out} + "IBF_Deleted");
-    for (unsigned j = 0; j < ibf_args.number_expression_thresholds; j++)
+    for (auto & deleted : delete_files)
     {
-        outfile << delete_files[j] << ",";
+        outfile << deleted << ",";
     }
     outfile << "\n";
     outfile.close();
@@ -1428,7 +1410,6 @@ void calculate_minimiser(std::vector<std::filesystem::path> const & sequence_fil
                          std::vector<uint8_t> & cutoffs)
 {
     robin_hood::unordered_node_map<uint64_t, uint16_t> hash_table{}; // Storage for minimisers
-    uint16_t count{0};
     uint8_t cutoff{0};
 
     // Create a smaller cutoff table to save RAM, this cutoff table is only used for constructing the hash table
@@ -1445,7 +1426,7 @@ void calculate_minimiser(std::vector<std::filesystem::path> const & sequence_fil
         cutoff = cutoffs[i];
 
     // Fill hash_table with minimisers.
-    for (unsigned f = 0; f < minimiser_args.samples[i]; f++)
+    for (int f = 0; f < minimiser_args.samples[i]; f++)
     {
         seqan3::sequence_file_input<my_traits, seqan3::fields<seqan3::field::seq>> fin{sequence_files[file_iterator+f]};
         if constexpr (parallel)
@@ -1467,15 +1448,14 @@ void calculate_minimiser(std::vector<std::filesystem::path> const & sequence_fil
     outfile.write(reinterpret_cast<const char*>(&hash_size), sizeof(hash_size));
     outfile.write(reinterpret_cast<const char*>(&cutoff), sizeof(cutoff));
     outfile.write(reinterpret_cast<const char*>(&args.k), sizeof(args.k));
-    outfile.write(reinterpret_cast<const char*>(&args.w_size.get()), sizeof(args.w_size.get()));
-    outfile.write(reinterpret_cast<const char*>(&args.s.get()), sizeof(args.s.get()));
+    outfile.write(reinterpret_cast<const char*>(&args.w_size), sizeof(args.w_size));
+    outfile.write(reinterpret_cast<const char*>(&args.s), sizeof(args.s));
     bool ungapped = args.shape.all();
     outfile.write(reinterpret_cast<const char*>(&ungapped), sizeof(ungapped));
 
     if (!ungapped)
     {
-        uint64_t shapesize = args.shape.to_ulong();
-        outfile.write(reinterpret_cast<const char*>(&shapesize), sizeof(shapesize));
+        outfile.write(reinterpret_cast<const char*>(&args.shape), sizeof(args.shape));
     }
 
     for (auto && hash : hash_table)
diff --git a/src/main.cpp b/src/main.cpp
index 9539a00..3c2927f 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -130,7 +130,6 @@ int run_needle_count_genome(seqan3::argument_parser & parser)
     std::filesystem::path genome_file;
     std::filesystem::path exclude_file{""};
     std::filesystem::path out_path = "./";
-    bool paired = false;
 
     parser.info.short_description = "Creates the genome file necessary as an input to count.";
     parser.add_positional_option(genome_file, "Please provide one sequence file with transcripts.");
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 3a86f2c..2b1048c 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,102 +1,18 @@
-cmake_minimum_required (VERSION 3.9)
+# SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
+# SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
+# SPDX-License-Identifier: CC0-1.0
 
-# Set directories for test output files, input data and binaries.
-file (MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/output)
-add_definitions (-DOUTPUTDIR=\"${CMAKE_CURRENT_BINARY_DIR}/output/\")
-add_definitions (-DDATADIR=\"${CMAKE_CURRENT_BINARY_DIR}/data/\")
-add_definitions (-DBINDIR=\"${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/\")
-add_definitions (-DDATA_INPUT_DIR=\"${CMAKE_CURRENT_SOURCE_DIR}/data/\")
+cmake_minimum_required (VERSION 3.25)
 
-# Define cmake configuration flags to configure and build external projects with the same flags as specified for
-# this project.
-set (APP_TEMPLATE_EXTERNAL_PROJECT_CMAKE_ARGS "")
-list (APPEND APP_TEMPLATE_EXTERNAL_PROJECT_CMAKE_ARGS "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}")
-list (APPEND APP_TEMPLATE_EXTERNAL_PROJECT_CMAKE_ARGS "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
-list (APPEND APP_TEMPLATE_EXTERNAL_PROJECT_CMAKE_ARGS "-DCMAKE_INSTALL_PREFIX=${PROJECT_BINARY_DIR}")
-list (APPEND APP_TEMPLATE_EXTERNAL_PROJECT_CMAKE_ARGS "-DCMAKE_VERBOSE_MAKEFILE=${CMAKE_VERBOSE_MAKEFILE}")
+# This includes `cmake/test/config.cmake` which takes care of setting up the test infrastructure. It also provides
+# the `add_app_test` macro, which is used to add tests to the CMake test suite.
+include (test/config)
 
-# Define cmake configuration flags to configure and build external projects with the same flags as specified for
-# this project.
-set (SEQAN3_EXTERNAL_PROJECT_CMAKE_ARGS "")
-list (APPEND SEQAN3_EXTERNAL_PROJECT_CMAKE_ARGS "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}")
-list (APPEND SEQAN3_EXTERNAL_PROJECT_CMAKE_ARGS "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
-list (APPEND SEQAN3_EXTERNAL_PROJECT_CMAKE_ARGS "-DCMAKE_INSTALL_PREFIX=${PROJECT_BINARY_DIR}")
-list (APPEND SEQAN3_EXTERNAL_PROJECT_CMAKE_ARGS "-DCMAKE_VERBOSE_MAKEFILE=${CMAKE_VERBOSE_MAKEFILE}")
-set (SEQAN3_TEST_CLONE_DIR "${PROJECT_BINARY_DIR}/vendor/googletest")
-
-include ("${SEQAN3_CLONE_DIR}/test/cmake/seqan3_require_test.cmake")
-
-seqan3_require_test ()
-
-# Build tests just before their execution, because they have not been built with "all" target.
-# The trick is here to provide a cmake file as a directory property that executes the build command.
-file (WRITE "${CMAKE_CURRENT_BINARY_DIR}/build_test_targets.cmake"
-            "execute_process(COMMAND ${CMAKE_COMMAND} --build . --target api_test)\n"
-            "execute_process(COMMAND ${CMAKE_COMMAND} --build . --target cli_test)")
-set_directory_properties (PROPERTIES TEST_INCLUDE_FILE "${CMAKE_CURRENT_BINARY_DIR}/build_test_targets.cmake")
-
-# Define the test targets. All depending targets are built just before the test execution.
-add_custom_target (api_test)
-add_custom_target (cli_test)
-
-# Test executables and libraries should not mix with the application files.
-unset (CMAKE_ARCHIVE_OUTPUT_DIRECTORY)
-unset (CMAKE_LIBRARY_OUTPUT_DIRECTORY)
-unset (CMAKE_RUNTIME_OUTPUT_DIRECTORY)
-
-# A macro that adds an api or cli test.
-macro (add_app_test test_filename test_alternative)
-    # Extract the test target name.
-    file (RELATIVE_PATH source_file "${CMAKE_SOURCE_DIR}" "${CMAKE_CURRENT_LIST_DIR}/${test_filename}")
-    get_filename_component (target "${source_file}" NAME_WE)
-
-    # Create the test target.
-    add_executable (${target} ${test_filename})
-    target_link_libraries (${target} "${PROJECT_NAME}_lib" seqan3::seqan3 gtest gtest_main)
-
-    # Make seqan3::test available for both cli and api tests.
-    target_include_directories(${target} PUBLIC "${SEQAN3_CLONE_DIR}/test/include")
-    target_include_directories(${target} PUBLIC "${SEQAN3_TEST_CLONE_DIR}/googletest/include/")
-
-    # Make seqan3::test available for both cli and api tests.
-    target_include_directories(${target} PUBLIC "${SEQAN3_CLONE_DIR}/test/include")
-
-    # Add the test to its general target (cli or api).
-    if (${test_alternative} STREQUAL "CLI_TEST")
-        add_dependencies (${target} "${PROJECT_NAME}") # cli test needs the application executable
-        add_dependencies (cli_test ${target})
-    elseif (${test_alternative} STREQUAL "API_TEST")
-        add_dependencies (api_test ${target})
-    endif ()
-
-    # Generate and set the test name.
-    get_filename_component (target_relative_path "${source_file}" DIRECTORY)
-    if (target_relative_path)
-        set (test_name "${target_relative_path}/${target}")
-    else ()
-        set (test_name "${target}")
-    endif ()
-    add_test (NAME "${test_name}" COMMAND ${target})
-
-    unset (source_file)
-    unset (target)
-    unset (test_name)
-endmacro ()
-
-# A macro that adds an api test.
-macro (add_api_test test_filename)
-    add_app_test (${test_filename} API_TEST)
-endmacro ()
-
-# A macro that adds a cli test.
-macro (add_cli_test test_filename)
-    add_app_test (${test_filename} CLI_TEST)
-endmacro ()
-
-# Fetch data and add the tests.
+# This includes `test/data/datasources.cmake`, which makes test data available to the tests.
 include (data/datasources.cmake)
+
 add_subdirectory (api)
 add_subdirectory (cli)
-add_subdirectory (coverage)
 
-message (STATUS "${FontBold}You can run `make test` to build and run tests.${FontReset}")
+message (STATUS "You can run `make tests` to build tests.")
+message (STATUS "You can run `make check` to build and run tests.")
diff --git a/test/api/CMakeLists.txt b/test/api/CMakeLists.txt
index d352507..105e00b 100644
--- a/test/api/CMakeLists.txt
+++ b/test/api/CMakeLists.txt
@@ -1,9 +1,12 @@
-cmake_minimum_required (VERSION 3.9)
+# SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
+# SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
+# SPDX-License-Identifier: CC0-1.0
 
-# The api_test build target.
-add_api_test (count_test.cpp)
-add_api_test (insert_delete_test.cpp)
-add_api_test (estimate_test.cpp)
-add_api_test (ibf_test.cpp)
-add_api_test (ibfmin_test.cpp)
-add_api_test (minimiser_test.cpp)
+cmake_minimum_required (VERSION 3.25)
+
+add_app_test (count_test.cpp)
+add_app_test (insert_delete_test.cpp)
+add_app_test (estimate_test.cpp)
+add_app_test (ibf_test.cpp)
+add_app_test (ibfmin_test.cpp)
+add_app_test (minimiser_test.cpp)
diff --git a/test/api/count_test.cpp b/test/api/count_test.cpp
index 3bde843..0b43380 100644
--- a/test/api/count_test.cpp
+++ b/test/api/count_test.cpp
@@ -5,33 +5,31 @@
 
 #include "ibf.h"
 #include "shared.h"
+#include "../app_test.hpp"
 
-#ifndef DATA_INPUT_DIR
-#  define DATA_INPUT_DIR @DATA_INPUT_DIR@
-#endif
-
-using seqan3::operator""_shape;
-std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
-
-void initialization_args(estimate_ibf_arguments & args)
+// To prevent issues when running multiple CLI tests in parallel, give each CLI test unique names:
+struct count_test : public app_test
 {
-    args.compressed = true;
-    args.k = 4;
-    args.shape = seqan3::ungapped{args.k};
-    args.w_size = seqan3::window_size{4};
-    args.s = seqan3::seed{0};
-    args.path_out = tmp_dir/"Count_Test_";
-}
+    void initialization_args(estimate_ibf_arguments & args)
+    {
+        args.compressed = true;
+        args.k = 4;
+        args.shape = seqan3::ungapped{args.k};
+        args.w_size = seqan3::window_size{4};
+        args.s = seqan3::seed{0};
+        args.path_out = "Count_Test_";
+    }
+};
 
-TEST(count, small_example)
+TEST_F(count_test, small_example)
 {
     estimate_ibf_arguments args{};
     initialization_args(args);
 
-    count(args, {std::string(DATA_INPUT_DIR) + "mini_example.fasta"}, std::string(DATA_INPUT_DIR) + "mini_gen.fasta",
-          std::string(DATA_INPUT_DIR) + "mini_gen.genome", false);
+    count(args, {data("mini_example.fasta")}, data("mini_gen.fasta"),
+          data("mini_gen.genome"), false);
 
-    std::ifstream output_file(tmp_dir/"mini_example.count.out");
+    std::ifstream output_file("mini_example.count.out");
     std::string line;
     std::string expected{"gen1\t3"};
     if (output_file.is_open())
@@ -42,18 +40,17 @@ TEST(count, small_example)
         }
         output_file.close();
     }
-    std::filesystem::remove(tmp_dir/"Count_Test_mini_example.count.out");
 }
 
-TEST(count, small_example_paired)
+TEST_F(count_test, small_example_paired)
 {
     estimate_ibf_arguments args{};
     initialization_args(args);
 
-    count(args, {std::string(DATA_INPUT_DIR) + "mini_example.fasta", std::string(DATA_INPUT_DIR) + "mini_example.fasta"},
-          std::string(DATA_INPUT_DIR) + "mini_gen.fasta", std::string(DATA_INPUT_DIR) + "mini_gen.genome", true);
+    count(args, {data("mini_example.fasta"), data("mini_example.fasta")},
+          data("mini_gen.fasta"), data("mini_gen.genome"), true);
 
-    std::ifstream output_file(tmp_dir/"mini_example.count.out");
+    std::ifstream output_file("mini_example.count.out");
     std::string line;
     std::string expected{"gen1\t6"};
     if (output_file.is_open())
@@ -64,18 +61,17 @@ TEST(count, small_example_paired)
         }
         output_file.close();
     }
-    std::filesystem::remove(tmp_dir/"Count_Test_mini_example.count.out");
 }
 
-TEST(count, small_example_exclude)
+TEST_F(count_test, small_example_exclude)
 {
     estimate_ibf_arguments args{};
     initialization_args(args);
 
-    count(args, {std::string(DATA_INPUT_DIR) + "mini_example.fasta"}, std::string(DATA_INPUT_DIR) + "mini_gen.fasta",
-                 std::string(DATA_INPUT_DIR) + "mini_gen2.genome", false);
+    count(args, {data("mini_example.fasta")}, data("mini_gen.fasta"),
+                 data("mini_gen2.genome"), false);
 
-    std::ifstream output_file(tmp_dir/"mini_example.count.out");
+    std::ifstream output_file("mini_example.count.out");
     std::string line;
     std::string expected{"gen1\t3"};
     if (output_file.is_open())
@@ -86,19 +82,19 @@ TEST(count, small_example_exclude)
         }
         output_file.close();
     }
-    std::filesystem::remove(tmp_dir/"Count_Test_mini_example.count.out");
+
 }
 
-TEST(genome, small_example)
+TEST_F(count_test, genome_small_example)
 {
     estimate_ibf_arguments args{};
     initialization_args(args);
 
-    count_genome(args, std::string(DATA_INPUT_DIR) + "mini_gen.fasta", std::string(DATA_INPUT_DIR) + "mini_gen2.fasta");
+    count_genome(args, data("mini_gen.fasta"), data("mini_gen2.fasta"));
 
     std::ifstream output_file;
     uint64_t expected{192};
-    output_file.open(tmp_dir/"mini_gen.genome", std::ios::binary);
+    output_file.open("mini_gen.genome", std::ios::binary);
     uint64_t minimiser;
     while(output_file.read((char*)&minimiser, sizeof(minimiser)))
     {
diff --git a/test/api/estimate_test.cpp b/test/api/estimate_test.cpp
index 2674eb6..d0441c6 100644
--- a/test/api/estimate_test.cpp
+++ b/test/api/estimate_test.cpp
@@ -6,42 +6,40 @@
 #include "ibf.h"
 #include "shared.h"
 #include "estimate.h"
+#include "../app_test.hpp"
 
-#ifndef DATA_INPUT_DIR
-#  define DATA_INPUT_DIR @DATA_INPUT_DIR@
-#endif
-
-using seqan3::operator""_shape;
-
-void initialization_args(estimate_ibf_arguments & args)
+// To prevent issues when running multiple CLI tests in parallel, give each CLI test unique names:
+struct estimate_test : public app_test
 {
-    args.compressed = true;
-    args.k = 4;
-    args.shape = seqan3::ungapped{args.k};
-    args.w_size = seqan3::window_size{4};
-    args.s = seqan3::seed{0};
-}
+    void initialization_args(estimate_ibf_arguments & args)
+    {
+        args.compressed = true;
+        args.k = 4;
+        args.shape = seqan3::ungapped{args.k};
+        args.w_size = seqan3::window_size{4};
+        args.s = seqan3::seed{0};
+        args.path_out = "Estimate_Test_";
+    }
+};
 
-TEST(estimate, small_example)
+TEST_F(estimate_test, small_example)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     minimiser_arguments minimiser_args{};
     estimate_arguments estimate_args{};
     initialization_args(ibf_args);
-    ibf_args.path_out = tmp_dir/"Estimate_Test_";
     ibf_args.expression_thresholds = {1, 2, 4};
     std::vector<double> fpr = {0.05};
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta"};
-    estimate_args.search_file = std::string(DATA_INPUT_DIR) + "mini_gen.fasta";
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta")};
+    estimate_args.search_file = data("mini_gen.fasta");
     estimate_args.path_in = ibf_args.path_out;
     std::vector<uint8_t> cutoffs{};
 
     ibf(sequence_files, ibf_args, minimiser_args, fpr, cutoffs);
-    ibf_args.path_out = tmp_dir/"expression.out";
+    ibf_args.path_out = "expression.out";
     call_estimate(ibf_args, estimate_args);
 
-    std::ifstream output_file(tmp_dir/"expression.out");
+    std::ifstream output_file("expression.out");
     std::string line;
     std::string expected{"gen1\t3\t"};
     if (output_file.is_open())
@@ -52,34 +50,27 @@ TEST(estimate, small_example)
         }
         output_file.close();
     }
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_2");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_4");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_Data");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/"expression.out");
 }
 
-TEST(estimate, small_example_uncompressed)
+TEST_F(estimate_test, small_example_uncompressed)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     minimiser_arguments minimiser_args{};
     estimate_arguments estimate_args{};
     initialization_args(ibf_args);
-    ibf_args.path_out = tmp_dir/"Estimate_Test_";
     ibf_args.compressed = false;
     ibf_args.expression_thresholds = {1, 2, 4};
     std::vector<double> fpr = {0.05};
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta"};
-    estimate_args.search_file = std::string(DATA_INPUT_DIR) + "mini_gen.fasta";
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta")};
+    estimate_args.search_file = data("mini_gen.fasta");
     estimate_args.path_in = ibf_args.path_out;
     std::vector<uint8_t> cutoffs{};
 
     ibf(sequence_files, ibf_args, minimiser_args, fpr, cutoffs);
-    ibf_args.path_out = tmp_dir/"expression.out";
+    ibf_args.path_out = "expression.out";
     call_estimate(ibf_args, estimate_args);
 
-    std::ifstream output_file(tmp_dir/"expression.out");
+    std::ifstream output_file("expression.out");
     std::string line;
     std::string expected{"gen1\t3\t"};
     if (output_file.is_open())
@@ -90,34 +81,26 @@ TEST(estimate, small_example_uncompressed)
         }
         output_file.close();
     }
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_1");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_2");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_4");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_Data");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/"expression.out");
 }
 
-TEST(estimate, small_example_gene_not_found)
+TEST_F(estimate_test, small_example_gene_not_found)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     minimiser_arguments minimiser_args{};
     estimate_arguments estimate_args{};
     initialization_args(ibf_args);
-    ibf_args.path_out = tmp_dir/"Estimate_Test_";
     ibf_args.expression_thresholds = {2, 4};
-    estimate_args.search_file = std::string(DATA_INPUT_DIR) + "mini_gen2.fasta";
+    estimate_args.search_file = data("mini_gen2.fasta");
     estimate_args.path_in = ibf_args.path_out;
     std::vector<double> fpr = {0.05};
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta"};
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta")};
     std::vector<uint8_t> cutoffs{};
 
     ibf(sequence_files, ibf_args, minimiser_args, fpr, cutoffs);
-    ibf_args.path_out = tmp_dir/"expression.out";
+    ibf_args.path_out = "expression.out";
     call_estimate(ibf_args, estimate_args);
 
-    std::ifstream output_file(tmp_dir/"expression.out");
+    std::ifstream output_file("expression.out");
     std::string line;
     std::string expected{"gen2\t0\t"};
     if (output_file.is_open())
@@ -128,38 +111,32 @@ TEST(estimate, small_example_gene_not_found)
         }
         output_file.close();
     }
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_2");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_4");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_Data");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/"expression.out");
 }
 
-TEST(estimate, small_example_different_expressions_per_level)
+TEST_F(estimate_test, small_example_different_expressions_per_level)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     minimiser_arguments minimiser_args{};
     estimate_arguments estimate_args{};
     initialization_args(ibf_args);
-    ibf_args.path_out = tmp_dir/"Estimate_Test0_";
     ibf_args.number_expression_thresholds = 2;
     std::vector<double> fpr = {0.05};
     std::vector<uint8_t> cutoffs{};
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta"};
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta")};
 
     minimiser(sequence_files, ibf_args, minimiser_args, cutoffs);
-    std::vector<std::filesystem::path> minimiser_files{tmp_dir/"Estimate_Test0_mini_example.minimiser"};
+    std::vector<std::filesystem::path> minimiser_files{"Estimate_Test_mini_example.minimiser"};
+    ASSERT_TRUE(std::filesystem::exists(minimiser_files[0]));
     ibf_args.expression_thresholds= {};
     ibf(minimiser_files, ibf_args, fpr);
 
     ibf_args.expression_thresholds = {0, 1, 2};
-    estimate_args.search_file = std::string(DATA_INPUT_DIR) + "mini_gen.fasta";
+    estimate_args.search_file = data("mini_gen.fasta");
     estimate_args.path_in = ibf_args.path_out;
-    ibf_args.path_out = tmp_dir/"Test0_expression.out";
+    ibf_args.path_out = "Test0_expression.out";
     call_estimate(ibf_args, estimate_args);
 
-    std::ifstream output_file(tmp_dir/"Test0_expression.out");
+    std::ifstream output_file("Test0_expression.out");
     std::string line;
     std::string expected{"gen1\t3\t"};
     if (output_file.is_open())
@@ -170,41 +147,33 @@ TEST(estimate, small_example_different_expressions_per_level)
         }
         output_file.close();
     }
-    std::filesystem::remove(tmp_dir/"Estimate_Test0_IBF_Level_0");
-    std::filesystem::remove(tmp_dir/"Estimate_Test0_IBF_Level_1");
-    std::filesystem::remove(tmp_dir/"Estimate_Test0_IBF_Levels.levels");
-    std::filesystem::remove(tmp_dir/"Estimate_Test0_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/"Estimate_Test0_IBF_Data");
-    std::filesystem::remove(tmp_dir/"Test0_expression.out");
-    std::filesystem::remove(tmp_dir/"Estimate_Test0_mini_example.minimiser");
 }
 
-TEST(estimate, small_example_different_expressions_per_level_normalization_1)
+TEST_F(estimate_test, small_example_different_expressions_per_level_normalization_1)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     minimiser_arguments minimiser_args{};
     estimate_arguments estimate_args{};
     estimate_args.normalization_method = 1;
     initialization_args(ibf_args);
-    ibf_args.path_out = tmp_dir/"Estimate_Test_";
     ibf_args.number_expression_thresholds = 2;
     std::vector<double> fpr = {0.05};
     std::vector<uint8_t> cutoffs{};
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta"};
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta")};
 
     minimiser(sequence_files, ibf_args, minimiser_args, cutoffs);
-    std::vector<std::filesystem::path> minimiser_files{tmp_dir/"Estimate_Test_mini_example.minimiser"};
+    std::vector<std::filesystem::path> minimiser_files{"Estimate_Test_mini_example.minimiser"};
+    ASSERT_TRUE(std::filesystem::exists(minimiser_files[0]));
     ibf_args.expression_thresholds= {};
     ibf(minimiser_files, ibf_args, fpr);
 
     ibf_args.expression_thresholds = {0, 1, 2};
-    estimate_args.search_file = std::string(DATA_INPUT_DIR) + "mini_gen.fasta";
+    estimate_args.search_file = data("mini_gen.fasta");
     estimate_args.path_in = ibf_args.path_out;
-    ibf_args.path_out = tmp_dir/"expression.out";
+    ibf_args.path_out = "expression.out";
     call_estimate(ibf_args, estimate_args);
 
-    std::ifstream output_file(tmp_dir/"expression.out");
+    std::ifstream output_file("expression.out");
     std::string line;
     std::string expected{"gen1\t1\t"};
     if (output_file.is_open())
@@ -215,41 +184,34 @@ TEST(estimate, small_example_different_expressions_per_level_normalization_1)
         }
         output_file.close();
     }
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_Level_0");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_Level_1");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_Levels.levels");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_Data");
-    std::filesystem::remove(tmp_dir/"expression.out");
 }
 
-TEST(estimate, small_example_different_expressions_per_level_normalization_1_uncompressed)
+TEST_F(estimate_test, small_example_different_expressions_per_level_normalization_1_uncompressed)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     minimiser_arguments minimiser_args{};
     estimate_arguments estimate_args{};
     estimate_args.normalization_method = 1;
     initialization_args(ibf_args);
-    ibf_args.path_out = tmp_dir/"Estimate_Test2_";
     ibf_args.number_expression_thresholds = 2;
     ibf_args.compressed = false;
     std::vector<double> fpr = {0.05};
     std::vector<uint8_t> cutoffs{};
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta"};
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta")};
 
     minimiser(sequence_files, ibf_args, minimiser_args, cutoffs);
-    std::vector<std::filesystem::path> minimiser_files{tmp_dir/"Estimate_Test2_mini_example.minimiser"};
+    std::vector<std::filesystem::path> minimiser_files{"Estimate_Test_mini_example.minimiser"};
+    ASSERT_TRUE(std::filesystem::exists(minimiser_files[0]));
     ibf_args.expression_thresholds= {};
     ibf(minimiser_files, ibf_args, fpr);
 
     ibf_args.expression_thresholds = {0, 1, 2};
-    estimate_args.search_file = std::string(DATA_INPUT_DIR) + "mini_gen.fasta";
+    estimate_args.search_file = data("mini_gen.fasta");
     estimate_args.path_in = ibf_args.path_out;
-    ibf_args.path_out = tmp_dir/"Test2_expression.out";
+    ibf_args.path_out = "Test2_expression.out";
     call_estimate(ibf_args, estimate_args);
 
-    std::ifstream output_file(tmp_dir/"Test2_expression.out");
+    std::ifstream output_file("Test2_expression.out");
     std::string line;
     std::string expected{"gen1\t1\t"};
     if (output_file.is_open())
@@ -260,38 +222,28 @@ TEST(estimate, small_example_different_expressions_per_level_normalization_1_unc
         }
         output_file.close();
     }
-    std::filesystem::remove(tmp_dir/"Estimate_Test2_IBF_Level_0");
-    std::filesystem::remove(tmp_dir/"Estimate_Test2_IBF_Level_1");
-    std::filesystem::remove(tmp_dir/"Estimate_Test2_IBF_Levels.levels");
-    std::filesystem::remove(tmp_dir/"Estimate_Test2_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/"Estimate_Test2_IBF_Data");
-    std::filesystem::remove(tmp_dir/"Test2_expression.out");
-    std::filesystem::remove(tmp_dir/"Estimate_Test2_mini_example.minimiser");
 }
 
-TEST(estimate, example)
+TEST_F(estimate_test, example)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     minimiser_arguments minimiser_args{};
     estimate_arguments estimate_args{};
-    ibf_args.path_out = tmp_dir/"Estimate_Test_";
     std::vector<double> fpr = {0.05};
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "exp_01.fasta", std::string(DATA_INPUT_DIR) + "exp_02.fasta",
-                                                         std::string(DATA_INPUT_DIR) + "exp_11.fasta", std::string(DATA_INPUT_DIR) + "exp_12.fasta"};
+    std::vector<std::filesystem::path> sequence_files = {data("exp_01.fasta"), data("exp_02.fasta"),
+                                                         data("exp_11.fasta"), data("exp_12.fasta")};
     minimiser_args.samples = {2, 2};
     ibf_args.expression_thresholds = {4, 32};
-    ibf_args.path_out = tmp_dir/"Estimate_Test_Single_";
     ibf_args.compressed = false;
     std::vector<uint8_t> cutoffs{};
     ibf(sequence_files, ibf_args, minimiser_args, fpr, cutoffs);
 
-    estimate_args.search_file = std::string(DATA_INPUT_DIR) + "gene.fasta";
+    estimate_args.search_file = data("gene.fasta");
     estimate_args.path_in = ibf_args.path_out;
-    ibf_args.path_out = tmp_dir/"Single_expression.out";
+    ibf_args.path_out = "Single_expression.out";
     call_estimate(ibf_args, estimate_args);
 
-    std::ifstream output_file(tmp_dir/"Single_expression.out");
+    std::ifstream output_file("Single_expression.out");
     std::string line;
     std::string expected{"GeneA\t9\t32\t"};
     if (output_file.is_open())
@@ -302,37 +254,29 @@ TEST(estimate, example)
         }
         output_file.close();
     }
-    std::filesystem::remove(tmp_dir/"Estimate_Test_Single_IBF_4");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_Single_IBF_32");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_Single_IBF_Data");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_Single_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/"Single_expression.out");
 }
 
-TEST(estimate, example_multiple_threads)
+TEST_F(estimate_test, example_multiple_threads)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     minimiser_arguments minimiser_args{};
     estimate_arguments estimate_args{};
-    ibf_args.path_out = tmp_dir/"Estimate_Test_";
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "exp_01.fasta", std::string(DATA_INPUT_DIR) + "exp_02.fasta",
-                                                         std::string(DATA_INPUT_DIR) + "exp_11.fasta", std::string(DATA_INPUT_DIR) + "exp_12.fasta"};
+    std::vector<std::filesystem::path> sequence_files = {data("exp_01.fasta"), data("exp_02.fasta"),
+                                                         data("exp_11.fasta"), data("exp_12.fasta")};
     minimiser_args.samples = {2,2};
     ibf_args.expression_thresholds = {4, 32};
     std::vector<double> fpr = {0.05};
-    ibf_args.path_out = tmp_dir/"Estimate_Test_Multiple_";
     ibf_args.compressed = false;
     std::vector<uint8_t> cutoffs{};
     ibf(sequence_files, ibf_args, minimiser_args, fpr, cutoffs);
     ibf_args.threads = 2;
 
-    estimate_args.search_file = std::string(DATA_INPUT_DIR) + "gene4.fasta";
+    estimate_args.search_file = data("gene4.fasta");
     estimate_args.path_in = ibf_args.path_out;
-    ibf_args.path_out = tmp_dir/"Multiple_expression.out";
+    ibf_args.path_out = "Multiple_expression.out";
     call_estimate(ibf_args, estimate_args);
 
-    std::ifstream output_file(tmp_dir/"Multiple_expression.out");
+    std::ifstream output_file("Multiple_expression.out");
     std::string line;
     std::string expected{"GeneA\t9\t32\t"};
     if (output_file.is_open())
@@ -343,39 +287,33 @@ TEST(estimate, example_multiple_threads)
         }
         output_file.close();
     }
-    std::filesystem::remove(tmp_dir/"Estimate_Test_Multiple_IBF_32");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_Multiple_IBF_4");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_Multiple_IBF_Data");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_Multiple_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/"Multiple_expression.out");
 }
 
-TEST(estimate, example_different_expressions_per_level)
+TEST_F(estimate_test, example_different_expressions_per_level)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     minimiser_arguments minimiser_args{};
     estimate_arguments estimate_args{};
-    ibf_args.path_out = tmp_dir/"Estimate_Test_";
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "exp_01.fasta", std::string(DATA_INPUT_DIR) + "exp_02.fasta",
-                                                         std::string(DATA_INPUT_DIR) + "exp_11.fasta", std::string(DATA_INPUT_DIR) + "exp_12.fasta"};
+    std::vector<std::filesystem::path> sequence_files = {data("exp_01.fasta"), data("exp_02.fasta"),
+                                                         data("exp_11.fasta"), data("exp_12.fasta")};
     std::vector<uint8_t> cutoffs = {0, 0};
     minimiser_args.samples = {2,2};
     ibf_args.number_expression_thresholds = 4;
     std::vector<double> fpr = {0.05};
-    ibf_args.path_out = tmp_dir/"Estimate_Test_";
     ibf_args.compressed = false;
     minimiser(sequence_files, ibf_args, minimiser_args, cutoffs);
-    std::vector<std::filesystem::path> minimiser_files{tmp_dir/"Estimate_Test_exp_01.minimiser", tmp_dir/"Estimate_Test_exp_11.minimiser"};
+    std::vector<std::filesystem::path> minimiser_files{"exp_01.minimiser", "exp_11.minimiser"};
+    ASSERT_TRUE(std::filesystem::exists(minimiser_files[0]));
+    ASSERT_TRUE(std::filesystem::exists(minimiser_files[1]));
     ibf(minimiser_files, ibf_args, fpr);
 
     ibf_args.expression_thresholds = {0, 1, 2};
-    estimate_args.search_file = std::string(DATA_INPUT_DIR) + "gene.fasta";
+    estimate_args.search_file = data("gene.fasta");
     estimate_args.path_in = ibf_args.path_out;
-    ibf_args.path_out = tmp_dir/"expression.out";
+    ibf_args.path_out = "expression.out";
     call_estimate(ibf_args, estimate_args);
 
-    std::ifstream output_file(tmp_dir/"expression.out");
+    std::ifstream output_file("expression.out");
     std::string line;
     // Count would expect 6 and 34
     std::string expected{"GeneA\t7\t26\t"};
@@ -387,43 +325,35 @@ TEST(estimate, example_different_expressions_per_level)
         }
         output_file.close();
     }
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_Level_0");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_Level_1");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_Level_2");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_Levels.levels");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_Data");
-    std::filesystem::remove(tmp_dir/"expression.out");
 }
 
-TEST(estimate, example_different_expressions_per_level_multiple_threads)
+TEST_F(estimate_test, example_different_expressions_per_level_multiple_threads)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     minimiser_arguments minimiser_args{};
     estimate_arguments estimate_args{};
-    ibf_args.path_out = tmp_dir/"Estimate_Test_";
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "exp_01.fasta", std::string(DATA_INPUT_DIR) + "exp_02.fasta",
-                                                         std::string(DATA_INPUT_DIR) + "exp_11.fasta", std::string(DATA_INPUT_DIR) + "exp_12.fasta"};
+    std::vector<std::filesystem::path> sequence_files = {data("exp_01.fasta"), data("exp_02.fasta"),
+                                                         data("exp_11.fasta"), data("exp_12.fasta")};
     std::vector<uint8_t> cutoffs = {0, 0};
     minimiser_args.samples = {2,2};
     ibf_args.number_expression_thresholds = 4;
     std::vector<double> fpr = {0.05};
-    ibf_args.path_out = tmp_dir/"Estimate_Test_";
     ibf_args.compressed = false;
     minimiser(sequence_files, ibf_args, minimiser_args, cutoffs);
-    std::vector<std::filesystem::path> minimiser_files{tmp_dir/"Estimate_Test_exp_01.minimiser", tmp_dir/"Estimate_Test_exp_11.minimiser"};
+    std::vector<std::filesystem::path> minimiser_files{"exp_01.minimiser", "exp_11.minimiser"};
+    ASSERT_TRUE(std::filesystem::exists(minimiser_files[0]));
+    ASSERT_TRUE(std::filesystem::exists(minimiser_files[1]));
     ibf_args.expression_thresholds= {};
     ibf(minimiser_files, ibf_args, fpr);
 
     ibf_args.threads = 2;
     ibf_args.expression_thresholds = {0, 1, 2};
-    estimate_args.search_file = std::string(DATA_INPUT_DIR) + "gene4.fasta";
+    estimate_args.search_file = data("gene4.fasta");
     estimate_args.path_in = ibf_args.path_out;
-    ibf_args.path_out = tmp_dir/"expression.out";
+    ibf_args.path_out = "expression.out";
     call_estimate(ibf_args, estimate_args);
 
-    std::ifstream output_file(tmp_dir/"expression.out");
+    std::ifstream output_file("expression.out");
     std::string line;
     // Count would expect 6 and 34
     std::string expected{"GeneA\t7\t26\t"};
@@ -435,14 +365,4 @@ TEST(estimate, example_different_expressions_per_level_multiple_threads)
         }
         output_file.close();
     }
-    std::filesystem::remove(tmp_dir/"Estimate_Test_exp_01.minimiser");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_exp_11.minimiser");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_Level_0");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_Level_1");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_Level_2");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_Level_3");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_Levels.levels");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/"Estimate_Test_IBF_Data");
-    std::filesystem::remove(tmp_dir/"expression.out");
 }
diff --git a/test/api/ibf_test.cpp b/test/api/ibf_test.cpp
index 3f8dab1..d5de94e 100644
--- a/test/api/ibf_test.cpp
+++ b/test/api/ibf_test.cpp
@@ -5,33 +5,30 @@
 
 #include "ibf.h"
 #include "shared.h"
+#include "../app_test.hpp"
 
-#ifndef DATA_INPUT_DIR
-#  define DATA_INPUT_DIR @DATA_INPUT_DIR@
-#endif
-
-using seqan3::operator""_shape;
-
-
-void initialization_args(estimate_ibf_arguments & args)
+// To prevent issues when running multiple CLI tests in parallel, give each CLI test unique names:
+struct ibf_test : public app_test
 {
-    args.compressed = true;
-    args.k = 4;
-    args.shape = seqan3::ungapped{args.k};
-    args.w_size = seqan3::window_size{4};
-    args.s = seqan3::seed{0};
-}
+    void initialization_args(estimate_ibf_arguments & args)
+    {
+        args.compressed = true;
+        args.k = 4;
+        args.shape = seqan3::ungapped{args.k};
+        args.w_size = seqan3::window_size{4};
+        args.s = seqan3::seed{0};
+    }
+};
 
-TEST(ibf, given_expression_thresholds)
+TEST_F(ibf_test, given_expression_thresholds)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     minimiser_arguments minimiser_args{};
     initialization_args(ibf_args);
-    ibf_args.path_out = tmp_dir/"IBF_Test_Exp_";
+    ibf_args.path_out = "IBF_Test_Exp_";
     ibf_args.expression_thresholds = {1, 2};
     minimiser_args.experiment_names = true;
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta"};
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta")};
     std::vector<double> fpr = {0.05};
 
     std::vector<uint16_t> expected{1, 2};
@@ -42,9 +39,9 @@ TEST(ibf, given_expression_thresholds)
     EXPECT_EQ(expected, medians);
 
     seqan3::interleaved_bloom_filter<seqan3::data_layout::compressed> ibf;
-    if (std::filesystem::exists(tmp_dir/"IBF_Test_Exp_IBF_1"))
+    ASSERT_TRUE(std::filesystem::exists("IBF_Test_Exp_IBF_1"));
     {
-        load_ibf(ibf, tmp_dir/"IBF_Test_Exp_IBF_1");
+        load_ibf(ibf, "IBF_Test_Exp_IBF_1");
         auto agent = ibf.membership_agent();
 
         std::vector<bool> expected_result(1, 0);
@@ -54,13 +51,11 @@ TEST(ibf, given_expression_thresholds)
         auto & res2 = agent.bulk_contains(24);
         EXPECT_RANGE_EQ(expected_result,  res2);
     }
-    std::filesystem::remove(tmp_dir/"IBF_Test_Exp_IBF_1");
-    std::filesystem::remove(tmp_dir/"IBF_Test_Exp_IBF_2");
 
-    estimate_ibf_arguments args{};
-    if (std::filesystem::exists(tmp_dir/"IBF_Test_Exp_IBF_Data"))
+    ASSERT_TRUE(std::filesystem::exists("IBF_Test_Exp_IBF_Data"));
     {
-        load_args(args, tmp_dir/"IBF_Test_Exp_IBF_Data");
+        estimate_ibf_arguments args{};
+        load_args(args, "IBF_Test_Exp_IBF_Data");
         EXPECT_EQ(4, args.k);
         EXPECT_EQ(4, args.w_size.get());
         EXPECT_EQ(0, args.s.get());
@@ -70,21 +65,17 @@ TEST(ibf, given_expression_thresholds)
         EXPECT_RANGE_EQ(ibf_args.expression_thresholds, args.expression_thresholds);
         EXPECT_EQ(ibf_args.samplewise, args.samplewise);
     }
-    std::filesystem::remove(tmp_dir/"IBF_Test_Exp_IBF_Data");
-    std::filesystem::remove(tmp_dir/"IBF_Test_Exp_Stored_Files.txt");
-    std::filesystem::remove(tmp_dir/"IBF_Test_Exp_IBF_FPRs.fprs");
 }
 
-TEST(ibf, given_expression_thresholds_include_file)
+TEST_F(ibf_test, given_expression_thresholds_include_file)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     minimiser_arguments minimiser_args{};
     initialization_args(ibf_args);
-    ibf_args.path_out = tmp_dir/"IBF_Test_Include_";
+    ibf_args.path_out = "IBF_Test_Include_";
     ibf_args.expression_thresholds = {1, 2};
-    minimiser_args.include_file = std::string(DATA_INPUT_DIR) + "mini_example.fasta";
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta"};
+    minimiser_args.include_file = data("mini_example.fasta");
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta")};
     std::vector<double> fpr = {0.05};
 
     std::vector<uint16_t> expected{1, 2};
@@ -95,9 +86,9 @@ TEST(ibf, given_expression_thresholds_include_file)
     EXPECT_EQ(expected, medians);
 
     seqan3::interleaved_bloom_filter<seqan3::data_layout::compressed> ibf;
-    if (std::filesystem::exists(tmp_dir/"IBF_Test_Include_IBF_1"))
+    ASSERT_TRUE(std::filesystem::exists("IBF_Test_Include_IBF_1"));
     {
-        load_ibf(ibf, tmp_dir/"IBF_Test_Include_IBF_1");
+        load_ibf(ibf, "IBF_Test_Include_IBF_1");
         auto agent = ibf.membership_agent();
 
         std::vector<bool> expected_result(1, 0);
@@ -107,22 +98,17 @@ TEST(ibf, given_expression_thresholds_include_file)
         auto & res2 = agent.bulk_contains(24);
         EXPECT_RANGE_EQ(expected_result,  res2);
     }
-    std::filesystem::remove(tmp_dir/"IBF_Test_Include_IBF_1");
-    std::filesystem::remove(tmp_dir/"IBF_Test_Include_IBF_2");
-    std::filesystem::remove(tmp_dir/"IBF_Test_Include_IBF_Data");
-    std::filesystem::remove(tmp_dir/"IBF_Test_Include_IBF_FPRs.fprs");
 }
 
-TEST(ibf, given_expression_thresholds_exclude_file)
+TEST_F(ibf_test, given_expression_thresholds_exclude_file)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     minimiser_arguments minimiser_args{};
     initialization_args(ibf_args);
-    ibf_args.path_out = tmp_dir/"IBF_Test_Exclude_";
+    ibf_args.path_out = "IBF_Test_Exclude_";
     ibf_args.expression_thresholds = {1, 2};
-    minimiser_args.exclude_file = std::string(DATA_INPUT_DIR) + "mini_gen.fasta";
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta"};
+    minimiser_args.exclude_file = data("mini_gen.fasta");
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta")};
     std::vector<double> fpr = {0.05};
 
     std::vector<uint16_t> expected{1, 2};
@@ -133,9 +119,9 @@ TEST(ibf, given_expression_thresholds_exclude_file)
     EXPECT_EQ(expected, medians);
 
     seqan3::interleaved_bloom_filter<seqan3::data_layout::compressed> ibf;
-    if (std::filesystem::exists(tmp_dir/"IBF_Test_Exclude_IBF_1"))
+    ASSERT_TRUE(std::filesystem::exists("IBF_Test_Exclude_IBF_1"));
     {
-        load_ibf(ibf, tmp_dir/"IBF_Test_Exclude_IBF_1");
+        load_ibf(ibf, "IBF_Test_Exclude_IBF_1");
         auto agent = ibf.membership_agent();
 
         std::vector<bool> expected_result(1, 0);
@@ -145,21 +131,16 @@ TEST(ibf, given_expression_thresholds_exclude_file)
         auto & res2 = agent.bulk_contains(24);
         EXPECT_RANGE_EQ(expected_result,  res2);
     }
-    std::filesystem::remove(tmp_dir/"IBF_Test_Exclude_IBF_1");
-    std::filesystem::remove(tmp_dir/"IBF_Test_Exclude_IBF_2");
-    std::filesystem::remove(tmp_dir/"IBF_Test_Exclude_IBF_Data");
-    std::filesystem::remove(tmp_dir/"IBF_Test_Exclude_IBF_FPRs.fprs");
 }
 
-TEST(ibf, no_given_expression_thresholds)
+TEST_F(ibf_test, no_given_expression_thresholds)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     minimiser_arguments minimiser_args{};
     initialization_args(ibf_args);
-    ibf_args.path_out = tmp_dir/"IBF_Test_";
+    ibf_args.path_out = "IBF_Test_";
     ibf_args.number_expression_thresholds = 2;
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta"};
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta")};
     std::vector<double> fpr = {0.05};
 
     std::vector<uint16_t> expected{};
@@ -171,9 +152,9 @@ TEST(ibf, no_given_expression_thresholds)
 
     seqan3::interleaved_bloom_filter<seqan3::data_layout::compressed> ibf;
 
-    if (std::filesystem::exists(tmp_dir/"IBF_Test_IBF_Level_0"))
+    ASSERT_TRUE(std::filesystem::exists("IBF_Test_IBF_Level_0"));
     {
-        load_ibf(ibf, tmp_dir/"IBF_Test_IBF_Level_0");
+        load_ibf(ibf, "IBF_Test_IBF_Level_0");
         auto agent = ibf.membership_agent();
 
         std::vector<bool> expected_result(1, 0);
@@ -183,37 +164,31 @@ TEST(ibf, no_given_expression_thresholds)
         auto & res2 = agent.bulk_contains(24);
         EXPECT_RANGE_EQ(expected_result,  res2);
     }
-    std::filesystem::remove(tmp_dir/"IBF_Test_IBF_Level_0");
-    std::filesystem::remove(tmp_dir/"IBF_Test_IBF_Level_1");
-    std::filesystem::remove(tmp_dir/"IBF_Test_IBF_Levels.levels");
-    std::filesystem::remove(tmp_dir/"IBF_Test_IBF_Data");
-    std::filesystem::remove(tmp_dir/"IBF_Test_IBF_FPRs.fprs");
 }
 
-TEST(ibf, expression_thresholds_by_genome)
+TEST_F(ibf_test, expression_thresholds_by_genome)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     minimiser_arguments minimiser_args{};
     initialization_args(ibf_args);
-    ibf_args.path_out = tmp_dir/"IBF_Test_";
+    ibf_args.path_out = "IBF_Test_";
     ibf_args.number_expression_thresholds = 1;
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta"};
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta")};
     std::vector<double> fpr = {0.05};
 
     std::vector<uint16_t> expected{};
     std::vector<uint8_t> cutoffs{};
 
     std::vector<uint16_t> medians = ibf(sequence_files, ibf_args, minimiser_args, fpr, cutoffs,
-                                        std::string(DATA_INPUT_DIR) + "mini_gen.fasta");
+                                        data("mini_gen.fasta"));
 
     EXPECT_EQ(expected, medians);
 
     seqan3::interleaved_bloom_filter<seqan3::data_layout::compressed> ibf;
 
-    if (std::filesystem::exists(tmp_dir/"IBF_Test_IBF_Level_0"))
+    ASSERT_TRUE(std::filesystem::exists("IBF_Test_IBF_Level_0"));
     {
-        load_ibf(ibf, tmp_dir/"IBF_Test_IBF_Level_0");
+        load_ibf(ibf, "IBF_Test_IBF_Level_0");
         auto agent = ibf.membership_agent();
 
         std::vector<bool> expected_result(1, 0);
@@ -223,21 +198,16 @@ TEST(ibf, expression_thresholds_by_genome)
         auto & res2 = agent.bulk_contains(192);
         EXPECT_RANGE_EQ(expected_result,  res2);
     }
-    std::filesystem::remove(tmp_dir/"IBF_Test_IBF_Level_0");
-    std::filesystem::remove(tmp_dir/"IBF_Test_IBF_Levels.levels");
-    std::filesystem::remove(tmp_dir/"IBF_Test_IBF_Data");
-    std::filesystem::remove(tmp_dir/"IBF_Test_IBF_FPRs.fprs");
 }
 
-TEST(ibf, throws)
+TEST_F(ibf_test, throws)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     minimiser_arguments minimiser_args{};
     std::vector<uint8_t> cutoffs{};
     initialization_args(ibf_args);
-    ibf_args.path_out = tmp_dir/"IBF_Test_";
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta"};
+    ibf_args.path_out = "IBF_Test_";
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta")};
     std::vector<double> fpr = {0.05};
 
     EXPECT_THROW(ibf(sequence_files, ibf_args, minimiser_args, fpr, cutoffs), std::invalid_argument);
@@ -253,16 +223,15 @@ TEST(ibf, throws)
     EXPECT_THROW(ibf(sequence_files, ibf_args, minimiser_args, fpr, cutoffs), std::invalid_argument);
 }
 
-TEST(ibf, given_cutoffs)
+TEST_F(ibf_test, given_cutoffs)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     minimiser_arguments minimiser_args{};
     initialization_args(ibf_args);
-    ibf_args.path_out = tmp_dir/"IBF_Test_Cut_";
+    ibf_args.path_out = "IBF_Test_Cut_";
     ibf_args.expression_thresholds = {1, 2};
     std::vector<uint8_t> cutoffs = {0};
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta"};
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta")};
     std::vector<double> fpr = {0.05};
 
     std::vector<uint16_t> expected{1, 2};
@@ -272,9 +241,9 @@ TEST(ibf, given_cutoffs)
     EXPECT_EQ(expected, medians);
 
     seqan3::interleaved_bloom_filter<seqan3::data_layout::compressed> ibf;
-    if (std::filesystem::exists(tmp_dir/"IBF_Test_Cut_IBF_1"))
+    ASSERT_TRUE(std::filesystem::exists("IBF_Test_Cut_IBF_1"));
     {
-        load_ibf(ibf, tmp_dir/"IBF_Test_Cut_IBF_1");
+        load_ibf(ibf, "IBF_Test_Cut_IBF_1");
         auto agent = ibf.membership_agent();
 
         std::vector<bool> expected_result(1, 0);
@@ -284,13 +253,11 @@ TEST(ibf, given_cutoffs)
         auto & res2 = agent.bulk_contains(24);
         EXPECT_RANGE_EQ(expected_result,  res2);
     }
-    std::filesystem::remove(tmp_dir/"IBF_Test_Cut_IBF_1");
-    std::filesystem::remove(tmp_dir/"IBF_Test_Cut_IBF_2");
 
     estimate_ibf_arguments args{};
-    if (std::filesystem::exists(tmp_dir/"IBF_Test_Cut_IBF_Data"))
+    ASSERT_TRUE(std::filesystem::exists("IBF_Test_Cut_IBF_Data"));
     {
-        load_args(args, tmp_dir/"IBF_Test_Cut_IBF_Data");
+        load_args(args, "IBF_Test_Cut_IBF_Data");
         EXPECT_EQ(4, args.k);
         EXPECT_EQ(4, args.w_size.get());
         EXPECT_EQ(0, args.s.get());
@@ -300,19 +267,16 @@ TEST(ibf, given_cutoffs)
         EXPECT_RANGE_EQ(ibf_args.expression_thresholds, args.expression_thresholds);
         EXPECT_EQ(ibf_args.samplewise, args.samplewise);
     }
-    std::filesystem::remove(tmp_dir/"IBF_Test_Cut_IBF_Data");
-    std::filesystem::remove(tmp_dir/"IBF_Test_Cut_IBF_FPRs.fprs");
 }
 
-TEST(ibf, different_file_sizes)
+TEST_F(ibf_test, different_file_sizes)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     minimiser_arguments minimiser_args{};
     initialization_args(ibf_args);
-    ibf_args.path_out = tmp_dir/"IBF_Test_Diff_";
+    ibf_args.path_out = "IBF_Test_Diff_";
     ibf_args.number_expression_thresholds = 4;
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta", std::string(DATA_INPUT_DIR) + "exp_01.fasta"};
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta"), data("exp_01.fasta")};
     std::vector<double> fpr = {0.05};
 
     std::vector<uint16_t> expected{};
@@ -324,9 +288,9 @@ TEST(ibf, different_file_sizes)
 
     seqan3::interleaved_bloom_filter<seqan3::data_layout::compressed> ibf;
 
-    if (std::filesystem::exists(tmp_dir/"IBF_Test_Diff_IBF_Level_0"))
+    ASSERT_TRUE(std::filesystem::exists("IBF_Test_Diff_IBF_Level_0"));
     {
-        load_ibf(ibf, tmp_dir/"IBF_Test_Diff_IBF_Level_0");
+        load_ibf(ibf, "IBF_Test_Diff_IBF_Level_0");
         auto agent = ibf.membership_agent();
 
         std::vector<bool> expected_result(2, 0);
@@ -337,11 +301,4 @@ TEST(ibf, different_file_sizes)
         auto & res2 = agent.bulk_contains(24);
         EXPECT_RANGE_EQ(expected_result,  res2);
     }
-    std::filesystem::remove(tmp_dir/"IBF_Test_Diff_IBF_Level_0");
-    std::filesystem::remove(tmp_dir/"IBF_Test_Diff_IBF_Level_1");
-    std::filesystem::remove(tmp_dir/"IBF_Test_Diff_IBF_Level_2");
-    std::filesystem::remove(tmp_dir/"IBF_Test_Diff_IBF_Level_3");
-    std::filesystem::remove(tmp_dir/"IBF_Test_Diff_IBF_Levels.levels");
-    std::filesystem::remove(tmp_dir/"IBF_Test_Diff_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/"IBF_Test_Diff_IBF_Data");
 }
diff --git a/test/api/ibfmin_test.cpp b/test/api/ibfmin_test.cpp
index 28d1252..020448e 100644
--- a/test/api/ibfmin_test.cpp
+++ b/test/api/ibfmin_test.cpp
@@ -5,32 +5,30 @@
 
 #include "ibf.h"
 #include "shared.h"
+#include "../app_test.hpp"
 
-#ifndef DATA_INPUT_DIR
-#  define DATA_INPUT_DIR @DATA_INPUT_DIR@
-#endif
-
-using seqan3::operator""_shape;
-std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
-
-void initialization_args(estimate_ibf_arguments & args)
+// To prevent issues when running multiple CLI tests in parallel, give each CLI test unique names:
+struct ibfmin_test : public app_test
 {
-    args.compressed = true;
-    args.k = 4;
-    args.shape = seqan3::ungapped{args.k};
-    args.w_size = seqan3::window_size{4};
-    args.s = seqan3::seed{0};
-    args.path_out = tmp_dir/"IBFMIN_Test_";
-}
+    void initialization_args(estimate_ibf_arguments & args)
+    {
+        args.compressed = true;
+        args.k = 4;
+        args.shape = seqan3::ungapped{args.k};
+        args.w_size = seqan3::window_size{4};
+        args.s = seqan3::seed{0};
+        args.path_out = "IBFMIN_Test_";
+    }
+};
 
-TEST(ibfmin, given_expression_thresholds)
+TEST_F(ibfmin_test, given_expression_thresholds)
 {
     estimate_ibf_arguments ibf_args{};
     initialization_args(ibf_args);
     ibf_args.expression_thresholds = {1, 2};
     std::vector<double> fpr = {0.05, 0.05};
-    ibf_args.path_out = tmp_dir/"IBFMIN_Test_Given_";
-    std::vector<std::filesystem::path> minimiser_file = {std::string(DATA_INPUT_DIR) + "mini_example.minimiser"};
+    ibf_args.path_out = "IBFMIN_Test_Given_";
+    std::vector<std::filesystem::path> minimiser_file = {data("mini_example.minimiser")};
 
     std::vector<uint16_t> expected{1, 2};
 
@@ -39,9 +37,9 @@ TEST(ibfmin, given_expression_thresholds)
     EXPECT_EQ(expected, medians);
 
     seqan3::interleaved_bloom_filter<seqan3::data_layout::compressed> ibf;
-    if (std::filesystem::exists(tmp_dir/"IBFMIN_Test_Given_IBF_1"))
+    ASSERT_TRUE(std::filesystem::exists("IBFMIN_Test_Given_IBF_1"));
     {
-        load_ibf(ibf, tmp_dir/"IBFMIN_Test_Given_IBF_1");
+        load_ibf(ibf, "IBFMIN_Test_Given_IBF_1");
         auto agent = ibf.membership_agent();
 
         std::vector<bool> expected_result(1, 0);
@@ -52,23 +50,18 @@ TEST(ibfmin, given_expression_thresholds)
         EXPECT_RANGE_EQ(expected_result,  res2);
     }
 
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Given_IBF_1");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Given_IBF_2");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Given_IBF_Data");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Given_IBF_FPRs.fprs");
 }
 
-#if defined(__GNUC__) && ((__GNUC___ == 10 && __cplusplus == 201703L) || (__GNUC__ <10))
-TEST(ibfmin, given_expression_thresholds_multiple_threads)
+TEST_F(ibfmin_test, given_expression_thresholds_multiple_threads)
 {
     estimate_ibf_arguments ibf_args{};
     initialization_args(ibf_args);
     ibf_args.expression_thresholds = {1, 2};
     std::vector<double> fpr = {0.05, 0.05};
     ibf_args.threads = 2;
-    ibf_args.path_out = tmp_dir/"IBFMIN_Test_Multiple_";
+    ibf_args.path_out = "IBFMIN_Test_Multiple_";
     std::vector<std::filesystem::path> minimiser_file{};
-    minimiser_file.assign(16, std::string(DATA_INPUT_DIR) + "mini_example.minimiser");
+    minimiser_file.assign(16, data("mini_example.minimiser"));
 
     std::vector<uint16_t> expected{1, 2};
 
@@ -77,7 +70,7 @@ TEST(ibfmin, given_expression_thresholds_multiple_threads)
     EXPECT_EQ(expected, medians);
 
     seqan3::interleaved_bloom_filter<seqan3::data_layout::compressed> ibf;
-    load_ibf(ibf, tmp_dir/"IBFMIN_Test_Multiple_IBF_1");
+    load_ibf(ibf, "IBFMIN_Test_Multiple_IBF_1");
     auto agent = ibf.membership_agent();
 
     std::vector<bool> expected_result(16, 0);
@@ -86,20 +79,15 @@ TEST(ibfmin, given_expression_thresholds_multiple_threads)
     std::vector<bool> expected_result2(16, 1);
     auto & res2 = agent.bulk_contains(24);
     EXPECT_RANGE_EQ(expected_result2,  res2);
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Multiple_IBF_1");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Multiple_IBF_2");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Multiple_IBF_Data");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Multiple_IBF_FPRs.fprs");
 }
-#endif
 
-TEST(ibfmin, no_given_expression_thresholds)
+TEST_F(ibfmin_test, no_given_expression_thresholds)
 {
     estimate_ibf_arguments ibf_args{};
     initialization_args(ibf_args);
     ibf_args.number_expression_thresholds = 2;
     std::vector<double> fpr = {0.0025, 0.0025};
-    std::vector<std::filesystem::path> minimiser_file = {std::string(DATA_INPUT_DIR) + "mini_example.minimiser"};
+    std::vector<std::filesystem::path> minimiser_file = {data("mini_example.minimiser")};
 
     std::vector<uint16_t> expected{};
 
@@ -107,10 +95,10 @@ TEST(ibfmin, no_given_expression_thresholds)
 
     EXPECT_EQ(expected, medians);
 
-    if (std::filesystem::exists(tmp_dir/"IBFMIN_Test_IBF_Level_0"))
+    ASSERT_TRUE(std::filesystem::exists("IBFMIN_Test_IBF_Level_0"));
     {
         seqan3::interleaved_bloom_filter<seqan3::data_layout::compressed> ibf;
-        load_ibf(ibf, tmp_dir/"IBFMIN_Test_IBF_Level_0");
+        load_ibf(ibf, "IBFMIN_Test_IBF_Level_0");
         auto agent = ibf.membership_agent();
 
         std::vector<bool> expected_result(1, 0);
@@ -121,31 +109,26 @@ TEST(ibfmin, no_given_expression_thresholds)
         EXPECT_RANGE_EQ(expected_result,  res2);
     }
 
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_IBF_Level_0");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_IBF_Level_1");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_IBF_Data");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_IBF_Levels.levels");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_IBF_FPRs.fprs");
 }
 
-TEST(ibfmin, expression_thresholds_by_genome)
+TEST_F(ibfmin_test, expression_thresholds_by_genome)
 {
     estimate_ibf_arguments ibf_args{};
     initialization_args(ibf_args);
     ibf_args.number_expression_thresholds = 1;
     std::vector<double> fpr = {0.05};
-    std::vector<std::filesystem::path> minimiser_file = {std::string(DATA_INPUT_DIR) + "mini_example.minimiser"};
+    std::vector<std::filesystem::path> minimiser_file = {data("mini_example.minimiser")};
 
     std::vector<uint16_t> expected{};
 
-    std::vector<uint16_t> medians = ibf(minimiser_file, ibf_args, fpr, std::string(DATA_INPUT_DIR) + "mini_gen.fasta");
+    std::vector<uint16_t> medians = ibf(minimiser_file, ibf_args, fpr, data("mini_gen.fasta"));
 
     EXPECT_EQ(expected, medians);
 
-    if (std::filesystem::exists(tmp_dir/"IBFMIN_Test_IBF_Level_0"))
+    ASSERT_TRUE(std::filesystem::exists("IBFMIN_Test_IBF_Level_0"));
     {
         seqan3::interleaved_bloom_filter<seqan3::data_layout::compressed> ibf;
-        load_ibf(ibf, tmp_dir/"IBFMIN_Test_IBF_Level_0");
+        load_ibf(ibf, "IBFMIN_Test_IBF_Level_0");
         auto agent = ibf.membership_agent();
 
         std::vector<bool> expected_result(1, 0);
@@ -156,23 +139,18 @@ TEST(ibfmin, expression_thresholds_by_genome)
         EXPECT_RANGE_EQ(expected_result,  res2);
     }
 
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_IBF_Level_0");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_IBF_Data");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_IBF_Levels.levels");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_IBF_FPRs.fprs");
 }
 
-#if defined(__GNUC__) && ((__GNUC___ == 10 && __cplusplus == 201703L) || (__GNUC__ <10))
-TEST(ibfmin, no_given_expression_thresholds_multiple_threads)
+TEST_F(ibfmin_test, no_given_expression_thresholds_multiple_threads)
 {
     estimate_ibf_arguments ibf_args{};
     initialization_args(ibf_args);
     ibf_args.number_expression_thresholds = 2;
     std::vector<double> fpr = {0.0025, 0.0025};
     ibf_args.threads = 2;
-    ibf_args.path_out = tmp_dir/"IBFMIN_Test_Multiple_";
+    ibf_args.path_out = "IBFMIN_Test_Multiple_";
     std::vector<std::filesystem::path> minimiser_file{};
-    minimiser_file.assign(128, std::string(DATA_INPUT_DIR) + "mini_example.minimiser");
+    minimiser_file.assign(128, data("mini_example.minimiser"));
 
     std::vector<uint16_t> expected{};
 
@@ -181,7 +159,7 @@ TEST(ibfmin, no_given_expression_thresholds_multiple_threads)
     EXPECT_EQ(expected, medians);
 
     seqan3::interleaved_bloom_filter<seqan3::data_layout::compressed> ibf;
-    load_ibf(ibf, tmp_dir/"IBFMIN_Test_Multiple_IBF_Level_0");
+    load_ibf(ibf, "IBFMIN_Test_Multiple_IBF_Level_0");
     auto agent = ibf.membership_agent();
 
     std::vector<bool> expected_result(128, 0);
@@ -190,15 +168,9 @@ TEST(ibfmin, no_given_expression_thresholds_multiple_threads)
     std::vector<bool> expected_result2(128, 1);
     auto & res2 = agent.bulk_contains(24);
     EXPECT_RANGE_EQ(expected_result2,  res2);
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Multiple_IBF_Level_0");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Multiple_IBF_Level_1");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Multiple_IBF_Data");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Multiple_IBF_Levels.levels");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Multiple_IBF_FPRs.fprs");
 }
-#endif
 
-TEST(ibfmin, different_shape)
+TEST_F(ibfmin_test, different_shape)
 {
     estimate_ibf_arguments ibf_args{};
     minimiser_arguments minimiser_args{};
@@ -207,10 +179,10 @@ TEST(ibfmin, different_shape)
     ibf_args.shape = seqan3::bin_literal{11};
     ibf_args.expression_thresholds = {1, 2};
     std::vector<double> fpr = {0.05, 0.05};
-    ibf_args.path_out = tmp_dir/"IBFMIN_Test_Shape_";
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta"};
+    ibf_args.path_out = "IBFMIN_Test_Shape_";
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta")};
     minimiser(sequence_files, ibf_args, minimiser_args, cutoffs);
-    std::vector<std::filesystem::path> minimiser_file = {tmp_dir/"IBFMIN_Test_Shape_mini_example.minimiser"};
+    std::vector<std::filesystem::path> minimiser_file = {"IBFMIN_Test_Shape_mini_example.minimiser"};
 
     std::vector<uint16_t> expected{1, 2};
 
@@ -219,9 +191,9 @@ TEST(ibfmin, different_shape)
     EXPECT_EQ(expected, medians);
 
     seqan3::interleaved_bloom_filter<seqan3::data_layout::compressed> ibf;
-    if (std::filesystem::exists(tmp_dir/"IBFMIN_Test_Shape_IBF_1"))
+    ASSERT_TRUE(std::filesystem::exists("IBFMIN_Test_Shape_IBF_1"));
     {
-        load_ibf(ibf, tmp_dir/"IBFMIN_Test_Shape_IBF_1");
+        load_ibf(ibf, "IBFMIN_Test_Shape_IBF_1");
         auto agent = ibf.membership_agent();
 
         std::vector<bool> expected_result(1, 0);
@@ -232,9 +204,4 @@ TEST(ibfmin, different_shape)
         EXPECT_RANGE_EQ(expected_result,  res2);
     }
 
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Shape_IBF_1");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Shape_IBF_2");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Shape_IBF_Data");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Shape_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/("IBFMIN_Test_Shape_mini_example.minimiser"));
 }
diff --git a/test/api/insert_delete_test.cpp b/test/api/insert_delete_test.cpp
index d8ca97c..3c68b56 100644
--- a/test/api/insert_delete_test.cpp
+++ b/test/api/insert_delete_test.cpp
@@ -5,25 +5,65 @@
 
 #include "ibf.h"
 #include "shared.h"
+#include "../app_test.hpp"
 
-#ifndef DATA_INPUT_DIR
-#  define DATA_INPUT_DIR @DATA_INPUT_DIR@
-#endif
-
-using seqan3::operator""_shape;
-
-void initialization_args(estimate_ibf_arguments & args)
+// To prevent issues when running multiple CLI tests in parallel, give each CLI test unique names:
+struct delete_test : public app_test
 {
-    args.compressed = true;
-    args.k = 4;
-    args.shape = seqan3::ungapped{args.k};
-    args.w_size = seqan3::window_size{4};
-    args.s = seqan3::seed{0};
-}
+    void initialization_args(estimate_ibf_arguments & args)
+    {
+        args.compressed = true;
+        args.k = 4;
+        args.shape = seqan3::ungapped{args.k};
+        args.w_size = seqan3::window_size{4};
+        args.s = seqan3::seed{0};
+    }
+};
+
+struct insert_test : public delete_test
+{
+    // Reads the level file ibf creates
+    template<typename float_or_int>
+    void read_levels(std::vector<std::vector<float_or_int>> & expressions, std::filesystem::path filename)
+    {
+        ASSERT_TRUE(std::filesystem::exists(filename)) << filename;
+        std::ifstream fin{filename};
+        auto stream_view = seqan3::detail::istreambuf(fin);
+        auto stream_it = std::ranges::begin(stream_view);
+        size_t j{0};
+        std::vector<float_or_int> empty_vector{};
+
+        std::string buffer{};
 
-TEST(delete, no_given_thresholds)
+        // Read line = expression levels
+        do
+        {
+            if (j == expressions.size())
+                expressions.push_back(empty_vector);
+            std::ranges::copy(stream_view | seqan3::detail::take_until_or_throw(seqan3::is_char<' '>),
+                                            std::back_inserter(buffer));
+            if constexpr(std::same_as<uint16_t, float_or_int>)
+                expressions[j].push_back((uint16_t)  std::stoi(buffer));
+            else
+                expressions[j].push_back((double)  std::stod(buffer));
+            buffer.clear();
+            if(*stream_it != '/')
+                ++stream_it;
+
+            if (*stream_it == '\n')
+            {
+                ++stream_it;
+                j++;
+            }
+        } while (*stream_it != '/');
+        ++stream_it;
+
+        fin.close();
+    }
+};
+
+TEST_F(delete_test, no_given_thresholds)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     std::vector<double> fpr = {0.05};
     std::vector<uint8_t> cutoffs_delete{0,0};
     estimate_ibf_arguments ibf_args_delete{};
@@ -32,84 +72,40 @@ TEST(delete, no_given_thresholds)
     ibf_args_delete.compressed = false;
     ibf_args_delete.number_expression_thresholds = 2;
     minimiser_args_delete.experiment_names = false;
-    ibf_args_delete.path_out = tmp_dir/"IBF_delete_Exp_";
-    std::vector<std::filesystem::path> sequence_files_delete = {std::string(DATA_INPUT_DIR) + "mini_example.fasta",std::string(DATA_INPUT_DIR) + "mini_example.fasta"};
+    ibf_args_delete.path_out = "IBF_delete_Exp_";
+    std::vector<std::filesystem::path> sequence_files_delete = {data("mini_example.fasta"),data("mini_example.fasta")};
     ibf(sequence_files_delete, ibf_args_delete, minimiser_args_delete, fpr, cutoffs_delete);
     seqan3::interleaved_bloom_filter<seqan3::data_layout::uncompressed> ibf{};
-    load_ibf(ibf, tmp_dir/"IBF_delete_Exp_IBF_Level_0");
+    load_ibf(ibf, "IBF_delete_Exp_IBF_Level_0");
     seqan3::interleaved_bloom_filter<seqan3::data_layout::uncompressed> ibf_0{seqan3::bin_count{2u},
                                          seqan3::bin_size{ibf.bin_size()},
                                          seqan3::hash_function_count{1u}};
-    load_ibf(ibf, tmp_dir/"IBF_delete_Exp_IBF_Level_1");
+    load_ibf(ibf, "IBF_delete_Exp_IBF_Level_1");
     seqan3::interleaved_bloom_filter<seqan3::data_layout::uncompressed> ibf_1{seqan3::bin_count{2u},
                                           seqan3::bin_size{ibf.bin_size()},
                                           seqan3::hash_function_count{1u}};
 
-    delete_bin({0,1}, ibf_args_delete,  tmp_dir/"IBF_delete_Exp_", true);
+    delete_bin({0,1}, ibf_args_delete,  "IBF_delete_Exp_", true);
 
     seqan3::interleaved_bloom_filter<seqan3::data_layout::uncompressed> ibf_delete{};
 
-    load_ibf(ibf_delete, tmp_dir/"IBF_delete_Exp_IBF_Level_0");
+    load_ibf(ibf_delete, "IBF_delete_Exp_IBF_Level_0");
     EXPECT_TRUE((ibf_0 == ibf_delete));
 
-    load_ibf(ibf_delete, tmp_dir/"IBF_delete_Exp_IBF_Level_1");
+    load_ibf(ibf_delete, "IBF_delete_Exp_IBF_Level_1");
     EXPECT_TRUE((ibf_1 == ibf_delete));
-
-    std::filesystem::remove(tmp_dir/"IBF_delete_Exp_IBF_Level_0");
-    std::filesystem::remove(tmp_dir/"IBF_delete_Exp_IBF_Level_1");
-    std::filesystem::remove(tmp_dir/"IBF_delete_Exp_IBF_Deleted");
 }
 
-// Reads the level file ibf creates
-template<typename float_or_int>
-void read_levels(std::vector<std::vector<float_or_int>> & expressions, std::filesystem::path filename)
+TEST_F(insert_test, ibf)
 {
-    std::ifstream fin;
-    fin.open(filename);
-    auto stream_view = seqan3::detail::istreambuf(fin);
-    auto stream_it = std::ranges::begin(stream_view);
-    int j{0};
-    std::vector<float_or_int> empty_vector{};
-
-    std::string buffer{};
-
-    // Read line = expression levels
-    do
-    {
-        if (j == expressions.size())
-            expressions.push_back(empty_vector);
-        std::ranges::copy(stream_view | seqan3::detail::take_until_or_throw(seqan3::is_char<' '>),
-                                        std::back_inserter(buffer));
-        if constexpr(std::same_as<uint16_t, float_or_int>)
-            expressions[j].push_back((uint16_t)  std::stoi(buffer));
-        else
-            expressions[j].push_back((double)  std::stod(buffer));
-        buffer.clear();
-        if(*stream_it != '/')
-            ++stream_it;
-
-        if (*stream_it == '\n')
-        {
-            ++stream_it;
-            j++;
-        }
-    } while (*stream_it != '/');
-    ++stream_it;
-
-    fin.close();
-}
-
-TEST(insert, ibf)
-{
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     minimiser_arguments minimiser_args{};
     initialization_args(ibf_args);
     ibf_args.compressed = false;
-    ibf_args.path_out = tmp_dir/"IBF_True_Exp_";
+    ibf_args.path_out = "IBF_True_Exp_";
     ibf_args.expression_thresholds = {1, 2};
     minimiser_args.experiment_names = false;
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta", std::string(DATA_INPUT_DIR) + "mini_example.fasta"};
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta"), data("mini_example.fasta")};
     std::vector<double> fpr = {0.05};
     std::vector<uint8_t> cutoffs{0,0};
 
@@ -120,51 +116,43 @@ TEST(insert, ibf)
     minimiser_arguments minimiser_args_insert{};
     initialization_args(ibf_args_insert);
     ibf_args_insert.compressed = false;
-    ibf_args_insert.path_out = tmp_dir/"IBF_True_Exp_";
+    ibf_args_insert.path_out = "IBF_True_Exp_";
     ibf_args_insert.expression_thresholds = {1, 2};
     minimiser_args_insert.experiment_names = false;
-    ibf_args_insert.path_out = tmp_dir/"IBF_Insert_Exp_";
-    std::vector<std::filesystem::path> sequence_files_insert = {std::string(DATA_INPUT_DIR) + "mini_example.fasta"};
+    ibf_args_insert.path_out = "IBF_Insert_Exp_";
+    std::vector<std::filesystem::path> sequence_files_insert = {data("mini_example.fasta")};
     ibf(sequence_files_insert, ibf_args_insert, minimiser_args_insert, fpr, cutoffs_insert);
 
-    insert(sequence_files_insert, ibf_args_insert, minimiser_args_insert, cutoffs_insert, "", tmp_dir/"IBF_Insert_Exp_", false);
+    insert(sequence_files_insert, ibf_args_insert, minimiser_args_insert, cutoffs_insert, "", "IBF_Insert_Exp_", false);
 
     seqan3::interleaved_bloom_filter<seqan3::data_layout::uncompressed> ibf;
     seqan3::interleaved_bloom_filter<seqan3::data_layout::uncompressed> ibf_insert;
 
-    load_ibf(ibf, tmp_dir/"IBF_True_Exp_IBF_1");
-    load_ibf(ibf_insert, tmp_dir/"IBF_Insert_Exp_IBF_1");
+    load_ibf(ibf, "IBF_True_Exp_IBF_1");
+    load_ibf(ibf_insert, "IBF_Insert_Exp_IBF_1");
     EXPECT_TRUE((ibf == ibf_insert));
 
-    load_ibf(ibf, tmp_dir/"IBF_True_Exp_IBF_2");
-    load_ibf(ibf_insert, tmp_dir/"IBF_Insert_Exp_IBF_2");
+    load_ibf(ibf, "IBF_True_Exp_IBF_2");
+    load_ibf(ibf_insert, "IBF_Insert_Exp_IBF_2");
     EXPECT_TRUE((ibf == ibf_insert));
 
     std::vector<std::vector<double>> fpr_ibf{};
-    read_levels<double>(fpr_ibf, tmp_dir/"IBF_True_Exp_IBF_FPRs.fprs");
+    read_levels<double>(fpr_ibf, "IBF_True_Exp_IBF_FPRs.fprs");
     std::vector<std::vector<double>> fpr_insert{};
-    read_levels<double>(fpr_insert, tmp_dir/"IBF_Insert_Exp_IBF_FPRs.fprs");
+    read_levels<double>(fpr_insert, "IBF_Insert_Exp_IBF_FPRs.fprs");
     EXPECT_EQ(fpr_ibf,fpr_insert);
-
-    std::filesystem::remove(tmp_dir/"IBF_True_Exp_IBF_1");
-    std::filesystem::remove(tmp_dir/"IBF_True_Exp_IBF_2");
-    std::filesystem::remove(tmp_dir/"IBF_True_Exp_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/"IBF_Insert_Exp_IBF_1");
-    std::filesystem::remove(tmp_dir/"IBF_Insert_Exp_IBF_2");
-    std::filesystem::remove(tmp_dir/"IBF_Insert_Exp_IBF_FPRs.fprs");
 }
 
-TEST(insert, ibf_no_given_thresholds)
+TEST_F(insert_test, ibf_no_given_thresholds)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     minimiser_arguments minimiser_args{};
     initialization_args(ibf_args);
     ibf_args.compressed = false;
-    ibf_args.path_out = tmp_dir/"IBF_True_Exp_";
+    ibf_args.path_out = "IBF_True_Exp_";
     ibf_args.number_expression_thresholds = 2;
     minimiser_args.experiment_names = false;
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta", std::string(DATA_INPUT_DIR) + "mini_example.fasta"};
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta"), data("mini_example.fasta")};
     std::vector<double> fpr = {0.05};
 
     std::vector<uint16_t> expected{};
@@ -179,50 +167,44 @@ TEST(insert, ibf_no_given_thresholds)
     ibf_args_insert.compressed = false;
     ibf_args_insert.number_expression_thresholds = 2;
     minimiser_args_insert.experiment_names = false;
-    ibf_args_insert.path_out = tmp_dir/"IBF_Insert_Exp_";
-    std::vector<std::filesystem::path> sequence_files_insert = {std::string(DATA_INPUT_DIR) + "mini_example.fasta"};
+    ibf_args_insert.path_out = "IBF_Insert_Exp_";
+    std::vector<std::filesystem::path> sequence_files_insert = {data("mini_example.fasta")};
     std::vector<uint16_t> medians_insert = ibf(sequence_files_insert, ibf_args_insert, minimiser_args_insert, fpr, cutoffs_insert);
-    insert(sequence_files_insert, ibf_args_insert, minimiser_args_insert, cutoffs_insert, "", tmp_dir/"IBF_Insert_Exp_", true);
+    insert(sequence_files_insert, ibf_args_insert, minimiser_args_insert, cutoffs_insert, "", "IBF_Insert_Exp_", true);
     seqan3::interleaved_bloom_filter<seqan3::data_layout::uncompressed> ibf;
     seqan3::interleaved_bloom_filter<seqan3::data_layout::uncompressed> ibf_insert;
 
-    load_ibf(ibf, tmp_dir/"IBF_True_Exp_IBF_Level_0");
-    load_ibf(ibf_insert, tmp_dir/"IBF_Insert_Exp_IBF_Level_0");
+    load_ibf(ibf, "IBF_True_Exp_IBF_Level_0");
+    load_ibf(ibf_insert, "IBF_Insert_Exp_IBF_Level_0");
     EXPECT_TRUE((ibf == ibf_insert));
 
-    load_ibf(ibf, tmp_dir/"IBF_True_Exp_IBF_Level_1");
-    load_ibf(ibf_insert, tmp_dir/"IBF_Insert_Exp_IBF_Level_1");
+    load_ibf(ibf, "IBF_True_Exp_IBF_Level_1");
+    load_ibf(ibf_insert, "IBF_Insert_Exp_IBF_Level_1");
     EXPECT_TRUE((ibf == ibf_insert));
 
     std::vector<std::vector<uint16_t>> expressions_ibf{};
-    read_levels<uint16_t>(expressions_ibf, tmp_dir/"IBF_True_Exp_IBF_Levels.levels");
+    read_levels<uint16_t>(expressions_ibf, "IBF_True_Exp_IBF_Levels.levels");
     std::vector<std::vector<uint16_t>> expressions_insert{};
-    read_levels<uint16_t>(expressions_insert, tmp_dir/"IBF_Insert_Exp_IBF_Levels.levels");
+    read_levels<uint16_t>(expressions_insert, "IBF_Insert_Exp_IBF_Levels.levels");
     EXPECT_EQ(expressions_ibf,expressions_insert);
 
     std::vector<std::vector<double>> fpr_ibf{};
-    read_levels<double>(fpr_ibf, tmp_dir/"IBF_True_Exp_IBF_FPRs.fprs");
+    read_levels<double>(fpr_ibf, "IBF_True_Exp_IBF_FPRs.fprs");
     std::vector<std::vector<double>> fpr_insert{};
-    read_levels<double>(fpr_insert, tmp_dir/"IBF_Insert_Exp_IBF_FPRs.fprs");
+    read_levels<double>(fpr_insert, "IBF_Insert_Exp_IBF_FPRs.fprs");
     EXPECT_EQ(fpr_ibf,fpr_insert);
-
-    std::filesystem::remove(tmp_dir/"IBF_True_Exp_IBF_Level_0");
-    std::filesystem::remove(tmp_dir/"IBF_True_Exp_IBF_Level_1");
-    std::filesystem::remove(tmp_dir/"IBF_Insert_Exp_IBF_Level_0");
-    std::filesystem::remove(tmp_dir/"IBF_Insert_Exp_IBF_Level_1");
 }
 
-TEST(insert, ibf_delete)
+TEST_F(insert_test, ibf_delete)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     minimiser_arguments minimiser_args{};
     initialization_args(ibf_args);
     ibf_args.compressed = false;
-    ibf_args.path_out = tmp_dir/"IBF_True_Exp_";
+    ibf_args.path_out = "IBF_True_Exp_";
     ibf_args.expression_thresholds = {1, 2};
     minimiser_args.experiment_names = false;
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta", std::string(DATA_INPUT_DIR) + "mini_example2.fasta", std::string(DATA_INPUT_DIR) + "mini_example.fasta"};
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta"), data("mini_example2.fasta"), data("mini_example.fasta")};
     std::vector<double> fpr = {0.05,0.05};
     std::vector<uint8_t> cutoffs{0,0,0};
 
@@ -233,54 +215,45 @@ TEST(insert, ibf_delete)
     minimiser_arguments minimiser_args_insert{};
     initialization_args(ibf_args_insert);
     ibf_args_insert.compressed = false;
-    ibf_args_insert.path_out = tmp_dir/"IBF_Insert_Exp_";
+    ibf_args_insert.path_out = "IBF_Insert_Exp_";
     ibf_args_insert.expression_thresholds = {1, 2};
     minimiser_args_insert.experiment_names = false;
-    std::vector<std::filesystem::path> sequence_files_insert = {std::string(DATA_INPUT_DIR) + "mini_example2.fasta"};
-    std::vector<std::filesystem::path> sequence_files_test = {std::string(DATA_INPUT_DIR) + "mini_example.fasta", std::string(DATA_INPUT_DIR) + "mini_example2.fasta", std::string(DATA_INPUT_DIR) + "mini_example.fasta"};
+    std::vector<std::filesystem::path> sequence_files_insert = {data("mini_example2.fasta")};
+    std::vector<std::filesystem::path> sequence_files_test = {data("mini_example.fasta"), data("mini_example2.fasta"), data("mini_example.fasta")};
 
     ibf(sequence_files_test, ibf_args_insert, minimiser_args, fpr, cutoffs);
     delete_bin({1}, ibf_args_insert, ibf_args_insert.path_out, false);
-    insert(sequence_files_insert, ibf_args_insert, minimiser_args_insert, cutoffs_insert, "", tmp_dir/"IBF_Insert_Exp_", false);
+    insert(sequence_files_insert, ibf_args_insert, minimiser_args_insert, cutoffs_insert, "", "IBF_Insert_Exp_", false);
 
     seqan3::interleaved_bloom_filter<seqan3::data_layout::uncompressed> ibf;
     seqan3::interleaved_bloom_filter<seqan3::data_layout::uncompressed> ibf_insert;
 
-    load_ibf(ibf, tmp_dir/"IBF_True_Exp_IBF_1");
-    load_ibf(ibf_insert, tmp_dir/"IBF_Insert_Exp_IBF_1");
+    load_ibf(ibf, "IBF_True_Exp_IBF_1");
+    load_ibf(ibf_insert, "IBF_Insert_Exp_IBF_1");
     EXPECT_TRUE((ibf == ibf_insert));
 
-    load_ibf(ibf, tmp_dir/"IBF_True_Exp_IBF_2");
-    load_ibf(ibf_insert, tmp_dir/"IBF_Insert_Exp_IBF_2");
+    load_ibf(ibf, "IBF_True_Exp_IBF_2");
+    load_ibf(ibf_insert, "IBF_Insert_Exp_IBF_2");
     EXPECT_TRUE((ibf == ibf_insert));
 
     std::vector<std::vector<double>> fpr_ibf{};
-    read_levels<double>(fpr_ibf, tmp_dir/"IBF_True_Exp_IBF_FPRs.fprs");
+    read_levels<double>(fpr_ibf, "IBF_True_Exp_IBF_FPRs.fprs");
     std::vector<std::vector<double>> fpr_insert{};
-    read_levels<double>(fpr_insert, tmp_dir/"IBF_Insert_Exp_IBF_FPRs.fprs");
+    read_levels<double>(fpr_insert, "IBF_Insert_Exp_IBF_FPRs.fprs");
     EXPECT_EQ(fpr_ibf,fpr_insert);
-
-    std::filesystem::remove(tmp_dir/"IBF_True_Exp_IBF_1");
-    std::filesystem::remove(tmp_dir/"IBF_True_Exp_IBF_2");
-    std::filesystem::remove(tmp_dir/"IBF_True_Exp_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/"IBF_Insert_Exp_IBF_1");
-    std::filesystem::remove(tmp_dir/"IBF_Insert_Exp_IBF_2");
-    std::filesystem::remove(tmp_dir/"IBF_Insert_Exp_IBF_Deleted");
-    std::filesystem::remove(tmp_dir/"IBF_Insert_Exp_IBF_FPRs.fprs");
 }
 
 
-TEST(insert, ibf_delete_no_given_threshold)
+TEST_F(insert_test, ibf_delete_no_given_threshold)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     minimiser_arguments minimiser_args{};
     initialization_args(ibf_args);
     ibf_args.compressed = false;
-    ibf_args.path_out = tmp_dir/"IBF_True_Exp_";
+    ibf_args.path_out = "IBF_True_Exp_";
     ibf_args.number_expression_thresholds = 2;
     minimiser_args.experiment_names = false;
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta", std::string(DATA_INPUT_DIR) + "mini_example2.fasta", std::string(DATA_INPUT_DIR) + "mini_example.fasta"};
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta"), data("mini_example2.fasta"), data("mini_example.fasta")};
     std::vector<double> fpr = {0.05,0.05};
     std::vector<uint8_t> cutoffs{0,0,0};
 
@@ -291,261 +264,207 @@ TEST(insert, ibf_delete_no_given_threshold)
     minimiser_arguments minimiser_args_insert{};
     initialization_args(ibf_args_insert);
     ibf_args_insert.compressed = false;
-    ibf_args_insert.path_out = tmp_dir/"IBF_Insert_Exp_";
+    ibf_args_insert.path_out = "IBF_Insert_Exp_";
     ibf_args_insert.number_expression_thresholds = 2;
     minimiser_args_insert.experiment_names = false;
-    std::vector<std::filesystem::path> sequence_files_insert = {std::string(DATA_INPUT_DIR) + "mini_example2.fasta"};
-    std::vector<std::filesystem::path> sequence_files_test = {std::string(DATA_INPUT_DIR) + "mini_example.fasta", std::string(DATA_INPUT_DIR) + "mini_example2.fasta", std::string(DATA_INPUT_DIR) + "mini_example.fasta"};
+    std::vector<std::filesystem::path> sequence_files_insert = {data("mini_example2.fasta")};
+    std::vector<std::filesystem::path> sequence_files_test = {data("mini_example.fasta"), data("mini_example2.fasta"), data("mini_example.fasta")};
 
     ibf(sequence_files_test, ibf_args_insert, minimiser_args, fpr, cutoffs);
     delete_bin({1}, ibf_args_insert, ibf_args_insert.path_out, true);
-    insert(sequence_files_insert, ibf_args_insert, minimiser_args_insert, cutoffs_insert, "", tmp_dir/"IBF_Insert_Exp_", true);
+    insert(sequence_files_insert, ibf_args_insert, minimiser_args_insert, cutoffs_insert, "", "IBF_Insert_Exp_", true);
 
     seqan3::interleaved_bloom_filter<seqan3::data_layout::uncompressed> ibf;
     seqan3::interleaved_bloom_filter<seqan3::data_layout::uncompressed> ibf_insert;
 
-    load_ibf(ibf, tmp_dir/"IBF_True_Exp_IBF_Level_0");
+    load_ibf(ibf, "IBF_True_Exp_IBF_Level_0");
 
-    load_ibf(ibf_insert, tmp_dir/"IBF_Insert_Exp_IBF_Level_0");
+    load_ibf(ibf_insert, "IBF_Insert_Exp_IBF_Level_0");
     EXPECT_TRUE((ibf == ibf_insert));
 
-    load_ibf(ibf, tmp_dir/"IBF_True_Exp_IBF_Level_1");
-    load_ibf(ibf_insert, tmp_dir/"IBF_Insert_Exp_IBF_Level_1");
+    load_ibf(ibf, "IBF_True_Exp_IBF_Level_1");
+    load_ibf(ibf_insert, "IBF_Insert_Exp_IBF_Level_1");
     EXPECT_TRUE((ibf == ibf_insert));
 
     std::vector<std::vector<uint16_t>> expressions_ibf{};
-    read_levels<uint16_t>(expressions_ibf, tmp_dir/"IBF_True_Exp_IBF_Levels.levels");
+    read_levels<uint16_t>(expressions_ibf, "IBF_True_Exp_IBF_Levels.levels");
     std::vector<std::vector<uint16_t>> expressions_insert{};
-    read_levels<uint16_t>(expressions_insert, tmp_dir/"IBF_Insert_Exp_IBF_Levels.levels");
+    read_levels<uint16_t>(expressions_insert, "IBF_Insert_Exp_IBF_Levels.levels");
     EXPECT_EQ(expressions_ibf,expressions_insert);
 
     std::vector<std::vector<double>> fpr_ibf{};
-    read_levels<double>(fpr_ibf, tmp_dir/"IBF_True_Exp_IBF_FPRs.fprs");
+    read_levels<double>(fpr_ibf, "IBF_True_Exp_IBF_FPRs.fprs");
     std::vector<std::vector<double>> fpr_insert{};
-    read_levels<double>(fpr_insert, tmp_dir/"IBF_Insert_Exp_IBF_FPRs.fprs");
+    read_levels<double>(fpr_insert, "IBF_Insert_Exp_IBF_FPRs.fprs");
     EXPECT_EQ(fpr_ibf,fpr_insert);
-
-    std::filesystem::remove(tmp_dir/"IBF_True_Exp_IBF_Level_0");
-    std::filesystem::remove(tmp_dir/"IBF_True_Exp_IBF_Level_1");
-    std::filesystem::remove(tmp_dir/"IBF_True_Exp_IBF_Levels.levels");
-    std::filesystem::remove(tmp_dir/"IBF_True_Exp_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/"IBF_Insert_Exp_IBF_Level_0");
-    std::filesystem::remove(tmp_dir/"IBF_Insert_Exp_IBF_Level_1");
-    std::filesystem::remove(tmp_dir/"IBF_Insert_Exp_IBF_Deleted");
-    std::filesystem::remove(tmp_dir/"IBF_Insert_Exp_IBF_Levels.levels");
-    std::filesystem::remove(tmp_dir/"IBF_Insert_Exp_IBF_FPRs.fprs");
 }
 
-TEST(insert, ibfmin)
+TEST_F(insert_test, ibfmin)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     initialization_args(ibf_args);
     ibf_args.expression_thresholds = {1, 2};
     std::vector<double> fpr = {0.05, 0.05};
-    ibf_args.path_out = tmp_dir/"IBFMIN_Test_Given_";
+    ibf_args.path_out = "IBFMIN_Test_Given_";
     ibf_args.compressed = false;
-    std::vector<std::filesystem::path> minimiser_file = {std::string(DATA_INPUT_DIR) + "mini_example.minimiser", std::string(DATA_INPUT_DIR) + "mini_example.minimiser"};
+    std::vector<std::filesystem::path> minimiser_file = {data("mini_example.minimiser"), data("mini_example.minimiser")};
     ibf(minimiser_file, ibf_args, fpr);
 
     estimate_ibf_arguments ibf_args_insert{};
     initialization_args(ibf_args_insert);
     ibf_args_insert.expression_thresholds = {1, 2};
-    ibf_args_insert.path_out = tmp_dir/"IBFMIN_Insert_Given_";
+    ibf_args_insert.path_out = "IBFMIN_Insert_Given_";
     ibf_args_insert.compressed = false;
-    std::vector<std::filesystem::path> minimiser_file_insert = {std::string(DATA_INPUT_DIR) + "mini_example.minimiser"};
+    std::vector<std::filesystem::path> minimiser_file_insert = {data("mini_example.minimiser")};
     ibf(minimiser_file_insert, ibf_args_insert, fpr);
-    insert(minimiser_file_insert, ibf_args_insert, "",  tmp_dir/"IBFMIN_Insert_Given_", false);
+    insert(minimiser_file_insert, ibf_args_insert, "",  "IBFMIN_Insert_Given_", false);
 
     seqan3::interleaved_bloom_filter<seqan3::data_layout::uncompressed> ibf;
     seqan3::interleaved_bloom_filter<seqan3::data_layout::uncompressed> ibf_insert;
 
-    load_ibf(ibf, tmp_dir/"IBFMIN_Test_Given_IBF_1");
-    load_ibf(ibf_insert, tmp_dir/"IBFMIN_Insert_Given_IBF_1");
+    load_ibf(ibf, "IBFMIN_Test_Given_IBF_1");
+    load_ibf(ibf_insert, "IBFMIN_Insert_Given_IBF_1");
     EXPECT_TRUE((ibf == ibf_insert));
 
-    load_ibf(ibf, tmp_dir/"IBFMIN_Test_Given_IBF_2");
-    load_ibf(ibf_insert, tmp_dir/"IBFMIN_Insert_Given_IBF_2");
+    load_ibf(ibf, "IBFMIN_Test_Given_IBF_2");
+    load_ibf(ibf_insert, "IBFMIN_Insert_Given_IBF_2");
     EXPECT_TRUE((ibf == ibf_insert));
 
     std::vector<std::vector<double>> fpr_ibf{};
-    read_levels<double>(fpr_ibf, tmp_dir/"IBFMIN_Test_Given_IBF_FPRs.fprs");
+    read_levels<double>(fpr_ibf, "IBFMIN_Test_Given_IBF_FPRs.fprs");
     std::vector<std::vector<double>> fpr_insert{};
-    read_levels<double>(fpr_insert, tmp_dir/"IBFMIN_Insert_Given_IBF_FPRs.fprs");
+    read_levels<double>(fpr_insert, "IBFMIN_Insert_Given_IBF_FPRs.fprs");
     EXPECT_EQ(fpr_ibf,fpr_insert);
-
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Given_IBF_1");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Given_IBF_2");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Given_IBF_Data");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Given_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Insert_Test_Given_IBF_1");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Insert_Given_IBF_2");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Insert_Given_IBF_Data");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Insert_Given_IBF_FPRs.fprs");
 }
 
-TEST(insert, ibfmin_delete)
+TEST_F(insert_test, ibfmin_delete)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     initialization_args(ibf_args);
     ibf_args.expression_thresholds = {1, 2};
     std::vector<double> fpr = {0.05, 0.05};
-    ibf_args.path_out = tmp_dir/"IBFMIN_Test_Given_";
+    ibf_args.path_out = "IBFMIN_Test_Given_";
     ibf_args.compressed = false;
-    std::vector<std::filesystem::path> minimiser_file = {std::string(DATA_INPUT_DIR) + "mini_example.minimiser", std::string(DATA_INPUT_DIR) + "mini_example.minimiser", std::string(DATA_INPUT_DIR) + "mini_example.minimiser"};
+    std::vector<std::filesystem::path> minimiser_file = {data("mini_example.minimiser"), data("mini_example.minimiser"), data("mini_example.minimiser")};
     ibf(minimiser_file, ibf_args, fpr);
 
     estimate_ibf_arguments ibf_args_insert{};
     initialization_args(ibf_args_insert);
     ibf_args_insert.expression_thresholds = {1, 2};
-    ibf_args_insert.path_out = tmp_dir/"IBFMIN_Insert_Given_";
+    ibf_args_insert.path_out = "IBFMIN_Insert_Given_";
     ibf_args_insert.compressed = false;
-    std::vector<std::filesystem::path> minimiser_file_insert = {std::string(DATA_INPUT_DIR) + "mini_example.minimiser"};
+    std::vector<std::filesystem::path> minimiser_file_insert = {data("mini_example.minimiser")};
     ibf(minimiser_file, ibf_args_insert, fpr);
     delete_bin({1}, ibf_args_insert, ibf_args_insert.path_out, false);
-    insert(minimiser_file_insert, ibf_args_insert, "",  tmp_dir/"IBFMIN_Insert_Given_", false);
+    insert(minimiser_file_insert, ibf_args_insert, "",  "IBFMIN_Insert_Given_", false);
 
     seqan3::interleaved_bloom_filter<seqan3::data_layout::uncompressed> ibf;
     seqan3::interleaved_bloom_filter<seqan3::data_layout::uncompressed> ibf_insert;
 
-    load_ibf(ibf, tmp_dir/"IBFMIN_Test_Given_IBF_1");
-    load_ibf(ibf_insert, tmp_dir/"IBFMIN_Insert_Given_IBF_1");
+    load_ibf(ibf, "IBFMIN_Test_Given_IBF_1");
+    load_ibf(ibf_insert, "IBFMIN_Insert_Given_IBF_1");
     EXPECT_TRUE((ibf == ibf_insert));
 
-    load_ibf(ibf, tmp_dir/"IBFMIN_Test_Given_IBF_2");
-    load_ibf(ibf_insert, tmp_dir/"IBFMIN_Insert_Given_IBF_2");
+    load_ibf(ibf, "IBFMIN_Test_Given_IBF_2");
+    load_ibf(ibf_insert, "IBFMIN_Insert_Given_IBF_2");
     EXPECT_TRUE((ibf == ibf_insert));
 
     std::vector<std::vector<double>> fpr_ibf{};
-    read_levels<double>(fpr_ibf, tmp_dir/"IBFMIN_Test_Given_IBF_FPRs.fprs");
+    read_levels<double>(fpr_ibf, "IBFMIN_Test_Given_IBF_FPRs.fprs");
     std::vector<std::vector<double>> fpr_insert{};
-    read_levels<double>(fpr_insert, tmp_dir/"IBFMIN_Insert_Given_IBF_FPRs.fprs");
+    read_levels<double>(fpr_insert, "IBFMIN_Insert_Given_IBF_FPRs.fprs");
     EXPECT_EQ(fpr_ibf,fpr_insert);
-
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Given_IBF_1");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Given_IBF_2");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Given_IBF_Data");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Given_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Insert_Test_Given_IBF_1");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Insert_Given_IBF_2");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Insert_Given_IBF_Data");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Insert_Given_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Insert_Given_IBF_Deleted");
 }
 
-TEST(insert, ibfmin_no_given_thresholds)
+TEST_F(insert_test, ibfmin_no_given_thresholds)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     initialization_args(ibf_args);
     ibf_args.number_expression_thresholds = 2;
     std::vector<double> fpr = {0.05, 0.05};
-    ibf_args.path_out = tmp_dir/"IBFMIN_Test_Given_";
+    ibf_args.path_out = "IBFMIN_Test_Given_";
     ibf_args.compressed = false;
-    std::vector<std::filesystem::path> minimiser_file = {std::string(DATA_INPUT_DIR) + "mini_example.minimiser", std::string(DATA_INPUT_DIR) + "mini_example.minimiser"};
+    std::vector<std::filesystem::path> minimiser_file = {data("mini_example.minimiser"), data("mini_example.minimiser")};
 
     ibf(minimiser_file, ibf_args, fpr);
 
     estimate_ibf_arguments ibf_args_insert{};
     initialization_args(ibf_args_insert);
     ibf_args_insert.number_expression_thresholds = 2;
-    ibf_args_insert.path_out = tmp_dir/"IBFMIN_Insert_Given_";
+    ibf_args_insert.path_out = "IBFMIN_Insert_Given_";
     ibf_args_insert.compressed = false;
     fpr = {0.05};
-    std::vector<std::filesystem::path> minimiser_file_insert = {std::string(DATA_INPUT_DIR) + "mini_example.minimiser"};
+    std::vector<std::filesystem::path> minimiser_file_insert = {data("mini_example.minimiser")};
     ibf(minimiser_file_insert, ibf_args_insert, fpr);
-    insert(minimiser_file_insert, ibf_args_insert, "",  tmp_dir/"IBFMIN_Insert_Given_", true);
+    insert(minimiser_file_insert, ibf_args_insert, "",  "IBFMIN_Insert_Given_", true);
 
     seqan3::interleaved_bloom_filter<seqan3::data_layout::uncompressed> ibf;
     seqan3::interleaved_bloom_filter<seqan3::data_layout::uncompressed> ibf_insert;
 
-    load_ibf(ibf, tmp_dir/"IBFMIN_Test_Given_IBF_Level_0");
-    load_ibf(ibf_insert, tmp_dir/"IBFMIN_Insert_Given_IBF_Level_0");
+    load_ibf(ibf, "IBFMIN_Test_Given_IBF_Level_0");
+    load_ibf(ibf_insert, "IBFMIN_Insert_Given_IBF_Level_0");
     EXPECT_TRUE((ibf == ibf_insert));
 
-    load_ibf(ibf, tmp_dir/"IBFMIN_Test_Given_IBF_Level_1");
-    load_ibf(ibf_insert, tmp_dir/"IBFMIN_Insert_Given_IBF_Level_1");
+    load_ibf(ibf, "IBFMIN_Test_Given_IBF_Level_1");
+    load_ibf(ibf_insert, "IBFMIN_Insert_Given_IBF_Level_1");
     EXPECT_TRUE((ibf == ibf_insert));
 
     std::vector<std::vector<uint16_t>> expressions_ibf{};
-    read_levels<uint16_t>(expressions_ibf, tmp_dir/"IBFMIN_Test_Given_IBF_Levels.levels");
+    read_levels<uint16_t>(expressions_ibf, "IBFMIN_Test_Given_IBF_Levels.levels");
     std::vector<std::vector<uint16_t>> expressions_insert{};
-    read_levels<uint16_t>(expressions_insert, tmp_dir/"IBFMIN_Insert_Given_IBF_Levels.levels");
+    read_levels<uint16_t>(expressions_insert, "IBFMIN_Insert_Given_IBF_Levels.levels");
     EXPECT_EQ(expressions_ibf,expressions_insert);
 
     std::vector<std::vector<double>> fpr_ibf{};
-    read_levels<double>(fpr_ibf, tmp_dir/"IBFMIN_Test_Given_IBF_FPRs.fprs");
+    read_levels<double>(fpr_ibf, "IBFMIN_Test_Given_IBF_FPRs.fprs");
     std::vector<std::vector<double>> fpr_insert{};
-    read_levels<double>(fpr_insert, tmp_dir/"IBFMIN_Insert_Given_IBF_FPRs.fprs");
+    read_levels<double>(fpr_insert, "IBFMIN_Insert_Given_IBF_FPRs.fprs");
     EXPECT_EQ(fpr_ibf,fpr_insert);
-
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Given_IBF_Level_0");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Given_IBF_Level_1");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Given_IBF_Data");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Given_IBF_Levels.levels");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Insert_Given_IBF_Level_0");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Insert_Given_IBF_Level_1");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Insert_Given_IBF_Data");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Insert_Given_IBF_Levels.levels");
 }
 
-TEST(insert, delete_ibfmin_no_given_thresholds)
+TEST_F(insert_test, delete_ibfmin_no_given_thresholds)
 {
-    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
     estimate_ibf_arguments ibf_args{};
     initialization_args(ibf_args);
     ibf_args.number_expression_thresholds = 2;
     std::vector<double> fpr = {0.05, 0.05};
-    ibf_args.path_out = tmp_dir/"IBFMIN_Test_Given_Del_";
+    ibf_args.path_out = "IBFMIN_Test_Given_Del_";
     ibf_args.compressed = false;
-    std::vector<std::filesystem::path> minimiser_file = {std::string(DATA_INPUT_DIR) + "mini_example.minimiser", std::string(DATA_INPUT_DIR) + "mini_example.minimiser", std::string(DATA_INPUT_DIR) + "mini_example.minimiser"};
+    std::vector<std::filesystem::path> minimiser_file = {data("mini_example.minimiser"), data("mini_example.minimiser"), data("mini_example.minimiser")};
 
     ibf(minimiser_file, ibf_args, fpr);
 
     estimate_ibf_arguments ibf_args_insert{};
     initialization_args(ibf_args_insert);
     ibf_args_insert.number_expression_thresholds = 2;
-    ibf_args_insert.path_out = tmp_dir/"IBFMIN_Insert_Given_Del_";
+    ibf_args_insert.path_out = "IBFMIN_Insert_Given_Del_";
     ibf_args_insert.compressed = false;
     fpr = {0.05};
-    std::vector<std::filesystem::path> minimiser_file_insert = {std::string(DATA_INPUT_DIR) + "mini_example.minimiser"};
+    std::vector<std::filesystem::path> minimiser_file_insert = {data("mini_example.minimiser")};
     ibf(minimiser_file, ibf_args_insert, fpr);
     delete_bin({1}, ibf_args_insert, ibf_args_insert.path_out, true);
-    insert(minimiser_file_insert, ibf_args_insert, "",  tmp_dir/"IBFMIN_Insert_Given_Del_", true);
+    insert(minimiser_file_insert, ibf_args_insert, "",  "IBFMIN_Insert_Given_Del_", true);
 
     seqan3::interleaved_bloom_filter<seqan3::data_layout::uncompressed> ibf;
     seqan3::interleaved_bloom_filter<seqan3::data_layout::uncompressed> ibf_insert;
 
-    load_ibf(ibf, tmp_dir/"IBFMIN_Test_Given_Del_IBF_Level_0");
-    load_ibf(ibf_insert, tmp_dir/"IBFMIN_Insert_Given_Del_IBF_Level_0");
+    load_ibf(ibf, "IBFMIN_Test_Given_Del_IBF_Level_0");
+    load_ibf(ibf_insert, "IBFMIN_Insert_Given_Del_IBF_Level_0");
     EXPECT_TRUE((ibf == ibf_insert));
 
-    load_ibf(ibf, tmp_dir/"IBFMIN_Test_Given_Del_IBF_Level_1");
-    load_ibf(ibf_insert, tmp_dir/"IBFMIN_Insert_Given_Del_IBF_Level_1");
+    load_ibf(ibf, "IBFMIN_Test_Given_Del_IBF_Level_1");
+    load_ibf(ibf_insert, "IBFMIN_Insert_Given_Del_IBF_Level_1");
     EXPECT_TRUE((ibf == ibf_insert));
 
     std::vector<std::vector<uint16_t>> expressions_ibf{};
-    read_levels<uint16_t>(expressions_ibf, tmp_dir/"IBFMIN_Test_Given_Del_IBF_Levels.levels");
+    read_levels<uint16_t>(expressions_ibf, "IBFMIN_Test_Given_Del_IBF_Levels.levels");
     std::vector<std::vector<uint16_t>> expressions_insert{};
-    read_levels<uint16_t>(expressions_insert, tmp_dir/"IBFMIN_Insert_Given_Del_IBF_Levels.levels");
+    read_levels<uint16_t>(expressions_insert, "IBFMIN_Insert_Given_Del_IBF_Levels.levels");
     EXPECT_EQ(expressions_ibf,expressions_insert);
 
     std::vector<std::vector<double>> fpr_ibf{};
-    read_levels<double>(fpr_ibf, tmp_dir/"IBFMIN_Test_Given_IBF_FPRs.fprs");
+    read_levels<double>(fpr_ibf, "IBFMIN_Test_Given_Del_IBF_FPRs.fprs");
     std::vector<std::vector<double>> fpr_insert{};
-    read_levels<double>(fpr_insert, tmp_dir/"IBFMIN_Insert_Given_IBF_FPRs.fprs");
+    read_levels<double>(fpr_insert, "IBFMIN_Insert_Given_Del_IBF_FPRs.fprs");
     EXPECT_EQ(fpr_ibf,fpr_insert);
-
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Given_Del_IBF_Level_0");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Given_Del_IBF_Level_1");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Given_Del_IBF_Data");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Given_Del_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Test_Given_Del_IBF_Levels.levels");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Insert_Given_Del_IBF_Level_0");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Insert_Given_Del_IBF_Level_1");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Insert_Given_Del_IBF_Data");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Insert_Given_Del_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Insert_Given_Del_IBF_Levels.levels");
-    std::filesystem::remove(tmp_dir/"IBFMIN_Insert_Given_Del_IBF_Deleted");
 }
diff --git a/test/api/minimiser_test.cpp b/test/api/minimiser_test.cpp
index 5c33160..6c8d352 100644
--- a/test/api/minimiser_test.cpp
+++ b/test/api/minimiser_test.cpp
@@ -5,15 +5,22 @@
 
 #include "ibf.h"
 #include "shared.h"
+#include "../app_test.hpp"
 
-#ifndef DATA_INPUT_DIR
-#  define DATA_INPUT_DIR @DATA_INPUT_DIR@
-#endif
-
-using seqan3::operator""_shape;
-std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the temp directory
+// To prevent issues when running multiple CLI tests in parallel, give each CLI test unique names:
+struct minimiser_test : public app_test
+{
+    void initialization_args(estimate_ibf_arguments & args)
+    {
+        args.k = 4;
+        args.shape = seqan3::ungapped{args.k};
+        args.w_size = seqan3::window_size{4};
+        args.s = seqan3::seed{0};
+        args.path_out = "Minimiser_Test_";
+        args.compressed = true;
+    }
 
-std::vector<robin_hood::unordered_node_map<uint64_t, uint16_t>> expected_hash_tables{   // minimisers:
+    std::vector<robin_hood::unordered_node_map<uint64_t, uint16_t>> expected_hash_tables{   // minimisers:
                                                                              {{0,2},   // AAAA
                                                                               {1,4},   // AAAC
                                                                               {6,4},   // AACG
@@ -40,18 +47,9 @@ std::vector<robin_hood::unordered_node_map<uint64_t, uint16_t>> expected_hash_ta
                                                                               {165,1}, // GGCC
                                                                               {168,1}, // GGGA
                                                                                      },};
+};
 
-void initialization_args(estimate_ibf_arguments & args)
-{
-    args.k = 4;
-    args.shape = seqan3::ungapped{args.k};
-    args.w_size = seqan3::window_size{4};
-    args.s = seqan3::seed{0};
-    args.path_out = tmp_dir/"Minimiser_Test_";
-    args.compressed = true;
-}
-
-TEST(minimiser, small_example)
+TEST_F(minimiser_test, small_example)
 {
     estimate_ibf_arguments args{};
     minimiser_arguments minimiser_args{};
@@ -59,20 +57,19 @@ TEST(minimiser, small_example)
     std::vector<uint8_t> cutoffs = {0, 0};
     args.expression_thresholds = {0};
     std::vector<double> fpr = {0.05};
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta",
-                                                         std::string(DATA_INPUT_DIR) + "mini_example2.fasta"};
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta"),
+                                                         data("mini_example2.fasta")};
     minimiser(sequence_files, args, minimiser_args, cutoffs);
-    uint32_t normalized_exp_value{};
     robin_hood::unordered_node_map<uint64_t, uint16_t> result_hash_table{};
     std::vector<std::filesystem::path> minimiser_files{};
     uint64_t num_of_minimisers{};
     std::vector<uint64_t> expected_nums{12, 12};
 
-    for (int i = 0; i < sequence_files.size(); ++i)
+    for (size_t i = 0; i < sequence_files.size(); ++i)
     {
         uint8_t cutoff{};
         // Test Header file
-        read_binary_start(args, tmp_dir/("Minimiser_Test_" + std::string{sequence_files[i].stem()} + ".minimiser"), num_of_minimisers, cutoff);
+        read_binary_start(args, ("Minimiser_Test_" + std::string{sequence_files[i].stem()} + ".minimiser"), num_of_minimisers, cutoff);
 
         EXPECT_EQ(4, args.k);
         EXPECT_EQ(4, args.w_size.get());
@@ -82,8 +79,8 @@ TEST(minimiser, small_example)
         EXPECT_EQ(0, cutoff);
 
         // Test binary file
-        read_binary(tmp_dir/("Minimiser_Test_" + std::string{sequence_files[i].stem()} + ".minimiser"), result_hash_table);
-        minimiser_files.push_back(tmp_dir/("Minimiser_Test_" + std::string{sequence_files[i].stem()} + ".minimiser"));
+        read_binary(("Minimiser_Test_" + std::string{sequence_files[i].stem()} + ".minimiser"), result_hash_table);
+        minimiser_files.push_back(("Minimiser_Test_" + std::string{sequence_files[i].stem()} + ".minimiser"));
         for (auto & hash : expected_hash_tables[i])
         {
             EXPECT_EQ(expected_hash_tables[i][hash.first], result_hash_table[hash.first]);
@@ -94,7 +91,7 @@ TEST(minimiser, small_example)
 
     EXPECT_EQ(args.expression_thresholds, ibf(minimiser_files, args, fpr));
     seqan3::interleaved_bloom_filter<seqan3::data_layout::compressed> ibf;
-    load_ibf(ibf, tmp_dir/"Minimiser_Test_IBF_0");
+    load_ibf(ibf, "Minimiser_Test_IBF_0");
     auto agent = ibf.membership_agent();
 
     std::vector<bool> expected_result(2, 0);
@@ -107,32 +104,28 @@ TEST(minimiser, small_example)
     auto & res3 = agent.bulk_contains(27);
     EXPECT_RANGE_EQ(expected_result,  res3);
 
-    std::filesystem::remove(tmp_dir/"Minimiser_Test_IBF_0");
-    std::filesystem::remove(tmp_dir/"Minimiser_Test_IBF_Data");
-    std::filesystem::remove(tmp_dir/"Minimiser_Test_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/("Minimiser_Test_mini_example.minimiser"));
-    std::filesystem::remove(tmp_dir/("Minimiser_Test_mini_example2.minimiser"));
 }
 
-TEST(minimiser, small_example_different_shape)
+TEST_F(minimiser_test, small_example_different_shape)
 {
     estimate_ibf_arguments args{};
     minimiser_arguments minimiser_args{};
     initialization_args(args);
     std::vector<uint8_t> cutoffs = {0, 0};
     args.shape = seqan3::bin_literal{0b1101};
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta",
-                                                         std::string(DATA_INPUT_DIR) + "mini_example2.fasta"};
+    EXPECT_EQ(13, args.shape.to_ulong());
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta"),
+                                                         data("mini_example2.fasta")};
     minimiser(sequence_files, args, minimiser_args, cutoffs);
 
     uint64_t num_of_minimisers{};
     std::vector<uint64_t> expected_nums{12, 11};
 
-    for (int i = 0; i < sequence_files.size(); ++i)
+    for (size_t i = 0; i < sequence_files.size(); ++i)
     {
         uint8_t cutoff{};
         // Test Header file
-        read_binary_start(args, tmp_dir/("Minimiser_Test_" + std::string{sequence_files[i].stem()} + ".minimiser"), num_of_minimisers, cutoff);
+        read_binary_start(args, ("Minimiser_Test_" + std::string{sequence_files[i].stem()} + ".minimiser"), num_of_minimisers, cutoff);
 
         EXPECT_EQ(4, args.k);
         EXPECT_EQ(4, args.w_size.get());
@@ -142,11 +135,9 @@ TEST(minimiser, small_example_different_shape)
         EXPECT_EQ(0, cutoff);
     }
 
-    std::filesystem::remove(tmp_dir/("Minimiser_Test_mini_example.minimiser"));
-    std::filesystem::remove(tmp_dir/("Minimiser_Test_mini_example2.minimiser"));
 }
 
-TEST(minimiser, small_example_samplewise)
+TEST_F(minimiser_test, small_example_samplewise)
 {
     estimate_ibf_arguments args{};
     minimiser_arguments minimiser_args{};
@@ -155,11 +146,10 @@ TEST(minimiser, small_example_samplewise)
     std::vector<uint8_t> cutoffs = {0, 0};
     args.number_expression_thresholds = 1;
     std::vector<double> fpr = {0.05};
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta",
-                                                         std::string(DATA_INPUT_DIR) + "mini_example2.fasta"};
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta"),
+                                                         data("mini_example2.fasta")};
 
     minimiser(sequence_files, args, minimiser_args, cutoffs);
-    uint32_t normalized_exp_value{};
     std::vector<std::vector<uint32_t>> expected_counts{{7}, {12}};
     std::vector<uint16_t> expected_levels{};
     robin_hood::unordered_node_map<uint64_t, uint16_t> result_hash_table{};
@@ -167,12 +157,12 @@ TEST(minimiser, small_example_samplewise)
     uint64_t num_of_minimisers{};
     std::vector<uint64_t> expected_nums{12, 12};
 
-    for (int i = 0; i < sequence_files.size(); ++i)
+    for (size_t i = 0; i < sequence_files.size(); ++i)
     {
         uint8_t cutoff{};
         // Test Header file
         args.expression_thresholds = {};
-        read_binary_start(args, tmp_dir/("Minimiser_Test_" + std::string{sequence_files[i].stem()} + ".minimiser"), num_of_minimisers, cutoff);
+        read_binary_start(args, ("Minimiser_Test_" + std::string{sequence_files[i].stem()} + ".minimiser"), num_of_minimisers, cutoff);
         EXPECT_EQ(4, args.k);
         EXPECT_EQ(4, args.w_size.get());
         EXPECT_EQ(0, args.s.get());
@@ -181,8 +171,8 @@ TEST(minimiser, small_example_samplewise)
         EXPECT_EQ(0, cutoff);
 
         // Test binary file
-        read_binary(tmp_dir/("Minimiser_Test_" + std::string{sequence_files[i].stem()} + ".minimiser"), result_hash_table);
-        minimiser_files.push_back(tmp_dir/("Minimiser_Test_" + std::string{sequence_files[i].stem()} + ".minimiser"));
+        read_binary(("Minimiser_Test_" + std::string{sequence_files[i].stem()} + ".minimiser"), result_hash_table);
+        minimiser_files.push_back(("Minimiser_Test_" + std::string{sequence_files[i].stem()} + ".minimiser"));
         for (auto & hash : expected_hash_tables[i])
         {
             EXPECT_EQ(expected_hash_tables[i][hash.first], result_hash_table[hash.first]);
@@ -194,7 +184,7 @@ TEST(minimiser, small_example_samplewise)
     EXPECT_EQ(expected_levels, ibf(minimiser_files, args, fpr));
 
     seqan3::interleaved_bloom_filter<seqan3::data_layout::compressed> ibf;
-    load_ibf(ibf, tmp_dir/"Minimiser_Test_IBF_Level_0");
+    load_ibf(ibf, "Minimiser_Test_IBF_Level_0");
     auto agent = ibf.membership_agent();
 
     std::vector<bool> expected_result(2, 0);
@@ -206,15 +196,9 @@ TEST(minimiser, small_example_samplewise)
     expected_result[1] = 1;
     auto & res3 = agent.bulk_contains(27);
     EXPECT_RANGE_EQ(expected_result,  res3);
-    std::filesystem::remove(tmp_dir/"Minimiser_Test_IBF_Level_0");
-    std::filesystem::remove(tmp_dir/"Minimiser_Test_IBF_Levels.levels");
-    std::filesystem::remove(tmp_dir/"Minimiser_Test_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/"Minimiser_Test_IBF_Data");
-    std::filesystem::remove(tmp_dir/("Minimiser_Test_mini_example.minimiser"));
-    std::filesystem::remove(tmp_dir/("Minimiser_Test_mini_example2.minimiser"));
 }
 
-TEST(minimiser, cutoff_by_filesize)
+TEST_F(minimiser_test, cutoff_by_filesize)
 {
     estimate_ibf_arguments args{};
     minimiser_arguments minimiser_args{};
@@ -222,20 +206,20 @@ TEST(minimiser, cutoff_by_filesize)
     args.expression_thresholds = {0};
     std::vector<double> fpr = {0.05};
     std::vector<uint8_t> cutoffs{};
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta",
-                                                         std::string(DATA_INPUT_DIR) + "mini_example2.fasta"};
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta"),
+                                                         data("mini_example2.fasta")};
 
     minimiser(sequence_files, args, minimiser_args, cutoffs);
-    uint32_t normalized_exp_value{};
+
     std::vector<std::filesystem::path> minimiser_files{};
     uint64_t num_of_minimisers{};
     std::vector<uint64_t> expected_nums{12, 12};
 
-    for (int i = 0; i < sequence_files.size(); ++i)
+    for (size_t i = 0; i < sequence_files.size(); ++i)
     {
         uint8_t cutoff{};
         // Test Header file
-        read_binary_start(args, tmp_dir/("Minimiser_Test_" + std::string{sequence_files[i].stem()} + ".minimiser"), num_of_minimisers, cutoff);
+        read_binary_start(args, ("Minimiser_Test_" + std::string{sequence_files[i].stem()} + ".minimiser"), num_of_minimisers, cutoff);
 
         EXPECT_EQ(4, args.k);
         EXPECT_EQ(4, args.w_size.get());
@@ -243,13 +227,13 @@ TEST(minimiser, cutoff_by_filesize)
         EXPECT_EQ(15, args.shape.to_ulong());
         EXPECT_EQ(0, cutoff);
         EXPECT_EQ(expected_nums[i], num_of_minimisers);
-        minimiser_files.push_back(tmp_dir/("Minimiser_Test_" + std::string{sequence_files[i].stem()} + ".minimiser"));
+        minimiser_files.push_back(("Minimiser_Test_" + std::string{sequence_files[i].stem()} + ".minimiser"));
     }
 
     EXPECT_EQ(args.expression_thresholds, ibf(minimiser_files, args, fpr));
 
     seqan3::interleaved_bloom_filter<seqan3::data_layout::compressed> ibf;
-    load_ibf(ibf, tmp_dir/"Minimiser_Test_IBF_0");
+    load_ibf(ibf, "Minimiser_Test_IBF_0");
     auto agent = ibf.membership_agent();
 
     std::vector<bool> expected_result(2, 0);
@@ -263,14 +247,9 @@ TEST(minimiser, cutoff_by_filesize)
     auto & res3 = agent.bulk_contains(85);
     EXPECT_RANGE_EQ(expected_result, res3);
 
-    std::filesystem::remove(tmp_dir/"Minimiser_Test_IBF_0");
-    std::filesystem::remove(tmp_dir/"Minimiser_Test_IBF_Data");
-    std::filesystem::remove(tmp_dir/"Minimiser_Test_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/("Minimiser_Test_mini_example.minimiser"));
-    std::filesystem::remove(tmp_dir/("Minimiser_Test_mini_example2.minimiser"));
 }
 
-TEST(minimiser, small_example_two_threads)
+TEST_F(minimiser_test, small_example_two_threads)
 {
     estimate_ibf_arguments args{};
     minimiser_arguments minimiser_args{};
@@ -279,21 +258,20 @@ TEST(minimiser, small_example_two_threads)
     std::vector<uint8_t> cutoffs = {0, 0};
     args.expression_thresholds = {0};
     std::vector<double> fpr = {0.05};
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta",
-                                                         std::string(DATA_INPUT_DIR) + "mini_example2.fasta"};
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta"),
+                                                         data("mini_example2.fasta")};
     minimiser(sequence_files, args, minimiser_args, cutoffs);
     args.threads = 1;
-    uint32_t normalized_exp_value{};
     robin_hood::unordered_node_map<uint64_t, uint16_t> result_hash_table{};
     std::vector<std::filesystem::path> minimiser_files{};
     uint64_t num_of_minimisers{};
     std::vector<uint64_t> expected_nums{12, 12};
 
-    for (int i = 0; i < sequence_files.size(); ++i)
+    for (size_t i = 0; i < sequence_files.size(); ++i)
     {
         uint8_t cutoff{};
         // Test Header file
-        read_binary_start(args, tmp_dir/("Minimiser_Test_" + std::string{sequence_files[i].stem()} + ".minimiser"), num_of_minimisers, cutoff);
+        read_binary_start(args, ("Minimiser_Test_" + std::string{sequence_files[i].stem()} + ".minimiser"), num_of_minimisers, cutoff);
 
         EXPECT_EQ(4, args.k);
         EXPECT_EQ(4, args.w_size.get());
@@ -303,8 +281,8 @@ TEST(minimiser, small_example_two_threads)
         EXPECT_EQ(expected_nums[i], num_of_minimisers);
 
         // Test binary file
-        read_binary(tmp_dir/("Minimiser_Test_" + std::string{sequence_files[i].stem()} + ".minimiser"), result_hash_table);
-        minimiser_files.push_back(tmp_dir/("Minimiser_Test_" + std::string{sequence_files[i].stem()} + ".minimiser"));
+        read_binary(("Minimiser_Test_" + std::string{sequence_files[i].stem()} + ".minimiser"), result_hash_table);
+        minimiser_files.push_back(("Minimiser_Test_" + std::string{sequence_files[i].stem()} + ".minimiser"));
         for (auto & hash : expected_hash_tables[i])
         {
             EXPECT_EQ(expected_hash_tables[i][hash.first], result_hash_table[hash.first]);
@@ -316,7 +294,7 @@ TEST(minimiser, small_example_two_threads)
     EXPECT_EQ(args.expression_thresholds, ibf(minimiser_files, args, fpr));
 
     seqan3::interleaved_bloom_filter<seqan3::data_layout::compressed> ibf;
-    load_ibf(ibf, tmp_dir/"Minimiser_Test_IBF_0");
+    load_ibf(ibf, "Minimiser_Test_IBF_0");
     auto agent = ibf.membership_agent();
 
     std::vector<bool> expected_result(2, 0);
@@ -329,35 +307,29 @@ TEST(minimiser, small_example_two_threads)
     auto & res3 = agent.bulk_contains(27);
     EXPECT_RANGE_EQ(expected_result, res3);
 
-    std::filesystem::remove(tmp_dir/"Minimiser_Test_IBF_0");
-    std::filesystem::remove(tmp_dir/"Minimiser_Test_IBF_Data");
-    std::filesystem::remove(tmp_dir/"Minimiser_Test_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/("Minimiser_Test_mini_example.minimiser"));
-    std::filesystem::remove(tmp_dir/("Minimiser_Test_mini_example2.minimiser"));
 }
 
-TEST(minimiser, small_example_include)
+TEST_F(minimiser_test, small_example_include)
 {
     estimate_ibf_arguments args{};
     minimiser_arguments minimiser_args{};
     initialization_args(args);
-    args.path_out = tmp_dir/"Minimiser_Test_In_";
+    args.path_out = "Minimiser_Test_In_";
     std::vector<uint8_t> cutoffs = {0, 0};
-    minimiser_args.include_file = std::string(DATA_INPUT_DIR) + "mini_gen.fasta";
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta",
-                                                         std::string(DATA_INPUT_DIR) + "mini_example2.fasta"};
+    minimiser_args.include_file = data("mini_gen.fasta");
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta"),
+                                                         data("mini_example2.fasta")};
     minimiser(sequence_files, args, minimiser_args, cutoffs);
-    uint32_t normalized_exp_value{};
     robin_hood::unordered_node_map<uint64_t, uint16_t> result_hash_table{};
     std::vector<std::filesystem::path> minimiser_files{};
     uint64_t num_of_minimisers{};
     std::vector<uint64_t> expected_nums{1, 0};
 
-    for (int i = 0; i < sequence_files.size(); ++i)
+    for (size_t i = 0; i < sequence_files.size(); ++i)
     {
         uint8_t cutoff{};
         // Test Header file
-        read_binary_start(args, tmp_dir/("Minimiser_Test_In_" + std::string{sequence_files[i].stem()} + ".minimiser"), num_of_minimisers, cutoff);
+        read_binary_start(args, ("Minimiser_Test_In_" + std::string{sequence_files[i].stem()} + ".minimiser"), num_of_minimisers, cutoff);
 
         EXPECT_EQ(4, args.k);
         EXPECT_EQ(4, args.w_size.get());
@@ -367,8 +339,8 @@ TEST(minimiser, small_example_include)
         EXPECT_EQ(expected_nums[i], num_of_minimisers);
 
         // Test binary file
-        read_binary(tmp_dir/("Minimiser_Test_In_" + std::string{sequence_files[i].stem()} + ".minimiser"), result_hash_table);
-        minimiser_files.push_back(tmp_dir/("Minimiser_Test_In_" + std::string{sequence_files[i].stem()} + ".minimiser"));
+        read_binary(("Minimiser_Test_In_" + std::string{sequence_files[i].stem()} + ".minimiser"), result_hash_table);
+        minimiser_files.push_back(("Minimiser_Test_In_" + std::string{sequence_files[i].stem()} + ".minimiser"));
         if (i==0)
         {
             for (auto & hash : result_hash_table)
@@ -385,34 +357,31 @@ TEST(minimiser, small_example_include)
         result_hash_table.clear();
     }
 
-    std::filesystem::remove(tmp_dir/("Minimiser_Test_In_mini_example.minimiser"));
-    std::filesystem::remove(tmp_dir/("Minimiser_Test_In_mini_example2.minimiser"));
 }
 
-TEST(minimiser, small_example_exclude)
+TEST_F(minimiser_test, small_example_exclude)
 {
     estimate_ibf_arguments args{};
     minimiser_arguments minimiser_args{};
     initialization_args(args);
-    args.path_out = tmp_dir/"Minimiser_Test_Ex_";
+    args.path_out = "Minimiser_Test_Ex_";
     std::vector<uint8_t> cutoffs = {0, 0};
-    minimiser_args.exclude_file = std::string(DATA_INPUT_DIR) + "mini_gen2.fasta";
+    minimiser_args.exclude_file = data("mini_gen2.fasta");
     args.expression_thresholds = {0};
     std::vector<double> fpr = {0.05};
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta",
-                                                         std::string(DATA_INPUT_DIR) + "mini_example2.fasta"};
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta"),
+                                                         data("mini_example2.fasta")};
     minimiser(sequence_files, args, minimiser_args, cutoffs);
-    uint32_t normalized_exp_value{};
     robin_hood::unordered_node_map<uint64_t, uint16_t> result_hash_table{};
     std::vector<std::filesystem::path> minimiser_files{};
     uint64_t num_of_minimisers{};
     std::vector<uint64_t> expected_nums{11, 12};
 
-    for (int i = 0; i < sequence_files.size(); ++i)
+    for (size_t i = 0; i < sequence_files.size(); ++i)
     {
         uint8_t cutoff{};
         // Test Header file
-        read_binary_start(args, tmp_dir/("Minimiser_Test_Ex_" + std::string{sequence_files[i].stem()} + ".minimiser"), num_of_minimisers, cutoff);
+        read_binary_start(args, ("Minimiser_Test_Ex_" + std::string{sequence_files[i].stem()} + ".minimiser"), num_of_minimisers, cutoff);
 
         EXPECT_EQ(4, args.k);
         EXPECT_EQ(4, args.w_size.get());
@@ -422,8 +391,8 @@ TEST(minimiser, small_example_exclude)
         EXPECT_EQ(0, cutoff);
 
         // Test binary file
-        read_binary(tmp_dir/("Minimiser_Test_Ex_" + std::string{sequence_files[i].stem()} + ".minimiser"), result_hash_table);
-        minimiser_files.push_back(tmp_dir/("Minimiser_Test_Ex_" + std::string{sequence_files[i].stem()} + ".minimiser"));
+        read_binary(("Minimiser_Test_Ex_" + std::string{sequence_files[i].stem()} + ".minimiser"), result_hash_table);
+        minimiser_files.push_back(("Minimiser_Test_Ex_" + std::string{sequence_files[i].stem()} + ".minimiser"));
         EXPECT_TRUE(result_hash_table.find(216) == result_hash_table.end()); //TCGA, only minimiser in mini_gen2
         for (auto & hash : expected_hash_tables[i])
         {
@@ -438,7 +407,7 @@ TEST(minimiser, small_example_exclude)
 
     EXPECT_EQ(args.expression_thresholds, ibf(minimiser_files, args, fpr));
     seqan3::interleaved_bloom_filter<seqan3::data_layout::compressed> ibf;
-    load_ibf(ibf, tmp_dir/"Minimiser_Test_Ex_IBF_0");
+    load_ibf(ibf, "Minimiser_Test_Ex_IBF_0");
     auto agent = ibf.membership_agent();
 
     std::vector<bool> expected_result(2, 0);
@@ -451,14 +420,9 @@ TEST(minimiser, small_example_exclude)
     auto & res3 = agent.bulk_contains(27);
     EXPECT_RANGE_EQ(expected_result,  res3);
 
-    std::filesystem::remove(tmp_dir/"Minimiser_Test_Ex_IBF_0");
-    std::filesystem::remove(tmp_dir/"Minimiser_Test_Ex_IBF_Data");
-    std::filesystem::remove(tmp_dir/"Minimiser_Test_Ex_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/("Minimiser_Test_Ex_mini_example.minimiser"));
-    std::filesystem::remove(tmp_dir/("Minimiser_Test_Ex_mini_example2.minimiser"));
 }
 
-TEST(minimiser, small_example_shape)
+TEST_F(minimiser_test, small_example_shape)
 {
     std::vector<robin_hood::unordered_node_map<uint64_t, uint16_t>> expected_hash_tables_shape{   // minimisers:
                                                                                  {
@@ -484,24 +448,24 @@ TEST(minimiser, small_example_shape)
     minimiser_arguments minimiser_args{};
     initialization_args(args);
     args.shape = seqan3::bin_literal{9};
-    args.path_out = tmp_dir/"Minimiser_Test_Shape_";
+    EXPECT_EQ(9, args.shape.to_ulong());
+    args.path_out = "Minimiser_Test_Shape_";
     std::vector<uint8_t> cutoffs = {0, 0};
     args.expression_thresholds = {0};
     std::vector<double> fpr = {0.05};
-    std::vector<std::filesystem::path> sequence_files = {std::string(DATA_INPUT_DIR) + "mini_example.fasta",
-                                                         std::string(DATA_INPUT_DIR) + "mini_example2.fasta"};
+    std::vector<std::filesystem::path> sequence_files = {data("mini_example.fasta"),
+                                                         data("mini_example2.fasta")};
     minimiser(sequence_files, args, minimiser_args, cutoffs);
-    uint32_t normalized_exp_value{};
     robin_hood::unordered_node_map<uint64_t, uint16_t> result_hash_table{};
     std::vector<std::filesystem::path> minimiser_files{};
     uint64_t num_of_minimisers{};
     std::vector<uint64_t> expected_nums{8, 7};
 
-    for (int i = 0; i < sequence_files.size(); ++i)
+    for (size_t i = 0; i < sequence_files.size(); ++i)
     {
         uint8_t cutoff{};
         // Test Header file
-        read_binary_start(args, tmp_dir/("Minimiser_Test_Shape_" + std::string{sequence_files[i].stem()} + ".minimiser"), num_of_minimisers, cutoff);
+        read_binary_start(args, ("Minimiser_Test_Shape_" + std::string{sequence_files[i].stem()} + ".minimiser"), num_of_minimisers, cutoff);
 
         EXPECT_EQ(4, args.k);
         EXPECT_EQ(4, args.w_size.get());
@@ -511,8 +475,8 @@ TEST(minimiser, small_example_shape)
         EXPECT_EQ(0, cutoff);
 
         // Test binary file
-        read_binary(tmp_dir/("Minimiser_Test_Shape_" + std::string{sequence_files[i].stem()} + ".minimiser"), result_hash_table);
-        minimiser_files.push_back(tmp_dir/("Minimiser_Test_Shape_" + std::string{sequence_files[i].stem()} + ".minimiser"));
+        read_binary(("Minimiser_Test_Shape_" + std::string{sequence_files[i].stem()} + ".minimiser"), result_hash_table);
+        minimiser_files.push_back(("Minimiser_Test_Shape_" + std::string{sequence_files[i].stem()} + ".minimiser"));
         for (auto & hash : expected_hash_tables_shape[i])
             EXPECT_EQ(expected_hash_tables_shape[i][hash.first], result_hash_table[hash.first]);
 
@@ -521,7 +485,7 @@ TEST(minimiser, small_example_shape)
 
     EXPECT_EQ(args.expression_thresholds, ibf(minimiser_files, args, fpr));
     seqan3::interleaved_bloom_filter<seqan3::data_layout::compressed> ibf;
-    load_ibf(ibf, tmp_dir/"Minimiser_Test_Shape_IBF_0");
+    load_ibf(ibf, "Minimiser_Test_Shape_IBF_0");
     auto agent = ibf.membership_agent();
 
     std::vector<bool> expected_result(2, 0);
@@ -534,9 +498,4 @@ TEST(minimiser, small_example_shape)
     auto & res3 = agent.bulk_contains(2);
     EXPECT_RANGE_EQ(expected_result,  res3);
 
-    std::filesystem::remove(tmp_dir/"Minimiser_Test_Shape_IBF_0");
-    std::filesystem::remove(tmp_dir/"Minimiser_Test_Shape_IBF_Data");
-    std::filesystem::remove(tmp_dir/"Minimiser_Test_Shape_IBF_FPRs.fprs");
-    std::filesystem::remove(tmp_dir/("Minimiser_Test_Shape_mini_example.minimiser"));
-    std::filesystem::remove(tmp_dir/("Minimiser_Test_Shape_mini_example2.minimiser"));
 }
diff --git a/test/app_test.hpp b/test/app_test.hpp
new file mode 100644
index 0000000..84ca45f
--- /dev/null
+++ b/test/app_test.hpp
@@ -0,0 +1,120 @@
+// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
+// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
+// SPDX-License-Identifier: CC0-1.0
+
+#pragma once
+
+#include <gtest/gtest.h>
+
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <sstream>
+#include <string>
+
+// Checks for CLI test result for success, and prints the command line call if the test fails.
+#ifndef EXPECT_SUCCESS
+#    define EXPECT_SUCCESS(arg) EXPECT_EQ(arg.exit_code, 0) << "Command: " << arg.command
+#endif
+
+// Checks the exit code of a CLI test result for failure, and prints the command line call if the test fails.
+#ifndef EXPECT_FAILURE
+#    define EXPECT_FAILURE(arg) EXPECT_NE(arg.exit_code, 0) << "Command: " << arg.command
+#endif
+
+// Provides functions for CLI test implementation.
+struct app_test : public ::testing::Test
+{
+private:
+    // Holds the original work directory where Gtest has been started.
+    std::filesystem::path original_workdir{};
+
+protected:
+    // Result struct for captured streams and exit code.
+    struct app_test_result
+    {
+        std::string out{};
+        std::string err{};
+        std::string command{};
+        int exit_code{};
+    };
+
+    // Invoke the app execution. The command line call should be given as separate parameters.
+    template <typename... CommandItemTypes>
+    app_test_result execute_app(CommandItemTypes &&... command_items)
+    {
+        app_test_result result{};
+
+        // Assemble the command string and disable version check.
+        result.command = [&command_items...]()
+        {
+            std::ostringstream command{};
+            command << "SEQAN3_NO_VERSION_CHECK=1 " << BINDIR << APPNAME;
+            (void)((command << ' ' << command_items), ...); // (void) silences "state has no effect" warning if no items
+            return command.str();
+        }();
+
+        // Always capture the output streams.
+        testing::internal::CaptureStdout();
+        testing::internal::CaptureStderr();
+
+        // Run the command and return results.
+        result.exit_code = std::system(result.command.c_str());
+        result.out = testing::internal::GetCapturedStdout();
+        result.err = testing::internal::GetCapturedStderr();
+        return result;
+    }
+
+    // Generate the full path of a test input file that is provided in the data directory.
+    static std::filesystem::path data(std::string const & filename)
+    {
+        return std::filesystem::path{std::string{DATADIR}}.concat(filename);
+    }
+
+    // Read the contents of a file into a string.
+    static std::string const string_from_file(std::filesystem::path const & path,
+                                              std::ios_base::openmode const mode = std::ios_base::in)
+    {
+        std::ifstream file_stream(path, mode);
+        if (!file_stream.is_open())
+            throw std::logic_error{"Cannot open " + path.string()};
+        std::stringstream file_buffer;
+        file_buffer << file_stream.rdbuf();
+        return {file_buffer.str()};
+    }
+
+    // Create an individual work directory for the current test.
+    void SetUp() override
+    {
+        // Assemble the directory name.
+        ::testing::TestInfo const * const info = ::testing::UnitTest::GetInstance()->current_test_info();
+        std::filesystem::path const test_dir{std::string{OUTPUTDIR} +              //
+                                             std::string{info->test_case_name()} + //
+                                             std::string{"."} +                    //
+                                             std::string{info->name()}};
+        try
+        {
+            std::filesystem::remove_all(test_dir);              // delete the directory if it exists
+            std::filesystem::create_directories(test_dir);      // create the new empty directory
+            original_workdir = std::filesystem::current_path(); // store original work dir path
+            std::filesystem::current_path(test_dir);            // change the work dir
+        }
+        catch (std::exception const & exc)
+        {
+            FAIL() << "Failed to set up the test directory " << test_dir << ":\n" << exc.what();
+        }
+    }
+
+    // Switch back to the initial work directory.
+    void TearDown() override
+    {
+        try
+        {
+            std::filesystem::current_path(original_workdir); // restore the original work dir
+        }
+        catch (std::exception const & exc)
+        {
+            FAIL() << "Failed to set the work directory to " << original_workdir << ":\n" << exc.what();
+        }
+    }
+};
diff --git a/test/cli/CMakeLists.txt b/test/cli/CMakeLists.txt
index eb6c29e..8c984d1 100644
--- a/test/cli/CMakeLists.txt
+++ b/test/cli/CMakeLists.txt
@@ -1,15 +1,13 @@
-cmake_minimum_required (VERSION 3.9)
+# SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
+# SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
+# SPDX-License-Identifier: CC0-1.0
 
-add_cli_test (needle_options_test.cpp)
-add_cli_test (ibf_options_test.cpp)
-target_use_datasources (ibf_options_test FILES exp_01.fasta mini_example.fasta mini_example.minimiser)
-add_cli_test (insert_options_test.cpp)
-target_use_datasources (insert_options_test FILES exp_01.fasta mini_example.fasta mini_example.minimiser)
-add_cli_test (minimiser_options_test.cpp)
-target_use_datasources (minimiser_options_test FILES mini_example.fasta)
-add_cli_test (estimate_options_test.cpp)
-target_use_datasources (estimate_options_test FILES IBF_1 mini_gen.fasta)
-add_cli_test (count_options_test.cpp)
-target_use_datasources (count_options_test FILES mini_example.fasta mini_gen.fasta mini_gen.genome)
-add_cli_test (delete_options_test.cpp)
-target_use_datasources (delete_options_test FILES exp_01.fasta)
+cmake_minimum_required (VERSION 3.25)
+
+add_app_test (needle_options_test.cpp)
+add_app_test (ibf_options_test.cpp)
+add_app_test (insert_options_test.cpp)
+add_app_test (minimiser_options_test.cpp)
+add_app_test (estimate_options_test.cpp)
+add_app_test (count_options_test.cpp)
+add_app_test (delete_options_test.cpp)
diff --git a/test/cli/count_options_test.cpp b/test/cli/count_options_test.cpp
index 5621882..43e3310 100644
--- a/test/cli/count_options_test.cpp
+++ b/test/cli/count_options_test.cpp
@@ -1,12 +1,12 @@
 #include <string>                // strings
 
-#include "cli_test.hpp"
+#include "../app_test.hpp"
 
-struct count_options_test : public cli_test {};
+struct count_options_test : public app_test {};
 
 TEST_F(count_options_test, no_options)
 {
-    cli_test_result result = execute_app("needle count");
+    app_test_result result = execute_app("count");
     std::string expected
     {
         "needle-count - Get expression value depending on minimizers. "
@@ -21,91 +21,91 @@ TEST_F(count_options_test, no_options)
         "==========================================\n    "
         "Try -h or --help for more information.\n"
     };
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, expected);
     EXPECT_EQ(result.err, std::string{});
 }
 
 TEST_F(count_options_test, fail_no_argument)
 {
-    cli_test_result result = execute_app("needle count", "--seed 0 --genome", data("mini_gen.genome")," --include", data("mini_gen.fasta"));
+    app_test_result result = execute_app("count", "--seed 0 --genome", data("mini_gen.genome")," --include", data("mini_gen.fasta"));
     std::string expected
     {
         "Error. Incorrect command line input for count. Not enough positional arguments provided "
         "(Need at least 1). See -h/--help for more information.\n"
     };
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, std::string{});
     EXPECT_EQ(result.err, expected);
 }
 
 TEST_F(count_options_test, with_arguments)
 {
-    cli_test_result result = execute_app("needle count -k 4 -w 4 --seed 0 --genome", data("mini_gen.genome")," --include", data("mini_gen.fasta"), data("mini_example.fasta"));
-    EXPECT_EQ(result.exit_code, 0);
+    app_test_result result = execute_app("count -k 4 -w 4 --seed 0 --genome", data("mini_gen.genome")," --include", data("mini_gen.fasta"), data("mini_example.fasta"));
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, "");
     EXPECT_EQ(result.err, std::string{});
 }
 
 TEST_F(count_options_test, multithreads)
 {
-    cli_test_result result = execute_app("needle count -k 4 -w 8 -t 2 --genome",
+    app_test_result result = execute_app("count -k 4 -w 8 -t 2 --genome",
                                         data("mini_gen.genome"),
                                         " --include",
                                         data("mini_gen.fasta"),
                                         data("mini_example.fasta"),
                                         data("mini_example.fasta"));
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, "");
     EXPECT_EQ(result.err, std::string{});
 }
 
 TEST_F(count_options_test, paired)
 {
-    cli_test_result result = execute_app("needle count -k 4 -w 8 -p --genome",
+    app_test_result result = execute_app("count -k 4 -w 8 -p --genome",
                                         data("mini_gen.genome"),
                                         " --include",
                                         data("mini_gen.fasta"),
                                         data("mini_example.fasta"),
                                         data("mini_example.fasta"));
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, "");
     EXPECT_EQ(result.err, std::string{});
 }
 
-struct genome_options_test : public cli_test {};
+struct genome_options_test : public app_test {};
 
 TEST_F(genome_options_test, no_options)
 {
-    cli_test_result result = execute_app("needle genome");
+    app_test_result result = execute_app("genome");
     std::string expected
     {
         "needle-genome - Creates the genome file necessary as an input to count.\n"
         "=======================================================================\n"
         "    Try -h or --help for more information.\n"
     };
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, expected);
     EXPECT_EQ(result.err, std::string{});
 }
 
 TEST_F(genome_options_test, fail_no_argument)
 {
-    cli_test_result result = execute_app("needle genome", "--seed 0");
+    app_test_result result = execute_app("genome", "--seed 0");
     std::string expected
     {
         "Error. Incorrect command line input for count. Not enough positional arguments provided "
         "(Need at least 1). See -h/--help for more information.\n"
     };
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, std::string{});
     EXPECT_EQ(result.err, expected);
 }
 
 TEST_F(genome_options_test, with_arguments)
 {
-    cli_test_result result = execute_app("needle genome -k 4 -w 4 --seed 0 ", data("mini_gen.fasta"));
-    EXPECT_EQ(result.exit_code, 0);
+    app_test_result result = execute_app("genome -k 4 -w 4 --seed 0 ", data("mini_gen.fasta"));
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, "");
     EXPECT_EQ(result.err, std::string{});
 }
diff --git a/test/cli/delete_options_test.cpp b/test/cli/delete_options_test.cpp
index d26b11b..fbbe668 100644
--- a/test/cli/delete_options_test.cpp
+++ b/test/cli/delete_options_test.cpp
@@ -1,22 +1,22 @@
 #include <string>                // strings
 
-#include "cli_test.hpp"
+#include "../app_test.hpp"
 
 #include "ibf.h"
 #include "shared.h"
 
-struct delete_options_test : public cli_test {};
+struct delete_options_test : public app_test {};
 
 TEST_F(delete_options_test, delete_no_options)
 {
-    cli_test_result result = execute_app("needle delete");
+    app_test_result result = execute_app("delete");
     std::string expected
     {
         "needle-delete - Delete experiments specified by their position from the Needle index.\n"
         "=====================================================================================\n"
         "    Try -h or --help for more information.\n"
     };
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, expected);
     EXPECT_EQ(result.err, std::string{});
 }
@@ -32,8 +32,8 @@ TEST_F(delete_options_test, with_argument)
     std::vector<uint8_t> cutoffs{};
     ibf(sequence_files, ibf_args, minimiser_args, fpr, cutoffs);
 
-    cli_test_result result = execute_app("needle delete -i ", "Test_ ", "0");
-    EXPECT_EQ(result.exit_code, 0);
+    app_test_result result = execute_app("delete -i ", "Test_ ", "0");
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, "");
     EXPECT_EQ(result.err, std::string{});
 }
diff --git a/test/cli/estimate_options_test.cpp b/test/cli/estimate_options_test.cpp
index 53a21ee..1781f6c 100644
--- a/test/cli/estimate_options_test.cpp
+++ b/test/cli/estimate_options_test.cpp
@@ -1,35 +1,35 @@
 #include <string>                // strings
 
-#include "cli_test.hpp"
+#include "../app_test.hpp"
 
 #include "ibf.h"
 #include "shared.h"
 
-struct estimate_options_test : public cli_test {};
+struct estimate_options_test : public app_test {};
 
 TEST_F(estimate_options_test, no_options)
 {
-    cli_test_result result = execute_app("needle estimate");
+    app_test_result result = execute_app("estimate");
     std::string expected
     {
         "needle-estimate - Estimate expression value of transcript based on the Needle index.\n"
         "====================================================================================\n"
         "    Try -h or --help for more information.\n"
     };
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, expected);
     EXPECT_EQ(result.err, std::string{});
 }
 
 TEST_F(estimate_options_test, fail_no_argument)
 {
-    cli_test_result result = execute_app("needle estimate", "-m");
+    app_test_result result = execute_app("estimate", "-m");
     std::string expected
     {
         "Error. Incorrect command line input for estimate. Not enough positional arguments provided "
         "(Need at least 1). See -h/--help for more information.\n"
     };
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, std::string{});
     EXPECT_EQ(result.err, expected);
 }
@@ -45,8 +45,8 @@ TEST_F(estimate_options_test, with_argument)
     std::vector<uint8_t> cutoffs{};
     ibf(sequence_files, ibf_args, minimiser_args, fpr, cutoffs);
 
-    cli_test_result result = execute_app("needle estimate -i ", "Test_", data("mini_gen.fasta"));
-    EXPECT_EQ(result.exit_code, 0);
+    app_test_result result = execute_app("estimate -i ", "Test_", data("mini_gen.fasta"));
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, "");
     EXPECT_EQ(result.err, std::string{});
 }
@@ -62,8 +62,8 @@ TEST_F(estimate_options_test, with_argument_normalization_method)
     std::vector<uint8_t> cutoffs{};
     ibf(sequence_files, ibf_args, minimiser_args, fpr, cutoffs);
 
-    cli_test_result result = execute_app("needle estimate -m -i ", "Test_", data("mini_gen.fasta"));
-    EXPECT_EQ(result.exit_code, 0);
+    app_test_result result = execute_app("estimate -m -i ", "Test_", data("mini_gen.fasta"));
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, "");
     EXPECT_EQ(result.err, std::string{});
 }
@@ -79,8 +79,8 @@ TEST_F(estimate_options_test, with_argument_out)
     std::vector<uint8_t> cutoffs{};
     ibf(sequence_files, ibf_args, minimiser_args, fpr, cutoffs);
 
-    cli_test_result result = execute_app("needle estimate -o ", "expressions.out","-i ", "Test_", data("mini_gen.fasta"));
-    EXPECT_EQ(result.exit_code, 0);
+    app_test_result result = execute_app("estimate -o ", "expressions.out","-i ", "Test_", data("mini_gen.fasta"));
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, "");
     EXPECT_EQ(result.err, std::string{});
 }
diff --git a/test/cli/ibf_options_test.cpp b/test/cli/ibf_options_test.cpp
index d41b8cf..03178e3 100644
--- a/test/cli/ibf_options_test.cpp
+++ b/test/cli/ibf_options_test.cpp
@@ -1,51 +1,51 @@
 #include <string>                // strings
 
-#include "cli_test.hpp"
+#include "../app_test.hpp"
 
-struct ibf_options_test : public cli_test {};
+struct ibf_options_test : public app_test {};
 
 TEST_F(ibf_options_test, ibf_no_options)
 {
-    cli_test_result result = execute_app("needle ibf");
+    app_test_result result = execute_app("ibf");
     std::string expected
     {
         "needle-ibf - Constructs the Needle index.\n"
         "=========================================\n"
         "    Try -h or --help for more information.\n"
     };
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, expected);
     EXPECT_EQ(result.err, std::string{});
 }
 
 TEST_F(ibf_options_test, ibf_fail_no_argument)
 {
-    cli_test_result result = execute_app("needle ibf", "-c");
+    app_test_result result = execute_app("ibf", "-c");
     std::string expected
     {
         "Error. Incorrect command line input for ibf. Not enough positional arguments provided "
         "(Need at least 1). See -h/--help for more information.\n"
     };
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, std::string{""});
     EXPECT_EQ(result.err, expected);
 }
 
 TEST_F(ibf_options_test, ibf_fail_contradiction)
 {
-    cli_test_result result = execute_app("needle ibf -f 0.05 -e 1 -e 2 -l 1", data("exp_01.fasta"));
+    app_test_result result = execute_app("ibf -f 0.05 -e 1 -e 2 -l 1", data("exp_01.fasta"));
     std::string expected
     {
         "Error. Please set the expression levels OR give the number of expression levels.\n"
     };
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, std::string{""});
     EXPECT_EQ(result.err, expected);
 }
 
 TEST_F(ibf_options_test, ibf_fail_contradiction2)
 {
-    cli_test_result result = execute_app("needle ibf -f 0.05 -e 1 -e 2 --levels-by-genome ", data("exp_01.fasta"),
+    app_test_result result = execute_app("ibf -f 0.05 -e 1 -e 2 --levels-by-genome ", data("exp_01.fasta"),
                                          data("exp_01.fasta"));
     std::string expected
     {
@@ -53,101 +53,101 @@ TEST_F(ibf_options_test, ibf_fail_contradiction2)
         "the expression levels without the option --level-by-genome OR use the number of expression levels with that option."
         "\n"
     };
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, std::string{""});
     EXPECT_EQ(result.err, expected);
 }
 
 TEST_F(ibf_options_test, ibf_fail_no_fpr)
 {
-    cli_test_result result = execute_app("needle ibf -l 2", data("exp_01.fasta"));
+    app_test_result result = execute_app("ibf -l 2", data("exp_01.fasta"));
     std::string expected
     {
         "Error. Please give a false positive rate for the IBFs.\n"
     };
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, std::string{""});
     EXPECT_EQ(result.err, expected);
 }
 
 TEST_F(ibf_options_test, ibf_fail_incorrect_number_of_fprs)
 {
-    cli_test_result result = execute_app("needle ibf -f 0.05 -f 0.01 -f 0.03 -l 2", data("exp_01.fasta"));
+    app_test_result result = execute_app("ibf -f 0.05 -f 0.01 -f 0.03 -l 2", data("exp_01.fasta"));
     std::string expected
     {
         "Error. Length of false positive rates for IBFs is not equal to length of expression thresholds.\n"
     };
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, std::string{""});
     EXPECT_EQ(result.err, expected);
 }
 
 TEST_F(ibf_options_test, ibf_with_argument)
 {
-    cli_test_result result = execute_app("needle ibf -f 0.05 -l 1", data("exp_01.fasta"));
-    EXPECT_EQ(result.exit_code, 0);
+    app_test_result result = execute_app("ibf -f 0.05 -l 1", data("exp_01.fasta"));
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, "");
     EXPECT_EQ(result.err, std::string{});
 }
 
 TEST_F(ibf_options_test, ibf_with_argument_with_options)
 {
-    cli_test_result result = execute_app("needle ibf -f 0.05 -k 4 -w 8 -l 1", data("exp_01.fasta"));
-    EXPECT_EQ(result.exit_code, 0);
+    app_test_result result = execute_app("ibf -f 0.05 -k 4 -w 8 -l 1", data("exp_01.fasta"));
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, "");
     EXPECT_EQ(result.err, std::string{});
 }
 
 TEST_F(ibf_options_test, ibf_with_argument_with_userdefined_shape)
 {
-    cli_test_result result = execute_app("needle ibf -f 0.05 -k 4 -w 8 --shape 11 -l 1", data("exp_01.fasta"));
-    EXPECT_EQ(result.exit_code, 0);
+    app_test_result result = execute_app("ibf -f 0.05 -k 4 -w 8 --shape 11 -l 1", data("exp_01.fasta"));
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, "");
     EXPECT_EQ(result.err, std::string{});
 }
 
 TEST_F(ibf_options_test, ibfmin_no_options)
 {
-    cli_test_result result = execute_app("needle ibfmin");
+    app_test_result result = execute_app("ibfmin");
     std::string expected
     {
         "needle-ibfmin - Constructs the Needle index from the minimiser files created by needle minimiser.\n"
         "=================================================================================================\n"
         "    Try -h or --help for more information.\n"
     };
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, expected);
     EXPECT_EQ(result.err, std::string{});
 }
 
 TEST_F(ibf_options_test, ibfmin_fail_no_argument)
 {
-    cli_test_result result = execute_app("needle ibfmin -c");
+    app_test_result result = execute_app("ibfmin -c");
     std::string expected
     {
         "Error. Incorrect command line input for ibfmin. Not enough positional arguments provided "
         "(Need at least 1). See -h/--help for more information.\n"
     };
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, std::string{});
     EXPECT_EQ(result.err, expected);
 }
 
 TEST_F(ibf_options_test, ibfmin_fail_contradiction)
 {
-    cli_test_result result = execute_app("needle ibfmin -f 0.05 -e 1 -e 2 -l 1", data("mini_example.minimiser"));
+    app_test_result result = execute_app("ibfmin -f 0.05 -e 1 -e 2 -l 1", data("mini_example.minimiser"));
     std::string expected
     {
         "Error. Please set the expression levels OR give the number of expression levels.\n"
     };
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, std::string{""});
     EXPECT_EQ(result.err, expected);
 }
 
 TEST_F(ibf_options_test, ibfmin_fail_contradiction2)
 {
-    cli_test_result result = execute_app("needle ibfmin -f 0.05 -e 1 -e 2 --levels-by-genome ", data("exp_01.fasta"),
+    app_test_result result = execute_app("ibfmin -f 0.05 -e 1 -e 2 --levels-by-genome ", data("exp_01.fasta"),
                                          data("mini_example.minimiser"));
     std::string expected
     {
@@ -155,63 +155,63 @@ TEST_F(ibf_options_test, ibfmin_fail_contradiction2)
         "the expression levels without the option --level-by-genome OR use the number of expression levels with that option."
         "\n"
     };
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, std::string{""});
     EXPECT_EQ(result.err, expected);
 }
 
 TEST_F(ibf_options_test, ibfmin_fail_no_fpr)
 {
-    cli_test_result result = execute_app("needle ibfmin -l 2", data("mini_example.minimiser"));
+    app_test_result result = execute_app("ibfmin -l 2", data("mini_example.minimiser"));
     std::string expected
     {
         "Error. Please give a false positive rate for the IBFs.\n"
     };
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, std::string{""});
     EXPECT_EQ(result.err, expected);
 }
 
 TEST_F(ibf_options_test, ibfmin_fail_incorrect_number_of_fprs)
 {
-    cli_test_result result = execute_app("needle ibfmin -f 0.05 -f 0.01 -f 0.03 -l 2", data("mini_example.minimiser"));
+    app_test_result result = execute_app("ibfmin -f 0.05 -f 0.01 -f 0.03 -l 2", data("mini_example.minimiser"));
     std::string expected
     {
         "Error. Length of false positive rates for IBFs is not equal to length of expression thresholds.\n"
     };
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, std::string{""});
     EXPECT_EQ(result.err, expected);
 }
 
 TEST_F(ibf_options_test, ibfmin_with_argument)
 {
-    cli_test_result result = execute_app("needle ibfmin -f 0.05 -l 1", data("mini_example.minimiser"));
-    EXPECT_EQ(result.exit_code, 0);
+    app_test_result result = execute_app("ibfmin -f 0.05 -l 1", data("mini_example.minimiser"));
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, "");
     EXPECT_EQ(result.err, std::string{});
 }
 
 TEST_F(ibf_options_test, compressed)
 {
-    cli_test_result result = execute_app("needle ibfmin -f 0.05 -l 1 -c ", data("mini_example.minimiser"));
-    EXPECT_EQ(result.exit_code, 0);
+    app_test_result result = execute_app("ibfmin -f 0.05 -l 1 -c ", data("mini_example.minimiser"));
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, "");
     EXPECT_EQ(result.err, std::string{});
 }
 
 TEST_F(ibf_options_test, more_hash_functions)
 {
-    cli_test_result result = execute_app("needle ibfmin -f 0.05 -l 1 -n 4 ", data("mini_example.minimiser"));
-    EXPECT_EQ(result.exit_code, 0);
+    app_test_result result = execute_app("ibfmin -f 0.05 -l 1 -n 4 ", data("mini_example.minimiser"));
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, "");
     EXPECT_EQ(result.err, std::string{});
 }
 
 TEST_F(ibf_options_test, expression_thresholds)
 {
-    cli_test_result result = execute_app("needle ibfmin -f 0.05 -e 2 -e 4", data("mini_example.minimiser"));
-    EXPECT_EQ(result.exit_code, 0);
+    app_test_result result = execute_app("ibfmin -f 0.05 -e 2 -e 4", data("mini_example.minimiser"));
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, "");
     EXPECT_EQ(result.err, std::string{});
 }
diff --git a/test/cli/insert_options_test.cpp b/test/cli/insert_options_test.cpp
index 4499699..3fe3610 100644
--- a/test/cli/insert_options_test.cpp
+++ b/test/cli/insert_options_test.cpp
@@ -1,35 +1,35 @@
 #include <string>                // strings
 
-#include "cli_test.hpp"
+#include "../app_test.hpp"
 
 #include "ibf.h"
 #include "shared.h"
 
-struct insert_options_test : public cli_test {};
+struct insert_options_test : public app_test {};
 
 TEST_F(insert_options_test, insert_no_options)
 {
-    cli_test_result result = execute_app("needle insert");
+    app_test_result result = execute_app("insert");
     std::string expected
     {
         "needle-insert - Inserts into a given uncompressed Needle index.\n"
         "===============================================================\n"
         "    Try -h or --help for more information.\n"
     };
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, expected);
     EXPECT_EQ(result.err, std::string{});
 }
 
 TEST_F(insert_options_test, insert_fail_no_argument)
 {
-    cli_test_result result = execute_app("needle insert", "-c");
+    app_test_result result = execute_app("insert", "-c");
     std::string expected
     {
         "Error. Incorrect command line input for insert. Not enough positional arguments provided "
         "(Need at least 1). See -h/--help for more information.\n"
     };
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, std::string{""});
     EXPECT_EQ(result.err, expected);
 }
@@ -46,8 +46,8 @@ TEST_F(insert_options_test, with_argument)
     std::vector<uint8_t> cutoffs{1};
     ibf(sequence_files, ibf_args, minimiser_args, fpr, cutoffs);
 
-    cli_test_result result = execute_app("needle insert -i ", tmp_dir/"Test_", data("exp_01.fasta"));
-    EXPECT_EQ(result.exit_code, 0);
+    app_test_result result = execute_app("insert -i ", tmp_dir/"Test_", data("exp_01.fasta"));
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, "");
     EXPECT_EQ(result.err, std::string{});
 }
diff --git a/test/cli/minimiser_options_test.cpp b/test/cli/minimiser_options_test.cpp
index 975f4b6..d823a6d 100644
--- a/test/cli/minimiser_options_test.cpp
+++ b/test/cli/minimiser_options_test.cpp
@@ -1,88 +1,88 @@
 #include <string>                // strings
 
-#include "cli_test.hpp"
+#include "../app_test.hpp"
 
-struct minimiser_options_test : public cli_test {};
+struct minimiser_options_test : public app_test {};
 
 TEST_F(minimiser_options_test, no_options)
 {
-    cli_test_result result = execute_app("needle minimiser");
+    app_test_result result = execute_app("minimiser");
     std::string expected
     {
         "needle-minimiser - Calculates minimiser for given experiments.\n"
         "==============================================================\n"
         "    Try -h or --help for more information.\n"
     };
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, expected);
     EXPECT_EQ(result.err, std::string{});
 }
 
 TEST_F(minimiser_options_test, fail_no_argument)
 {
-    cli_test_result result = execute_app("needle minimiser", "--seed 0");
+    app_test_result result = execute_app("minimiser", "--seed 0");
     std::string expected
     {
         "Error. Incorrect command line input for minimiser. Not enough positional arguments provided "
         "(Need at least 1). See -h/--help for more information.\n"
     };
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, std::string{});
     EXPECT_EQ(result.err, expected);
 }
 
 TEST_F(minimiser_options_test, with_arguments)
 {
-    cli_test_result result = execute_app("needle minimiser -k 4 -w 4 --seed 0", data("mini_example.fasta"));
-    EXPECT_EQ(result.exit_code, 0);
+    app_test_result result = execute_app("minimiser -k 4 -w 4 --seed 0", data("mini_example.fasta"));
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, "");
     EXPECT_EQ(result.err, std::string{});
 }
 
 TEST_F(minimiser_options_test, cutoff)
 {
-    cli_test_result result = execute_app("needle minimiser -k 4 -w 8 --cutoff 2", data("mini_example.fasta"));
-    EXPECT_EQ(result.exit_code, 0);
+    app_test_result result = execute_app("minimiser -k 4 -w 8 --cutoff 2", data("mini_example.fasta"));
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, "");
     EXPECT_EQ(result.err, std::string{});
 }
 
 TEST_F(minimiser_options_test, multiple_sample)
 {
-    cli_test_result result = execute_app("needle minimiser -k 4 -w 8 --samples 2 ", data("mini_example.fasta"),
+    app_test_result result = execute_app("minimiser -k 4 -w 8 --samples 2 ", data("mini_example.fasta"),
                                                                                    data("mini_example.fasta"));
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, "");
     EXPECT_EQ(result.err, std::string{});
 }
 
 TEST_F(minimiser_options_test, multithreads)
 {
-    cli_test_result result = execute_app("needle minimiser -k 4 -w 8 -t 2", data("mini_example.fasta"),
+    app_test_result result = execute_app("minimiser -k 4 -w 8 -t 2", data("mini_example.fasta"),
                                                                             data("mini_example.fasta"));
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, "");
     EXPECT_EQ(result.err, std::string{});
 }
 
 TEST_F(minimiser_options_test, paired)
 {
-    cli_test_result result = execute_app("needle minimiser -k 4 -w 8 -p ", data("mini_example.fasta"),
+    app_test_result result = execute_app("minimiser -k 4 -w 8 -p ", data("mini_example.fasta"),
                                                                            data("mini_example.fasta"));
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, "");
     EXPECT_EQ(result.err, std::string{});
 }
 
 TEST_F(minimiser_options_test, invalid_argument)
 {
-    cli_test_result result = execute_app("needle minimiser -k 4 -w 8 --samples 3 ", data("mini_example.fasta"),
+    app_test_result result = execute_app("minimiser -k 4 -w 8 --samples 3 ", data("mini_example.fasta"),
                                                                                     data("mini_example.fasta"));
     std::string expected
     {
         "Error. Incorrect command line input for multiple-samples.\n"
     };
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, "");
     EXPECT_EQ(result.err, expected);
 }
diff --git a/test/cli/needle_options_test.cpp b/test/cli/needle_options_test.cpp
index 567abab..df40aca 100644
--- a/test/cli/needle_options_test.cpp
+++ b/test/cli/needle_options_test.cpp
@@ -1,26 +1,26 @@
 #include <string>                // strings
 
-#include "cli_test.hpp"
+#include "../app_test.hpp"
 
-struct needle_options_test : public cli_test {};
+struct needle_options_test : public app_test {};
 
 TEST_F(needle_options_test, no_options)
 {
-    cli_test_result result = execute_app("needle");
+    app_test_result result = execute_app();
     std::string expected
     {
         "needle\n"
         "======\n"
         "    Try -h or --help for more information.\n"
     };
-    EXPECT_EQ(result.exit_code, 0);
+    EXPECT_SUCCESS(result);
     EXPECT_EQ(result.out, expected);
     EXPECT_EQ(result.err, std::string{});
 }
 
 TEST_F(needle_options_test, fail_no_argument)
 {
-    cli_test_result result = execute_app("needle", "-v");
+    app_test_result result = execute_app("-v");
     std::string expected
     {
         "Error. Incorrect command. See needle help for more information.You either forgot or misspelled the subcommand!"
diff --git a/test/cmake/app_datasources.cmake b/test/cmake/app_datasources.cmake
deleted file mode 100644
index 912cd7d..0000000
--- a/test/cmake/app_datasources.cmake
+++ /dev/null
@@ -1,92 +0,0 @@
-include (ExternalProject)
-
-# Example call:
-#
-# ```cmake
-# declare_datasource(
-#   FILE pdb100d.ent.gz # build/data/pdb100d.ent.gz
-#   URL ftp://ftp.wwpdb.org/pub/pdb/data/structures/divided/pdb/00/pdb100d.ent.gz # 16KiloByte
-#   URL_HASH SHA256=c2b8f884568b07f58519966e256e2f3aa440508e8013bd10e0ee338e138e62a0)
-# ```
-#
-# Options:
-#
-# declare_datasource(FILE <datasource name> URL <url1> [<url2>...] [URL_HASH <algo>=<hashValue>] [<option>...])
-#
-# FILE <datasource name> (required):
-#    The name of the downloaded file (must be unique across all declared datasources).
-#    This will put the file into the ``<build>/data/<datasource name>`` folder.
-#
-# URL <url1> [<url2>...] (required):
-#    List of paths and/or URL(s) of the external datasource. When more than one URL is given, they are tried in
-#    turn until one succeeds. A URL may be an ordinary path in the local file system (in which case it must be the only
-#    URL provided) or any downloadable URL supported by the file(DOWNLOAD) command. A local filesystem path may refer to
-#    either an existing directory or to an archive file, whereas a URL is expected to point to a file which can be
-#    treated as an archive.
-#
-# URL_HASH <algo>=<hashValue> (optional):
-#    Hash of the archive file to be downloaded. The argument should be of the form <algo>=<hashValue> where algo can be
-#    any of the hashing algorithms supported by the file() command. Specifying this option is strongly recommended for
-#    URL downloads, as it ensures the integrity of the downloaded content. It is also used as a check for a previously
-#    downloaded file, allowing connection to the remote location to be avoided altogether if the local directory already
-#    has a file from an earlier download that matches the specified hash.
-#
-# This uses under the hood ExternalProject's and you can pass any viable option of ExternalProject to this function and
-# overwrite the default behaviour. See https://cmake.org/cmake/help/latest/module/ExternalProject.html for more
-# information.
-function(declare_datasource)
-    set(options "")
-    set(one_value_args FILE URL_HASH)
-    set(multi_value_args URL)
-
-    cmake_parse_arguments(ARG "${options}" "${one_value_args}" "${multi_value_args}" ${ARGN})
-
-    string(TOLOWER "datasource--${ARG_FILE}" datasource_name)
-
-    # create data folder
-    file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/data)
-
-    ExternalProject_Add(
-        "${datasource_name}"
-        URL "${ARG_URL}"
-        URL_HASH "${ARG_URL_HASH}"
-        DOWNLOAD_NAME "${ARG_FILE}"
-        CONFIGURE_COMMAND ""
-        BUILD_COMMAND ""
-        INSTALL_COMMAND
-            ${CMAKE_COMMAND} -E create_symlink <DOWNLOADED_FILE> ${CMAKE_CURRENT_BINARY_DIR}/data/${ARG_FILE}
-        TEST_COMMAND ""
-        PREFIX "${CMAKE_CURRENT_BINARY_DIR}/_datasources"
-        DOWNLOAD_NO_EXTRACT TRUE # don't extract archive files like .tar.gz.
-        ${ARG_UNPARSED_ARGUMENTS}
-    )
-endfunction()
-
-# Example call:
-#
-# ```cmake
-# # my_app uses and needs the files RF00001.fa.gz, pdb100d.ent.gz, and GRCh38_latest_clinvar.vcf.gz.
-# target_use_datasources(my_app FILES RF00001.fa.gz pdb100d.ent.gz GRCh38_latest_clinvar.vcf.gz)
-# ```
-#
-# Options:
-#
-# target_use_datasources(<target> FILES <file1> [<file2>...])
-#
-# It declares that a <target> uses and depends on the following files.
-#
-# This also sets the build requirement that the files must be downloaded before the <target> will be build.
-#
-# The named <target> must have been created by a command such as add_executable() or add_library().
-function(target_use_datasources target)
-    set(options "")
-    set(one_value_args)
-    set(multi_value_args "FILES")
-
-    cmake_parse_arguments(ARG "${options}" "${one_value_args}" "${multi_value_args}" ${ARGN})
-
-    foreach(filename ${ARG_FILES})
-        string(TOLOWER "datasource--${filename}" datasource_name)
-        add_dependencies ("${target}" "${datasource_name}")
-    endforeach()
-endfunction()
diff --git a/test/coverage/CMakeLists.txt b/test/coverage/CMakeLists.txt
deleted file mode 100644
index 300ce61..0000000
--- a/test/coverage/CMakeLists.txt
+++ /dev/null
@@ -1,26 +0,0 @@
-cmake_minimum_required (VERSION 3.8)
-
-# Add a custom build type: Coverage
-
-set (CMAKE_CXX_FLAGS_COVERAGE
-     "${CMAKE_CXX_FLAGS_DEBUG} --coverage -fprofile-arcs -ftest-coverage" CACHE STRING
-     "Flags used by the C++ compiler during coverage builds."
-     FORCE)
-set (CMAKE_C_FLAGS_COVERAGE
-     "${CMAKE_C_FLAGS_DEBUG} --coverage -fprofile-arcs -ftest-coverage" CACHE STRING
-     "Flags used by the C compiler during coverage builds."
-     FORCE)
-set (CMAKE_EXE_LINKER_FLAGS_COVERAGE
-     "${CMAKE_EXE_LINKER_FLAGS_DEBUG} -Wl,-lgcov" CACHE STRING
-     "Flags used for linking binaries during coverage builds."
-     FORCE)
-set (CMAKE_SHARED_LINKER_FLAGS_COVERAGE
-     "${CMAKE_SHARED_LINKER_FLAGS_DEBUG} -Wl,-lgcov" CACHE STRING
-     "Flags used by the shared libraries linker during coverage builds."
-     FORCE)
-
-mark_as_advanced (
-    CMAKE_CXX_FLAGS_COVERAGE
-    CMAKE_C_FLAGS_COVERAGE
-    CMAKE_EXE_LINKER_FLAGS_COVERAGE
-    CMAKE_SHARED_LINKER_FLAGS_COVERAGE)
diff --git a/test/coverage/README.md b/test/coverage/README.md
deleted file mode 100644
index 12742ea..0000000
--- a/test/coverage/README.md
+++ /dev/null
@@ -1,9 +0,0 @@
-# Coverage Test
-
-This is the test for the code coverage.
-It reaches 100% if each code line is executed at least once through the app tests.
-
-Coverage tests are not yet part of the CMake configuration like it is in SeqAn3.
-However, the CI tests code coverage by running gcov and uploading the results to codecov.
-
-The custom build type `Coverage` can be used to configure the project such that coverage reports are possible.
diff --git a/test/data/datasources.cmake b/test/data/datasources.cmake
index 8832159..daed835 100644
--- a/test/data/datasources.cmake
+++ b/test/data/datasources.cmake
@@ -1,29 +1,12 @@
-cmake_minimum_required (VERSION 3.9)
+# SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
+# SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
+# SPDX-License-Identifier: CC0-1.0
 
-include (cmake/app_datasources.cmake)
+# This includes `cmake/test/declare_datasource.cmake`, which provides the `declare_datasource` function.
+include (test/declare_datasource)
+
+# Makes all files in this directory and subdirectories available to the build, i.e., copying them to <build>/data/.
+# `datasources.cmake`, `README.md`, and files ending in `.license` are ignored.
+# You may organise your data in subdirectories, but each file must have a unique name.
+include (test/add_local_data)
 
-# copies file to <build>/data/<file>
-declare_datasource (FILE exp_01.fasta
-                    URL ${CMAKE_SOURCE_DIR}/test/data/exp_01.fasta
-                    URL_HASH SHA256=e7236e7b86303d84a86a4454044125005433857416183cdaac0f4cdf7ac34e06)
-declare_datasource (FILE IBF_1
-                    URL ${CMAKE_SOURCE_DIR}/test/data/IBF_1
-                    URL_HASH SHA256=b0f23b093f774e29f75d03c7ebb94c5e809ee2f640d6b6d0e93667ad251ad480)
-declare_datasource (FILE mini_example.fasta
-                    URL ${CMAKE_SOURCE_DIR}/test/data/mini_example.fasta
-                    URL_HASH SHA256=f872221632e7423b071d1aedaf4c4e9da2a659e843fcafac12cd65632b904b93)
-declare_datasource (FILE mini_example.minimiser
-                    URL ${CMAKE_SOURCE_DIR}/test/data/mini_example.minimiser
-                    URL_HASH SHA256=9ecbc424b72b05760ec4977b97cfd78c31d19c2e4e67f22f7905e10e691a1cb8)
-declare_datasource (FILE mini_gen.fasta
-                    URL ${CMAKE_SOURCE_DIR}/test/data/mini_gen.fasta
-                    URL_HASH SHA256=6e9da2f6693938586c902f5e4445f2df1f1ac94cff8c23dea9e02b58759a8998)
-declare_datasource (FILE mini_gen2.fasta
-                    URL ${CMAKE_SOURCE_DIR}/test/data/mini_gen2.fasta
-                    URL_HASH SHA256=7e21b3eff20f950e6a0fa2369a0bbbed4cc967a24083876350f839f4a232771b)
-declare_datasource (FILE mini_gen.genome
-                    URL ${CMAKE_SOURCE_DIR}/test/data/mini_gen.genome
-                    URL_HASH SHA256=6a1426381b3966930dc36f30d85a95ccf6855add27b7cf49775b5d65b2902ac4)
-declare_datasource (FILE mini_gen2.genome
-                    URL ${CMAKE_SOURCE_DIR}/test/data/mini_gen2.genome
-                    URL_HASH SHA256=6a1426381b3966930dc36f30d85a95ccf6855add27b7cf49775b5d65b2902ac4)