chore(deps): update github artifact actions

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

.github/workflows/GnuComment.yml

@@ -0,0 +1,100 @@
+name: GnuComment
+
+on:
+  workflow_run:
+    workflows: ["GnuTests"]
+    types:
+      - completed
+
+permissions: {}
+
+jobs:
+  post-comment:
+    permissions:
+      actions: read  #  to list workflow runs artifacts
+      pull-requests: write  #  to comment on pr
+
+    runs-on: ubuntu-latest
+    if: >
+      github.event.workflow_run.event == 'pull_request'
+    steps:
+      - name: 'Download artifact'
+        uses: actions/github-script@v9
+        with:
+          script: |
+            // List all artifacts from GnuTests
+            var artifacts = await github.rest.actions.listWorkflowRunArtifacts({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              run_id: ${{ github.event.workflow_run.id }},
+            });
+
+            // Download the "comment" artifact, which contains a PR number (NR) and result.txt
+            var matchArtifact = artifacts.data.artifacts.filter((artifact) => {
+              return artifact.name == "comment"
+            })[0];
+
+            if (!matchArtifact) {
+              console.log('No comment artifact found');
+              return;
+            }
+
+            var download = await github.rest.actions.downloadArtifact({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              artifact_id: matchArtifact.id,
+              archive_format: 'zip',
+            });
+            var fs = require('fs');
+            fs.writeFileSync('${{ github.workspace }}/comment.zip', Buffer.from(download.data));
+
+      - run: unzip comment.zip || echo "Failed to unzip comment artifact"
+
+      - name: 'Comment on PR'
+        uses: actions/github-script@v9
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            var fs = require('fs');
+
+            // Check if files exist
+            if (!fs.existsSync('./NR')) {
+              console.log('No NR file found, skipping comment');
+              return;
+            }
+            if (!fs.existsSync('./result.txt')) {
+              console.log('No result.txt file found, skipping comment');
+              return;
+            }
+
+            var issue_number = Number(fs.readFileSync('./NR'));
+            var content = fs.readFileSync('./result.txt');
+
+            if (content.toString().trim().length > 7) { // 7 because we have backquote + \n
+              // Update existing comment if present, otherwise create a new one
+              var marker = '<!-- gnu-tests-bot -->';
+              var body = marker + '\nGNU diffutils testsuite comparison:\n```\n' + content + '```';
+              var comments = await github.rest.issues.listComments({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issue_number,
+              });
+              var existing = comments.data.filter(c => c.body.includes(marker))[0];
+              if (existing) {
+                await github.rest.issues.updateComment({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  comment_id: existing.id,
+                  body: body,
+                });
+              } else {
+                await github.rest.issues.createComment({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: issue_number,
+                  body: body,
+                });
+              }
+            } else {
+              console.log('Comment content too short, skipping');
+            }

.github/workflows/GnuTests.yml

@@ -0,0 +1,231 @@
+name: GnuTests
+
+# Run GNU diffutils testsuite against the Rust diffutils implementation
+# and compare results against the main branch to catch regressions
+
+on:
+  pull_request:
+  push:
+    branches:
+      - '*'
+
+permissions:
+  contents: write # Publish diffutils instead of discarding
+
+# End the current execution if there is a new changeset in the PR
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+env:
+  DEFAULT_BRANCH: ${{ github.event.repository.default_branch }}
+  TEST_FULL_SUMMARY_FILE: 'diffutils-gnu-full-result.json'
+
+jobs:
+  native:
+    name: Run GNU diffutils testsuite
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: stable
+
+      - uses: Swatinem/rust-cache@v2
+
+      ### Build
+      - name: Build Rust diffutils binary
+        shell: bash
+        run: |
+          ## Build Rust diffutils binary
+          cargo build --config=profile.release.strip=true --profile=release
+          zstd -19 target/release/diffutils -o diffutils-x86_64-unknown-linux-gnu.zst
+
+      - name: Publish latest commit
+        uses: softprops/action-gh-release@v3
+        if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+        with:
+          tag_name: latest-commit
+          body: |
+            commit: ${{ github.sha }}
+          draft: false
+          prerelease: true
+          files: |
+            diffutils-x86_64-unknown-linux-gnu.zst
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      ### Run tests
+      - name: Run GNU diffutils testsuite
+        shell: bash
+        run: |
+          ## Run GNU diffutils testsuite
+          ./tests/run-upstream-testsuite.sh release || true
+        env:
+          TERM: xterm
+
+      - name: Upload full json results
+        uses: actions/upload-artifact@v7
+        with:
+          name: diffutils-gnu-full-result
+          path: tests/test-results.json
+          if-no-files-found: warn
+
+  aggregate:
+    needs: [native]
+    permissions:
+      actions: read
+      contents: read
+      pull-requests: read
+    name: Aggregate GNU test results
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Initialize workflow variables
+        id: vars
+        shell: bash
+        run: |
+          ## VARs setup
+          outputs() { step_id="${{ github.action }}"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
+
+          TEST_SUMMARY_FILE='diffutils-gnu-result.json'
+          outputs TEST_SUMMARY_FILE
+
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Retrieve reference artifacts
+        uses: dawidd6/action-download-artifact@v21
+        continue-on-error: true
+        with:
+          workflow: GnuTests.yml
+          branch: "${{ env.DEFAULT_BRANCH }}"
+          workflow_conclusion: completed
+          path: "reference"
+          if_no_artifact_found: warn
+
+      - name: Download full json results
+        uses: actions/download-artifact@v8
+        with:
+          name: diffutils-gnu-full-result
+          path: results
+
+      - name: Extract/summarize testing info
+        id: summary
+        shell: bash
+        run: |
+          ## Extract/summarize testing info
+          outputs() { step_id="${{ github.action }}"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
+
+          RESULT_FILE="results/test-results.json"
+          if [[ ! -f "$RESULT_FILE" ]]; then
+            echo "::error ::Missing test results at $RESULT_FILE"
+            exit 1
+          fi
+
+          TOTAL=$(jq '[.tests[]] | length' "$RESULT_FILE")
+          PASS=$(jq '[.tests[] | select(.result=="PASS")] | length' "$RESULT_FILE")
+          FAIL=$(jq '[.tests[] | select(.result=="FAIL")] | length' "$RESULT_FILE")
+          SKIP=$(jq '[.tests[] | select(.result=="SKIP")] | length' "$RESULT_FILE")
+          ERROR=0
+
+          output="GNU diffutils tests summary = TOTAL: $TOTAL / PASS: $PASS / FAIL: $FAIL / SKIP: $SKIP"
+          echo "${output}"
+
+          if [[ "$FAIL" -gt 0 ]]; then
+            echo "::warning ::${output}"
+          fi
+
+          jq -n \
+            --arg date "$(date --rfc-email)" \
+            --arg sha "$GITHUB_SHA" \
+            --arg total "$TOTAL" \
+            --arg pass "$PASS" \
+            --arg skip "$SKIP" \
+            --arg fail "$FAIL" \
+            --arg error "$ERROR" \
+            '{($date): { sha: $sha, total: $total, pass: $pass, skip: $skip, fail: $fail, error: $error }}' > '${{ steps.vars.outputs.TEST_SUMMARY_FILE }}'
+
+          HASH=$(sha1sum '${{ steps.vars.outputs.TEST_SUMMARY_FILE }}' | cut --delim=" " -f 1)
+          outputs HASH TOTAL PASS FAIL SKIP
+
+      - name: Upload SHA1/ID of 'test-summary'
+        uses: actions/upload-artifact@v7
+        with:
+          name: "${{ steps.summary.outputs.HASH }}"
+          path: "${{ steps.vars.outputs.TEST_SUMMARY_FILE }}"
+
+      - name: Upload test results summary
+        uses: actions/upload-artifact@v7
+        with:
+          name: test-summary
+          path: "${{ steps.vars.outputs.TEST_SUMMARY_FILE }}"
+
+      - name: Compare test failures VS reference
+        shell: bash
+        run: |
+          ## Compare test failures VS reference
+          REF_SUMMARY_FILE='reference/diffutils-gnu-full-result/test-results.json'
+          CURRENT_SUMMARY_FILE="results/test-results.json"
+
+          IGNORE_INTERMITTENT=".github/workflows/ignore-intermittent.txt"
+
+          COMMENT_DIR="reference/comment"
+          mkdir -p ${COMMENT_DIR}
+          echo ${{ github.event.number }} > ${COMMENT_DIR}/NR
+          COMMENT_LOG="${COMMENT_DIR}/result.txt"
+
+          COMPARISON_RESULT=0
+          if test -f "${CURRENT_SUMMARY_FILE}"; then
+            if test -f "${REF_SUMMARY_FILE}"; then
+              echo "Reference summary SHA1/ID: $(sha1sum -- "${REF_SUMMARY_FILE}")"
+              echo "Current summary SHA1/ID: $(sha1sum -- "${CURRENT_SUMMARY_FILE}")"
+
+              python3 util/compare_test_results.py \
+                --ignore-file "${IGNORE_INTERMITTENT}" \
+                --output "${COMMENT_LOG}" \
+                "${CURRENT_SUMMARY_FILE}" "${REF_SUMMARY_FILE}"
+
+              COMPARISON_RESULT=$?
+            else
+              echo "::warning ::Skipping test comparison; no prior reference summary is available at '${REF_SUMMARY_FILE}'."
+            fi
+          else
+            echo "::error ::Failed to find summary of test results (missing '${CURRENT_SUMMARY_FILE}'); failing early"
+            exit 1
+          fi
+
+          if [ ${COMPARISON_RESULT} -eq 1 ]; then
+            echo "::error ::Found new non-intermittent test failures"
+            exit 1
+          else
+            echo "::notice ::No new test failures detected"
+          fi
+
+      - name: Upload comparison log (for GnuComment workflow)
+        if: success() || failure()
+        uses: actions/upload-artifact@v7
+        with:
+          name: comment
+          path: reference/comment/
+
+      - name: Report test results
+        if: success() || failure()
+        shell: bash
+        run: |
+          ## Report final results
+          echo "::notice ::GNU diffutils testsuite results:"
+          echo "::notice ::  Total tests: ${{ steps.summary.outputs.TOTAL }}"
+          echo "::notice ::  Passed: ${{ steps.summary.outputs.PASS }}"
+          echo "::notice ::  Failed: ${{ steps.summary.outputs.FAIL }}"
+          echo "::notice ::  Skipped: ${{ steps.summary.outputs.SKIP }}"
+
+          if [[ "${{ steps.summary.outputs.FAIL }}" -gt 0 ]]; then
+            PASS_RATE=$(( ${{ steps.summary.outputs.PASS }} * 100 / (${{ steps.summary.outputs.PASS }} + ${{ steps.summary.outputs.FAIL }}) ))
+            echo "::notice ::  Pass rate: ${PASS_RATE}%"
+          fi

.github/workflows/audit.yml

@@ -0,0 +1,15 @@
+name: Security audit
+
+on:
+  schedule:
+    - cron: "0 0 * * *"
+jobs:
+  audit:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - uses: rustsec/audit-check@v2
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/ci.yml

@@ -4,6 +4,7 @@ name: Basic CI
 
 env:
   CARGO_TERM_COLOR: always
+  CARGO_INCREMENTAL: 0
 
 jobs:
   check:
@@ -15,7 +16,6 @@ jobs:
         os: [ubuntu-latest, macOS-latest, windows-latest]
     steps:
       - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
       - run: cargo check
 
   test:
@@ -27,7 +27,14 @@ jobs:
         os: [ubuntu-latest, macOS-latest, windows-latest]
     steps:
       - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
+      - name: install GNU patch on MacOS
+        if: runner.os == 'macOS'
+        run: |
+          brew install gpatch
+      - 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
       - run: cargo test
 
   fmt:
@@ -35,8 +42,6 @@ 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:
@@ -48,111 +53,12 @@ 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:
-    name: GNU test suite
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - 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:
-          TERM: xterm
-      - uses: actions/upload-artifact@v4
-        with:
-          name: test-results.json
-          path: tests/test-results.json
-      - run: ./tests/print-test-results.sh tests/test-results.json
-
-  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:
-          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:
-          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
+    env:
+      RUSTC_BOOTSTRAP: 1
     runs-on: ${{ matrix.job.os }}
     strategy:
       fail-fast: false
@@ -169,29 +75,26 @@ jobs:
       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: rust toolchain ~ install
-      uses: dtolnay/rust-toolchain@nightly
+    - name: install GNU patch on MacOS
+      if: runner.os == 'macOS'
+      run: |
+        brew install gpatch
+    - 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: Test
-      run: cargo test ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} --no-fail-fast
+      run: cargo test --all-features --no-fail-fast
       env:
-        CARGO_INCREMENTAL: "0"
         RUSTC_WRAPPER: ""
-        RUSTFLAGS: "-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
+        RUSTFLAGS: "-Cinstrument-coverage -Zcoverage-options=branch -Ccodegen-units=1 -Copt-level=0 -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
         RUSTDOCFLAGS: "-Cpanic=abort"
+        LLVM_PROFILE_FILE: "diffutils-%p-%m.profraw"
     - name: "`grcov` ~ install"
       id: build_grcov
       shell: bash
@@ -219,67 +122,16 @@ jobs:
         COVERAGE_REPORT_FILE="${COVERAGE_REPORT_DIR}/lcov.info"
         mkdir -p "${COVERAGE_REPORT_DIR}"
         # display coverage files
-        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
+        grcov . --output-type files --binary-path "${COVERAGE_REPORT_DIR}" | sort --unique
         # generate coverage report
-        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\()"
+        grcov . --output-type lcov --output-path "${COVERAGE_REPORT_FILE}" --binary-path "${COVERAGE_REPORT_DIR}" --branch
         echo "report=${COVERAGE_REPORT_FILE}" >> $GITHUB_OUTPUT
     - name: Upload coverage results (to Codecov.io)
-      uses: codecov/codecov-action@v3
-      # if: steps.vars.outputs.HAS_CODECOV_TOKEN
+      uses: codecov/codecov-action@v7
       with:
-        # token: ${{ secrets.CODECOV_TOKEN }}
-        file: ${{ steps.coverage.outputs.report }}
+        token: ${{ secrets.CODECOV_TOKEN }}
+        files: ${{ 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 }}

.github/workflows/codspeed.yml

@@ -0,0 +1,37 @@
+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@v1
+        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

.github/workflows/fuzzing.yml

@@ -2,6 +2,10 @@ name: Fuzzing
 
 # spell-checker:ignore fuzzer
 
+env:
+  CARGO_INCREMENTAL: 0
+  RUSTC_BOOTSTRAP: 1
+
 on:
   pull_request:
   push:
@@ -21,15 +25,15 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@nightly
       - name: Install `cargo-fuzz`
-        run: cargo install cargo-fuzz
+        run: |
+          cargo install cargo-fuzz --locked
       - uses: Swatinem/rust-cache@v2
         with:
           shared-key: "cargo-fuzz-cache-key"
           cache-directories: "fuzz/target"
       - name: Run `cargo-fuzz build`
-        run: cargo +nightly fuzz build
+        run: cargo fuzz build
 
   fuzz-run:
     needs: fuzz-build
@@ -41,31 +45,34 @@ 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: cargo install cargo-fuzz
+        run: |
+          cargo install cargo-fuzz --locked
       - uses: Swatinem/rust-cache@v2
         with:
           shared-key: "cargo-fuzz-cache-key"
           cache-directories: "fuzz/target"
       - name: Restore Cached Corpus
-        uses: actions/cache/restore@v4
+        uses: actions/cache/restore@v5
         with:
           key: corpus-cache-${{ matrix.test-target.name }}
           path: |
             fuzz/corpus/${{ matrix.test-target.name }}
       - name: Run ${{ matrix.test-target.name }} for XX seconds
         shell: bash
-        continue-on-error: ${{ !matrix.test-target.name.should_pass }}
+        continue-on-error: ${{ !matrix.test-target.should_pass }}
         run: |
-          cargo +nightly fuzz run ${{ matrix.test-target.name }} -- -max_total_time=${{ env.RUN_FOR }} -detect_leaks=0
+          cargo fuzz run ${{ matrix.test-target.name }} -- -max_total_time=${{ env.RUN_FOR }} -detect_leaks=0
       - name: Save Corpus Cache
-        uses: actions/cache/save@v4
+        uses: actions/cache/save@v5
         with:
           key: corpus-cache-${{ matrix.test-target.name }}
           path: |

.github/workflows/release.yml

@@ -0,0 +1,296 @@
+# 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@v7
+        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@v7
+        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@v8
+        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@v7
+        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@v8
+        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@v8
+        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@v7
+        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@v8
+        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@v8
+        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@v7
+        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@v8
+        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

.github/workflows/wasi.yml

@@ -0,0 +1,28 @@
+# spell-checker:ignore wasip
+name: WASI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: read
+
+# End the current execution if there is a new changeset in the PR.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+jobs:
+  test_wasi:
+    name: Tests
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v6
+    - uses: dtolnay/rust-toolchain@stable
+      with:
+        targets: wasm32-wasip1
+    - name: check
+      run: cargo check --target wasm32-wasip1

.pre-commit-config.yaml

@@ -0,0 +1,48 @@
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+exclude: ^tests/fixtures/
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v6.0.0
+    hooks:
+      - id: check-added-large-files
+      - id: check-executables-have-shebangs
+      - id: check-json
+        exclude: '\.vscode/(cSpell|extensions)\.json' # cSpell.json and extensions.json use comments
+      - id: check-shebang-scripts-are-executable
+        exclude: '.+\.rs' # would be triggered by #![some_attribute]
+      - id: check-symlinks
+      - id: check-toml
+      - id: check-yaml
+        args: [ --allow-multiple-documents ]
+      - id: destroyed-symlinks
+      - id: end-of-file-fixer
+      - id: mixed-line-ending
+        args: [ --fix=lf ]
+      - id: trailing-whitespace
+
+  - repo: local
+    hooks:
+      - id: rust-linting
+        name: Rust linting
+        description: Run cargo fmt on files included in the commit.
+        entry: cargo +stable fmt --
+        pass_filenames: true
+        types: [file, rust]
+        language: system
+      - id: rust-clippy
+        name: Rust clippy
+        description: Run cargo clippy on files included in the commit.
+        entry: cargo +stable clippy --workspace --all-targets --all-features -- -D warnings
+        pass_filenames: false
+        types: [file, rust]
+        language: system
+      - id: cspell
+        name: Code spell checker (cspell)
+        description: Run cspell to check for spelling errors (if available).
+        entry: bash -c 'if command -v cspell >/dev/null 2>&1; then cspell --no-must-find-files -- "$@"; else echo "cspell not found, skipping spell check"; exit 0; fi' --
+        pass_filenames: true
+        language: system
+
+ci:
+  skip: [rust-linting, rust-clippy, cspell]

CONTRIBUTING.md

@@ -0,0 +1,32 @@
+# Contributing to diffutils
+
+Hi! Welcome to uutils/diffutils, and thanks for wanting to contribute!
+
+This project follows the shared conventions of the [uutils](https://github.com/uutils)
+organization. Before opening a pull request, please read:
+
+- Our **[Review Guidelines](https://uutils.github.io/reviews/)** — what we expect
+  from a pull request and how reviews are carried out.
+- Our community's [CODE_OF_CONDUCT.md](./CODE_OF_CONDUCT.md), if present.
+
+Finally, feel free to join our [Discord](https://discord.gg/wQVJbvJ)!
+
+> [!WARNING]
+> uutils is original code and cannot contain any code from GNU or other
+> strongly-licensed (GPL/LGPL) implementations. We **cannot** accept changes
+> based on the GNU source code, and you **must not link** to it either. You may
+> look at permissively-licensed implementations (MIT/BSD) and read the GNU
+> *manuals* — never the GNU *source*.
+
+## In short
+
+- Discuss non-trivial changes in an issue **before** writing the code.
+- Keep pull requests **small, self-contained, and descriptively titled**
+  (e.g. `diffutils: fix ...`).
+- Make sure CI passes: tests are green, `rustfmt` is satisfied, and there are
+  no `clippy` warnings.
+- Add tests for new behavior; don't let coverage regress.
+- Write small, atomic commits annotated with the component you touched.
+
+See the [Review Guidelines](https://uutils.github.io/reviews/) for the full
+details.

COPYRIGHT

@@ -0,0 +1,8 @@
+Copyright (c) Michael Howell
+Copyright (c) uutils developers
+
+Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+<LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+option. All files in the project carrying such notice may not be
+copied, modified, or distributed except according to those terms.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "diffutils"
-version = "0.3.0"
+version = "0.5.0"
 edition = "2021"
 description = "A CLI app for generating diff files"
 license = "MIT OR Apache-2.0"
@@ -15,13 +15,38 @@ name = "diffutils"
 path = "src/main.rs"
 
 [dependencies]
-diff = "0.1.10"
-regex = "1.10.3"
+chrono = "0.4.38"
+diff = "0.1.13"
+itoa = "1.0.11"
+regex = "1.10.4"
 same-file = "1.0.6"
-unicode-width = "0.1.11"
+unicode-width = "0.2.0"
 
 [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"
-tempfile = "3.10.0"
+rand = "0.10.0"
+tempfile = "3.26.0"
+
+[profile.release]
+lto = "thin"
+codegen-units = 1
+panic = "abort"
+
+# alias profile for 'dist'
+[profile.dist]
+inherits = "release"
+
+[[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 = []

README.md

@@ -2,10 +2,11 @@
 [![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/) in Rust.
+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.
 
 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.
 
@@ -53,4 +54,8 @@ $ cargo run -- -u fruits_old.txt fruits_new.txt
 
 ## License
 
-diffutils is licensed under the MIT and Apache Licenses - see the `LICENSE-MIT` or `LICENSE-APACHE` files for details
+This project is distributed under the terms of both the MIT license and the
+Apache License (Version 2.0).
+
+See [LICENSE-APACHE](LICENSE-APACHE), [LICENSE-MIT](LICENSE-MIT), and
+[COPYRIGHT](COPYRIGHT) for details.

SECURITY.md

@@ -0,0 +1,44 @@
+# Security Policy
+
+## Supported Versions
+
+We provide security updates only for the latest released version of `uutils/diffutils`.
+Older versions may not receive patches.
+If you are using a version packaged by your Linux distribution, please check with your distribution maintainers for their update policy.
+
+---
+
+## Reporting a Vulnerability
+
+**Do not open public GitHub issues for security vulnerabilities.**
+This prevents accidental disclosure before a fix is available.
+
+Instead, please use the following method:
+
+- **Email:** [sylvestre@debian.org](mailto:Sylvestre@debian.org)
+- **Encryption (optional):** You may encrypt your report using our PGP key:
+Fingerprint: B60D B599 4D39 BEC4 D1A9 5CCF 7E65 28DA 752F 1BE1
+---
+
+### What to Include in Your Report
+
+To help us investigate and resolve the issue quickly, please include as much detail as possible:
+
+- **Type of issue:** e.g. privilege escalation, information disclosure.
+- **Location in the source:** file path, commit hash, branch, or tag.
+- **Steps to reproduce:** exact commands, test cases, or scripts.
+- **Special configuration:** any flags, environment variables, or system setup required.
+- **Affected systems:** OS/distribution and version(s) where the issue occurs.
+- **Impact:** your assessment of the potential severity (DoS, RCE, data leak, etc.).
+
+---
+
+## Disclosure Policy
+
+We follow a **Coordinated Vulnerability Disclosure (CVD)** process:
+
+1. We will acknowledge receipt of your report within **10 days**.
+2. We will investigate, reproduce, and assess the issue.
+3. We will provide a timeline for developing and releasing a fix.
+4. Once a fix is available, we will publish a GitHub Security Advisory.
+5. You will be credited in the advisory unless you request anonymity.

benches/bench-diffutils.rs

@@ -0,0 +1,377 @@
+// 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();
+}

dist-workspace.toml

@@ -0,0 +1,13 @@
+[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"]

fuzz/Cargo.lock

@@ -0,0 +1,447 @@
+# 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.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
+
+[[package]]
+name = "cc"
+version = "1.2.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43c5703da9466b66a946814e1adf53ea2c90f10063b86290cc9eb67ce3478a20"
+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.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0"
+dependencies = [
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "wasm-bindgen",
+ "windows-link",
+]
+
+[[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",
+ "diff",
+ "itoa",
+ "regex",
+ "same-file",
+ "unicode-width",
+]
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[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.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
+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.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[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.94"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e04e2ef80ce82e13552136fabeef8a5ed1f985a96805761cbb9a2c34e7664d9"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.184"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48f5d2a454e16a5ea0f4ced81bd44e4cfc7bd3a507b61887c99fd3538b28e4af"
+
+[[package]]
+name = "libfuzzer-sys"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9fd2f41a1cba099f79a0b6b6c35656cf7c03351a7bae8ff0f28f25270f929d2"
+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.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+
+[[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.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+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.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
+
+[[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.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unicode-width"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
+
+[[package]]
+name = "unified-diff-fuzz"
+version = "0.0.0"
+dependencies = [
+ "diffutils",
+ "libfuzzer-sys",
+]
+
+[[package]]
+name = "wasip2"
+version = "1.0.2+wasi-0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0551fc1bb415591e3372d0bc4780db7e587d84e2a7e79da121051c5c4b89d0b0"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fbdf9a35adf44786aecd5ff89b4563a90325f9da0923236f6104e603c7e86be"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dca9693ef2bab6d4e6707234500350d8dad079eb508dca05530c85dc3a529ff2"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39129a682a6d2d841b6c429d0c51e5cb0ed1a03829d8b3d1e69a011e62cb3d3b"
+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.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"

fuzz/Cargo.toml

@@ -9,13 +9,25 @@ edition = "2018"
 cargo-fuzz = true
 
 [dependencies]
-libfuzzer-sys = "0.4"
+libfuzzer-sys = "0.4.7"
 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"
@@ -35,4 +47,8 @@ path = "fuzz_targets/fuzz_ed.rs"
 test = false
 doc = false
 
-
+[[bin]]
+name = "fuzz_side"
+path = "fuzz_targets/fuzz_side.rs"
+test = false
+doc = false

fuzz/dictionaries/cmp.txt

@@ -0,0 +1,36 @@
+"-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"

fuzz/fuzz_targets/fuzz_cmp.rs

@@ -0,0 +1,51 @@
+#![no_main]
+#[macro_use]
+extern crate libfuzzer_sys;
+use diffutilslib::cmp::{self, Cmp};
+
+use std::ffi::OsString;
+use std::fs::{self, 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;
+    fs::create_dir_all("target").unwrap();
+    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
+        );
+    }
+});

fuzz/fuzz_targets/fuzz_cmp_args.rs

@@ -0,0 +1,26 @@
+#![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.iter().any(|a| a == "--help") {
+        return Corpus::Reject;
+    }
+    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
+});

fuzz/fuzz_targets/fuzz_ed.rs

@@ -38,6 +38,7 @@ fuzz_target!(|x: (Vec<u8>, Vec<u8>)| {
     } else {
         return;
     }
+    fs::create_dir_all("target").unwrap();
     let diff = diff_w(&from, &to, "target/fuzz.file").unwrap();
     File::create("target/fuzz.file.original")
         .unwrap()

fuzz/fuzz_targets/fuzz_normal.rs

@@ -23,6 +23,7 @@ fuzz_target!(|x: (Vec<u8>, Vec<u8>)| {
         return
     }*/
     let diff = normal_diff::diff(&from, &to, &Params::default());
+    fs::create_dir_all("target").unwrap();
     File::create("target/fuzz.file.original")
         .unwrap()
         .write_all(&from)

fuzz/fuzz_targets/fuzz_patch.rs

@@ -21,15 +21,17 @@ fuzz_target!(|x: (Vec<u8>, Vec<u8>, u8)| {
     } else {
         return
     }*/
+    fs::create_dir_all("target").unwrap();
+    let patched = "target/fuzz.file";
     let diff = unified_diff::diff(
         &from,
         &to,
         &Params {
-            from: "a/fuzz.file".into(),
-            to: "target/fuzz.file".into(),
+            from: patched.into(),
+            to: patched.into(),
             context_count: context as usize,
             ..Default::default()
-        }
+        },
     );
     File::create("target/fuzz.file.original")
         .unwrap()

fuzz/fuzz_targets/fuzz_side.rs

@@ -0,0 +1,43 @@
+#![no_main]
+#[macro_use]
+extern crate libfuzzer_sys;
+
+use diffutilslib::side_diff;
+
+use diffutilslib::params::Params;
+use std::fs::{self, File};
+use std::io::Write;
+
+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()
+    };
+    fs::create_dir_all("target").unwrap();
+    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();
+});

src/context_diff.rs

@@ -8,6 +8,7 @@ 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 {
@@ -267,10 +268,14 @@ 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\n--- {1}\t\n",
+        "*** {0}\t{1}\n--- {2}\t{3}\n",
         params.from.to_string_lossy(),
-        params.to.to_string_lossy()
+        from_modified_time,
+        params.to.to_string_lossy(),
+        to_modified_time
     )
     .into_bytes();
     let diff_results = make_diff(expected, actual, params.context_count, params.brief);
@@ -376,6 +381,9 @@ pub fn diff(expected: &[u8], actual: &[u8], params: &Params) -> Vec<u8> {
 mod tests {
     use super::*;
     use pretty_assertions::assert_eq;
+
+    use crate::utils::testcmds::PATCH_CMD;
+
     #[test]
     fn test_permutations() {
         // test all possible six-line files.
@@ -389,7 +397,6 @@ mod tests {
                             for &f in &[0, 1, 2] {
                                 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" })
@@ -424,36 +431,38 @@ mod tests {
                                 }
                                 // This test diff is intentionally reversed.
                                 // We want it to turn the alef into bet.
+                                let patched = &format!("{target}/alef");
                                 let diff = diff(
                                     &alef,
                                     &bet,
                                     &Params {
-                                        from: "a/alef".into(),
-                                        to: (&format!("{target}/alef")).into(),
+                                        from: patched.into(),
+                                        to: patched.into(),
                                         context_count: 2,
                                         ..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")
+                                let output = PATCH_CMD
+                                    .new()
                                     .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);
                             }
                         }
@@ -476,7 +485,6 @@ mod tests {
                             for &f in &[0, 1, 2] {
                                 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();
@@ -505,36 +513,38 @@ mod tests {
                                 }
                                 // This test diff is intentionally reversed.
                                 // We want it to turn the alef into bet.
+                                let patched = &format!("{target}/alef_");
                                 let diff = diff(
                                     &alef,
                                     &bet,
                                     &Params {
-                                        from: "a/alef_".into(),
-                                        to: (&format!("{target}/alef_")).into(),
+                                        from: patched.into(),
+                                        to: patched.into(),
                                         context_count: 2,
                                         ..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")
+                                let output = PATCH_CMD
+                                    .new()
                                     .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);
                             }
                         }
@@ -557,7 +567,6 @@ mod tests {
                             for &f in &[0, 1, 2] {
                                 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"" }).unwrap();
@@ -589,36 +598,38 @@ mod tests {
                                 };
                                 // This test diff is intentionally reversed.
                                 // We want it to turn the alef into bet.
+                                let patched = &format!("{target}/alefx");
                                 let diff = diff(
                                     &alef,
                                     &bet,
                                     &Params {
-                                        from: "a/alefx".into(),
-                                        to: (&format!("{target}/alefx")).into(),
+                                        from: patched.into(),
+                                        to: patched.into(),
                                         context_count: 2,
                                         ..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")
+                                let output = PATCH_CMD
+                                    .new()
                                     .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);
                             }
                         }
@@ -641,7 +652,6 @@ mod tests {
                             for &f in &[0, 1, 2] {
                                 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" })
@@ -676,36 +686,38 @@ mod tests {
                                 }
                                 // This test diff is intentionally reversed.
                                 // We want it to turn the alef into bet.
+                                let alefr_path = &format!("{target}/alefr");
                                 let diff = diff(
                                     &alef,
                                     &bet,
                                     &Params {
-                                        from: "a/alefr".into(),
-                                        to: (&format!("{target}/alefr")).into(),
+                                        from: alefr_path.into(),
+                                        to: alefr_path.into(),
                                         context_count: 2,
                                         ..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")
+                                let output = PATCH_CMD
+                                    .new()
                                     .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);
                             }
                         }
@@ -717,6 +729,8 @@ 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";
@@ -731,9 +745,10 @@ mod tests {
                 ..Default::default()
             },
         );
+
         let expected_full = [
-            "*** foo\t",
-            "--- bar\t",
+            "*** foo\tTIMESTAMP",
+            "--- bar\tTIMESTAMP",
             "***************",
             "*** 1,3 ****",
             "  a",
@@ -746,7 +761,7 @@ mod tests {
             "",
         ]
         .join("\n");
-        assert_eq!(diff_full, expected_full.as_bytes());
+        assert_diff_eq!(diff_full, expected_full);
 
         let diff_brief = diff(
             from.as_bytes(),
@@ -758,8 +773,9 @@ mod tests {
                 ..Default::default()
             },
         );
-        let expected_brief = ["*** foo\t", "--- bar\t", ""].join("\n");
-        assert_eq!(diff_brief, expected_brief.as_bytes());
+
+        let expected_brief = ["*** foo\tTIMESTAMP", "--- bar\tTIMESTAMP", ""].join("\n");
+        assert_diff_eq!(diff_brief, expected_brief);
 
         let nodiff_full = diff(
             from.as_bytes(),

src/diff.rs

@@ -0,0 +1,102 @@
+// 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)
+    }
+}

src/ed_diff.rs

@@ -162,6 +162,9 @@ pub fn diff(expected: &[u8], actual: &[u8], params: &Params) -> Result<Vec<u8>,
 mod tests {
     use super::*;
     use pretty_assertions::assert_eq;
+
+    use crate::utils::testcmds::ED_CMD;
+
     pub fn diff_w(expected: &[u8], actual: &[u8], filename: &str) -> Result<Vec<u8>, DiffError> {
         let mut output = diff(expected, actual, &Params::default())?;
         writeln!(&mut output, "w {filename}").unwrap();
@@ -188,9 +191,8 @@ mod tests {
                     for &d in &[0, 1, 2] {
                         for &e in &[0, 1, 2] {
                             for &f in &[0, 1, 2] {
-                                use std::fs::{self, File};
+                                use std::fs::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" })
@@ -226,26 +228,30 @@ 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("target/ab.ed")
+                                File::create(format!("{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;
-                                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);
+                                #[cfg(not(windows))] // there's no ed on windows
+                                {
+                                    let output = ED_CMD
+                                        .new()
+                                        .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);
+                                }
                             }
                         }
                     }
@@ -265,9 +271,8 @@ mod tests {
                     for &d in &[0, 1, 2] {
                         for &e in &[0, 1, 2] {
                             for &f in &[0, 1, 2] {
-                                use std::fs::{self, File};
+                                use std::fs::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();
@@ -296,27 +301,31 @@ mod tests {
                                 }
                                 // This test diff is intentionally reversed.
                                 // We want it to turn the alef into bet.
-                                let diff = diff_w(&alef, &bet, "target/alef_").unwrap();
-                                File::create("target/ab_.ed")
+                                let diff = diff_w(&alef, &bet, &format!("{target}/alef_")).unwrap();
+                                File::create(format!("{target}/ab_.ed"))
                                     .unwrap()
                                     .write_all(&diff)
                                     .unwrap();
-                                let mut fa = File::create("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("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);
+                                #[cfg(not(windows))] // there's no ed on windows
+                                {
+                                    let output = ED_CMD
+                                        .new()
+                                        .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);
+                                }
                             }
                         }
                     }
@@ -336,9 +345,8 @@ mod tests {
                     for &d in &[0, 1, 2] {
                         for &e in &[0, 1, 2] {
                             for &f in &[0, 1, 2] {
-                                use std::fs::{self, File};
+                                use std::fs::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" })
@@ -374,26 +382,30 @@ 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("target/abr.ed")
+                                File::create(format!("{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;
-                                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);
+                                #[cfg(not(windows))] // there's no ed on windows
+                                {
+                                    let output = ED_CMD
+                                        .new()
+                                        .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);
+                                }
                             }
                         }
                     }

src/lib.rs

@@ -1,7 +1,10 @@
+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;
 
@@ -9,4 +12,5 @@ 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;

src/macros.rs

@@ -0,0 +1,25 @@
+// 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);
+    }};
+}

src/main.rs

@@ -3,83 +3,83 @@
 // 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 std::env;
-
-use std::fs;
-use std::io::{self, Write};
-use std::process::{exit, ExitCode};
+use std::{
+    env::ArgsOs,
+    ffi::{OsStr, OsString},
+    iter::Peekable,
+    path::{Path, PathBuf},
+    process::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;
 
-// 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 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(),
-            );
-        }
-    };
-    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)
+/// # 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);
+}
+
+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.as_encoded_bytes().ends_with(b"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.as_encoded_bytes() {
+        name if name.ends_with(b"diff") => diff::main(args),
+        name if name.ends_with(b"cmp") => cmp::main(args),
+        name => {
+            use std::io::{stderr, Write as _};
+            let _ = writeln!(
+                stderr(),
+                "{}: utility not supported",
+                String::from_utf8_lossy(name)
+            );
+            ExitCode::from(2)
+        }
     }
 }

src/normal_diff.rs

@@ -215,6 +215,8 @@ mod tests {
     use super::*;
     use pretty_assertions::assert_eq;
 
+    use crate::utils::testcmds::PATCH_CMD;
+
     #[test]
     fn test_basic() {
         let mut a = Vec::new();
@@ -239,7 +241,6 @@ mod tests {
                             for &f in &[0, 1, 2] {
                                 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" })
@@ -275,26 +276,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}/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")
+                                let output = PATCH_CMD
+                                    .new()
                                     .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);
                             }
                         }
@@ -318,7 +320,6 @@ mod tests {
                                 for &g in &[0, 1, 2] {
                                     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" })
@@ -367,27 +368,28 @@ 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")
+                                    let output = PATCH_CMD
+                                        .new()
                                         .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);
                                 }
                             }
@@ -411,7 +413,6 @@ mod tests {
                             for &f in &[0, 1, 2] {
                                 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();
@@ -441,26 +442,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}/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")
+                                let output = PATCH_CMD
+                                    .new()
                                     .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);
                             }
                         }
@@ -483,7 +485,6 @@ mod tests {
                             for &f in &[0, 1, 2] {
                                 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" })
@@ -519,26 +520,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}/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")
+                                let output = PATCH_CMD
+                                    .new()
                                     .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);
                             }
                         }

src/params.rs

@@ -1,4 +1,6 @@
-use std::ffi::{OsStr, OsString};
+use std::ffi::OsString;
+use std::iter::Peekable;
+use std::path::PathBuf;
 
 use regex::Regex;
 
@@ -9,21 +11,12 @@ pub enum Format {
     Unified,
     Context,
     Ed,
-}
-
-#[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()
+    SideBySide,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct Params {
+    pub executable: OsString,
     pub from: OsString,
     pub to: OsString,
     pub format: Format,
@@ -32,11 +25,13 @@ 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(),
@@ -45,33 +40,42 @@ impl Default for Params {
             brief: false,
             expand_tabs: false,
             tabsize: 8,
+            width: 130,
         }
     }
 }
 
-pub fn parse_params<I: IntoIterator<Item = OsString>>(opts: I) -> Result<Params, String> {
-    let mut opts = opts.into_iter();
+pub fn parse_params<I: Iterator<Item = OsString>>(mut opts: Peekable<I>) -> Result<Params, String> {
     // parse CLI
 
-    let Some(exe) = opts.next() else {
+    let Some(executable) = opts.next() else {
         return Err("Usage: <exe> <from> <to>".to_string());
     };
-    let mut params = Params::default();
+    let mut params = Params {
+        executable,
+        ..Default::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(OsString::from("/dev/stdin"));
+                from = Some(param);
             } else if to.is_none() {
-                to = Some(OsString::from("/dev/stdin"));
+                to = Some(param);
             } else {
-                return Err(format!("Usage: {} <from> <to>", exe.to_string_lossy()));
+                return Err(format!(
+                    "Usage: {} <from> <to>",
+                    params.executable.to_string_lossy()
+                ));
             }
             continue;
         }
@@ -87,6 +91,48 @@ pub fn parse_params<I: IntoIterator<Item = OsString>>(opts: I) -> Result<Params,
             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.
@@ -98,70 +144,68 @@ pub fn parse_params<I: IntoIterator<Item = OsString>>(opts: I) -> Result<Params,
                 .unwrap()
                 .as_str();
             params.tabsize = match tabsize_str.parse::<usize>() {
-                Ok(num) => num,
+                Ok(num) => {
+                    if num == 0 {
+                        return Err("invalid tabsize «0»".to_string());
+                    }
+
+                    num
+                }
                 Err(_) => return Err(format!("invalid tabsize «{tabsize_str}»")),
             };
+
             continue;
         }
-        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;
-                        }
+        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;
                     }
-                    b'c' => {
-                        if format.is_some() && format != Some(Format::Context) {
-                            return Err("Conflicting output style options".to_string());
-                        }
-                        format = Some(Format::Context);
+                    if next_param_consumed {
+                        opts.next();
                     }
-                    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]))),
+                    continue;
                 }
             }
-        } else if from.is_none() {
+            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.to_string_lossy()));
+        }
+        if from.is_none() {
             from = Some(param);
         } else if to.is_none() {
             to = Some(param);
         } else {
-            return Err(format!("Usage: {} <from> <to>", exe.to_string_lossy()));
+            return Err(format!(
+                "Usage: {} <from> <to>",
+                params.executable.to_string_lossy()
+            ));
         }
     }
     params.from = if let Some(from) = from {
@@ -169,19 +213,136 @@ pub fn parse_params<I: IntoIterator<Item = OsString>>(opts: I) -> Result<Params,
     } else if let Some(param) = opts.next() {
         param
     } else {
-        return Err(format!("Usage: {} <from> <to>", exe.to_string_lossy()));
+        return Err(format!(
+            "Usage: {} <from> <to>",
+            params.executable.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>", exe.to_string_lossy()));
+        return Err(format!(
+            "Usage: {} <from> <to>",
+            params.executable.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::*;
@@ -192,29 +353,176 @@ 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())
+            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()
+            )
         );
     }
     #[test]
     fn basics_ed() {
-        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())
-        );
+        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());
+        }
     }
     #[test]
     fn context_count() {
         assert_eq!(
             Ok(Params {
+                executable: os("diff"),
                 from: os("foo"),
                 to: os("bar"),
                 format: Format::Unified,
@@ -225,10 +533,12 @@ 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,
@@ -239,10 +549,12 @@ 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,
@@ -253,10 +565,12 @@ 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,
@@ -267,6 +581,7 @@ mod tests {
                 [os("diff"), os("-c54"), os("foo"), os("bar")]
                     .iter()
                     .cloned()
+                    .peekable()
             )
         );
     }
@@ -274,23 +589,36 @@ 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())
+            parse_params(
+                [os("diff"), os("foo"), os("bar")]
+                    .iter()
+                    .cloned()
+                    .peekable()
+            )
         );
         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())
+            parse_params(
+                [os("diff"), os("-s"), os("foo"), os("bar")]
+                    .iter()
+                    .cloned()
+                    .peekable()
+            )
         );
         assert_eq!(
             Ok(Params {
+                executable: os("diff"),
                 from: os("foo"),
                 to: os("bar"),
                 report_identical_files: true,
@@ -305,6 +633,7 @@ mod tests {
                 ]
                 .iter()
                 .cloned()
+                .peekable()
             )
         );
     }
@@ -312,23 +641,36 @@ 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())
+            parse_params(
+                [os("diff"), os("foo"), os("bar")]
+                    .iter()
+                    .cloned()
+                    .peekable()
+            )
         );
         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())
+            parse_params(
+                [os("diff"), os("-q"), os("foo"), os("bar")]
+                    .iter()
+                    .cloned()
+                    .peekable()
+            )
         );
         assert_eq!(
             Ok(Params {
+                executable: os("diff"),
                 from: os("foo"),
                 to: os("bar"),
                 brief: true,
@@ -338,6 +680,7 @@ mod tests {
                 [os("diff"), os("--brief"), os("foo"), os("bar"),]
                     .iter()
                     .cloned()
+                    .peekable()
             )
         );
     }
@@ -345,15 +688,22 @@ 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())
+            parse_params(
+                [os("diff"), os("foo"), os("bar")]
+                    .iter()
+                    .cloned()
+                    .peekable()
+            )
         );
         for option in ["-t", "--expand-tabs"] {
             assert_eq!(
                 Ok(Params {
+                    executable: os("diff"),
                     from: os("foo"),
                     to: os("bar"),
                     expand_tabs: true,
@@ -363,6 +713,7 @@ mod tests {
                     [os("diff"), os(option), os("foo"), os("bar")]
                         .iter()
                         .cloned()
+                        .peekable()
                 )
             );
         }
@@ -371,27 +722,36 @@ 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())
-        );
-        assert_eq!(
-            Ok(Params {
-                from: os("foo"),
-                to: os("bar"),
-                tabsize: 0,
-                ..Default::default()
-            }),
             parse_params(
-                [os("diff"), os("--tabsize=0"), os("foo"), os("bar")]
+                [os("diff"), os("foo"), os("bar")]
                     .iter()
                     .cloned()
+                    .peekable()
             )
         );
         assert_eq!(
             Ok(Params {
+                executable: os("diff"),
+                from: os("foo"),
+                to: os("bar"),
+                tabsize: 1,
+                ..Default::default()
+            }),
+            parse_params(
+                [os("diff"), os("--tabsize=1"), os("foo"), os("bar")]
+                    .iter()
+                    .cloned()
+                    .peekable()
+            )
+        );
+        assert_eq!(
+            Ok(Params {
+                executable: os("diff"),
                 from: os("foo"),
                 to: os("bar"),
                 tabsize: 42,
@@ -401,36 +761,42 @@ 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(
@@ -442,6 +808,7 @@ mod tests {
             ]
             .iter()
             .cloned()
+            .peekable()
         )
         .is_err());
     }
@@ -449,57 +816,104 @@ 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())
+            parse_params(
+                [os("diff"), os("--"), os("-g"), os("-h")]
+                    .iter()
+                    .cloned()
+                    .peekable()
+            )
         );
     }
     #[test]
     fn default_to_stdin() {
         assert_eq!(
             Ok(Params {
+                executable: os("diff"),
                 from: os("foo"),
-                to: os("/dev/stdin"),
+                to: os("-"),
                 ..Default::default()
             }),
-            parse_params([os("diff"), os("foo"), os("-")].iter().cloned())
+            parse_params([os("diff"), os("foo"), os("-")].iter().cloned().peekable())
         );
         assert_eq!(
             Ok(Params {
-                from: os("/dev/stdin"),
+                executable: os("diff"),
+                from: os("-"),
                 to: os("bar"),
                 ..Default::default()
             }),
-            parse_params([os("diff"), os("-"), os("bar")].iter().cloned())
+            parse_params([os("diff"), os("-"), os("bar")].iter().cloned().peekable())
         );
         assert_eq!(
             Ok(Params {
-                from: os("/dev/stdin"),
-                to: os("/dev/stdin"),
+                executable: os("diff"),
+                from: os("-"),
+                to: os("-"),
                 ..Default::default()
             }),
-            parse_params([os("diff"), os("-"), os("-")].iter().cloned())
+            parse_params([os("diff"), os("-"), os("-")].iter().cloned().peekable())
         );
-        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());
+        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());
     }
     #[test]
     fn missing_arguments() {
-        assert!(parse_params([os("diff")].iter().cloned()).is_err());
-        assert!(parse_params([os("diff"), os("foo")].iter().cloned()).is_err());
+        assert!(parse_params([os("diff")].iter().cloned().peekable()).is_err());
+        assert!(parse_params([os("diff"), os("foo")].iter().cloned().peekable()).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("foo"), os("bar")].iter().cloned()).is_err()
+            parse_params([os("diff"), os("-g"), os("bar")].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());
+        assert!(parse_params([os("diff"), os("-g")].iter().cloned().peekable()).is_err());
     }
     #[test]
     fn empty() {
-        assert!(parse_params([].iter().cloned()).is_err());
+        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());
+        }
     }
 }

src/unified_diff.rs

@@ -8,6 +8,7 @@ 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 {
@@ -238,10 +239,14 @@ 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\n+++ {1}\t\n",
+        "--- {0}\t{1}\n+++ {2}\t{3}\n",
         params.from.to_string_lossy(),
-        params.to.to_string_lossy()
+        from_modified_time,
+        params.to.to_string_lossy(),
+        to_modified_time
     )
     .into_bytes();
     let diff_results = make_diff(expected, actual, params.context_count, params.brief);
@@ -403,6 +408,8 @@ mod tests {
     use super::*;
     use pretty_assertions::assert_eq;
 
+    use crate::utils::testcmds::PATCH_CMD;
+
     #[test]
     fn test_permutations() {
         let target = "target/unified-diff/";
@@ -416,7 +423,6 @@ mod tests {
                             for &f in &[0, 1, 2] {
                                 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" })
@@ -451,23 +457,24 @@ mod tests {
                                 }
                                 // This test diff is intentionally reversed.
                                 // We want it to turn the alef into bet.
+                                let patched = &format!("{target}/alef");
                                 let diff = diff(
                                     &alef,
                                     &bet,
                                     &Params {
-                                        from: "a/alef".into(),
-                                        to: (&format!("{target}/alef")).into(),
+                                        from: patched.into(),
+                                        to: patched.into(),
                                         context_count: 2,
                                         ..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;
@@ -487,15 +494,18 @@ mod tests {
                                         .unwrap_or_else(|_| String::from("[Invalid UTF-8]"))
                                 );
 
-                                let output = Command::new("patch")
+                                use crate::utils::testcmds::PATCH_CMD;
+
+                                let output = PATCH_CMD
+                                    .new()
                                     .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);
                             }
                         }
@@ -519,7 +529,6 @@ mod tests {
                                 for &g in &[0, 1, 2] {
                                     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" })
@@ -567,35 +576,37 @@ mod tests {
                                     }
                                     // This test diff is intentionally reversed.
                                     // We want it to turn the alef into bet.
+                                    let patched = &format!("{target}/alefn");
                                     let diff = diff(
                                         &alef,
                                         &bet,
                                         &Params {
-                                            from: "a/alefn".into(),
-                                            to: (&format!("{target}/alefn")).into(),
+                                            from: patched.into(),
+                                            to: patched.into(),
                                             context_count: 2,
                                             ..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")
+                                    let output = PATCH_CMD
+                                        .new()
                                         .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);
                                 }
                             }
@@ -620,7 +631,6 @@ mod tests {
                                 for &g in &[0, 1, 2, 3] {
                                     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();
@@ -663,35 +673,37 @@ mod tests {
                                     }
                                     // This test diff is intentionally reversed.
                                     // We want it to turn the alef into bet.
+                                    let patched = &format!("{target}/alef_");
                                     let diff = diff(
                                         &alef,
                                         &bet,
                                         &Params {
-                                            from: "a/alef_".into(),
-                                            to: (&format!("{target}/alef_")).into(),
+                                            from: patched.into(),
+                                            to: patched.into(),
                                             context_count: 2,
                                             ..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")
+                                    let output = PATCH_CMD
+                                        .new()
                                         .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);
                                 }
                             }
@@ -715,7 +727,6 @@ mod tests {
                             for &f in &[0, 1, 2] {
                                 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"" }).unwrap();
@@ -744,35 +755,37 @@ mod tests {
                                 }
                                 // This test diff is intentionally reversed.
                                 // We want it to turn the alef into bet.
+                                let patched = &format!("{target}/alefx");
                                 let diff = diff(
                                     &alef,
                                     &bet,
                                     &Params {
-                                        from: "a/alefx".into(),
-                                        to: (&format!("{target}/alefx")).into(),
+                                        from: patched.into(),
+                                        to: patched.into(),
                                         context_count: 2,
                                         ..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")
+                                let output = PATCH_CMD
+                                    .new()
                                     .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);
                             }
                         }
@@ -795,7 +808,6 @@ mod tests {
                             for &f in &[0, 1, 2] {
                                 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" })
@@ -830,35 +842,37 @@ mod tests {
                                 }
                                 // This test diff is intentionally reversed.
                                 // We want it to turn the alef into bet.
+                                let patched = &format!("{target}/alefr");
                                 let diff = diff(
                                     &alef,
                                     &bet,
                                     &Params {
-                                        from: "a/alefr".into(),
-                                        to: (&format!("{target}/alefr")).into(),
+                                        from: patched.into(),
+                                        to: patched.into(),
                                         context_count: 2,
                                         ..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")
+                                let output = PATCH_CMD
+                                    .new()
                                     .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);
                             }
                         }
@@ -870,6 +884,8 @@ 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";
@@ -884,9 +900,10 @@ mod tests {
                 ..Default::default()
             },
         );
+
         let expected_full = [
-            "--- foo\t",
-            "+++ bar\t",
+            "--- foo\tTIMESTAMP",
+            "+++ bar\tTIMESTAMP",
             "@@ -1,3 +1,3 @@",
             " a",
             "-b",
@@ -895,7 +912,7 @@ mod tests {
             "",
         ]
         .join("\n");
-        assert_eq!(diff_full, expected_full.as_bytes());
+        assert_diff_eq!(diff_full, expected_full);
 
         let diff_brief = diff(
             from.as_bytes(),
@@ -907,8 +924,9 @@ mod tests {
                 ..Default::default()
             },
         );
-        let expected_brief = ["--- foo\t", "+++ bar\t", ""].join("\n");
-        assert_eq!(diff_brief, expected_brief.as_bytes());
+
+        let expected_brief = ["--- foo\tTIMESTAMP", "+++ bar\tTIMESTAMP", ""].join("\n");
+        assert_diff_eq!(diff_brief, expected_brief);
 
         let nodiff_full = diff(
             from.as_bytes(),

src/utils.rs

@@ -3,8 +3,8 @@
 // For the full copyright and license information, please view the LICENSE-*
 // files that was distributed with this source code.
 
-use std::io::Write;
-
+use regex::Regex;
+use std::{ffi::OsString, io::Write};
 use unicode_width::UnicodeWidthStr;
 
 /// Replace tabs by spaces in the input line.
@@ -52,6 +52,145 @@ 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)]
+pub mod testcmds {
+    // Command construction wrapper that provides some validation and non-obscure, "fail fast"
+    // feedback and error messages.
+    use std::any::Any;
+    use std::io::Write;
+    use std::panic::catch_unwind;
+    use std::process::{Command, Stdio};
+    use std::sync::LazyLock;
+
+    pub struct CmdFactory {
+        cmd: &'static str,
+        validated_once: LazyLock<Result<(), String>>,
+        validate: fn(&CmdFactory) -> (),
+    }
+
+    impl CmdFactory {
+        pub fn new(&self) -> Command {
+            match &*self.validated_once {
+                Ok(()) => Command::new(self.cmd),
+                Err(errmsg) => panic!(
+                    "'{}' validation failed in earlier thread/test: {}",
+                    self.cmd, errmsg
+                ),
+            }
+        }
+        // "self" is not compatible with static initialization
+        fn try_catch_validate(cmd: &CmdFactory) -> Result<(), String> {
+            // Note catch_unwind() does _not_ hide error messages, stack traces, etc.
+            catch_unwind(|| {
+                let _ = (cmd.validate)(cmd);
+            })
+            .map_err(find_panic_message)
+        }
+    }
+
+    fn find_panic_message(payload: Box<dyn Any + Send>) -> String {
+        // https://github.com/rust-lang/rust/blob/1.95.0/library/std/src/panicking.rs#L771
+        if let Some(&s) = payload.downcast_ref::<&'static str>() {
+            String::from(s)
+        } else if let Some(s) = payload.downcast_ref::<String>() {
+            s.clone()
+        } else {
+            format!(
+                "Unusual panic payload type {:?}, look for the first thread/test that failed",
+                payload.type_id(),
+            )
+        }
+    }
+
+    pub static PATCH_CMD: CmdFactory = CmdFactory {
+        cmd: if cfg!(target_os = "macos") {
+            "gpatch" // brew install gpatch
+        } else {
+            "patch"
+        },
+        validated_once: LazyLock::new(|| CmdFactory::try_catch_validate(&PATCH_CMD)),
+
+        validate: (|myself| {
+            let output = Command::new(myself.cmd)
+                .arg("--version")
+                .output()
+                .expect(format!("`{} --version` failed", myself.cmd).as_str());
+            // Non-GNU versions have subtle differences. When some newlines are missing in some test
+            // patches, the macOS version can even stall the whole test run.
+            assert!(output.stdout.starts_with(b"GNU patch"));
+            assert!(output.status.success());
+        }),
+    };
+
+    pub static ED_CMD: CmdFactory = CmdFactory {
+        cmd: "ed",
+        validated_once: LazyLock::new(|| CmdFactory::try_catch_validate(&ED_CMD)),
+
+        validate: (|myself| {
+            let mut child = Command::new(myself.cmd)
+                .arg("!echo hello_ed")
+                .stdin(Stdio::piped())
+                .stdout(Stdio::piped())
+                .spawn()
+                .expect("Failed to start 'ed' command");
+
+            let mut stdin = child.stdin.take().unwrap();
+            writeln!(stdin, "1p\nq").expect("Failed to send command to 'ed'");
+
+            let output = child
+                .wait_with_output()
+                .expect("Failed to read 'ed' stdout");
+            assert_eq!(String::from_utf8_lossy(&output.stdout), "9\nhello_ed\n");
+        }),
+    };
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -82,10 +221,11 @@ 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 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");
+            // 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");
         }
 
         #[test]
@@ -115,4 +255,46 @@ 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);
+        }
+    }
 }

tests/run-upstream-testsuite.sh

@@ -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 overriden by the $TESTS environment variable, all tests in the test
+# Unless overridden 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. cmp, diff3 or sdiff) are skipped.
+# (e.g. diff3 or sdiff) are skipped.
 
 scriptpath=$(dirname "$(readlink -f "$0")")
 rev=$(git rev-parse HEAD)
@@ -57,8 +57,13 @@ 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 -sL "$gitserver/gitweb/?p=gnulib.git;a=blob_plain;f=tests/init.sh;hb=HEAD" -o init.sh
+
 if [[ -n "$TESTS" ]]
 then
   tests="$TESTS"
@@ -71,7 +76,6 @@ 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
@@ -82,35 +86,43 @@ for test in $tests
 do
   result="FAIL"
   url="$urlroot$test?id=$upstreamrev"
-  # Run only the tests that invoke `diff`,
+  # Run only the tests that invoke `diff` or `cmp`,
   # because other binaries aren't implemented yet
-  if ! grep -E -s -q "(cmp|diff3|sdiff)" "$test"
+  if ! grep -E -s -q "(diff3|sdiff)" "$test"
   then
-    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++ ))
+    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
   else
     result="SKIP"
-    (( skipped++ ))
-    json+="{\"test\":\"$test\",\"url\":\"$url\",\"result\":\"$result\"},"
   fi
   color=2 # green
   [[ "$result" = "FAIL" ]] && color=1 # red
-  [[ "$result" = "SKIP" ]] && color=3 # yellow
+  if [[ $result = "SKIP" ]]
+  then
+    (( skipped++ ))
+    json+="{\"test\":\"$test\",\"url\":\"$url\",\"result\":\"$result\"},"
+    color=3 # yellow
+  fi
   printf "  %-40s $(tput setaf $color)$result$(tput sgr0)\n" "$test"
 done
 echo ""
@@ -138,4 +150,5 @@ resultsfile="test-results.json"
 echo "$json" | jq > "$resultsfile"
 echo "Results written to $scriptpath/$resultsfile"
 
-exit $exitcode
+(( failed > 0 )) && exit 1
+exit 0

util/compare_test_results.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+
+"""
+Compare the current GNU test results to the last results gathered from the main branch to
+highlight if a PR is making the results better/worse.
+Don't exit with error code if all failing tests are in the ignore-intermittent.txt list.
+"""
+
+import json
+import sys
+import argparse
+from pathlib import Path
+
+
+def load_ignore_list(ignore_file):
+    """Load list of intermittent test names to ignore from file."""
+    ignore_set = set()
+    if ignore_file and Path(ignore_file).exists():
+        with open(ignore_file, "r") as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith("#"):
+                    ignore_set.add(line)
+    return ignore_set
+
+
+def extract_test_results(json_data):
+    """Extract test results from a diffutils test-results.json.
+
+    Note: unlike sed, diffutils JSON has no 'summary' object — results are
+    computed from the 'tests' array using the 'result' and 'test' fields.
+    """
+    tests = json_data.get("tests", [])
+    passed  = sum(1 for t in tests if t.get("result") == "PASS")
+    failed  = sum(1 for t in tests if t.get("result") == "FAIL")
+    skipped = sum(1 for t in tests if t.get("result") == "SKIP")
+    summary = {"total": len(tests), "passed": passed, "failed": failed, "skipped": skipped}
+    failed_tests = [t["test"] for t in tests if t.get("result") == "FAIL"]
+    return summary, failed_tests
+
+
+def compare_results(current_file, reference_file, ignore_file=None, output_file=None):
+    """Compare current results with reference results."""
+    ignore_set = load_ignore_list(ignore_file)
+
+    try:
+        with open(current_file, "r") as f:
+            current_data = json.load(f)
+        current_summary, current_failed = extract_test_results(current_data)
+    except Exception as e:
+        print(f"Error loading current results: {e}")
+        return 1
+
+    try:
+        with open(reference_file, "r") as f:
+            reference_data = json.load(f)
+        reference_summary, reference_failed = extract_test_results(reference_data)
+    except Exception as e:
+        print(f"Error loading reference results: {e}")
+        return 1
+
+    # Calculate differences
+    pass_diff  = int(current_summary.get("passed",  0)) - int(reference_summary.get("passed",  0))
+    fail_diff  = int(current_summary.get("failed",  0)) - int(reference_summary.get("failed",  0))
+    total_diff = int(current_summary.get("total",   0)) - int(reference_summary.get("total",   0))
+
+    # Find new failures and improvements
+    current_failed_set   = set(current_failed)
+    reference_failed_set = set(reference_failed)
+
+    new_failures  = current_failed_set   - reference_failed_set
+    improvements  = reference_failed_set - current_failed_set
+
+    # Filter out intermittent failures
+    non_intermittent_new_failures = new_failures - ignore_set
+
+    # Check if results are identical (no changes)
+    no_changes = (
+        pass_diff == 0
+        and fail_diff == 0
+        and total_diff == 0
+        and not new_failures
+        and not improvements
+    )
+
+    # If no changes, write empty output to prevent comment posting
+    if no_changes:
+        if output_file:
+            with open(output_file, "w") as f:
+                f.write("")
+        return 0
+
+    # Prepare output message
+    output_lines = []
+
+    output_lines.append("Test results comparison:")
+    output_lines.append(
+        f"  Current:   TOTAL: {current_summary.get('total', 0)} / PASSED: {current_summary.get('passed', 0)} / FAILED: {current_summary.get('failed', 0)} / SKIPPED: {current_summary.get('skipped', 0)}"
+    )
+    output_lines.append(
+        f"  Reference: TOTAL: {reference_summary.get('total', 0)} / PASSED: {reference_summary.get('passed', 0)} / FAILED: {reference_summary.get('failed', 0)} / SKIPPED: {reference_summary.get('skipped', 0)}"
+    )
+    output_lines.append("")
+
+    if pass_diff != 0 or fail_diff != 0 or total_diff != 0:
+        output_lines.append("Changes from main branch:")
+        output_lines.append(f"  TOTAL: {total_diff:+d}")
+        output_lines.append(f"  PASSED: {pass_diff:+d}")
+        output_lines.append(f"  FAILED: {fail_diff:+d}")
+        output_lines.append("")
+
+    if new_failures:
+        output_lines.append(f"New test failures ({len(new_failures)}):")
+        for test in sorted(new_failures):
+            if test in ignore_set:
+                output_lines.append(f"  - {test} (intermittent)")
+            else:
+                output_lines.append(f"  - {test}")
+        output_lines.append("")
+
+    if improvements:
+        output_lines.append(f"Test improvements ({len(improvements)}):")
+        for test in sorted(improvements):
+            output_lines.append(f"  + {test}")
+        output_lines.append("")
+
+    output_text = "\n".join(output_lines)
+    if output_file:
+        with open(output_file, "w") as f:
+            f.write(output_text)
+    else:
+        print(output_text)
+
+    if non_intermittent_new_failures:
+        print(
+            f"ERROR: Found {len(non_intermittent_new_failures)} new non-intermittent test failures"
+        )
+        return 1
+
+    return 0
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Compare GNU diffutils test results")
+    parser.add_argument("current",   help="Current test results JSON file")
+    parser.add_argument("reference", help="Reference test results JSON file")
+    parser.add_argument(
+        "--ignore-file", help="File containing intermittent test names to ignore"
+    )
+    parser.add_argument("--output",  help="Output file for comparison results")
+
+    args = parser.parse_args()
+
+    return compare_results(args.current, args.reference, args.ignore_file, args.output)
+
+
+if __name__ == "__main__":
+    sys.exit(main())