github action: try to build and release findutils

2026-06-30 23:55:13 -04:00 · 2024-04-03 23:41:58 +02:00
31 changed files with 754 additions and 6705 deletions
@@ -4,7 +4,6 @@ name: Basic CI

 env:
  CARGO_TERM_COLOR: always
-  CARGO_INCREMENTAL: 0

 jobs:
  check:
@@ -16,6 +15,7 @@ jobs:
        os: [ubuntu-latest, macOS-latest, windows-latest]
    steps:
      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
      - run: cargo check

  test:
@@ -27,15 +27,7 @@ jobs:
        os: [ubuntu-latest, macOS-latest, windows-latest]
    steps:
      - uses: actions/checkout@v4
-      - name: install GNU patch on MacOS
-        if: runner.os == 'macOS'
-        run: |
-          brew install gpatch
-          echo "/opt/homebrew/opt/gpatch/libexec/gnubin" >> "$GITHUB_PATH"
-      - name: set up PATH on Windows
-        # Needed to use GNU's patch.exe instead of Strawberry Perl patch
-        if: runner.os == 'Windows'
-        run: echo "C:\Program Files\Git\usr\bin" >> $env:GITHUB_PATH
+      - uses: dtolnay/rust-toolchain@stable
      - run: cargo test

  fmt:
@@ -43,6 +35,8 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - run: rustup component add rustfmt
      - run: cargo fmt --all -- --check

  clippy:
@@ -54,18 +48,17 @@ jobs:
        os: [ubuntu-latest, macOS-latest, windows-latest]
    steps:
      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - run: rustup component add clippy
      - run: cargo clippy -- -D warnings

  gnu-testsuite:
-    permissions:
-      contents: write # Publish diffutils instead of discarding
    name: GNU test suite
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
-      - run: |
-          cargo build --config=profile.release.strip=true --profile=release #-fast
-          zstd -19 target/release/diffutils -o diffutils-x86_64-unknown-linux-gnu.zst
+      - uses: dtolnay/rust-toolchain@stable
+      - run: cargo build --release
      # do not fail, the report is merely informative (at least until all tests pass reliably)
      - run: ./tests/run-upstream-testsuite.sh release || true
        env:
@@ -75,17 +68,88 @@ jobs:
          name: test-results.json
          path: tests/test-results.json
      - run: ./tests/print-test-results.sh tests/test-results.json
-      - name: Publish latest commit
-        uses: softprops/action-gh-release@v2
-        if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+
+  build:
+    name: build ${{ matrix.binary || 'findutils' }} ${{ matrix.target }}
+    runs-on: ${{ matrix.os }}
+    container: ${{ fromJson(matrix.container || '{"image":null}') }}
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-20.04
+            target: x86_64-unknown-linux-musl
+          - os: ubuntu-20.04
+            target: aarch64-unknown-linux-musl
+          - os: ubuntu-20.04
+            target: armv7-unknown-linux-musleabi
+            container: '{"image": "messense/rust-musl-cross:armv7-musleabi"}'
+          - os: ubuntu-20.04
+            target: i686-unknown-linux-musl
+            container: '{"image": "messense/rust-musl-cross:i686-musl"}'
+          - os: macOS-11
+            target: x86_64-apple-darwin
+            macosx_deployment_target: 10.13
+            developer_dir: /Applications/Xcode_11.7.app
+            sdkroot: /Applications/Xcode_11.7.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk
+          - os: macos-14
+            target: aarch64-apple-darwin
+            macosx_deployment_target: 11.0
+          - os: windows-2019
+            target: x86_64-pc-windows-msvc
+            rustflags: -Ctarget-feature=+crt-static
+    steps:
+      - name: Clone repository
+        uses: actions/checkout@v4
+
+      - name: Install rust
+        uses: ./.github/actions/rust-toolchain
        with:
-          tag_name: latest-commit
-          draft: false
-          prerelease: true
-          files: |
-            diffutils-x86_64-unknown-linux-gnu.zst
+          toolchain: ${{ matrix.target == 'aarch64-apple-darwin' && 'beta' || 'stable' }}
+          target: ${{ matrix.target }}
+        if: ${{ !matrix.container }}
+
+      - name: Install musl-tools (x86_64)
+        run: sudo apt-get install musl-tools
+        if: ${{ matrix.target == 'x86_64-unknown-linux-musl' }}
+
+      - name: Install musl-tools (arm64)
+        run: |
+          set -x
+          sed 's/mirror+file:\/etc\/apt\/apt-mirrors\.txt/[arch=arm64] http:\/\/ports.ubuntu.com\/ubuntu-ports\//g' /etc/apt/sources.list | sudo tee /etc/apt/sources.list.d/ports.list
+          sudo dpkg --add-architecture arm64
+          sudo apt-get update || true
+          sudo apt-get install musl-dev:arm64 binutils-multiarch gcc-10-aarch64-linux-gnu libc6-dev-arm64-cross
+          apt-get download musl-tools:arm64
+          sudo dpkg-deb -x musl-tools_*_arm64.deb /
+          sed 2iREALGCC=aarch64-linux-gnu-gcc-10 /usr/bin/musl-gcc | sudo tee /usr/bin/aarch64-linux-musl-gcc > /dev/null
+          sudo chmod +x /usr/bin/aarch64-linux-musl-gcc
+        if: ${{ matrix.target == 'aarch64-unknown-linux-musl' }}
+
+      - name: Build
+        run: cargo build --locked --release --bin ${{ matrix.binary || 'findutils' }} --target ${{ matrix.target }} --features=openssl/vendored ${{ matrix.extra_args }}
        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          CARGO_TARGET_AARCH64_UNKNOWN_LINUX_MUSL_LINKER: aarch64-linux-musl-gcc
+          MACOSX_DEPLOYMENT_TARGET: ${{ matrix.macosx_deployment_target }}
+          DEVELOPER_DIR: ${{ matrix.developer_dir }}
+          SDKROOT: ${{ matrix.sdkroot }}
+          RUSTFLAGS: ${{ matrix.rustflags }}
+
+      # Workaround for the lack of substring() function in github actions expressions.
+      - name: Id
+        id: id
+        shell: bash
+        run: echo "id=${ID#refs/tags/}" >> $GITHUB_OUTPUT
+        env:
+          ID: ${{ startsWith(github.ref, 'refs/tags/') && github.ref || github.sha }}
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.binary || 'findutils' }}-${{ steps.id.outputs.id }}-${{ matrix.target }}
+          path: target/${{ matrix.target }}/release/${{ matrix.binary || 'findutils' }}${{ endsWith(matrix.target, '-msvc') && '.exe' || '' }}
+          if-no-files-found: error

  coverage:
    name: Code Coverage
@@ -100,42 +164,35 @@ jobs:
    steps:
    - uses: actions/checkout@v4
    - name: Initialize workflow variables
-      env:
-        # Use -Z
-        RUSTC_BOOTSTRAP: 1
      id: vars
      shell: bash
      run: |
        ## VARs setup
        outputs() { step_id="vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
+        # toolchain
+        TOOLCHAIN="nightly" ## default to "nightly" toolchain (required for certain required unstable compiler flags) ## !maint: refactor when stable channel has needed support
+        # * specify gnu-type TOOLCHAIN for windows; `grcov` requires gnu-style code coverage data files
+        case ${{ matrix.job.os }} in windows-*) TOOLCHAIN="$TOOLCHAIN-x86_64-pc-windows-gnu" ;; esac;
+        # * use requested TOOLCHAIN if specified
+        if [ -n "${{ matrix.job.toolchain }}" ]; then TOOLCHAIN="${{ matrix.job.toolchain }}" ; fi
+        outputs TOOLCHAIN
        # target-specific options
+        # * CARGO_FEATURES_OPTION
+        CARGO_FEATURES_OPTION='--all -- --check' ;  ## default to '--all-features' for code coverage
        # * CODECOV_FLAGS
        CODECOV_FLAGS=$( echo "${{ matrix.job.os }}" | sed 's/[^[:alnum:]]/_/g' )
        outputs CODECOV_FLAGS

-    - name: install GNU patch on MacOS
-      if: runner.os == 'macOS'
-      run: |
-        brew install gpatch
-        echo "/opt/homebrew/opt/gpatch/libexec/gnubin" >> "$GITHUB_PATH"
-    - name: set up PATH on Windows
-      # Needed to use GNU's patch.exe instead of Strawberry Perl patch
-      if: runner.os == 'Windows'
-      run: echo "C:\Program Files\Git\usr\bin" >> $env:GITHUB_PATH
+    - name: rust toolchain ~ install
+      uses: dtolnay/rust-toolchain@nightly
    - name: Test
-      run: cargo test --all-features --no-fail-fast
+      run: cargo test ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} --no-fail-fast
      env:
        CARGO_INCREMENTAL: "0"
        RUSTC_WRAPPER: ""
-        RUSTFLAGS: "-Cinstrument-coverage -Zcoverage-options=branch -Ccodegen-units=1 -Copt-level=0 -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
+        RUSTFLAGS: "-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
        RUSTDOCFLAGS: "-Cpanic=abort"
-        LLVM_PROFILE_FILE: "diffutils-%p-%m.profraw"
-        # Use -Z
-        RUSTC_BOOTSTRAP: 1
    - name: "`grcov` ~ install"
-      env:
-        # Use -Z
-        RUSTC_BOOTSTRAP: 1
      id: build_grcov
      shell: bash
      run: |
@@ -162,17 +219,67 @@ jobs:
        COVERAGE_REPORT_FILE="${COVERAGE_REPORT_DIR}/lcov.info"
        mkdir -p "${COVERAGE_REPORT_DIR}"
        # display coverage files
-        grcov . --output-type files --binary-path "${COVERAGE_REPORT_DIR}" | sort --unique
+        grcov . --output-type files --ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()" | sort --unique
        # generate coverage report
-        grcov . --output-type lcov --output-path "${COVERAGE_REPORT_FILE}" --binary-path "${COVERAGE_REPORT_DIR}" --branch
+        grcov . --output-type lcov --output-path "${COVERAGE_REPORT_FILE}" --branch --ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()"
        echo "report=${COVERAGE_REPORT_FILE}" >> $GITHUB_OUTPUT
    - name: Upload coverage results (to Codecov.io)
-      uses: codecov/codecov-action@v5
+      uses: codecov/codecov-action@v3
+      # if: steps.vars.outputs.HAS_CODECOV_TOKEN
      with:
-        token: ${{ secrets.CODECOV_TOKEN }}
-        files: ${{ steps.coverage.outputs.report }}
+        # token: ${{ secrets.CODECOV_TOKEN }}
+        file: ${{ steps.coverage.outputs.report }}
        ## flags: IntegrationTests, UnitTests, ${{ steps.vars.outputs.CODECOV_FLAGS }}
        flags: ${{ steps.vars.outputs.CODECOV_FLAGS }}
        name: codecov-umbrella
        fail_ci_if_error: false

+
+
+  release:
+    name: release
+    runs-on: ubuntu-latest
+    needs: [build, clippy, check, test]
+    if: ${{ startsWith(github.ref, 'refs/tags/') }}
+    steps:
+      - name: Clone repository
+        uses: actions/checkout@v4
+
+      - name: Check versions
+        run: |
+          tag_name=${GITHUB_REF#refs/tags/}
+          v=$(grep -m 1 "^version" Cargo.toml|sed -e "s|version = \"\(.*\)\"|\1|")
+          if ! echo $tag_name|grep -q $v; then
+             echo "Mistmatch of the version:"
+             echo "Cargo.toml says $v while the tag is $tag_name"
+             exit 2
+          fi
+
+      - name: Get artifacts
+        uses: actions/download-artifact@v4
+
+      - name: Create release assets
+        run: |
+          for d in findutils-*; do
+            chmod +x "$d/findutils"*
+            cp README.md LICENSE "$d/"
+            tar -zcvf "$d.tar.gz" "$d"
+            echo -n "$(shasum -ba 256 "$d.tar.gz" | cut -d " " -f 1)" > "$d.tar.gz.sha256"
+            if [[ $d =~ (findutils-)(.*)?(x86_64-pc-windows)(.*)? ]]; then
+              zip -r "$d.zip" "$d"
+              echo -n "$(shasum -ba 256 "$d.zip" | cut -d " " -f 1)" > "$d.zip.sha256"
+            fi
+          done
+
+      - name: Create release
+        run: |
+          sudo apt-get update && sudo apt-get install -y hub
+          tag_name=${GITHUB_REF#refs/tags/}
+          for f in findutils-*.tar.gz* findutils-*.zip*; do
+              if [[ -f "$f" ]]; then
+                files="$files -a $f";
+              fi
+          done
+          hub release create -m $tag_name $tag_name $files
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -1,37 +0,0 @@
-name: CodSpeed
-
-on:
-  push:
-    branches:
-      - "main"
-  pull_request:
-  # `workflow_dispatch` allows CodSpeed to trigger backtest
-  # performance analysis in order to generate initial data.
-  workflow_dispatch:
-
-permissions:
-  contents: read
-  id-token: write
-
-jobs:
-  codspeed:
-    name: Run benchmarks
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Setup rust toolchain, cache and cargo-codspeed binary
-        uses: moonrepo/setup-rust@v0
-        with:
-          channel: stable
-          cache-target: release
-          bins: cargo-codspeed
-
-      - name: Build the benchmark target(s)
-        run: cargo codspeed build -m simulation
-
-      - name: Run the benchmarks
-        uses: CodSpeedHQ/action@v4
-        with:
-          mode: simulation
-          run: cargo codspeed run
@@ -21,17 +21,15 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@nightly
      - name: Install `cargo-fuzz`
-        run: |
-          echo "RUSTC_BOOTSTRAP=1" >> "${GITHUB_ENV}"
-          echo "CARGO_INCREMENTAL=0" >> "${GITHUB_ENV}"
-          cargo install cargo-fuzz --locked
+        run: cargo install cargo-fuzz
      - uses: Swatinem/rust-cache@v2
        with:
          shared-key: "cargo-fuzz-cache-key"
          cache-directories: "fuzz/target"
      - name: Run `cargo-fuzz build`
-        run: cargo fuzz build
+        run: cargo +nightly fuzz build

  fuzz-run:
    needs: fuzz-build
@@ -43,25 +41,20 @@ jobs:
    strategy:
      matrix:
        test-target:
-          - { name: fuzz_cmp, should_pass: true }
-          - { name: fuzz_cmp_args, should_pass: true }
          - { name: fuzz_ed, should_pass: true }
          - { name: fuzz_normal, should_pass: true }
          - { name: fuzz_patch, should_pass: true }
-          - { name: fuzz_side, should_pass: true }
    steps:
      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@nightly
      - name: Install `cargo-fuzz`
-        run: |
-          echo "RUSTC_BOOTSTRAP=1" >> "${GITHUB_ENV}"
-          echo "CARGO_INCREMENTAL=0" >> "${GITHUB_ENV}"
-          cargo install cargo-fuzz --locked
+        run: cargo install cargo-fuzz
      - uses: Swatinem/rust-cache@v2
        with:
          shared-key: "cargo-fuzz-cache-key"
          cache-directories: "fuzz/target"
      - name: Restore Cached Corpus
-        uses: actions/cache/restore@v5
+        uses: actions/cache/restore@v4
        with:
          key: corpus-cache-${{ matrix.test-target.name }}
          path: |
@@ -70,9 +63,9 @@ jobs:
        shell: bash
        continue-on-error: ${{ !matrix.test-target.name.should_pass }}
        run: |
-          cargo fuzz run ${{ matrix.test-target.name }} -- -max_total_time=${{ env.RUN_FOR }} -detect_leaks=0
+          cargo +nightly fuzz run ${{ matrix.test-target.name }} -- -max_total_time=${{ env.RUN_FOR }} -detect_leaks=0
      - name: Save Corpus Cache
-        uses: actions/cache/save@v5
+        uses: actions/cache/save@v4
        with:
          key: corpus-cache-${{ matrix.test-target.name }}
          path: |
@@ -1,296 +0,0 @@
-# This file was autogenerated by dist: https://axodotdev.github.io/cargo-dist
-#
-# Copyright 2022-2024, axodotdev
-# SPDX-License-Identifier: MIT or Apache-2.0
-#
-# CI that:
-#
-# * checks for a Git Tag that looks like a release
-# * builds artifacts with dist (archives, installers, hashes)
-# * uploads those artifacts to temporary workflow zip
-# * on success, uploads the artifacts to a GitHub Release
-#
-# Note that the GitHub Release will be created with a generated
-# title/body based on your changelogs.
-
-name: Release
-permissions:
-  "contents": "write"
-
-# This task will run whenever you push a git tag that looks like a version
-# like "1.0.0", "v0.1.0-prerelease.1", "my-app/0.1.0", "releases/v1.0.0", etc.
-# Various formats will be parsed into a VERSION and an optional PACKAGE_NAME, where
-# PACKAGE_NAME must be the name of a Cargo package in your workspace, and VERSION
-# must be a Cargo-style SemVer Version (must have at least major.minor.patch).
-#
-# If PACKAGE_NAME is specified, then the announcement will be for that
-# package (erroring out if it doesn't have the given version or isn't dist-able).
-#
-# If PACKAGE_NAME isn't specified, then the announcement will be for all
-# (dist-able) packages in the workspace with that version (this mode is
-# intended for workspaces with only one dist-able package, or with all dist-able
-# packages versioned/released in lockstep).
-#
-# If you push multiple tags at once, separate instances of this workflow will
-# spin up, creating an independent announcement for each one. However, GitHub
-# will hard limit this to 3 tags per commit, as it will assume more tags is a
-# mistake.
-#
-# If there's a prerelease-style suffix to the version, then the release(s)
-# will be marked as a prerelease.
-on:
-  pull_request:
-  push:
-    tags:
-      - '**[0-9]+.[0-9]+.[0-9]+*'
-
-jobs:
-  # Run 'dist plan' (or host) to determine what tasks we need to do
-  plan:
-    runs-on: "ubuntu-22.04"
-    outputs:
-      val: ${{ steps.plan.outputs.manifest }}
-      tag: ${{ !github.event.pull_request && github.ref_name || '' }}
-      tag-flag: ${{ !github.event.pull_request && format('--tag={0}', github.ref_name) || '' }}
-      publishing: ${{ !github.event.pull_request }}
-    env:
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
-          submodules: recursive
-      - name: Install dist
-        # we specify bash to get pipefail; it guards against the `curl` command
-        # failing. otherwise `sh` won't catch that `curl` returned non-0
-        shell: bash
-        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.30.3/cargo-dist-installer.sh | sh"
-      - name: Cache dist
-        uses: actions/upload-artifact@v4
-        with:
-          name: cargo-dist-cache
-          path: ~/.cargo/bin/dist
-      # sure would be cool if github gave us proper conditionals...
-      # so here's a doubly-nested ternary-via-truthiness to try to provide the best possible
-      # functionality based on whether this is a pull_request, and whether it's from a fork.
-      # (PRs run on the *source* but secrets are usually on the *target* -- that's *good*
-      # but also really annoying to build CI around when it needs secrets to work right.)
-      - id: plan
-        run: |
-          dist ${{ (!github.event.pull_request && format('host --steps=create --tag={0}', github.ref_name)) || 'plan' }} --output-format=json > plan-dist-manifest.json
-          echo "dist ran successfully"
-          cat plan-dist-manifest.json
-          echo "manifest=$(jq -c "." plan-dist-manifest.json)" >> "$GITHUB_OUTPUT"
-      - name: "Upload dist-manifest.json"
-        uses: actions/upload-artifact@v4
-        with:
-          name: artifacts-plan-dist-manifest
-          path: plan-dist-manifest.json
-
-  # Build and packages all the platform-specific things
-  build-local-artifacts:
-    name: build-local-artifacts (${{ join(matrix.targets, ', ') }})
-    # Let the initial task tell us to not run (currently very blunt)
-    needs:
-      - plan
-    if: ${{ fromJson(needs.plan.outputs.val).ci.github.artifacts_matrix.include != null && (needs.plan.outputs.publishing == 'true' || fromJson(needs.plan.outputs.val).ci.github.pr_run_mode == 'upload') }}
-    strategy:
-      fail-fast: false
-      # Target platforms/runners are computed by dist in create-release.
-      # Each member of the matrix has the following arguments:
-      #
-      # - runner: the github runner
-      # - dist-args: cli flags to pass to dist
-      # - install-dist: expression to run to install dist on the runner
-      #
-      # Typically there will be:
-      # - 1 "global" task that builds universal installers
-      # - N "local" tasks that build each platform's binaries and platform-specific installers
-      matrix: ${{ fromJson(needs.plan.outputs.val).ci.github.artifacts_matrix }}
-    runs-on: ${{ matrix.runner }}
-    container: ${{ matrix.container && matrix.container.image || null }}
-    env:
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      BUILD_MANIFEST_NAME: target/distrib/${{ join(matrix.targets, '-') }}-dist-manifest.json
-    steps:
-      - name: enable windows longpaths
-        run: |
-          git config --global core.longpaths true
-      - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
-          submodules: recursive
-      - name: Install Rust non-interactively if not already installed
-        if: ${{ matrix.container }}
-        run: |
-          if ! command -v cargo > /dev/null 2>&1; then
-            curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
-            echo "$HOME/.cargo/bin" >> $GITHUB_PATH
-          fi
-      - name: Install dist
-        run: ${{ matrix.install_dist.run }}
-      # Get the dist-manifest
-      - name: Fetch local artifacts
-        uses: actions/download-artifact@v4
-        with:
-          pattern: artifacts-*
-          path: target/distrib/
-          merge-multiple: true
-      - name: Install dependencies
-        run: |
-          ${{ matrix.packages_install }}
-      - name: Build artifacts
-        run: |
-          # Actually do builds and make zips and whatnot
-          dist build ${{ needs.plan.outputs.tag-flag }} --print=linkage --output-format=json ${{ matrix.dist_args }} > dist-manifest.json
-          echo "dist ran successfully"
-      - id: cargo-dist
-        name: Post-build
-        # We force bash here just because github makes it really hard to get values up
-        # to "real" actions without writing to env-vars, and writing to env-vars has
-        # inconsistent syntax between shell and powershell.
-        shell: bash
-        run: |
-          # Parse out what we just built and upload it to scratch storage
-          echo "paths<<EOF" >> "$GITHUB_OUTPUT"
-          dist print-upload-files-from-manifest --manifest dist-manifest.json >> "$GITHUB_OUTPUT"
-          echo "EOF" >> "$GITHUB_OUTPUT"
-
-          cp dist-manifest.json "$BUILD_MANIFEST_NAME"
-      - name: "Upload artifacts"
-        uses: actions/upload-artifact@v4
-        with:
-          name: artifacts-build-local-${{ join(matrix.targets, '_') }}
-          path: |
-            ${{ steps.cargo-dist.outputs.paths }}
-            ${{ env.BUILD_MANIFEST_NAME }}
-
-  # Build and package all the platform-agnostic(ish) things
-  build-global-artifacts:
-    needs:
-      - plan
-      - build-local-artifacts
-    runs-on: "ubuntu-22.04"
-    env:
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      BUILD_MANIFEST_NAME: target/distrib/global-dist-manifest.json
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
-          submodules: recursive
-      - name: Install cached dist
-        uses: actions/download-artifact@v4
-        with:
-          name: cargo-dist-cache
-          path: ~/.cargo/bin/
-      - run: chmod +x ~/.cargo/bin/dist
-      # Get all the local artifacts for the global tasks to use (for e.g. checksums)
-      - name: Fetch local artifacts
-        uses: actions/download-artifact@v4
-        with:
-          pattern: artifacts-*
-          path: target/distrib/
-          merge-multiple: true
-      - id: cargo-dist
-        shell: bash
-        run: |
-          dist build ${{ needs.plan.outputs.tag-flag }} --output-format=json "--artifacts=global" > dist-manifest.json
-          echo "dist ran successfully"
-
-          # Parse out what we just built and upload it to scratch storage
-          echo "paths<<EOF" >> "$GITHUB_OUTPUT"
-          jq --raw-output ".upload_files[]" dist-manifest.json >> "$GITHUB_OUTPUT"
-          echo "EOF" >> "$GITHUB_OUTPUT"
-
-          cp dist-manifest.json "$BUILD_MANIFEST_NAME"
-      - name: "Upload artifacts"
-        uses: actions/upload-artifact@v4
-        with:
-          name: artifacts-build-global
-          path: |
-            ${{ steps.cargo-dist.outputs.paths }}
-            ${{ env.BUILD_MANIFEST_NAME }}
-  # Determines if we should publish/announce
-  host:
-    needs:
-      - plan
-      - build-local-artifacts
-      - build-global-artifacts
-    # Only run if we're "publishing", and only if plan, local and global didn't fail (skipped is fine)
-    if: ${{ always() && needs.plan.result == 'success' && needs.plan.outputs.publishing == 'true' && (needs.build-global-artifacts.result == 'skipped' || needs.build-global-artifacts.result == 'success') && (needs.build-local-artifacts.result == 'skipped' || needs.build-local-artifacts.result == 'success') }}
-    env:
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    runs-on: "ubuntu-22.04"
-    outputs:
-      val: ${{ steps.host.outputs.manifest }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
-          submodules: recursive
-      - name: Install cached dist
-        uses: actions/download-artifact@v4
-        with:
-          name: cargo-dist-cache
-          path: ~/.cargo/bin/
-      - run: chmod +x ~/.cargo/bin/dist
-      # Fetch artifacts from scratch-storage
-      - name: Fetch artifacts
-        uses: actions/download-artifact@v4
-        with:
-          pattern: artifacts-*
-          path: target/distrib/
-          merge-multiple: true
-      - id: host
-        shell: bash
-        run: |
-          dist host ${{ needs.plan.outputs.tag-flag }} --steps=upload --steps=release --output-format=json > dist-manifest.json
-          echo "artifacts uploaded and released successfully"
-          cat dist-manifest.json
-          echo "manifest=$(jq -c "." dist-manifest.json)" >> "$GITHUB_OUTPUT"
-      - name: "Upload dist-manifest.json"
-        uses: actions/upload-artifact@v4
-        with:
-          # Overwrite the previous copy
-          name: artifacts-dist-manifest
-          path: dist-manifest.json
-      # Create a GitHub Release while uploading all files to it
-      - name: "Download GitHub Artifacts"
-        uses: actions/download-artifact@v4
-        with:
-          pattern: artifacts-*
-          path: artifacts
-          merge-multiple: true
-      - name: Cleanup
-        run: |
-          # Remove the granular manifests
-          rm -f artifacts/*-dist-manifest.json
-      - name: Create GitHub Release
-        env:
-          PRERELEASE_FLAG: "${{ fromJson(steps.host.outputs.manifest).announcement_is_prerelease && '--prerelease' || '' }}"
-          ANNOUNCEMENT_TITLE: "${{ fromJson(steps.host.outputs.manifest).announcement_title }}"
-          ANNOUNCEMENT_BODY: "${{ fromJson(steps.host.outputs.manifest).announcement_github_body }}"
-          RELEASE_COMMIT: "${{ github.sha }}"
-        run: |
-          # Write and read notes from a file to avoid quoting breaking things
-          echo "$ANNOUNCEMENT_BODY" > $RUNNER_TEMP/notes.txt
-
-          gh release create "${{ needs.plan.outputs.tag }}" --target "$RELEASE_COMMIT" $PRERELEASE_FLAG --title "$ANNOUNCEMENT_TITLE" --notes-file "$RUNNER_TEMP/notes.txt" artifacts/*
-
-  announce:
-    needs:
-      - plan
-      - host
-    # use "always() && ..." to allow us to wait for all publish jobs while
-    # still allowing individual publish jobs to skip themselves (for prereleases).
-    # "host" however must run to completion, no skipping allowed!
-    if: ${{ always() && needs.host.result == 'success' }}
-    runs-on: "ubuntu-22.04"
-    env:
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
-          submodules: recursive
@@ -1,6 +1,6 @@
 [package]
 name = "diffutils"
-version = "0.5.0"
+version = "0.3.0"
 edition = "2021"
 description = "A CLI app for generating diff files"
 license = "MIT OR Apache-2.0"
@@ -15,42 +15,13 @@ name = "diffutils"
 path = "src/main.rs"

 [dependencies]
-chrono = "0.4.38"
-diff = "0.1.13"
-itoa = "1.0.11"
-regex = "1.10.4"
+diff = "0.1.10"
+regex = "1.10.3"
 same-file = "1.0.6"
-unicode-width = "0.2.0"
+unicode-width = "0.1.11"

 [dev-dependencies]
+pretty_assertions = "1"
 assert_cmd = "2.0.14"
-divan = { version = "4.3.0", package = "codspeed-divan-compat" }
-pretty_assertions = "1.4.0"
 predicates = "3.1.0"
-rand = "0.10.0"
-tempfile = "3.26.0"
-
-[profile.release]
-lto = "thin"
-codegen-units = 1
-
-[profile.release-fast]
-inherits = "release"
-panic = "abort"
-
-# The profile that 'dist' will build with
-[profile.dist]
-inherits = "release"
-lto = "thin"
-
-[[bench]]
-name = "bench_diffutils"
-path = "benches/bench-diffutils.rs"
-harness = false
-
-[features]
-# default = ["feat_bench_not_diff"]
-# Turn bench for diffutils cmp off
-feat_bench_not_cmp = []
-# Turn bench for diffutils diff off
-feat_bench_not_diff = []
+tempfile = "3.10.0"
@@ -1,6 +1,3 @@
-Copyright (c) Michael Howell
-Copyright (c) uutils developers
-
                              Apache License
                        Version 2.0, January 2004
                     http://www.apache.org/licenses/
@@ -1,6 +1,3 @@
-Copyright (c) Michael Howell
-Copyright (c) uutils developers
-
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated
 documentation files (the "Software"), to deal in the
@@ -2,11 +2,10 @@
 [![Discord](https://img.shields.io/badge/discord-join-7289DA.svg?logo=discord&longCache=true&style=flat)](https://discord.gg/wQVJbvJ)
 [![License](http://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/uutils/diffutils/blob/main/LICENSE)
 [![dependency status](https://deps.rs/repo/github/uutils/diffutils/status.svg)](https://deps.rs/repo/github/uutils/diffutils)
-[![CodSpeed](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://codspeed.io/uutils/diffutils?utm_source=badge)

 [![CodeCov](https://codecov.io/gh/uutils/diffutils/branch/main/graph/badge.svg)](https://codecov.io/gh/uutils/diffutils)

-The goal of this package is to be a drop-in replacement for the [diffutils commands](https://www.gnu.org/software/diffutils/) (diff, cmp, diff3, sdiff) in Rust.
+The goal of this package is to be a drop-in replacement for the [diffutils commands](https://www.gnu.org/software/diffutils/) in Rust.

 Based on the incomplete diff generator in https://github.com/rust-lang/rust/blob/master/src/tools/compiletest/src/runtest.rs, and made to be compatible with GNU's diff and patch tools.

@@ -1,377 +0,0 @@
-// This file is part of the uutils diffutils package.
-//
-// For the full copyright and license information, please view the LICENSE-*
-// files that was distributed with this source code.
-
-//! Benches for all utils in diffutils.
-//!
-//! There is a file generator included to create files of different sizes for comparison. \
-//! Set the TEMP_DIR const to keep the files. df_to_ files have small changes in them, search for '#'. \
-//! File generation up to 1 GB is really fast, Benchmarking above 100 MB takes very long.
-
-/// Generate test files with these sizes in KB.
-const FILE_SIZE_KILO_BYTES: [u64; 4] = [100, 1 * MB, 10 * MB, 25 * MB];
-// const FILE_SIZE_KILO_BYTES: [u64; 3] = [100, 1 * MB, 5 * MB];
-// Empty String to use TempDir (files will be removed after test) or specify dir to keep generated files
-const TEMP_DIR: &str = "";
-const NUM_DIFF: u64 = 4;
-// just for FILE_SIZE_KILO_BYTES
-const MB: u64 = 1_000;
-const CHANGE_CHAR: u8 = b'#';
-
-#[cfg(not(feature = "feat_bench_not_cmp"))]
-mod diffutils_cmp {
-    use std::hint::black_box;
-
-    use diffutilslib::cmp;
-    use divan::Bencher;
-
-    use crate::{binary, prepare::*, FILE_SIZE_KILO_BYTES};
-
-    #[divan::bench(args = FILE_SIZE_KILO_BYTES)]
-    fn cmp_compare_files_equal(bencher: Bencher, kb: u64) {
-        let (from, to) = get_context().get_test_files_equal(kb);
-        let cmd = format!("cmp {from} {to}");
-        let opts = str_to_options(&cmd).into_iter().peekable();
-        let params = cmp::parse_params(opts).unwrap();
-
-        bencher
-            // .with_inputs(|| prepare::cmp_params_identical_testfiles(lines))
-            .with_inputs(|| params.clone())
-            .bench_refs(|params| black_box(cmp::cmp(&params).unwrap()));
-    }
-
-    // bench the actual compare; cmp exits on first difference
-    #[divan::bench(args = FILE_SIZE_KILO_BYTES)]
-    fn cmp_compare_files_different(bencher: Bencher, bytes: u64) {
-        let (from, to) = get_context().get_test_files_different(bytes);
-        let cmd = format!("cmp {from} {to} -s");
-        let opts = str_to_options(&cmd).into_iter().peekable();
-        let params = cmp::parse_params(opts).unwrap();
-
-        bencher
-            // .with_inputs(|| prepare::cmp_params_identical_testfiles(lines))
-            .with_inputs(|| params.clone())
-            .bench_refs(|params| black_box(cmp::cmp(&params).unwrap()));
-    }
-
-    // bench original GNU cmp
-    #[divan::bench(args = FILE_SIZE_KILO_BYTES)]
-    fn cmd_cmp_gnu_equal(bencher: Bencher, bytes: u64) {
-        let (from, to) = get_context().get_test_files_equal(bytes);
-        let args_str = format!("{from} {to}");
-        bencher
-            // .with_inputs(|| prepare::cmp_params_identical_testfiles(lines))
-            .with_inputs(|| args_str.clone())
-            .bench_refs(|cmd_args| binary::bench_binary("cmp", cmd_args));
-    }
-
-    // bench the compiled release version
-    #[divan::bench(args = FILE_SIZE_KILO_BYTES)]
-    fn cmd_cmp_release_equal(bencher: Bencher, bytes: u64) {
-        let (from, to) = get_context().get_test_files_equal(bytes);
-        let args_str = format!("cmp {from} {to}");
-
-        bencher
-            // .with_inputs(|| prepare::cmp_params_identical_testfiles(lines))
-            .with_inputs(|| args_str.clone())
-            .bench_refs(|cmd_args| binary::bench_binary("target/release/diffutils", cmd_args));
-    }
-}
-
-#[cfg(not(feature = "feat_bench_not_diff"))]
-mod diffutils_diff {
-    // use std::hint::black_box;
-
-    use crate::{binary, prepare::*, FILE_SIZE_KILO_BYTES};
-    // use diffutilslib::params;
-    use divan::Bencher;
-
-    // bench the actual compare
-    // TODO diff does not have a diff function
-    //     #[divan::bench(args = [100_000,10_000])]
-    //     fn diff_compare_files(bencher: Bencher, bytes: u64) {
-    //         let (from, to) = gen_testfiles(lines, 0, "id");
-    //         let cmd = format!("cmp {from} {to}");
-    //         let opts = str_to_options(&cmd).into_iter().peekable();
-    //         let params = params::parse_params(opts).unwrap();
-    //
-    //         bencher
-    //             // .with_inputs(|| prepare::cmp_params_identical_testfiles(lines))
-    //             .with_inputs(|| params.clone())
-    //             .bench_refs(|params| diff::diff(&params).unwrap());
-    //     }
-
-    // bench original GNU diff
-    #[divan::bench(args = FILE_SIZE_KILO_BYTES)]
-    fn cmd_diff_gnu_equal(bencher: Bencher, bytes: u64) {
-        let (from, to) = get_context().get_test_files_equal(bytes);
-        let args_str = format!("{from} {to}");
-        bencher
-            // .with_inputs(|| prepare::cmp_params_identical_testfiles(lines))
-            .with_inputs(|| args_str.clone())
-            .bench_refs(|cmd_args| binary::bench_binary("diff", cmd_args));
-    }
-
-    // bench the compiled release version
-    #[divan::bench(args = FILE_SIZE_KILO_BYTES)]
-    fn cmd_diff_release_equal(bencher: Bencher, bytes: u64) {
-        let (from, to) = get_context().get_test_files_equal(bytes);
-        let args_str = format!("diff {from} {to}");
-
-        bencher
-            // .with_inputs(|| prepare::cmp_params_identical_testfiles(lines))
-            .with_inputs(|| args_str.clone())
-            .bench_refs(|cmd_args| binary::bench_binary("target/release/diffutils", cmd_args));
-    }
-}
-
-mod parser {
-    use std::hint::black_box;
-
-    use diffutilslib::{cmp, params};
-    use divan::Bencher;
-
-    use crate::prepare::str_to_options;
-
-    // bench the time it takes to parse the command line arguments
-    #[divan::bench]
-    fn cmp_parser(bencher: Bencher) {
-        let cmd = "cmd file_1.txt file_2.txt -bl n10M --ignore-initial=100KiB:1MiB";
-        let args = str_to_options(&cmd).into_iter().peekable();
-        bencher
-            .with_inputs(|| args.clone())
-            .bench_values(|data| black_box(cmp::parse_params(data)));
-    }
-
-    // // test the impact on the benchmark if not converting the cmd to Vec<OsString> (doubles for parse)
-    // #[divan::bench]
-    // fn cmp_parser_no_prepare() {
-    //     let cmd = "cmd file_1.txt file_2.txt -bl n10M --ignore-initial=100KiB:1MiB";
-    //     let args = str_to_options(&cmd).into_iter().peekable();
-    //     let _ = cmp::parse_params(args);
-    // }
-
-    // bench the time it takes to parse the command line arguments
-    #[divan::bench]
-    fn diff_parser(bencher: Bencher) {
-        let cmd = "diff file_1.txt file_2.txt -s --brief --expand-tabs --width=100";
-        let args = str_to_options(&cmd).into_iter().peekable();
-        bencher
-            .with_inputs(|| args.clone())
-            .bench_values(|data| black_box(params::parse_params(data)));
-    }
-}
-
-mod prepare {
-    use std::{
-        ffi::OsString,
-        fs::{self, File},
-        io::{BufWriter, Write},
-        path::Path,
-        sync::OnceLock,
-    };
-
-    use rand::RngExt;
-    use tempfile::TempDir;
-
-    use crate::{CHANGE_CHAR, FILE_SIZE_KILO_BYTES, NUM_DIFF, TEMP_DIR};
-
-    // file lines and .txt will be added
-    const FROM_FILE: &str = "from_file";
-    const TO_FILE: &str = "to_file";
-    const LINE_LENGTH: usize = 60;
-
-    /// Contains test data (file names) which only needs to be created once.
-    #[derive(Debug, Default)]
-    pub struct BenchContext {
-        pub tmp_dir: Option<TempDir>,
-        pub dir: String,
-        pub files_equal: Vec<(String, String)>,
-        pub files_different: Vec<(String, String)>,
-    }
-
-    impl BenchContext {
-        pub fn get_path(&self) -> &Path {
-            match &self.tmp_dir {
-                Some(tmp) => tmp.path(),
-                None => Path::new(&self.dir),
-            }
-        }
-
-        pub fn get_test_files_equal(&self, kb: u64) -> &(String, String) {
-            let p = FILE_SIZE_KILO_BYTES.iter().position(|f| *f == kb).unwrap();
-            &self.files_equal[p]
-        }
-
-        #[allow(unused)]
-        pub fn get_test_files_different(&self, kb: u64) -> &(String, String) {
-            let p = FILE_SIZE_KILO_BYTES.iter().position(|f| *f == kb).unwrap();
-            &self.files_different[p]
-        }
-    }
-
-    // Since each bench function is separate in Divan it is more difficult to dynamically create test data.
-    // This keeps the TempDir alive until the program exits and generates the files only once.
-    static SHARED_CONTEXT: OnceLock<BenchContext> = OnceLock::new();
-    /// Creates the test files once and provides them to all tests.
-    pub fn get_context() -> &'static BenchContext {
-        SHARED_CONTEXT.get_or_init(|| {
-            let mut ctx = BenchContext::default();
-            if TEMP_DIR.is_empty() {
-                let tmp_dir = TempDir::new().expect("Failed to create temp dir");
-                ctx.tmp_dir = Some(tmp_dir);
-            } else {
-                // uses current directory, the generated files are kept
-                let path = Path::new(TEMP_DIR);
-                if !path.exists() {
-                    fs::create_dir_all(path).expect("Path {path} could not be created");
-                }
-                ctx.dir = TEMP_DIR.to_string();
-            };
-
-            // generate test bytes
-            for kb in FILE_SIZE_KILO_BYTES {
-                let f = generate_test_files_bytes(ctx.get_path(), kb * 1000, 0, "eq")
-                    .expect("generate_test_files failed");
-                ctx.files_equal.push(f);
-                let f = generate_test_files_bytes(ctx.get_path(), kb * 1000, NUM_DIFF, "df")
-                    .expect("generate_test_files failed");
-                ctx.files_different.push(f);
-            }
-
-            ctx
-        })
-    }
-
-    pub fn str_to_options(opt: &str) -> Vec<OsString> {
-        let s: Vec<OsString> = opt
-            .split(" ")
-            .into_iter()
-            .filter(|s| !s.is_empty())
-            .map(|s| OsString::from(s))
-            .collect();
-
-        s
-    }
-
-    /// Generates two test files for comparison with <bytes> size.
-    ///
-    /// Each line consists of 10 words with 5 letters, giving a line length of 60 bytes.
-    /// If num_differences is set, '#' will be inserted between the first two words of a line,
-    /// evenly spaced in the file. 1 will add the change in the last line, so the comparison takes longest.
-    fn generate_test_files_bytes(
-        dir: &Path,
-        bytes: u64,
-        num_differences: u64,
-        id: &str,
-    ) -> std::io::Result<(String, String)> {
-        let id = if id.is_empty() {
-            "".to_string()
-        } else {
-            format!("{id}_")
-        };
-        let f1 = format!("{id}{FROM_FILE}_{bytes}.txt");
-        let f2 = format!("{id}{TO_FILE}_{bytes}.txt");
-        let from_path = dir.join(f1);
-        let to_path = dir.join(f2);
-
-        generate_file_bytes(&from_path, &to_path, bytes, num_differences)?;
-
-        Ok((
-            from_path.to_string_lossy().to_string(),
-            to_path.to_string_lossy().to_string(),
-        ))
-    }
-
-    fn generate_file_bytes(
-        from_name: &Path,
-        to_name: &Path,
-        bytes: u64,
-        num_differences: u64,
-    ) -> std::io::Result<()> {
-        let file_from = File::create(from_name)?;
-        let file_to = File::create(to_name)?;
-        // for int division, lines will be smaller than requested bytes
-        let n_lines = bytes / LINE_LENGTH as u64;
-        let change_every_n_lines = if num_differences == 0 {
-            0
-        } else {
-            let c = n_lines / num_differences;
-            if c == 0 {
-                1
-            } else {
-                c
-            }
-        };
-        // Use a larger 128KB buffer for massive files
-        let mut writer_from = BufWriter::with_capacity(128 * 1024, file_from);
-        let mut writer_to = BufWriter::with_capacity(128 * 1024, file_to);
-        let mut rng = rand::rng();
-
-        // Each line: (5 chars * 10 words) + 9 spaces + 1 newline = 60 bytes
-        let mut line_buffer = [b' '; 60];
-        line_buffer[59] = b'\n'; // Set the newline once at the end
-
-        for i in (0..n_lines).rev() {
-            // Fill only the letter positions, skipping spaces and the newline
-            for word_idx in 0..10 {
-                let start = word_idx * 6; // Each word + space block is 6 bytes
-                for i in 0..5 {
-                    line_buffer[start + i] = rng.random_range(b'a'..b'z' + 1);
-                }
-            }
-
-            // Write the raw bytes directly to both files
-            writer_from.write_all(&line_buffer)?;
-            // make changes in the file
-            if num_differences == 0 {
-                writer_to.write_all(&line_buffer)?;
-            } else {
-                if i % change_every_n_lines == 0 && n_lines - i > 2 {
-                    line_buffer[5] = CHANGE_CHAR;
-                }
-                writer_to.write_all(&line_buffer)?;
-                line_buffer[5] = b' ';
-            }
-        }
-
-        // create last line
-        let missing = (bytes - n_lines as u64 * LINE_LENGTH as u64) as usize;
-        if missing > 0 {
-            for word_idx in 0..10 {
-                let start = word_idx * 6; // Each word + space block is 6 bytes
-                for i in 0..5 {
-                    line_buffer[start + i] = rng.random_range(b'a'..b'z' + 1);
-                }
-            }
-            line_buffer[missing - 1] = b'\n';
-            writer_from.write_all(&line_buffer[0..missing])?;
-            writer_to.write_all(&line_buffer[0..missing])?;
-        }
-
-        writer_from.flush()?;
-        writer_to.flush()?;
-
-        Ok(())
-    }
-}
-
-mod binary {
-    use std::process::Command;
-
-    use crate::prepare::str_to_options;
-
-    pub fn bench_binary(program: &str, cmd_args: &str) -> std::process::ExitStatus {
-        let args = str_to_options(cmd_args);
-        Command::new(program)
-            .args(args)
-            .status()
-            .expect("Failed to execute binary")
-    }
-}
-
-fn main() {
-    // Run registered benchmarks.
-    divan::main();
-}
@@ -1,13 +0,0 @@
-[workspace]
-members = ["cargo:."]
-
-# Config for 'dist'
-[dist]
-# The preferred dist version to use in CI (Cargo.toml SemVer syntax)
-cargo-dist-version = "0.30.3"
-# CI backends to support
-ci = "github"
-# The installers to generate for each app
-installers = []
-# Target platforms to build apps for (Rust target-triple syntax)
-targets = ["aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"]
@@ -1,474 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 4
-
-[[package]]
-name = "aho-corasick"
-version = "1.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "android_system_properties"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "arbitrary"
-version = "1.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1"
-
-[[package]]
-name = "autocfg"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
-
-[[package]]
-name = "bumpalo"
-version = "3.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510"
-
-[[package]]
-name = "cc"
-version = "1.2.51"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a0aeaff4ff1a90589618835a598e545176939b97874f7abc7851caa0618f203"
-dependencies = [
- "find-msvc-tools",
- "jobserver",
- "libc",
- "shlex",
-]
-
-[[package]]
-name = "cfg-if"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
-
-[[package]]
-name = "chrono"
-version = "0.4.42"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "145052bdd345b87320e369255277e3fb5152762ad123a901ef5c262dd38fe8d2"
-dependencies = [
- "iana-time-zone",
- "js-sys",
- "num-traits",
- "wasm-bindgen",
- "windows-link",
-]
-
-[[package]]
-name = "const_format"
-version = "0.2.35"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7faa7469a93a566e9ccc1c73fe783b4a65c274c5ace346038dca9c39fe0030ad"
-dependencies = [
- "const_format_proc_macros",
-]
-
-[[package]]
-name = "const_format_proc_macros"
-version = "0.2.34"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d57c2eccfb16dbac1f4e61e206105db5820c9d26c3c472bc17c774259ef7744"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-xid",
-]
-
-[[package]]
-name = "core-foundation-sys"
-version = "0.8.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
-
-[[package]]
-name = "diff"
-version = "0.1.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
-
-[[package]]
-name = "diffutils"
-version = "0.5.0"
-dependencies = [
- "chrono",
- "const_format",
- "diff",
- "itoa",
- "regex",
- "same-file",
- "unicode-width",
-]
-
-[[package]]
-name = "find-msvc-tools"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "645cbb3a84e60b7531617d5ae4e57f7e27308f6445f5abf653209ea76dec8dff"
-
-[[package]]
-name = "getrandom"
-version = "0.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
-dependencies = [
- "cfg-if",
- "libc",
- "r-efi",
- "wasip2",
-]
-
-[[package]]
-name = "iana-time-zone"
-version = "0.1.64"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33e57f83510bb73707521ebaffa789ec8caf86f9657cad665b092b581d40e9fb"
-dependencies = [
- "android_system_properties",
- "core-foundation-sys",
- "iana-time-zone-haiku",
- "js-sys",
- "log",
- "wasm-bindgen",
- "windows-core",
-]
-
-[[package]]
-name = "iana-time-zone-haiku"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
-dependencies = [
- "cc",
-]
-
-[[package]]
-name = "itoa"
-version = "1.0.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
-
-[[package]]
-name = "jobserver"
-version = "0.1.34"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
-dependencies = [
- "getrandom",
- "libc",
-]
-
-[[package]]
-name = "js-sys"
-version = "0.3.83"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "464a3709c7f55f1f721e5389aa6ea4e3bc6aba669353300af094b29ffbdde1d8"
-dependencies = [
- "once_cell",
- "wasm-bindgen",
-]
-
-[[package]]
-name = "libc"
-version = "0.2.178"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091"
-
-[[package]]
-name = "libfuzzer-sys"
-version = "0.4.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f12a681b7dd8ce12bff52488013ba614b869148d54dd79836ab85aafdd53f08d"
-dependencies = [
- "arbitrary",
- "cc",
-]
-
-[[package]]
-name = "log"
-version = "0.4.29"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
-
-[[package]]
-name = "memchr"
-version = "2.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
-
-[[package]]
-name = "num-traits"
-version = "0.2.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
-dependencies = [
- "autocfg",
-]
-
-[[package]]
-name = "once_cell"
-version = "1.21.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.104"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9695f8df41bb4f3d222c95a67532365f569318332d03d5f3f67f37b20e6ebdf0"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.42"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "r-efi"
-version = "5.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
-
-[[package]]
-name = "regex"
-version = "1.12.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-automata",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-automata"
-version = "0.4.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-syntax"
-version = "0.8.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
-
-[[package]]
-name = "rustversion"
-version = "1.0.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
-
-[[package]]
-name = "same-file"
-version = "1.0.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
-dependencies = [
- "winapi-util",
-]
-
-[[package]]
-name = "shlex"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
-
-[[package]]
-name = "syn"
-version = "2.0.112"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21f182278bf2d2bcb3c88b1b08a37df029d71ce3d3ae26168e3c653b213b99d4"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
-
-[[package]]
-name = "unicode-width"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
-
-[[package]]
-name = "unicode-xid"
-version = "0.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
-
-[[package]]
-name = "unified-diff-fuzz"
-version = "0.0.0"
-dependencies = [
- "diffutils",
- "libfuzzer-sys",
-]
-
-[[package]]
-name = "wasip2"
-version = "1.0.1+wasi-0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"
-dependencies = [
- "wit-bindgen",
-]
-
-[[package]]
-name = "wasm-bindgen"
-version = "0.2.106"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d759f433fa64a2d763d1340820e46e111a7a5ab75f993d1852d70b03dbb80fd"
-dependencies = [
- "cfg-if",
- "once_cell",
- "rustversion",
- "wasm-bindgen-macro",
- "wasm-bindgen-shared",
-]
-
-[[package]]
-name = "wasm-bindgen-macro"
-version = "0.2.106"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48cb0d2638f8baedbc542ed444afc0644a29166f1595371af4fecf8ce1e7eeb3"
-dependencies = [
- "quote",
- "wasm-bindgen-macro-support",
-]
-
-[[package]]
-name = "wasm-bindgen-macro-support"
-version = "0.2.106"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cefb59d5cd5f92d9dcf80e4683949f15ca4b511f4ac0a6e14d4e1ac60c6ecd40"
-dependencies = [
- "bumpalo",
- "proc-macro2",
- "quote",
- "syn",
- "wasm-bindgen-shared",
-]
-
-[[package]]
-name = "wasm-bindgen-shared"
-version = "0.2.106"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cbc538057e648b67f72a982e708d485b2efa771e1ac05fec311f9f63e5800db4"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "winapi-util"
-version = "0.1.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
-dependencies = [
- "windows-sys",
-]
-
-[[package]]
-name = "windows-core"
-version = "0.62.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
-dependencies = [
- "windows-implement",
- "windows-interface",
- "windows-link",
- "windows-result",
- "windows-strings",
-]
-
-[[package]]
-name = "windows-implement"
-version = "0.60.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "windows-interface"
-version = "0.59.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "windows-link"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
-
-[[package]]
-name = "windows-result"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
-dependencies = [
- "windows-link",
-]
-
-[[package]]
-name = "windows-strings"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
-dependencies = [
- "windows-link",
-]
-
-[[package]]
-name = "windows-sys"
-version = "0.61.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
-dependencies = [
- "windows-link",
-]
-
-[[package]]
-name = "wit-bindgen"
-version = "0.46.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
@@ -9,25 +9,13 @@ edition = "2018"
 cargo-fuzz = true

 [dependencies]
-libfuzzer-sys = "0.4.7"
+libfuzzer-sys = "0.4"
 diffutils = { path = "../" }

 # Prevent this from interfering with workspaces
 [workspace]
 members = ["."]

-[[bin]]
-name = "fuzz_cmp"
-path = "fuzz_targets/fuzz_cmp.rs"
-test = false
-doc = false
-
-[[bin]]
-name = "fuzz_cmp_args"
-path = "fuzz_targets/fuzz_cmp_args.rs"
-test = false
-doc = false
-
 [[bin]]
 name = "fuzz_patch"
 path = "fuzz_targets/fuzz_patch.rs"
@@ -47,8 +35,4 @@ path = "fuzz_targets/fuzz_ed.rs"
 test = false
 doc = false

-[[bin]]
-name = "fuzz_side"
-path = "fuzz_targets/fuzz_side.rs"
-test = false
-doc = false
+
@@ -1,36 +0,0 @@
-"-l"
-"--verbose"
-"-b"
-"--print-bytes"
-"-lb"
-"-bl"
-"-n"
-"--bytes"
-"--bytes="
-"--bytes=1024"
-"--bytes=99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
-"-i"
-"--ignore-initial"
-"--ignore-initial="
-"--ignore-initial=1024"
-"--ignore-initial=99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999:9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
-"-s"
-"-q"
-"--quiet"
-"--silent"
-"-"
-"--"
-"1kB"
-"1G"
-"1GB"
-"1T"
-"1TB"
-"1P"
-"1PB"
-"1Z"
-"1ZB"
-"1Y"
-"1YB"
-"1Y"
-"0"
-"1:2"
@@ -1,51 +0,0 @@
-#![no_main]
-#[macro_use]
-extern crate libfuzzer_sys;
-use diffutilslib::cmp::{self, Cmp};
-
-use std::ffi::OsString;
-use std::fs::File;
-use std::io::Write;
-
-fn os(s: &str) -> OsString {
-    OsString::from(s)
-}
-
-fuzz_target!(|x: (Vec<u8>, Vec<u8>)| {
-    let args = vec!["cmp", "-l", "-b", "target/fuzz.cmp.a", "target/fuzz.cmp.b"]
-        .into_iter()
-        .map(|s| os(s))
-        .peekable();
-
-    let (from, to) = x;
-
-    File::create("target/fuzz.cmp.a")
-        .unwrap()
-        .write_all(&from)
-        .unwrap();
-
-    File::create("target/fuzz.cmp.b")
-        .unwrap()
-        .write_all(&to)
-        .unwrap();
-
-    let params =
-        cmp::parse_params(args).unwrap_or_else(|e| panic!("Failed to parse params: {}", e));
-    let ret = cmp::cmp(&params);
-    if from == to && !matches!(ret, Ok(Cmp::Equal)) {
-        panic!(
-            "target/fuzz.cmp.a and target/fuzz.cmp.b are equal, but cmp returned {:?}.",
-            ret
-        );
-    } else if from != to && !matches!(ret, Ok(Cmp::Different)) {
-        panic!(
-            "target/fuzz.cmp.a and target/fuzz.cmp.b are different, but cmp returned {:?}.",
-            ret
-        );
-    } else if ret.is_err() {
-        panic!(
-            "target/fuzz.cmp.a and target/fuzz.cmp.b caused cmp to error ({:?}).",
-            ret
-        );
-    }
-});
@@ -1,23 +0,0 @@
-#![no_main]
-#[macro_use]
-extern crate libfuzzer_sys;
-use diffutilslib::cmp;
-
-use libfuzzer_sys::Corpus;
-use std::ffi::OsString;
-
-fn os(s: &str) -> OsString {
-    OsString::from(s)
-}
-
-fuzz_target!(|x: Vec<OsString>| -> Corpus {
-    if x.len() > 6 {
-        // Make sure we try to parse an option when we get longer args. x[0] will be
-        // the executable name.
-        if ![os("-l"), os("-b"), os("-s"), os("-n"), os("-i")].contains(&x[1]) {
-            return Corpus::Reject;
-        }
-    }
-    let _ = cmp::parse_params(x.into_iter().peekable());
-    Corpus::Keep
-});
@@ -1,42 +0,0 @@
-#![no_main]
-#[macro_use]
-extern crate libfuzzer_sys;
-
-use diffutilslib::side_diff;
-
-use std::fs::File;
-use std::io::Write;
-use diffutilslib::params::Params;
-
-fuzz_target!(|x: (Vec<u8>, Vec<u8>, /* usize, usize */ bool)| {
-    let (original, new, /* width, tabsize, */ expand) = x;
-
-    // if width == 0 || tabsize == 0 {
-    //     return;
-    // }
-
-    let params = Params {
-        // width,
-        // tabsize,
-        expand_tabs: expand,
-        ..Default::default()
-    };
-    let mut output_buf = vec![];
-    side_diff::diff(&original, &new, &mut output_buf, &params);
-    File::create("target/fuzz.file.original")
-        .unwrap()
-        .write_all(&original)
-        .unwrap();
-    File::create("target/fuzz.file.new")
-        .unwrap()
-        .write_all(&new)
-        .unwrap();
-    File::create("target/fuzz.file")
-        .unwrap()
-        .write_all(&original)
-        .unwrap();
-    File::create("target/fuzz.diff")
-        .unwrap()
-        .write_all(&output_buf)
-        .unwrap();
-});
@@ -8,7 +8,6 @@ use std::io::Write;

 use crate::params::Params;
 use crate::utils::do_write_line;
-use crate::utils::get_modification_time;

 #[derive(Debug, PartialEq)]
 pub enum DiffLine {
@@ -268,14 +267,10 @@ fn make_diff(

 #[must_use]
 pub fn diff(expected: &[u8], actual: &[u8], params: &Params) -> Vec<u8> {
-    let from_modified_time = get_modification_time(&params.from.to_string_lossy());
-    let to_modified_time = get_modification_time(&params.to.to_string_lossy());
    let mut output = format!(
-        "*** {0}\t{1}\n--- {2}\t{3}\n",
+        "*** {0}\t\n--- {1}\t\n",
        params.from.to_string_lossy(),
-        from_modified_time,
-        params.to.to_string_lossy(),
-        to_modified_time
+        params.to.to_string_lossy()
    )
    .into_bytes();
    let diff_results = make_diff(expected, actual, params.context_count, params.brief);
@@ -439,26 +434,26 @@ mod tests {
                                        ..Default::default()
                                    },
                                );
-                                File::create(format!("{target}/ab.diff"))
+                                File::create(&format!("{target}/ab.diff"))
                                    .unwrap()
                                    .write_all(&diff)
                                    .unwrap();
-                                let mut fa = File::create(format!("{target}/alef")).unwrap();
+                                let mut fa = File::create(&format!("{target}/alef")).unwrap();
                                fa.write_all(&alef[..]).unwrap();
-                                let mut fb = File::create(format!("{target}/bet")).unwrap();
+                                let mut fb = File::create(&format!("{target}/bet")).unwrap();
                                fb.write_all(&bet[..]).unwrap();
                                let _ = fa;
                                let _ = fb;
                                let output = Command::new("patch")
                                    .arg("-p0")
                                    .arg("--context")
-                                    .stdin(File::open(format!("{target}/ab.diff")).unwrap())
+                                    .stdin(File::open(&format!("{target}/ab.diff")).unwrap())
                                    .output()
                                    .unwrap();
                                assert!(output.status.success(), "{output:?}");
                                //println!("{}", String::from_utf8_lossy(&output.stdout));
                                //println!("{}", String::from_utf8_lossy(&output.stderr));
-                                let alef = fs::read(format!("{target}/alef")).unwrap();
+                                let alef = fs::read(&format!("{target}/alef")).unwrap();
                                assert_eq!(alef, bet);
                            }
                        }
@@ -520,26 +515,26 @@ mod tests {
                                        ..Default::default()
                                    },
                                );
-                                File::create(format!("{target}/ab_.diff"))
+                                File::create(&format!("{target}/ab_.diff"))
                                    .unwrap()
                                    .write_all(&diff)
                                    .unwrap();
-                                let mut fa = File::create(format!("{target}/alef_")).unwrap();
+                                let mut fa = File::create(&format!("{target}/alef_")).unwrap();
                                fa.write_all(&alef[..]).unwrap();
-                                let mut fb = File::create(format!("{target}/bet_")).unwrap();
+                                let mut fb = File::create(&format!("{target}/bet_")).unwrap();
                                fb.write_all(&bet[..]).unwrap();
                                let _ = fa;
                                let _ = fb;
                                let output = Command::new("patch")
                                    .arg("-p0")
                                    .arg("--context")
-                                    .stdin(File::open(format!("{target}/ab_.diff")).unwrap())
+                                    .stdin(File::open(&format!("{target}/ab_.diff")).unwrap())
                                    .output()
                                    .unwrap();
                                assert!(output.status.success(), "{output:?}");
                                //println!("{}", String::from_utf8_lossy(&output.stdout));
                                //println!("{}", String::from_utf8_lossy(&output.stderr));
-                                let alef = fs::read(format!("{target}/alef_")).unwrap();
+                                let alef = fs::read(&format!("{target}/alef_")).unwrap();
                                assert_eq!(alef, bet);
                            }
                        }
@@ -604,26 +599,26 @@ mod tests {
                                        ..Default::default()
                                    },
                                );
-                                File::create(format!("{target}/abx.diff"))
+                                File::create(&format!("{target}/abx.diff"))
                                    .unwrap()
                                    .write_all(&diff)
                                    .unwrap();
-                                let mut fa = File::create(format!("{target}/alefx")).unwrap();
+                                let mut fa = File::create(&format!("{target}/alefx")).unwrap();
                                fa.write_all(&alef[..]).unwrap();
-                                let mut fb = File::create(format!("{target}/betx")).unwrap();
+                                let mut fb = File::create(&format!("{target}/betx")).unwrap();
                                fb.write_all(&bet[..]).unwrap();
                                let _ = fa;
                                let _ = fb;
                                let output = Command::new("patch")
                                    .arg("-p0")
                                    .arg("--context")
-                                    .stdin(File::open(format!("{target}/abx.diff")).unwrap())
+                                    .stdin(File::open(&format!("{target}/abx.diff")).unwrap())
                                    .output()
                                    .unwrap();
                                assert!(output.status.success(), "{output:?}");
                                //println!("{}", String::from_utf8_lossy(&output.stdout));
                                //println!("{}", String::from_utf8_lossy(&output.stderr));
-                                let alef = fs::read(format!("{target}/alefx")).unwrap();
+                                let alef = fs::read(&format!("{target}/alefx")).unwrap();
                                assert_eq!(alef, bet);
                            }
                        }
@@ -691,26 +686,26 @@ mod tests {
                                        ..Default::default()
                                    },
                                );
-                                File::create(format!("{target}/abr.diff"))
+                                File::create(&format!("{target}/abr.diff"))
                                    .unwrap()
                                    .write_all(&diff)
                                    .unwrap();
-                                let mut fa = File::create(format!("{target}/alefr")).unwrap();
+                                let mut fa = File::create(&format!("{target}/alefr")).unwrap();
                                fa.write_all(&alef[..]).unwrap();
-                                let mut fb = File::create(format!("{target}/betr")).unwrap();
+                                let mut fb = File::create(&format!("{target}/betr")).unwrap();
                                fb.write_all(&bet[..]).unwrap();
                                let _ = fa;
                                let _ = fb;
                                let output = Command::new("patch")
                                    .arg("-p0")
                                    .arg("--context")
-                                    .stdin(File::open(format!("{target}/abr.diff")).unwrap())
+                                    .stdin(File::open(&format!("{target}/abr.diff")).unwrap())
                                    .output()
                                    .unwrap();
                                assert!(output.status.success(), "{output:?}");
                                //println!("{}", String::from_utf8_lossy(&output.stdout));
                                //println!("{}", String::from_utf8_lossy(&output.stderr));
-                                let alef = fs::read(format!("{target}/alefr")).unwrap();
+                                let alef = fs::read(&format!("{target}/alefr")).unwrap();
                                assert_eq!(alef, bet);
                            }
                        }
@@ -722,8 +717,6 @@ mod tests {

    #[test]
    fn test_stop_early() {
-        use crate::assert_diff_eq;
-
        let from_filename = "foo";
        let from = ["a", "b", "c", ""].join("\n");
        let to_filename = "bar";
@@ -738,10 +731,9 @@ mod tests {
                ..Default::default()
            },
        );
-
        let expected_full = [
-            "*** foo\tTIMESTAMP",
-            "--- bar\tTIMESTAMP",
+            "*** foo\t",
+            "--- bar\t",
            "***************",
            "*** 1,3 ****",
            "  a",
@@ -754,7 +746,7 @@ mod tests {
            "",
        ]
        .join("\n");
-        assert_diff_eq!(diff_full, expected_full);
+        assert_eq!(diff_full, expected_full.as_bytes());

        let diff_brief = diff(
            from.as_bytes(),
@@ -766,9 +758,8 @@ mod tests {
                ..Default::default()
            },
        );
-
-        let expected_brief = ["*** foo\tTIMESTAMP", "--- bar\tTIMESTAMP", ""].join("\n");
-        assert_diff_eq!(diff_brief, expected_brief);
+        let expected_brief = ["*** foo\t", "--- bar\t", ""].join("\n");
+        assert_eq!(diff_brief, expected_brief.as_bytes());

        let nodiff_full = diff(
            from.as_bytes(),
@@ -1,102 +0,0 @@
-// This file is part of the uutils diffutils package.
-//
-// For the full copyright and license information, please view the LICENSE-*
-// files that was distributed with this source code.
-
-use crate::params::{parse_params, Format};
-use crate::utils::report_failure_to_read_input_file;
-use crate::{context_diff, ed_diff, normal_diff, side_diff, unified_diff};
-use std::env::ArgsOs;
-use std::ffi::OsString;
-use std::fs;
-use std::io::{self, stdout, Read, Write};
-use std::iter::Peekable;
-use std::process::{exit, ExitCode};
-
-// Exit codes are documented at
-// https://www.gnu.org/software/diffutils/manual/html_node/Invoking-diff.html.
-//     An exit status of 0 means no differences were found,
-//     1 means some differences were found,
-//     and 2 means trouble.
-pub fn main(opts: Peekable<ArgsOs>) -> ExitCode {
-    let params = parse_params(opts).unwrap_or_else(|error| {
-        eprintln!("{error}");
-        exit(2);
-    });
-    // if from and to are the same file, no need to perform any comparison
-    let maybe_report_identical_files = || {
-        if params.report_identical_files {
-            println!(
-                "Files {} and {} are identical",
-                params.from.to_string_lossy(),
-                params.to.to_string_lossy(),
-            );
-        }
-    };
-    if params.from == "-" && params.to == "-"
-        || same_file::is_same_file(&params.from, &params.to).unwrap_or(false)
-    {
-        maybe_report_identical_files();
-        return ExitCode::SUCCESS;
-    }
-
-    // read files
-    fn read_file_contents(filepath: &OsString) -> io::Result<Vec<u8>> {
-        if filepath == "-" {
-            let mut content = Vec::new();
-            io::stdin().read_to_end(&mut content).and(Ok(content))
-        } else {
-            fs::read(filepath)
-        }
-    }
-    let mut io_error = false;
-    let from_content = match read_file_contents(&params.from) {
-        Ok(from_content) => from_content,
-        Err(e) => {
-            report_failure_to_read_input_file(&params.executable, &params.from, &e);
-            io_error = true;
-            vec![]
-        }
-    };
-    let to_content = match read_file_contents(&params.to) {
-        Ok(to_content) => to_content,
-        Err(e) => {
-            report_failure_to_read_input_file(&params.executable, &params.to, &e);
-            io_error = true;
-            vec![]
-        }
-    };
-    if io_error {
-        return ExitCode::from(2);
-    }
-
-    // run diff
-    let result: Vec<u8> = match params.format {
-        Format::Normal => normal_diff::diff(&from_content, &to_content, &params),
-        Format::Unified => unified_diff::diff(&from_content, &to_content, &params),
-        Format::Context => context_diff::diff(&from_content, &to_content, &params),
-        Format::Ed => ed_diff::diff(&from_content, &to_content, &params).unwrap_or_else(|error| {
-            eprintln!("{error}");
-            exit(2);
-        }),
-        Format::SideBySide => {
-            let mut output = stdout().lock();
-            side_diff::diff(&from_content, &to_content, &mut output, &params)
-        }
-    };
-    if params.brief && !result.is_empty() {
-        println!(
-            "Files {} and {} differ",
-            params.from.to_string_lossy(),
-            params.to.to_string_lossy()
-        );
-    } else {
-        io::stdout().write_all(&result).unwrap();
-    }
-    if result.is_empty() {
-        maybe_report_identical_files();
-        ExitCode::SUCCESS
-    } else {
-        ExitCode::from(1)
-    }
-}
@@ -188,8 +188,9 @@ mod tests {
                    for &d in &[0, 1, 2] {
                        for &e in &[0, 1, 2] {
                            for &f in &[0, 1, 2] {
-                                use std::fs::File;
+                                use std::fs::{self, File};
                                use std::io::Write;
+                                use std::process::Command;
                                let mut alef = Vec::new();
                                let mut bet = Vec::new();
                                alef.write_all(if a == 0 { b"a\n" } else { b"b\n" })
@@ -225,30 +226,26 @@ mod tests {
                                // This test diff is intentionally reversed.
                                // We want it to turn the alef into bet.
                                let diff = diff_w(&alef, &bet, &format!("{target}/alef")).unwrap();
-                                File::create(format!("{target}/ab.ed"))
+                                File::create("target/ab.ed")
                                    .unwrap()
                                    .write_all(&diff)
                                    .unwrap();
-                                let mut fa = File::create(format!("{target}/alef")).unwrap();
+                                let mut fa = File::create(&format!("{target}/alef")).unwrap();
                                fa.write_all(&alef[..]).unwrap();
-                                let mut fb = File::create(format!("{target}/bet")).unwrap();
+                                let mut fb = File::create(&format!("{target}/bet")).unwrap();
                                fb.write_all(&bet[..]).unwrap();
                                let _ = fa;
                                let _ = fb;
-                                #[cfg(not(windows))] // there's no ed on windows
-                                {
-                                    use std::process::Command;
-                                    let output = Command::new("ed")
-                                        .arg(format!("{target}/alef"))
-                                        .stdin(File::open(format!("{target}/ab.ed")).unwrap())
-                                        .output()
-                                        .unwrap();
-                                    assert!(output.status.success(), "{output:?}");
-                                    //println!("{}", String::from_utf8_lossy(&output.stdout));
-                                    //println!("{}", String::from_utf8_lossy(&output.stderr));
-                                    let alef = std::fs::read(format!("{target}/alef")).unwrap();
-                                    assert_eq!(alef, bet);
-                                }
+                                let output = Command::new("ed")
+                                    .arg(&format!("{target}/alef"))
+                                    .stdin(File::open("target/ab.ed").unwrap())
+                                    .output()
+                                    .unwrap();
+                                assert!(output.status.success(), "{output:?}");
+                                //println!("{}", String::from_utf8_lossy(&output.stdout));
+                                //println!("{}", String::from_utf8_lossy(&output.stderr));
+                                let alef = fs::read(&format!("{target}/alef")).unwrap();
+                                assert_eq!(alef, bet);
                            }
                        }
                    }
@@ -268,8 +265,9 @@ mod tests {
                    for &d in &[0, 1, 2] {
                        for &e in &[0, 1, 2] {
                            for &f in &[0, 1, 2] {
-                                use std::fs::File;
+                                use std::fs::{self, File};
                                use std::io::Write;
+                                use std::process::Command;
                                let mut alef = Vec::new();
                                let mut bet = Vec::new();
                                alef.write_all(if a == 0 { b"\n" } else { b"b\n" }).unwrap();
@@ -298,31 +296,27 @@ mod tests {
                                }
                                // This test diff is intentionally reversed.
                                // We want it to turn the alef into bet.
-                                let diff = diff_w(&alef, &bet, &format!("{target}/alef_")).unwrap();
-                                File::create(format!("{target}/ab_.ed"))
+                                let diff = diff_w(&alef, &bet, "target/alef_").unwrap();
+                                File::create("target/ab_.ed")
                                    .unwrap()
                                    .write_all(&diff)
                                    .unwrap();
-                                let mut fa = File::create(format!("{target}/alef_")).unwrap();
+                                let mut fa = File::create("target/alef_").unwrap();
                                fa.write_all(&alef[..]).unwrap();
-                                let mut fb = File::create(format!("{target}/bet_")).unwrap();
+                                let mut fb = File::create(&format!("{target}/bet_")).unwrap();
                                fb.write_all(&bet[..]).unwrap();
                                let _ = fa;
                                let _ = fb;
-                                #[cfg(not(windows))] // there's no ed on windows
-                                {
-                                    use std::process::Command;
-                                    let output = Command::new("ed")
-                                        .arg(format!("{target}/alef_"))
-                                        .stdin(File::open(format!("{target}/ab_.ed")).unwrap())
-                                        .output()
-                                        .unwrap();
-                                    assert!(output.status.success(), "{output:?}");
-                                    //println!("{}", String::from_utf8_lossy(&output.stdout));
-                                    //println!("{}", String::from_utf8_lossy(&output.stderr));
-                                    let alef = std::fs::read(format!("{target}/alef_")).unwrap();
-                                    assert_eq!(alef, bet);
-                                }
+                                let output = Command::new("ed")
+                                    .arg("target/alef_")
+                                    .stdin(File::open("target/ab_.ed").unwrap())
+                                    .output()
+                                    .unwrap();
+                                assert!(output.status.success(), "{output:?}");
+                                //println!("{}", String::from_utf8_lossy(&output.stdout));
+                                //println!("{}", String::from_utf8_lossy(&output.stderr));
+                                let alef = fs::read("target/alef_").unwrap();
+                                assert_eq!(alef, bet);
                            }
                        }
                    }
@@ -342,8 +336,9 @@ mod tests {
                    for &d in &[0, 1, 2] {
                        for &e in &[0, 1, 2] {
                            for &f in &[0, 1, 2] {
-                                use std::fs::File;
+                                use std::fs::{self, File};
                                use std::io::Write;
+                                use std::process::Command;
                                let mut alef = Vec::new();
                                let mut bet = Vec::new();
                                alef.write_all(if a == 0 { b"a\n" } else { b"f\n" })
@@ -379,30 +374,26 @@ mod tests {
                                // This test diff is intentionally reversed.
                                // We want it to turn the alef into bet.
                                let diff = diff_w(&alef, &bet, &format!("{target}/alefr")).unwrap();
-                                File::create(format!("{target}/abr.ed"))
+                                File::create("target/abr.ed")
                                    .unwrap()
                                    .write_all(&diff)
                                    .unwrap();
-                                let mut fa = File::create(format!("{target}/alefr")).unwrap();
+                                let mut fa = File::create(&format!("{target}/alefr")).unwrap();
                                fa.write_all(&alef[..]).unwrap();
-                                let mut fb = File::create(format!("{target}/betr")).unwrap();
+                                let mut fb = File::create(&format!("{target}/betr")).unwrap();
                                fb.write_all(&bet[..]).unwrap();
                                let _ = fa;
                                let _ = fb;
-                                #[cfg(not(windows))] // there's no ed on windows
-                                {
-                                    use std::process::Command;
-                                    let output = Command::new("ed")
-                                        .arg(format!("{target}/alefr"))
-                                        .stdin(File::open(format!("{target}/abr.ed")).unwrap())
-                                        .output()
-                                        .unwrap();
-                                    assert!(output.status.success(), "{output:?}");
-                                    //println!("{}", String::from_utf8_lossy(&output.stdout));
-                                    //println!("{}", String::from_utf8_lossy(&output.stderr));
-                                    let alef = std::fs::read(format!("{target}/alefr")).unwrap();
-                                    assert_eq!(alef, bet);
-                                }
+                                let output = Command::new("ed")
+                                    .arg(&format!("{target}/alefr"))
+                                    .stdin(File::open("target/abr.ed").unwrap())
+                                    .output()
+                                    .unwrap();
+                                assert!(output.status.success(), "{output:?}");
+                                //println!("{}", String::from_utf8_lossy(&output.stdout));
+                                //println!("{}", String::from_utf8_lossy(&output.stderr));
+                                let alef = fs::read(&format!("{target}/alefr")).unwrap();
+                                assert_eq!(alef, bet);
                            }
                        }
                    }
@@ -1,10 +1,7 @@
-pub mod cmp;
 pub mod context_diff;
 pub mod ed_diff;
-pub mod macros;
 pub mod normal_diff;
 pub mod params;
-pub mod side_diff;
 pub mod unified_diff;
 pub mod utils;

@@ -12,5 +9,4 @@ pub mod utils;
 pub use context_diff::diff as context_diff;
 pub use ed_diff::diff as ed_diff;
 pub use normal_diff::diff as normal_diff;
-pub use side_diff::diff as side_by_side_diff;
 pub use unified_diff::diff as unified_diff;
@@ -1,25 +0,0 @@
-// asserts equality of the actual diff and expected diff
-// considering datetime varitations
-//
-// It replaces the modification time in the actual diff
-// with placeholder "TIMESTAMP" and then asserts the equality
-//
-// For eg.
-// let brief = "*** fruits_old.txt\t2024-03-24 23:43:05.189597645 +0530\n
-//              --- fruits_new.txt\t2024-03-24 23:35:08.922581904 +0530\n";
-//
-// replaced = "*** fruits_old.txt\tTIMESTAMP\n
-//             --- fruits_new.txt\tTIMESTAMP\n";
-#[macro_export]
-macro_rules! assert_diff_eq {
-    ($actual:expr, $expected:expr) => {{
-        use regex::Regex;
-        use std::str;
-
-        let diff = str::from_utf8(&$actual).unwrap();
-        let re = Regex::new(r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d+ [+-]\d{4}").unwrap();
-        let actual = re.replacen(diff, 2, "TIMESTAMP");
-
-        assert_eq!(actual, $expected);
-    }};
-}
@@ -3,79 +3,83 @@
 // For the full copyright and license information, please view the LICENSE-*
 // files that was distributed with this source code.

-use std::{
-    env::ArgsOs,
-    ffi::{OsStr, OsString},
-    iter::Peekable,
-    path::{Path, PathBuf},
-    process::ExitCode,
-};
+use crate::params::{parse_params, Format};
+use std::env;
+
+use std::fs;
+use std::io::{self, Write};
+use std::process::{exit, ExitCode};

-mod cmp;
 mod context_diff;
-mod diff;
 mod ed_diff;
-mod macros;
 mod normal_diff;
 mod params;
-mod side_diff;
 mod unified_diff;
 mod utils;

-/// # Panics
-/// Panics if the binary path cannot be determined
-fn binary_path(args: &mut Peekable<ArgsOs>) -> PathBuf {
-    match args.peek() {
-        Some(ref s) if !s.is_empty() => PathBuf::from(s),
-        _ => std::env::current_exe().unwrap(),
-    }
-}
-
-/// #Panics
-/// Panics if path has no UTF-8 valid name
-fn name(binary_path: &Path) -> &OsStr {
-    binary_path.file_stem().unwrap()
-}
-
-const VERSION: &str = env!("CARGO_PKG_VERSION");
-
-fn usage(name: &str) {
-    println!("{name} {VERSION} (multi-call binary)\n");
-    println!("Usage: {name} [function [arguments...]]\n");
-    println!("Currently defined functions:\n");
-    println!("    cmp, diff\n");
-}
-
-fn second_arg_error(name: &OsStr) -> ! {
-    eprintln!("Expected utility name as second argument, got nothing.");
-    usage(&name.to_string_lossy());
-    std::process::exit(0);
-}
-
+// Exit codes are documented at
+// https://www.gnu.org/software/diffutils/manual/html_node/Invoking-diff.html.
+//     An exit status of 0 means no differences were found,
+//     1 means some differences were found,
+//     and 2 means trouble.
 fn main() -> ExitCode {
-    let mut args = std::env::args_os().peekable();
-
-    let exe_path = binary_path(&mut args);
-    let exe_name = name(&exe_path);
-
-    let util_name = if exe_name == "diffutils" {
-        // Discard the item we peeked.
-        let _ = args.next();
-
-        args.peek()
-            .cloned()
-            .unwrap_or_else(|| second_arg_error(exe_name))
-    } else {
-        OsString::from(exe_name)
-    };
-
-    match util_name.to_str() {
-        Some("diff") => diff::main(args),
-        Some("cmp") => cmp::main(args),
-        Some(name) => {
-            eprintln!("{name}: utility not supported");
-            ExitCode::from(2)
+    let opts = env::args_os();
+    let params = parse_params(opts).unwrap_or_else(|error| {
+        eprintln!("{error}");
+        exit(2);
+    });
+    // if from and to are the same file, no need to perform any comparison
+    let maybe_report_identical_files = || {
+        if params.report_identical_files {
+            println!(
+                "Files {} and {} are identical",
+                params.from.to_string_lossy(),
+                params.to.to_string_lossy(),
+            );
        }
-        None => second_arg_error(exe_name),
+    };
+    if same_file::is_same_file(&params.from, &params.to).unwrap_or(false) {
+        maybe_report_identical_files();
+        return ExitCode::SUCCESS;
+    }
+    // read files
+    let from_content = match fs::read(&params.from) {
+        Ok(from_content) => from_content,
+        Err(e) => {
+            eprintln!("Failed to read from-file: {e}");
+            return ExitCode::from(2);
+        }
+    };
+    let to_content = match fs::read(&params.to) {
+        Ok(to_content) => to_content,
+        Err(e) => {
+            eprintln!("Failed to read to-file: {e}");
+            return ExitCode::from(2);
+        }
+    };
+    // run diff
+    let result: Vec<u8> = match params.format {
+        Format::Normal => normal_diff::diff(&from_content, &to_content, &params),
+        Format::Unified => unified_diff::diff(&from_content, &to_content, &params),
+        Format::Context => context_diff::diff(&from_content, &to_content, &params),
+        Format::Ed => ed_diff::diff(&from_content, &to_content, &params).unwrap_or_else(|error| {
+            eprintln!("{error}");
+            exit(2);
+        }),
+    };
+    if params.brief && !result.is_empty() {
+        println!(
+            "Files {} and {} differ",
+            params.from.to_string_lossy(),
+            params.to.to_string_lossy()
+        );
+    } else {
+        io::stdout().write_all(&result).unwrap();
+    }
+    if result.is_empty() {
+        maybe_report_identical_files();
+        ExitCode::SUCCESS
+    } else {
+        ExitCode::from(1)
    }
 }
@@ -275,26 +275,26 @@ mod tests {
                                // This test diff is intentionally reversed.
                                // We want it to turn the alef into bet.
                                let diff = diff(&alef, &bet, &Params::default());
-                                File::create(format!("{target}/ab.diff"))
+                                File::create(&format!("{target}/ab.diff"))
                                    .unwrap()
                                    .write_all(&diff)
                                    .unwrap();
-                                let mut fa = File::create(format!("{target}/alef")).unwrap();
+                                let mut fa = File::create(&format!("{target}/alef")).unwrap();
                                fa.write_all(&alef[..]).unwrap();
-                                let mut fb = File::create(format!("{target}/bet")).unwrap();
+                                let mut fb = File::create(&format!("{target}/bet")).unwrap();
                                fb.write_all(&bet[..]).unwrap();
                                let _ = fa;
                                let _ = fb;
                                let output = Command::new("patch")
                                    .arg("-p0")
-                                    .arg(format!("{target}/alef"))
-                                    .stdin(File::open(format!("{target}/ab.diff")).unwrap())
+                                    .arg(&format!("{target}/alef"))
+                                    .stdin(File::open(&format!("{target}/ab.diff")).unwrap())
                                    .output()
                                    .unwrap();
                                assert!(output.status.success(), "{output:?}");
                                //println!("{}", String::from_utf8_lossy(&output.stdout));
                                //println!("{}", String::from_utf8_lossy(&output.stderr));
-                                let alef = fs::read(format!("{target}/alef")).unwrap();
+                                let alef = fs::read(&format!("{target}/alef")).unwrap();
                                assert_eq!(alef, bet);
                            }
                        }
@@ -367,27 +367,27 @@ mod tests {
                                    // This test diff is intentionally reversed.
                                    // We want it to turn the alef into bet.
                                    let diff = diff(&alef, &bet, &Params::default());
-                                    File::create(format!("{target}/abn.diff"))
+                                    File::create(&format!("{target}/abn.diff"))
                                        .unwrap()
                                        .write_all(&diff)
                                        .unwrap();
-                                    let mut fa = File::create(format!("{target}/alefn")).unwrap();
+                                    let mut fa = File::create(&format!("{target}/alefn")).unwrap();
                                    fa.write_all(&alef[..]).unwrap();
-                                    let mut fb = File::create(format!("{target}/betn")).unwrap();
+                                    let mut fb = File::create(&format!("{target}/betn")).unwrap();
                                    fb.write_all(&bet[..]).unwrap();
                                    let _ = fa;
                                    let _ = fb;
                                    let output = Command::new("patch")
                                        .arg("-p0")
                                        .arg("--normal")
-                                        .arg(format!("{target}/alefn"))
-                                        .stdin(File::open(format!("{target}/abn.diff")).unwrap())
+                                        .arg(&format!("{target}/alefn"))
+                                        .stdin(File::open(&format!("{target}/abn.diff")).unwrap())
                                        .output()
                                        .unwrap();
                                    assert!(output.status.success(), "{output:?}");
                                    //println!("{}", String::from_utf8_lossy(&output.stdout));
                                    //println!("{}", String::from_utf8_lossy(&output.stderr));
-                                    let alef = fs::read(format!("{target}/alefn")).unwrap();
+                                    let alef = fs::read(&format!("{target}/alefn")).unwrap();
                                    assert_eq!(alef, bet);
                                }
                            }
@@ -441,26 +441,26 @@ mod tests {
                                // This test diff is intentionally reversed.
                                // We want it to turn the alef into bet.
                                let diff = diff(&alef, &bet, &Params::default());
-                                File::create(format!("{target}/ab_.diff"))
+                                File::create(&format!("{target}/ab_.diff"))
                                    .unwrap()
                                    .write_all(&diff)
                                    .unwrap();
-                                let mut fa = File::create(format!("{target}/alef_")).unwrap();
+                                let mut fa = File::create(&format!("{target}/alef_")).unwrap();
                                fa.write_all(&alef[..]).unwrap();
-                                let mut fb = File::create(format!("{target}/bet_")).unwrap();
+                                let mut fb = File::create(&format!("{target}/bet_")).unwrap();
                                fb.write_all(&bet[..]).unwrap();
                                let _ = fa;
                                let _ = fb;
                                let output = Command::new("patch")
                                    .arg("-p0")
-                                    .arg(format!("{target}/alef_"))
-                                    .stdin(File::open(format!("{target}/ab_.diff")).unwrap())
+                                    .arg(&format!("{target}/alef_"))
+                                    .stdin(File::open(&format!("{target}/ab_.diff")).unwrap())
                                    .output()
                                    .unwrap();
                                assert!(output.status.success(), "{output:?}");
                                //println!("{}", String::from_utf8_lossy(&output.stdout));
                                //println!("{}", String::from_utf8_lossy(&output.stderr));
-                                let alef = fs::read(format!("{target}/alef_")).unwrap();
+                                let alef = fs::read(&format!("{target}/alef_")).unwrap();
                                assert_eq!(alef, bet);
                            }
                        }
@@ -519,26 +519,26 @@ mod tests {
                                // This test diff is intentionally reversed.
                                // We want it to turn the alef into bet.
                                let diff = diff(&alef, &bet, &Params::default());
-                                File::create(format!("{target}/abr.diff"))
+                                File::create(&format!("{target}/abr.diff"))
                                    .unwrap()
                                    .write_all(&diff)
                                    .unwrap();
-                                let mut fa = File::create(format!("{target}/alefr")).unwrap();
+                                let mut fa = File::create(&format!("{target}/alefr")).unwrap();
                                fa.write_all(&alef[..]).unwrap();
-                                let mut fb = File::create(format!("{target}/betr")).unwrap();
+                                let mut fb = File::create(&format!("{target}/betr")).unwrap();
                                fb.write_all(&bet[..]).unwrap();
                                let _ = fa;
                                let _ = fb;
                                let output = Command::new("patch")
                                    .arg("-p0")
-                                    .arg(format!("{target}/alefr"))
-                                    .stdin(File::open(format!("{target}/abr.diff")).unwrap())
+                                    .arg(&format!("{target}/alefr"))
+                                    .stdin(File::open(&format!("{target}/abr.diff")).unwrap())
                                    .output()
                                    .unwrap();
                                assert!(output.status.success(), "{output:?}");
                                //println!("{}", String::from_utf8_lossy(&output.stdout));
                                //println!("{}", String::from_utf8_lossy(&output.stderr));
-                                let alef = fs::read(format!("{target}/alefr")).unwrap();
+                                let alef = fs::read(&format!("{target}/alefr")).unwrap();
                                assert_eq!(alef, bet);
                            }
                        }
@@ -1,6 +1,4 @@
-use std::ffi::OsString;
-use std::iter::Peekable;
-use std::path::PathBuf;
+use std::ffi::{OsStr, OsString};

 use regex::Regex;

@@ -11,12 +9,21 @@ pub enum Format {
    Unified,
    Context,
    Ed,
-    SideBySide,
+}
+
+#[cfg(unix)]
+fn osstr_bytes(osstr: &OsStr) -> &[u8] {
+    use std::os::unix::ffi::OsStrExt;
+    osstr.as_bytes()
+}
+
+#[cfg(not(unix))]
+fn osstr_bytes(osstr: &OsStr) -> Vec<u8> {
+    osstr.to_string_lossy().bytes().collect()
 }

 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct Params {
-    pub executable: OsString,
    pub from: OsString,
    pub to: OsString,
    pub format: Format,
@@ -25,13 +32,11 @@ pub struct Params {
    pub brief: bool,
    pub expand_tabs: bool,
    pub tabsize: usize,
-    pub width: usize,
 }

 impl Default for Params {
    fn default() -> Self {
        Self {
-            executable: OsString::default(),
            from: OsString::default(),
            to: OsString::default(),
            format: Format::default(),
@@ -40,42 +45,33 @@ impl Default for Params {
            brief: false,
            expand_tabs: false,
            tabsize: 8,
-            width: 130,
        }
    }
 }

-pub fn parse_params<I: Iterator<Item = OsString>>(mut opts: Peekable<I>) -> Result<Params, String> {
+pub fn parse_params<I: IntoIterator<Item = OsString>>(opts: I) -> Result<Params, String> {
+    let mut opts = opts.into_iter();
    // parse CLI

-    let Some(executable) = opts.next() else {
+    let Some(exe) = opts.next() else {
        return Err("Usage: <exe> <from> <to>".to_string());
    };
-    let mut params = Params {
-        executable,
-        ..Default::default()
-    };
+    let mut params = Params::default();
    let mut from = None;
    let mut to = None;
    let mut format = None;
-    let mut context = None;
    let tabsize_re = Regex::new(r"^--tabsize=(?<num>\d+)$").unwrap();
-    let width_re = Regex::new(r"--width=(?P<long>\d+)$").unwrap();
    while let Some(param) = opts.next() {
-        let next_param = opts.peek();
        if param == "--" {
            break;
        }
        if param == "-" {
            if from.is_none() {
-                from = Some(param);
+                from = Some(OsString::from("/dev/stdin"));
            } else if to.is_none() {
-                to = Some(param);
+                to = Some(OsString::from("/dev/stdin"));
            } else {
-                return Err(format!(
-                    "Usage: {} <from> <to>",
-                    params.executable.to_string_lossy()
-                ));
+                return Err(format!("Usage: {} <from> <to>", exe.to_string_lossy()));
            }
            continue;
        }
@@ -91,48 +87,6 @@ pub fn parse_params<I: Iterator<Item = OsString>>(mut opts: Peekable<I>) -> Resu
            params.expand_tabs = true;
            continue;
        }
-        if param == "--normal" {
-            if format.is_some() && format != Some(Format::Normal) {
-                return Err("Conflicting output style options".to_string());
-            }
-            format = Some(Format::Normal);
-            continue;
-        }
-        if param == "-e" || param == "--ed" {
-            if format.is_some() && format != Some(Format::Ed) {
-                return Err("Conflicting output style options".to_string());
-            }
-            format = Some(Format::Ed);
-            continue;
-        }
-        if param == "-y" || param == "--side-by-side" {
-            if format.is_some() && format != Some(Format::SideBySide) {
-                return Err("Conflicting output style option".to_string());
-            }
-            format = Some(Format::SideBySide);
-            continue;
-        }
-        if width_re.is_match(param.to_string_lossy().as_ref()) {
-            let param = param.into_string().unwrap();
-            let width_str: &str = width_re
-                .captures(param.as_str())
-                .unwrap()
-                .name("long")
-                .unwrap()
-                .as_str();
-
-            params.width = match width_str.parse::<usize>() {
-                Ok(num) => {
-                    if num == 0 {
-                        return Err("invalid width «0»".to_string());
-                    }
-
-                    num
-                }
-                Err(_) => return Err(format!("invalid width «{width_str}»")),
-            };
-            continue;
-        }
        if tabsize_re.is_match(param.to_string_lossy().as_ref()) {
            // Because param matches the regular expression,
            // it is safe to assume it is valid UTF-8.
@@ -144,68 +98,70 @@ pub fn parse_params<I: Iterator<Item = OsString>>(mut opts: Peekable<I>) -> Resu
                .unwrap()
                .as_str();
            params.tabsize = match tabsize_str.parse::<usize>() {
-                Ok(num) => {
-                    if num == 0 {
-                        return Err("invalid tabsize «0»".to_string());
-                    }
-
-                    num
-                }
+                Ok(num) => num,
                Err(_) => return Err(format!("invalid tabsize «{tabsize_str}»")),
            };
-
            continue;
        }
-        match match_context_diff_params(&param, next_param, format) {
-            Ok(DiffStyleMatch {
-                is_match,
-                context_count,
-                next_param_consumed,
-            }) => {
-                if is_match {
-                    format = Some(Format::Context);
-                    if context_count.is_some() {
-                        context = context_count;
+        let p = osstr_bytes(&param);
+        if p.first() == Some(&b'-') && p.get(1) != Some(&b'-') {
+            let mut bit = p[1..].iter().copied().peekable();
+            // Can't use a for loop because `diff -30u` is supposed to make a diff
+            // with 30 lines of context.
+            while let Some(b) = bit.next() {
+                match b {
+                    b'0'..=b'9' => {
+                        params.context_count = (b - b'0') as usize;
+                        while let Some(b'0'..=b'9') = bit.peek() {
+                            params.context_count *= 10;
+                            params.context_count += (bit.next().unwrap() - b'0') as usize;
+                        }
                    }
-                    if next_param_consumed {
-                        opts.next();
+                    b'c' => {
+                        if format.is_some() && format != Some(Format::Context) {
+                            return Err("Conflicting output style options".to_string());
+                        }
+                        format = Some(Format::Context);
                    }
-                    continue;
+                    b'e' => {
+                        if format.is_some() && format != Some(Format::Ed) {
+                            return Err("Conflicting output style options".to_string());
+                        }
+                        format = Some(Format::Ed);
+                    }
+                    b'u' => {
+                        if format.is_some() && format != Some(Format::Unified) {
+                            return Err("Conflicting output style options".to_string());
+                        }
+                        format = Some(Format::Unified);
+                    }
+                    b'U' => {
+                        if format.is_some() && format != Some(Format::Unified) {
+                            return Err("Conflicting output style options".to_string());
+                        }
+                        format = Some(Format::Unified);
+                        let context_count_maybe = if bit.peek().is_some() {
+                            String::from_utf8(bit.collect::<Vec<u8>>()).ok()
+                        } else {
+                            opts.next().map(|x| x.to_string_lossy().into_owned())
+                        };
+                        if let Some(context_count_maybe) =
+                            context_count_maybe.and_then(|x| x.parse().ok())
+                        {
+                            params.context_count = context_count_maybe;
+                            break;
+                        }
+                        return Err("Invalid context count".to_string());
+                    }
+                    _ => return Err(format!("Unknown option: {}", String::from_utf8_lossy(&[b]))),
                }
            }
-            Err(error) => return Err(error),
-        }
-        match match_unified_diff_params(&param, next_param, format) {
-            Ok(DiffStyleMatch {
-                is_match,
-                context_count,
-                next_param_consumed,
-            }) => {
-                if is_match {
-                    format = Some(Format::Unified);
-                    if context_count.is_some() {
-                        context = context_count;
-                    }
-                    if next_param_consumed {
-                        opts.next();
-                    }
-                    continue;
-                }
-            }
-            Err(error) => return Err(error),
-        }
-        if param.to_string_lossy().starts_with('-') {
-            return Err(format!("unrecognized option: {param:?}"));
-        }
-        if from.is_none() {
+        } else if from.is_none() {
            from = Some(param);
        } else if to.is_none() {
            to = Some(param);
        } else {
-            return Err(format!(
-                "Usage: {} <from> <to>",
-                params.executable.to_string_lossy()
-            ));
+            return Err(format!("Usage: {} <from> <to>", exe.to_string_lossy()));
        }
    }
    params.from = if let Some(from) = from {
@@ -213,136 +169,19 @@ pub fn parse_params<I: Iterator<Item = OsString>>(mut opts: Peekable<I>) -> Resu
    } else if let Some(param) = opts.next() {
        param
    } else {
-        return Err(format!(
-            "Usage: {} <from> <to>",
-            params.executable.to_string_lossy()
-        ));
+        return Err(format!("Usage: {} <from> <to>", exe.to_string_lossy()));
    };
    params.to = if let Some(to) = to {
        to
    } else if let Some(param) = opts.next() {
        param
    } else {
-        return Err(format!(
-            "Usage: {} <from> <to>",
-            params.executable.to_string_lossy()
-        ));
+        return Err(format!("Usage: {} <from> <to>", exe.to_string_lossy()));
    };
-
-    // diff DIRECTORY FILE => diff DIRECTORY/FILE FILE
-    // diff FILE DIRECTORY => diff FILE DIRECTORY/FILE
-    let mut from_path: PathBuf = PathBuf::from(&params.from);
-    let mut to_path: PathBuf = PathBuf::from(&params.to);
-
-    if from_path.is_dir() && to_path.is_file() {
-        from_path.push(to_path.file_name().unwrap());
-        params.from = from_path.into_os_string();
-    } else if from_path.is_file() && to_path.is_dir() {
-        to_path.push(from_path.file_name().unwrap());
-        params.to = to_path.into_os_string();
-    }
-
    params.format = format.unwrap_or(Format::default());
-    if let Some(context_count) = context {
-        params.context_count = context_count;
-    }
    Ok(params)
 }

-struct DiffStyleMatch {
-    is_match: bool,
-    context_count: Option<usize>,
-    next_param_consumed: bool,
-}
-
-fn match_context_diff_params(
-    param: &OsString,
-    next_param: Option<&OsString>,
-    format: Option<Format>,
-) -> Result<DiffStyleMatch, String> {
-    const CONTEXT_RE: &str = r"^(-[cC](?<num1>\d*)|--context(=(?<num2>\d*))?|-(?<num3>\d+)c)$";
-    let regex = Regex::new(CONTEXT_RE).unwrap();
-    let is_match = regex.is_match(param.to_string_lossy().as_ref());
-    let mut context_count = None;
-    let mut next_param_consumed = false;
-    if is_match {
-        if format.is_some() && format != Some(Format::Context) {
-            return Err("Conflicting output style options".to_string());
-        }
-        let captures = regex.captures(param.to_str().unwrap()).unwrap();
-        let num = captures
-            .name("num1")
-            .or(captures.name("num2"))
-            .or(captures.name("num3"));
-        if let Some(numvalue) = num {
-            if !numvalue.as_str().is_empty() {
-                context_count = Some(numvalue.as_str().parse::<usize>().unwrap());
-            }
-        }
-        if param == "-C" {
-            if let Some(p) = next_param {
-                let size_str = p.to_string_lossy();
-                match size_str.parse::<usize>() {
-                    Ok(context_size) => {
-                        context_count = Some(context_size);
-                        next_param_consumed = true;
-                    }
-                    Err(_) => return Err(format!("invalid context length '{size_str}'")),
-                }
-            }
-        }
-    }
-    Ok(DiffStyleMatch {
-        is_match,
-        context_count,
-        next_param_consumed,
-    })
-}
-
-fn match_unified_diff_params(
-    param: &OsString,
-    next_param: Option<&OsString>,
-    format: Option<Format>,
-) -> Result<DiffStyleMatch, String> {
-    const UNIFIED_RE: &str = r"^(-[uU](?<num1>\d*)|--unified(=(?<num2>\d*))?|-(?<num3>\d+)u)$";
-    let regex = Regex::new(UNIFIED_RE).unwrap();
-    let is_match = regex.is_match(param.to_string_lossy().as_ref());
-    let mut context_count = None;
-    let mut next_param_consumed = false;
-    if is_match {
-        if format.is_some() && format != Some(Format::Unified) {
-            return Err("Conflicting output style options".to_string());
-        }
-        let captures = regex.captures(param.to_str().unwrap()).unwrap();
-        let num = captures
-            .name("num1")
-            .or(captures.name("num2"))
-            .or(captures.name("num3"));
-        if let Some(numvalue) = num {
-            if !numvalue.as_str().is_empty() {
-                context_count = Some(numvalue.as_str().parse::<usize>().unwrap());
-            }
-        }
-        if param == "-U" {
-            if let Some(p) = next_param {
-                let size_str = p.to_string_lossy();
-                match size_str.parse::<usize>() {
-                    Ok(context_size) => {
-                        context_count = Some(context_size);
-                        next_param_consumed = true;
-                    }
-                    Err(_) => return Err(format!("invalid context length '{size_str}'")),
-                }
-            }
-        }
-    }
-    Ok(DiffStyleMatch {
-        is_match,
-        context_count,
-        next_param_consumed,
-    })
-}
-
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -353,176 +192,29 @@ mod tests {
    fn basics() {
        assert_eq!(
            Ok(Params {
-                executable: os("diff"),
                from: os("foo"),
                to: os("bar"),
                ..Default::default()
            }),
-            parse_params(
-                [os("diff"), os("foo"), os("bar")]
-                    .iter()
-                    .cloned()
-                    .peekable()
-            )
-        );
-        assert_eq!(
-            Ok(Params {
-                executable: os("diff"),
-                from: os("foo"),
-                to: os("bar"),
-                ..Default::default()
-            }),
-            parse_params(
-                [os("diff"), os("--normal"), os("foo"), os("bar")]
-                    .iter()
-                    .cloned()
-                    .peekable()
-            )
+            parse_params([os("diff"), os("foo"), os("bar")].iter().cloned())
        );
    }
    #[test]
    fn basics_ed() {
-        for arg in ["-e", "--ed"] {
-            assert_eq!(
-                Ok(Params {
-                    executable: os("diff"),
-                    from: os("foo"),
-                    to: os("bar"),
-                    format: Format::Ed,
-                    ..Default::default()
-                }),
-                parse_params(
-                    [os("diff"), os(arg), os("foo"), os("bar")]
-                        .iter()
-                        .cloned()
-                        .peekable()
-                )
-            );
-        }
-    }
-    #[test]
-    fn context_valid() {
-        for args in [vec!["-c"], vec!["--context"], vec!["--context="]] {
-            let mut params = vec!["diff"];
-            params.extend(args);
-            params.extend(["foo", "bar"]);
-            assert_eq!(
-                Ok(Params {
-                    executable: os("diff"),
-                    from: os("foo"),
-                    to: os("bar"),
-                    format: Format::Context,
-                    ..Default::default()
-                }),
-                parse_params(params.iter().map(|x| os(x)).peekable())
-            );
-        }
-        for args in [
-            vec!["-c42"],
-            vec!["-C42"],
-            vec!["-C", "42"],
-            vec!["--context=42"],
-            vec!["-42c"],
-        ] {
-            let mut params = vec!["diff"];
-            params.extend(args);
-            params.extend(["foo", "bar"]);
-            assert_eq!(
-                Ok(Params {
-                    executable: os("diff"),
-                    from: os("foo"),
-                    to: os("bar"),
-                    format: Format::Context,
-                    context_count: 42,
-                    ..Default::default()
-                }),
-                parse_params(params.iter().map(|x| os(x)).peekable())
-            );
-        }
-    }
-    #[test]
-    fn context_invalid() {
-        for args in [
-            vec!["-c", "42"],
-            vec!["-c=42"],
-            vec!["-c="],
-            vec!["-C"],
-            vec!["-C=42"],
-            vec!["-C="],
-            vec!["--context42"],
-            vec!["--context", "42"],
-            vec!["-42C"],
-        ] {
-            let mut params = vec!["diff"];
-            params.extend(args);
-            params.extend(["foo", "bar"]);
-            assert!(parse_params(params.iter().map(|x| os(x)).peekable()).is_err());
-        }
-    }
-    #[test]
-    fn unified_valid() {
-        for args in [vec!["-u"], vec!["--unified"], vec!["--unified="]] {
-            let mut params = vec!["diff"];
-            params.extend(args);
-            params.extend(["foo", "bar"]);
-            assert_eq!(
-                Ok(Params {
-                    executable: os("diff"),
-                    from: os("foo"),
-                    to: os("bar"),
-                    format: Format::Unified,
-                    ..Default::default()
-                }),
-                parse_params(params.iter().map(|x| os(x)).peekable())
-            );
-        }
-        for args in [
-            vec!["-u42"],
-            vec!["-U42"],
-            vec!["-U", "42"],
-            vec!["--unified=42"],
-            vec!["-42u"],
-        ] {
-            let mut params = vec!["diff"];
-            params.extend(args);
-            params.extend(["foo", "bar"]);
-            assert_eq!(
-                Ok(Params {
-                    executable: os("diff"),
-                    from: os("foo"),
-                    to: os("bar"),
-                    format: Format::Unified,
-                    context_count: 42,
-                    ..Default::default()
-                }),
-                parse_params(params.iter().map(|x| os(x)).peekable())
-            );
-        }
-    }
-    #[test]
-    fn unified_invalid() {
-        for args in [
-            vec!["-u", "42"],
-            vec!["-u=42"],
-            vec!["-u="],
-            vec!["-U"],
-            vec!["-U=42"],
-            vec!["-U="],
-            vec!["--unified42"],
-            vec!["--unified", "42"],
-            vec!["-42U"],
-        ] {
-            let mut params = vec!["diff"];
-            params.extend(args);
-            params.extend(["foo", "bar"]);
-            assert!(parse_params(params.iter().map(|x| os(x)).peekable()).is_err());
-        }
+        assert_eq!(
+            Ok(Params {
+                from: os("foo"),
+                to: os("bar"),
+                format: Format::Ed,
+                ..Default::default()
+            }),
+            parse_params([os("diff"), os("-e"), os("foo"), os("bar")].iter().cloned())
+        );
    }
    #[test]
    fn context_count() {
        assert_eq!(
            Ok(Params {
-                executable: os("diff"),
                from: os("foo"),
                to: os("bar"),
                format: Format::Unified,
@@ -533,12 +225,10 @@ mod tests {
                [os("diff"), os("-u54"), os("foo"), os("bar")]
                    .iter()
                    .cloned()
-                    .peekable()
            )
        );
        assert_eq!(
            Ok(Params {
-                executable: os("diff"),
                from: os("foo"),
                to: os("bar"),
                format: Format::Unified,
@@ -549,12 +239,10 @@ mod tests {
                [os("diff"), os("-U54"), os("foo"), os("bar")]
                    .iter()
                    .cloned()
-                    .peekable()
            )
        );
        assert_eq!(
            Ok(Params {
-                executable: os("diff"),
                from: os("foo"),
                to: os("bar"),
                format: Format::Unified,
@@ -565,12 +253,10 @@ mod tests {
                [os("diff"), os("-U"), os("54"), os("foo"), os("bar")]
                    .iter()
                    .cloned()
-                    .peekable()
            )
        );
        assert_eq!(
            Ok(Params {
-                executable: os("diff"),
                from: os("foo"),
                to: os("bar"),
                format: Format::Context,
@@ -581,7 +267,6 @@ mod tests {
                [os("diff"), os("-c54"), os("foo"), os("bar")]
                    .iter()
                    .cloned()
-                    .peekable()
            )
        );
    }
@@ -589,36 +274,23 @@ mod tests {
    fn report_identical_files() {
        assert_eq!(
            Ok(Params {
-                executable: os("diff"),
                from: os("foo"),
                to: os("bar"),
                ..Default::default()
            }),
-            parse_params(
-                [os("diff"), os("foo"), os("bar")]
-                    .iter()
-                    .cloned()
-                    .peekable()
-            )
+            parse_params([os("diff"), os("foo"), os("bar")].iter().cloned())
        );
        assert_eq!(
            Ok(Params {
-                executable: os("diff"),
                from: os("foo"),
                to: os("bar"),
                report_identical_files: true,
                ..Default::default()
            }),
-            parse_params(
-                [os("diff"), os("-s"), os("foo"), os("bar")]
-                    .iter()
-                    .cloned()
-                    .peekable()
-            )
+            parse_params([os("diff"), os("-s"), os("foo"), os("bar")].iter().cloned())
        );
        assert_eq!(
            Ok(Params {
-                executable: os("diff"),
                from: os("foo"),
                to: os("bar"),
                report_identical_files: true,
@@ -633,7 +305,6 @@ mod tests {
                ]
                .iter()
                .cloned()
-                .peekable()
            )
        );
    }
@@ -641,36 +312,23 @@ mod tests {
    fn brief() {
        assert_eq!(
            Ok(Params {
-                executable: os("diff"),
                from: os("foo"),
                to: os("bar"),
                ..Default::default()
            }),
-            parse_params(
-                [os("diff"), os("foo"), os("bar")]
-                    .iter()
-                    .cloned()
-                    .peekable()
-            )
+            parse_params([os("diff"), os("foo"), os("bar")].iter().cloned())
        );
        assert_eq!(
            Ok(Params {
-                executable: os("diff"),
                from: os("foo"),
                to: os("bar"),
                brief: true,
                ..Default::default()
            }),
-            parse_params(
-                [os("diff"), os("-q"), os("foo"), os("bar")]
-                    .iter()
-                    .cloned()
-                    .peekable()
-            )
+            parse_params([os("diff"), os("-q"), os("foo"), os("bar")].iter().cloned())
        );
        assert_eq!(
            Ok(Params {
-                executable: os("diff"),
                from: os("foo"),
                to: os("bar"),
                brief: true,
@@ -680,7 +338,6 @@ mod tests {
                [os("diff"), os("--brief"), os("foo"), os("bar"),]
                    .iter()
                    .cloned()
-                    .peekable()
            )
        );
    }
@@ -688,22 +345,15 @@ mod tests {
    fn expand_tabs() {
        assert_eq!(
            Ok(Params {
-                executable: os("diff"),
                from: os("foo"),
                to: os("bar"),
                ..Default::default()
            }),
-            parse_params(
-                [os("diff"), os("foo"), os("bar")]
-                    .iter()
-                    .cloned()
-                    .peekable()
-            )
+            parse_params([os("diff"), os("foo"), os("bar")].iter().cloned())
        );
        for option in ["-t", "--expand-tabs"] {
            assert_eq!(
                Ok(Params {
-                    executable: os("diff"),
                    from: os("foo"),
                    to: os("bar"),
                    expand_tabs: true,
@@ -713,7 +363,6 @@ mod tests {
                    [os("diff"), os(option), os("foo"), os("bar")]
                        .iter()
                        .cloned()
-                        .peekable()
                )
            );
        }
@@ -722,36 +371,27 @@ mod tests {
    fn tabsize() {
        assert_eq!(
            Ok(Params {
-                executable: os("diff"),
                from: os("foo"),
                to: os("bar"),
                ..Default::default()
            }),
-            parse_params(
-                [os("diff"), os("foo"), os("bar")]
-                    .iter()
-                    .cloned()
-                    .peekable()
-            )
+            parse_params([os("diff"), os("foo"), os("bar")].iter().cloned())
        );
        assert_eq!(
            Ok(Params {
-                executable: os("diff"),
                from: os("foo"),
                to: os("bar"),
-                tabsize: 1,
+                tabsize: 0,
                ..Default::default()
            }),
            parse_params(
-                [os("diff"), os("--tabsize=1"), os("foo"), os("bar")]
+                [os("diff"), os("--tabsize=0"), os("foo"), os("bar")]
                    .iter()
                    .cloned()
-                    .peekable()
            )
        );
        assert_eq!(
            Ok(Params {
-                executable: os("diff"),
                from: os("foo"),
                to: os("bar"),
                tabsize: 42,
@@ -761,42 +401,36 @@ mod tests {
                [os("diff"), os("--tabsize=42"), os("foo"), os("bar")]
                    .iter()
                    .cloned()
-                    .peekable()
            )
        );
        assert!(parse_params(
            [os("diff"), os("--tabsize"), os("foo"), os("bar")]
                .iter()
                .cloned()
-                .peekable()
        )
        .is_err());
        assert!(parse_params(
            [os("diff"), os("--tabsize="), os("foo"), os("bar")]
                .iter()
                .cloned()
-                .peekable()
        )
        .is_err());
        assert!(parse_params(
            [os("diff"), os("--tabsize=r2"), os("foo"), os("bar")]
                .iter()
                .cloned()
-                .peekable()
        )
        .is_err());
        assert!(parse_params(
            [os("diff"), os("--tabsize=-1"), os("foo"), os("bar")]
                .iter()
                .cloned()
-                .peekable()
        )
        .is_err());
        assert!(parse_params(
            [os("diff"), os("--tabsize=r2"), os("foo"), os("bar")]
                .iter()
                .cloned()
-                .peekable()
        )
        .is_err());
        assert!(parse_params(
@@ -808,7 +442,6 @@ mod tests {
            ]
            .iter()
            .cloned()
-            .peekable()
        )
        .is_err());
    }
@@ -816,104 +449,57 @@ mod tests {
    fn double_dash() {
        assert_eq!(
            Ok(Params {
-                executable: os("diff"),
                from: os("-g"),
                to: os("-h"),
                ..Default::default()
            }),
-            parse_params(
-                [os("diff"), os("--"), os("-g"), os("-h")]
-                    .iter()
-                    .cloned()
-                    .peekable()
-            )
+            parse_params([os("diff"), os("--"), os("-g"), os("-h")].iter().cloned())
        );
    }
    #[test]
    fn default_to_stdin() {
        assert_eq!(
            Ok(Params {
-                executable: os("diff"),
                from: os("foo"),
-                to: os("-"),
+                to: os("/dev/stdin"),
                ..Default::default()
            }),
-            parse_params([os("diff"), os("foo"), os("-")].iter().cloned().peekable())
+            parse_params([os("diff"), os("foo"), os("-")].iter().cloned())
        );
        assert_eq!(
            Ok(Params {
-                executable: os("diff"),
-                from: os("-"),
+                from: os("/dev/stdin"),
                to: os("bar"),
                ..Default::default()
            }),
-            parse_params([os("diff"), os("-"), os("bar")].iter().cloned().peekable())
+            parse_params([os("diff"), os("-"), os("bar")].iter().cloned())
        );
        assert_eq!(
            Ok(Params {
-                executable: os("diff"),
-                from: os("-"),
-                to: os("-"),
+                from: os("/dev/stdin"),
+                to: os("/dev/stdin"),
                ..Default::default()
            }),
-            parse_params([os("diff"), os("-"), os("-")].iter().cloned().peekable())
+            parse_params([os("diff"), os("-"), os("-")].iter().cloned())
        );
-        assert!(parse_params(
-            [os("diff"), os("foo"), os("bar"), os("-")]
-                .iter()
-                .cloned()
-                .peekable()
-        )
-        .is_err());
-        assert!(parse_params(
-            [os("diff"), os("-"), os("-"), os("-")]
-                .iter()
-                .cloned()
-                .peekable()
-        )
-        .is_err());
+        assert!(parse_params([os("diff"), os("foo"), os("bar"), os("-")].iter().cloned()).is_err());
+        assert!(parse_params([os("diff"), os("-"), os("-"), os("-")].iter().cloned()).is_err());
    }
    #[test]
    fn missing_arguments() {
-        assert!(parse_params([os("diff")].iter().cloned().peekable()).is_err());
-        assert!(parse_params([os("diff"), os("foo")].iter().cloned().peekable()).is_err());
+        assert!(parse_params([os("diff")].iter().cloned()).is_err());
+        assert!(parse_params([os("diff"), os("foo")].iter().cloned()).is_err());
    }
    #[test]
    fn unknown_argument() {
-        assert!(parse_params(
-            [os("diff"), os("-g"), os("foo"), os("bar")]
-                .iter()
-                .cloned()
-                .peekable()
-        )
-        .is_err());
        assert!(
-            parse_params([os("diff"), os("-g"), os("bar")].iter().cloned().peekable()).is_err()
+            parse_params([os("diff"), os("-g"), os("foo"), os("bar")].iter().cloned()).is_err()
        );
-        assert!(parse_params([os("diff"), os("-g")].iter().cloned().peekable()).is_err());
+        assert!(parse_params([os("diff"), os("-g"), os("bar")].iter().cloned()).is_err());
+        assert!(parse_params([os("diff"), os("-g")].iter().cloned()).is_err());
    }
    #[test]
    fn empty() {
-        assert!(parse_params([].iter().cloned().peekable()).is_err());
-    }
-    #[test]
-    fn conflicting_output_styles() {
-        for (arg1, arg2) in [
-            ("-u", "-c"),
-            ("-u", "-e"),
-            ("-c", "-u"),
-            ("-c", "-U42"),
-            ("-u", "--normal"),
-            ("--normal", "-e"),
-            ("--context", "--normal"),
-        ] {
-            assert!(parse_params(
-                [os("diff"), os(arg1), os(arg2), os("foo"), os("bar")]
-                    .iter()
-                    .cloned()
-                    .peekable()
-            )
-            .is_err());
-        }
+        assert!(parse_params([].iter().cloned()).is_err());
    }
 }
@@ -8,7 +8,6 @@ use std::io::Write;

 use crate::params::Params;
 use crate::utils::do_write_line;
-use crate::utils::get_modification_time;

 #[derive(Debug, PartialEq)]
 pub enum DiffLine {
@@ -239,14 +238,10 @@ fn make_diff(

 #[must_use]
 pub fn diff(expected: &[u8], actual: &[u8], params: &Params) -> Vec<u8> {
-    let from_modified_time = get_modification_time(&params.from.to_string_lossy());
-    let to_modified_time = get_modification_time(&params.to.to_string_lossy());
    let mut output = format!(
-        "--- {0}\t{1}\n+++ {2}\t{3}\n",
+        "--- {0}\t\n+++ {1}\t\n",
        params.from.to_string_lossy(),
-        from_modified_time,
-        params.to.to_string_lossy(),
-        to_modified_time
+        params.to.to_string_lossy()
    )
    .into_bytes();
    let diff_results = make_diff(expected, actual, params.context_count, params.brief);
@@ -466,13 +461,13 @@ mod tests {
                                        ..Default::default()
                                    },
                                );
-                                File::create(format!("{target}/ab.diff"))
+                                File::create(&format!("{target}/ab.diff"))
                                    .unwrap()
                                    .write_all(&diff)
                                    .unwrap();
-                                let mut fa = File::create(format!("{target}/alef")).unwrap();
+                                let mut fa = File::create(&format!("{target}/alef")).unwrap();
                                fa.write_all(&alef[..]).unwrap();
-                                let mut fb = File::create(format!("{target}/bet")).unwrap();
+                                let mut fb = File::create(&format!("{target}/bet")).unwrap();
                                fb.write_all(&bet[..]).unwrap();
                                let _ = fa;
                                let _ = fb;
@@ -494,13 +489,13 @@ mod tests {

                                let output = Command::new("patch")
                                    .arg("-p0")
-                                    .stdin(File::open(format!("{target}/ab.diff")).unwrap())
+                                    .stdin(File::open(&format!("{target}/ab.diff")).unwrap())
                                    .output()
                                    .unwrap();
                                println!("{}", String::from_utf8_lossy(&output.stdout));
                                println!("{}", String::from_utf8_lossy(&output.stderr));
                                assert!(output.status.success(), "{output:?}");
-                                let alef = fs::read(format!("{target}/alef")).unwrap();
+                                let alef = fs::read(&format!("{target}/alef")).unwrap();
                                assert_eq!(alef, bet);
                            }
                        }
@@ -582,25 +577,25 @@ mod tests {
                                            ..Default::default()
                                        },
                                    );
-                                    File::create(format!("{target}/abn.diff"))
+                                    File::create(&format!("{target}/abn.diff"))
                                        .unwrap()
                                        .write_all(&diff)
                                        .unwrap();
-                                    let mut fa = File::create(format!("{target}/alefn")).unwrap();
+                                    let mut fa = File::create(&format!("{target}/alefn")).unwrap();
                                    fa.write_all(&alef[..]).unwrap();
-                                    let mut fb = File::create(format!("{target}/betn")).unwrap();
+                                    let mut fb = File::create(&format!("{target}/betn")).unwrap();
                                    fb.write_all(&bet[..]).unwrap();
                                    let _ = fa;
                                    let _ = fb;
                                    let output = Command::new("patch")
                                        .arg("-p0")
-                                        .stdin(File::open(format!("{target}/abn.diff")).unwrap())
+                                        .stdin(File::open(&format!("{target}/abn.diff")).unwrap())
                                        .output()
                                        .unwrap();
                                    assert!(output.status.success(), "{output:?}");
                                    //println!("{}", String::from_utf8_lossy(&output.stdout));
                                    //println!("{}", String::from_utf8_lossy(&output.stderr));
-                                    let alef = fs::read(format!("{target}/alefn")).unwrap();
+                                    let alef = fs::read(&format!("{target}/alefn")).unwrap();
                                    assert_eq!(alef, bet);
                                }
                            }
@@ -678,25 +673,25 @@ mod tests {
                                            ..Default::default()
                                        },
                                    );
-                                    File::create(format!("{target}/ab_.diff"))
+                                    File::create(&format!("{target}/ab_.diff"))
                                        .unwrap()
                                        .write_all(&diff)
                                        .unwrap();
-                                    let mut fa = File::create(format!("{target}/alef_")).unwrap();
+                                    let mut fa = File::create(&format!("{target}/alef_")).unwrap();
                                    fa.write_all(&alef[..]).unwrap();
-                                    let mut fb = File::create(format!("{target}/bet_")).unwrap();
+                                    let mut fb = File::create(&format!("{target}/bet_")).unwrap();
                                    fb.write_all(&bet[..]).unwrap();
                                    let _ = fa;
                                    let _ = fb;
                                    let output = Command::new("patch")
                                        .arg("-p0")
-                                        .stdin(File::open(format!("{target}/ab_.diff")).unwrap())
+                                        .stdin(File::open(&format!("{target}/ab_.diff")).unwrap())
                                        .output()
                                        .unwrap();
                                    assert!(output.status.success(), "{output:?}");
                                    //println!("{}", String::from_utf8_lossy(&output.stdout));
                                    //println!("{}", String::from_utf8_lossy(&output.stderr));
-                                    let alef = fs::read(format!("{target}/alef_")).unwrap();
+                                    let alef = fs::read(&format!("{target}/alef_")).unwrap();
                                    assert_eq!(alef, bet);
                                }
                            }
@@ -759,25 +754,25 @@ mod tests {
                                        ..Default::default()
                                    },
                                );
-                                File::create(format!("{target}/abx.diff"))
+                                File::create(&format!("{target}/abx.diff"))
                                    .unwrap()
                                    .write_all(&diff)
                                    .unwrap();
-                                let mut fa = File::create(format!("{target}/alefx")).unwrap();
+                                let mut fa = File::create(&format!("{target}/alefx")).unwrap();
                                fa.write_all(&alef[..]).unwrap();
-                                let mut fb = File::create(format!("{target}/betx")).unwrap();
+                                let mut fb = File::create(&format!("{target}/betx")).unwrap();
                                fb.write_all(&bet[..]).unwrap();
                                let _ = fa;
                                let _ = fb;
                                let output = Command::new("patch")
                                    .arg("-p0")
-                                    .stdin(File::open(format!("{target}/abx.diff")).unwrap())
+                                    .stdin(File::open(&format!("{target}/abx.diff")).unwrap())
                                    .output()
                                    .unwrap();
                                assert!(output.status.success(), "{output:?}");
                                //println!("{}", String::from_utf8_lossy(&output.stdout));
                                //println!("{}", String::from_utf8_lossy(&output.stderr));
-                                let alef = fs::read(format!("{target}/alefx")).unwrap();
+                                let alef = fs::read(&format!("{target}/alefx")).unwrap();
                                assert_eq!(alef, bet);
                            }
                        }
@@ -845,25 +840,25 @@ mod tests {
                                        ..Default::default()
                                    },
                                );
-                                File::create(format!("{target}/abr.diff"))
+                                File::create(&format!("{target}/abr.diff"))
                                    .unwrap()
                                    .write_all(&diff)
                                    .unwrap();
-                                let mut fa = File::create(format!("{target}/alefr")).unwrap();
+                                let mut fa = File::create(&format!("{target}/alefr")).unwrap();
                                fa.write_all(&alef[..]).unwrap();
-                                let mut fb = File::create(format!("{target}/betr")).unwrap();
+                                let mut fb = File::create(&format!("{target}/betr")).unwrap();
                                fb.write_all(&bet[..]).unwrap();
                                let _ = fa;
                                let _ = fb;
                                let output = Command::new("patch")
                                    .arg("-p0")
-                                    .stdin(File::open(format!("{target}/abr.diff")).unwrap())
+                                    .stdin(File::open(&format!("{target}/abr.diff")).unwrap())
                                    .output()
                                    .unwrap();
                                assert!(output.status.success(), "{output:?}");
                                //println!("{}", String::from_utf8_lossy(&output.stdout));
                                //println!("{}", String::from_utf8_lossy(&output.stderr));
-                                let alef = fs::read(format!("{target}/alefr")).unwrap();
+                                let alef = fs::read(&format!("{target}/alefr")).unwrap();
                                assert_eq!(alef, bet);
                            }
                        }
@@ -875,8 +870,6 @@ mod tests {

    #[test]
    fn test_stop_early() {
-        use crate::assert_diff_eq;
-
        let from_filename = "foo";
        let from = ["a", "b", "c", ""].join("\n");
        let to_filename = "bar";
@@ -891,10 +884,9 @@ mod tests {
                ..Default::default()
            },
        );
-
        let expected_full = [
-            "--- foo\tTIMESTAMP",
-            "+++ bar\tTIMESTAMP",
+            "--- foo\t",
+            "+++ bar\t",
            "@@ -1,3 +1,3 @@",
            " a",
            "-b",
@@ -903,7 +895,7 @@ mod tests {
            "",
        ]
        .join("\n");
-        assert_diff_eq!(diff_full, expected_full);
+        assert_eq!(diff_full, expected_full.as_bytes());

        let diff_brief = diff(
            from.as_bytes(),
@@ -915,9 +907,8 @@ mod tests {
                ..Default::default()
            },
        );
-
-        let expected_brief = ["--- foo\tTIMESTAMP", "+++ bar\tTIMESTAMP", ""].join("\n");
-        assert_diff_eq!(diff_brief, expected_brief);
+        let expected_brief = ["--- foo\t", "+++ bar\t", ""].join("\n");
+        assert_eq!(diff_brief, expected_brief.as_bytes());

        let nodiff_full = diff(
            from.as_bytes(),
@@ -3,8 +3,8 @@
 // For the full copyright and license information, please view the LICENSE-*
 // files that was distributed with this source code.

-use regex::Regex;
-use std::{ffi::OsString, io::Write};
+use std::io::Write;
+
 use unicode_width::UnicodeWidthStr;

 /// Replace tabs by spaces in the input line.
@@ -52,52 +52,6 @@ pub fn do_write_line(
    }
 }

-/// Retrieves the modification time of the input file specified by file path
-/// If an error occurs, it returns the current system time
-pub fn get_modification_time(file_path: &str) -> String {
-    use chrono::{DateTime, Local};
-    use std::fs;
-    use std::time::SystemTime;
-
-    let modification_time: SystemTime = fs::metadata(file_path)
-        .and_then(|m| m.modified())
-        .unwrap_or(SystemTime::now());
-
-    let modification_time: DateTime<Local> = modification_time.into();
-    let modification_time: String = modification_time
-        .format("%Y-%m-%d %H:%M:%S%.9f %z")
-        .to_string();
-
-    modification_time
-}
-
-pub fn format_failure_to_read_input_file(
-    executable: &OsString,
-    filepath: &OsString,
-    error: &std::io::Error,
-) -> String {
-    // std::io::Error's display trait outputs "{detail} (os error {code})"
-    // but we want only the {detail} (error string) part
-    let error_code_re = Regex::new(r"\ \(os\ error\ \d+\)$").unwrap();
-    format!(
-        "{}: {}: {}",
-        executable.to_string_lossy(),
-        filepath.to_string_lossy(),
-        error_code_re.replace(error.to_string().as_str(), ""),
-    )
-}
-
-pub fn report_failure_to_read_input_file(
-    executable: &OsString,
-    filepath: &OsString,
-    error: &std::io::Error,
-) {
-    eprintln!(
-        "{}",
-        format_failure_to_read_input_file(executable, filepath, error)
-    );
-}
-
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -128,11 +82,10 @@ mod tests {

            // Note: The Woman Scientist emoji (👩‍🔬) is a ZWJ sequence combining
            // the Woman emoji (👩) and the Microscope emoji (🔬). On supported platforms
-            // it is displayed as a single emoji and has a print size of 2 columns.
-            // Terminal emulators tend to not support this, and display the two emojis
-            // side by side, thus accounting for a print size of 4 columns, but the
-            // unicode_width crate reports a correct size of 2.
-            assert_tab_expansion("foo\t👩‍🔬\tbaz", 6, "foo   👩‍🔬    baz");
+            // it is displayed as a single emoji and should have a print size of 2 columns,
+            // but terminal emulators tend to not support this, and display the two emojis
+            // side by side, thus accounting for a print size of 4 columns.
+            assert_tab_expansion("foo\t👩‍🔬\tbaz", 6, "foo   👩‍🔬  baz");
        }

        #[test]
@@ -162,46 +115,4 @@ mod tests {
            assert_line_written("foo bar\tbaz", true, 8, "foo bar baz");
        }
    }
-
-    mod modification_time {
-        use super::*;
-
-        #[test]
-        fn set_time() {
-            use chrono::{DateTime, Local};
-            use std::time::SystemTime;
-            use tempfile::NamedTempFile;
-
-            let temp = NamedTempFile::new().unwrap();
-            // set file modification time equal to current time
-            let current = SystemTime::now();
-            let _ = temp.as_file().set_modified(current);
-
-            // format current time
-            let current: DateTime<Local> = current.into();
-            let current: String = current.format("%Y-%m-%d %H:%M:%S%.9f %z").to_string();
-
-            // verify
-            assert_eq!(
-                current,
-                get_modification_time(&temp.path().to_string_lossy())
-            );
-        }
-
-        #[test]
-        fn invalid_file() {
-            use chrono::{DateTime, Local};
-            use std::time::SystemTime;
-
-            let invalid_file = "target/utils/invalid-file";
-
-            // store current time before calling `get_modification_time`
-            // Because the file is invalid, it will return SystemTime::now()
-            // which will be greater than previously saved time
-            let current_time: DateTime<Local> = SystemTime::now().into();
-            let m_time: DateTime<Local> = get_modification_time(invalid_file).parse().unwrap();
-
-            assert!(m_time > current_time);
-        }
-    }
 }
@@ -19,9 +19,9 @@
 # By default it expects a release build of the diffutils binary, but a
 # different build profile can be specified as an argument
 # (e.g. 'dev' or 'test').
-# Unless overridden by the $TESTS environment variable, all tests in the test
+# Unless overriden by the $TESTS environment variable, all tests in the test
 # suite will be run. Tests targeting a command that is not yet implemented
-# (e.g. diff3 or sdiff) are skipped.
+# (e.g. cmp, diff3 or sdiff) are skipped.

 scriptpath=$(dirname "$(readlink -f "$0")")
 rev=$(git rev-parse HEAD)
@@ -57,13 +57,8 @@ upstreamrev=$(git rev-parse HEAD)
 mkdir src
 cd src
 ln -s "$binary" diff
-ln -s "$binary" cmp
 cd ../tests

-# Fetch tests/init.sh from the gnulib repository (needed since
-# https://git.savannah.gnu.org/cgit/diffutils.git/commit/tests?id=1d2456f539)
-curl -s "$gitserver/gitweb/?p=gnulib.git;a=blob_plain;f=tests/init.sh;hb=HEAD" -o init.sh
-
 if [[ -n "$TESTS" ]]
 then
  tests="$TESTS"
@@ -76,6 +71,7 @@ total=$(echo "$tests" | wc -w)
 echo "Running $total tests"
 export LC_ALL=C
 export KEEP=yes
+exitcode=0
 timestamp=$(date -Iseconds)
 urlroot="$gitserver/cgit/diffutils.git/tree/tests/"
 passed=0
@@ -86,43 +82,35 @@ for test in $tests
 do
  result="FAIL"
  url="$urlroot$test?id=$upstreamrev"
-  # Run only the tests that invoke `diff` or `cmp`,
+  # Run only the tests that invoke `diff`,
  # because other binaries aren't implemented yet
-  if ! grep -E -s -q "(diff3|sdiff)" "$test"
+  if ! grep -E -s -q "(cmp|diff3|sdiff)" "$test"
  then
-    sh "$test" 1> stdout.txt 2> stderr.txt && result="PASS"
-    if [[ $? = 77 ]]
-    then
-      result="SKIP"
-    else
-      json+="{\"test\":\"$test\",\"result\":\"$result\","
-      json+="\"url\":\"$url\","
-      json+="\"stdout\":\"$(base64 -w0 < stdout.txt)\","
-      json+="\"stderr\":\"$(base64 -w0 < stderr.txt)\","
-      json+="\"files\":{"
-      cd gt-$test.*
-      # Note: this doesn't include the contents of subdirectories,
-      # but there isn't much value added in doing so
-      for file in *
-      do
-        [[ -f "$file" ]] && json+="\"$file\":\"$(base64 -w0 < "$file")\","
-      done
-      json="${json%,}}},"
-      cd - > /dev/null
-      [[ "$result" = "PASS" ]] && (( passed++ ))
-      [[ "$result" = "FAIL" ]] && (( failed++ ))
-    fi
+    sh "$test" 1> stdout.txt 2> stderr.txt && result="PASS" || exitcode=1
+    json+="{\"test\":\"$test\",\"result\":\"$result\","
+    json+="\"url\":\"$url\","
+    json+="\"stdout\":\"$(base64 -w0 < stdout.txt)\","
+    json+="\"stderr\":\"$(base64 -w0 < stderr.txt)\","
+    json+="\"files\":{"
+    cd gt-$test.*
+    # Note: this doesn't include the contents of subdirectories,
+    # but there isn't much value added in doing so
+    for file in *
+    do
+      [[ -f "$file" ]] && json+="\"$file\":\"$(base64 -w0 < "$file")\","
+    done
+    json="${json%,}}},"
+    cd - > /dev/null
+    [[ "$result" = "PASS" ]] && (( passed++ ))
+    [[ "$result" = "FAIL" ]] && (( failed++ ))
  else
    result="SKIP"
+    (( skipped++ ))
+    json+="{\"test\":\"$test\",\"url\":\"$url\",\"result\":\"$result\"},"
  fi
  color=2 # green
  [[ "$result" = "FAIL" ]] && color=1 # red
-  if [[ $result = "SKIP" ]]
-  then
-    (( skipped++ ))
-    json+="{\"test\":\"$test\",\"url\":\"$url\",\"result\":\"$result\"},"
-    color=3 # yellow
-  fi
+  [[ "$result" = "SKIP" ]] && color=3 # yellow
  printf "  %-40s $(tput setaf $color)$result$(tput sgr0)\n" "$test"
 done
 echo ""
@@ -150,5 +138,4 @@ resultsfile="test-results.json"
 echo "$json" | jq > "$resultsfile"
 echo "Results written to $scriptpath/$resultsfile"

-(( failed > 0 )) && exit 1
-exit 0
+exit $exitcode