diff --git a/.cargo/config b/.cargo/config
index 35da7a485..a4dc4b423 100644
--- a/.cargo/config
+++ b/.cargo/config
@@ -3,18 +3,11 @@ linker = "x86_64-unknown-redox-gcc"
 
 [target.'cfg(feature = "cargo-clippy")']
 rustflags = [
-  "-Wclippy::use_self",
-  "-Wclippy::needless_pass_by_value",
-  "-Wclippy::semicolon_if_nothing_returned",
-  "-Wclippy::single_char_pattern",
-  "-Wclippy::explicit_iter_loop",
+    "-Wclippy::use_self",
+    "-Wclippy::needless_pass_by_value",
+    "-Wclippy::semicolon_if_nothing_returned",
+    "-Wclippy::single_char_pattern",
+    "-Wclippy::explicit_iter_loop",
+    "-Wclippy::if_not_else",
 ]
 
-[build]
-# See https://github.com/time-rs/time/issues/293#issuecomment-1005002386. The
-# unsoundness here is not in the `time` library, but in the Rust stdlib, and as
-# such it needs to be fixed there.
-rustflags = ["--cfg", "unsound_local_offset"]
-
-[target.'cfg(target_os = "linux")']
-rustflags = ["--cfg", "unsound_local_offset"]
diff --git a/.clippy.toml b/.clippy.toml
index 22fd4be73..bee70857b 100644
--- a/.clippy.toml
+++ b/.clippy.toml
@@ -1 +1,2 @@
 msrv = "1.64.0"
+cognitive-complexity-threshold = 10
diff --git a/.config/nextest.toml b/.config/nextest.toml
new file mode 100644
index 000000000..3ba8bb393
--- /dev/null
+++ b/.config/nextest.toml
@@ -0,0 +1,6 @@
+[profile.ci]
+retries = 2
+status-level = "all"
+final-status-level = "skip"
+failure-output = "immediate-final"
+fail-fast = false
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
deleted file mode 100644
index c29a77873..000000000
--- a/.github/dependabot.yml
+++ /dev/null
@@ -1,12 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "cargo"
-    directory: "/"
-    schedule:
-      interval: weekly
-    open-pull-requests-limit: 10
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: weekly
-    open-pull-requests-limit: 5
diff --git a/.github/workflows/CICD.yml b/.github/workflows/CICD.yml
index cf12ee2d7..b52ea5098 100644
--- a/.github/workflows/CICD.yml
+++ b/.github/workflows/CICD.yml
@@ -1,9 +1,9 @@
 name: CICD
 
-# spell-checker:ignore (abbrev/names) CICD CodeCOV MacOS MinGW MSVC musl
-# spell-checker:ignore (env/flags) Awarnings Ccodegen Coverflow Cpanic Dwarnings RUSTDOCFLAGS RUSTFLAGS Zpanic
-# spell-checker:ignore (jargon) SHAs deps dequote softprops subshell toolchain
-# spell-checker:ignore (people) Peltoche rivy
+# spell-checker:ignore (abbrev/names) CICD CodeCOV MacOS MinGW MSVC musl taiki
+# spell-checker:ignore (env/flags) Awarnings Ccodegen Coverflow Cpanic Dwarnings RUSTDOCFLAGS RUSTFLAGS Zpanic CARGOFLAGS
+# spell-checker:ignore (jargon) SHAs deps dequote softprops subshell toolchain fuzzers
+# spell-checker:ignore (people) Peltoche rivy dtolnay
 # spell-checker:ignore (shell/tools) choco clippy dmake dpkg esac fakeroot fdesc fdescfs gmake grcov halium lcov libssl mkdir popd printf pushd rsync rustc rustfmt rustup shopt utmpdump xargs
 # spell-checker:ignore (misc) aarch alnum armhf bindir busytest coreutils defconfig DESTDIR gecos gnueabihf issuecomment maint multisize nullglob onexitbegin onexitend pell runtest Swatinem tempfile testsuite toybox uutils
 
@@ -37,8 +37,6 @@ jobs:
     ## ToDO: [2021-11-10; rivy] 'Style/deps' needs more informative output and better integration of results into the GHA dashboard
     name: Style/deps
     runs-on: ${{ matrix.job.os }}
-    # env:
-    #   STYLE_FAIL_ON_FAULT: false # overrides workflow default
     strategy:
       fail-fast: false
       matrix:
@@ -50,6 +48,11 @@ jobs:
           - { os: windows-latest , features: feat_os_windows }
     steps:
     - uses: actions/checkout@v3
+    - uses: dtolnay/rust-toolchain@nightly
+    ## note: requires 'nightly' toolchain b/c `cargo-udeps` uses the `rustc` '-Z save-analysis' option
+    ## * ... ref: <https://github.com/est31/cargo-udeps/issues/73>
+    - uses: taiki-e/install-action@cargo-udeps
+    - uses: Swatinem/rust-cache@v2
     - name: Initialize workflow variables
       id: vars
       shell: bash
@@ -67,17 +70,6 @@ jobs:
         CARGO_FEATURES_OPTION='' ;
         if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
         outputs CARGO_FEATURES_OPTION
-    ## note: requires 'nightly' toolchain b/c `cargo-udeps` uses the `rustc` '-Z save-analysis' option
-    ## * ... ref: <https://github.com/est31/cargo-udeps/issues/73>
-    - name: Install `rust` toolchain
-      run: |
-        rustup toolchain install nightly --no-self-update --profile minimal
-        rustup default nightly
-    - uses: Swatinem/rust-cache@v2
-    - name: Install `cargo-udeps`
-      run: cargo install cargo-udeps
-      env:
-        RUSTUP_TOOLCHAIN: stable
     - name: Detect unused dependencies
       shell: bash
       run: |
@@ -93,8 +85,6 @@ jobs:
   style_format:
     name: Style/format
     runs-on: ${{ matrix.job.os }}
-    # env:
-    #   STYLE_FAIL_ON_FAULT: false # overrides workflow default
     strategy:
       fail-fast: false
       matrix:
@@ -102,6 +92,11 @@ jobs:
           - { os: ubuntu-latest , features: feat_os_unix }
     steps:
     - uses: actions/checkout@v3
+    - uses: dtolnay/rust-toolchain@master
+      with:
+        toolchain: stable
+        components: rustfmt
+    - uses: Swatinem/rust-cache@v2
     - name: Initialize workflow variables
       id: vars
       shell: bash
@@ -119,12 +114,6 @@ jobs:
         CARGO_FEATURES_OPTION='' ;
         if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
         outputs CARGO_FEATURES_OPTION
-    - name: Install `rust` toolchain
-      run: |
-        ## Install `rust` toolchain
-        rustup toolchain install stable --no-self-update -c rustfmt --profile minimal
-        rustup default stable
-    - uses: Swatinem/rust-cache@v2
     - name: "`cargo fmt` testing"
       shell: bash
       run: |
@@ -136,11 +125,48 @@ jobs:
         S=$(cargo fmt -- --check) && printf "%s\n" "$S" || { printf "%s\n" "$S" ; printf "%s\n" "$S" | sed -E -n -e "s/^Diff[[:space:]]+in[[:space:]]+${PWD//\//\\/}\/(.*)[[:space:]]+at[[:space:]]+[^0-9]+([0-9]+).*$/::${fault_type} file=\1,line=\2::${fault_prefix}: \`cargo fmt\`: style violation (file:'\1', line:\2; use \`cargo fmt -- \"\1\"\`)/p" ; fault=true ; }
         if [ -n "${{ steps.vars.outputs.FAIL_ON_FAULT }}" ] && [ -n "$fault" ]; then exit 1 ; fi
 
+  fuzz:
+    name: Run the fuzzers
+    runs-on: ubuntu-latest
+    env:
+      RUN_FOR: 60
+    steps:
+    - uses: actions/checkout@v3
+    - uses: dtolnay/rust-toolchain@nightly
+    - name: Install `cargo-fuzz`
+      run: cargo install cargo-fuzz
+    - uses: Swatinem/rust-cache@v2
+    - name: Run fuzz_date for XX seconds
+      shell: bash
+      run: |
+        ## Run it
+        cd fuzz
+        cargo +nightly fuzz run fuzz_date -- -max_total_time=${{ env.RUN_FOR }} -detect_leaks=0
+    - name: Run fuzz_parse_glob for XX seconds
+      shell: bash
+      run: |
+        ## Run it
+        cd fuzz
+        cargo +nightly fuzz run fuzz_parse_glob -- -max_total_time=${{ env.RUN_FOR }} -detect_leaks=0
+    - name: Run fuzz_parse_size for XX seconds
+      shell: bash
+      run: |
+        ## Run it
+        cd fuzz
+        cargo +nightly fuzz run fuzz_parse_size -- -max_total_time=${{ env.RUN_FOR }} -detect_leaks=0
+    - name: Run fuzz_parse_time for XX seconds
+      shell: bash
+      run: |
+        ## Run it
+        cd fuzz
+        cargo +nightly fuzz run fuzz_parse_time -- -max_total_time=${{ env.RUN_FOR }} -detect_leaks=0
+
   style_lint:
     name: Style/lint
     runs-on: ${{ matrix.job.os }}
-    # env:
-    #   STYLE_FAIL_ON_FAULT: false # overrides workflow default
+    env:
+      SCCACHE_GHA_ENABLED: "true"
+      RUSTC_WRAPPER: "sccache"
     strategy:
       fail-fast: false
       matrix:
@@ -150,6 +176,13 @@ jobs:
           - { os: windows-latest , features: feat_os_windows }
     steps:
     - uses: actions/checkout@v3
+    - uses: dtolnay/rust-toolchain@master
+      with:
+        toolchain: stable
+        components: clippy
+    - uses: Swatinem/rust-cache@v2
+    - name: Run sccache-cache
+      uses: mozilla-actions/sccache-action@v0.0.3
     - name: Initialize workflow variables
       id: vars
       shell: bash
@@ -165,7 +198,7 @@ jobs:
         # target-specific options
         # * CARGO_FEATURES_OPTION
         CARGO_FEATURES_OPTION='--all-features' ;
-        if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
+        if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features ${{ matrix.job.features }}' ; fi
         outputs CARGO_FEATURES_OPTION
         # * determine sub-crate utility list
         UTILITY_LIST="$(./util/show-utils.sh ${CARGO_FEATURES_OPTION})"
@@ -179,12 +212,6 @@ jobs:
         case '${{ matrix.job.os }}' in
           macos-latest) brew install coreutils ;; # needed for show-utils.sh
         esac
-    - name: Install `rust` toolchain
-      run: |
-        ## Install `rust` toolchain
-        rustup toolchain install stable --no-self-update -c clippy --profile minimal
-        rustup default stable
-    - uses: Swatinem/rust-cache@v2
     - name: "`cargo clippy` lint testing"
       shell: bash
       run: |
@@ -193,21 +220,18 @@ jobs:
         fault_type="${{ steps.vars.outputs.FAULT_TYPE }}"
         fault_prefix=$(echo "$fault_type" | tr '[:lower:]' '[:upper:]')
         # * convert any warnings to GHA UI annotations; ref: <https://help.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-a-warning-message>
-        S=$(cargo clippy --all-targets ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} ${{ steps.vars.outputs.CARGO_UTILITY_LIST_OPTIONS }} -- -W clippy::manual_string_new -D warnings 2>&1) && printf "%s\n" "$S" || { printf "%s\n" "$S" ; printf "%s" "$S" | sed -E -n -e '/^error:/{' -e "N; s/^error:[[:space:]]+(.*)\\n[[:space:]]+-->[[:space:]]+(.*):([0-9]+):([0-9]+).*$/::${fault_type} file=\2,line=\3,col=\4::${fault_prefix}: \`cargo clippy\`: \1 (file:'\2', line:\3)/p;" -e '}' ; fault=true ; }
+        S=$(cargo clippy --all-targets ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_UTILITY_LIST_OPTIONS }} -- -W clippy::manual_string_new -D warnings 2>&1) && printf "%s\n" "$S" || { printf "%s\n" "$S" ; printf "%s" "$S" | sed -E -n -e '/^error:/{' -e "N; s/^error:[[:space:]]+(.*)\\n[[:space:]]+-->[[:space:]]+(.*):([0-9]+):([0-9]+).*$/::${fault_type} file=\2,line=\3,col=\4::${fault_prefix}: \`cargo clippy\`: \1 (file:'\2', line:\3)/p;" -e '}' ; fault=true ; }
         if [ -n "${{ steps.vars.outputs.FAIL_ON_FAULT }}" ] && [ -n "$fault" ]; then exit 1 ; fi
 
   style_spellcheck:
     name: Style/spelling
     runs-on: ${{ matrix.job.os }}
-    # env:
-    #   STYLE_FAIL_ON_FAULT: false # overrides workflow default
     strategy:
       matrix:
         job:
           - { os: ubuntu-latest , features: feat_os_unix }
     steps:
     - uses: actions/checkout@v3
-    - uses: Swatinem/rust-cache@v2
     - name: Initialize workflow variables
       id: vars
       shell: bash
@@ -247,6 +271,9 @@ jobs:
   doc_warnings:
     name: Documentation/warnings
     runs-on: ${{ matrix.job.os }}
+    env:
+      SCCACHE_GHA_ENABLED: "true"
+      RUSTC_WRAPPER: "sccache"
     strategy:
       fail-fast: false
       matrix:
@@ -259,6 +286,13 @@ jobs:
 #          - { os: windows-latest , features: feat_os_windows }
     steps:
     - uses: actions/checkout@v3
+    - uses: dtolnay/rust-toolchain@master
+      with:
+        toolchain: stable
+        components: clippy
+    - uses: Swatinem/rust-cache@v2
+    - name: Run sccache-cache
+      uses: mozilla-actions/sccache-action@v0.0.3
     - name: Initialize workflow variables
       id: vars
       shell: bash
@@ -274,34 +308,45 @@ jobs:
         # target-specific options
         # * CARGO_FEATURES_OPTION
         CARGO_FEATURES_OPTION='--all-features' ;
-        if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
+        if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features ${{ matrix.job.features }}' ; fi
         outputs CARGO_FEATURES_OPTION
         # * determine sub-crate utility list
         UTILITY_LIST="$(./util/show-utils.sh ${CARGO_FEATURES_OPTION})"
         echo UTILITY_LIST=${UTILITY_LIST}
         CARGO_UTILITY_LIST_OPTIONS="$(for u in ${UTILITY_LIST}; do echo -n "-puu_${u} "; done;)"
         outputs CARGO_UTILITY_LIST_OPTIONS
-    - name: Install `rust` toolchain
-      run: |
-        ## Install `rust` toolchain
-        rustup toolchain install stable --no-self-update -c clippy --profile minimal
-        rustup default stable
-    - uses: Swatinem/rust-cache@v2
     - name: "`cargo doc` with warnings"
       shell: bash
       run: |
         RUSTDOCFLAGS="-Dwarnings" cargo doc  ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} --no-deps --workspace --document-private-items
-
+    - uses: DavidAnson/markdownlint-cli2-action@v10
+      with:
+        command: fix
+        globs: |
+          *.md
+          docs/src/*.md
+          src/uu/*/*.md
 
   min_version:
     name: MinRustV # Minimum supported rust version (aka, MinSRV or MSRV)
     runs-on: ${{ matrix.job.os }}
+    env:
+      SCCACHE_GHA_ENABLED: "true"
+      RUSTC_WRAPPER: "sccache"
     strategy:
       matrix:
         job:
           - { os: ubuntu-latest , features: feat_os_unix }
     steps:
     - uses: actions/checkout@v3
+    - uses: dtolnay/rust-toolchain@master
+      with:
+        toolchain: ${{ env.RUST_MIN_SRV }}
+        components: rustfmt
+    - uses: taiki-e/install-action@nextest
+    - uses: Swatinem/rust-cache@v2
+    - name: Run sccache-cache
+      uses: mozilla-actions/sccache-action@v0.0.3
     - name: Initialize workflow variables
       id: vars
       shell: bash
@@ -313,12 +358,6 @@ jobs:
         unset CARGO_FEATURES_OPTION
         if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
         outputs CARGO_FEATURES_OPTION
-    - name: Install `rust` toolchain (v${{ env.RUST_MIN_SRV }})
-      run: |
-        ## Install `rust` toolchain (v${{ env.RUST_MIN_SRV }})
-        rustup toolchain install --no-self-update ${{ env.RUST_MIN_SRV }} --profile minimal
-        rustup default ${{ env.RUST_MIN_SRV }}
-    - uses: Swatinem/rust-cache@v2
     - name: Confirm MinSRV compatible 'Cargo.lock'
       shell: bash
       run: |
@@ -353,9 +392,9 @@ jobs:
         RUSTUP_TOOLCHAIN=stable cargo fetch --locked --quiet
         RUSTUP_TOOLCHAIN=stable cargo tree --all --locked --no-dev-dependencies --no-indent ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} | grep -vE "$PWD" | sort --unique
     - name: Test
-      run: cargo test -v ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} -p uucore -p coreutils
+      run: cargo nextest run --hide-progress-bar --profile ci ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} -p uucore -p coreutils
       env:
-        RUSTFLAGS: "-Awarnings --cfg unsound_local_offset"
+        RUSTFLAGS: "-Awarnings"
         RUST_BACKTRACE: "1"
 
   deps:
@@ -368,11 +407,7 @@ jobs:
           - { os: ubuntu-latest , features: feat_os_unix }
     steps:
     - uses: actions/checkout@v3
-    - name: Install `rust` toolchain
-      run: |
-        ## Install `rust` toolchain
-        rustup toolchain install stable --no-self-update --profile minimal
-        rustup default stable
+    - uses: dtolnay/rust-toolchain@stable
     - uses: Swatinem/rust-cache@v2
     - name: "`cargo update` testing"
       shell: bash
@@ -385,6 +420,9 @@ jobs:
     name: Build/Makefile
     needs: [ min_version, deps ]
     runs-on: ${{ matrix.job.os }}
+    env:
+      SCCACHE_GHA_ENABLED: "true"
+      RUSTC_WRAPPER: "sccache"
     strategy:
       fail-fast: false
       matrix:
@@ -392,29 +430,39 @@ jobs:
           - { os: ubuntu-latest , features: feat_os_unix }
     steps:
     - uses: actions/checkout@v3
-    - name: Install `rust` toolchain
-      run: |
-        ## Install `rust` toolchain
-        rustup toolchain install stable --no-self-update --profile minimal
-        rustup default stable
+    - uses: dtolnay/rust-toolchain@stable
+    - uses: taiki-e/install-action@nextest
     - uses: Swatinem/rust-cache@v2
+    - name: Run sccache-cache
+      uses: mozilla-actions/sccache-action@v0.0.3
     - name: "`make build`"
       shell: bash
       run: |
         make build
-    - name: "`make test`"
+    - name: "`make nextest`"
       shell: bash
-      run: |
-        make test
+      run: make nextest CARGOFLAGS="--profile ci --hide-progress-bar"
+      env:
+        RUST_BACKTRACE: "1"
+    - name: "`make install`"
+      shell: bash
+      run: |
+        DESTDIR=/tmp/ make PROFILE=release install
+        # Check that the manpage is present
+        test -f /tmp/usr/local/share/man/man1/whoami.1
+        # Check that the completion is present
+        test -f /tmp/usr/local/share/zsh/site-functions/_install
       env:
         RUST_BACKTRACE: "1"
-
 
   build_rust_stable:
     name: Build/stable
     needs: [ min_version, deps ]
     runs-on: ${{ matrix.job.os }}
     timeout-minutes: 90
+    env:
+      SCCACHE_GHA_ENABLED: "true"
+      RUSTC_WRAPPER: "sccache"
     strategy:
       fail-fast: false
       matrix:
@@ -424,14 +472,13 @@ jobs:
           - { os: windows-latest , features: feat_os_windows }
     steps:
     - uses: actions/checkout@v3
-    - name: Install `rust` toolchain
-      run: |
-        ## Install `rust` toolchain
-        rustup toolchain install stable --no-self-update --profile minimal
-        rustup default stable
+    - uses: dtolnay/rust-toolchain@stable
+    - uses: taiki-e/install-action@nextest
     - uses: Swatinem/rust-cache@v2
+    - name: Run sccache-cache
+      uses: mozilla-actions/sccache-action@v0.0.3
     - name: Test
-      run: cargo test ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
+      run: cargo nextest run --hide-progress-bar --profile ci ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
       env:
         RUST_BACKTRACE: "1"
 
@@ -440,6 +487,9 @@ jobs:
     needs: [ min_version, deps ]
     runs-on: ${{ matrix.job.os }}
     timeout-minutes: 90
+    env:
+      SCCACHE_GHA_ENABLED: "true"
+      RUSTC_WRAPPER: "sccache"
     strategy:
       fail-fast: false
       matrix:
@@ -449,14 +499,13 @@ jobs:
           - { os: windows-latest , features: feat_os_windows }
     steps:
     - uses: actions/checkout@v3
-    - name: Install `rust` toolchain
-      run: |
-        ## Install `rust` toolchain
-        rustup toolchain install nightly --no-self-update --profile minimal
-        rustup default nightly
+    - uses: dtolnay/rust-toolchain@nightly
+    - uses: taiki-e/install-action@nextest
     - uses: Swatinem/rust-cache@v2
+    - name: Run sccache-cache
+      uses: mozilla-actions/sccache-action@v0.0.3
     - name: Test
-      run: cargo test ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
+      run: cargo nextest run --hide-progress-bar --profile ci ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
       env:
         RUST_BACKTRACE: "1"
 
@@ -464,6 +513,9 @@ jobs:
     name: Binary sizes
     needs: [ min_version, deps ]
     runs-on: ${{ matrix.job.os }}
+    env:
+      SCCACHE_GHA_ENABLED: "true"
+      RUSTC_WRAPPER: "sccache"
     strategy:
       fail-fast: false
       matrix:
@@ -471,18 +523,16 @@ jobs:
           - { os: ubuntu-latest , features: feat_os_unix }
     steps:
     - uses: actions/checkout@v3
+    - uses: dtolnay/rust-toolchain@stable
+    - uses: Swatinem/rust-cache@v2
+    - name: Run sccache-cache
+      uses: mozilla-actions/sccache-action@v0.0.3
     - name: Install dependencies
       shell: bash
       run: |
         ## Install dependencies
         sudo apt-get update
         sudo apt-get install jq
-    - name: Install `rust` toolchain
-      run: |
-        ## Install `rust` toolchain
-        rustup toolchain install stable --no-self-update --profile minimal
-        rustup default stable
-    - uses: Swatinem/rust-cache@v2
     - name: "`make install`"
       shell: bash
       run: |
@@ -495,15 +545,70 @@ jobs:
       shell: bash
       run: |
         ## Compute uutil release sizes
-        SIZE=$(du -s target/size-release/usr/local/bin/|awk '{print $1}')
-        SIZE_MULTI=$(du -s target/size-multi-release/usr/local/bin/|awk '{print $1}')
+        DATE=$(date --rfc-email)
+        find target/size-release/usr/local/bin -type f -printf '%f\0' | sort -z |
+          while IFS= read -r -d '' name; do
+            size=$(du -s target/size-release/usr/local/bin/$name | awk '{print $1}')
+            echo "\"$name\""
+            echo "$size"
+          done | \
+            jq -n \
+                --arg date "$DATE" \
+                --arg sha "$GITHUB_SHA" \
+                'reduce inputs as $name ({}; . + { ($name): input }) | { ($date): {sha: $sha, sizes: map_values(.)} }' > individual-size-result.json
+        SIZE=$(cat individual-size-result.json | jq '[.[] | .sizes | .[]] | reduce .[] as $num (0; . + $num)')
+        SIZE_MULTI=$(du -s target/size-multi-release/usr/local/bin/coreutils | awk '{print $1}')
         jq -n \
-              --arg date "$(date --rfc-email)" \
+              --arg date "$DATE" \
               --arg sha "$GITHUB_SHA" \
               --arg size "$SIZE" \
               --arg multisize "$SIZE_MULTI" \
               '{($date): { sha: $sha, size: $size, multisize: $multisize, }}' > size-result.json
-    - uses: actions/upload-artifact@v3
+    - name: Download the previous individual size result
+      uses: dawidd6/action-download-artifact@v2
+      with:
+        workflow: CICD.yml
+        name: individual-size-result
+        repo: uutils/coreutils
+        path: dl
+    - name: Download the previous size result
+      uses: dawidd6/action-download-artifact@v2
+      with:
+        workflow: CICD.yml
+        name: size-result
+        repo: uutils/coreutils
+        path: dl
+    - name: Check uutil release sizes
+      shell: bash
+      run: |
+        check() {
+          # Warn if the size increases by more than 5%
+          threshold='1.05'
+          ratio=$(jq -n "$2 / $3")
+          echo "$1: size=$2, previous_size=$3, ratio=$ratio, threshold=$threshold"
+          if [[ "$(jq -n "$ratio > $threshold")" == 'true' ]]; then
+            echo "::warning file=$4::Size of $1 increases by more than 5%"
+          fi
+        }
+        ## Check individual size result
+        while read -r name previous_size; do
+          size=$(cat individual-size-result.json | jq -r ".[] | .sizes | .\"$name\"")
+          check "\`$name\` binary" "$size" "$previous_size" 'individual-size-result.json'
+        done < <(cat dl/individual-size-result.json | jq -r '.[] | .sizes | to_entries[] | "\(.key) \(.value)"')
+        ## Check size result
+        size=$(cat size-result.json | jq -r '.[] | .size')
+        previous_size=$(cat dl/size-result.json | jq -r '.[] | .size')
+        check 'multiple binaries' "$size" "$previous_size" 'size-result.json'
+        multisize=$(cat size-result.json | jq -r '.[] | .multisize')
+        previous_multisize=$(cat dl/size-result.json | jq -r '.[] | .multisize')
+        check 'multicall binary' "$multisize" "$previous_multisize" 'size-result.json'
+    - name: Upload the individual size result
+      uses: actions/upload-artifact@v3
+      with:
+        name: individual-size-result
+        path: individual-size-result.json
+    - name: Upload the size result
+      uses: actions/upload-artifact@v3
       with:
         name: size-result
         path: size-result.json
@@ -518,6 +623,8 @@ jobs:
     timeout-minutes: 90
     env:
       DOCKER_OPTS: '--volume /etc/passwd:/etc/passwd --volume /etc/group:/etc/group'
+      SCCACHE_GHA_ENABLED: "true"
+      RUSTC_WRAPPER: "sccache"
     strategy:
       fail-fast: false
       matrix:
@@ -525,25 +632,26 @@ jobs:
           # { os , target , cargo-options , features , use-cross , toolchain }
           - { os: ubuntu-latest  , target: arm-unknown-linux-gnueabihf, features: feat_os_unix_gnueabihf, use-cross: use-cross, }
           - { os: ubuntu-latest  , target: aarch64-unknown-linux-gnu   , features: feat_os_unix_gnueabihf , use-cross: use-cross }
-          - { os: ubuntu-latest  , target: x86_64-unknown-linux-gnu    , features: feat_os_unix           , use-cross: use-cross }
           # - { os: ubuntu-latest  , target: x86_64-unknown-linux-gnu    , features: feat_selinux           , use-cross: use-cross }
-          # - { os: ubuntu-18.04   , target: i586-unknown-linux-gnu      , features: feat_os_unix           , use-cross: use-cross } ## note: older windows platform; not required, dev-FYI only
-          # - { os: ubuntu-18.04   , target: i586-unknown-linux-gnu      , features: feat_os_unix           , use-cross: use-cross } ## note: older windows platform; not required, dev-FYI only
           - { os: ubuntu-latest   , target: i686-unknown-linux-gnu      , features: feat_os_unix           , use-cross: use-cross }
           - { os: ubuntu-latest   , target: i686-unknown-linux-musl     , features: feat_os_unix_musl      , use-cross: use-cross }
           - { os: ubuntu-latest   , target: x86_64-unknown-linux-gnu    , features: feat_os_unix           , use-cross: use-cross }
           - { os: ubuntu-latest   , target: x86_64-unknown-linux-musl   , features: feat_os_unix_musl      , use-cross: use-cross }
-          # Commented until https://github.com/uutils/coreutils/issues/3210 is fixed
-          #- { os: ubuntu-18.04   , target: i686-unknown-linux-gnu      , features: feat_os_unix           , use-cross: use-cross }
-          #- { os: ubuntu-18.04   , target: i686-unknown-linux-musl     , features: feat_os_unix_musl      , use-cross: use-cross }
-          #- { os: ubuntu-18.04   , target: x86_64-unknown-linux-gnu    , features: feat_os_unix           , use-cross: use-cross }
-          #- { os: ubuntu-18.04   , target: x86_64-unknown-linux-musl   , features: feat_os_unix_musl      , use-cross: use-cross }
           - { os: macos-latest   , target: x86_64-apple-darwin         , features: feat_os_macos }
           - { os: windows-latest , target: i686-pc-windows-msvc        , features: feat_os_windows }
           - { os: windows-latest , target: x86_64-pc-windows-gnu       , features: feat_os_windows } ## note: requires rust >= 1.43.0 to link correctly
           - { os: windows-latest , target: x86_64-pc-windows-msvc      , features: feat_os_windows }
     steps:
     - uses: actions/checkout@v3
+    - uses: dtolnay/rust-toolchain@master
+      with:
+        toolchain: ${{ env.RUST_MIN_SRV }}
+        targets: ${{ matrix.job.target }}
+    - uses: Swatinem/rust-cache@v2
+      with:
+        key: "${{ matrix.job.os }}_${{ matrix.job.target }}"
+    - name: Run sccache-cache
+      uses: mozilla-actions/sccache-action@v0.0.3
     - name: Initialize workflow variables
       id: vars
       shell: bash
@@ -619,8 +727,7 @@ jobs:
         outputs CARGO_CMD
         # ** pass needed environment into `cross` container (iff `cross` not already configured via "Cross.toml")
         if [ "${CARGO_CMD}" = 'cross' ] && [ ! -e "Cross.toml" ] ; then
-          cargo install --version 0.2.1 cross
-          printf "[build.env]\npassthrough = [\"CI\", \"RUST_BACKTRACE\"]\n" > Cross.toml
+          printf "[build.env]\npassthrough = [\"CI\", \"RUST_BACKTRACE\", \"CARGO_TERM_COLOR\"]\n" > Cross.toml
         fi
         # * test only library and/or binaries for arm-type targets
         unset CARGO_TEST_OPTIONS ; case '${{ matrix.job.target }}' in aarch64-* | arm-*) CARGO_TEST_OPTIONS="--bins" ;; esac;
@@ -633,6 +740,10 @@ jobs:
           *-pc-windows-msvc) STRIP="" ;;
         esac;
         outputs STRIP
+    - uses: taiki-e/install-action@v2
+      if: steps.vars.outputs.CARGO_CMD == 'cross'
+      with:
+        tool: cross@0.2.1
     - name: Create all needed build/work directories
       shell: bash
       run: |
@@ -666,14 +777,6 @@ jobs:
             echo "foo" > /home/runner/.plan
             ;;
         esac
-    - name: rust toolchain ~ install
-      run: |
-        ## rust toolchain ~ install
-        rustup toolchain install --no-self-update ${{ env.RUST_MIN_SRV }} -t ${{ matrix.job.target }} --profile minimal
-        rustup default ${{ env.RUST_MIN_SRV }}
-    - uses: Swatinem/rust-cache@v2
-      with:
-        key: ${{ matrix.job.os }}-${{ matrix.job.target }}
     - name: Initialize toolchain-dependent workflow variables
       id: dep_vars
       shell: bash
@@ -783,6 +886,9 @@ jobs:
     name: Tests/BusyBox test suite
     needs: [ min_version, deps ]
     runs-on: ${{ matrix.job.os }}
+    env:
+      SCCACHE_GHA_ENABLED: "true"
+      RUSTC_WRAPPER: "sccache"
     strategy:
       fail-fast: false
       matrix:
@@ -797,6 +903,8 @@ jobs:
         echo "TEST_SUMMARY_FILE=busybox-result.json" >> $GITHUB_OUTPUT
     - uses: actions/checkout@v3
     - uses: Swatinem/rust-cache@v2
+    - name: Run sccache-cache
+      uses: mozilla-actions/sccache-action@v0.0.3
     - name: Install/setup prerequisites
       shell: bash
       run: |
@@ -856,6 +964,9 @@ jobs:
     name: Tests/Toybox test suite
     needs: [ min_version, deps ]
     runs-on: ${{ matrix.job.os }}
+    env:
+      SCCACHE_GHA_ENABLED: "true"
+      RUSTC_WRAPPER: "sccache"
     strategy:
       fail-fast: false
       matrix:
@@ -871,12 +982,13 @@ jobs:
         TEST_SUMMARY_FILE="toybox-result.json"
         outputs TEST_SUMMARY_FILE
     - uses: actions/checkout@v3
+    - uses: dtolnay/rust-toolchain@master
+      with:
+        toolchain: ${{ env.RUST_MIN_SRV }}
+        components: rustfmt
     - uses: Swatinem/rust-cache@v2
-    - name: rust toolchain ~ install
-      run: |
-        ## rust toolchain ~ install
-        rustup toolchain install --no-self-update ${{ env.RUST_MIN_SRV }} --profile minimal
-        rustup default ${{ env.RUST_MIN_SRV }}
+    - name: Run sccache-cache
+      uses: mozilla-actions/sccache-action@v0.0.3
     - name: Build coreutils as multiple binaries
       shell: bash
       run: |
@@ -936,150 +1048,40 @@ jobs:
         name: toybox-result.json
         path: ${{ steps.vars.outputs.TEST_SUMMARY_FILE }}
 
-  test_android:
-    name: Test Android builds
-    needs: [ min_version, deps ]
-    runs-on: macos-latest
-    timeout-minutes: 90
-    strategy:
-      fail-fast: false
-      matrix:
-        api-level: [28]
-        target: [default]
-        arch: [x86] # , arm64-v8a
-    env:
-      TERMUX: v0.118.0
+  toml_format:
+    runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
-    - name: AVD cache
-      uses: actions/cache@v3
-      id: avd-cache
-      with:
-        path: |
-          ~/.android/avd/*
-          ~/.android/avd/*/snapshots/*
-          ~/.android/adb*
-        key: avd-${{ matrix.api-level }}-${{ matrix.arch }}+termux-${{ env.TERMUX }}
-    - name: Create and cache emulator image
-      if: steps.avd-cache.outputs.cache-hit != 'true'
-      uses: reactivecircus/android-emulator-runner@v2
-      with:
-        api-level: ${{ matrix.api-level }}
-        target: ${{ matrix.target }}
-        arch: ${{ matrix.arch }}
-        ram-size: 2048M
-        disk-size: 5120M
-        force-avd-creation: true
-        emulator-options: -no-snapshot-load -noaudio -no-boot-anim -camera-back none
-        script: |
-          wget https://github.com/termux/termux-app/releases/download/${{ env.TERMUX }}/termux-app_${{ env.TERMUX }}+github-debug_${{ matrix.arch }}.apk
-          util/android-commands.sh snapshot termux-app_${{ env.TERMUX }}+github-debug_${{ matrix.arch }}.apk
-          adb -s emulator-5554 emu avd snapshot save ${{ matrix.api-level }}-${{ matrix.arch }}+termux-${{ env.TERMUX }}
-          echo "Emulator image created."
-          pkill -9 qemu-system-x86_64
-    - name: Build and Test on Android
-      uses: reactivecircus/android-emulator-runner@v2
-      with:
-        api-level: ${{ matrix.api-level }}
-        target: ${{ matrix.target }}
-        arch: ${{ matrix.arch }}
-        ram-size: 2048M
-        disk-size: 5120M
-        force-avd-creation: false
-        emulator-options: -no-snapshot-save -gpu swiftshader_indirect -noaudio -no-boot-anim -camera-back none -snapshot ${{ matrix.api-level }}-${{ matrix.arch }}+termux-${{ env.TERMUX }}
-        script: |
-          util/android-commands.sh sync
-          util/android-commands.sh build
-          util/android-commands.sh tests
+      - name: Clone repository
+        uses: actions/checkout@v3
 
-  test_freebsd:
-    name: Tests/FreeBSD test suite
-    needs: [ min_version, deps ]
-    runs-on: ${{ matrix.job.os }}
-    timeout-minutes: 90
-    strategy:
-      fail-fast: false
-      matrix:
-        job:
-          - { os: macos-12 , features: unix } ## GHA MacOS-11.0 VM won't have VirtualBox; refs: <https://github.com/actions/virtual-environments/issues/4060> , <https://github.com/actions/virtual-environments/pull/4010>
-    env:
-      mem: 4096
-    steps:
-    - uses: actions/checkout@v3
-    - uses: Swatinem/rust-cache@v2
-    - name: Prepare, build and test
-      ## spell-checker:ignore (ToDO) sshfs usesh vmactions
-      uses: vmactions/freebsd-vm@v0.3.0
-      with:
-        usesh: true
-        # sync: sshfs
-        prepare: pkg install -y curl gmake sudo
-        run: |
-          ## Prepare, build, and test
-          # implementation modelled after ref: <https://github.com/rust-lang/rustup/pull/2783>
-          # * NOTE: All steps need to be run in this block, otherwise, we are operating back on the mac host
-          set -e
-          #
-          # We need a file-descriptor file system to test test_ls::test_ls_io_errors
-          mount -t fdescfs fdesc /dev/fd
-          #
-          TEST_USER=tester
-          REPO_NAME=${GITHUB_WORKSPACE##*/}
-          WORKSPACE_PARENT="/Users/runner/work/${REPO_NAME}"
-          WORKSPACE="${WORKSPACE_PARENT}/${REPO_NAME}"
-          #
-          pw adduser -n ${TEST_USER} -d /root/ -g wheel -c "Coreutils user to build" -w random
-          # chown -R ${TEST_USER}:wheel /root/ "${WORKSPACE_PARENT}"/
-          chown -R ${TEST_USER}:wheel /root/ "/Users/runner/work/${REPO_NAME}"/
-          whoami
-          #
-          # Further work needs to be done in a sudo as we are changing users
-          sudo -i -u ${TEST_USER} sh << EOF
-          set -e
-          whoami
-          curl https://sh.rustup.rs -sSf --output rustup.sh
-          sh rustup.sh -y --profile=minimal
-          . $HOME/.cargo/env
-          ## Info
-          # environment
-          echo "## environment"
-          echo "CI='${CI}'"
-          echo "REPO_NAME='${REPO_NAME}'"
-          echo "TEST_USER='${TEST_USER}'"
-          echo "WORKSPACE_PARENT='${WORKSPACE_PARENT}'"
-          echo "WORKSPACE='${WORKSPACE}'"
-          env | sort
-          # tooling info
-          echo "## tooling info"
-          cargo -V
-          rustc -V
-          #
-          # To ensure that files are cleaned up, we don't want to exit on error
-          set +e
-          cd "${WORKSPACE}"
-          unset FAULT
-          cargo build || FAULT=1
-          export RUST_BACKTRACE=1
-          if (test -z "\$FAULT"); then cargo test --features '${{ matrix.job.features }}' || FAULT=1 ; fi
-          if (test -z "\$FAULT"); then cargo test --all-features -p uucore || FAULT=1 ; fi
-          # Clean to avoid to rsync back the files
-          cargo clean
-          if (test -n "\$FAULT"); then exit 1 ; fi
-          EOF
+      - name: Check
+        run: npx --yes @taplo/cli fmt --check
 
   coverage:
     name: Code Coverage
     runs-on: ${{ matrix.job.os }}
     timeout-minutes: 90
+    env:
+      SCCACHE_GHA_ENABLED: "true"
+      RUSTC_WRAPPER: "sccache"
     strategy:
       fail-fast: false
       matrix:
         job:
-          - { os: ubuntu-latest  , features: unix }
-          - { os: macos-latest   , features: macos }
-          - { os: windows-latest , features: windows }
+          - { os: ubuntu-latest  , features: unix, toolchain: nightly }
+          - { os: macos-latest   , features: macos, toolchain: nightly }
+          - { os: windows-latest , features: windows, toolchain: nightly-x86_64-pc-windows-gnu }
     steps:
     - uses: actions/checkout@v3
+    - uses: dtolnay/rust-toolchain@master
+      with:
+        toolchain: ${{ matrix.job.toolchain }}
+        components: rustfmt
+    - uses: taiki-e/install-action@nextest
+    - uses: taiki-e/install-action@grcov
+    - uses: Swatinem/rust-cache@v2
+    - name: Run sccache-cache
+      uses: mozilla-actions/sccache-action@v0.0.3
     # - name: Reattach HEAD ## may be needed for accurate code coverage info
     #   run: git checkout ${{ github.head_ref }}
     - name: Initialize workflow variables
@@ -1128,12 +1130,6 @@ jobs:
             echo "foo" > /home/runner/.plan
             ;;
         esac
-    - name: rust toolchain ~ install
-      run: |
-        ## rust toolchain ~ install
-        rustup toolchain install ${{ steps.vars.outputs.TOOLCHAIN }} --no-self-update --profile minimal
-        rustup default ${{ steps.vars.outputs.TOOLCHAIN }}
-    - uses: Swatinem/rust-cache@v2
     - name: Initialize toolchain-dependent workflow variables
       id: dep_vars
       shell: bash
@@ -1145,35 +1141,29 @@ jobs:
         CARGO_UTILITY_LIST_OPTIONS="$(for u in ${UTILITY_LIST}; do echo -n "-puu_${u} "; done;)"
         outputs CARGO_UTILITY_LIST_OPTIONS
     - name: Test uucore
-      run: cargo test --no-fail-fast -p uucore
+      run: cargo nextest run --profile ci --hide-progress-bar -p uucore
       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"
         RUSTDOCFLAGS: "-Cpanic=abort"
         RUST_BACKTRACE: "1"
         # RUSTUP_TOOLCHAIN: ${{ steps.vars.outputs.TOOLCHAIN }}
     - name: Test
-      run: cargo test ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} --no-fail-fast
+      run: cargo nextest run --profile ci --hide-progress-bar ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
       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"
         RUSTDOCFLAGS: "-Cpanic=abort"
         RUST_BACKTRACE: "1"
         # RUSTUP_TOOLCHAIN: ${{ steps.vars.outputs.TOOLCHAIN }}
     - name: Test individual utilities
-      run: cargo test --no-fail-fast ${{ steps.dep_vars.outputs.CARGO_UTILITY_LIST_OPTIONS }}
+      run: cargo nextest run --profile ci --hide-progress-bar ${{ steps.dep_vars.outputs.CARGO_UTILITY_LIST_OPTIONS }}
       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"
         RUSTDOCFLAGS: "-Cpanic=abort"
         RUST_BACKTRACE: "1"
         # RUSTUP_TOOLCHAIN: ${{ steps.vars.outputs.TOOLCHAIN }}
-    - name: "`grcov` ~ install"
-      id: build_grcov
-      run: cargo install grcov
     - name: Generate coverage data (via `grcov`)
       id: coverage
       shell: bash
@@ -1199,3 +1189,4 @@ jobs:
         flags: ${{ steps.vars.outputs.CODECOV_FLAGS }}
         name: codecov-umbrella
         fail_ci_if_error: false
+
diff --git a/.github/workflows/FixPR.yml b/.github/workflows/FixPR.yml
index 52561fb36..e1729b173 100644
--- a/.github/workflows/FixPR.yml
+++ b/.github/workflows/FixPR.yml
@@ -1,6 +1,6 @@
 name: FixPR
 
-# spell-checker:ignore Swatinem
+# spell-checker:ignore Swatinem dtolnay
 
 # Trigger automated fixes for PRs being merged (with associated commits)
 
@@ -36,11 +36,7 @@ jobs:
         # surface MSRV from CICD workflow
         RUST_MIN_SRV=$(grep -P "^\s+RUST_MIN_SRV:" .github/workflows/CICD.yml | grep -Po "(?<=\x22)\d+[.]\d+(?:[.]\d+)?(?=\x22)" )
         outputs RUST_MIN_SRV
-    - name: Install `rust` toolchain (v${{ steps.vars.outputs.RUST_MIN_SRV }})
-      run: |
-        ## Install `rust` toolchain (v${{ steps.vars.outputs.RUST_MIN_SRV }})
-        rustup toolchain install ${{ steps.vars.outputs.RUST_MIN_SRV }} --profile minimal
-        rustup default ${{ steps.vars.outputs.RUST_MIN_SRV }}
+    - uses: dtolnay/rust-toolchain@${{ steps.vars.outputs.RUST_MIN_SRV }}
     - uses: Swatinem/rust-cache@v2
     - name: Ensure updated 'Cargo.lock'
       shell: bash
@@ -101,12 +97,10 @@ jobs:
         CARGO_FEATURES_OPTION='' ;
         if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
         outputs CARGO_FEATURES_OPTION
-    - name: Install `rust` toolchain
-      run: |
-        ## Install `rust` toolchain
-        rm -f "${HOME}/.cargo/bin/"{rustfmt,cargo-fmt}
-        rustup toolchain install stable -c rustfmt --profile minimal
-        rustup default stable
+    - uses: dtolnay/rust-toolchain@master
+      with:
+        toolchain: stable
+        components: rustfmt
     - uses: Swatinem/rust-cache@v2
     - name: "`cargo fmt`"
       shell: bash
diff --git a/.github/workflows/GnuTests.yml b/.github/workflows/GnuTests.yml
index fd2d66835..372bf0717 100644
--- a/.github/workflows/GnuTests.yml
+++ b/.github/workflows/GnuTests.yml
@@ -1,10 +1,10 @@
 name: GnuTests
 
-# spell-checker:ignore (abbrev/names) CodeCov gnulib GnuTests
+# spell-checker:ignore (abbrev/names) CodeCov gnulib GnuTests Swatinem
 # spell-checker:ignore (jargon) submodules
-# spell-checker:ignore (libs/utils) autopoint chksum gperf lcov libexpect pyinotify shopt texinfo valgrind
+# spell-checker:ignore (libs/utils) autopoint chksum gperf lcov libexpect pyinotify shopt texinfo valgrind libattr libcap taiki-e
 # spell-checker:ignore (options) Ccodegen Coverflow Cpanic Zpanic
-# spell-checker:ignore (people) Dawid Dziurla * dawidd
+# spell-checker:ignore (people) Dawid Dziurla * dawidd dtolnay
 # spell-checker:ignore (vars) FILESET SUBDIRS XPASS
 
 # * note: to run a single test => `REPO/util/run-gnu-test.sh PATH/TO/TEST/SCRIPT`
@@ -42,7 +42,7 @@ jobs:
         outputs path_GNU path_GNU_tests path_reference path_UUTILS
         #
         repo_default_branch="${{ github.event.repository.default_branch }}"
-        repo_GNU_ref="v9.1"
+        repo_GNU_ref="v9.3"
         repo_reference_branch="${{ github.event.repository.default_branch }}"
         outputs repo_default_branch repo_GNU_ref repo_reference_branch
         #
@@ -58,6 +58,13 @@ jobs:
       uses: actions/checkout@v3
       with:
         path: '${{ steps.vars.outputs.path_UUTILS }}'
+    - uses: dtolnay/rust-toolchain@master
+      with:
+        toolchain: stable
+        components: rustfmt
+    - uses: Swatinem/rust-cache@v2
+      with:
+        workspaces: "./${{ steps.vars.outputs.path_UUTILS }} -> target"
     - name: Checkout code (GNU coreutils)
       uses: actions/checkout@v3
       with:
@@ -75,18 +82,12 @@ jobs:
         # workflow_conclusion: success ## (default); * but, if commit with failed GnuTests is merged into the default branch, future commits will all show regression errors in GnuTests CI until o/w fixed
         workflow_conclusion: completed ## continually recalibrates to last commit of default branch with a successful GnuTests (ie, "self-heals" from GnuTest regressions, but needs more supervision for/of regressions)
         path: "${{ steps.vars.outputs.path_reference }}"
-    - name: Install `rust` toolchain
-      run: |
-        ## Install `rust` toolchain
-        rm -f "${HOME}/.cargo/bin/"{rustfmt,cargo-fmt}
-        rustup toolchain install stable -c rustfmt --profile minimal
-        rustup default stable
     - name: Install dependencies
       shell: bash
       run: |
         ## Install dependencies
         sudo apt-get update
-        sudo apt-get install autoconf autopoint bison texinfo gperf gcc g++ gdb python3-pyinotify jq valgrind libexpect-perl
+        sudo apt-get install -y autoconf autopoint bison texinfo gperf gcc g++ gdb python3-pyinotify jq valgrind libexpect-perl libacl1-dev libattr1-dev libcap-dev
     - name: Add various locales
       shell: bash
       run: |
@@ -201,9 +202,10 @@ jobs:
         REF_LOG_FILE='${{ steps.vars.outputs.path_reference }}/test-logs/test-suite.log'
         REF_SUMMARY_FILE='${{ steps.vars.outputs.path_reference }}/test-summary/gnu-result.json'
         REPO_DEFAULT_BRANCH='${{ steps.vars.outputs.repo_default_branch }}'
+        path_UUTILS='${{ steps.vars.outputs.path_UUTILS }}'
         # https://github.com/uutils/coreutils/issues/4294
         # https://github.com/uutils/coreutils/issues/4295
-        IGNORE_INTERMITTENT='tests/tail-2/inotify-dir-recreate tests/misc/timeout tests/rm/rm1'
+        IGNORE_INTERMITTENT='${path_UUTILS}/.github/workflows/ignore-intermittent.txt'
 
         mkdir -p ${{ steps.vars.outputs.path_reference }}
 
@@ -226,9 +228,17 @@ jobs:
           for LINE in ${REF_FAILING}
           do
             if ! grep -Fxq ${LINE}<<<"${NEW_FAILING}"; then
-              MSG="Congrats! The gnu test ${LINE} is no longer failing!"
-              echo "::warning ::$MSG"
-              echo $MSG >> ${COMMENT_LOG}
+              if ! grep ${LINE} ${IGNORE_INTERMITTENT}
+              then
+                MSG="Congrats! The gnu test ${LINE} is no longer failing!"
+                echo "::warning ::$MSG"
+                echo $MSG >> ${COMMENT_LOG}
+              else
+                MSG="Skipping an intermittent issue ${LINE}"
+                echo "::warning ::$MSG"
+                echo $MSG >> ${COMMENT_LOG}
+                echo ""
+              fi
             fi
           done
           for LINE in ${NEW_FAILING}
@@ -305,19 +315,21 @@ jobs:
       with:
         repository: 'coreutils/coreutils'
         path: 'gnu'
-        ref: 'v9.1'
+        ref: 'v9.3'
         submodules: recursive
-    - name: Install `rust` toolchain
-      run: |
-        ## Install `rust` toolchain
-        rm -f "${HOME}/.cargo/bin/"{rustfmt,cargo-fmt}
-        rustup toolchain install nightly -c rustfmt --profile minimal
-        rustup default nightly
+    - uses: dtolnay/rust-toolchain@master
+      with:
+        toolchain: nightly
+        components: rustfmt
+    - uses: taiki-e/install-action@grcov
+    - uses: Swatinem/rust-cache@v2
+      with:
+        workspaces: "./uutils -> target"
     - name: Install dependencies
       run: |
         ## Install dependencies
-        sudo apt update
-        sudo apt install autoconf autopoint bison texinfo gperf gcc g++ gdb python3-pyinotify jq valgrind libexpect-perl -y
+        sudo apt-get update
+        sudo apt-get install -y autoconf autopoint bison texinfo gperf gcc g++ gdb python3-pyinotify jq valgrind libexpect-perl libacl1-dev libattr1-dev libcap-dev
     - name: Add various locales
       run: |
         ## Add various locales
@@ -333,7 +345,6 @@ jobs:
         locale -a
     - name: Build binaries
       env:
-        CARGO_INCREMENTAL: "0"
         RUSTFLAGS: "-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
         RUSTDOCFLAGS: "-Cpanic=abort"
       run: |
@@ -342,8 +353,6 @@ jobs:
         UU_MAKE_PROFILE=debug bash util/build-gnu.sh
     - name: Run GNU tests
       run: bash uutils/util/run-gnu-test.sh
-    - name: "`grcov` ~ install"
-      run: cargo install grcov
     - name: Generate coverage data (via `grcov`)
       id: coverage
       run: |
diff --git a/.github/workflows/android.yml b/.github/workflows/android.yml
new file mode 100644
index 000000000..a6929b171
--- /dev/null
+++ b/.github/workflows/android.yml
@@ -0,0 +1,100 @@
+name: Android
+
+# spell-checker:ignore TERMUX reactivecircus Swatinem  noaudio pkill swiftshader dtolnay juliangruber
+
+on: [push, pull_request]
+
+permissions:
+  contents: read # to fetch code (actions/checkout)
+
+# 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_android:
+    name: Test builds
+    runs-on: macos-latest
+    timeout-minutes: 90
+    strategy:
+      fail-fast: false
+      matrix:
+        api-level: [28]
+        target: [default]
+        arch: [x86] # , arm64-v8a
+    env:
+      TERMUX: v0.118.0
+    steps:
+    - uses: actions/checkout@v3
+    - name: Restore AVD cache
+      uses: actions/cache/restore@v3
+      id: avd-cache
+      with:
+        path: |
+          ~/.android/avd/*
+          ~/.android/avd/*/snapshots/*
+          ~/.android/adb*
+          ~/__rustc_hash__
+        key: avd-${{ matrix.api-level }}-${{ matrix.arch }}+termux-${{ env.TERMUX }}+nextest+rustc-hash
+    - name: Create and cache emulator image
+      if: steps.avd-cache.outputs.cache-hit != 'true'
+      uses: reactivecircus/android-emulator-runner@v2
+      with:
+        api-level: ${{ matrix.api-level }}
+        target: ${{ matrix.target }}
+        arch: ${{ matrix.arch }}
+        ram-size: 2048M
+        disk-size: 7GB
+        force-avd-creation: true
+        emulator-options: -no-snapshot-load -noaudio -no-boot-anim -camera-back none
+        script: |
+          util/android-commands.sh init "${{ matrix.arch }}" "${{ matrix.api-level }}" "${{ env.TERMUX }}"
+    - name: Save AVD cache
+      if: steps.avd-cache.outputs.cache-hit != 'true'
+      uses: actions/cache/save@v3
+      with:
+        path: |
+          ~/.android/avd/*
+          ~/.android/avd/*/snapshots/*
+          ~/.android/adb*
+          ~/__rustc_hash__
+        key: avd-${{ matrix.api-level }}-${{ matrix.arch }}+termux-${{ env.TERMUX }}+nextest+rustc-hash
+    - uses: juliangruber/read-file-action@v1
+      id: read_rustc_hash
+      with:
+        # ~ expansion didn't work
+        path: /Users/runner/__rustc_hash__
+        trim: true
+    - name: Restore rust cache
+      id: rust-cache
+      uses: actions/cache/restore@v3
+      with:
+        path: ~/__rust_cache__
+        # The version vX at the end of the key is just a development version to avoid conflicts in
+        # the github cache during the development of this workflow
+        key: ${{ matrix.arch }}_${{ matrix.target}}_${{ steps.read_rustc_hash.outputs.content }}_${{ hashFiles('**/Cargo.toml', '**/Cargo.lock') }}_v3
+    - name: Build and Test
+      uses: reactivecircus/android-emulator-runner@v2
+      with:
+        api-level: ${{ matrix.api-level }}
+        target: ${{ matrix.target }}
+        arch: ${{ matrix.arch }}
+        ram-size: 2048M
+        disk-size: 7GB
+        force-avd-creation: false
+        emulator-options: -no-snapshot-save -gpu swiftshader_indirect -noaudio -no-boot-anim -camera-back none -snapshot ${{ matrix.api-level }}-${{ matrix.arch }}+termux-${{ env.TERMUX }}
+        # This is not a usual script. Every line is executed in a separate shell with `sh -c`. If
+        # one of the lines returns with error the whole script is failed (like running a script with
+        # set -e) and in consequences the other lines (shells) are not executed.
+        script: |
+          util/android-commands.sh sync_host
+          util/android-commands.sh build
+          util/android-commands.sh tests
+          if [[ "${{ steps.rust-cache.outputs.cache-hit }}" != 'true' ]]; then util/android-commands.sh sync_image; fi; exit 0
+    - name: Save rust cache
+      if: steps.rust-cache.outputs.cache-hit != 'true'
+      uses: actions/cache/save@v3
+      with:
+        path: ~/__rust_cache__
+        key: ${{ matrix.arch }}_${{ matrix.target}}_${{ steps.read_rustc_hash.outputs.content }}_${{ hashFiles('**/Cargo.toml', '**/Cargo.lock') }}_v3
diff --git a/.github/workflows/freebsd.yml b/.github/workflows/freebsd.yml
new file mode 100644
index 000000000..9507b3a56
--- /dev/null
+++ b/.github/workflows/freebsd.yml
@@ -0,0 +1,190 @@
+name: FreeBSD
+
+# spell-checker:ignore sshfs usesh vmactions taiki Swatinem esac fdescfs fdesc
+
+env:
+  # * style job configuration
+  STYLE_FAIL_ON_FAULT: true ## (bool) fail the build if a style job contains a fault (error or warning); may be overridden on a per-job basis
+
+on: [push, pull_request]
+
+permissions:
+  contents: read # to fetch code (actions/checkout)
+
+# 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:
+  style:
+    name: Style and Lint
+    runs-on: ${{ matrix.job.os }}
+    timeout-minutes: 90
+    strategy:
+      fail-fast: false
+      matrix:
+        job:
+          - { os: macos-12 , features: unix } ## GHA MacOS-11.0 VM won't have VirtualBox; refs: <https://github.com/actions/virtual-environments/issues/4060> , <https://github.com/actions/virtual-environments/pull/4010>
+    env:
+      SCCACHE_GHA_ENABLED: "true"
+      RUSTC_WRAPPER: "sccache"
+    steps:
+    - uses: actions/checkout@v3
+    - uses: Swatinem/rust-cache@v2
+    - name: Run sccache-cache
+      uses: mozilla-actions/sccache-action@v0.0.3
+    - name: Prepare, build and test
+      uses: vmactions/freebsd-vm@v0.3.0
+      with:
+        usesh: true
+        # We need jq to run show-utils.sh and bash to use inline shell string replacement
+        prepare: pkg install -y curl sudo jq bash
+        run: |
+          ## Prepare, build, and test
+          # implementation modelled after ref: <https://github.com/rust-lang/rustup/pull/2783>
+          # * NOTE: All steps need to be run in this block, otherwise, we are operating back on the mac host
+          set -e
+          #
+          TEST_USER=tester
+          REPO_NAME=${GITHUB_WORKSPACE##*/}
+          WORKSPACE_PARENT="/Users/runner/work/${REPO_NAME}"
+          WORKSPACE="${WORKSPACE_PARENT}/${REPO_NAME}"
+          #
+          pw adduser -n ${TEST_USER} -d /root/ -g wheel -c "Coreutils user to build" -w random
+          chown -R ${TEST_USER}:wheel /root/ "/Users/runner/work/${REPO_NAME}"/
+          whoami
+          #
+          # Further work needs to be done in a sudo as we are changing users
+          sudo -i -u ${TEST_USER} bash << EOF
+          set -e
+          whoami
+          curl https://sh.rustup.rs -sSf --output rustup.sh
+          sh rustup.sh -y -c rustfmt,clippy --profile=minimal -t stable
+          . ${HOME}/.cargo/env
+          ## VARs setup
+          cd "${WORKSPACE}"
+          unset FAIL_ON_FAULT ; case '${{ env.STYLE_FAIL_ON_FAULT }}' in
+          ''|0|f|false|n|no|off) FAULT_TYPE=warning ;;
+          *) FAIL_ON_FAULT=true ; FAULT_TYPE=error ;;
+          esac;
+          FAULT_PREFIX=\$(echo "\${FAULT_TYPE}" | tr '[:lower:]' '[:upper:]')
+          # * determine sub-crate utility list
+          UTILITY_LIST="\$(./util/show-utils.sh --features ${{ matrix.job.features }})"
+          CARGO_UTILITY_LIST_OPTIONS="\$(for u in \${UTILITY_LIST}; do echo -n "-puu_\${u} "; done;)"
+          ## Info
+          # environment
+          echo "## environment"
+          echo "CI='${CI}'"
+          echo "REPO_NAME='${REPO_NAME}'"
+          echo "TEST_USER='${TEST_USER}'"
+          echo "WORKSPACE_PARENT='${WORKSPACE_PARENT}'"
+          echo "WORKSPACE='${WORKSPACE}'"
+          echo "FAULT_PREFIX='\${FAULT_PREFIX}'"
+          echo "UTILITY_LIST='\${UTILITY_LIST}'"
+          env | sort
+          # tooling info
+          echo "## tooling info"
+          cargo -V
+          rustc -V
+          #
+          # To ensure that files are cleaned up, we don't want to exit on error
+          set +e
+          unset FAULT
+          ## cargo fmt testing
+          echo "## cargo fmt testing"
+          # * convert any errors/warnings to GHA UI annotations; ref: <https://help.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-a-warning-message>
+          S=\$(cargo fmt -- --check) && printf "%s\n" "\$S" || { printf "%s\n" "\$S" ; printf "%s\n" "\$S" | sed -E -n -e "s/^Diff[[:space:]]+in[[:space:]]+\${PWD//\//\\\\/}\/(.*)[[:space:]]+at[[:space:]]+[^0-9]+([0-9]+).*\$/::\${FAULT_TYPE} file=\1,line=\2::\${FAULT_PREFIX}: \\\`cargo fmt\\\`: style violation (file:'\1', line:\2; use \\\`cargo fmt -- \"\1\"\\\`)/p" ; FAULT=true ; }
+          ## cargo clippy lint testing
+          if [ -z "\${FAULT}" ]; then
+            echo "## cargo clippy lint testing"
+            # * convert any warnings to GHA UI annotations; ref: <https://help.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-a-warning-message>
+            S=\$(cargo clippy --all-targets \${CARGO_UTILITY_LIST_OPTIONS} -- -W clippy::manual_string_new -D warnings 2>&1) && printf "%s\n" "\$S" || { printf "%s\n" "\$S" ; printf "%s" "\$S" | sed -E -n -e '/^error:/{' -e "N; s/^error:[[:space:]]+(.*)\\n[[:space:]]+-->[[:space:]]+(.*):([0-9]+):([0-9]+).*\$/::\${FAULT_TYPE} file=\2,line=\3,col=\4::\${FAULT_PREFIX}: \\\`cargo clippy\\\`: \1 (file:'\2', line:\3)/p;" -e '}' ; FAULT=true ; }
+          fi
+          # Clean to avoid to rsync back the files
+          cargo clean
+          if [ -n "\${FAIL_ON_FAULT}" ] && [ -n "\${FAULT}" ]; then exit 1 ; fi
+          EOF
+
+  test:
+    name: Tests
+    runs-on: ${{ matrix.job.os }}
+    timeout-minutes: 90
+    strategy:
+      fail-fast: false
+      matrix:
+        job:
+          - { os: macos-12 , features: unix } ## GHA MacOS-11.0 VM won't have VirtualBox; refs: <https://github.com/actions/virtual-environments/issues/4060> , <https://github.com/actions/virtual-environments/pull/4010>
+    env:
+      mem: 4096
+      SCCACHE_GHA_ENABLED: "true"
+      RUSTC_WRAPPER: "sccache"
+    steps:
+    - uses: actions/checkout@v3
+    - uses: Swatinem/rust-cache@v2
+    - name: Run sccache-cache
+      uses: mozilla-actions/sccache-action@v0.0.3
+    - name: Prepare, build and test
+      uses: vmactions/freebsd-vm@v0.3.0
+      with:
+        usesh: true
+        # sync: sshfs
+        prepare: pkg install -y curl gmake sudo
+        run: |
+          ## Prepare, build, and test
+          # implementation modelled after ref: <https://github.com/rust-lang/rustup/pull/2783>
+          # * NOTE: All steps need to be run in this block, otherwise, we are operating back on the mac host
+          set -e
+          #
+          # We need a file-descriptor file system to test test_ls::test_ls_io_errors
+          mount -t fdescfs fdesc /dev/fd
+          #
+          TEST_USER=tester
+          REPO_NAME=${GITHUB_WORKSPACE##*/}
+          WORKSPACE_PARENT="/Users/runner/work/${REPO_NAME}"
+          WORKSPACE="${WORKSPACE_PARENT}/${REPO_NAME}"
+          #
+          pw adduser -n ${TEST_USER} -d /root/ -g wheel -c "Coreutils user to build" -w random
+          # chown -R ${TEST_USER}:wheel /root/ "${WORKSPACE_PARENT}"/
+          chown -R ${TEST_USER}:wheel /root/ "/Users/runner/work/${REPO_NAME}"/
+          whoami
+          #
+          # Further work needs to be done in a sudo as we are changing users
+          sudo -i -u ${TEST_USER} sh << EOF
+          set -e
+          whoami
+          curl https://sh.rustup.rs -sSf --output rustup.sh
+          sh rustup.sh -y --profile=minimal
+          . $HOME/.cargo/env
+          # Install nextest
+          mkdir -p ~/.cargo/bin
+          curl -LsSf https://get.nexte.st/latest/freebsd | tar zxf - -C ~/.cargo/bin
+          ## Info
+          # environment
+          echo "## environment"
+          echo "CI='${CI}'"
+          echo "REPO_NAME='${REPO_NAME}'"
+          echo "TEST_USER='${TEST_USER}'"
+          echo "WORKSPACE_PARENT='${WORKSPACE_PARENT}'"
+          echo "WORKSPACE='${WORKSPACE}'"
+          env | sort
+          # tooling info
+          echo "## tooling info"
+          cargo -V
+          cargo nextest --version
+          rustc -V
+          #
+          # To ensure that files are cleaned up, we don't want to exit on error
+          set +e
+          cd "${WORKSPACE}"
+          unset FAULT
+          cargo build || FAULT=1
+          export PATH=~/.cargo/bin:${PATH}
+          export RUST_BACKTRACE=1
+          export CARGO_TERM_COLOR=always
+          if (test -z "\$FAULT"); then cargo nextest run --hide-progress-bar --profile ci --features '${{ matrix.job.features }}' || FAULT=1 ; fi
+          if (test -z "\$FAULT"); then cargo nextest run --hide-progress-bar --profile ci --all-features -p uucore || FAULT=1 ; fi
+          # Clean to avoid to rsync back the files
+          cargo clean
+          if (test -n "\$FAULT"); then exit 1 ; fi
+          EOF
diff --git a/.github/workflows/ignore-intermittent.txt b/.github/workflows/ignore-intermittent.txt
new file mode 100644
index 000000000..759bd96eb
--- /dev/null
+++ b/.github/workflows/ignore-intermittent.txt
@@ -0,0 +1,3 @@
+tests/tail-2/inotify-dir-recreate
+tests/misc/timeout
+tests/rm/rm1
diff --git a/.markdownlint.yaml b/.markdownlint.yaml
new file mode 100644
index 000000000..11b733e0b
--- /dev/null
+++ b/.markdownlint.yaml
@@ -0,0 +1,6 @@
+# Disable 'Line length'. Doesn't provide much values
+MD013: false
+# Disable 'Fenced code blocks should have a language specified'
+# Doesn't provide much in src/ to enforce it
+MD040: false
+
diff --git a/.vscode/cspell.dictionaries/acronyms+names.wordlist.txt b/.vscode/cspell.dictionaries/acronyms+names.wordlist.txt
index 81bc3bc5f..8711913d9 100644
--- a/.vscode/cspell.dictionaries/acronyms+names.wordlist.txt
+++ b/.vscode/cspell.dictionaries/acronyms+names.wordlist.txt
@@ -50,6 +50,7 @@ Gmail
 GNU
 Illumos
 Irix
+libfuzzer
 MS-DOS
 MSDOS
 MacOS
diff --git a/.vscode/cspell.dictionaries/workspace.wordlist.txt b/.vscode/cspell.dictionaries/workspace.wordlist.txt
index d6e91dca5..6d6533bcf 100644
--- a/.vscode/cspell.dictionaries/workspace.wordlist.txt
+++ b/.vscode/cspell.dictionaries/workspace.wordlist.txt
@@ -20,6 +20,7 @@ exacl
 filetime
 formatteriteminfo
 fsext
+fundu
 getopts
 getrandom
 globset
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
index d196c6e95..39474f7ab 100644
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -116,7 +116,7 @@ the community.
 
 This Code of Conduct is adapted from the [Contributor Covenant][homepage],
 version 2.0, available at
-https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+<https://www.contributor-covenant.org/version/2/0/code_of_conduct.html>.
 
 Community Impact Guidelines were inspired by [Mozilla's code of conduct
 enforcement ladder](https://github.com/mozilla/diversity).
@@ -124,5 +124,5 @@ enforcement ladder](https://github.com/mozilla/diversity).
 [homepage]: https://www.contributor-covenant.org
 
 For answers to common questions about this code of conduct, see the FAQ at
-https://www.contributor-covenant.org/faq. Translations are available at
-https://www.contributor-covenant.org/translations.
+<https://www.contributor-covenant.org/faq>. Translations are available at
+<https://www.contributor-covenant.org/translations>.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 7a749ebac..7dc2565c1 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,20 +1,12 @@
+<!-- spell-checker:ignore reimplementing toybox RUNTEST CARGOFLAGS nextest -->
+
 # Contributing to coreutils
 
-Contributions are very welcome, and should target Rust's main branch until the
-standard libraries are stabilized. You may *claim* an item on the to-do list by
-following these steps:
-
-1. Open an issue named "Implement [the utility of your choice]", e.g. "Implement
-   ls".
-1. State that you are working on this utility.
-1. Develop the utility.
-1. Add integration tests.
-1. Add the reference to your utility into Cargo.toml and Makefile.
-1. Remove utility from the to-do list in the README.
-1. Submit a pull request and close the issue.
-
-The steps above imply that, before starting to work on a utility, you should
-search the issues to make sure no one else is working on it.
+Contributions are very welcome via Pull Requests. If you don't know where to
+start, take a look at the
+[`good-first-issues`](https://github.com/uutils/coreutils/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22).
+If you have any questions, feel free to ask them in the issues or on
+[Discord](https://discord.gg/wQVJbvJ).
 
 ## Best practices
 
@@ -38,37 +30,259 @@ search the issues to make sure no one else is working on it.
 
 ## Platforms
 
-We take pride in supporting many operating systems and architectures. 
+We take pride in supporting many operating systems and architectures. Any code
+you contribute must at least compile without warnings for all platforms in the
+CI. However, you can use `#[cfg(...)]` attributes to create platform dependent features.
 
-**Tip:**
-For Windows, Microsoft provides some images (VMWare, Hyper-V, VirtualBox and Parallels) 
-for development:
-https://developer.microsoft.com/windows/downloads/virtual-machines/
+**Tip:** For Windows, Microsoft provides some images (VMWare, Hyper-V,
+VirtualBox and Parallels) for development:
+<https://developer.microsoft.com/windows/downloads/virtual-machines/>
 
+## Tools
+
+We have an extensive CI that will check your code before it can be merged. This
+section explains how to run those checks locally to avoid waiting for the CI.
+
+### pre-commit hooks
+
+A configuration for `pre-commit` is provided in the repository. It allows
+automatically checking every git commit you make to ensure it compiles, and
+passes `clippy` and `rustfmt` without warnings.
+
+To use the provided hook:
+
+1. [Install `pre-commit`](https://pre-commit.com/#install)
+1. Run `pre-commit install` while in the repository directory
+
+Your git commits will then automatically be checked. If a check fails, an error
+message will explain why, and your commit will be canceled. You can then make
+the suggested changes, and run `git commit ...` again.
+
+### clippy
+
+```shell
+cargo clippy --all-targets --all-features
+```
+
+The `msrv` key in the clippy configuration file `clippy.toml` is used to disable
+lints pertaining to newer features by specifying the minimum supported Rust
+version (MSRV).
+
+### rustfmt
+
+```shell
+cargo fmt --all
+```
+
+### cargo-deny
+
+This project uses [cargo-deny](https://github.com/EmbarkStudios/cargo-deny/) to
+detect duplicate dependencies, checks licenses, etc. To run it locally, first
+install it and then run with:
+
+```
+cargo deny --all-features check all
+```
+
+### Markdown linter
+
+We use [markdownlint](https://github.com/DavidAnson/markdownlint) to lint the
+Markdown files in the repository.
+
+### Spell checker
+
+We use `cspell` as spell checker for all files in the project. If you are using
+VS Code, you can install the
+[code spell checker](https://marketplace.visualstudio.com/items?itemName=streetsidesoftware.code-spell-checker)
+extension to enable spell checking within your editor. Otherwise, you can
+install [cspell](https://cspell.org/) separately.
+
+If you want to make the spell checker ignore a word, you can add
+
+```rust
+// spell-checker:ignore word_to_ignore
+```
+
+at the top of the file.
+
+## Testing
+
+Testing can be done using either Cargo or `make`.
+
+### Testing with Cargo
+
+Just like with building, we follow the standard procedure for testing using
+Cargo:
+
+```shell
+cargo test
+```
+
+By default, `cargo test` only runs the common programs. To run also platform
+specific tests, run:
+
+```shell
+cargo test --features unix
+```
+
+If you would prefer to test a select few utilities:
+
+```shell
+cargo test --features "chmod mv tail" --no-default-features
+```
+
+If you also want to test the core utilities:
+
+```shell
+cargo test  -p uucore -p coreutils
+```
+
+Running the complete test suite might take a while. We use [nextest](https://nexte.st/index.html) in
+the CI and you might want to try it out locally. It can speed up the execution time of the whole
+test run significantly if the cpu has multiple cores.
+
+```shell
+cargo nextest run --features unix --no-fail-fast
+```
+
+To debug:
+
+```shell
+gdb --args target/debug/coreutils ls
+(gdb) b ls.rs:79
+(gdb) run
+```
+
+### Testing with GNU Make
+
+To simply test all available utilities:
+
+```shell
+make test
+```
+
+To test all but a few of the available utilities:
+
+```shell
+make SKIP_UTILS='UTILITY_1 UTILITY_2' test
+```
+
+To test only a few of the available utilities:
+
+```shell
+make UTILS='UTILITY_1 UTILITY_2' test
+```
+
+To include tests for unimplemented behavior:
+
+```shell
+make UTILS='UTILITY_1 UTILITY_2' SPEC=y test
+```
+
+To run tests with `nextest` just use the nextest target. Note you'll need to
+[install](https://nexte.st/book/installation.html) `nextest` first. The `nextest` target accepts the
+same arguments like the default `test` target, so it's possible to pass arguments to `nextest run`
+via `CARGOFLAGS`:
+
+```shell
+make CARGOFLAGS='--no-fail-fast' UTILS='UTILITY_1 UTILITY_2' nextest
+```
+
+### Run Busybox Tests
+
+This testing functionality is only available on *nix operating systems and
+requires `make`.
+
+To run busybox tests for all utilities for which busybox has tests
+
+```shell
+make busytest
+```
+
+To run busybox tests for a few of the available utilities
+
+```shell
+make UTILS='UTILITY_1 UTILITY_2' busytest
+```
+
+To pass an argument like "-v" to the busybox test runtime
+
+```shell
+make UTILS='UTILITY_1 UTILITY_2' RUNTEST_ARGS='-v' busytest
+```
+
+### Comparing with GNU
+
+To run uutils against the GNU test suite locally, run the following commands:
+
+```shell
+bash util/build-gnu.sh
+# Build uutils without release optimizations
+UU_MAKE_PROFILE=debug bash util/build-gnu.sh
+bash util/run-gnu-test.sh
+# To run a single test:
+bash util/run-gnu-test.sh tests/touch/not-owner.sh # for example
+# To run several tests:
+bash util/run-gnu-test.sh tests/touch/not-owner.sh tests/rm/no-give-up.sh # for example
+# If this is a perl (.pl) test, to run in debug:
+DEBUG=1 bash util/run-gnu-test.sh tests/misc/sm3sum.pl
+```
+
+Note that it relies on individual utilities (not the multicall binary).
+
+### Improving the GNU compatibility
+
+The Python script `./util/remaining-gnu-error.py` shows the list of failing
+tests in the CI.
+
+To improve the GNU compatibility, the following process is recommended:
+
+1. Identify a test (the smaller, the better) on a program that you understand or
+   is easy to understand. You can use the `./util/remaining-gnu-error.py` script
+   to help with this decision.
+1. Build both the GNU and Rust coreutils using: `bash util/build-gnu.sh`
+1. Run the test with `bash util/run-gnu-test.sh <your test>`
+1. Start to modify `<your test>` to understand what is wrong. Examples:
+   1. Add `set -v` to have the bash verbose mode
+   1. Add `echo $?` where needed
+   1. When the variable `fail` is used in the test, `echo $fail` to see when the
+      test started to fail
+   1. Bump the content of the output (ex: `cat err`)
+   1. ...
+1. Or, if the test is simple, extract the relevant information to create a new
+   test case running both GNU & Rust implementation
+1. Start to modify the Rust implementation to match the expected behavior
+1. Add a test to make sure that we don't regress (our test suite is super quick)
 
 ## Commit messages
 
 To help the project maintainers review pull requests from contributors across
 numerous utilities, the team has settled on conventions for commit messages.
 
-From http://git-scm.com/book/ch5-2.html:
+From <https://git-scm.com/book/ch5-2.html>:
 
 ```
-Short (50 chars or less) summary of changes
+Capitalized, short (50 chars or less) summary
 
 More detailed explanatory text, if necessary.  Wrap it to about 72
 characters or so.  In some contexts, the first line is treated as the
 subject of an email and the rest of the text as the body.  The blank
 line separating the summary from the body is critical (unless you omit
-the body entirely); tools like rebase can get confused if you run the
+the body entirely); tools like rebase will confuse you if you run the
 two together.
 
+Write your commit message in the imperative: "Fix bug" and not "Fixed bug"
+or "Fixes bug."  This convention matches up with commit messages generated
+by commands like git merge and git revert.
+
 Further paragraphs come after blank lines.
 
   - Bullet points are okay, too
 
-  - Typically a hyphen or asterisk is used for the bullet, preceded by a
+  - Typically a hyphen or asterisk is used for the bullet, followed by a
     single space, with blank lines in between, but conventions vary here
+
+  - Use a hanging indent
 ```
 
 Furthermore, here are a few examples for a summary line:
@@ -104,15 +318,47 @@ uutils: add new utility
 gitignore: add temporary files
 ```
 
-## cargo-deny
+## Code coverage
 
-This project uses [cargo-deny](https://github.com/EmbarkStudios/cargo-deny/) to
-detect duplicate dependencies, checks licenses, etc. To run it locally, first
-install it and then run with:
+<!-- spell-checker:ignore (flags) Ccodegen Coverflow Cpanic Zinstrument Zpanic -->
 
+Code coverage report can be generated using [grcov](https://github.com/mozilla/grcov).
+
+### Using Nightly Rust
+
+To generate [gcov-based](https://github.com/mozilla/grcov#example-how-to-generate-gcda-files-for-a-rust-project) coverage report
+
+```shell
+export CARGO_INCREMENTAL=0
+export RUSTFLAGS="-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
+export RUSTDOCFLAGS="-Cpanic=abort"
+cargo build <options...> # e.g., --features feat_os_unix
+cargo test <options...> # e.g., --features feat_os_unix test_pathchk
+grcov . -s . --binary-path ./target/debug/ -t html --branch --ignore-not-existing --ignore build.rs --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?\#\[derive\()" -o ./target/debug/coverage/
+# open target/debug/coverage/index.html in browser
 ```
-cargo deny --all-features check all
-```
+
+if changes are not reflected in the report then run `cargo clean` and run the above commands.
+
+### Using Stable Rust
+
+If you are using stable version of Rust that doesn't enable code coverage instrumentation by default
+then add `-Z-Zinstrument-coverage` flag to `RUSTFLAGS` env variable specified above.
+
+## Other implementations
+
+The Coreutils have different implementations, with different levels of completions:
+
+* [GNU's](https://git.savannah.gnu.org/gitweb/?p=coreutils.git)
+* [OpenBSD](https://github.com/openbsd/src/tree/master/bin)
+* [Busybox](https://github.com/mirror/busybox/tree/master/coreutils)
+* [Toybox (Android)](https://github.com/landley/toybox/tree/master/toys/posix)
+* [V lang](https://github.com/vlang/coreutils)
+* [SerenityOS](https://github.com/SerenityOS/serenity/tree/master/Userland/Utilities)
+* [Initial Unix](https://github.com/dspinellis/unix-history-repo)
+
+However, when reimplementing the tools/options in Rust, don't read their source codes
+when they are using reciprocal licenses (ex: GNU GPL, GNU LGPL, etc).
 
 ## Licensing
 
diff --git a/Cargo.lock b/Cargo.lock
index 89d67bf81..a92d01416 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -34,12 +34,27 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "aho-corasick"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67fc08ce920c31afb70f013dcce1bfc3a3195de6a228474e45e1f145b36f8d04"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "aliasable"
 version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "250f629c0161ad8107cf89319e990051fae62832fd343083bea452d93e2205fd"
 
+[[package]]
+name = "android-tzdata"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
+
 [[package]]
 name = "android_system_properties"
 version = "0.1.5"
@@ -49,6 +64,55 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "anstream"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ca84f3628370c59db74ee214b3263d58f9aadd9b4fe7e711fd87dc452b7f163"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is-terminal",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41ed9a86bf92ae6580e0a31281f65a1b1d867c0cc68d5346e2ae128dddfa6a7d"
+
+[[package]]
+name = "anstyle-parse"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e765fd216e48e067936442276d1d57399e37bce53c264d6fefbe298080cb57ee"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ca11d4be1bab0c8bc8734a9aa7bf4ee8316d462a08c6ac5052f888fef5b494b"
+dependencies = [
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "180abfa45703aebe0093f79badacc01b8fd4ea2e35118747e5811127f926e188"
+dependencies = [
+ "anstyle",
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "arrayref"
 version = "0.3.6"
@@ -61,17 +125,6 @@ version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"
 
-[[package]]
-name = "atty"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
-dependencies = [
- "hermit-abi 0.1.19",
- "libc",
- "winapi",
-]
-
 [[package]]
 name = "autocfg"
 version = "1.1.0"
@@ -100,9 +153,9 @@ dependencies = [
 
 [[package]]
 name = "bindgen"
-version = "0.62.0"
+version = "0.63.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6720a8b7b2d39dd533285ed438d458f65b31b5c257e6ac7bb3d7e82844dd722"
+checksum = "36d860121800b2a9a94f9b5604b332d5cffb234ce17609ea479d723dbc9d3885"
 dependencies = [
  "bitflags",
  "cexpr",
@@ -139,9 +192,9 @@ dependencies = [
 
 [[package]]
 name = "blake3"
-version = "1.3.2"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "895adc16c8b3273fbbc32685a7d55227705eda08c01e77704020f3491924b44b"
+checksum = "729b71f35bd3fa1a4c86b85d32c8b9069ea7fe14f7a53cfabb65f62d4265b888"
 dependencies = [
  "arrayref",
  "arrayvec",
@@ -162,9 +215,9 @@ dependencies = [
 
 [[package]]
 name = "bstr"
-version = "1.0.1"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fca0852af221f458706eb0725c03e4ed6c46af9ac98e6a689d5e634215d594dd"
+checksum = "a246e68bb43f6cd9db24bea052a53e40405417c5fb372e3d1a8a7f770a564ef5"
 dependencies = [
  "memchr",
  "once_cell",
@@ -213,12 +266,12 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "chrono"
-version = "0.4.23"
+version = "0.4.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16b0a3d9ed01224b22057780a37bb8c5dbfe1be8ba48678e7bf57ec4b385411f"
+checksum = "ec837a71355b28f6556dbd569b37b3f363091c0bd4b2e735674521b4c5fd9bc5"
 dependencies = [
+ "android-tzdata",
  "iana-time-zone",
- "num-integer",
  "num-traits",
  "winapi",
 ]
@@ -236,35 +289,51 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.0.26"
+version = "4.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2148adefda54e14492fb9bddcc600b4344c5d1a3123bd666dcb939c6f0e0e57e"
+checksum = "93aae7a4192245f70fe75dd9157fc7b4a5bf53e88d30bd4396f7d8f9284d5acc"
 dependencies = [
- "atty",
+ "clap_builder",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f423e341edefb78c9caba2d9c7f7687d0e72e89df3ce3394554754393ac3990"
+dependencies = [
+ "anstream",
+ "anstyle",
  "bitflags",
  "clap_lex",
  "once_cell",
  "strsim",
- "termcolor",
  "terminal_size",
 ]
 
 [[package]]
 name = "clap_complete"
-version = "4.0.6"
+version = "4.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7b3c9eae0de7bf8e3f904a5e40612b21fb2e2e566456d177809a48b892d24da"
+checksum = "a04ddfaacc3bc9e6ea67d024575fafc2a813027cf374b8f24f7bc233c6b6be12"
 dependencies = [
  "clap",
 ]
 
 [[package]]
 name = "clap_lex"
-version = "0.3.0"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d4198f73e42b4936b35b5bb248d81d2b595ecb170da0bac7655c54eedfa8da8"
+checksum = "2da6da31387c7e4ef160ffab6d5e7f00c42626fe39aea70a7b0f1773f7dd6c1b"
+
+[[package]]
+name = "clap_mangen"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0f09a0ca8f0dd8ac92c546b426f466ef19828185c6d504c80c48c9c2768ed9"
 dependencies = [
- "os_str_bytes",
+ "clap",
+ "roff",
 ]
 
 [[package]]
@@ -277,6 +346,12 @@ dependencies = [
  "unicode-width",
 ]
 
+[[package]]
+name = "colorchoice"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7"
+
 [[package]]
 name = "compare"
 version = "0.1.0"
@@ -285,15 +360,15 @@ checksum = "120133d4db2ec47efe2e26502ee984747630c67f51974fca0b6c1340cf2368d3"
 
 [[package]]
 name = "console"
-version = "0.15.5"
+version = "0.15.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3d79fbe8970a77e3e34151cc13d3b3e248aa0faaecb9f6091fa07ebefe5ad60"
+checksum = "c926e00cc70edefdc64d3a5ff31cc65bb97a3460097762bd23afb4d8145fccf8"
 dependencies = [
  "encode_unicode",
  "lazy_static",
  "libc",
  "unicode-width",
- "windows-sys 0.42.0",
+ "windows-sys 0.45.0",
 ]
 
 [[package]]
@@ -319,11 +394,12 @@ checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
 
 [[package]]
 name = "coreutils"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "chrono",
  "clap",
  "clap_complete",
+ "clap_mangen",
  "conv",
  "filetime",
  "glob",
@@ -347,7 +423,6 @@ dependencies = [
  "textwrap",
  "time",
  "unindent",
- "users",
  "uu_arch",
  "uu_base32",
  "uu_base64",
@@ -452,6 +527,7 @@ dependencies = [
  "uu_whoami",
  "uu_yes",
  "uucore",
+ "uuhelp_parser",
  "walkdir",
  "zip",
 ]
@@ -507,7 +583,7 @@ version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7fdaa01904c12a8989dbfa110b41ef27efc432ac9934f691b9732f01cb64dc01"
 dependencies = [
- "aho-corasick",
+ "aho-corasick 0.7.19",
  "byteorder",
  "cpp_common",
  "lazy_static",
@@ -536,9 +612,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-channel"
-version = "0.5.6"
+version = "0.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2dd04ddaf88237dc3b8d8f9a3c1004b506b54b3313403944054d23c0870c521"
+checksum = "a33c2bf77f2df06183c3aa30d1e96c0695a313d4f9c453cc3762a6db39f99200"
 dependencies = [
  "cfg-if",
  "crossbeam-utils",
@@ -557,9 +633,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-epoch"
-version = "0.9.12"
+version = "0.9.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96bf8df95e795db1a4aca2957ad884a2df35413b24bbeb3114422f3cc21498e8"
+checksum = "46bd5f3f85273295a9d14aedfb86f6aadbff6d8f5295c4a9edb08e819dcf5695"
 dependencies = [
  "autocfg",
  "cfg-if",
@@ -570,18 +646,18 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.13"
+version = "0.8.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "422f23e724af1240ec469ea1e834d87a4b59ce2efe2c6a96256b0c47e2fd86aa"
+checksum = "3c063cd8cc95f5c377ed0d4b49a4b21f632396ff690e8470c29b3359b346984b"
 dependencies = [
  "cfg-if",
 ]
 
 [[package]]
 name = "crossterm"
-version = "0.25.0"
+version = "0.26.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e64e6c0fbe2c17357405f7c758c1ef960fce08bdfb2c03d88d2a18d7e09c4b67"
+checksum = "a84cda67535339806297f1b331d6dd6320470d2a0fe65381e79ee9e156dd3d13"
 dependencies = [
  "bitflags",
  "crossterm_winapi",
@@ -630,12 +706,12 @@ dependencies = [
 
 [[package]]
 name = "ctrlc"
-version = "3.2.4"
+version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1631ca6e3c59112501a9d87fd86f21591ff77acd31331e8a73f8d80a65bbdd71"
+checksum = "2a011bbe2c35ce9c1f143b7af6f94f29a167beb4cd1d29e6740ce836f723120e"
 dependencies = [
  "nix",
- "windows-sys 0.42.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -690,15 +766,15 @@ dependencies = [
 
 [[package]]
 name = "data-encoding"
-version = "2.3.2"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ee2393c4a91429dffb4bedf19f4d6abf27d8a732c8ce4980305d782e5426d57"
+checksum = "c2e66c9d817f1720209181c316d28635c050fa304f9c79e47a520882661b7308"
 
 [[package]]
 name = "data-encoding-macro"
-version = "0.1.12"
+version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86927b7cd2fe88fa698b87404b287ab98d1a0063a34071d92e575b72d3029aca"
+checksum = "c904b33cc60130e1aeea4956ab803d08a3f4a0ca82d64ed757afac3891f2bb99"
 dependencies = [
  "data-encoding",
  "data-encoding-macro-internal",
@@ -706,9 +782,9 @@ dependencies = [
 
 [[package]]
 name = "data-encoding-macro-internal"
-version = "0.1.10"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5bbed42daaa95e780b60a50546aa345b8413a1e46f9a40a12907d3598f038db"
+checksum = "8fdf3fce3ce863539ec1d7fd1b6dcc3c645663376b43ed376bbf887733e4f772"
 dependencies = [
  "data-encoding",
  "syn",
@@ -722,9 +798,9 @@ checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
 
 [[package]]
 name = "digest"
-version = "0.10.6"
+version = "0.10.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8168378f4e5023e7218c89c891c0fd8ecdb5e5e4f18cb78f38cf245dd021e76f"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
 dependencies = [
  "block-buffer",
  "crypto-common",
@@ -739,21 +815,21 @@ checksum = "0688c2a7f92e427f44895cd63841bff7b29f8d7a1648b9e7e07a4a365b2e1257"
 
 [[package]]
 name = "dns-lookup"
-version = "1.0.8"
+version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53ecafc952c4528d9b51a458d1a8904b81783feff9fde08ab6ed2545ff396872"
+checksum = "8f332aa79f9e9de741ac013237294ef42ce2e9c6394dc7d766725812f1238812"
 dependencies = [
  "cfg-if",
  "libc",
  "socket2",
- "winapi",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "dunce"
-version = "1.0.3"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bd4b30a6560bbd9b4620f4de34c3f14f60848e58a9b7216801afcb4c7b31c3c"
+checksum = "56ce8c6da7551ec6c462cbaf3bfbc75131ebbfa1c944aeaa9dab51ca1c5f0c3b"
 
 [[package]]
 name = "either"
@@ -779,13 +855,13 @@ dependencies = [
 
 [[package]]
 name = "errno"
-version = "0.2.8"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f639046355ee4f37944e44f60642c6f3a7efa3cf6b78c78a0d989a8ce6c396a1"
+checksum = "4bcfec3a70f97c962c307b2d2c56e358cf1d00b558d74262b5f929ee8cc7e73a"
 dependencies = [
  "errno-dragonfly",
  "libc",
- "winapi",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -800,9 +876,9 @@ dependencies = [
 
 [[package]]
 name = "exacl"
-version = "0.9.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "129c7b60e19ea8393c47b2110f8e3cea800530fd962380ef110d1fef6591faee"
+checksum = "1cfeb22a59deb24c3262c43ffcafd1eb807180f371f9fcc99098d181b5d639be"
 dependencies = [
  "bitflags",
  "log",
@@ -827,14 +903,14 @@ checksum = "31a7a908b8f32538a2143e59a6e4e2508988832d5d4d6f7c156b3cbc762643a5"
 
 [[package]]
 name = "filetime"
-version = "0.2.18"
+version = "0.2.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b9663d381d07ae25dc88dbdf27df458faa83a9b25336bcac83d5e452b5fc9d3"
+checksum = "8a3de6e8d11b22ff9edc6d916f890800597d60f8b2da1caf2955c274638d6412"
 dependencies = [
  "cfg-if",
  "libc",
- "redox_syscall",
- "windows-sys 0.42.0",
+ "redox_syscall 0.2.16",
+ "windows-sys 0.45.0",
 ]
 
 [[package]]
@@ -870,9 +946,9 @@ dependencies = [
 
 [[package]]
 name = "fts-sys"
-version = "0.2.3"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32bd98333d10742c0b048272ebf4cb05336d415423b853961c92ccb398966a03"
+checksum = "9a66c0a21e344f20c87b4ca12643cf4f40a7018f132c98d344e989b959f49dd1"
 dependencies = [
  "bindgen",
  "libc",
@@ -880,9 +956,9 @@ dependencies = [
 
 [[package]]
 name = "fundu"
-version = "0.3.0"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "925250bc259498d4008ee072bf16586083ab2c491aa4b06b3c4d0a6556cebd74"
+checksum = "47af3b646bdd738395be2db903fc11a5923b5e206016b8d4ad6db890bcae9bd5"
 
 [[package]]
 name = "futures"
@@ -981,9 +1057,9 @@ dependencies = [
 
 [[package]]
 name = "gcd"
-version = "2.2.0"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4b1b088ad0a967aa29540456b82fc8903f854775d33f71e9709c4efb3dfbfd2"
+checksum = "1d758ba1b47b00caf47f24925c0074ecb20d6dfcffe7f6d53395c0465674841a"
 
 [[package]]
 name = "generic-array"
@@ -997,9 +1073,9 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.2.8"
+version = "0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
+checksum = "c85e1d9ab2eadba7e5040d4e09cbd6d072b76a557ad64e797c2cb9d4da21d7e4"
 dependencies = [
  "cfg-if",
  "libc",
@@ -1008,15 +1084,15 @@ dependencies = [
 
 [[package]]
 name = "glob"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574"
+checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
 
 [[package]]
 name = "half"
-version = "2.1.0"
+version = "2.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad6a9459c9c30b177b925162351f97e7d967c7ea8bab3b8352805327daf45554"
+checksum = "02b4af3693f1b705df946e9fe5631932443781d0aabb423b62fcd4d73f6d2fd0"
 dependencies = [
  "crunchy",
 ]
@@ -1030,12 +1106,6 @@ dependencies = [
  "ahash",
 ]
 
-[[package]]
-name = "heck"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9"
-
 [[package]]
 name = "hermit-abi"
 version = "0.1.19"
@@ -1059,9 +1129,9 @@ checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
 [[package]]
 name = "hex-literal"
-version = "0.3.4"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ebdb29d2ea9ed0083cd8cece49bbd968021bd99b0849edb4a9a7ee0fdf6a4e0"
+checksum = "6fe2267d4ed49bc07b63801559be28c718ea06c4738b7a03c94df7386d2cde46"
 
 [[package]]
 name = "hostname"
@@ -1074,6 +1144,16 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "humantime_to_duration"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "714764645f21cc70c4c151d7798dd158409641f37ad820bed65224aae403cbed"
+dependencies = [
+ "regex",
+ "time",
+]
+
 [[package]]
 name = "iana-time-zone"
 version = "0.1.53"
@@ -1141,30 +1221,25 @@ dependencies = [
 
 [[package]]
 name = "io-lifetimes"
-version = "0.7.5"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59ce5ef949d49ee85593fc4d3f3f95ad61657076395cbbce23e2121fc5542074"
-
-[[package]]
-name = "io-lifetimes"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1abeb7a0dd0f8181267ff8adc397075586500b81b28a73e8a0208b00fc170fb3"
+checksum = "eae7b9aee968036d54dce06cebaefd919e4472e753296daccd6d344e3e2df0c2"
 dependencies = [
+ "hermit-abi 0.3.1",
  "libc",
- "windows-sys 0.45.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "is-terminal"
-version = "0.4.3"
+version = "0.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22e18b0a45d56fe973d6db23972bf5bc46f988a4a2385deac9cc29572f09daef"
+checksum = "adcf93614601c8129ddf72e2d5633df827ba6551541c6d8c59520a371475be1f"
 dependencies = [
  "hermit-abi 0.3.1",
- "io-lifetimes 1.0.5",
- "rustix 0.36.8",
- "windows-sys 0.45.0",
+ "io-lifetimes",
+ "rustix 0.37.19",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -1193,9 +1268,9 @@ dependencies = [
 
 [[package]]
 name = "keccak"
-version = "0.1.3"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3afef3b6eff9ce9d8ff9b3601125eec7f0c8cbac7abd14f355d053fa56c98768"
+checksum = "8f6d5ed8676d904364de097082f4e7d240b571b67989ced0240f08b7f966f940"
 dependencies = [
  "cpufeatures",
 ]
@@ -1234,9 +1309,9 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
 
 [[package]]
 name = "libc"
-version = "0.2.139"
+version = "0.2.146"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "201de327520df007757c1f0adce6e827fe8562fbc28bfd9c15571c66ca1f5f79"
+checksum = "f92be4933c13fd498862a9e02a3055f8a8d9c039ce33db97306fd5a6caa7f29b"
 
 [[package]]
 name = "libloading"
@@ -1257,18 +1332,18 @@ dependencies = [
  "cc",
 ]
 
-[[package]]
-name = "linux-raw-sys"
-version = "0.0.46"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4d2456c373231a208ad294c33dc5bff30051eafd954cd4caae83a712b12854d"
-
 [[package]]
 name = "linux-raw-sys"
 version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f051f77a7c8e6957c0696eac88f26b0117e54f52d3fc682ab19397a8812846a4"
 
+[[package]]
+name = "linux-raw-sys"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef53942eb7bf7ff43a617b3e2c1c4a5ecf5944a7c1bc12d7ee39bbb15e5c1519"
+
 [[package]]
 name = "lock_api"
 version = "0.4.9"
@@ -1290,9 +1365,9 @@ dependencies = [
 
 [[package]]
 name = "lscolors"
-version = "0.13.0"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2dedc85d67baf5327114fad78ab9418f8893b1121c17d5538dd11005ad1ddf2"
+checksum = "18a9df1d1fb6d9e92fa043e9eb9a3ecf6892c7b542bae5137cd1e419e40aa8bf"
 dependencies = [
  "nu-ansi-term",
 ]
@@ -1320,18 +1395,18 @@ checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
 
 [[package]]
 name = "memmap2"
-version = "0.5.8"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b182332558b18d807c4ce1ca8ca983b34c3ee32765e47b3f0f69b90355cc1dc"
+checksum = "180d4b35be83d33392d1d1bfbd2ae1eca7ff5de1a94d3fc87faaa99a069e7cbd"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "memoffset"
-version = "0.7.1"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5de893c32cde5f383baa4c04c5d6dbdd735cfd4a794b0debdb2bb1b421da5ff4"
+checksum = "d61c719bcfbcf5d62b3a09efa6088de8c54bc0bfcd3ea7ae39fcc186108b8de1"
 dependencies = [
  "autocfg",
 ]
@@ -1353,14 +1428,14 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "0.8.5"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5d732bc30207a6423068df043e3d02e0735b155ad7ce1a6f76fe2baa5b158de"
+checksum = "5b9d9a46eff5b4ff64b45a9e316a6d1e0bc719ef429cbec4dc630684212bfdf9"
 dependencies = [
  "libc",
  "log",
  "wasi",
- "windows-sys 0.42.0",
+ "windows-sys 0.45.0",
 ]
 
 [[package]]
@@ -1377,9 +1452,9 @@ dependencies = [
 
 [[package]]
 name = "nom"
-version = "7.1.1"
+version = "7.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8903e5a29a317527874d0402f867152a3d21c908bb0b933e416c65e301d4c36"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
 dependencies = [
  "memchr",
  "minimal-lexical",
@@ -1387,9 +1462,9 @@ dependencies = [
 
 [[package]]
 name = "notify"
-version = "5.0.0"
+version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed2c66da08abae1c024c01d635253e402341b4060a12e99b31c7594063bf490a"
+checksum = "4d9ba6c734de18ca27c8cef5cd7058aa4ac9f63596131e4c7e41e579319032a2"
 dependencies = [
  "bitflags",
  "crossbeam-channel",
@@ -1400,17 +1475,16 @@ dependencies = [
  "libc",
  "mio",
  "walkdir",
- "winapi",
+ "windows-sys 0.45.0",
 ]
 
 [[package]]
 name = "nu-ansi-term"
-version = "0.46.0"
+version = "0.47.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
+checksum = "1df031e117bca634c262e9bd3173776844b6c17a90b3741c9163663b4385af76"
 dependencies = [
- "overload",
- "winapi",
+ "windows-sys 0.45.0",
 ]
 
 [[package]]
@@ -1470,9 +1544,9 @@ checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3"
 
 [[package]]
 name = "once_cell"
-version = "1.17.1"
+version = "1.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7e5500299e16ebb147ae15a00a942af264cf3688f47923b8fc2cd5858f23ad3"
+checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
 
 [[package]]
 name = "onig"
@@ -1515,17 +1589,11 @@ dependencies = [
  "unicode-width",
 ]
 
-[[package]]
-name = "os_str_bytes"
-version = "6.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b7820b9daea5457c9f21c69448905d723fbd21136ccf521748f23fd49e723ee"
-
 [[package]]
 name = "ouroboros"
-version = "0.15.5"
+version = "0.15.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfbb50b356159620db6ac971c6d5c9ab788c9cc38a6f49619fca2a27acb062ca"
+checksum = "e1358bd1558bd2a083fed428ffeda486fbfb323e698cdda7794259d592ca72db"
 dependencies = [
  "aliasable",
  "ouroboros_macro",
@@ -1533,9 +1601,9 @@ dependencies = [
 
 [[package]]
 name = "ouroboros_macro"
-version = "0.15.5"
+version = "0.15.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a0d9d1a6191c4f391f87219d1ea42b23f09ee84d64763cd05ee6ea88d9f384d"
+checksum = "5f7d21ccd03305a674437ee1248f3ab5d4b1db095cf1caf49f1713ddf61956b7"
 dependencies = [
  "Inflector",
  "proc-macro-error",
@@ -1553,12 +1621,6 @@ dependencies = [
  "winapi",
 ]
 
-[[package]]
-name = "overload"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
-
 [[package]]
 name = "parking_lot"
 version = "0.12.1"
@@ -1571,22 +1633,26 @@ dependencies = [
 
 [[package]]
 name = "parking_lot_core"
-version = "0.9.4"
+version = "0.9.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4dc9e0dc2adc1c69d09143aff38d3d30c5c3f0df0dad82e6d25547af174ebec0"
+checksum = "9069cbb9f99e3a5083476ccb29ceb1de18b9118cafa53e90c9551235de2b9521"
 dependencies = [
  "cfg-if",
  "libc",
- "redox_syscall",
+ "redox_syscall 0.2.16",
  "smallvec",
- "windows-sys 0.42.0",
+ "windows-sys 0.45.0",
 ]
 
 [[package]]
-name = "paste"
-version = "1.0.9"
+name = "parse_datetime"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1de2e551fb905ac83f73f7aedf2f0cb4a0da7e35efa24a202a936269f1f18e1"
+checksum = "fecceaede7767a9a98058687a321bc91742eff7670167a34104afb30fc8757df"
+dependencies = [
+ "chrono",
+ "regex",
+]
 
 [[package]]
 name = "peeking_take_while"
@@ -1652,9 +1718,9 @@ checksum = "6ac9a59f73473f1b8d852421e59e64809f025994837ef743615c6d0c5b305160"
 
 [[package]]
 name = "platform-info"
-version = "1.0.2"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e7c23cfae725ae06d9e43010153fa77bdfa8c827bf08fe4beeb2a3514e6be12"
+checksum = "827dc4f7a81331d48c8abf11b5ac18673b390d33e9632327e286d940289aefab"
 dependencies = [
  "libc",
  "winapi",
@@ -1719,15 +1785,15 @@ dependencies = [
 
 [[package]]
 name = "procfs"
-version = "0.14.1"
+version = "0.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dfb6451c91904606a1abe93e83a8ec851f45827fa84273f256ade45dc095818"
+checksum = "943ca7f9f29bab5844ecd8fdb3992c5969b6622bb9609b9502fef9b4310e3f1f"
 dependencies = [
  "bitflags",
  "byteorder",
  "hex",
  "lazy_static",
- "rustix 0.35.13",
+ "rustix 0.36.14",
 ]
 
 [[package]]
@@ -1797,20 +1863,19 @@ dependencies = [
 
 [[package]]
 name = "rayon"
-version = "1.6.0"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e060280438193c554f654141c9ea9417886713b7acd75974c85b18a69a88e0b"
+checksum = "1d2df5196e37bcc87abebc0053e20787d73847bb33134a69841207dd0a47f03b"
 dependencies = [
- "crossbeam-deque",
  "either",
  "rayon-core",
 ]
 
 [[package]]
 name = "rayon-core"
-version = "1.10.1"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cac410af5d00ab6884528b4ab69d1e8e146e8d471201800fa1b4524126de6ad3"
+checksum = "4b8f95bd6966f5c87776639160a66bd8ab9895d9d4ab01ddba9fc60661aebe8d"
 dependencies = [
  "crossbeam-channel",
  "crossbeam-deque",
@@ -1827,6 +1892,15 @@ dependencies = [
  "bitflags",
 ]
 
+[[package]]
+name = "redox_syscall"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29"
+dependencies = [
+ "bitflags",
+]
+
 [[package]]
 name = "reference-counted-singleton"
 version = "0.1.2"
@@ -1835,11 +1909,11 @@ checksum = "f1bfbf25d7eb88ddcbb1ec3d755d0634da8f7657b2cb8b74089121409ab8228f"
 
 [[package]]
 name = "regex"
-version = "1.7.1"
+version = "1.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48aaa5748ba571fb95cd2c85c09f629215d3a6ece942baa100950af03a34f733"
+checksum = "d0ab3ca65655bb1e41f2a8c8cd662eb4fb035e67c3f78da1d61dffe89d07300f"
 dependencies = [
- "aho-corasick",
+ "aho-corasick 1.0.1",
  "memchr",
  "regex-syntax",
 ]
@@ -1852,18 +1926,9 @@ checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
 
 [[package]]
 name = "regex-syntax"
-version = "0.6.28"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"
-
-[[package]]
-name = "remove_dir_all"
-version = "0.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
-dependencies = [
- "winapi",
-]
+checksum = "436b050e76ed2903236f032a59761c1eb99e1b0aead2c257922771dab1fc8c78"
 
 [[package]]
 name = "rlimit"
@@ -1875,10 +1940,16 @@ dependencies = [
 ]
 
 [[package]]
-name = "rstest"
-version = "0.16.0"
+name = "roff"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b07f2d176c472198ec1e6551dc7da28f1c089652f66a7b722676c2238ebc0edf"
+checksum = "b833d8d034ea094b1ea68aa6d5c740e0d04bad9d16568d08ba6f76823a114316"
+
+[[package]]
+name = "rstest"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de1bb486a691878cd320c2f0d319ba91eeaa2e894066d8b5f8f117c000e9d962"
 dependencies = [
  "futures",
  "futures-timer",
@@ -1888,9 +1959,9 @@ dependencies = [
 
 [[package]]
 name = "rstest_macros"
-version = "0.16.0"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7229b505ae0706e64f37ffc54a9c163e11022a6636d58fe1f3f52018257ff9f7"
+checksum = "290ca1a1c8ca7edb7c3283bd44dc35dd54fdec6253a3912e201ba1072018fca8"
 dependencies = [
  "cfg-if",
  "proc-macro2",
@@ -1927,37 +1998,31 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "0.35.13"
+version = "0.36.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "727a1a6d65f786ec22df8a81ca3121107f235970dc1705ed681d3e6e8b9cd5f9"
+checksum = "14e4d67015953998ad0eb82887a0eb0129e18a7e2f3b7b0f6c422fddcd503d62"
 dependencies = [
  "bitflags",
  "errno",
- "io-lifetimes 0.7.5",
- "libc",
- "linux-raw-sys 0.0.46",
- "windows-sys 0.42.0",
-]
-
-[[package]]
-name = "rustix"
-version = "0.36.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f43abb88211988493c1abb44a70efa56ff0ce98f233b7b276146f1f3f7ba9644"
-dependencies = [
- "bitflags",
- "errno",
- "io-lifetimes 1.0.5",
+ "io-lifetimes",
  "libc",
  "linux-raw-sys 0.1.4",
  "windows-sys 0.45.0",
 ]
 
 [[package]]
-name = "rustversion"
-version = "1.0.9"
+name = "rustix"
+version = "0.37.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97477e48b4cf8603ad5f7aaf897467cf42ab4218a38ef76fb14c2d6773a6d6a8"
+checksum = "acf8729d8542766f1b2cf77eb034d52f40d375bb8b615d0b147089946e16613d"
+dependencies = [
+ "bitflags",
+ "errno",
+ "io-lifetimes",
+ "libc",
+ "linux-raw-sys 0.3.8",
+ "windows-sys 0.48.0",
+]
 
 [[package]]
 name = "same-file"
@@ -1996,9 +2061,9 @@ dependencies = [
 
 [[package]]
 name = "selinux-sys"
-version = "0.6.1"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4c02c5c6e2db8a78b3ffffc666f75fcda5bbd7068ba3c0f560e5504f4d88443"
+checksum = "806d381649bb85347189d2350728817418138d11d738e2482cb644ec7f3c755d"
 dependencies = [
  "bindgen",
  "cc",
@@ -2042,9 +2107,9 @@ dependencies = [
 
 [[package]]
 name = "sha3"
-version = "0.10.6"
+version = "0.10.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bdf0c33fae925bdc080598b84bc15c55e7b9a4a43b3c704da051f977469691c9"
+checksum = "75872d278a8f37ef87fa0ddbda7802605cb18344497949862c0d4dcb291eba60"
 dependencies = [
  "digest",
  "keccak",
@@ -2058,9 +2123,9 @@ checksum = "43b2853a4d09f215c24cc5489c992ce46052d359b5109343cbafbf26bc62f8a3"
 
 [[package]]
 name = "signal-hook"
-version = "0.3.14"
+version = "0.3.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a253b5e89e2698464fc26b545c9edceb338e18a89effeeecfea192c3025be29d"
+checksum = "732768f1176d21d09e076c23a93123d40bba92d50c4058da34d45c8de8e682b9"
 dependencies = [
  "libc",
  "signal-hook-registry",
@@ -2103,9 +2168,9 @@ dependencies = [
 
 [[package]]
 name = "sm3"
-version = "0.4.1"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f943a7c5e3089f2bd046221d1e9f4fa59396bf0fe966360983649683086215da"
+checksum = "ebb9a3b702d0a7e33bc4d85a14456633d2b165c2ad839c5fd9a8417c1ab15860"
 dependencies = [
  "digest",
 ]
@@ -2124,12 +2189,12 @@ checksum = "f67ad224767faa3c7d8b6d91985b78e70a1324408abcb1cfcc2be4c06bc06043"
 
 [[package]]
 name = "socket2"
-version = "0.4.7"
+version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02e2d2db9033d13a1567121ddd7a095ee144db4e1ca1b1bda3419bc0da294ebd"
+checksum = "2538b18701741680e0322a2302176d3253a35388e2e62f172f64f4f16605f877"
 dependencies = [
  "libc",
- "winapi",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -2144,25 +2209,6 @@ version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
 
-[[package]]
-name = "strum"
-version = "0.24.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "063e6045c0e62079840579a7e47a355ae92f60eb74daaf156fb1e84ba164e63f"
-
-[[package]]
-name = "strum_macros"
-version = "0.24.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e385be0d24f186b4ce2f9982191e7101bb737312ad61c1f2f984f34bcf85d59"
-dependencies = [
- "heck",
- "proc-macro2",
- "quote",
- "rustversion",
- "syn",
-]
-
 [[package]]
 name = "subtle"
 version = "2.4.1"
@@ -2182,16 +2228,16 @@ dependencies = [
 
 [[package]]
 name = "tempfile"
-version = "3.3.0"
+version = "3.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4"
+checksum = "31c0432476357e58790aaa47a8efb0c5138f137343f3b5f23bd36a27e3b0a6d6"
 dependencies = [
+ "autocfg",
  "cfg-if",
  "fastrand",
- "libc",
- "redox_syscall",
- "remove_dir_all",
- "winapi",
+ "redox_syscall 0.3.5",
+ "rustix 0.37.19",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -2214,12 +2260,12 @@ dependencies = [
 
 [[package]]
 name = "terminal_size"
-version = "0.2.2"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40ca90c434fd12083d1a6bdcbe9f92a14f96c8a1ba600ba451734ac334521f7a"
+checksum = "8e6bf6f19e9f8ed8d4048dc22981458ebcf406d67e94cd422e5ecd73d63b3237"
 dependencies = [
- "rustix 0.35.13",
- "windows-sys 0.42.0",
+ "rustix 0.37.19",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -2256,9 +2302,9 @@ dependencies = [
 
 [[package]]
 name = "time"
-version = "0.3.17"
+version = "0.3.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a561bf4617eebd33bca6434b988f39ed798e527f51a1e797d0ee4f61c0a38376"
+checksum = "cd0cbfecb4d19b5ea75bb31ad904eb5b9fa13f21079c3b92017ebdf4999a5890"
 dependencies = [
  "itoa",
  "libc",
@@ -2276,9 +2322,9 @@ checksum = "2e153e1f1acaef8acc537e68b44906d2db6436e2b35ac2c6b42640fff91f00fd"
 
 [[package]]
 name = "time-macros"
-version = "0.2.6"
+version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d967f99f534ca7e495c575c62638eebc2898a8c84c119b89e250477bc4ba16b2"
+checksum = "fd80a657e71da814b8e5d60d3374fc6d35045062245d80224748ae522dd76f36"
 dependencies = [
  "time-core",
 ]
@@ -2307,9 +2353,9 @@ dependencies = [
 
 [[package]]
 name = "unicode-segmentation"
-version = "1.10.0"
+version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fdbf052a0783de01e944a6ce7a8cb939e295b1e7be835a1112c3b9a7f047a5a"
+checksum = "1dd624098567895118886609431a7c3b8f516e41d30e0643f03d94592a147e36"
 
 [[package]]
 name = "unicode-width"
@@ -2325,29 +2371,19 @@ checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
 
 [[package]]
 name = "unindent"
-version = "0.1.10"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58ee9362deb4a96cef4d437d1ad49cffc9b9e92d202b6995674e928ce684f112"
+checksum = "5aa30f5ea51ff7edfc797c6d3f9ec8cbd8cfedef5371766b7181d33977f4814f"
 
 [[package]]
-name = "users"
-version = "0.11.0"
+name = "utf8parse"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24cc0f6d6f267b73e5a2cadf007ba8f9bc39c6a6f9666f8cf25ea809a153b032"
-dependencies = [
- "libc",
- "log",
-]
-
-[[package]]
-name = "utf-8"
-version = "0.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
+checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
 
 [[package]]
 name = "uu_arch"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "platform-info",
@@ -2356,7 +2392,7 @@ dependencies = [
 
 [[package]]
 name = "uu_base32"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -2364,7 +2400,7 @@ dependencies = [
 
 [[package]]
 name = "uu_base64"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "uu_base32",
  "uucore",
@@ -2372,7 +2408,7 @@ dependencies = [
 
 [[package]]
 name = "uu_basename"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -2380,7 +2416,7 @@ dependencies = [
 
 [[package]]
 name = "uu_basenc"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uu_base32",
@@ -2389,7 +2425,7 @@ dependencies = [
 
 [[package]]
 name = "uu_cat"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "is-terminal",
@@ -2400,7 +2436,7 @@ dependencies = [
 
 [[package]]
 name = "uu_chcon"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "fts-sys",
@@ -2412,7 +2448,7 @@ dependencies = [
 
 [[package]]
 name = "uu_chgrp"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -2420,7 +2456,7 @@ dependencies = [
 
 [[package]]
 name = "uu_chmod"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "libc",
@@ -2429,7 +2465,7 @@ dependencies = [
 
 [[package]]
 name = "uu_chown"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -2437,7 +2473,7 @@ dependencies = [
 
 [[package]]
 name = "uu_chroot"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -2445,7 +2481,7 @@ dependencies = [
 
 [[package]]
 name = "uu_cksum"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "hex",
@@ -2454,7 +2490,7 @@ dependencies = [
 
 [[package]]
 name = "uu_comm"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -2462,7 +2498,7 @@ dependencies = [
 
 [[package]]
 name = "uu_cp"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "exacl",
@@ -2478,7 +2514,7 @@ dependencies = [
 
 [[package]]
 name = "uu_csplit"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "regex",
@@ -2488,7 +2524,7 @@ dependencies = [
 
 [[package]]
 name = "uu_cut"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "bstr",
  "clap",
@@ -2499,38 +2535,41 @@ dependencies = [
 
 [[package]]
 name = "uu_date"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "chrono",
  "clap",
  "libc",
+ "parse_datetime",
  "uucore",
- "windows-sys 0.42.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "uu_dd"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "gcd",
  "libc",
+ "nix",
  "signal-hook",
  "uucore",
 ]
 
 [[package]]
 name = "uu_df"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
+ "tempfile",
  "unicode-width",
  "uucore",
 ]
 
 [[package]]
 name = "uu_dir"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uu_ls",
@@ -2539,7 +2578,7 @@ dependencies = [
 
 [[package]]
 name = "uu_dircolors"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -2547,7 +2586,7 @@ dependencies = [
 
 [[package]]
 name = "uu_dirname"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -2555,18 +2594,18 @@ dependencies = [
 
 [[package]]
 name = "uu_du"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "chrono",
  "clap",
  "glob",
  "uucore",
- "windows-sys 0.42.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "uu_echo"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -2574,7 +2613,7 @@ dependencies = [
 
 [[package]]
 name = "uu_env"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "nix",
@@ -2584,7 +2623,7 @@ dependencies = [
 
 [[package]]
 name = "uu_expand"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "unicode-width",
@@ -2593,7 +2632,7 @@ dependencies = [
 
 [[package]]
 name = "uu_expr"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "num-bigint",
@@ -2604,12 +2643,11 @@ dependencies = [
 
 [[package]]
 name = "uu_factor"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "coz",
  "num-traits",
- "paste",
  "quickcheck",
  "rand",
  "smallvec",
@@ -2618,7 +2656,7 @@ dependencies = [
 
 [[package]]
 name = "uu_false"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -2626,7 +2664,7 @@ dependencies = [
 
 [[package]]
 name = "uu_fmt"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "unicode-width",
@@ -2635,7 +2673,7 @@ dependencies = [
 
 [[package]]
 name = "uu_fold"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -2643,7 +2681,7 @@ dependencies = [
 
 [[package]]
 name = "uu_groups"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -2651,7 +2689,7 @@ dependencies = [
 
 [[package]]
 name = "uu_hashsum"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "hex",
@@ -2662,7 +2700,7 @@ dependencies = [
 
 [[package]]
 name = "uu_head"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "memchr",
@@ -2671,7 +2709,7 @@ dependencies = [
 
 [[package]]
 name = "uu_hostid"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "libc",
@@ -2680,17 +2718,17 @@ dependencies = [
 
 [[package]]
 name = "uu_hostname"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "hostname",
  "uucore",
- "windows-sys 0.42.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "uu_id"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "selinux",
@@ -2699,19 +2737,18 @@ dependencies = [
 
 [[package]]
 name = "uu_install"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "file_diff",
  "filetime",
  "libc",
- "time",
  "uucore",
 ]
 
 [[package]]
 name = "uu_join"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "memchr",
@@ -2720,7 +2757,7 @@ dependencies = [
 
 [[package]]
 name = "uu_kill"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "nix",
@@ -2729,7 +2766,7 @@ dependencies = [
 
 [[package]]
 name = "uu_link"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -2737,7 +2774,7 @@ dependencies = [
 
 [[package]]
 name = "uu_ln"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -2745,7 +2782,7 @@ dependencies = [
 
 [[package]]
 name = "uu_logname"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "libc",
@@ -2754,7 +2791,7 @@ dependencies = [
 
 [[package]]
 name = "uu_ls"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "chrono",
  "clap",
@@ -2772,7 +2809,7 @@ dependencies = [
 
 [[package]]
 name = "uu_mkdir"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -2780,7 +2817,7 @@ dependencies = [
 
 [[package]]
 name = "uu_mkfifo"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "libc",
@@ -2789,7 +2826,7 @@ dependencies = [
 
 [[package]]
 name = "uu_mknod"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "libc",
@@ -2798,7 +2835,7 @@ dependencies = [
 
 [[package]]
 name = "uu_mktemp"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "rand",
@@ -2808,7 +2845,7 @@ dependencies = [
 
 [[package]]
 name = "uu_more"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "crossterm",
@@ -2821,7 +2858,7 @@ dependencies = [
 
 [[package]]
 name = "uu_mv"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "fs_extra",
@@ -2831,7 +2868,7 @@ dependencies = [
 
 [[package]]
 name = "uu_nice"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "libc",
@@ -2841,7 +2878,7 @@ dependencies = [
 
 [[package]]
 name = "uu_nl"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "regex",
@@ -2850,7 +2887,7 @@ dependencies = [
 
 [[package]]
 name = "uu_nohup"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "is-terminal",
@@ -2860,7 +2897,7 @@ dependencies = [
 
 [[package]]
 name = "uu_nproc"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "libc",
@@ -2869,7 +2906,7 @@ dependencies = [
 
 [[package]]
 name = "uu_numfmt"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -2877,7 +2914,7 @@ dependencies = [
 
 [[package]]
 name = "uu_od"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "byteorder",
  "clap",
@@ -2887,7 +2924,7 @@ dependencies = [
 
 [[package]]
 name = "uu_paste"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -2895,7 +2932,7 @@ dependencies = [
 
 [[package]]
 name = "uu_pathchk"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "libc",
@@ -2904,7 +2941,7 @@ dependencies = [
 
 [[package]]
 name = "uu_pinky"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -2912,19 +2949,19 @@ dependencies = [
 
 [[package]]
 name = "uu_pr"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
+ "chrono",
  "clap",
  "itertools",
  "quick-error",
  "regex",
- "time",
  "uucore",
 ]
 
 [[package]]
 name = "uu_printenv"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -2932,7 +2969,7 @@ dependencies = [
 
 [[package]]
 name = "uu_printf"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -2940,7 +2977,7 @@ dependencies = [
 
 [[package]]
 name = "uu_ptx"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "regex",
@@ -2949,7 +2986,7 @@ dependencies = [
 
 [[package]]
 name = "uu_pwd"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -2957,7 +2994,7 @@ dependencies = [
 
 [[package]]
 name = "uu_readlink"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -2965,7 +3002,7 @@ dependencies = [
 
 [[package]]
 name = "uu_realpath"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -2973,7 +3010,7 @@ dependencies = [
 
 [[package]]
 name = "uu_relpath"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -2981,18 +3018,18 @@ dependencies = [
 
 [[package]]
 name = "uu_rm"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "libc",
  "uucore",
  "walkdir",
- "windows-sys 0.42.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "uu_rmdir"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "libc",
@@ -3001,7 +3038,7 @@ dependencies = [
 
 [[package]]
 name = "uu_runcon"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "libc",
@@ -3012,7 +3049,7 @@ dependencies = [
 
 [[package]]
 name = "uu_seq"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "bigdecimal",
  "clap",
@@ -3023,16 +3060,17 @@ dependencies = [
 
 [[package]]
 name = "uu_shred"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
+ "libc",
  "rand",
  "uucore",
 ]
 
 [[package]]
 name = "uu_shuf"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "memchr",
@@ -3043,15 +3081,16 @@ dependencies = [
 
 [[package]]
 name = "uu_sleep"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
+ "fundu",
  "uucore",
 ]
 
 [[package]]
 name = "uu_sort"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "binary-heap-plus",
  "clap",
@@ -3070,7 +3109,7 @@ dependencies = [
 
 [[package]]
 name = "uu_split"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "memchr",
@@ -3079,7 +3118,7 @@ dependencies = [
 
 [[package]]
 name = "uu_stat"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -3087,7 +3126,7 @@ dependencies = [
 
 [[package]]
 name = "uu_stdbuf"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "tempfile",
@@ -3097,7 +3136,7 @@ dependencies = [
 
 [[package]]
 name = "uu_stdbuf_libstdbuf"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "cpp",
  "cpp_build",
@@ -3107,7 +3146,7 @@ dependencies = [
 
 [[package]]
 name = "uu_stty"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "nix",
@@ -3116,7 +3155,7 @@ dependencies = [
 
 [[package]]
 name = "uu_sum"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -3124,18 +3163,18 @@ dependencies = [
 
 [[package]]
 name = "uu_sync"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "libc",
  "nix",
  "uucore",
- "windows-sys 0.42.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "uu_tac"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "memchr",
@@ -3146,7 +3185,7 @@ dependencies = [
 
 [[package]]
 name = "uu_tail"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "fundu",
@@ -3154,15 +3193,16 @@ dependencies = [
  "libc",
  "memchr",
  "notify",
+ "rstest",
  "same-file",
  "uucore",
  "winapi-util",
- "windows-sys 0.42.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "uu_tee"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "libc",
@@ -3171,17 +3211,17 @@ dependencies = [
 
 [[package]]
 name = "uu_test"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "libc",
- "redox_syscall",
+ "redox_syscall 0.3.5",
  "uucore",
 ]
 
 [[package]]
 name = "uu_timeout"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "libc",
@@ -3191,18 +3231,19 @@ dependencies = [
 
 [[package]]
 name = "uu_touch"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "filetime",
+ "humantime_to_duration",
  "time",
  "uucore",
- "windows-sys 0.42.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "uu_tr"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "nom",
@@ -3211,7 +3252,7 @@ dependencies = [
 
 [[package]]
 name = "uu_true"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -3219,7 +3260,7 @@ dependencies = [
 
 [[package]]
 name = "uu_truncate"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -3227,7 +3268,7 @@ dependencies = [
 
 [[package]]
 name = "uu_tsort"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -3235,7 +3276,7 @@ dependencies = [
 
 [[package]]
 name = "uu_tty"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "is-terminal",
@@ -3245,7 +3286,7 @@ dependencies = [
 
 [[package]]
 name = "uu_uname"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "platform-info",
@@ -3254,7 +3295,7 @@ dependencies = [
 
 [[package]]
 name = "uu_unexpand"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "unicode-width",
@@ -3263,17 +3304,15 @@ dependencies = [
 
 [[package]]
 name = "uu_uniq"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
- "strum",
- "strum_macros",
  "uucore",
 ]
 
 [[package]]
 name = "uu_unlink"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -3281,7 +3320,7 @@ dependencies = [
 
 [[package]]
 name = "uu_uptime"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "chrono",
  "clap",
@@ -3290,7 +3329,7 @@ dependencies = [
 
 [[package]]
 name = "uu_users"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -3298,7 +3337,7 @@ dependencies = [
 
 [[package]]
 name = "uu_vdir"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uu_ls",
@@ -3307,20 +3346,20 @@ dependencies = [
 
 [[package]]
 name = "uu_wc"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "bytecount",
  "clap",
  "libc",
  "nix",
+ "thiserror",
  "unicode-width",
- "utf-8",
  "uucore",
 ]
 
 [[package]]
 name = "uu_who"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "uucore",
@@ -3328,27 +3367,27 @@ dependencies = [
 
 [[package]]
 name = "uu_whoami"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
  "libc",
  "uucore",
- "windows-sys 0.42.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "uu_yes"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "clap",
- "libc",
+ "itertools",
  "nix",
  "uucore",
 ]
 
 [[package]]
 name = "uucore"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "blake2b_simd",
  "blake3",
@@ -3371,24 +3410,30 @@ dependencies = [
  "sha2",
  "sha3",
  "sm3",
+ "tempfile",
  "thiserror",
  "time",
  "uucore_procs",
  "walkdir",
  "wild",
  "winapi-util",
- "windows-sys 0.42.0",
+ "windows-sys 0.48.0",
  "z85",
 ]
 
 [[package]]
 name = "uucore_procs"
-version = "0.0.17"
+version = "0.0.19"
 dependencies = [
  "proc-macro2",
  "quote",
+ "uuhelp_parser",
 ]
 
+[[package]]
+name = "uuhelp_parser"
+version = "0.0.19"
+
 [[package]]
 name = "uuid"
 version = "1.2.2"
@@ -3523,92 +3568,143 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
-[[package]]
-name = "windows-sys"
-version = "0.42.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7"
-dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
-]
-
 [[package]]
 name = "windows-sys"
 version = "0.45.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
 dependencies = [
- "windows-targets",
+ "windows-targets 0.42.2",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets 0.48.0",
 ]
 
 [[package]]
 name = "windows-targets"
-version = "0.42.1"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e2522491fbfcd58cc84d47aeb2958948c4b8982e9a2d8a2a35bbaed431390e7"
+checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
 dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
+ "windows_aarch64_gnullvm 0.42.2",
+ "windows_aarch64_msvc 0.42.2",
+ "windows_i686_gnu 0.42.2",
+ "windows_i686_msvc 0.42.2",
+ "windows_x86_64_gnu 0.42.2",
+ "windows_x86_64_gnullvm 0.42.2",
+ "windows_x86_64_msvc 0.42.2",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b1eb6f0cd7c80c79759c929114ef071b87354ce476d9d94271031c0497adfd5"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.0",
+ "windows_aarch64_msvc 0.48.0",
+ "windows_i686_gnu 0.48.0",
+ "windows_i686_msvc 0.48.0",
+ "windows_x86_64_gnu 0.48.0",
+ "windows_x86_64_gnullvm 0.48.0",
+ "windows_x86_64_msvc 0.48.0",
 ]
 
 [[package]]
 name = "windows_aarch64_gnullvm"
-version = "0.42.1"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c9864e83243fdec7fc9c5444389dcbbfd258f745e7853198f365e3c4968a608"
+checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91ae572e1b79dba883e0d315474df7305d12f569b400fcf90581b06062f7e1bc"
 
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.42.1"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c8b1b673ffc16c47a9ff48570a9d85e25d265735c503681332589af6253c6c7"
+checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2ef27e0d7bdfcfc7b868b317c1d32c641a6fe4629c171b8928c7b08d98d7cf3"
 
 [[package]]
 name = "windows_i686_gnu"
-version = "0.42.1"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de3887528ad530ba7bdbb1faa8275ec7a1155a45ffa57c37993960277145d640"
+checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "622a1962a7db830d6fd0a69683c80a18fda201879f0f447f065a3b7467daa241"
 
 [[package]]
 name = "windows_i686_msvc"
-version = "0.42.1"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf4d1122317eddd6ff351aa852118a2418ad4214e6613a50e0191f7004372605"
+checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4542c6e364ce21bf45d69fdd2a8e455fa38d316158cfd43b3ac1c5b1b19f8e00"
 
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.42.1"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1040f221285e17ebccbc2591ffdc2d44ee1f9186324dd3e84e99ac68d699c45"
+checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca2b8a661f7628cbd23440e50b05d705db3686f894fc9580820623656af974b1"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.42.1"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "628bfdf232daa22b0d64fdb62b09fcc36bb01f05a3939e20ab73aaf9470d0463"
+checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7896dbc1f41e08872e9d5e8f8baa8fdd2677f29468c4e156210174edc7f7b953"
 
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.42.1"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "447660ad36a13288b1db4d4248e857b510e8c3a225c822ba4fb748c0aafecffd"
+checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
 
 [[package]]
 name = "xattr"
-version = "0.2.3"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d1526bbe5aaeb5eb06885f4d987bcdfa5e23187055de9b83fe00156a821fabc"
+checksum = "ea263437ca03c1522846a4ddafbca2542d0ad5ed9b784909d4b27b76f62bc34a"
 dependencies = [
  "libc",
 ]
@@ -3627,9 +3723,9 @@ checksum = "2a599daf1b507819c1121f0bf87fa37eb19daac6aff3aefefd4e6e2e0f2020fc"
 
 [[package]]
 name = "zip"
-version = "0.6.3"
+version = "0.6.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "537ce7411d25e54e8ae21a7ce0b15840e7bfcff15b51d697ec3266cc76bdf080"
+checksum = "760394e246e4c28189f19d488c058bf16f564016aefac5d32bb1f3b51d5e9261"
 dependencies = [
  "byteorder",
  "crc32fast",
diff --git a/Cargo.toml b/Cargo.toml
index 61a461deb..09e120957 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,11 +1,11 @@
 # coreutils (uutils)
 # * see the repository LICENSE, README, and CONTRIBUTING files for more information
 
-# spell-checker:ignore (libs) libselinux gethostid procfs bigdecimal kqueue fundu
+# spell-checker:ignore (libs) libselinux gethostid procfs bigdecimal kqueue fundu mangen datetime uuhelp
 
 [package]
 name = "coreutils"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "coreutils ~ GNU coreutils (updated); implemented as universal (cross-platform) utils, written in Rust"
@@ -22,16 +22,16 @@ edition = "2021"
 build = "build.rs"
 
 [features]
-default = [ "feat_common_core" ]
+default = ["feat_common_core"]
 ## OS feature shortcodes
-macos = [ "feat_os_macos" ]
-unix = [ "feat_os_unix" ]
-windows = [ "feat_os_windows" ]
+macos = ["feat_os_macos"]
+unix = ["feat_os_unix"]
+windows = ["feat_os_windows"]
 ## project-specific feature shortcodes
 nightly = []
 test_unimplemented = []
 # * only build `uudoc` when `--feature uudoc` is activated
-uudoc = ["zip"]
+uudoc = ["zip", "dep:uuhelp_parser"]
 ## features
 # "feat_acl" == enable support for ACLs (access control lists; by using`--features feat_acl`)
 # NOTE:
@@ -42,426 +42,429 @@ feat_acl = ["cp/feat_acl"]
 # NOTE:
 # * The selinux(-sys) crate requires `libselinux` headers and shared library to be accessible in the C toolchain at compile time.
 # * Running a uutils compiled with `feat_selinux` requires an SELinux enabled Kernel at run time.
-feat_selinux = ["cp/selinux", "id/selinux", "ls/selinux", "selinux", "feat_require_selinux"]
+feat_selinux = [
+  "cp/selinux",
+  "id/selinux",
+  "ls/selinux",
+  "selinux",
+  "feat_require_selinux",
+]
 ##
 ## feature sets
 ## (common/core and Tier1) feature sets
 # "feat_common_core" == baseline core set of utilities which can be built/run on most targets
 feat_common_core = [
-    "base32",
-    "base64",
-    "basename",
-    "basenc",
-    "cat",
-    "cksum",
-    "comm",
-    "cp",
-    "csplit",
-    "cut",
-    "date",
-    "df",
-    "dir",
-    "dircolors",
-    "dirname",
-    "dd",
-    "du",
-    "echo",
-    "env",
-    "expand",
-    "expr",
-    "factor",
-    "false",
-    "fmt",
-    "fold",
-    "hashsum",
-    "head",
-    "join",
-    "link",
-    "ln",
-    "ls",
-    "mkdir",
-    "mktemp",
-    "more",
-    "mv",
-    "nl",
-    "numfmt",
-    "od",
-    "paste",
-    "pr",
-    "printenv",
-    "printf",
-    "ptx",
-    "pwd",
-    "readlink",
-    "realpath",
-    "relpath",
-    "rm",
-    "rmdir",
-    "seq",
-    "shred",
-    "shuf",
-    "sleep",
-    "sort",
-    "split",
-    "sum",
-    "tac",
-    "tail",
-    "tee",
-    "test",
-    "tr",
-    "true",
-    "truncate",
-    "tsort",
-    "touch",
-    "unexpand",
-    "uniq",
-    "unlink",
-    "vdir",
-    "wc",
-    "yes",
+  "base32",
+  "base64",
+  "basename",
+  "basenc",
+  "cat",
+  "cksum",
+  "comm",
+  "cp",
+  "csplit",
+  "cut",
+  "date",
+  "df",
+  "dir",
+  "dircolors",
+  "dirname",
+  "dd",
+  "du",
+  "echo",
+  "env",
+  "expand",
+  "expr",
+  "factor",
+  "false",
+  "fmt",
+  "fold",
+  "hashsum",
+  "head",
+  "join",
+  "link",
+  "ln",
+  "ls",
+  "mkdir",
+  "mktemp",
+  "more",
+  "mv",
+  "nl",
+  "numfmt",
+  "od",
+  "paste",
+  "pr",
+  "printenv",
+  "printf",
+  "ptx",
+  "pwd",
+  "readlink",
+  "realpath",
+  "relpath",
+  "rm",
+  "rmdir",
+  "seq",
+  "shred",
+  "shuf",
+  "sleep",
+  "sort",
+  "split",
+  "sum",
+  "tac",
+  "tail",
+  "tee",
+  "test",
+  "tr",
+  "true",
+  "truncate",
+  "tsort",
+  "touch",
+  "unexpand",
+  "uniq",
+  "unlink",
+  "vdir",
+  "wc",
+  "yes",
 ]
 # "feat_Tier1" == expanded set of utilities which can be built/run on the usual rust "Tier 1" target platforms (ref: <https://forge.rust-lang.org/release/platform-support.html>)
 feat_Tier1 = [
-    "feat_common_core",
-    #
-    "arch",
-    "hostname",
-    "nproc",
-    "sync",
-    "touch",
-    "uname",
-    "whoami",
+  "feat_common_core",
+  #
+  "arch",
+  "hostname",
+  "nproc",
+  "sync",
+  "touch",
+  "uname",
+  "whoami",
 ]
 ## (primary platforms) feature sets
 # "feat_os_macos" == set of utilities which can be built/run on the MacOS platform
 feat_os_macos = [
-    "feat_os_unix", ## == a modern/usual *nix platform
-    #
-    "feat_require_unix_hostid",
+  "feat_os_unix", ## == a modern/usual *nix platform
+  #
+  "feat_require_unix_hostid",
 ]
 # "feat_os_unix" == set of utilities which can be built/run on modern/usual *nix platforms
 feat_os_unix = [
-    "feat_Tier1",
-    #
-    "feat_require_crate_cpp",
-    "feat_require_unix",
-    "feat_require_unix_utmpx",
+  "feat_Tier1",
+  #
+  "feat_require_crate_cpp",
+  "feat_require_unix",
+  "feat_require_unix_utmpx",
 ]
 # "feat_os_windows" == set of utilities which can be built/run on modern/usual windows platforms
 feat_os_windows = [
-    "feat_Tier1", ## == "feat_os_windows_legacy" + "hostname"
+  "feat_Tier1", ## == "feat_os_windows_legacy" + "hostname"
 ]
 ## (secondary platforms) feature sets
 # "feat_os_unix_gnueabihf" == set of utilities which can be built/run on the "arm-unknown-linux-gnueabihf" target (ARMv6 Linux [hardfloat])
 feat_os_unix_gnueabihf = [
-    "feat_Tier1",
-    #
-    "feat_require_unix",
-    "feat_require_unix_hostid",
-    "feat_require_unix_utmpx",
+  "feat_Tier1",
+  #
+  "feat_require_unix",
+  "feat_require_unix_hostid",
+  "feat_require_unix_utmpx",
 ]
 # "feat_os_unix_musl" == set of utilities which can be built/run on targets binding to the "musl" library (ref: <https://musl.libc.org/about.html>)
 feat_os_unix_musl = [
-    "feat_Tier1",
-    #
-    "feat_require_unix",
-    "feat_require_unix_hostid",
+  "feat_Tier1",
+  #
+  "feat_require_unix",
+  "feat_require_unix_hostid",
 ]
 feat_os_unix_android = [
-    "feat_Tier1",
-    #
-    "feat_require_unix",
+  "feat_Tier1",
+  #
+  "feat_require_unix",
 ]
 ## feature sets with requirements (restricting cross-platform availability)
 #
 # ** NOTE: these `feat_require_...` sets should be minimized as much as possible to encourage cross-platform availability of utilities
 #
 # "feat_require_crate_cpp" == set of utilities requiring the `cpp` crate (which fail to compile on several platforms; as of 2020-04-23)
-feat_require_crate_cpp = [
-    "stdbuf",
-]
+feat_require_crate_cpp = ["stdbuf"]
 # "feat_require_unix" == set of utilities requiring support which is only available on unix platforms (as of 2020-04-23)
 feat_require_unix = [
-    "chgrp",
-    "chmod",
-    "chown",
-    "chroot",
-    "groups",
-    "id",
-    "install",
-    "kill",
-    "logname",
-    "mkfifo",
-    "mknod",
-    "nice",
-    "nohup",
-    "pathchk",
-    "stat",
-    "stty",
-    "timeout",
-    "tty",
+  "chgrp",
+  "chmod",
+  "chown",
+  "chroot",
+  "groups",
+  "id",
+  "install",
+  "kill",
+  "logname",
+  "mkfifo",
+  "mknod",
+  "nice",
+  "nohup",
+  "pathchk",
+  "stat",
+  "stty",
+  "timeout",
+  "tty",
 ]
 # "feat_require_unix_utmpx" == set of utilities requiring unix utmp/utmpx support
 # * ref: <https://wiki.musl-libc.org/faq.html#Q:-Why-is-the-utmp/wtmp-functionality-only-implemented-as-stubs?>
-feat_require_unix_utmpx = [
-    "pinky",
-    "uptime",
-    "users",
-    "who",
-]
+feat_require_unix_utmpx = ["pinky", "uptime", "users", "who"]
 # "feat_require_unix_hostid" == set of utilities requiring gethostid in libc (only some unixes provide)
-feat_require_unix_hostid = [
-    "hostid",
-]
+feat_require_unix_hostid = ["hostid"]
 # "feat_require_selinux" == set of utilities depending on SELinux.
-feat_require_selinux = [
-    "chcon",
-    "runcon",
-]
+feat_require_selinux = ["chcon", "runcon"]
 ## (alternate/newer/smaller platforms) feature sets
 # "feat_os_unix_fuchsia" == set of utilities which can be built/run on the "Fuchsia" OS (refs: <https://fuchsia.dev>; <https://en.wikipedia.org/wiki/Google_Fuchsia>)
 feat_os_unix_fuchsia = [
-    "feat_common_core",
-    #
-    "feat_require_crate_cpp",
-    #
-    "chgrp",
-    "chmod",
-    "chown",
-    "du",
-    "groups",
-    "hostid",
-    "install",
-    "logname",
-    "mkfifo",
-    "mknod",
-    "nice",
-    "pathchk",
-    "tty",
-    "uname",
-    "unlink",
+  "feat_common_core",
+  #
+  "feat_require_crate_cpp",
+  #
+  "chgrp",
+  "chmod",
+  "chown",
+  "du",
+  "groups",
+  "hostid",
+  "install",
+  "logname",
+  "mkfifo",
+  "mknod",
+  "nice",
+  "pathchk",
+  "tty",
+  "uname",
+  "unlink",
 ]
 # "feat_os_unix_redox" == set of utilities which can be built/run on "Redox OS" (refs: <https://www.redox-os.org>; <https://en.wikipedia.org/wiki/Redox_(operating_system)>)
 feat_os_unix_redox = [
-    "feat_common_core",
-    #
-    "chmod",
-    "uname",
+  "feat_common_core",
+  #
+  "chmod",
+  "uname",
 ]
 # "feat_os_windows_legacy" == slightly restricted set of utilities which can be built/run on early windows platforms (eg, "WinXP")
 feat_os_windows_legacy = [
-    "feat_common_core",
-    #
-    "arch",
-    "nproc",
-    "sync",
-    "touch",
-    "whoami",
+  "feat_common_core",
+  #
+  "arch",
+  "nproc",
+  "sync",
+  "touch",
+  "whoami",
 ]
 ##
 # * bypass/override ~ translate 'test' feature name to avoid dependency collision with rust core 'test' crate (o/w surfaces as compiler errors during testing)
-test = [ "uu_test" ]
+test = ["uu_test"]
 
 [workspace.dependencies]
 bigdecimal = "0.3"
 binary-heap-plus = "0.5.0"
-bstr = "1.0"
+bstr = "1.5"
 bytecount = "0.6.3"
-byteorder = "1.3.2"
-chrono = { version="^0.4.23", default-features=false, features=["std", "alloc", "clock"]}
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-clap_complete = "4.0"
+byteorder = "1.4.3"
+chrono = { version = "^0.4.26", default-features = false, features = [
+  "std",
+  "alloc",
+  "clock",
+] }
+clap = { version = "4.3", features = ["wrap_help", "cargo"] }
+clap_complete = "4.3"
+clap_mangen = "0.2"
 compare = "0.1.0"
 coz = { version = "0.1.3" }
-crossterm = ">=0.19"
-ctrlc = { version = "3.0", features = ["termination"] }
-exacl = "0.9.0"
+crossterm = ">=0.26.1"
+ctrlc = { version = "3.4", features = ["termination"] }
+exacl = "0.10.0"
 file_diff = "1.0.0"
 filetime = "0.2"
 fnv = "1.0.7"
-fs_extra = "1.1.0"
+fs_extra = "1.3.0"
 fts-sys = "0.2"
-fundu = "0.3.0"
-gcd = "2.2"
-glob = "0.3.0"
-half = "2.1"
+fundu = "1.0.0"
+gcd = "2.3"
+glob = "0.3.1"
+half = "2.2"
 indicatif = "0.17"
-is-terminal = "0.4.3"
-itertools = "0.10.0"
-libc = "0.2.139"
-lscolors = { version = "0.13.0", default-features=false, features = ["nu-ansi-term"] }
+is-terminal = "0.4.7"
+itertools = "0.10.5"
+libc = "0.2.146"
+lscolors = { version = "0.14.0", default-features = false, features = [
+  "nu-ansi-term",
+] }
 memchr = "2"
-nix = { version="0.26", default-features=false }
-nom = "7.1.1"
-notify = { version = "=5.0.0", features=["macos_kqueue"]}
-num_cpus = "1.14"
-num-bigint = "0.4.0"
+nix = { version = "0.26", default-features = false }
+nom = "7.1.3"
+notify = { version = "=6.0.0", features = ["macos_kqueue"] }
+num-bigint = "0.4.3"
 num-traits = "0.2.15"
 number_prefix = "0.4"
-once_cell = "1.13.1"
+once_cell = "1.18.0"
 onig = { version = "~6.4", default-features = false }
-ouroboros = "0.15.5"
+ouroboros = "0.15.6"
+parse_datetime = "0.4.0"
 phf = "0.11.1"
 phf_codegen = "0.11.1"
-platform-info = "1.0.2"
+platform-info = "2.0.1"
 quick-error = "2.0.1"
 rand = { version = "0.8", features = ["small_rng"] }
 rand_core = "0.6"
-rayon = "1.5"
-redox_syscall = "0.2"
-regex = "1.7.1"
+rayon = "1.7"
+redox_syscall = "0.3"
+regex = "1.8.4"
+rstest = "0.17.0"
 rust-ini = "0.18.0"
 same-file = "1.0.6"
 selinux = "0.4"
-signal-hook = "0.3.14"
+signal-hook = "0.3.15"
 smallvec = { version = "1.10", features = ["union"] }
-strum = "0.24.1"
-strum_macros = "0.24.2"
-tempfile = "3.3.0"
+tempfile = "3.6.0"
 term_grid = "0.1.5"
-terminal_size = "0.2.2"
-textwrap = { version="0.16.0", features=["terminal_size"] }
+terminal_size = "0.2.6"
+textwrap = { version = "0.16.0", features = ["terminal_size"] }
 thiserror = "1.0"
-time = { version="0.3" }
-unicode-segmentation = "1.9.0"
-unicode-width = "0.1.8"
+time = { version = "0.3" }
+unicode-segmentation = "1.10.1"
+unicode-width = "0.1.10"
 utf-8 = "0.7.6"
-walkdir = "2.2"
+walkdir = "2.3"
 winapi-util = "0.1.5"
-windows-sys = { version="0.42.0", default-features=false }
-xattr = "0.2.3"
-zip = { version = "0.6.3", default_features=false, features=["deflate"] }
+windows-sys = { version = "0.48.0", default-features = false }
+xattr = "1.0.0"
+zip = { version = "0.6.6", default_features = false, features = ["deflate"] }
 
 hex = "0.4.3"
 md-5 = "0.10.5"
-sha1 = "0.10.1"
-sha2 = "0.10.2"
-sha3 = "0.10.6"
+sha1 = "0.10.5"
+sha2 = "0.10.6"
+sha3 = "0.10.8"
 blake2b_simd = "1.0.1"
-blake3 = "1.3.2"
-sm3 = "0.4.1"
-digest = "0.10.6"
+blake3 = "1.4.0"
+sm3 = "0.4.2"
+digest = "0.10.7"
 
-uucore = { version=">=0.0.17", package="uucore", path="src/uucore" }
-uucore_procs = { version=">=0.0.17", package="uucore_procs", path="src/uucore_procs" }
-uu_ls = { version=">=0.0.17", path="src/uu/ls" }
-uu_base32 = { version=">=0.0.17", path="src/uu/base32"}
+uucore = { version = ">=0.0.19", package = "uucore", path = "src/uucore" }
+uucore_procs = { version = ">=0.0.19", package = "uucore_procs", path = "src/uucore_procs" }
+uu_ls = { version = ">=0.0.18", path = "src/uu/ls" }
+uu_base32 = { version = ">=0.0.18", path = "src/uu/base32" }
 
 [dependencies]
-clap = { workspace=true }
-once_cell = { workspace=true }
-uucore = { workspace=true }
-clap_complete = { workspace=true }
-phf = { workspace=true }
-selinux = { workspace=true, optional = true }
-textwrap = { workspace=true }
-zip = { workspace=true, optional = true }
+clap = { workspace = true }
+once_cell = { workspace = true }
+uucore = { workspace = true }
+clap_complete = { workspace = true }
+clap_mangen = { workspace = true }
+phf = { workspace = true }
+selinux = { workspace = true, optional = true }
+textwrap = { workspace = true }
+zip = { workspace = true, optional = true }
+
+uuhelp_parser = { optional = true, version = ">=0.0.19", path = "src/uuhelp_parser" }
 
 # * uutils
-uu_test  = { optional=true, version="0.0.17", package="uu_test", path="src/uu/test" }
+uu_test = { optional = true, version = "0.0.19", package = "uu_test", path = "src/uu/test" }
 #
-arch     = { optional=true, version="0.0.17", package="uu_arch", path="src/uu/arch" }
-base32   = { optional=true, version="0.0.17", package="uu_base32", path="src/uu/base32" }
-base64   = { optional=true, version="0.0.17", package="uu_base64", path="src/uu/base64" }
-basename = { optional=true, version="0.0.17", package="uu_basename", path="src/uu/basename" }
-basenc   = { optional=true, version="0.0.17", package="uu_basenc", path="src/uu/basenc" }
-cat      = { optional=true, version="0.0.17", package="uu_cat", path="src/uu/cat" }
-chcon    = { optional=true, version="0.0.17", package="uu_chcon", path="src/uu/chcon" }
-chgrp    = { optional=true, version="0.0.17", package="uu_chgrp", path="src/uu/chgrp" }
-chmod    = { optional=true, version="0.0.17", package="uu_chmod", path="src/uu/chmod" }
-chown    = { optional=true, version="0.0.17", package="uu_chown", path="src/uu/chown" }
-chroot   = { optional=true, version="0.0.17", package="uu_chroot", path="src/uu/chroot" }
-cksum    = { optional=true, version="0.0.17", package="uu_cksum", path="src/uu/cksum" }
-comm     = { optional=true, version="0.0.17", package="uu_comm", path="src/uu/comm" }
-cp       = { optional=true, version="0.0.17", package="uu_cp", path="src/uu/cp" }
-csplit   = { optional=true, version="0.0.17", package="uu_csplit", path="src/uu/csplit" }
-cut      = { optional=true, version="0.0.17", package="uu_cut", path="src/uu/cut" }
-date     = { optional=true, version="0.0.17", package="uu_date", path="src/uu/date" }
-dd       = { optional=true, version="0.0.17", package="uu_dd", path="src/uu/dd" }
-df       = { optional=true, version="0.0.17", package="uu_df", path="src/uu/df" }
-dir      = { optional=true, version="0.0.17", package="uu_dir", path="src/uu/dir" }
-dircolors= { optional=true, version="0.0.17", package="uu_dircolors", path="src/uu/dircolors" }
-dirname  = { optional=true, version="0.0.17", package="uu_dirname", path="src/uu/dirname" }
-du       = { optional=true, version="0.0.17", package="uu_du", path="src/uu/du" }
-echo     = { optional=true, version="0.0.17", package="uu_echo", path="src/uu/echo" }
-env      = { optional=true, version="0.0.17", package="uu_env", path="src/uu/env" }
-expand   = { optional=true, version="0.0.17", package="uu_expand", path="src/uu/expand" }
-expr     = { optional=true, version="0.0.17", package="uu_expr", path="src/uu/expr" }
-factor   = { optional=true, version="0.0.17", package="uu_factor", path="src/uu/factor" }
-false    = { optional=true, version="0.0.17", package="uu_false", path="src/uu/false" }
-fmt      = { optional=true, version="0.0.17", package="uu_fmt", path="src/uu/fmt" }
-fold     = { optional=true, version="0.0.17", package="uu_fold", path="src/uu/fold" }
-groups   = { optional=true, version="0.0.17", package="uu_groups", path="src/uu/groups" }
-hashsum  = { optional=true, version="0.0.17", package="uu_hashsum", path="src/uu/hashsum" }
-head     = { optional=true, version="0.0.17", package="uu_head", path="src/uu/head" }
-hostid   = { optional=true, version="0.0.17", package="uu_hostid", path="src/uu/hostid" }
-hostname = { optional=true, version="0.0.17", package="uu_hostname", path="src/uu/hostname" }
-id       = { optional=true, version="0.0.17", package="uu_id", path="src/uu/id" }
-install  = { optional=true, version="0.0.17", package="uu_install", path="src/uu/install" }
-join     = { optional=true, version="0.0.17", package="uu_join", path="src/uu/join" }
-kill     = { optional=true, version="0.0.17", package="uu_kill", path="src/uu/kill" }
-link     = { optional=true, version="0.0.17", package="uu_link", path="src/uu/link" }
-ln       = { optional=true, version="0.0.17", package="uu_ln", path="src/uu/ln" }
-ls       = { optional=true, version="0.0.17", package="uu_ls", path="src/uu/ls" }
-logname  = { optional=true, version="0.0.17", package="uu_logname", path="src/uu/logname" }
-mkdir    = { optional=true, version="0.0.17", package="uu_mkdir", path="src/uu/mkdir" }
-mkfifo   = { optional=true, version="0.0.17", package="uu_mkfifo", path="src/uu/mkfifo" }
-mknod    = { optional=true, version="0.0.17", package="uu_mknod", path="src/uu/mknod" }
-mktemp   = { optional=true, version="0.0.17", package="uu_mktemp", path="src/uu/mktemp" }
-more     = { optional=true, version="0.0.17", package="uu_more", path="src/uu/more" }
-mv       = { optional=true, version="0.0.17", package="uu_mv", path="src/uu/mv" }
-nice     = { optional=true, version="0.0.17", package="uu_nice", path="src/uu/nice" }
-nl       = { optional=true, version="0.0.17", package="uu_nl", path="src/uu/nl" }
-nohup    = { optional=true, version="0.0.17", package="uu_nohup", path="src/uu/nohup" }
-nproc    = { optional=true, version="0.0.17", package="uu_nproc", path="src/uu/nproc" }
-numfmt   = { optional=true, version="0.0.17", package="uu_numfmt", path="src/uu/numfmt" }
-od       = { optional=true, version="0.0.17", package="uu_od", path="src/uu/od" }
-paste    = { optional=true, version="0.0.17", package="uu_paste", path="src/uu/paste" }
-pathchk  = { optional=true, version="0.0.17", package="uu_pathchk", path="src/uu/pathchk" }
-pinky    = { optional=true, version="0.0.17", package="uu_pinky", path="src/uu/pinky" }
-pr       = { optional=true, version="0.0.17", package="uu_pr", path="src/uu/pr" }
-printenv = { optional=true, version="0.0.17", package="uu_printenv", path="src/uu/printenv" }
-printf   = { optional=true, version="0.0.17", package="uu_printf", path="src/uu/printf" }
-ptx      = { optional=true, version="0.0.17", package="uu_ptx", path="src/uu/ptx" }
-pwd      = { optional=true, version="0.0.17", package="uu_pwd", path="src/uu/pwd" }
-readlink = { optional=true, version="0.0.17", package="uu_readlink", path="src/uu/readlink" }
-realpath = { optional=true, version="0.0.17", package="uu_realpath", path="src/uu/realpath" }
-relpath  = { optional=true, version="0.0.17", package="uu_relpath", path="src/uu/relpath" }
-rm       = { optional=true, version="0.0.17", package="uu_rm", path="src/uu/rm" }
-rmdir    = { optional=true, version="0.0.17", package="uu_rmdir", path="src/uu/rmdir" }
-runcon   = { optional=true, version="0.0.17", package="uu_runcon", path="src/uu/runcon" }
-seq      = { optional=true, version="0.0.17", package="uu_seq", path="src/uu/seq" }
-shred    = { optional=true, version="0.0.17", package="uu_shred", path="src/uu/shred" }
-shuf     = { optional=true, version="0.0.17", package="uu_shuf", path="src/uu/shuf" }
-sleep    = { optional=true, version="0.0.17", package="uu_sleep", path="src/uu/sleep" }
-sort     = { optional=true, version="0.0.17", package="uu_sort", path="src/uu/sort" }
-split    = { optional=true, version="0.0.17", package="uu_split", path="src/uu/split" }
-stat     = { optional=true, version="0.0.17", package="uu_stat", path="src/uu/stat" }
-stdbuf   = { optional=true, version="0.0.17", package="uu_stdbuf", path="src/uu/stdbuf" }
-stty     = { optional=true, version="0.0.17", package="uu_stty", path="src/uu/stty" }
-sum      = { optional=true, version="0.0.17", package="uu_sum", path="src/uu/sum" }
-sync     = { optional=true, version="0.0.17", package="uu_sync", path="src/uu/sync" }
-tac      = { optional=true, version="0.0.17", package="uu_tac", path="src/uu/tac" }
-tail     = { optional=true, version="0.0.17", package="uu_tail", path="src/uu/tail" }
-tee      = { optional=true, version="0.0.17", package="uu_tee", path="src/uu/tee" }
-timeout  = { optional=true, version="0.0.17", package="uu_timeout", path="src/uu/timeout" }
-touch    = { optional=true, version="0.0.17", package="uu_touch", path="src/uu/touch" }
-tr       = { optional=true, version="0.0.17", package="uu_tr", path="src/uu/tr" }
-true     = { optional=true, version="0.0.17", package="uu_true", path="src/uu/true" }
-truncate = { optional=true, version="0.0.17", package="uu_truncate", path="src/uu/truncate" }
-tsort    = { optional=true, version="0.0.17", package="uu_tsort", path="src/uu/tsort" }
-tty      = { optional=true, version="0.0.17", package="uu_tty", path="src/uu/tty" }
-uname    = { optional=true, version="0.0.17", package="uu_uname", path="src/uu/uname" }
-unexpand = { optional=true, version="0.0.17", package="uu_unexpand", path="src/uu/unexpand" }
-uniq     = { optional=true, version="0.0.17", package="uu_uniq", path="src/uu/uniq" }
-unlink   = { optional=true, version="0.0.17", package="uu_unlink", path="src/uu/unlink" }
-uptime   = { optional=true, version="0.0.17", package="uu_uptime", path="src/uu/uptime" }
-users    = { optional=true, version="0.0.17", package="uu_users", path="src/uu/users" }
-vdir     = { optional=true, version="0.0.17", package="uu_vdir", path="src/uu/vdir" }
-wc       = { optional=true, version="0.0.17", package="uu_wc", path="src/uu/wc" }
-who      = { optional=true, version="0.0.17", package="uu_who", path="src/uu/who" }
-whoami   = { optional=true, version="0.0.17", package="uu_whoami", path="src/uu/whoami" }
-yes      = { optional=true, version="0.0.17", package="uu_yes", path="src/uu/yes" }
+arch = { optional = true, version = "0.0.19", package = "uu_arch", path = "src/uu/arch" }
+base32 = { optional = true, version = "0.0.19", package = "uu_base32", path = "src/uu/base32" }
+base64 = { optional = true, version = "0.0.19", package = "uu_base64", path = "src/uu/base64" }
+basename = { optional = true, version = "0.0.19", package = "uu_basename", path = "src/uu/basename" }
+basenc = { optional = true, version = "0.0.19", package = "uu_basenc", path = "src/uu/basenc" }
+cat = { optional = true, version = "0.0.19", package = "uu_cat", path = "src/uu/cat" }
+chcon = { optional = true, version = "0.0.19", package = "uu_chcon", path = "src/uu/chcon" }
+chgrp = { optional = true, version = "0.0.19", package = "uu_chgrp", path = "src/uu/chgrp" }
+chmod = { optional = true, version = "0.0.19", package = "uu_chmod", path = "src/uu/chmod" }
+chown = { optional = true, version = "0.0.19", package = "uu_chown", path = "src/uu/chown" }
+chroot = { optional = true, version = "0.0.19", package = "uu_chroot", path = "src/uu/chroot" }
+cksum = { optional = true, version = "0.0.19", package = "uu_cksum", path = "src/uu/cksum" }
+comm = { optional = true, version = "0.0.19", package = "uu_comm", path = "src/uu/comm" }
+cp = { optional = true, version = "0.0.19", package = "uu_cp", path = "src/uu/cp" }
+csplit = { optional = true, version = "0.0.19", package = "uu_csplit", path = "src/uu/csplit" }
+cut = { optional = true, version = "0.0.19", package = "uu_cut", path = "src/uu/cut" }
+date = { optional = true, version = "0.0.19", package = "uu_date", path = "src/uu/date" }
+dd = { optional = true, version = "0.0.19", package = "uu_dd", path = "src/uu/dd" }
+df = { optional = true, version = "0.0.19", package = "uu_df", path = "src/uu/df" }
+dir = { optional = true, version = "0.0.19", package = "uu_dir", path = "src/uu/dir" }
+dircolors = { optional = true, version = "0.0.19", package = "uu_dircolors", path = "src/uu/dircolors" }
+dirname = { optional = true, version = "0.0.19", package = "uu_dirname", path = "src/uu/dirname" }
+du = { optional = true, version = "0.0.19", package = "uu_du", path = "src/uu/du" }
+echo = { optional = true, version = "0.0.19", package = "uu_echo", path = "src/uu/echo" }
+env = { optional = true, version = "0.0.19", package = "uu_env", path = "src/uu/env" }
+expand = { optional = true, version = "0.0.19", package = "uu_expand", path = "src/uu/expand" }
+expr = { optional = true, version = "0.0.19", package = "uu_expr", path = "src/uu/expr" }
+factor = { optional = true, version = "0.0.19", package = "uu_factor", path = "src/uu/factor" }
+false = { optional = true, version = "0.0.19", package = "uu_false", path = "src/uu/false" }
+fmt = { optional = true, version = "0.0.19", package = "uu_fmt", path = "src/uu/fmt" }
+fold = { optional = true, version = "0.0.19", package = "uu_fold", path = "src/uu/fold" }
+groups = { optional = true, version = "0.0.19", package = "uu_groups", path = "src/uu/groups" }
+hashsum = { optional = true, version = "0.0.19", package = "uu_hashsum", path = "src/uu/hashsum" }
+head = { optional = true, version = "0.0.19", package = "uu_head", path = "src/uu/head" }
+hostid = { optional = true, version = "0.0.19", package = "uu_hostid", path = "src/uu/hostid" }
+hostname = { optional = true, version = "0.0.19", package = "uu_hostname", path = "src/uu/hostname" }
+id = { optional = true, version = "0.0.19", package = "uu_id", path = "src/uu/id" }
+install = { optional = true, version = "0.0.19", package = "uu_install", path = "src/uu/install" }
+join = { optional = true, version = "0.0.19", package = "uu_join", path = "src/uu/join" }
+kill = { optional = true, version = "0.0.19", package = "uu_kill", path = "src/uu/kill" }
+link = { optional = true, version = "0.0.19", package = "uu_link", path = "src/uu/link" }
+ln = { optional = true, version = "0.0.19", package = "uu_ln", path = "src/uu/ln" }
+ls = { optional = true, version = "0.0.19", package = "uu_ls", path = "src/uu/ls" }
+logname = { optional = true, version = "0.0.19", package = "uu_logname", path = "src/uu/logname" }
+mkdir = { optional = true, version = "0.0.19", package = "uu_mkdir", path = "src/uu/mkdir" }
+mkfifo = { optional = true, version = "0.0.19", package = "uu_mkfifo", path = "src/uu/mkfifo" }
+mknod = { optional = true, version = "0.0.19", package = "uu_mknod", path = "src/uu/mknod" }
+mktemp = { optional = true, version = "0.0.19", package = "uu_mktemp", path = "src/uu/mktemp" }
+more = { optional = true, version = "0.0.19", package = "uu_more", path = "src/uu/more" }
+mv = { optional = true, version = "0.0.19", package = "uu_mv", path = "src/uu/mv" }
+nice = { optional = true, version = "0.0.19", package = "uu_nice", path = "src/uu/nice" }
+nl = { optional = true, version = "0.0.19", package = "uu_nl", path = "src/uu/nl" }
+nohup = { optional = true, version = "0.0.19", package = "uu_nohup", path = "src/uu/nohup" }
+nproc = { optional = true, version = "0.0.19", package = "uu_nproc", path = "src/uu/nproc" }
+numfmt = { optional = true, version = "0.0.19", package = "uu_numfmt", path = "src/uu/numfmt" }
+od = { optional = true, version = "0.0.19", package = "uu_od", path = "src/uu/od" }
+paste = { optional = true, version = "0.0.19", package = "uu_paste", path = "src/uu/paste" }
+pathchk = { optional = true, version = "0.0.19", package = "uu_pathchk", path = "src/uu/pathchk" }
+pinky = { optional = true, version = "0.0.19", package = "uu_pinky", path = "src/uu/pinky" }
+pr = { optional = true, version = "0.0.19", package = "uu_pr", path = "src/uu/pr" }
+printenv = { optional = true, version = "0.0.19", package = "uu_printenv", path = "src/uu/printenv" }
+printf = { optional = true, version = "0.0.19", package = "uu_printf", path = "src/uu/printf" }
+ptx = { optional = true, version = "0.0.19", package = "uu_ptx", path = "src/uu/ptx" }
+pwd = { optional = true, version = "0.0.19", package = "uu_pwd", path = "src/uu/pwd" }
+readlink = { optional = true, version = "0.0.19", package = "uu_readlink", path = "src/uu/readlink" }
+realpath = { optional = true, version = "0.0.19", package = "uu_realpath", path = "src/uu/realpath" }
+relpath = { optional = true, version = "0.0.19", package = "uu_relpath", path = "src/uu/relpath" }
+rm = { optional = true, version = "0.0.19", package = "uu_rm", path = "src/uu/rm" }
+rmdir = { optional = true, version = "0.0.19", package = "uu_rmdir", path = "src/uu/rmdir" }
+runcon = { optional = true, version = "0.0.19", package = "uu_runcon", path = "src/uu/runcon" }
+seq = { optional = true, version = "0.0.19", package = "uu_seq", path = "src/uu/seq" }
+shred = { optional = true, version = "0.0.19", package = "uu_shred", path = "src/uu/shred" }
+shuf = { optional = true, version = "0.0.19", package = "uu_shuf", path = "src/uu/shuf" }
+sleep = { optional = true, version = "0.0.19", package = "uu_sleep", path = "src/uu/sleep" }
+sort = { optional = true, version = "0.0.19", package = "uu_sort", path = "src/uu/sort" }
+split = { optional = true, version = "0.0.19", package = "uu_split", path = "src/uu/split" }
+stat = { optional = true, version = "0.0.19", package = "uu_stat", path = "src/uu/stat" }
+stdbuf = { optional = true, version = "0.0.19", package = "uu_stdbuf", path = "src/uu/stdbuf" }
+stty = { optional = true, version = "0.0.19", package = "uu_stty", path = "src/uu/stty" }
+sum = { optional = true, version = "0.0.19", package = "uu_sum", path = "src/uu/sum" }
+sync = { optional = true, version = "0.0.19", package = "uu_sync", path = "src/uu/sync" }
+tac = { optional = true, version = "0.0.19", package = "uu_tac", path = "src/uu/tac" }
+tail = { optional = true, version = "0.0.19", package = "uu_tail", path = "src/uu/tail" }
+tee = { optional = true, version = "0.0.19", package = "uu_tee", path = "src/uu/tee" }
+timeout = { optional = true, version = "0.0.19", package = "uu_timeout", path = "src/uu/timeout" }
+touch = { optional = true, version = "0.0.19", package = "uu_touch", path = "src/uu/touch" }
+tr = { optional = true, version = "0.0.19", package = "uu_tr", path = "src/uu/tr" }
+true = { optional = true, version = "0.0.19", package = "uu_true", path = "src/uu/true" }
+truncate = { optional = true, version = "0.0.19", package = "uu_truncate", path = "src/uu/truncate" }
+tsort = { optional = true, version = "0.0.19", package = "uu_tsort", path = "src/uu/tsort" }
+tty = { optional = true, version = "0.0.19", package = "uu_tty", path = "src/uu/tty" }
+uname = { optional = true, version = "0.0.19", package = "uu_uname", path = "src/uu/uname" }
+unexpand = { optional = true, version = "0.0.19", package = "uu_unexpand", path = "src/uu/unexpand" }
+uniq = { optional = true, version = "0.0.19", package = "uu_uniq", path = "src/uu/uniq" }
+unlink = { optional = true, version = "0.0.19", package = "uu_unlink", path = "src/uu/unlink" }
+uptime = { optional = true, version = "0.0.19", package = "uu_uptime", path = "src/uu/uptime" }
+users = { optional = true, version = "0.0.19", package = "uu_users", path = "src/uu/users" }
+vdir = { optional = true, version = "0.0.19", package = "uu_vdir", path = "src/uu/vdir" }
+wc = { optional = true, version = "0.0.19", package = "uu_wc", path = "src/uu/wc" }
+who = { optional = true, version = "0.0.19", package = "uu_who", path = "src/uu/who" }
+whoami = { optional = true, version = "0.0.19", package = "uu_whoami", path = "src/uu/whoami" }
+yes = { optional = true, version = "0.0.19", package = "uu_yes", path = "src/uu/yes" }
 
 # this breaks clippy linting with: "tests/by-util/test_factor_benches.rs: No such file or directory (os error 2)"
 # factor_benches = { optional = true, version = "0.0.0", package = "uu_factor_benches", path = "tests/benches/factor" }
@@ -472,35 +475,34 @@ yes      = { optional=true, version="0.0.17", package="uu_yes", path="src/uu/yes
 #pin_cc = { version="1.0.61, < 1.0.62", package="cc" } ## cc v1.0.62 has compiler errors for MinRustV v1.32.0, requires 1.34 (for `std::str::split_ascii_whitespace()`)
 
 [dev-dependencies]
-chrono = { workspace=true }
+chrono = { workspace = true }
 conv = "0.3"
-filetime = { workspace=true }
-glob = { workspace=true }
-libc = { workspace=true }
+filetime = { workspace = true }
+glob = { workspace = true }
+libc = { workspace = true }
 pretty_assertions = "1"
-rand = { workspace=true }
-regex = { workspace=true }
-sha1 = { version="0.10", features=["std"] }
-tempfile = { workspace=true }
-time = { workspace=true, features=["local-offset"] }
-unindent = "0.1"
-uucore = { workspace=true, features=["entries", "process", "signals"] }
-walkdir = { workspace=true }
-is-terminal = { workspace=true }
-hex-literal = "0.3.1"
-rstest = "0.16.0"
+rand = { workspace = true }
+regex = { workspace = true }
+sha1 = { version = "0.10", features = ["std"] }
+tempfile = { workspace = true }
+time = { workspace = true, features = ["local-offset"] }
+unindent = "0.2"
+uucore = { workspace = true, features = ["entries", "process", "signals"] }
+walkdir = { workspace = true }
+is-terminal = { workspace = true }
+hex-literal = "0.4.1"
+rstest = "0.17.0"
 
 [target.'cfg(any(target_os = "linux", target_os = "android"))'.dev-dependencies]
-procfs = { version = "0.14", default-features = false }
+procfs = { version = "0.15", default-features = false }
 rlimit = "0.9.1"
 
 [target.'cfg(unix)'.dev-dependencies]
-nix = { workspace=true, features=["process", "signal", "user"] }
-rust-users = { version="0.11", package="users" }
+nix = { workspace = true, features = ["process", "signal", "user"] }
 rand_pcg = "0.3"
 
 [build-dependencies]
-phf_codegen = { workspace=true }
+phf_codegen = { workspace = true }
 
 [[bin]]
 name = "coreutils"
@@ -510,3 +512,22 @@ path = "src/bin/coreutils.rs"
 name = "uudoc"
 path = "src/bin/uudoc.rs"
 required-features = ["uudoc"]
+
+# The default release profile. It contains all optimizations, without
+# sacrificing debug info. With this profile (like in the standard
+# release profile), the debug info and the stack traces will still be available.
+[profile.release]
+lto = true
+
+# A release-like profile that is tuned to be fast, even when being fast
+# compromises on binary size. This includes aborting on panic.
+[profile.release-fast]
+inherits = "release"
+panic = "abort"
+
+# A release-like profile that is as small as possible.
+[profile.release-small]
+inherits = "release"
+opt-level = "z"
+panic = "abort"
+strip = true
diff --git a/DEVELOPER_INSTRUCTIONS.md b/DEVELOPER_INSTRUCTIONS.md
deleted file mode 100644
index 28deb2677..000000000
--- a/DEVELOPER_INSTRUCTIONS.md
+++ /dev/null
@@ -1,70 +0,0 @@
-Documentation
--------------
-
-The source of the documentation is available on:
-
-https://uutils.github.io/dev/coreutils/
-
-The documentation is updated everyday on this repository:
-
-https://github.com/uutils/uutils.github.io/
-
-Running GNU tests
------------------
-
-<!-- spell-checker:ignore gnulib -->
-
-- Check out https://github.com/coreutils/coreutils next to your fork as gnu
-- Check out https://github.com/coreutils/gnulib next to your fork as gnulib
-- Rename the checkout of your fork to uutils
-
-At the end you should have uutils, gnu and gnulib checked out next to each other.
-
-- Run `cd uutils && ./util/build-gnu.sh && cd ..` to get everything ready (this may take a while)
-- Finally, you can run tests with `bash uutils/util/run-gnu-test.sh <tests>`. Instead of `<tests>` insert the tests you want to run, e.g. `tests/misc/wc-proc.sh`.
-
-
-Code Coverage Report Generation
----------------------------------
-
-<!-- spell-checker:ignore (flags) Ccodegen Coverflow Cpanic Zinstrument Zpanic -->
-
-Code coverage report can be generated using [grcov](https://github.com/mozilla/grcov).
-
-### Using Nightly Rust
-
-To generate [gcov-based](https://github.com/mozilla/grcov#example-how-to-generate-gcda-files-for-a-rust-project) coverage report
-
-```bash
-$ export CARGO_INCREMENTAL=0
-$ export RUSTFLAGS="-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
-$ export RUSTDOCFLAGS="-Cpanic=abort"
-$ cargo build <options...> # e.g., --features feat_os_unix
-$ cargo test <options...> # e.g., --features feat_os_unix test_pathchk
-$ grcov . -s . --binary-path ./target/debug/ -t html --branch --ignore-not-existing --ignore build.rs --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?\#\[derive\()" -o ./target/debug/coverage/
-$ # open target/debug/coverage/index.html in browser
-```
-
-if changes are not reflected in the report then run `cargo clean` and run the above commands.
-
-### Using Stable Rust
-
-If you are using stable version of Rust that doesn't enable code coverage instrumentation by default
-then add `-Z-Zinstrument-coverage` flag to `RUSTFLAGS` env variable specified above.
-
-
-pre-commit hooks
-----------------
-
-A configuration for `pre-commit` is provided in the repository. It allows automatically checking every git commit you make to ensure it compiles, and passes `clippy` and `rustfmt` without warnings.
-
-To use the provided hook:
-
-1. [Install `pre-commit`](https://pre-commit.com/#install)
-2. Run `pre-commit install` while in the repository directory
-
-Your git commits will then automatically be checked. If a check fails, an error message will explain why, and your commit will be canceled. You can then make the suggested changes, and run `git commit ...` again.
-
-### Using Clippy
-
-The `msrv` key in the clippy configuration file `clippy.toml` is used to disable lints pertaining to newer features by specifying the minimum supported Rust version (MSRV). However, this key is only supported on `nightly`. To invoke clippy without errors, use `cargo +nightly clippy`. In order to also check tests and non-default crate features, use `cargo +nightly clippy --all-targets --all-features`.
diff --git a/GNUmakefile b/GNUmakefile
index b242bc8ce..26d6de5ba 100644
--- a/GNUmakefile
+++ b/GNUmakefile
@@ -1,4 +1,4 @@
-# spell-checker:ignore (misc) testsuite runtest findstring (targets) busytest toybox distclean pkgs ; (vars/env) BINDIR BUILDDIR CARGOFLAGS DESTDIR DOCSDIR INSTALLDIR INSTALLEES MULTICALL DATAROOTDIR TESTDIR
+# spell-checker:ignore (misc) testsuite runtest findstring (targets) busytest toybox distclean pkgs nextest ; (vars/env) BINDIR BUILDDIR CARGOFLAGS DESTDIR DOCSDIR INSTALLDIR INSTALLEES MULTICALL DATAROOTDIR TESTDIR
 
 # Config options
 PROFILE         ?= debug
@@ -289,6 +289,9 @@ $(foreach test,$(filter-out $(SKIP_UTILS),$(PROGS)),$(eval $(call TEST_BUSYBOX,$
 test:
 	${CARGO} test ${CARGOFLAGS} --features "$(TESTS) $(TEST_SPEC_FEATURE)" --no-default-features $(TEST_NO_FAIL_FAST)
 
+nextest:
+	${CARGO} nextest run ${CARGOFLAGS} --features "$(TESTS) $(TEST_SPEC_FEATURE)" --no-default-features $(TEST_NO_FAIL_FAST)
+
 test_toybox:
 	-(cd $(TOYBOX_SRC)/ && make tests)
 
@@ -349,10 +352,12 @@ endif
 	mkdir -p $(DESTDIR)$(DATAROOTDIR)/zsh/site-functions
 	mkdir -p $(DESTDIR)$(DATAROOTDIR)/bash-completion/completions
 	mkdir -p $(DESTDIR)$(DATAROOTDIR)/fish/vendor_completions.d
+	mkdir -p $(DESTDIR)$(DATAROOTDIR)/man/man1
 	$(foreach prog, $(INSTALLEES), \
 		$(BUILDDIR)/coreutils completion $(prog) zsh > $(DESTDIR)$(DATAROOTDIR)/zsh/site-functions/_$(PROG_PREFIX)$(prog); \
 		$(BUILDDIR)/coreutils completion $(prog) bash > $(DESTDIR)$(DATAROOTDIR)/bash-completion/completions/$(PROG_PREFIX)$(prog); \
 		$(BUILDDIR)/coreutils completion $(prog) fish > $(DESTDIR)$(DATAROOTDIR)/fish/vendor_completions.d/$(PROG_PREFIX)$(prog).fish; \
+		$(BUILDDIR)/coreutils manpage $(prog) > $(DESTDIR)$(DATAROOTDIR)/man/man1/$(PROG_PREFIX)$(prog).1; \
 	)
 
 uninstall:
diff --git a/Makefile.toml b/Makefile.toml
index ded2cd55b..84698df5f 100644
--- a/Makefile.toml
+++ b/Makefile.toml
@@ -20,15 +20,12 @@ run_task = "_init"
 
 [tasks._init]
 private = true
-dependencies = [
-	"_init-vars",
-]
+dependencies = ["_init-vars"]
 
 [tasks._init-vars]
 private = true
 script_runner = "@duckscript"
-script = [
-'''
+script = ['''
 # reset build/test flags
 set_env CARGO_MAKE_CARGO_BUILD_TEST_FLAGS ""
 # determine features
@@ -90,54 +87,36 @@ for arg in "${args_utils_list}"
 end
 args_utils = trim "${args_utils}"
 set_env CARGO_MAKE_TASK_BUILD_UTILS_ARGS "${args_utils}"
-'''
-]
+''']
 
 ### tasks
 
 [tasks.default]
 description = "## *DEFAULT* Build (debug-mode) and test project"
 category = "[project]"
-dependencies = [
-	"action-build-debug",
-	"test-terse",
-]
+dependencies = ["action-build-debug", "test-terse"]
 
 ##
 
 [tasks.build]
 description = "## Build (release-mode) project"
 category = "[project]"
-dependencies = [
-	"core::pre-build",
-	"action-build-release",
-	"core::post-build",
-]
+dependencies = ["core::pre-build", "action-build-release", "core::post-build"]
 
 [tasks.build-debug]
 description = "## Build (debug-mode) project"
 category = "[project]"
-dependencies = [
-	"action-build-debug",
-]
+dependencies = ["action-build-debug"]
 
 [tasks.build-examples]
 description = "## Build (release-mode) project example(s); usage: `cargo make (build-examples | examples) [EXAMPLE]...`"
 category = "[project]"
-dependencies = [
-	"core::pre-build",
-	"action-build-examples",
-	"core::post-build",
-]
+dependencies = ["core::pre-build", "action-build-examples", "core::post-build"]
 
 [tasks.build-features]
 description = "## Build (with features; release-mode) project; usage: `cargo make (build-features | features) FEATURE...`"
 category = "[project]"
-dependencies = [
-	"core::pre-build",
-	"action-build-features",
-	"core::post-build",
-]
+dependencies = ["core::pre-build", "action-build-features", "core::post-build"]
 
 [tasks.build-release]
 alias = "build"
@@ -148,9 +127,7 @@ alias = "build-debug"
 [tasks.example]
 description = "hidden singular-form alias for 'examples'"
 category = "[project]"
-dependencies = [
-	"examples",
-]
+dependencies = ["examples"]
 
 [tasks.examples]
 alias = "build-examples"
@@ -161,17 +138,12 @@ alias = "build-features"
 [tasks.format]
 description = "## Format code files (with `cargo fmt`; includes tests)"
 category = "[project]"
-dependencies = [
-	"action-format",
-	"action-format-tests",
-]
+dependencies = ["action-format", "action-format-tests"]
 
 [tasks.help]
 description = "## Display help"
 category = "[project]"
-dependencies = [
-	"action-display-help",
-]
+dependencies = ["action-display-help"]
 
 [tasks.install]
 description = "## Install project binary (to $HOME/.cargo/bin)"
@@ -182,10 +154,7 @@ args = ["install", "--path", "."]
 [tasks.lint]
 description = "## Display lint report"
 category = "[project]"
-dependencies = [
-	"action-clippy",
-	"action-fmt_report",
-]
+dependencies = ["action-clippy", "action-fmt_report"]
 
 [tasks.release]
 alias = "build"
@@ -193,48 +162,32 @@ alias = "build"
 [tasks.test]
 description = "## Run project tests"
 category = "[project]"
-dependencies = [
-	"core::pre-test",
-	"core::test",
-	"core::post-test",
-]
+dependencies = ["core::pre-test", "core::test", "core::post-test"]
 
 [tasks.test-terse]
 description = "## Run project tests (with terse/summary output)"
 category = "[project]"
-dependencies = [
-	"core::pre-test",
-	"action-test_quiet",
-	"core::post-test",
-]
+dependencies = ["core::pre-test", "action-test_quiet", "core::post-test"]
 
 [tasks.test-util]
 description = "## Test (individual) utilities; usage: `cargo make (test-util | test-uutil) [UTIL_NAME...]`"
 category = "[project]"
-dependencies = [
-	"action-test-utils",
-]
+dependencies = ["action-test-utils"]
 
 [tasks.test-utils]
 description = "hidden plural-form alias for 'test-util'"
 category = "[project]"
-dependencies = [
-	"test-util",
-]
+dependencies = ["test-util"]
 
 [tasks.test-uutil]
 description = "hidden alias for 'test-util'"
 category = "[project]"
-dependencies = [
-	"test-util",
-]
+dependencies = ["test-util"]
 
 [tasks.test-uutils]
 description = "hidden alias for 'test-util'"
 category = "[project]"
-dependencies = [
-	"test-util",
-]
+dependencies = ["test-util"]
 
 [tasks.uninstall]
 description = "## Remove project binary (from $HOME/.cargo/bin)"
@@ -246,63 +199,66 @@ args = ["uninstall"]
 description = "## Build (individual; release-mode) utilities; usage: `cargo make (util | uutil) [UTIL_NAME...]`"
 category = "[project]"
 dependencies = [
-	"core::pre-build",
-	"action-determine-utils",
-	"action-build-utils",
-	"core::post-build",
+  "core::pre-build",
+  "action-determine-utils",
+  "action-build-utils",
+  "core::post-build",
 ]
 
 [tasks.utils]
 description = "hidden plural-form alias for 'util'"
 category = "[project]"
-dependencies = [
-	"util",
-]
+dependencies = ["util"]
 
 [tasks.uutil]
 description = "hidden alias for 'util'"
 category = "[project]"
-dependencies = [
-	"util",
-]
+dependencies = ["util"]
 
 [tasks.uutils]
 description = "hidden plural-form alias for 'util'"
 category = "[project]"
-dependencies = [
-	"util",
-]
+dependencies = ["util"]
 
 ### actions
 
 [tasks.action-build-release]
 description = "`cargo build --release`"
 command = "cargo"
-args = ["build", "--release", "@@split(CARGO_MAKE_CARGO_BUILD_TEST_FLAGS, )" ]
+args = ["build", "--release", "@@split(CARGO_MAKE_CARGO_BUILD_TEST_FLAGS, )"]
 
 [tasks.action-build-debug]
 description = "`cargo build`"
 command = "cargo"
-args = ["build", "@@split(CARGO_MAKE_CARGO_BUILD_TEST_FLAGS, )" ]
+args = ["build", "@@split(CARGO_MAKE_CARGO_BUILD_TEST_FLAGS, )"]
 
 [tasks.action-build-examples]
 description = "`cargo build (--examples|(--example EXAMPLE)...)`"
 command = "cargo"
-args = ["build", "--release", "@@split(CARGO_MAKE_CARGO_BUILD_TEST_FLAGS, )", "${CARGO_MAKE_TASK_BUILD_EXAMPLES_ARGS}" ]
+args = [
+  "build",
+  "--release",
+  "@@split(CARGO_MAKE_CARGO_BUILD_TEST_FLAGS, )",
+  "${CARGO_MAKE_TASK_BUILD_EXAMPLES_ARGS}",
+]
 
 [tasks.action-build-features]
 description = "`cargo build --release --features FEATURES`"
 command = "cargo"
-args = ["build", "--release", "--no-default-features", "--features", "${CARGO_MAKE_TASK_BUILD_FEATURES_ARGS}" ]
+args = [
+  "build",
+  "--release",
+  "--no-default-features",
+  "--features",
+  "${CARGO_MAKE_TASK_BUILD_FEATURES_ARGS}",
+]
 
 [tasks.action-build-utils]
 description = "Build individual utilities"
-dependencies = [
-	"action-determine-utils",
-]
+dependencies = ["action-determine-utils"]
 command = "cargo"
 # args = ["build", "@@remove-empty(CARGO_MAKE_TASK_BUILD_UTILS_ARGS)" ]
-args = ["build", "--release", "@@split(CARGO_MAKE_TASK_BUILD_UTILS_ARGS, )" ]
+args = ["build", "--release", "@@split(CARGO_MAKE_TASK_BUILD_UTILS_ARGS, )"]
 
 [tasks.action-clippy]
 description = "`cargo clippy` lint report"
@@ -311,8 +267,7 @@ args = ["clippy", "@@split(CARGO_MAKE_CARGO_BUILD_TEST_FLAGS, )"]
 
 [tasks.action-determine-utils]
 script_runner = "@duckscript"
-script = [
-'''
+script = ['''
 package_options = get_env CARGO_MAKE_TASK_BUILD_UTILS_ARGS
 if is_empty "${package_options}"
 	show_utils = get_env CARGO_MAKE_VAR_SHOW_UTILS
@@ -335,13 +290,11 @@ if is_empty "${package_options}"
 	package_options = trim "${package_options}"
 end_if
 set_env CARGO_MAKE_TASK_BUILD_UTILS_ARGS "${package_options}"
-'''
-]
+''']
 
 [tasks.action-determine-tests]
 script_runner = "@duckscript"
-script = [
-'''
+script = ['''
 test_files = glob_array tests/**/*.rs
 for file in ${test_files}
 	file = replace "${file}" "\\" "/"
@@ -354,8 +307,7 @@ for file in ${test_files}
 	end_if
 end
 set_env CARGO_MAKE_VAR_TESTS "${tests}"
-'''
-]
+''']
 
 [tasks.action-format]
 description = "`cargo fmt`"
@@ -364,9 +316,7 @@ args = ["fmt"]
 
 [tasks.action-format-tests]
 description = "`cargo fmt` tests"
-dependencies = [
-	"action-determine-tests",
-]
+dependencies = ["action-determine-tests"]
 command = "cargo"
 args = ["fmt", "--", "@@split(CARGO_MAKE_VAR_TESTS, )"]
 
@@ -381,16 +331,18 @@ args = ["fmt", "--", "--check"]
 [tasks.action-spellcheck-codespell]
 description = "`codespell` spellcheck repository"
 command = "codespell" # (from `pip install codespell`)
-args = [".", "--skip=*/.git,./target,./tests/fixtures", "--ignore-words-list=mut,od"]
+args = [
+  ".",
+  "--skip=*/.git,./target,./tests/fixtures",
+  "--ignore-words-list=mut,od",
+]
 
 [tasks.action-test-utils]
 description = "Build individual utilities"
-dependencies = [
-	"action-determine-utils",
-]
+dependencies = ["action-determine-utils"]
 command = "cargo"
 # args = ["build", "@@remove-empty(CARGO_MAKE_TASK_BUILD_UTILS_ARGS)" ]
-args = ["test", "@@split(CARGO_MAKE_TASK_BUILD_UTILS_ARGS, )" ]
+args = ["test", "@@split(CARGO_MAKE_TASK_BUILD_UTILS_ARGS, )"]
 
 [tasks.action-test_quiet]
 description = "Test (in `--quiet` mode)"
@@ -399,8 +351,7 @@ args = ["test", "--quiet", "@@split(CARGO_MAKE_CARGO_BUILD_TEST_FLAGS, )"]
 
 [tasks.action-display-help]
 script_runner = "@duckscript"
-script = [
-'''
+script = ['''
 	echo ""
 	echo "usage: `cargo make TARGET [ARGS...]`"
 	echo ""
@@ -432,5 +383,4 @@ script = [
 		end_if
 	end
 	echo ""
-'''
-]
+''']
diff --git a/README.md b/README.md
index 66a0395e9..5a9f968ae 100644
--- a/README.md
+++ b/README.md
@@ -1,114 +1,124 @@
+<!-- markdownlint-disable MD033 MD041 MD002 -->
+<!-- markdownlint-disable commands-show-output no-duplicate-heading -->
+<!-- spell-checker:ignore markdownlint ; (options) DESTDIR UTILNAME manpages reimplementation -->
+<div align="center">
+
+![uutils logo](docs/src/logo.svg)
+
 # uutils coreutils
 
 [![Crates.io](https://img.shields.io/crates/v/coreutils.svg)](https://crates.io/crates/coreutils)
 [![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/coreutils/blob/main/LICENSE)
-[![LOC](https://tokei.rs/b1/github/uutils/coreutils?category=code)](https://github.com/Aaronepower/tokei)
 [![dependency status](https://deps.rs/repo/github/uutils/coreutils/status.svg)](https://deps.rs/repo/github/uutils/coreutils)
 
 [![CodeCov](https://codecov.io/gh/uutils/coreutils/branch/master/graph/badge.svg)](https://codecov.io/gh/uutils/coreutils)
 ![MSRV](https://img.shields.io/badge/MSRV-1.64.0-brightgreen)
 
------------------------------------------------
+</div>
 
-<!-- markdownlint-disable commands-show-output no-duplicate-heading -->
-<!-- spell-checker:ignore markdownlint ; (options) DESTDIR RUNTEST UTILNAME -->
+---
 
-uutils is an attempt at writing universal (as in cross-platform) CLI
-utilities in [Rust](http://www.rust-lang.org).
-While all programs have been implemented, some options might be missing
-or different behavior might be experienced.
+
+uutils coreutils is a cross-platform reimplementation of the GNU coreutils in
+[Rust](http://www.rust-lang.org). While all programs have been implemented, some
+options might be missing or different behavior might be experienced.
 
 To install it:
 
-```
-$ cargo install coreutils
-$ ~/.cargo/bin/coreutils
+```shell
+cargo install coreutils
+~/.cargo/bin/coreutils
 ```
 
-## Why?
+<!-- markdownlint-disable-next-line MD026 -->
 
-uutils aims to work on as many platforms as possible, to be able to use the
-same utils on Linux, Mac, Windows and other platforms. This ensures, for
-example, that scripts can be easily transferred between platforms. Rust was
-chosen not only because it is fast and safe, but is also excellent for
-writing cross-platform code.
+## Goals
+
+uutils aims to be a drop-in replacement for the GNU utils. Differences with GNU
+are treated as bugs.
+
+uutils aims to work on as many platforms as possible, to be able to use the same
+utils on Linux, Mac, Windows and other platforms. This ensures, for example,
+that scripts can be easily transferred between platforms.
 
 ## Documentation
+
 uutils has both user and developer documentation available:
 
 - [User Manual](https://uutils.github.io/user/)
 - [Developer Documentation](https://uutils.github.io/dev/coreutils/)
 
-Both can also be generated locally, the instructions for that can be found in the
-[coreutils docs](https://github.com/uutils/uutils.github.io) repository.
+Both can also be generated locally, the instructions for that can be found in
+the [coreutils docs](https://github.com/uutils/uutils.github.io) repository.
 
 <!-- ANCHOR: build (this mark is needed for mdbook) -->
+
 ## Requirements
 
-* Rust (`cargo`, `rustc`)
-* GNU Make (optional)
+- Rust (`cargo`, `rustc`)
+- GNU Make (optional)
 
 ### Rust Version
 
-uutils follows Rust's release channels and is tested against stable, beta and nightly.
-The current Minimum Supported Rust Version (MSRV) is `1.64.0`.
+uutils follows Rust's release channels and is tested against stable, beta and
+nightly. The current Minimum Supported Rust Version (MSRV) is `1.64.0`.
 
 ## Building
 
-There are currently two methods to build the uutils binaries: either Cargo
-or GNU Make.
+There are currently two methods to build the uutils binaries: either Cargo or
+GNU Make.
 
 > Building the full package, including all documentation, requires both Cargo
 > and Gnu Make on a Unix platform.
 
 For either method, we first need to fetch the repository:
 
-```bash
-$ git clone https://github.com/uutils/coreutils
-$ cd coreutils
+```shell
+git clone https://github.com/uutils/coreutils
+cd coreutils
 ```
 
 ### Cargo
 
-Building uutils using Cargo is easy because the process is the same as for
-every other Rust program:
+Building uutils using Cargo is easy because the process is the same as for every
+other Rust program:
 
-```bash
-$ cargo build --release
+```shell
+cargo build --release
 ```
 
 This command builds the most portable common core set of uutils into a multicall
 (BusyBox-type) binary, named 'coreutils', on most Rust-supported platforms.
 
-Additional platform-specific uutils are often available. Building these
-expanded sets of uutils for a platform (on that platform) is as simple as
-specifying it as a feature:
+Additional platform-specific uutils are often available. Building these expanded
+sets of uutils for a platform (on that platform) is as simple as specifying it
+as a feature:
 
-```bash
-$ cargo build --release --features macos
+```shell
+cargo build --release --features macos
 # or ...
-$ cargo build --release --features windows
+cargo build --release --features windows
 # or ...
-$ cargo build --release --features unix
+cargo build --release --features unix
 ```
 
 If you don't want to build every utility available on your platform into the
-final binary, you can also specify which ones you want to build manually.
-For example:
+final binary, you can also specify which ones you want to build manually. For
+example:
 
-```bash
-$ cargo build --features "base32 cat echo rm" --no-default-features
+```shell
+cargo build --features "base32 cat echo rm" --no-default-features
 ```
 
-If you don't want to build the multicall binary and would prefer to build
-the utilities as individual binaries, that is also possible. Each utility
-is contained in its own package within the main repository, named
-"uu_UTILNAME". To build individual utilities, use cargo to build just the
-specific packages (using the `--package` [aka `-p`] option). For example:
+If you don't want to build the multicall binary and would prefer to build the
+utilities as individual binaries, that is also possible. Each utility is
+contained in its own package within the main repository, named "uu_UTILNAME". To
+build individual utilities, use cargo to build just the specific packages (using
+the `--package` [aka `-p`] option). For example:
 
-```bash
-$ cargo build -p uu_base32 -p uu_cat -p uu_echo -p uu_rm
+```shell
+cargo build -p uu_base32 -p uu_cat -p uu_echo -p uu_rm
 ```
 
 ### GNU Make
@@ -117,80 +127,88 @@ Building using `make` is a simple process as well.
 
 To simply build all available utilities:
 
-```bash
-$ make
+```shell
+make
+```
+
+In release mode:
+
+```shell
+make PROFILE=release
 ```
 
 To build all but a few of the available utilities:
 
-```bash
-$ make SKIP_UTILS='UTILITY_1 UTILITY_2'
+```shell
+make SKIP_UTILS='UTILITY_1 UTILITY_2'
 ```
 
 To build only a few of the available utilities:
 
-```bash
-$ make UTILS='UTILITY_1 UTILITY_2'
+```shell
+make UTILS='UTILITY_1 UTILITY_2'
 ```
 
 ## Installation
 
-### Cargo
+### Install with Cargo
 
 Likewise, installing can simply be done using:
 
-```bash
-$ cargo install --path .
+```shell
+cargo install --path . --locked
 ```
 
-This command will install uutils into Cargo's *bin* folder (*e.g.* `$HOME/.cargo/bin`).
+This command will install uutils into Cargo's _bin_ folder (_e.g._
+`$HOME/.cargo/bin`).
 
-This does not install files necessary for shell completion. For shell completion to work,
-use `GNU Make` or see `Manually install shell completions`.
+This does not install files necessary for shell completion or manpages. For
+manpages or shell completion to work, use `GNU Make` or see
+`Manually install shell completions`/`Manually install manpages`.
 
-### GNU Make
+### Install with GNU Make
 
 To install all available utilities:
 
-```bash
-$ make install
+```shell
+make install
 ```
 
 To install using `sudo` switch `-E` must be used:
 
-```bash
-$ sudo -E make install
+```shell
+sudo -E make install
 ```
 
 To install all but a few of the available utilities:
 
-```bash
-$ make SKIP_UTILS='UTILITY_1 UTILITY_2' install
+```shell
+make SKIP_UTILS='UTILITY_1 UTILITY_2' install
 ```
 
 To install only a few of the available utilities:
 
-```bash
-$ make UTILS='UTILITY_1 UTILITY_2' install
+```shell
+make UTILS='UTILITY_1 UTILITY_2' install
 ```
 
 To install every program with a prefix (e.g. uu-echo uu-cat):
 
-```bash
-$ make PROG_PREFIX=PREFIX_GOES_HERE install
+```shell
+make PROG_PREFIX=PREFIX_GOES_HERE install
 ```
 
 To install the multicall binary:
 
-```bash
-$ make MULTICALL=y install
+```shell
+make MULTICALL=y install
 ```
 
 Set install parent directory (default value is /usr/local):
 
-```bash
+```shell
 # DESTDIR is also supported
-$ make PREFIX=/my/path install
+make PREFIX=/my/path install
 ```
 
 Installing with `make` installs shell completions for all installed utilities
@@ -199,302 +217,94 @@ be generated; See `Manually install shell completions`.
 
 ### Manually install shell completions
 
-The `coreutils` binary can generate completions for the `bash`, `elvish`, `fish`, `powershell`
-and `zsh` shells. It prints the result to stdout.
+The `coreutils` binary can generate completions for the `bash`, `elvish`,
+`fish`, `powershell` and `zsh` shells. It prints the result to stdout.
 
 The syntax is:
-```bash
+
+```shell
 cargo run completion <utility> <shell>
 ```
 
-So, to install completions for `ls` on `bash` to `/usr/local/share/bash-completion/completions/ls`,
-run:
+So, to install completions for `ls` on `bash` to
+`/usr/local/share/bash-completion/completions/ls`, run:
+
+```shell
+cargo run completion ls bash > /usr/local/share/bash-completion/completions/ls
+```
+
+### Manually install manpages
+
+To generate manpages, the syntax is:
 
 ```bash
-cargo run completion ls bash > /usr/local/share/bash-completion/completions/ls
+cargo run manpage <utility>
+```
+
+So, to install the manpage for `ls` to `/usr/local/share/man/man1/ls.1` run:
+
+```bash
+cargo run manpage ls > /usr/local/share/man/man1/ls.1
 ```
 
 ## Un-installation
 
-Un-installation differs depending on how you have installed uutils.  If you used
-Cargo to install, use Cargo to uninstall.  If you used GNU Make to install, use
+Un-installation differs depending on how you have installed uutils. If you used
+Cargo to install, use Cargo to uninstall. If you used GNU Make to install, use
 Make to uninstall.
 
-### Cargo
+### Uninstall with Cargo
 
 To uninstall uutils:
 
-```bash
-$ cargo uninstall uutils
+```shell
+cargo uninstall uutils
 ```
 
-### GNU Make
+### Uninstall with GNU Make
 
 To uninstall all utilities:
 
-```bash
-$ make uninstall
+```shell
+make uninstall
 ```
 
 To uninstall every program with a set prefix:
 
-```bash
-$ make PROG_PREFIX=PREFIX_GOES_HERE uninstall
+```shell
+make PROG_PREFIX=PREFIX_GOES_HERE uninstall
 ```
 
 To uninstall the multicall binary:
 
-```bash
-$ make MULTICALL=y uninstall
+```shell
+make MULTICALL=y uninstall
 ```
 
 To uninstall from a custom parent directory:
 
-```bash
+```shell
 # DESTDIR is also supported
-$ make PREFIX=/my/path uninstall
+make PREFIX=/my/path uninstall
 ```
+
 <!-- ANCHOR_END: build (this mark is needed for mdbook) -->
 
-## Testing
-
-Testing can be done using either Cargo or `make`.
-
-### Cargo
-
-Just like with building, we follow the standard procedure for testing using
-Cargo:
-
-```bash
-$ cargo test
-```
-
-By default, `cargo test` only runs the common programs. To run also platform
-specific tests, run:
-
-```bash
-$ cargo test --features unix
-```
-
-If you would prefer to test a select few utilities:
-
-```bash
-$ cargo test --features "chmod mv tail" --no-default-features
-```
-
-If you also want to test the core utilities:
-
-```bash
-$ cargo test  -p uucore -p coreutils
-```
-
-To debug:
-
-```bash
-$ gdb --args target/debug/coreutils ls
-(gdb) b ls.rs:79
-(gdb) run
-```
-
-### GNU Make
-
-To simply test all available utilities:
-
-```bash
-$ make test
-```
-
-To test all but a few of the available utilities:
-
-```bash
-$ make SKIP_UTILS='UTILITY_1 UTILITY_2' test
-```
-
-To test only a few of the available utilities:
-
-```bash
-$ make UTILS='UTILITY_1 UTILITY_2' test
-```
-
-To include tests for unimplemented behavior:
-
-```bash
-$ make UTILS='UTILITY_1 UTILITY_2' SPEC=y test
-```
-
-### Run Busybox Tests
-
-This testing functionality is only available on *nix operating systems and
-requires `make`.
-
-To run busybox tests for all utilities for which busybox has tests
-
-```bash
-$ make busytest
-```
-
-To run busybox tests for a few of the available utilities
-
-```bash
-$ make UTILS='UTILITY_1 UTILITY_2' busytest
-```
-
-To pass an argument like "-v" to the busybox test runtime
-
-```bash
-$ make UTILS='UTILITY_1 UTILITY_2' RUNTEST_ARGS='-v' busytest
-```
-
-### Comparing with GNU
+## GNU test suite compatibility
 
 Below is the evolution of how many GNU tests uutils passes. A more detailed
 breakdown of the GNU test results of the main branch can be found
 [in the user manual](https://uutils.github.io/user/test_coverage.html).
 
+See <https://github.com/uutils/coreutils/issues/3336> for the main meta bugs
+(many are missing).
+
 ![Evolution over time](https://github.com/uutils/coreutils-tracking/blob/main/gnu-results.png?raw=true)
 
-To run locally:
-
-```bash
-$ bash util/build-gnu.sh
-$ bash util/run-gnu-test.sh
-# To run a single test:
-$ bash util/run-gnu-test.sh tests/touch/not-owner.sh # for example
-# To run several tests:
-$ bash util/run-gnu-test.sh tests/touch/not-owner.sh tests/rm/no-give-up.sh # for example
-# If this is a perl (.pl) test, to run in debug:
-$ DEBUG=1 bash util/run-gnu-test.sh tests/misc/sm3sum.pl
-```
-
-Note that it relies on individual utilities (not the multicall binary).
-
-### Improving the GNU compatibility
-
-The Python script `./util/remaining-gnu-error.py` shows the list of failing tests in the CI.
-
-To improve the GNU compatibility, the following process is recommended:
-
-1. Identify a test (the smaller, the better) on a program that you understand or is easy to understand. You can use the `./util/remaining-gnu-error.py` script to help with this decision.
-1. Build both the GNU and Rust coreutils using: `bash util/build-gnu.sh`
-1. Run the test with `bash util/run-gnu-test.sh <your test>`
-1. Start to modify `<your test>` to understand what is wrong. Examples:
-    1. Add `set -v` to have the bash verbose mode
-    1. Add `echo $?` where needed
-    1. When the variable `fail` is used in the test, `echo $fail` to see when the test started to fail
-    1. Bump the content of the output (ex: `cat err`)
-    1. ...
-1. Or, if the test is simple, extract the relevant information to create a new test case running both GNU & Rust implementation
-1. Start to modify the Rust implementation to match the expected behavior
-1. Add a test to make sure that we don't regress (our test suite is super quick)
-
-
 ## Contributing
 
 To contribute to uutils, please see [CONTRIBUTING](CONTRIBUTING.md).
 
-## Utilities
-
-Please note that this is not fully accurate:
-* Some new options can be added / removed in the GNU implementation;
-* Some error management might be missing;
-* Some behaviors might be different.
-
-See https://github.com/uutils/coreutils/issues/3336 for the main meta bugs
-(many are missing).
-
-| Done      | WIP       |
-|-----------|-----------|
-| arch      | cp        |
-| base32    | date      |
-| base64    | dd        |
-| basename  | df        |
-| basenc    | expr      |
-| cat       | install   |
-| chcon     | ls        |
-| chgrp     | more      |
-| chmod     | numfmt    |
-| chown     | od (`--strings` and 128-bit data types missing) |
-| chroot    | pr        |
-| cksum     | printf    |
-| comm      | sort      |
-| csplit    | split     |
-| cut       | tac       |
-| dircolors | test      |
-| dirname   | dir       |
-| du        | vdir      |
-| echo      | stty      |
-| env       |           |
-| expand    |           |
-| factor    |           |
-| false     |           |
-| fmt       |           |
-| fold      |           |
-| groups    |           |
-| hashsum   |           |
-| head      |           |
-| hostid    |           |
-| hostname  |           |
-| id        |           |
-| join      |           |
-| kill      |           |
-| link      |           |
-| ln        |           |
-| logname   |           |
-| ~~md5sum~~ (replaced by [hashsum](https://github.com/uutils/coreutils/blob/main/src/uu/hashsum/src/hashsum.rs)) | |
-| ~~sha1sum~~ (replaced by [hashsum](https://github.com/uutils/coreutils/blob/main/src/uu/hashsum/src/hashsum.rs)) | |
-| ~~sha224sum~~ (replaced by [hashsum](https://github.com/uutils/coreutils/blob/main/src/uu/hashsum/src/hashsum.rs)) | |
-| ~~sha256sum~~ (replaced by [hashsum](https://github.com/uutils/coreutils/blob/main/src/uu/hashsum/src/hashsum.rs)) | |
-| ~~sha384sum~~ (replaced by [hashsum](https://github.com/uutils/coreutils/blob/main/src/uu/hashsum/src/hashsum.rs)) | |
-| ~~sha512sum~~ (replaced by [hashsum](https://github.com/uutils/coreutils/blob/main/src/uu/hashsum/src/hashsum.rs)) | |
-| mkdir     |           |
-| mkfifo    |           |
-| mknod     |           |
-| mktemp    |           |
-| mv        |           |
-| nice      |           |
-| nl        |           |
-| nohup     |           |
-| nproc     |           |
-| paste     |           |
-| pathchk   |           |
-| pinky     |           |
-| printenv  |           |
-| ptx       |           |
-| pwd       |           |
-| readlink  |           |
-| realpath  |           |
-| relpath   |           |
-| rm        |           |
-| rmdir     |           |
-| runcon    |           |
-| seq       |           |
-| shred     |           |
-| shuf      |           |
-| sleep     |           |
-| stat      |           |
-| stdbuf    |           |
-| sum       |           |
-| sync      |           |
-| tail      |           |
-| tee       |           |
-| timeout   |           |
-| touch     |           |
-| tr        |           |
-| true      |           |
-| truncate  |           |
-| tsort     |           |
-| tty       |           |
-| uname     |           |
-| unexpand  |           |
-| uniq      |           |
-| unlink    |           |
-| uptime    |           |
-| users     |           |
-| wc        |           |
-| who       |           |
-| whoami    |           |
-| yes       |           |
-
 ## License
 
 uutils is licensed under the MIT License - see the `LICENSE` file for details
diff --git a/build.rs b/build.rs
index 5201b9169..04948c0d3 100644
--- a/build.rs
+++ b/build.rs
@@ -20,6 +20,8 @@ pub fn main() {
     for (key, val) in env::vars() {
         if val == "1" && key.starts_with(ENV_FEATURE_PREFIX) {
             let krate = key[ENV_FEATURE_PREFIX.len()..].to_lowercase();
+            // Allow this as we have a bunch of info in the comments
+            #[allow(clippy::match_same_arms)]
             match krate.as_ref() {
                 "default" | "macos" | "unix" | "windows" | "selinux" | "zip" => continue, // common/standard feature names
                 "nightly" | "test_unimplemented" => continue, // crate-local custom features
diff --git a/deny.toml b/deny.toml
index aa05cdf3e..8687fbfae 100644
--- a/deny.toml
+++ b/deny.toml
@@ -11,7 +11,7 @@ unmaintained = "warn"
 yanked = "warn"
 notice = "warn"
 ignore = [
-    #"RUSTSEC-0000-0000",
+  #"RUSTSEC-0000-0000",
 ]
 
 # This section is considered when running `cargo deny check licenses`
@@ -20,15 +20,15 @@ ignore = [
 [licenses]
 unlicensed = "deny"
 allow = [
-    "MIT",
-    "Apache-2.0",
-    "ISC",
-    "BSD-2-Clause",
-    "BSD-2-Clause-FreeBSD",
-    "BSD-3-Clause",
-    "CC0-1.0",
-    "MPL-2.0", # XXX considered copyleft?
-    "Unicode-DFS-2016",
+  "MIT",
+  "Apache-2.0",
+  "ISC",
+  "BSD-2-Clause",
+  "BSD-2-Clause-FreeBSD",
+  "BSD-3-Clause",
+  "CC0-1.0",
+  "MPL-2.0",              # XXX considered copyleft?
+  "Unicode-DFS-2016",
 ]
 copyleft = "deny"
 allow-osi-fsf-free = "neither"
@@ -59,16 +59,34 @@ highlight = "all"
 # introduces it.
 # spell-checker: disable
 skip = [
-    # is-terminal
-    { name = "hermit-abi", version = "0.3.1" },
-    # is-terminal
-    { name = "rustix", version = "0.36.8" },
-    # is-terminal (via rustix)
-    { name = "io-lifetimes", version = "1.0.5" },
-    # is-terminal
-    { name = "linux-raw-sys", version = "0.1.4" },
-    # is-terminal
-    { name = "windows-sys", version = "0.45.0" },
+  # is-terminal
+  { name = "hermit-abi", version = "0.3.1" },
+  # procfs
+  { name = "rustix", version = "0.36.14" },
+  # rustix
+  { name = "linux-raw-sys", version = "0.1.4" },
+  # various crates
+  { name = "windows-sys", version = "0.45.0" },
+  # windows-sys
+  { name = "windows-targets", version = "0.42.2" },
+  # windows-targets
+  { name = "windows_aarch64_gnullvm", version = "0.42.2" },
+  # windows-targets
+  { name = "windows_aarch64_msvc", version = "0.42.2" },
+  # windows-targets
+  { name = "windows_i686_gnu", version = "0.42.2" },
+  # windows-targets
+  { name = "windows_i686_msvc", version = "0.42.2" },
+  # windows-targets
+  { name = "windows_x86_64_gnu", version = "0.42.2" },
+  # windows-targets
+  { name = "windows_x86_64_gnullvm", version = "0.42.2" },
+  # windows-targets
+  { name = "windows_x86_64_msvc", version = "0.42.2" },
+  # tempfile
+  { name = "redox_syscall", version = "0.3.5" },
+  # cpp_macros
+  { name = "aho-corasick", version = "0.7.19" },
 ]
 # spell-checker: enable
 
diff --git a/docs/book.toml b/docs/book.toml
index b9b31cfaf..f2da19338 100644
--- a/docs/book.toml
+++ b/docs/book.toml
@@ -10,4 +10,4 @@ git-repository-url = "https://github.com/rust-lang/cargo/tree/master/src/doc/src
 
 [preprocessor.toc]
 command = "mdbook-toc"
-renderer = ["html"]
\ No newline at end of file
+renderer = ["html"]
diff --git a/docs/src/build.md b/docs/src/build.md
index 6505b5b6e..e35b0ebe8 100644
--- a/docs/src/build.md
+++ b/docs/src/build.md
@@ -1,3 +1,3 @@
 # Build from source
 
-{{#include ../../README.md:build }}
\ No newline at end of file
+{{#include ../../README.md:build }}
diff --git a/docs/src/contributing.md b/docs/src/contributing.md
index 79ef4d13b..f69e1b377 100644
--- a/docs/src/contributing.md
+++ b/docs/src/contributing.md
@@ -1 +1,3 @@
-{{ #include ../../CONTRIBUTING.md }}
\ No newline at end of file
+<!-- markdownlint-disable MD041 -->
+
+{{ #include ../../CONTRIBUTING.md }}
diff --git a/docs/src/extensions.md b/docs/src/extensions.md
index 3e84f70d8..281d8ef2e 100644
--- a/docs/src/extensions.md
+++ b/docs/src/extensions.md
@@ -5,6 +5,21 @@ features that are not supported by GNU coreutils. We take care not to introduce
 features that are incompatible with the GNU coreutils. Below is a list of uutils
 extensions.
 
+## General
+
+GNU coreutils provides two ways to define short options taking an argument:
+
+```
+$ ls -w 80
+$ ls -w80
+```
+
+We support a third way:
+
+```
+$ ls -w=80
+```
+
 ## `env`
 
 `env` has an additional `-f`/`--file` flag that can parse `.env` files and set
@@ -43,3 +58,10 @@ therefore welcomed.
 
 `cut` can separate fields by whitespace (Space and Tab) with `-w` flag. This
 feature is adopted from [FreeBSD](https://www.freebsd.org/cgi/man.cgi?cut).
+
+## `fmt`
+
+`fmt` has additional flags for prefixes: `-P/--skip-prefix`, `-x/--exact-prefix`, and
+`-X/--exact-skip-prefix`. With `-m/--preserve-headers`, an attempt is made to detect and preserve
+mail headers in the input. `-q/--quick` breaks lines more quickly. And `-T/--tab-width` defines the
+number of spaces representing a tab when determining the line length.
diff --git a/docs/src/index.md b/docs/src/index.md
index 7bac8b816..0212b7526 100644
--- a/docs/src/index.md
+++ b/docs/src/index.md
@@ -1,5 +1,9 @@
+<!-- markdownlint-disable MD041 -->
+
 {{#include logo.svg}}
 
+<!-- markdownlint-disable MD033 -->
+
 <style>
     /* Make the logo a bit bigger and center */
     #logo {
diff --git a/docs/src/installation.md b/docs/src/installation.md
index 6c5667cf6..e3e5ccf16 100644
--- a/docs/src/installation.md
+++ b/docs/src/installation.md
@@ -11,9 +11,10 @@ You can also [build uutils from source](/build.md).
 <!-- toc -->
 
 ## Cargo
+
 [![crates.io package](https://repology.org/badge/version-for-repo/crates_io/uutils-coreutils.svg)](https://repology.org/project/uutils-coreutils/versions)
 
-```bash
+```shell
 # Linux
 cargo install coreutils --features unix
 # MacOs
@@ -23,11 +24,12 @@ cargo install coreutils --features windows
 ```
 
 ## Linux
+
 ### Alpine
 
 [![Alpine Linux Edge package](https://repology.org/badge/version-for-repo/alpine_edge/uutils-coreutils.svg)](https://pkgs.alpinelinux.org/packages?name=uutils-coreutils)
 
-```bash
+```shell
 apk update uutils-coreutils
 ```
 
@@ -37,7 +39,7 @@ apk update uutils-coreutils
 
 [![Arch package](https://repology.org/badge/version-for-repo/arch/uutils-coreutils.svg)](https://archlinux.org/packages/community/x86_64/uutils-coreutils/)
 
-```bash
+```shell
 pacman -S uutils-coreutils
 ```
 
@@ -45,7 +47,7 @@ pacman -S uutils-coreutils
 
 [![Debian package](https://repology.org/badge/version-for-repo/debian_unstable/uutils-coreutils.svg)](https://packages.debian.org/sid/source/rust-coreutils)
 
-```bash
+```shell
 apt install rust-coreutils
 # To use it:
 export PATH=/usr/lib/cargo/bin/coreutils:$PATH
@@ -57,32 +59,35 @@ export PATH=/usr/lib/cargo/bin/coreutils:$PATH
 
 [![Gentoo package](https://repology.org/badge/version-for-repo/gentoo/uutils-coreutils.svg)](https://packages.gentoo.org/packages/sys-apps/uutils-coreutils)
 
-```bash
+```shell
 emerge -pv sys-apps/uutils-coreutils
 ```
 
 ### Manjaro
+
 ![Manjaro Stable package](https://repology.org/badge/version-for-repo/manjaro_stable/uutils-coreutils.svg)
 [![Manjaro Testing package](https://repology.org/badge/version-for-repo/manjaro_testing/uutils-coreutils.svg)](https://repology.org/project/uutils-coreutils/versions)
 [![Manjaro Unstable package](https://repology.org/badge/version-for-repo/manjaro_unstable/uutils-coreutils.svg)](https://repology.org/project/uutils-coreutils/versions)
 
-```bash
+```shell
 pacman -S uutils-coreutils
 # or
 pamac install uutils-coreutils
 ```
 
 ### NixOS
+
 [![nixpkgs unstable package](https://repology.org/badge/version-for-repo/nix_unstable/uutils-coreutils.svg)](https://repology.org/project/uutils-coreutils/versions)
 
-```bash
+```shell
 nix-env -iA nixos.uutils-coreutils
 ```
 
 ### OpenMandriva Lx
+
 [![openmandriva cooker package](https://repology.org/badge/version-for-repo/openmandriva_cooker/uutils-coreutils.svg)](https://repology.org/project/uutils-coreutils/versions)
 
-```bash
+```shell
 dnf install uutils-coreutils
 ```
 
@@ -90,7 +95,7 @@ dnf install uutils-coreutils
 
 [![Ubuntu package](https://repology.org/badge/version-for-repo/ubuntu_23_04/uutils-coreutils.svg)](https://packages.ubuntu.com/source/lunar/rust-coreutils)
 
-```bash
+```shell
 apt install rust-coreutils
 # To use it:
 export PATH=/usr/lib/cargo/bin/coreutils:$PATH
@@ -101,13 +106,15 @@ export PATH=/usr/lib/cargo/bin/coreutils:$PATH
 ## MacOS
 
 ### Homebrew
+
 [![Homebrew package](https://repology.org/badge/version-for-repo/homebrew/uutils-coreutils.svg)](https://formulae.brew.sh/formula/uutils-coreutils)
 
-```bash
+```shell
 brew install uutils-coreutils
 ```
 
 ### MacPorts
+
 [![MacPorts package](https://repology.org/badge/version-for-repo/macports/uutils-coreutils.svg)](https://ports.macports.org/port/coreutils-uutils/)
 
 ```
@@ -115,18 +122,20 @@ port install coreutils-uutils
 ```
 
 ## FreeBSD
+
 [![FreeBSD port](https://repology.org/badge/version-for-repo/freebsd/uutils-coreutils.svg)](https://repology.org/project/uutils-coreutils/versions)
 
 ```sh
-pkg install uutils
+pkg install rust-coreutils
 ```
 
 ## Windows
 
 ### Scoop
+
 [![Scoop package](https://repology.org/badge/version-for-repo/scoop/uutils-coreutils.svg)](https://scoop.sh/#/apps?q=uutils-coreutils&s=0&d=1&o=true)
 
-```bash
+```shell
 scoop install uutils-coreutils
 ```
 
@@ -136,4 +145,6 @@ scoop install uutils-coreutils
 
 [![AUR package](https://repology.org/badge/version-for-repo/aur/coreutils-hybrid.svg)](https://aur.archlinux.org/packages/coreutils-hybrid)
 
-A GNU coreutils / uutils coreutils hybrid package. Uses stable uutils programs mixed with GNU counterparts if uutils counterpart is unfinished or buggy.
+A GNU coreutils / uutils coreutils hybrid package. Uses stable uutils
+programs mixed with GNU counterparts if uutils counterpart is
+unfinished or buggy.
diff --git a/docs/src/multicall.md b/docs/src/multicall.md
index 5d7b8b169..f4e29906b 100644
--- a/docs/src/multicall.md
+++ b/docs/src/multicall.md
@@ -1,4 +1,5 @@
-#  Multi-call binary
+# Multi-call binary
+
 uutils includes a multi-call binary from which the utils can be invoked. This
 reduces the binary size of the binary and can be useful for portability.
 
@@ -12,6 +13,7 @@ coreutils [util] [util options]
 The `--help` flag will print a list of available utils.
 
 ## Example
-```
+
+```shell
 coreutils ls -l
-```
\ No newline at end of file
+```
diff --git a/docs/src/packaging.md b/docs/src/packaging.md
new file mode 100644
index 000000000..40c90fa06
--- /dev/null
+++ b/docs/src/packaging.md
@@ -0,0 +1,86 @@
+# Packaging coreutils
+
+<!-- spell-checker:ignore debuginfo manpages backtraces -->
+
+> **Note**: This page is intended as a guide for packaging the uutils coreutils
+> for package maintainers. Normal users probably do not need to read this. If you
+> just want to install the coreutils, look at the
+> [installation](installation.md) instructions.
+
+The maintainers of this project do not have the capacity to maintain packages
+for every distribution and package manager out there. Therefore, we encourage
+other people to package the uutils coreutils for their preferred distributions.
+You do not need to ask permission for this and you can do this however you want
+as long as you comply with the license. However, we do like to hear and
+advertise where the uutils coreutils are available, so please do let us know!
+
+## License
+
+The uutils coreutils are licensed under the MIT license. See the
+[LICENSE](https://github.com/uutils/coreutils/blob/main/LICENSE) for the full
+license text. Make sure to add attribution and the license text to the package
+to comply with the license.
+
+## Package
+
+We recommend to name the package `uutils-coreutils`. Just `uutils` is incorrect,
+because that is the name of the organization, which also includes other
+projects.
+
+## Selecting the utils to include
+
+Not all utils are available on all platforms. To get the full set of utils for a
+particular platform, you must enable the feature flag with the platform name.
+For example, on Unix-like system, use `--features unix` and `--features windows`
+on Windows.
+
+For a more fine-grained selection, you can enable just the features with the
+name of the utils you want to include and disable the default feature set.
+
+Additionally, support for SELinux must explicitly enabled with the
+`feat_selinux` feature.
+
+We recommend including all the utilities that a platform supports.
+
+## Compilation parameters
+
+There are several compile-time flags that allow you to tune the coreutils to
+your particular needs. Some distributions, for example, might choose to
+minimize the binary size as much as possible.
+
+This can be achieved by customizing the configuration passed to cargo. You can
+view the full documentation in the
+[cargo documentation](https://doc.rust-lang.org/cargo/reference/profiles.html).
+
+We provide three release profiles out of the box, though you may want to tweak
+them:
+
+- `release`: This is the standard Rust release profile, but with link-time
+  optimization enabled. It is a balance between compile time, performance and a
+  reasonable amount of debug info. The main drawback of this profile is that the
+  binary is quite large (roughly 2x the GNU coreutils).
+- `release-fast`: Every setting is tuned for the best performance, at the cost
+  of compile time. This binary is still quite large.
+- `release-small`: Generates the smallest binary possible. This strips _all_
+  debug info from the binary and leads to worse backtraces. The performance of
+  this profile is also really good as it is close to the `release-fast` profile,
+  but with all debuginfo stripped.
+
+For the precise definition of these profiles, you can look at the root
+[`Cargo.toml`](https://github.com/uutils/coreutils/blob/main/Cargo.toml).
+
+The profiles above are just examples. We encourage package maintainers to decide
+for themselves what the best parameters for their distribution are. For example,
+a distribution focused on embedded systems would probably choose
+`release-small`, but another distribution focused on security might enable
+bounds checks.
+
+It is also possible to split the debuginfo into a separate package. See the
+[`split-debuginfo`](https://doc.rust-lang.org/cargo/reference/profiles.html#split-debuginfo)
+option in `cargo`.
+
+## Additional artifacts
+
+This project supports automatically generating manpages and shell completion
+files which you may want to include in the package. See the page on
+[building from source](build.md) for how to generate these.
diff --git a/docs/src/test_coverage.md b/docs/src/test_coverage.md
index bf4c72129..b83760588 100644
--- a/docs/src/test_coverage.md
+++ b/docs/src/test_coverage.md
@@ -1,5 +1,7 @@
 # GNU Test Coverage
 
+<!-- markdownlint-disable MD033 -->
+
 uutils is actively tested against the GNU coreutils test suite. The results
 below are automatically updated every day.
 
diff --git a/fuzz/.gitignore b/fuzz/.gitignore
new file mode 100644
index 000000000..a0925114d
--- /dev/null
+++ b/fuzz/.gitignore
@@ -0,0 +1,3 @@
+target
+corpus
+artifacts
diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml
new file mode 100644
index 000000000..c8565d691
--- /dev/null
+++ b/fuzz/Cargo.toml
@@ -0,0 +1,45 @@
+[package]
+name = "uucore-fuzz"
+version = "0.0.0"
+publish = false
+edition = "2021"
+
+[package.metadata]
+cargo-fuzz = true
+
+[dependencies]
+libfuzzer-sys = "0.4"
+
+[dependencies.uucore]
+path = "../src/uucore/"
+
+[dependencies.uu_date]
+path = "../src/uu/date/"
+
+# Prevent this from interfering with workspaces
+[workspace]
+members = ["."]
+
+[[bin]]
+name = "fuzz_date"
+path = "fuzz_targets/fuzz_date.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "fuzz_parse_glob"
+path = "fuzz_targets/fuzz_parse_glob.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "fuzz_parse_size"
+path = "fuzz_targets/fuzz_parse_size.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "fuzz_parse_time"
+path = "fuzz_targets/fuzz_parse_time.rs"
+test = false
+doc = false
diff --git a/fuzz/fuzz_targets/fuzz_date.rs b/fuzz/fuzz_targets/fuzz_date.rs
new file mode 100644
index 000000000..96c56cc6b
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_date.rs
@@ -0,0 +1,14 @@
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+
+use std::ffi::OsString;
+use uu_date::uumain;
+
+fuzz_target!(|data: &[u8]| {
+    let delim: u8 = 0; // Null byte
+    let args = data
+        .split(|b| *b == delim)
+        .filter_map(|e| std::str::from_utf8(e).ok())
+        .map(|e| OsString::from(e));
+    uumain(args);
+});
diff --git a/fuzz/fuzz_targets/fuzz_parse_glob.rs b/fuzz/fuzz_targets/fuzz_parse_glob.rs
new file mode 100644
index 000000000..061569bc4
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_parse_glob.rs
@@ -0,0 +1,10 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use uucore::parse_glob;
+
+fuzz_target!(|data: &[u8]| {
+    if let Ok(s) = std::str::from_utf8(data) {
+        _ = parse_glob::from_str(s)
+    }
+});
diff --git a/fuzz/fuzz_targets/fuzz_parse_size.rs b/fuzz/fuzz_targets/fuzz_parse_size.rs
new file mode 100644
index 000000000..23b3b5ea4
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_parse_size.rs
@@ -0,0 +1,10 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use uucore::parse_size::parse_size;
+
+fuzz_target!(|data: &[u8]| {
+    if let Ok(s) = std::str::from_utf8(data) {
+        _ = parse_size(s);
+    }
+});
diff --git a/fuzz/fuzz_targets/fuzz_parse_time.rs b/fuzz/fuzz_targets/fuzz_parse_time.rs
new file mode 100644
index 000000000..a643c6d80
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_parse_time.rs
@@ -0,0 +1,10 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use uucore::parse_time;
+
+fuzz_target!(|data: &[u8]| {
+    if let Ok(s) = std::str::from_utf8(data) {
+        _ = parse_time::from_str(s);
+    }
+});
diff --git a/src/bin/coreutils.rs b/src/bin/coreutils.rs
index 08c0774ba..8440689c6 100644
--- a/src/bin/coreutils.rs
+++ b/src/bin/coreutils.rs
@@ -5,6 +5,8 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+// spell-checker:ignore manpages mangen
+
 use clap::{Arg, Command};
 use clap_complete::Shell;
 use std::cmp;
@@ -41,10 +43,11 @@ fn binary_path(args: &mut impl Iterator<Item = OsString>) -> PathBuf {
     }
 }
 
-fn name(binary_path: &Path) -> &str {
-    binary_path.file_stem().unwrap().to_str().unwrap()
+fn name(binary_path: &Path) -> Option<&str> {
+    binary_path.file_stem()?.to_str()
 }
 
+#[allow(clippy::cognitive_complexity)]
 fn main() {
     uucore::panic::mute_sigpipe_panic();
 
@@ -52,7 +55,10 @@ fn main() {
     let mut args = uucore::args_os();
 
     let binary = binary_path(&mut args);
-    let binary_as_util = name(&binary);
+    let binary_as_util = name(&binary).unwrap_or_else(|| {
+        usage(&utils, "<unknown binary name>");
+        process::exit(0);
+    });
 
     // binary name equals util name?
     if let Some(&(uumain, _)) = utils.get(binary_as_util) {
@@ -90,6 +96,10 @@ fn main() {
             gen_completions(args, &utils);
         }
 
+        if util == "manpage" {
+            gen_manpage(args, &utils);
+        }
+
         match utils.get(util) {
             Some(&(uumain, _)) => {
                 process::exit(uumain((vec![util_os].into_iter()).chain(args)));
@@ -167,6 +177,39 @@ fn gen_completions<T: uucore::Args>(
     process::exit(0);
 }
 
+/// Generate the manpage for the utility in the first parameter
+fn gen_manpage<T: uucore::Args>(
+    args: impl Iterator<Item = OsString>,
+    util_map: &UtilityMap<T>,
+) -> ! {
+    let all_utilities: Vec<_> = std::iter::once("coreutils")
+        .chain(util_map.keys().copied())
+        .collect();
+
+    let matches = Command::new("manpage")
+        .about("Prints manpage to stdout")
+        .arg(
+            Arg::new("utility")
+                .value_parser(clap::builder::PossibleValuesParser::new(all_utilities))
+                .required(true),
+        )
+        .get_matches_from(std::iter::once(OsString::from("manpage")).chain(args));
+
+    let utility = matches.get_one::<String>("utility").unwrap();
+
+    let command = if utility == "coreutils" {
+        gen_coreutils_app(util_map)
+    } else {
+        util_map.get(utility).unwrap().1()
+    };
+
+    let man = clap_mangen::Man::new(command);
+    man.render(&mut io::stdout())
+        .expect("Man page generation failed");
+    io::stdout().flush().unwrap();
+    process::exit(0);
+}
+
 fn gen_coreutils_app<T: uucore::Args>(util_map: &UtilityMap<T>) -> Command {
     let mut command = Command::new("coreutils");
     for (_, (_, sub_app)) in util_map {
diff --git a/src/bin/uudoc.rs b/src/bin/uudoc.rs
index 8276d2ae1..5ac858226 100644
--- a/src/bin/uudoc.rs
+++ b/src/bin/uudoc.rs
@@ -2,7 +2,7 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore tldr
+// spell-checker:ignore tldr uuhelp
 
 use clap::Command;
 use std::collections::HashMap;
@@ -133,7 +133,7 @@ impl<'a, 'b> MDWriter<'a, 'b> {
         write!(self.w, "# {}\n\n", self.name)?;
         self.additional()?;
         self.usage()?;
-        self.description()?;
+        self.about()?;
         self.options()?;
         self.after_help()?;
         self.examples()
@@ -177,54 +177,34 @@ impl<'a, 'b> MDWriter<'a, 'b> {
     }
 
     fn usage(&mut self) -> io::Result<()> {
-        writeln!(self.w, "\n```")?;
-        let mut usage: String = self
-            .command
-            .render_usage()
-            .to_string()
-            .lines()
-            .map(|l| l.strip_prefix("Usage:").unwrap_or(l))
-            .map(|l| l.trim())
-            .filter(|l| !l.is_empty())
-            .collect::<Vec<_>>()
-            .join("\n");
-        usage = usage
-            .to_string()
-            .replace(uucore::execution_phrase(), self.name);
-        writeln!(self.w, "{}", usage)?;
-        writeln!(self.w, "```")
+        if let Some(markdown) = &self.markdown {
+            let usage = uuhelp_parser::parse_usage(markdown);
+            let usage = usage.replace("{}", self.name);
+
+            writeln!(self.w, "\n```")?;
+            writeln!(self.w, "{}", usage)?;
+            writeln!(self.w, "```")
+        } else {
+            Ok(())
+        }
     }
 
-    fn description(&mut self) -> io::Result<()> {
-        if let Some(after_help) = self.markdown_section("about") {
-            return writeln!(self.w, "\n\n{}", after_help);
-        }
-
-        if let Some(about) = self
-            .command
-            .get_long_about()
-            .or_else(|| self.command.get_about())
-        {
-            writeln!(self.w, "{}", about)
+    fn about(&mut self) -> io::Result<()> {
+        if let Some(markdown) = &self.markdown {
+            writeln!(self.w, "{}", uuhelp_parser::parse_about(markdown))
         } else {
             Ok(())
         }
     }
 
     fn after_help(&mut self) -> io::Result<()> {
-        if let Some(after_help) = self.markdown_section("after help") {
-            return writeln!(self.w, "\n\n{}", after_help);
+        if let Some(markdown) = &self.markdown {
+            if let Some(after_help) = uuhelp_parser::parse_section("after help", markdown) {
+                return writeln!(self.w, "\n\n{after_help}");
+            }
         }
 
-        if let Some(after_help) = self
-            .command
-            .get_after_long_help()
-            .or_else(|| self.command.get_after_help())
-        {
-            writeln!(self.w, "\n\n{}", after_help)
-        } else {
-            Ok(())
-        }
+        Ok(())
     }
 
     fn examples(&mut self) -> io::Result<()> {
@@ -236,6 +216,10 @@ impl<'a, 'b> MDWriter<'a, 'b> {
             } else if let Some(f) = get_zip_content(zip, &format!("pages/linux/{}.md", self.name)) {
                 f
             } else {
+                println!(
+                    "Warning: Could not find tldr examples for page '{}'",
+                    self.name
+                );
                 return Ok(());
             };
 
@@ -274,10 +258,10 @@ impl<'a, 'b> MDWriter<'a, 'b> {
             write!(self.w, "<dt>")?;
             let mut first = true;
             for l in arg.get_long_and_visible_aliases().unwrap_or_default() {
-                if !first {
-                    write!(self.w, ", ")?;
-                } else {
+                if first {
                     first = false;
+                } else {
+                    write!(self.w, ", ")?;
                 }
                 write!(self.w, "<code>")?;
                 write!(self.w, "--{}", l)?;
@@ -295,10 +279,10 @@ impl<'a, 'b> MDWriter<'a, 'b> {
                 write!(self.w, "</code>")?;
             }
             for s in arg.get_short_and_visible_aliases().unwrap_or_default() {
-                if !first {
-                    write!(self.w, ", ")?;
-                } else {
+                if first {
                     first = false;
+                } else {
+                    write!(self.w, ", ")?;
                 }
                 write!(self.w, "<code>")?;
                 write!(self.w, "-{}", s)?;
@@ -327,32 +311,6 @@ impl<'a, 'b> MDWriter<'a, 'b> {
         }
         writeln!(self.w, "</dl>\n")
     }
-
-    fn markdown_section(&self, section: &str) -> Option<String> {
-        let md = self.markdown.as_ref()?;
-        let section = section.to_lowercase();
-
-        fn is_section_header(line: &str, section: &str) -> bool {
-            line.strip_prefix("##")
-                .map_or(false, |l| l.trim().to_lowercase() == section)
-        }
-
-        let result = md
-            .lines()
-            .skip_while(|&l| !is_section_header(l, &section))
-            .skip(1)
-            .take_while(|l| !l.starts_with("##"))
-            .collect::<Vec<_>>()
-            .join("\n")
-            .trim()
-            .to_string();
-
-        if !result.is_empty() {
-            Some(result)
-        } else {
-            None
-        }
-    }
 }
 
 fn get_zip_content(archive: &mut ZipArchive<impl Read + Seek>, name: &str) -> Option<String> {
diff --git a/src/uu/arch/Cargo.toml b/src/uu/arch/Cargo.toml
index 8e8712338..42ac16b89 100644
--- a/src/uu/arch/Cargo.toml
+++ b/src/uu/arch/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_arch"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "arch ~ (uutils) display machine architecture"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/arch.rs"
 
 [dependencies]
-platform-info = { workspace=true }
-clap = { workspace=true }
-uucore = { workspace=true }
+platform-info = { workspace = true }
+clap = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "arch"
diff --git a/src/uu/arch/arch.md b/src/uu/arch/arch.md
index 7225ede2d..a4ba2e75f 100644
--- a/src/uu/arch/arch.md
+++ b/src/uu/arch/arch.md
@@ -4,11 +4,8 @@
 arch
 ```
 
-
 Display machine architecture
 
-
 ## After Help
 
 Determine architecture name for current machine.
-
diff --git a/src/uu/arch/src/arch.rs b/src/uu/arch/src/arch.rs
index a2208d8b0..96eba1ef9 100644
--- a/src/uu/arch/src/arch.rs
+++ b/src/uu/arch/src/arch.rs
@@ -9,7 +9,7 @@
 use platform_info::*;
 
 use clap::{crate_version, Command};
-use uucore::error::{FromIo, UResult};
+use uucore::error::{UResult, USimpleError};
 use uucore::{help_about, help_section};
 
 static ABOUT: &str = help_about!("arch.md");
@@ -19,8 +19,9 @@ static SUMMARY: &str = help_section!("after help", "arch.md");
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     uu_app().try_get_matches_from(args)?;
 
-    let uts = PlatformInfo::new().map_err_context(|| "cannot get system name".to_string())?;
-    println!("{}", uts.machine().trim());
+    let uts = PlatformInfo::new().map_err(|_e| USimpleError::new(1, "cannot get system name"))?;
+
+    println!("{}", uts.machine().to_string_lossy().trim());
     Ok(())
 }
 
diff --git a/src/uu/base32/Cargo.toml b/src/uu/base32/Cargo.toml
index d71e71f95..ea718e8dc 100644
--- a/src/uu/base32/Cargo.toml
+++ b/src/uu/base32/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_base32"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "base32 ~ (uutils) decode/encode input (base32-encoding)"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/base32.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true, features = ["encoding"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["encoding"] }
 
 [[bin]]
 name = "base32"
diff --git a/src/uu/base32/base32.md b/src/uu/base32/base32.md
index e55fb25f6..1805d433b 100644
--- a/src/uu/base32/base32.md
+++ b/src/uu/base32/base32.md
@@ -7,8 +7,8 @@ base32 [OPTION]... [FILE]
 encode/decode data and print to standard output
 With no FILE, or when FILE is -, read standard input.
 
-The data are encoded as described for the base32 alphabet in RFC
-4648. When decoding, the input may contain newlines in addition
+The data are encoded as described for the base32 alphabet in RFC 4648.
+When decoding, the input may contain newlines in addition
 to the bytes of the formal base32 alphabet. Use --ignore-garbage
 to attempt to recover from any other non-alphabet bytes in the
 encoded stream.
diff --git a/src/uu/base32/src/base_common.rs b/src/uu/base32/src/base_common.rs
index f68aa6b86..78698e8b9 100644
--- a/src/uu/base32/src/base_common.rs
+++ b/src/uu/base32/src/base_common.rs
@@ -160,18 +160,7 @@ pub fn handle_input<R: Read>(
         data = data.line_wrap(wrap);
     }
 
-    if !decode {
-        match data.encode() {
-            Ok(s) => {
-                wrap_print(&data, &s);
-                Ok(())
-            }
-            Err(_) => Err(USimpleError::new(
-                1,
-                "error: invalid input (length must be multiple of 4 characters)",
-            )),
-        }
-    } else {
+    if decode {
         match data.decode() {
             Ok(s) => {
                 // Silent the warning as we want to the error message
@@ -184,5 +173,16 @@ pub fn handle_input<R: Read>(
             }
             Err(_) => Err(USimpleError::new(1, "error: invalid input")),
         }
+    } else {
+        match data.encode() {
+            Ok(s) => {
+                wrap_print(&data, &s);
+                Ok(())
+            }
+            Err(_) => Err(USimpleError::new(
+                1,
+                "error: invalid input (length must be multiple of 4 characters)",
+            )),
+        }
     }
 }
diff --git a/src/uu/base64/Cargo.toml b/src/uu/base64/Cargo.toml
index af92c70c2..ba8229073 100644
--- a/src/uu/base64/Cargo.toml
+++ b/src/uu/base64/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_base64"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "base64 ~ (uutils) decode/encode input (base64-encoding)"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/base64.rs"
 
 [dependencies]
-uucore = { workspace=true, features = ["encoding"] }
-uu_base32 = { workspace=true }
+uucore = { workspace = true, features = ["encoding"] }
+uu_base32 = { workspace = true }
 
 [[bin]]
 name = "base64"
diff --git a/src/uu/base64/base64.md b/src/uu/base64/base64.md
index 6ff657457..ed3aa4f76 100644
--- a/src/uu/base64/base64.md
+++ b/src/uu/base64/base64.md
@@ -7,8 +7,8 @@ base64 [OPTION]... [FILE]
 encode/decode data and print to standard output
 With no FILE, or when FILE is -, read standard input.
 
-The data are encoded as described for the base64 alphabet in RFC
-3548. When decoding, the input may contain newlines in addition
+The data are encoded as described for the base64 alphabet in RFC 3548.
+When decoding, the input may contain newlines in addition
 to the bytes of the formal base64 alphabet. Use --ignore-garbage
 to attempt to recover from any other non-alphabet bytes in the
 encoded stream.
diff --git a/src/uu/basename/Cargo.toml b/src/uu/basename/Cargo.toml
index 7d8377de5..a1ea12c5e 100644
--- a/src/uu/basename/Cargo.toml
+++ b/src/uu/basename/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_basename"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "basename ~ (uutils) display PATHNAME with leading directory components removed"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/basename.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "basename"
diff --git a/src/uu/basename/basename.md b/src/uu/basename/basename.md
new file mode 100644
index 000000000..b17cac74a
--- /dev/null
+++ b/src/uu/basename/basename.md
@@ -0,0 +1,9 @@
+# basename
+
+```
+basename NAME [SUFFIX]
+basename OPTION... NAME...
+```
+
+Print NAME with any leading directory components removed
+If specified, also remove a trailing SUFFIX
diff --git a/src/uu/basename/src/basename.rs b/src/uu/basename/src/basename.rs
index 613c4d67c..ed7faee65 100644
--- a/src/uu/basename/src/basename.rs
+++ b/src/uu/basename/src/basename.rs
@@ -11,13 +11,11 @@ use clap::{crate_version, Arg, ArgAction, Command};
 use std::path::{is_separator, PathBuf};
 use uucore::display::Quotable;
 use uucore::error::{UResult, UUsageError};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
 
-static ABOUT: &str = r#"Print NAME with any leading directory components removed
-If specified, also remove a trailing SUFFIX"#;
+static ABOUT: &str = help_about!("basename.md");
 
-const USAGE: &str = "{} NAME [SUFFIX]
-    {} OPTION... NAME...";
+const USAGE: &str = help_usage!("basename.md");
 
 pub mod options {
     pub static MULTIPLE: &str = "multiple";
diff --git a/src/uu/basenc/Cargo.toml b/src/uu/basenc/Cargo.toml
index e6babef76..20665402a 100644
--- a/src/uu/basenc/Cargo.toml
+++ b/src/uu/basenc/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_basenc"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "basenc ~ (uutils) decode/encode input"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/basenc.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true, features = ["encoding"] }
-uu_base32 = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["encoding"] }
+uu_base32 = { workspace = true }
 
 [[bin]]
 name = "basenc"
diff --git a/src/uu/basenc/src/basenc.rs b/src/uu/basenc/src/basenc.rs
index afc25c736..3ec8cede0 100644
--- a/src/uu/basenc/src/basenc.rs
+++ b/src/uu/basenc/src/basenc.rs
@@ -24,15 +24,33 @@ use uucore::{help_about, help_usage};
 const ABOUT: &str = help_about!("basenc.md");
 const USAGE: &str = help_usage!("basenc.md");
 
-const ENCODINGS: &[(&str, Format)] = &[
-    ("base64", Format::Base64),
-    ("base64url", Format::Base64Url),
-    ("base32", Format::Base32),
-    ("base32hex", Format::Base32Hex),
-    ("base16", Format::Base16),
-    ("base2lsbf", Format::Base2Lsbf),
-    ("base2msbf", Format::Base2Msbf),
-    ("z85", Format::Z85),
+const ENCODINGS: &[(&str, Format, &str)] = &[
+    ("base64", Format::Base64, "same as 'base64' program"),
+    ("base64url", Format::Base64Url, "file- and url-safe base64"),
+    ("base32", Format::Base32, "same as 'base32' program"),
+    (
+        "base32hex",
+        Format::Base32Hex,
+        "extended hex alphabet base32",
+    ),
+    ("base16", Format::Base16, "hex encoding"),
+    (
+        "base2lsbf",
+        Format::Base2Lsbf,
+        "bit string with least significant bit (lsb) first",
+    ),
+    (
+        "base2msbf",
+        Format::Base2Msbf,
+        "bit string with most significant bit (msb) first",
+    ),
+    (
+        "z85",
+        Format::Z85,
+        "ascii85-like encoding;\n\
+        when encoding, input length must be a multiple of 4;\n\
+        when decoding, input length must be a multiple of 5",
+    ),
 ];
 
 pub fn uu_app() -> Command {
@@ -41,6 +59,7 @@ pub fn uu_app() -> Command {
         command = command.arg(
             Arg::new(encoding.0)
                 .long(encoding.0)
+                .help(encoding.2)
                 .action(ArgAction::SetTrue),
         );
     }
diff --git a/src/uu/cat/Cargo.toml b/src/uu/cat/Cargo.toml
index fbf91c249..e341fb535 100644
--- a/src/uu/cat/Cargo.toml
+++ b/src/uu/cat/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_cat"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "cat ~ (uutils) concatenate and display input"
@@ -15,13 +15,13 @@ edition = "2021"
 path = "src/cat.rs"
 
 [dependencies]
-clap = { workspace=true }
+clap = { workspace = true }
 thiserror = { workspace = true }
 is-terminal = { workspace = true }
-uucore = { workspace=true, features=["fs", "pipes"] }
+uucore = { workspace = true, features = ["fs", "pipes"] }
 
 [target.'cfg(unix)'.dependencies]
-nix = { workspace=true }
+nix = { workspace = true }
 
 [[bin]]
 name = "cat"
diff --git a/src/uu/cat/src/cat.rs b/src/uu/cat/src/cat.rs
index e90bdd116..4a5e7e0ad 100644
--- a/src/uu/cat/src/cat.rs
+++ b/src/uu/cat/src/cat.rs
@@ -456,6 +456,7 @@ fn write_fast<R: FdReadable>(handle: &mut InputHandle<R>) -> CatResult<()> {
 
 /// Outputs file contents to stdout in a line-by-line fashion,
 /// propagating any errors that might occur.
+#[allow(clippy::cognitive_complexity)]
 fn write_lines<R: FdReadable>(
     handle: &mut InputHandle<R>,
     options: &OutputOptions,
diff --git a/src/uu/chcon/Cargo.toml b/src/uu/chcon/Cargo.toml
index 2e28aa29e..58d6b9b46 100644
--- a/src/uu/chcon/Cargo.toml
+++ b/src/uu/chcon/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_chcon"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "chcon ~ (uutils) change file security context"
@@ -14,12 +14,12 @@ edition = "2021"
 path = "src/chcon.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true, features=["entries", "fs", "perms"] }
-selinux = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["entries", "fs", "perms"] }
+selinux = { workspace = true }
 thiserror = { workspace = true }
-libc = { workspace=true }
-fts-sys = { workspace=true }
+libc = { workspace = true }
+fts-sys = { workspace = true }
 
 [[bin]]
 name = "chcon"
diff --git a/src/uu/chcon/chcon.md b/src/uu/chcon/chcon.md
new file mode 100644
index 000000000..64c64f47b
--- /dev/null
+++ b/src/uu/chcon/chcon.md
@@ -0,0 +1,11 @@
+<!-- spell-checker:ignore (vars) RFILE -->
+# chcon
+
+```
+chcon [OPTION]... CONTEXT FILE...
+chcon [OPTION]... [-u USER] [-r ROLE] [-l RANGE] [-t TYPE] FILE...
+chcon [OPTION]... --reference=RFILE FILE...
+```
+
+Change the SELinux security context of each FILE to CONTEXT.
+With --reference, change the security context of each FILE to that of RFILE.
diff --git a/src/uu/chcon/src/chcon.rs b/src/uu/chcon/src/chcon.rs
index 3acd2ea43..63ae3abea 100644
--- a/src/uu/chcon/src/chcon.rs
+++ b/src/uu/chcon/src/chcon.rs
@@ -1,13 +1,11 @@
 // spell-checker:ignore (vars) RFILE
-
 #![allow(clippy::upper_case_acronyms)]
 
 use clap::builder::ValueParser;
 use uucore::error::{UResult, USimpleError, UUsageError};
-use uucore::format_usage;
-use uucore::{display::Quotable, show_error, show_warning};
+use uucore::{display::Quotable, format_usage, help_about, help_usage, show_error, show_warning};
 
-use clap::{Arg, ArgAction, Command};
+use clap::{crate_version, Arg, ArgAction, Command};
 use selinux::{OpaqueSecurityContext, SecurityContext};
 
 use std::borrow::Cow;
@@ -21,13 +19,8 @@ mod fts;
 
 use errors::*;
 
-static VERSION: &str = env!("CARGO_PKG_VERSION");
-static ABOUT: &str = "Change the SELinux security context of each FILE to CONTEXT. \n\
-                      With --reference, change the security context of each FILE to that of RFILE.";
-const USAGE: &str = "\
-    {} [OPTION]... CONTEXT FILE... \n    \
-    {} [OPTION]... [-u USER] [-r ROLE] [-l RANGE] [-t TYPE] FILE... \n    \
-    {} [OPTION]... --reference=RFILE FILE...";
+const ABOUT: &str = help_about!("chcon.md");
+const USAGE: &str = help_usage!("chcon.md");
 
 pub mod options {
     pub static HELP: &str = "help";
@@ -152,7 +145,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(VERSION)
+        .version(crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
diff --git a/src/uu/chgrp/Cargo.toml b/src/uu/chgrp/Cargo.toml
index 164a30e20..97ffc09b7 100644
--- a/src/uu/chgrp/Cargo.toml
+++ b/src/uu/chgrp/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_chgrp"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "chgrp ~ (uutils) change the group ownership of FILE"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/chgrp.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true, features=["entries", "fs", "perms"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["entries", "fs", "perms"] }
 
 [[bin]]
 name = "chgrp"
diff --git a/src/uu/chgrp/chgrp.md b/src/uu/chgrp/chgrp.md
new file mode 100644
index 000000000..79bc068d2
--- /dev/null
+++ b/src/uu/chgrp/chgrp.md
@@ -0,0 +1,10 @@
+<!-- spell-checker:ignore (vars) RFILE -->
+
+# chgrp
+
+```
+chgrp [OPTION]... GROUP FILE...
+chgrp [OPTION]... --reference=RFILE FILE...
+```
+
+Change the group of each FILE to GROUP.
diff --git a/src/uu/chgrp/src/chgrp.rs b/src/uu/chgrp/src/chgrp.rs
index 3b8d0bab0..bd01e132b 100644
--- a/src/uu/chgrp/src/chgrp.rs
+++ b/src/uu/chgrp/src/chgrp.rs
@@ -10,31 +10,33 @@
 use uucore::display::Quotable;
 pub use uucore::entries;
 use uucore::error::{FromIo, UResult, USimpleError};
-use uucore::format_usage;
-use uucore::perms::{chown_base, options, IfFrom};
+use uucore::perms::{chown_base, options, GidUidOwnerFilter, IfFrom};
+use uucore::{format_usage, help_about, help_usage};
 
-use clap::{Arg, ArgAction, ArgMatches, Command};
+use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
 
 use std::fs;
 use std::os::unix::fs::MetadataExt;
 
-static ABOUT: &str = "Change the group of each FILE to GROUP.";
-static VERSION: &str = env!("CARGO_PKG_VERSION");
+const ABOUT: &str = help_about!("chgrp.md");
+const USAGE: &str = help_usage!("chgrp.md");
 
-const USAGE: &str = "\
-    {} [OPTION]... GROUP FILE...\n    \
-    {} [OPTION]... --reference=RFILE FILE...";
-
-fn parse_gid_and_uid(matches: &ArgMatches) -> UResult<(Option<u32>, Option<u32>, IfFrom)> {
+fn parse_gid_and_uid(matches: &ArgMatches) -> UResult<GidUidOwnerFilter> {
+    let mut raw_group: String = String::new();
     let dest_gid = if let Some(file) = matches.get_one::<String>(options::REFERENCE) {
         fs::metadata(file)
-            .map(|meta| Some(meta.gid()))
+            .map(|meta| {
+                let gid = meta.gid();
+                raw_group = entries::gid2grp(gid).unwrap_or_else(|_| gid.to_string());
+                Some(gid)
+            })
             .map_err_context(|| format!("failed to get attributes of {}", file.quote()))?
     } else {
         let group = matches
             .get_one::<String>(options::ARG_GROUP)
             .map(|s| s.as_str())
             .unwrap_or_default();
+        raw_group = group.to_string();
         if group.is_empty() {
             None
         } else {
@@ -49,7 +51,12 @@ fn parse_gid_and_uid(matches: &ArgMatches) -> UResult<(Option<u32>, Option<u32>,
             }
         }
     };
-    Ok((dest_gid, None, IfFrom::All))
+    Ok(GidUidOwnerFilter {
+        dest_gid,
+        dest_uid: None,
+        raw_owner: raw_group,
+        filter: IfFrom::All,
+    })
 }
 
 #[uucore::main]
@@ -59,7 +66,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(VERSION)
+        .version(crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
diff --git a/src/uu/chmod/Cargo.toml b/src/uu/chmod/Cargo.toml
index 833067208..a4b4b799d 100644
--- a/src/uu/chmod/Cargo.toml
+++ b/src/uu/chmod/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_chmod"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "chmod ~ (uutils) change mode of FILE"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/chmod.rs"
 
 [dependencies]
-clap = { workspace=true }
-libc = { workspace=true }
-uucore = { workspace=true, features=["fs", "mode"] }
+clap = { workspace = true }
+libc = { workspace = true }
+uucore = { workspace = true, features = ["fs", "mode"] }
 
 [[bin]]
 name = "chmod"
diff --git a/src/uu/chmod/chmod.md b/src/uu/chmod/chmod.md
new file mode 100644
index 000000000..d6c2ed2d8
--- /dev/null
+++ b/src/uu/chmod/chmod.md
@@ -0,0 +1,16 @@
+<!-- spell-checker:ignore RFILE ugoa -->
+
+# chmod
+
+```
+chmod [OPTION]... MODE[,MODE]... FILE...
+chmod [OPTION]... OCTAL-MODE FILE...
+chmod [OPTION]... --reference=RFILE FILE...
+```
+
+Change the mode of each FILE to MODE.
+With --reference, change the mode of each FILE to that of RFILE.
+
+## After Help
+
+Each MODE is of the form '[ugoa]*([-+=]([rwxXst]*|[ugo]))+|[-+=]?[0-7]+'.
diff --git a/src/uu/chmod/src/chmod.rs b/src/uu/chmod/src/chmod.rs
index dee26ab69..a79886037 100644
--- a/src/uu/chmod/src/chmod.rs
+++ b/src/uu/chmod/src/chmod.rs
@@ -8,6 +8,7 @@
 // spell-checker:ignore (ToDO) Chmoder cmode fmode fperm fref ugoa RFILE RFILE's
 
 use clap::{crate_version, Arg, ArgAction, Command};
+use std::ffi::OsString;
 use std::fs;
 use std::os::unix::fs::{MetadataExt, PermissionsExt};
 use std::path::Path;
@@ -17,16 +18,11 @@ use uucore::fs::display_permissions_unix;
 use uucore::libc::mode_t;
 #[cfg(not(windows))]
 use uucore::mode;
-use uucore::{format_usage, show, show_error};
+use uucore::{format_usage, help_about, help_section, help_usage, show, show_error};
 
-const ABOUT: &str = "Change the mode of each FILE to MODE.\n\
-    With --reference, change the mode of each FILE to that of RFILE.";
-const USAGE: &str = "\
-       {} [OPTION]... MODE[,MODE]... FILE...
-       {} [OPTION]... OCTAL-MODE FILE...
-       {} [OPTION]... --reference=RFILE FILE...";
-const LONG_USAGE: &str =
-    "Each MODE is of the form '[ugoa]*([-+=]([rwxXst]*|[ugo]))+|[-+=]?[0-7]+'.";
+const ABOUT: &str = help_about!("chmod.md");
+const USAGE: &str = help_usage!("chmod.md");
+const LONG_USAGE: &str = help_section!("after help", "chmod.md");
 
 mod options {
     pub const CHANGES: &str = "changes";
@@ -40,14 +36,64 @@ mod options {
     pub const FILE: &str = "FILE";
 }
 
+/// Extract negative modes (starting with '-') from the rest of the arguments.
+///
+/// This is mainly required for GNU compatibility, where "non-positional negative" modes are used
+/// as the actual positional MODE. Some examples of these cases are:
+/// * "chmod -w -r file", which is the same as "chmod -w,-r file"
+/// * "chmod -w file -r", which is the same as "chmod -w,-r file"
+///
+/// These can currently not be handled by clap.
+/// Therefore it might be possible that a pseudo MODE is inserted to pass clap parsing.
+/// The pseudo MODE is later replaced by the extracted (and joined) negative modes.
+fn extract_negative_modes(mut args: impl uucore::Args) -> (Option<String>, Vec<OsString>) {
+    // we look up the args until "--" is found
+    // "-mode" will be extracted into parsed_cmode_vec
+    let (parsed_cmode_vec, pre_double_hyphen_args): (Vec<OsString>, Vec<OsString>) =
+        args.by_ref().take_while(|a| a != "--").partition(|arg| {
+            let arg = if let Some(arg) = arg.to_str() {
+                arg.to_string()
+            } else {
+                return false;
+            };
+            arg.len() >= 2
+                && arg.starts_with('-')
+                && matches!(
+                    arg.chars().nth(1).unwrap(),
+                    'r' | 'w' | 'x' | 'X' | 's' | 't' | 'u' | 'g' | 'o' | '0'..='7'
+                )
+        });
+
+    let mut clean_args = Vec::new();
+    if !parsed_cmode_vec.is_empty() {
+        // we need a pseudo cmode for clap, which won't be used later.
+        // this is required because clap needs the default "chmod MODE FILE" scheme.
+        clean_args.push("w".into());
+    }
+    clean_args.extend(pre_double_hyphen_args);
+
+    if let Some(arg) = args.next() {
+        // as there is still something left in the iterator, we previously consumed the "--"
+        // -> add it to the args again
+        clean_args.push("--".into());
+        clean_args.push(arg);
+    }
+    clean_args.extend(args);
+
+    let parsed_cmode = Some(
+        parsed_cmode_vec
+            .iter()
+            .map(|s| s.to_str().unwrap())
+            .collect::<Vec<&str>>()
+            .join(","),
+    )
+    .filter(|s| !s.is_empty());
+    (parsed_cmode, clean_args)
+}
+
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let mut args = args.collect_lossy();
-
-    // Before we can parse 'args' with clap (and previously getopts),
-    // a possible MODE prefix '-' needs to be removed (e.g. "chmod -x FILE").
-    let mode_had_minus_prefix = mode::strip_minus_from_mode(&mut args);
-
+    let (parsed_cmode, args) = extract_negative_modes(args.skip(1)); // skip binary name
     let matches = uu_app().after_help(LONG_USAGE).try_get_matches_from(args)?;
 
     let changes = matches.get_flag(options::CHANGES);
@@ -67,13 +113,14 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         },
         None => None,
     };
-    let modes = matches.get_one::<String>(options::MODE).unwrap(); // should always be Some because required
-    let cmode = if mode_had_minus_prefix {
-        // clap parsing is finished, now put prefix back
-        format!("-{modes}")
+
+    let modes = matches.get_one::<String>(options::MODE);
+    let cmode = if let Some(parsed_cmode) = parsed_cmode {
+        parsed_cmode
     } else {
-        modes.to_string()
+        modes.unwrap().to_string() // modes is required
     };
+    // FIXME: enable non-utf8 paths
     let mut files: Vec<String> = matches
         .get_many::<String>(options::FILE)
         .map(|v| v.map(ToString::to_string).collect())
@@ -112,6 +159,7 @@ pub fn uu_app() -> Command {
         .override_usage(format_usage(USAGE))
         .args_override_self(true)
         .infer_long_args(true)
+        .no_binary_name(true)
         .arg(
             Arg::new(options::CHANGES)
                 .long(options::CHANGES)
@@ -226,10 +274,10 @@ impl Chmoder {
                     )
                 ));
             }
-            if !self.recursive {
-                r = self.chmod_file(file).and(r);
-            } else {
+            if self.recursive {
                 r = self.walk_dir(file);
+            } else {
+                r = self.chmod_file(file).and(r);
             }
         }
         r
@@ -312,10 +360,10 @@ impl Chmoder {
                             naively_expected_new_mode = naive_mode;
                         }
                         Err(f) => {
-                            if !self.quiet {
-                                return Err(USimpleError::new(1, f));
-                            } else {
+                            if self.quiet {
                                 return Err(ExitCode::new(1));
+                            } else {
+                                return Err(USimpleError::new(1, f));
                             }
                         }
                     }
@@ -381,3 +429,34 @@ impl Chmoder {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_extract_negative_modes() {
+        // "chmod -w -r file" becomes "chmod -w,-r file". clap does not accept "-w,-r" as MODE.
+        // Therefore, "w" is added as pseudo mode to pass clap.
+        let (c, a) = extract_negative_modes(vec!["-w", "-r", "file"].iter().map(OsString::from));
+        assert_eq!(c, Some("-w,-r".to_string()));
+        assert_eq!(a, vec!["w", "file"]);
+
+        // "chmod -w file -r" becomes "chmod -w,-r file". clap does not accept "-w,-r" as MODE.
+        // Therefore, "w" is added as pseudo mode to pass clap.
+        let (c, a) = extract_negative_modes(vec!["-w", "file", "-r"].iter().map(OsString::from));
+        assert_eq!(c, Some("-w,-r".to_string()));
+        assert_eq!(a, vec!["w", "file"]);
+
+        // "chmod -w -- -r file" becomes "chmod -w -r file", where "-r" is interpreted as file.
+        // Again, "w" is needed as pseudo mode.
+        let (c, a) = extract_negative_modes(vec!["-w", "--", "-r", "f"].iter().map(OsString::from));
+        assert_eq!(c, Some("-w".to_string()));
+        assert_eq!(a, vec!["w", "--", "-r", "f"]);
+
+        // "chmod -- -r file" becomes "chmod -r file".
+        let (c, a) = extract_negative_modes(vec!["--", "-r", "file"].iter().map(OsString::from));
+        assert_eq!(c, None);
+        assert_eq!(a, vec!["--", "-r", "file"]);
+    }
+}
diff --git a/src/uu/chown/Cargo.toml b/src/uu/chown/Cargo.toml
index 9ff43b006..cd1f881ee 100644
--- a/src/uu/chown/Cargo.toml
+++ b/src/uu/chown/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_chown"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "chown ~ (uutils) change the ownership of FILE"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/chown.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true, features=["entries", "fs", "perms"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["entries", "fs", "perms"] }
 
 [[bin]]
 name = "chown"
diff --git a/src/uu/chown/chown.md b/src/uu/chown/chown.md
new file mode 100644
index 000000000..83101c74c
--- /dev/null
+++ b/src/uu/chown/chown.md
@@ -0,0 +1,9 @@
+<!-- spell-checker:ignore RFILE -->
+# chown
+
+```
+chown [OPTION]... [OWNER][:[GROUP]] FILE...
+chown [OPTION]... --reference=RFILE FILE...
+```
+
+Change file owner and group
diff --git a/src/uu/chown/src/chown.rs b/src/uu/chown/src/chown.rs
index 401703cdf..67e71b815 100644
--- a/src/uu/chown/src/chown.rs
+++ b/src/uu/chown/src/chown.rs
@@ -9,8 +9,8 @@
 
 use uucore::display::Quotable;
 pub use uucore::entries::{self, Group, Locate, Passwd};
-use uucore::format_usage;
-use uucore::perms::{chown_base, options, IfFrom};
+use uucore::perms::{chown_base, options, GidUidOwnerFilter, IfFrom};
+use uucore::{format_usage, help_about, help_usage};
 
 use uucore::error::{FromIo, UResult, USimpleError};
 
@@ -19,13 +19,11 @@ use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
 use std::fs;
 use std::os::unix::fs::MetadataExt;
 
-static ABOUT: &str = "Change file owner and group";
+static ABOUT: &str = help_about!("chown.md");
 
-const USAGE: &str = "\
-    {} [OPTION]... [OWNER][:[GROUP]] FILE...
-    {} [OPTION]... --reference=RFILE FILE...";
+const USAGE: &str = help_usage!("chown.md");
 
-fn parse_gid_uid_and_filter(matches: &ArgMatches) -> UResult<(Option<u32>, Option<u32>, IfFrom)> {
+fn parse_gid_uid_and_filter(matches: &ArgMatches) -> UResult<GidUidOwnerFilter> {
     let filter = if let Some(spec) = matches.get_one::<String>(options::FROM) {
         match parse_spec(spec, ':')? {
             (Some(uid), None) => IfFrom::User(uid),
@@ -39,17 +37,34 @@ fn parse_gid_uid_and_filter(matches: &ArgMatches) -> UResult<(Option<u32>, Optio
 
     let dest_uid: Option<u32>;
     let dest_gid: Option<u32>;
+    let raw_owner: String;
     if let Some(file) = matches.get_one::<String>(options::REFERENCE) {
         let meta = fs::metadata(file)
             .map_err_context(|| format!("failed to get attributes of {}", file.quote()))?;
-        dest_gid = Some(meta.gid());
-        dest_uid = Some(meta.uid());
+        let gid = meta.gid();
+        let uid = meta.uid();
+        dest_gid = Some(gid);
+        dest_uid = Some(uid);
+        raw_owner = format!(
+            "{}:{}",
+            entries::uid2usr(uid).unwrap_or_else(|_| uid.to_string()),
+            entries::gid2grp(gid).unwrap_or_else(|_| gid.to_string())
+        );
     } else {
-        let (u, g) = parse_spec(matches.get_one::<String>(options::ARG_OWNER).unwrap(), ':')?;
+        raw_owner = matches
+            .get_one::<String>(options::ARG_OWNER)
+            .unwrap()
+            .into();
+        let (u, g) = parse_spec(&raw_owner, ':')?;
         dest_uid = u;
         dest_gid = g;
     }
-    Ok((dest_gid, dest_uid, filter))
+    Ok(GidUidOwnerFilter {
+        dest_gid,
+        dest_uid,
+        raw_owner,
+        filter,
+    })
 }
 
 #[uucore::main]
@@ -200,7 +215,9 @@ fn parse_spec(spec: &str, sep: char) -> UResult<(Option<u32>, Option<u32>)> {
     let user = args.next().unwrap_or("");
     let group = args.next().unwrap_or("");
 
-    let uid = if !user.is_empty() {
+    let uid = if user.is_empty() {
+        None
+    } else {
         Some(match Passwd::locate(user) {
             Ok(u) => u.uid, // We have been able to get the uid
             Err(_) =>
@@ -227,10 +244,10 @@ fn parse_spec(spec: &str, sep: char) -> UResult<(Option<u32>, Option<u32>)> {
                 }
             }
         })
-    } else {
-        None
     };
-    let gid = if !group.is_empty() {
+    let gid = if group.is_empty() {
+        None
+    } else {
         Some(match Group::locate(group) {
             Ok(g) => g.gid,
             Err(_) => match group.parse() {
@@ -243,8 +260,6 @@ fn parse_spec(spec: &str, sep: char) -> UResult<(Option<u32>, Option<u32>)> {
                 }
             },
         })
-    } else {
-        None
     };
 
     if user.chars().next().map(char::is_numeric).unwrap_or(false)
diff --git a/src/uu/chroot/Cargo.toml b/src/uu/chroot/Cargo.toml
index 0cae53110..1256a96c8 100644
--- a/src/uu/chroot/Cargo.toml
+++ b/src/uu/chroot/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_chroot"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "chroot ~ (uutils) run COMMAND under a new root directory"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/chroot.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true, features=["entries", "fs"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["entries", "fs"] }
 
 [[bin]]
 name = "chroot"
diff --git a/src/uu/chroot/chroot.md b/src/uu/chroot/chroot.md
new file mode 100644
index 000000000..3967d08f9
--- /dev/null
+++ b/src/uu/chroot/chroot.md
@@ -0,0 +1,8 @@
+<!-- spell-checker:ignore NEWROOT -->
+# chroot
+
+```
+chroot [OPTION]... NEWROOT [COMMAND [ARG]...]
+```
+
+Run COMMAND with root directory set to NEWROOT.
diff --git a/src/uu/chroot/src/chroot.rs b/src/uu/chroot/src/chroot.rs
index c80b4ab87..2d1c3703e 100644
--- a/src/uu/chroot/src/chroot.rs
+++ b/src/uu/chroot/src/chroot.rs
@@ -19,10 +19,10 @@ use std::process;
 use uucore::error::{set_exit_code, UClapError, UResult, UUsageError};
 use uucore::fs::{canonicalize, MissingHandling, ResolveMode};
 use uucore::libc::{self, chroot, setgid, setgroups, setuid};
-use uucore::{entries, format_usage};
+use uucore::{entries, format_usage, help_about, help_usage};
 
-static ABOUT: &str = "Run COMMAND with root directory set to NEWROOT.";
-static USAGE: &str = "{} [OPTION]... NEWROOT [COMMAND [ARG]...]";
+static ABOUT: &str = help_about!("chroot.md");
+static USAGE: &str = help_usage!("chroot.md");
 
 mod options {
     pub const NEWROOT: &str = "newroot";
diff --git a/src/uu/cksum/Cargo.toml b/src/uu/cksum/Cargo.toml
index 9b7f70f8f..345dfb238 100644
--- a/src/uu/cksum/Cargo.toml
+++ b/src/uu/cksum/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_cksum"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "cksum ~ (uutils) display CRC and size of input"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/cksum.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true, features=["sum"] }
-hex = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["sum"] }
+hex = { workspace = true }
 
 [[bin]]
 name = "cksum"
diff --git a/src/uu/cksum/cksum.md b/src/uu/cksum/cksum.md
new file mode 100644
index 000000000..4b0d25f32
--- /dev/null
+++ b/src/uu/cksum/cksum.md
@@ -0,0 +1,23 @@
+# cksum
+
+```
+cksum [OPTIONS] [FILE]...
+```
+
+Print CRC and size for each file
+
+## After Help
+
+DIGEST determines the digest algorithm and default output format:
+
+- `sysv`:    (equivalent to sum -s)
+- `bsd`:     (equivalent to sum -r)
+- `crc`:     (equivalent to cksum)
+- `md5`:     (equivalent to md5sum)
+- `sha1`:    (equivalent to sha1sum)
+- `sha224`:  (equivalent to sha224sum)
+- `sha256`:  (equivalent to sha256sum)
+- `sha384`:  (equivalent to sha384sum)
+- `sha512`:  (equivalent to sha512sum)
+- `blake2b`: (equivalent to b2sum)
+- `sm3`:     (only available through cksum)
diff --git a/src/uu/cksum/src/cksum.rs b/src/uu/cksum/src/cksum.rs
index e66d5f029..a46f69302 100644
--- a/src/uu/cksum/src/cksum.rs
+++ b/src/uu/cksum/src/cksum.rs
@@ -6,7 +6,7 @@
 // file that was distributed with this source code.
 
 // spell-checker:ignore (ToDO) fname, algo
-use clap::{crate_version, Arg, Command};
+use clap::{crate_version, Arg, ArgAction, Command};
 use hex::encode;
 use std::ffi::OsStr;
 use std::fs::File;
@@ -15,15 +15,16 @@ use std::iter;
 use std::path::Path;
 use uucore::{
     error::{FromIo, UResult},
-    format_usage,
+    format_usage, help_about, help_section, help_usage,
     sum::{
         div_ceil, Blake2b, Digest, DigestWriter, Md5, Sha1, Sha224, Sha256, Sha384, Sha512, Sm3,
         BSD, CRC, SYSV,
     },
 };
 
-const USAGE: &str = "{} [OPTIONS] [FILE]...";
-const ABOUT: &str = "Print CRC and size for each file";
+const USAGE: &str = help_usage!("cksum.md");
+const ABOUT: &str = help_about!("cksum.md");
+const AFTER_HELP: &str = help_section!("after help", "cksum.md");
 
 const ALGORITHM_OPTIONS_SYSV: &str = "sysv";
 const ALGORITHM_OPTIONS_BSD: &str = "bsd";
@@ -102,6 +103,7 @@ struct Options {
     algo_name: &'static str,
     digest: Box<dyn Digest + 'static>,
     output_bits: usize,
+    untagged: bool,
 }
 
 /// Calculate checksum
@@ -158,8 +160,22 @@ where
                 div_ceil(sz, options.output_bits),
                 filename.display()
             ),
-            (_, true) => println!("{sum} {sz}"),
-            (_, false) => println!("{sum} {sz} {}", filename.display()),
+            (ALGORITHM_OPTIONS_CRC, true) => println!("{sum} {sz}"),
+            (ALGORITHM_OPTIONS_CRC, false) => println!("{sum} {sz} {}", filename.display()),
+            (ALGORITHM_OPTIONS_BLAKE2B, _) if !options.untagged => {
+                println!("BLAKE2b ({}) = {sum}", filename.display());
+            }
+            _ => {
+                if options.untagged {
+                    println!("{sum}  {}", filename.display());
+                } else {
+                    println!(
+                        "{} ({}) = {sum}",
+                        options.algo_name.to_ascii_uppercase(),
+                        filename.display()
+                    );
+                }
+            }
         }
     }
 
@@ -201,25 +217,11 @@ fn digest_read<T: Read>(
 }
 
 mod options {
-    pub static FILE: &str = "file";
-    pub static ALGORITHM: &str = "algorithm";
+    pub const ALGORITHM: &str = "algorithm";
+    pub const FILE: &str = "file";
+    pub const UNTAGGED: &str = "untagged";
 }
 
-const ALGORITHM_HELP_DESC: &str =
-    "DIGEST determines the digest algorithm and default output format:\n\
-\n\
--a=sysv:    (equivalent to sum -s)\n\
--a=bsd:     (equivalent to sum -r)\n\
--a=crc:     (equivalent to cksum)\n\
--a=md5:     (equivalent to md5sum)\n\
--a=sha1:    (equivalent to sha1sum)\n\
--a=sha224:  (equivalent to sha224sum)\n\
--a=sha256:  (equivalent to sha256sum)\n\
--a=sha384:  (equivalent to sha384sum)\n\
--a=sha512:  (equivalent to sha512sum)\n\
--a=blake2b: (equivalent to b2sum)\n\
--a=sm3:     (only available through cksum)\n";
-
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args.collect_ignore();
@@ -236,6 +238,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         algo_name: name,
         digest: algo,
         output_bits: bits,
+        untagged: matches.get_flag(options::UNTAGGED),
     };
 
     match matches.get_many::<String>(options::FILE) {
@@ -278,5 +281,11 @@ pub fn uu_app() -> Command {
                     ALGORITHM_OPTIONS_SM3,
                 ]),
         )
-        .after_help(ALGORITHM_HELP_DESC)
+        .arg(
+            Arg::new(options::UNTAGGED)
+                .long(options::UNTAGGED)
+                .help("create a reversed style checksum, without digest type")
+                .action(ArgAction::SetTrue),
+        )
+        .after_help(AFTER_HELP)
 }
diff --git a/src/uu/comm/Cargo.toml b/src/uu/comm/Cargo.toml
index fbe28903f..e5947bb84 100644
--- a/src/uu/comm/Cargo.toml
+++ b/src/uu/comm/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_comm"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "comm ~ (uutils) compare sorted inputs"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/comm.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "comm"
diff --git a/src/uu/comm/src/comm.rs b/src/uu/comm/src/comm.rs
index 3bc45b6a5..26e704037 100644
--- a/src/uu/comm/src/comm.rs
+++ b/src/uu/comm/src/comm.rs
@@ -8,11 +8,11 @@
 // spell-checker:ignore (ToDO) delim mkdelim
 
 use std::cmp::Ordering;
+use std::fmt::Display;
 use std::fs::File;
 use std::io::{self, stdin, BufRead, BufReader, Stdin};
 use std::path::Path;
-use uucore::error::FromIo;
-use uucore::error::UResult;
+use uucore::error::{FromIo, UResult};
 use uucore::{format_usage, help_about, help_usage};
 
 use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
@@ -29,6 +29,7 @@ mod options {
     pub const FILE_1: &str = "FILE1";
     pub const FILE_2: &str = "FILE2";
     pub const TOTAL: &str = "total";
+    pub const ZERO_TERMINATED: &str = "zero-terminated";
 }
 
 fn column_width(col: &str, opts: &ArgMatches) -> usize {
@@ -39,23 +40,66 @@ fn column_width(col: &str, opts: &ArgMatches) -> usize {
     }
 }
 
-fn ensure_nl(line: &mut String) {
-    if !line.ends_with('\n') {
-        line.push('\n');
+#[repr(u8)]
+#[derive(Clone, Copy)]
+enum LineEnding {
+    Newline = b'\n',
+    Nul = 0,
+}
+
+impl From<LineEnding> for u8 {
+    fn from(line_ending: LineEnding) -> Self {
+        line_ending as Self
     }
 }
 
-enum LineReader {
+impl From<bool> for LineEnding {
+    fn from(is_zero_terminated: bool) -> Self {
+        if is_zero_terminated {
+            Self::Nul
+        } else {
+            Self::Newline
+        }
+    }
+}
+
+impl Display for LineEnding {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Newline => writeln!(f),
+            Self::Nul => write!(f, "\0"),
+        }
+    }
+}
+
+enum Input {
     Stdin(Stdin),
     FileIn(BufReader<File>),
 }
 
+struct LineReader {
+    line_ending: LineEnding,
+    input: Input,
+}
+
 impl LineReader {
-    fn read_line(&mut self, buf: &mut String) -> io::Result<usize> {
-        match *self {
-            Self::Stdin(ref mut r) => r.read_line(buf),
-            Self::FileIn(ref mut r) => r.read_line(buf),
+    fn new(input: Input, line_ending: LineEnding) -> Self {
+        Self { input, line_ending }
+    }
+
+    fn read_line(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
+        let line_ending = self.line_ending.into();
+
+        let result = match &mut self.input {
+            Input::Stdin(r) => r.lock().read_until(line_ending, buf),
+            Input::FileIn(r) => r.read_until(line_ending, buf),
+        };
+
+        if !buf.ends_with(&[line_ending]) {
+            buf.push(line_ending);
         }
+
+        result
     }
 }
 
@@ -71,9 +115,9 @@ fn comm(a: &mut LineReader, b: &mut LineReader, opts: &ArgMatches) {
     let delim_col_2 = delim.repeat(width_col_1);
     let delim_col_3 = delim.repeat(width_col_1 + width_col_2);
 
-    let ra = &mut String::new();
+    let ra = &mut Vec::new();
     let mut na = a.read_line(ra);
-    let rb = &mut String::new();
+    let rb = &mut Vec::new();
     let mut nb = b.read_line(rb);
 
     let mut total_col_1 = 0;
@@ -96,8 +140,7 @@ fn comm(a: &mut LineReader, b: &mut LineReader, opts: &ArgMatches) {
         match ord {
             Ordering::Less => {
                 if !opts.get_flag(options::COLUMN_1) {
-                    ensure_nl(ra);
-                    print!("{ra}");
+                    print!("{}", String::from_utf8_lossy(ra));
                 }
                 ra.clear();
                 na = a.read_line(ra);
@@ -105,8 +148,7 @@ fn comm(a: &mut LineReader, b: &mut LineReader, opts: &ArgMatches) {
             }
             Ordering::Greater => {
                 if !opts.get_flag(options::COLUMN_2) {
-                    ensure_nl(rb);
-                    print!("{delim_col_2}{rb}");
+                    print!("{delim_col_2}{}", String::from_utf8_lossy(rb));
                 }
                 rb.clear();
                 nb = b.read_line(rb);
@@ -114,8 +156,7 @@ fn comm(a: &mut LineReader, b: &mut LineReader, opts: &ArgMatches) {
             }
             Ordering::Equal => {
                 if !opts.get_flag(options::COLUMN_3) {
-                    ensure_nl(ra);
-                    print!("{delim_col_3}{ra}");
+                    print!("{delim_col_3}{}", String::from_utf8_lossy(ra));
                 }
                 ra.clear();
                 rb.clear();
@@ -127,17 +168,20 @@ fn comm(a: &mut LineReader, b: &mut LineReader, opts: &ArgMatches) {
     }
 
     if opts.get_flag(options::TOTAL) {
-        println!("{total_col_1}{delim}{total_col_2}{delim}{total_col_3}{delim}total");
+        let line_ending = LineEnding::from(opts.get_flag(options::ZERO_TERMINATED));
+        print!("{total_col_1}{delim}{total_col_2}{delim}{total_col_3}{delim}total{line_ending}");
     }
 }
 
-fn open_file(name: &str) -> io::Result<LineReader> {
-    match name {
-        "-" => Ok(LineReader::Stdin(stdin())),
-        _ => {
-            let f = File::open(Path::new(name))?;
-            Ok(LineReader::FileIn(BufReader::new(f)))
-        }
+fn open_file(name: &str, line_ending: LineEnding) -> io::Result<LineReader> {
+    if name == "-" {
+        Ok(LineReader::new(Input::Stdin(stdin()), line_ending))
+    } else {
+        let f = File::open(Path::new(name))?;
+        Ok(LineReader::new(
+            Input::FileIn(BufReader::new(f)),
+            line_ending,
+        ))
     }
 }
 
@@ -146,10 +190,11 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args.collect_lossy();
 
     let matches = uu_app().try_get_matches_from(args)?;
+    let line_ending = LineEnding::from(matches.get_flag(options::ZERO_TERMINATED));
     let filename1 = matches.get_one::<String>(options::FILE_1).unwrap();
     let filename2 = matches.get_one::<String>(options::FILE_2).unwrap();
-    let mut f1 = open_file(filename1).map_err_context(|| filename1.to_string())?;
-    let mut f2 = open_file(filename2).map_err_context(|| filename2.to_string())?;
+    let mut f1 = open_file(filename1, line_ending).map_err_context(|| filename1.to_string())?;
+    let mut f2 = open_file(filename2, line_ending).map_err_context(|| filename2.to_string())?;
 
     comm(&mut f1, &mut f2, &matches);
     Ok(())
@@ -187,6 +232,14 @@ pub fn uu_app() -> Command {
                 .default_value(options::DELIMITER_DEFAULT)
                 .hide_default_value(true),
         )
+        .arg(
+            Arg::new(options::ZERO_TERMINATED)
+                .long(options::ZERO_TERMINATED)
+                .short('z')
+                .overrides_with(options::ZERO_TERMINATED)
+                .help("line delimiter is NUL, not newline")
+                .action(ArgAction::SetTrue),
+        )
         .arg(
             Arg::new(options::FILE_1)
                 .required(true)
diff --git a/src/uu/cp/Cargo.toml b/src/uu/cp/Cargo.toml
index 4aa871185..ff8f21160 100644
--- a/src/uu/cp/Cargo.toml
+++ b/src/uu/cp/Cargo.toml
@@ -1,10 +1,10 @@
 [package]
 name = "uu_cp"
-version = "0.0.17"
+version = "0.0.19"
 authors = [
-    "Jordy Dickinson <jordy.dickinson@gmail.com>",
-    "Joshua S. Miller <jsmiller@uchicago.edu>",
-    "uutils developers",
+  "Jordy Dickinson <jordy.dickinson@gmail.com>",
+  "Joshua S. Miller <jsmiller@uchicago.edu>",
+  "uutils developers",
 ]
 license = "MIT"
 description = "cp ~ (uutils) copy SOURCE to DESTINATION"
@@ -19,18 +19,18 @@ edition = "2021"
 path = "src/cp.rs"
 
 [dependencies]
-clap = { workspace=true }
-filetime = { workspace=true }
-libc = { workspace=true }
-quick-error = { workspace=true }
-selinux = { workspace=true, optional=true }
-uucore = { workspace=true, features=["entries", "fs", "perms", "mode"] }
-walkdir = { workspace=true }
-indicatif = { workspace=true }
+clap = { workspace = true }
+filetime = { workspace = true }
+libc = { workspace = true }
+quick-error = { workspace = true }
+selinux = { workspace = true, optional = true }
+uucore = { workspace = true, features = ["entries", "fs", "perms", "mode"] }
+walkdir = { workspace = true }
+indicatif = { workspace = true }
 
 [target.'cfg(unix)'.dependencies]
-xattr = { workspace=true }
-exacl = { workspace=true, optional=true }
+xattr = { workspace = true }
+exacl = { workspace = true, optional = true }
 
 [[bin]]
 name = "cp"
diff --git a/src/uu/cp/README.md b/src/uu/cp/README.md
index 13399c3b1..d40e29194 100644
--- a/src/uu/cp/README.md
+++ b/src/uu/cp/README.md
@@ -1,18 +1,18 @@
 <!-- markdownlint-disable first-line-heading -->
 <!-- spell-checker:ignore (markdown) markdownlint -->
 
-## Feature list
+# Feature list
 
 <!-- spell-checker:ignore (options) linkgs reflink -->
 
-### To Do
+## To Do
 
 - [ ] cli-symbolic-links
 - [ ] context
 - [ ] copy-contents
 - [ ] sparse
 
-### Completed
+## Completed
 
 - [x] archive
 - [x] attributes-only
diff --git a/src/uu/cp/cp.md b/src/uu/cp/cp.md
index 5f3cabc18..7485340f2 100644
--- a/src/uu/cp/cp.md
+++ b/src/uu/cp/cp.md
@@ -7,3 +7,19 @@ cp [OPTION]... -t DIRECTORY SOURCE...
 ```
 
 Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY.
+
+## After Help
+
+Do not copy a non-directory that has an existing destination with the same or newer modification timestamp;
+instead, silently skip the file without failing. If timestamps are being preserved, the comparison is to the
+source timestamp truncated to the resolutions of the destination file system and of the system calls used to
+update timestamps; this avoids duplicate work if several `cp -pu` commands are executed with the same source
+and destination. This option is ignored if the `-n` or `--no-clobber` option is also specified. Also, if
+`--preserve=links` is also specified (like with `cp -au` for example), that will take precedence; consequently,
+depending on the order that files are processed from the source, newer files in the destination may be replaced,
+to mirror hard links in the source. which gives more control over which existing files in the destination are
+replaced, and its value can be one of the following:
+
+* `all`    This is the default operation when an `--update` option is not specified, and results in all existing files in the destination being replaced.
+* `none`   This is similar to the `--no-clobber` option, in that no files in the destination are replaced, but also skipping a file does not induce a failure.
+* `older`  This is the default operation when `--update` is specified, and results in files being replaced if they’re older than the corresponding source file.
diff --git a/src/uu/cp/src/copydir.rs b/src/uu/cp/src/copydir.rs
index c312b7cbb..aaeb73f5a 100644
--- a/src/uu/cp/src/copydir.rs
+++ b/src/uu/cp/src/copydir.rs
@@ -404,8 +404,18 @@ pub(crate) fn copy_directory(
             Err(e) => show_error!("{}", e),
         }
     }
+
     // Copy the attributes from the root directory to the target directory.
-    copy_attributes(root, target, &options.attributes)?;
+    if options.parents {
+        let dest = target.join(root.file_name().unwrap());
+        copy_attributes(root, dest.as_path(), &options.attributes)?;
+        for (x, y) in aligned_ancestors(root, dest.as_path()) {
+            copy_attributes(x, y, &options.attributes)?;
+        }
+    } else {
+        copy_attributes(root, target, &options.attributes)?;
+    }
+
     Ok(())
 }
 
diff --git a/src/uu/cp/src/cp.rs b/src/uu/cp/src/cp.rs
index f0dc762be..60ef54095 100644
--- a/src/uu/cp/src/cp.rs
+++ b/src/uu/cp/src/cp.rs
@@ -26,7 +26,7 @@ use std::os::unix::fs::{FileTypeExt, PermissionsExt};
 use std::path::{Path, PathBuf, StripPrefixError};
 use std::string::ToString;
 
-use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
+use clap::{builder::ValueParser, crate_version, Arg, ArgAction, ArgMatches, Command};
 use filetime::FileTime;
 use indicatif::{ProgressBar, ProgressStyle};
 #[cfg(unix)]
@@ -38,9 +38,14 @@ use uucore::backup_control::{self, BackupMode};
 use uucore::display::Quotable;
 use uucore::error::{set_exit_code, UClapError, UError, UResult, UUsageError};
 use uucore::fs::{
-    canonicalize, paths_refer_to_same_file, FileInformation, MissingHandling, ResolveMode,
+    canonicalize, is_symlink_loop, paths_refer_to_same_file, FileInformation, MissingHandling,
+    ResolveMode,
+};
+use uucore::update_control::{self, UpdateMode};
+use uucore::{
+    crash, format_usage, help_about, help_section, help_usage, prompt_yes, show_error,
+    show_warning, util_name,
 };
-use uucore::{crash, format_usage, help_about, help_usage, prompt_yes, show_error, show_warning};
 
 use crate::copydir::copy_directory;
 
@@ -78,6 +83,7 @@ quick_error! {
         StripPrefixError(err: StripPrefixError) { from() }
 
         /// Result of a skipped file
+        /// Currently happens when "no" is selected in interactive mode
         Skipped { }
 
         /// Result of a skipped file
@@ -91,7 +97,7 @@ quick_error! {
         /// Invalid arguments to backup
         Backup(description: String) { display("{}\nTry '{} --help' for more information.", description, uucore::execution_phrase()) }
 
-        NotADirectory(path: String) { display("'{}' is not a directory", path) }
+        NotADirectory(path: PathBuf) { display("'{}' is not a directory", path.display()) }
     }
 }
 
@@ -222,14 +228,84 @@ pub struct Options {
     attributes: Attributes,
     recursive: bool,
     backup_suffix: String,
-    target_dir: Option<String>,
-    update: bool,
+    target_dir: Option<PathBuf>,
+    update: UpdateMode,
+    debug: bool,
     verbose: bool,
     progress_bar: bool,
 }
 
+/// Enum representing various debug states of the offload and reflink actions.
+#[derive(Debug)]
+#[allow(dead_code)] // All of them are used on Linux
+enum OffloadReflinkDebug {
+    Unknown,
+    No,
+    Yes,
+    Avoided,
+    Unsupported,
+}
+
+/// Enum representing various debug states of the sparse detection.
+#[derive(Debug)]
+#[allow(dead_code)] // silent for now until we use them
+enum SparseDebug {
+    Unknown,
+    No,
+    Zeros,
+    SeekHole,
+    SeekHoleZeros,
+    Unsupported,
+}
+
+/// Struct that contains the debug state for each action in a file copy operation.
+#[derive(Debug)]
+struct CopyDebug {
+    offload: OffloadReflinkDebug,
+    reflink: OffloadReflinkDebug,
+    sparse_detection: SparseDebug,
+}
+
+impl OffloadReflinkDebug {
+    fn to_string(&self) -> &'static str {
+        match self {
+            Self::No => "no",
+            Self::Yes => "yes",
+            Self::Avoided => "avoided",
+            Self::Unsupported => "unsupported",
+            Self::Unknown => "unknown",
+        }
+    }
+}
+
+impl SparseDebug {
+    fn to_string(&self) -> &'static str {
+        match self {
+            Self::No => "no",
+            Self::Zeros => "zeros",
+            Self::SeekHole => "SEEK_HOLE",
+            Self::SeekHoleZeros => "SEEK_HOLE + zeros",
+            Self::Unsupported => "unsupported",
+            Self::Unknown => "unknown",
+        }
+    }
+}
+
+/// This function prints the debug information of a file copy operation if
+/// no hard link or symbolic link is required, and data copy is required.
+/// It prints the debug information of the offload, reflink, and sparse detection actions.
+fn show_debug(copy_debug: &CopyDebug) {
+    println!(
+        "copy offload: {}, reflink: {}, sparse detection: {}",
+        copy_debug.offload.to_string(),
+        copy_debug.reflink.to_string(),
+        copy_debug.sparse_detection.to_string(),
+    );
+}
+
 const ABOUT: &str = help_about!("cp.md");
 const USAGE: &str = help_usage!("cp.md");
+const AFTER_HELP: &str = help_section!("after help", "cp.md");
 
 static EXIT_ERR: i32 = 1;
 
@@ -263,7 +339,7 @@ mod options {
     pub const STRIP_TRAILING_SLASHES: &str = "strip-trailing-slashes";
     pub const SYMBOLIC_LINK: &str = "symbolic-link";
     pub const TARGET_DIRECTORY: &str = "target-directory";
-    pub const UPDATE: &str = "update";
+    pub const DEBUG: &str = "debug";
     pub const VERBOSE: &str = "verbose";
 }
 
@@ -273,14 +349,22 @@ static PRESERVABLE_ATTRIBUTES: &[&str] = &[
     "ownership",
     "timestamps",
     "context",
+    "link",
     "links",
     "xattr",
     "all",
 ];
 
 #[cfg(not(unix))]
-static PRESERVABLE_ATTRIBUTES: &[&str] =
-    &["mode", "timestamps", "context", "links", "xattr", "all"];
+static PRESERVABLE_ATTRIBUTES: &[&str] = &[
+    "mode",
+    "timestamps",
+    "context",
+    "link",
+    "links",
+    "xattr",
+    "all",
+];
 
 pub fn uu_app() -> Command {
     const MODE_ARGS: &[&str] = &[
@@ -294,6 +378,10 @@ pub fn uu_app() -> Command {
         .version(crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
+        .after_help(format!(
+            "{AFTER_HELP}\n\n{}",
+            backup_control::BACKUP_CONTROL_LONG_HELP
+        ))
         .infer_long_args(true)
         .arg(
             Arg::new(options::TARGET_DIRECTORY)
@@ -302,6 +390,7 @@ pub fn uu_app() -> Command {
                 .long(options::TARGET_DIRECTORY)
                 .value_name(options::TARGET_DIRECTORY)
                 .value_hint(clap::ValueHint::DirPath)
+                .value_parser(ValueParser::path_buf())
                 .help("copy all SOURCE arguments into target-directory"),
         )
         .arg(
@@ -351,6 +440,12 @@ pub fn uu_app() -> Command {
                 .help("remove any trailing slashes from each SOURCE argument")
                 .action(ArgAction::SetTrue),
         )
+        .arg(
+            Arg::new(options::DEBUG)
+                .long(options::DEBUG)
+                .help("explain how a file is copied. Implies -v")
+                .action(ArgAction::SetTrue),
+        )
         .arg(
             Arg::new(options::VERBOSE)
                 .short('v')
@@ -391,16 +486,8 @@ pub fn uu_app() -> Command {
         .arg(backup_control::arguments::backup())
         .arg(backup_control::arguments::backup_no_args())
         .arg(backup_control::arguments::suffix())
-        .arg(
-            Arg::new(options::UPDATE)
-                .short('u')
-                .long(options::UPDATE)
-                .help(
-                    "copy only when the SOURCE file is newer than the destination file \
-                    or when the destination file is missing",
-                )
-                .action(ArgAction::SetTrue),
-        )
+        .arg(update_control::arguments::update())
+        .arg(update_control::arguments::update_no_args())
         .arg(
             Arg::new(options::REFLINK)
                 .long(options::REFLINK)
@@ -428,6 +515,7 @@ pub fn uu_app() -> Command {
                     PRESERVABLE_ATTRIBUTES,
                 ))
                 .num_args(0..)
+                .require_equals(true)
                 .value_name("ATTR_LIST")
                 .overrides_with_all([
                     options::ARCHIVE,
@@ -555,19 +643,18 @@ pub fn uu_app() -> Command {
         .arg(
             Arg::new(options::PATHS)
                 .action(ArgAction::Append)
-                .value_hint(clap::ValueHint::AnyPath),
+                .value_hint(clap::ValueHint::AnyPath)
+                .value_parser(ValueParser::path_buf()),
         )
 }
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let matches = uu_app()
-        .after_help(backup_control::BACKUP_CONTROL_LONG_HELP)
-        .try_get_matches_from(args);
+    let matches = uu_app().try_get_matches_from(args);
 
     // The error is parsed here because we do not want version or help being printed to stderr.
     if let Err(e) = matches {
-        let mut app = uu_app().after_help(backup_control::BACKUP_CONTROL_LONG_HELP);
+        let mut app = uu_app();
 
         match e.kind() {
             clap::error::ErrorKind::DisplayHelp => {
@@ -576,7 +663,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             clap::error::ErrorKind::DisplayVersion => print!("{}", app.render_version()),
             _ => return Err(Box::new(e.with_exit_code(1))),
         };
-    } else if let Ok(matches) = matches {
+    } else if let Ok(mut matches) = matches {
         let options = Options::from_matches(&matches)?;
 
         if options.overwrite == OverwriteMode::NoClobber && options.backup != BackupMode::NoBackup {
@@ -586,12 +673,12 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             ));
         }
 
-        let paths: Vec<String> = matches
-            .get_many::<String>(options::PATHS)
-            .map(|v| v.map(ToString::to_string).collect())
+        let paths: Vec<PathBuf> = matches
+            .remove_many::<PathBuf>(options::PATHS)
+            .map(|v| v.collect())
             .unwrap_or_default();
 
-        let (sources, target) = parse_path_args(&paths, &options)?;
+        let (sources, target) = parse_path_args(paths, &options)?;
 
         if let Err(error) = copy(&sources, &target, &options) {
             match error {
@@ -638,7 +725,11 @@ impl CopyMode {
             Self::Link
         } else if matches.get_flag(options::SYMBOLIC_LINK) {
             Self::SymLink
-        } else if matches.get_flag(options::UPDATE) {
+        } else if matches
+            .get_one::<String>(update_control::arguments::OPT_UPDATE)
+            .is_some()
+            || matches.get_flag(update_control::arguments::OPT_UPDATE_NO_ARG)
+        {
             Self::Update
         } else if matches.get_flag(options::ATTRIBUTES_ONLY) {
             Self::AttrOnly
@@ -708,7 +799,7 @@ impl Attributes {
             "ownership" => self.ownership = preserve_yes_required,
             "timestamps" => self.timestamps = preserve_yes_required,
             "context" => self.context = preserve_yes_required,
-            "links" => self.links = preserve_yes_required,
+            "link" | "links" => self.links = preserve_yes_required,
             "xattr" => self.xattr = preserve_yes_required,
             _ => {
                 return Err(Error::InvalidArgument(format!(
@@ -722,6 +813,7 @@ impl Attributes {
 }
 
 impl Options {
+    #[allow(clippy::cognitive_complexity)]
     fn from_matches(matches: &ArgMatches) -> CopyResult<Self> {
         let not_implemented_opts = vec![
             #[cfg(not(any(windows, unix)))]
@@ -746,6 +838,7 @@ impl Options {
             Err(e) => return Err(Error::Backup(format!("{e}"))),
             Ok(mode) => mode,
         };
+        let update_mode = update_control::determine_update_mode(matches);
 
         let backup_suffix = backup_control::determine_backup_suffix(matches);
 
@@ -754,11 +847,11 @@ impl Options {
         // Parse target directory options
         let no_target_dir = matches.get_flag(options::NO_TARGET_DIRECTORY);
         let target_dir = matches
-            .get_one::<String>(options::TARGET_DIRECTORY)
-            .map(ToString::to_string);
+            .get_one::<PathBuf>(options::TARGET_DIRECTORY)
+            .cloned();
 
         if let Some(dir) = &target_dir {
-            if !Path::new(dir).is_dir() {
+            if !dir.is_dir() {
                 return Err(Error::NotADirectory(dir.clone()));
             }
         };
@@ -823,8 +916,9 @@ impl Options {
                 || matches.get_flag(options::DEREFERENCE),
             one_file_system: matches.get_flag(options::ONE_FILE_SYSTEM),
             parents: matches.get_flag(options::PARENTS),
-            update: matches.get_flag(options::UPDATE),
-            verbose: matches.get_flag(options::VERBOSE),
+            update: update_mode,
+            debug: matches.get_flag(options::DEBUG),
+            verbose: matches.get_flag(options::VERBOSE) || matches.get_flag(options::DEBUG),
             strip_trailing_slashes: matches.get_flag(options::STRIP_TRAILING_SLASHES),
             reflink_mode: {
                 if let Some(reflink) = matches.get_one::<String>(options::REFLINK) {
@@ -915,9 +1009,7 @@ impl TargetType {
 }
 
 /// Returns tuple of (Source paths, Target)
-fn parse_path_args(path_args: &[String], options: &Options) -> CopyResult<(Vec<Source>, Target)> {
-    let mut paths = path_args.iter().map(PathBuf::from).collect::<Vec<_>>();
-
+fn parse_path_args(mut paths: Vec<Source>, options: &Options) -> CopyResult<(Vec<Source>, Target)> {
     if paths.is_empty() {
         // No files specified
         return Err("missing file operand".into());
@@ -933,7 +1025,7 @@ fn parse_path_args(path_args: &[String], options: &Options) -> CopyResult<(Vec<S
         Some(ref target) => {
             // All path args are sources, and the target dir was
             // specified separately
-            PathBuf::from(target)
+            target.clone()
         }
         None => {
             // If there was no explicit target-dir, then use the last
@@ -1012,19 +1104,21 @@ fn preserve_hardlinks(
 }
 
 /// When handling errors, we don't always want to show them to the user. This function handles that.
-/// If the error is printed, returns true, false otherwise.
-fn show_error_if_needed(error: &Error) -> bool {
+fn show_error_if_needed(error: &Error) {
     match error {
         // When using --no-clobber, we don't want to show
         // an error message
-        Error::NotAllFilesCopied => (),
-        Error::Skipped => (),
+        Error::NotAllFilesCopied => {
+            // Need to return an error code
+        }
+        Error::Skipped => {
+            // touch a b && echo "n"|cp -i a b && echo $?
+            // should return an error from GNU 9.2
+        }
         _ => {
             show_error!("{}", error);
-            return true;
         }
     }
-    false
 }
 
 /// Copy all `sources` to `target`.  Returns an
@@ -1081,9 +1175,8 @@ fn copy(sources: &[Source], target: &TargetSlice, options: &Options) -> CopyResu
                     options,
                     &mut symlinked_files,
                 ) {
-                    if show_error_if_needed(&error) {
-                        non_fatal_errors = true;
-                    }
+                    show_error_if_needed(&error);
+                    non_fatal_errors = true;
                 }
             }
             seen_sources.insert(source);
@@ -1142,25 +1235,41 @@ fn copy_source(
     } else {
         // Copy as file
         let dest = construct_dest_path(source_path, target, target_type, options)?;
-        copy_file(
+        let res = copy_file(
             progress_bar,
             source_path,
             dest.as_path(),
             options,
             symlinked_files,
             true,
-        )
+        );
+        if options.parents {
+            for (x, y) in aligned_ancestors(source, dest.as_path()) {
+                copy_attributes(x, y, &options.attributes)?;
+            }
+        }
+        res
     }
 }
 
 impl OverwriteMode {
-    fn verify(&self, path: &Path) -> CopyResult<()> {
+    fn verify(&self, path: &Path, verbose: bool) -> CopyResult<()> {
         match *self {
-            Self::NoClobber => Err(Error::NotAllFilesCopied),
+            Self::NoClobber => {
+                if verbose {
+                    println!("skipped {}", path.quote());
+                } else {
+                    eprintln!("{}: not replacing {}", util_name(), path.quote());
+                }
+                Err(Error::NotAllFilesCopied)
+            }
             Self::Interactive(_) => {
                 if prompt_yes!("overwrite {}?", path.quote()) {
                     Ok(())
                 } else {
+                    if verbose {
+                        println!("skipped {}", path.quote());
+                    }
                     Err(Error::Skipped)
                 }
             }
@@ -1368,7 +1477,7 @@ fn handle_existing_dest(
         return Err(format!("{} and {} are the same file", source.quote(), dest.quote()).into());
     }
 
-    options.overwrite.verify(dest)?;
+    options.overwrite.verify(dest, options.verbose)?;
 
     let backup_path = backup_control::get_backup_path(options.backup, dest, &options.backup_suffix);
     if let Some(backup_path) = backup_path {
@@ -1383,11 +1492,10 @@ fn handle_existing_dest(
             backup_dest(dest, &backup_path)?;
         }
     }
-
     match options.overwrite {
         // FIXME: print that the file was removed if --verbose is enabled
         OverwriteMode::Clobber(ClobberMode::Force) => {
-            if fs::metadata(dest)?.permissions().readonly() {
+            if is_symlink_loop(dest) || fs::metadata(dest)?.permissions().readonly() {
                 fs::remove_file(dest)?;
             }
         }
@@ -1460,6 +1568,7 @@ fn aligned_ancestors<'a>(source: &'a Path, dest: &'a Path) -> Vec<(&'a Path, &'a
 ///
 /// The original permissions of `source` will be copied to `dest`
 /// after a successful copy.
+#[allow(clippy::cognitive_complexity)]
 fn copy_file(
     progress_bar: &Option<ProgressBar>,
     source: &Path,
@@ -1468,7 +1577,9 @@ fn copy_file(
     symlinked_files: &mut HashSet<FileInformation>,
     source_in_command_line: bool,
 ) -> CopyResult<()> {
-    if options.update && options.overwrite == OverwriteMode::Interactive(ClobberMode::Standard) {
+    if (options.update == UpdateMode::ReplaceIfOlder || options.update == UpdateMode::ReplaceNone)
+        && options.overwrite == OverwriteMode::Interactive(ClobberMode::Standard)
+    {
         // `cp -i --update old new` when `new` exists doesn't copy anything
         // and exit with 0
         return Ok(());
@@ -1493,6 +1604,8 @@ fn copy_file(
                 options.overwrite,
                 OverwriteMode::Clobber(ClobberMode::RemoveDestination)
             )
+            && !is_symlink_loop(dest)
+            && std::env::var_os("POSIXLY_CORRECT").is_none()
         {
             return Err(Error::Error(format!(
                 "not writing through dangling symlink '{}'",
@@ -1624,22 +1737,38 @@ fn copy_file(
         }
         CopyMode::Update => {
             if dest.exists() {
-                let dest_metadata = fs::symlink_metadata(dest)?;
+                match options.update {
+                    update_control::UpdateMode::ReplaceAll => {
+                        copy_helper(
+                            source,
+                            dest,
+                            options,
+                            context,
+                            source_is_symlink,
+                            source_is_fifo,
+                            symlinked_files,
+                        )?;
+                    }
+                    update_control::UpdateMode::ReplaceNone => return Ok(()),
+                    update_control::UpdateMode::ReplaceIfOlder => {
+                        let dest_metadata = fs::symlink_metadata(dest)?;
 
-                let src_time = source_metadata.modified()?;
-                let dest_time = dest_metadata.modified()?;
-                if src_time <= dest_time {
-                    return Ok(());
-                } else {
-                    copy_helper(
-                        source,
-                        dest,
-                        options,
-                        context,
-                        source_is_symlink,
-                        source_is_fifo,
-                        symlinked_files,
-                    )?;
+                        let src_time = source_metadata.modified()?;
+                        let dest_time = dest_metadata.modified()?;
+                        if src_time <= dest_time {
+                            return Ok(());
+                        } else {
+                            copy_helper(
+                                source,
+                                dest,
+                                options,
+                                context,
+                                source_is_symlink,
+                                source_is_fifo,
+                                symlinked_files,
+                            )?;
+                        }
+                    }
                 }
             } else {
                 copy_helper(
@@ -1706,11 +1835,11 @@ fn copy_helper(
         File::create(dest).context(dest.display().to_string())?;
     } else if source_is_fifo && options.recursive && !options.copy_contents {
         #[cfg(unix)]
-        copy_fifo(dest, options.overwrite)?;
+        copy_fifo(dest, options.overwrite, options.verbose)?;
     } else if source_is_symlink {
         copy_link(source, dest, symlinked_files)?;
     } else {
-        copy_on_write(
+        let copy_debug = copy_on_write(
             source,
             dest,
             options.reflink_mode,
@@ -1719,6 +1848,10 @@ fn copy_helper(
             #[cfg(any(target_os = "linux", target_os = "android", target_os = "macos"))]
             source_is_fifo,
         )?;
+
+        if !options.attributes_only && options.debug {
+            show_debug(&copy_debug);
+        }
     }
 
     Ok(())
@@ -1727,9 +1860,9 @@ fn copy_helper(
 // "Copies" a FIFO by creating a new one. This workaround is because Rust's
 // built-in fs::copy does not handle FIFOs (see rust-lang/rust/issues/79390).
 #[cfg(unix)]
-fn copy_fifo(dest: &Path, overwrite: OverwriteMode) -> CopyResult<()> {
+fn copy_fifo(dest: &Path, overwrite: OverwriteMode, verbose: bool) -> CopyResult<()> {
     if dest.exists() {
-        overwrite.verify(dest)?;
+        overwrite.verify(dest, verbose)?;
         fs::remove_file(dest)?;
     }
 
diff --git a/src/uu/cp/src/platform/linux.rs b/src/uu/cp/src/platform/linux.rs
index 7d97813dd..18f2520a2 100644
--- a/src/uu/cp/src/platform/linux.rs
+++ b/src/uu/cp/src/platform/linux.rs
@@ -13,7 +13,7 @@ use quick_error::ResultExt;
 
 use uucore::mode::get_umask;
 
-use crate::{CopyResult, ReflinkMode, SparseMode};
+use crate::{CopyDebug, CopyResult, OffloadReflinkDebug, ReflinkMode, SparseDebug, SparseMode};
 
 // From /usr/include/linux/fs.h:
 // #define FICLONE		_IOW(0x94, 9, int)
@@ -145,24 +145,51 @@ pub(crate) fn copy_on_write(
     sparse_mode: SparseMode,
     context: &str,
     source_is_fifo: bool,
-) -> CopyResult<()> {
+) -> CopyResult<CopyDebug> {
+    let mut copy_debug = CopyDebug {
+        offload: OffloadReflinkDebug::Unknown,
+        reflink: OffloadReflinkDebug::Unsupported,
+        sparse_detection: SparseDebug::No,
+    };
+
     let result = match (reflink_mode, sparse_mode) {
-        (ReflinkMode::Never, SparseMode::Always) => sparse_copy(source, dest),
-        (ReflinkMode::Never, _) => std::fs::copy(source, dest).map(|_| ()),
-        (ReflinkMode::Auto, SparseMode::Always) => sparse_copy(source, dest),
+        (ReflinkMode::Never, SparseMode::Always) => {
+            copy_debug.sparse_detection = SparseDebug::Zeros;
+            copy_debug.offload = OffloadReflinkDebug::Avoided;
+            copy_debug.reflink = OffloadReflinkDebug::No;
+            sparse_copy(source, dest)
+        }
+        (ReflinkMode::Never, _) => {
+            copy_debug.sparse_detection = SparseDebug::No;
+            copy_debug.reflink = OffloadReflinkDebug::No;
+            std::fs::copy(source, dest).map(|_| ())
+        }
+        (ReflinkMode::Auto, SparseMode::Always) => {
+            copy_debug.offload = OffloadReflinkDebug::Avoided;
+            copy_debug.sparse_detection = SparseDebug::Zeros;
+            copy_debug.reflink = OffloadReflinkDebug::Unsupported;
+            sparse_copy(source, dest)
+        }
 
         (ReflinkMode::Auto, _) => {
+            copy_debug.sparse_detection = SparseDebug::No;
+            copy_debug.reflink = OffloadReflinkDebug::Unsupported;
             if source_is_fifo {
                 copy_fifo_contents(source, dest).map(|_| ())
             } else {
                 clone(source, dest, CloneFallback::FSCopy)
             }
         }
-        (ReflinkMode::Always, SparseMode::Auto) => clone(source, dest, CloneFallback::Error),
+        (ReflinkMode::Always, SparseMode::Auto) => {
+            copy_debug.sparse_detection = SparseDebug::No;
+            copy_debug.reflink = OffloadReflinkDebug::Yes;
+
+            clone(source, dest, CloneFallback::Error)
+        }
         (ReflinkMode::Always, _) => {
             return Err("`--reflink=always` can be used only with --sparse=auto".into())
         }
     };
     result.context(context)?;
-    Ok(())
+    Ok(copy_debug)
 }
diff --git a/src/uu/cp/src/platform/macos.rs b/src/uu/cp/src/platform/macos.rs
index 4407e0edf..b173aa959 100644
--- a/src/uu/cp/src/platform/macos.rs
+++ b/src/uu/cp/src/platform/macos.rs
@@ -11,7 +11,7 @@ use std::path::Path;
 
 use quick_error::ResultExt;
 
-use crate::{CopyResult, ReflinkMode, SparseMode};
+use crate::{CopyDebug, CopyResult, OffloadReflinkDebug, ReflinkMode, SparseDebug, SparseMode};
 
 /// Copies `source` to `dest` using copy-on-write if possible.
 ///
@@ -24,10 +24,15 @@ pub(crate) fn copy_on_write(
     sparse_mode: SparseMode,
     context: &str,
     source_is_fifo: bool,
-) -> CopyResult<()> {
+) -> CopyResult<CopyDebug> {
     if sparse_mode != SparseMode::Auto {
         return Err("--sparse is only supported on linux".to_string().into());
     }
+    let mut copy_debug = CopyDebug {
+        offload: OffloadReflinkDebug::Unknown,
+        reflink: OffloadReflinkDebug::Unsupported,
+        sparse_detection: SparseDebug::Unsupported,
+    };
 
     // Extract paths in a form suitable to be passed to a syscall.
     // The unwrap() is safe because they come from the command-line and so contain non nul
@@ -72,6 +77,7 @@ pub(crate) fn copy_on_write(
                 return Err(format!("failed to clone {source:?} from {dest:?}: {error}").into())
             }
             _ => {
+                copy_debug.reflink = OffloadReflinkDebug::Yes;
                 if source_is_fifo {
                     let mut src_file = File::open(source)?;
                     let mut dst_file = File::create(dest)?;
@@ -83,5 +89,5 @@ pub(crate) fn copy_on_write(
         };
     }
 
-    Ok(())
+    Ok(copy_debug)
 }
diff --git a/src/uu/cp/src/platform/other.rs b/src/uu/cp/src/platform/other.rs
index b70da2f23..f5882f75e 100644
--- a/src/uu/cp/src/platform/other.rs
+++ b/src/uu/cp/src/platform/other.rs
@@ -8,7 +8,7 @@ use std::path::Path;
 
 use quick_error::ResultExt;
 
-use crate::{CopyResult, ReflinkMode, SparseMode};
+use crate::{CopyDebug, CopyResult, OffloadReflinkDebug, ReflinkMode, SparseDebug, SparseMode};
 
 /// Copies `source` to `dest` for systems without copy-on-write
 pub(crate) fn copy_on_write(
@@ -17,7 +17,7 @@ pub(crate) fn copy_on_write(
     reflink_mode: ReflinkMode,
     sparse_mode: SparseMode,
     context: &str,
-) -> CopyResult<()> {
+) -> CopyResult<CopyDebug> {
     if reflink_mode != ReflinkMode::Never {
         return Err("--reflink is only supported on linux and macOS"
             .to_string()
@@ -26,8 +26,12 @@ pub(crate) fn copy_on_write(
     if sparse_mode != SparseMode::Auto {
         return Err("--sparse is only supported on linux".to_string().into());
     }
-
+    let copy_debug = CopyDebug {
+        offload: OffloadReflinkDebug::Unsupported,
+        reflink: OffloadReflinkDebug::Unsupported,
+        sparse_detection: SparseDebug::Unsupported,
+    };
     fs::copy(source, dest).context(context)?;
 
-    Ok(())
+    Ok(copy_debug)
 }
diff --git a/src/uu/csplit/Cargo.toml b/src/uu/csplit/Cargo.toml
index 62b43c10e..023d97243 100644
--- a/src/uu/csplit/Cargo.toml
+++ b/src/uu/csplit/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_csplit"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "csplit ~ (uutils) Output pieces of FILE separated by PATTERN(s) to files 'xx00', 'xx01', ..., and output byte counts of each piece to standard output"
@@ -15,10 +15,10 @@ edition = "2021"
 path = "src/csplit.rs"
 
 [dependencies]
-clap = { workspace=true }
+clap = { workspace = true }
 thiserror = { workspace = true }
-regex = { workspace=true }
-uucore = { workspace=true, features=["entries", "fs"] }
+regex = { workspace = true }
+uucore = { workspace = true, features = ["entries", "fs"] }
 
 [[bin]]
 name = "csplit"
diff --git a/src/uu/csplit/csplit.md b/src/uu/csplit/csplit.md
new file mode 100644
index 000000000..1d428fc8e
--- /dev/null
+++ b/src/uu/csplit/csplit.md
@@ -0,0 +1,11 @@
+# csplit
+
+```
+csplit [OPTION]... FILE PATTERN...
+```
+
+Split a file into sections determined by context lines
+
+## After Help
+
+Output pieces of FILE separated by PATTERN(s) to files 'xx00', 'xx01', ..., and output byte counts of each piece to standard output.
diff --git a/src/uu/csplit/src/csplit.rs b/src/uu/csplit/src/csplit.rs
index 85df5eb28..1a94b4156 100644
--- a/src/uu/csplit/src/csplit.rs
+++ b/src/uu/csplit/src/csplit.rs
@@ -13,7 +13,7 @@ use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
 use regex::Regex;
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult};
-use uucore::{crash_if_err, format_usage};
+use uucore::{crash_if_err, format_usage, help_about, help_section, help_usage};
 
 mod csplit_error;
 mod patterns;
@@ -22,9 +22,9 @@ mod split_name;
 use crate::csplit_error::CsplitError;
 use crate::split_name::SplitName;
 
-static ABOUT: &str = "Split a file into sections determined by context lines";
-static LONG_HELP: &str = "Output pieces of FILE separated by PATTERN(s) to files 'xx00', 'xx01', ..., and output byte counts of each piece to standard output.";
-const USAGE: &str = "{} [OPTION]... FILE PATTERN...";
+const ABOUT: &str = help_about!("csplit.md");
+const AFTER_HELP: &str = help_section!("after help", "csplit.md");
+const USAGE: &str = help_usage!("csplit.md");
 
 mod options {
     pub const SUFFIX_FORMAT: &str = "suffix-format";
@@ -356,6 +356,7 @@ impl<'a> SplitWriter<'a> {
     /// - if no line matched, an [`CsplitError::MatchNotFound`].
     /// - if there are not enough lines to accommodate the offset, an
     /// [`CsplitError::LineOutOfRange`].
+    #[allow(clippy::cognitive_complexity)]
     fn do_to_match<I>(
         &mut self,
         pattern_as_str: &str,
@@ -814,5 +815,5 @@ pub fn uu_app() -> Command {
                 .action(clap::ArgAction::Append)
                 .required(true),
         )
-        .after_help(LONG_HELP)
+        .after_help(AFTER_HELP)
 }
diff --git a/src/uu/cut/BENCHMARKING.md b/src/uu/cut/BENCHMARKING.md
index bd94cf93c..0455b55fb 100644
--- a/src/uu/cut/BENCHMARKING.md
+++ b/src/uu/cut/BENCHMARKING.md
@@ -1,46 +1,45 @@
-## Benchmarking cut
+# Benchmarking cut
 
-### Performance profile
+## Performance profile
 
 In normal use cases a significant amount of the total execution time of `cut`
 is spent performing I/O. When invoked with the `-f` option (cut fields) some
 CPU time is spent on detecting fields (in `Searcher::next`). Other than that
 some small amount of CPU time is spent on breaking the input stream into lines.
 
-
-### How to
+## How to
 
 When fixing bugs or adding features you might want to compare
 performance before and after your code changes.
 
--   `hyperfine` can be used to accurately measure and compare the total
+- `hyperfine` can be used to accurately measure and compare the total
     execution time of one or more commands.
 
-    ```
-    $ cargo build --release --package uu_cut
+    ```shell
+    cargo build --release --package uu_cut
 
-    $ hyperfine -w3 "./target/release/cut -f2-4,8 -d' ' input.txt" "cut -f2-4,8 -d' ' input.txt"
+    hyperfine -w3 "./target/release/cut -f2-4,8 -d' ' input.txt" "cut -f2-4,8 -d' ' input.txt"
     ```
+
     You can put those two commands in a shell script to be sure that you don't
     forget to build after making any changes.
 
 When optimizing or fixing performance regressions seeing the number of times a
 function is called, and the amount of time it takes can be useful.
 
--   `cargo flamegraph` generates flame graphs from function level metrics it records using `perf` or `dtrace`
+- `cargo flamegraph` generates flame graphs from function level metrics it records using `perf` or `dtrace`
 
-    ```
-    $ cargo flamegraph --bin cut --package uu_cut -- -f1,3-4 input.txt > /dev/null
+    ```shell
+    cargo flamegraph --bin cut --package uu_cut -- -f1,3-4 input.txt > /dev/null
     ```
 
-
-### What to benchmark
+## What to benchmark
 
 There are four different performance paths in `cut` to benchmark.
 
--   Byte ranges `-c`/`--characters` or `-b`/`--bytes` e.g. `cut -c 2,4,6-`
--   Byte ranges with output delimiters e.g. `cut -c 4- --output-delimiter=/`
--   Fields e.g. `cut -f -4`
--   Fields with output delimiters e.g. `cut -f 7-10 --output-delimiter=:`
+- Byte ranges `-c`/`--characters` or `-b`/`--bytes` e.g. `cut -c 2,4,6-`
+- Byte ranges with output delimiters e.g. `cut -c 4- --output-delimiter=/`
+- Fields e.g. `cut -f -4`
+- Fields with output delimiters e.g. `cut -f 7-10 --output-delimiter=:`
 
 Choose a test input file with large number of lines so that program startup time does not significantly affect the benchmark.
diff --git a/src/uu/cut/Cargo.toml b/src/uu/cut/Cargo.toml
index 8a5e8f1d2..6e8c28d74 100644
--- a/src/uu/cut/Cargo.toml
+++ b/src/uu/cut/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_cut"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "cut ~ (uutils) display byte/field columns of input lines"
@@ -15,11 +15,11 @@ edition = "2021"
 path = "src/cut.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true }
-memchr = { workspace=true }
-bstr = { workspace=true }
-is-terminal = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true }
+memchr = { workspace = true }
+bstr = { workspace = true }
+is-terminal = { workspace = true }
 
 [[bin]]
 name = "cut"
diff --git a/src/uu/cut/cut.md b/src/uu/cut/cut.md
new file mode 100644
index 000000000..972fcb632
--- /dev/null
+++ b/src/uu/cut/cut.md
@@ -0,0 +1,112 @@
+# cut
+
+<!-- spell-checker:ignore sourcefile sourcefiles -->
+
+```
+cut [-d|-w] [-s] [-z] [--output-delimiter] ((-f|-b|-c) {{sequence}}) {{sourcefile}}+
+```
+
+Prints specified byte or field columns from each line of stdin or the input files
+
+## After Help
+
+Each call must specify a mode (what to use for columns),
+a sequence (which columns to print), and provide a data source
+
+### Specifying a mode
+
+Use `--bytes` (`-b`) or `--characters` (`-c`) to specify byte mode
+
+Use `--fields` (`-f`) to specify field mode, where each line is broken into
+fields identified by a delimiter character. For example for a typical CSV
+you could use this in combination with setting comma as the delimiter
+
+### Specifying a sequence
+
+A sequence is a group of 1 or more numbers or inclusive ranges separated
+by a commas.
+
+```
+cut -f 2,5-7 some_file.txt
+```
+
+will display the 2nd, 5th, 6th, and 7th field for each source line
+
+Ranges can extend to the end of the row by excluding the second number
+
+```
+cut -f 3- some_file.txt
+```
+
+will display the 3rd field and all fields after for each source line
+
+The first number of a range can be excluded, and this is effectively the
+same as using 1 as the first number: it causes the range to begin at the
+first column. Ranges can also display a single column
+
+```
+cut -f 1,3-5 some_file.txt
+```
+
+will display the 1st, 3rd, 4th, and 5th field for each source line
+
+The `--complement` option, when used, inverts the effect of the sequence
+
+```
+cut --complement -f 4-6 some_file.txt
+```
+
+will display the every field but the 4th, 5th, and 6th
+
+### Specifying a data source
+
+If no `sourcefile` arguments are specified, stdin is used as the source of
+lines to print
+
+If `sourcefile` arguments are specified, stdin is ignored and all files are
+read in consecutively if a `sourcefile` is not successfully read, a warning
+will print to stderr, and the eventual status code will be 1, but cut
+will continue to read through proceeding `sourcefiles`
+
+To print columns from both STDIN and a file argument, use `-` (dash) as a
+`sourcefile` argument to represent stdin.
+
+### Field Mode options
+
+The fields in each line are identified by a delimiter (separator)
+
+#### Set the delimiter
+
+Set the delimiter which separates fields in the file using the
+`--delimiter` (`-d`) option. Setting the delimiter is optional.
+If not set, a default delimiter of Tab will be used.
+
+If the `-w` option is provided, fields will be separated by any number
+of whitespace characters (Space and Tab). The output delimiter will
+be a Tab unless explicitly specified. Only one of `-d` or `-w` option can be specified.
+This is an extension adopted from FreeBSD.
+
+#### Optionally Filter based on delimiter
+
+If the `--only-delimited` (`-s`) flag is provided, only lines which
+contain the delimiter will be printed
+
+#### Replace the delimiter
+
+If the `--output-delimiter` option is provided, the argument used for
+it will replace the delimiter character in each line printed. This is
+useful for transforming tabular data - e.g. to convert a CSV to a
+TSV (tab-separated file)
+
+### Line endings
+
+When the `--zero-terminated` (`-z`) option is used, cut sees \\0 (null) as the
+'line ending' character (both for the purposes of reading lines and
+separating printed lines) instead of \\n (newline). This is useful for
+tabular data where some of the cells may contain newlines
+
+```
+echo 'ab\\0cd' | cut -z -c 1
+```
+
+will result in 'a\\0c\\0'
diff --git a/src/uu/cut/src/cut.rs b/src/uu/cut/src/cut.rs
index 105449cbc..68ad566d7 100644
--- a/src/uu/cut/src/cut.rs
+++ b/src/uu/cut/src/cut.rs
@@ -19,99 +19,14 @@ use uucore::error::{FromIo, UResult, USimpleError};
 use self::searcher::Searcher;
 use matcher::{ExactMatcher, Matcher, WhitespaceMatcher};
 use uucore::ranges::Range;
-use uucore::{format_usage, show, show_error, show_if_err};
+use uucore::{format_usage, help_about, help_section, help_usage, show, show_error, show_if_err};
 
 mod matcher;
 mod searcher;
 
-static USAGE: &str =
-    "{} [-d|-w] [-s] [-z] [--output-delimiter] ((-f|-b|-c) {{sequence}}) {{sourcefile}}+";
-static ABOUT: &str =
-    "Prints specified byte or field columns from each line of stdin or the input files";
-static LONG_HELP: &str = "
- Each call must specify a mode (what to use for columns),
- a sequence (which columns to print), and provide a data source
-
- Specifying a mode
-
-    Use --bytes (-b) or --characters (-c) to specify byte mode
-
-    Use --fields (-f) to specify field mode, where each line is broken into
-    fields identified by a delimiter character. For example for a typical CSV
-    you could use this in combination with setting comma as the delimiter
-
- Specifying a sequence
-
-    A sequence is a group of 1 or more numbers or inclusive ranges separated
-    by a commas.
-
-    cut -f 2,5-7 some_file.txt
-    will display the 2nd, 5th, 6th, and 7th field for each source line
-
-    Ranges can extend to the end of the row by excluding the the second number
-
-    cut -f 3- some_file.txt
-    will display the 3rd field and all fields after for each source line
-
-    The first number of a range can be excluded, and this is effectively the
-    same as using 1 as the first number: it causes the range to begin at the
-    first column. Ranges can also display a single column
-
-    cut -f 1,3-5 some_file.txt
-    will display the 1st, 3rd, 4th, and 5th field for each source line
-
-    The --complement option, when used, inverts the effect of the sequence
-
-    cut --complement -f 4-6 some_file.txt
-    will display the every field but the 4th, 5th, and 6th
-
- Specifying a data source
-
-    If no sourcefile arguments are specified, stdin is used as the source of
-    lines to print
-
-    If sourcefile arguments are specified, stdin is ignored and all files are
-    read in consecutively if a sourcefile is not successfully read, a warning
-    will print to stderr, and the eventual status code will be 1, but cut
-    will continue to read through proceeding sourcefiles
-
-    To print columns from both STDIN and a file argument, use - (dash) as a
-    sourcefile argument to represent stdin.
-
- Field Mode options
-
-    The fields in each line are identified by a delimiter (separator)
-
-    Set the delimiter
-        Set the delimiter which separates fields in the file using the
-        --delimiter (-d) option. Setting the delimiter is optional.
-        If not set, a default delimiter of Tab will be used.
-
-        If the -w option is provided, fields will be separated by any number
-        of whitespace characters (Space and Tab). The output delimiter will
-        be a Tab unless explicitly specified. Only one of -d or -w option can be specified.
-        This is an extension adopted from FreeBSD.
-
-    Optionally Filter based on delimiter
-        If the --only-delimited (-s) flag is provided, only lines which
-        contain the delimiter will be printed
-
-    Replace the delimiter
-        If the --output-delimiter option is provided, the argument used for
-        it will replace the delimiter character in each line printed. This is
-        useful for transforming tabular data - e.g. to convert a CSV to a
-        TSV (tab-separated file)
-
- Line endings
-
-    When the --zero-terminated (-z) option is used, cut sees \\0 (null) as the
-    'line ending' character (both for the purposes of reading lines and
-    separating printed lines) instead of \\n (newline). This is useful for
-    tabular data where some of the cells may contain newlines
-
-    echo 'ab\\0cd' | cut -z -c 1
-    will result in 'a\\0c\\0'
-";
+const USAGE: &str = help_usage!("cut.md");
+const ABOUT: &str = help_about!("cut.md");
+const AFTER_HELP: &str = help_section!("after help", "cut.md");
 
 struct Options {
     out_delim: Option<String>,
@@ -594,7 +509,7 @@ pub fn uu_app() -> Command {
         .version(crate_version!())
         .override_usage(format_usage(USAGE))
         .about(ABOUT)
-        .after_help(LONG_HELP)
+        .after_help(AFTER_HELP)
         .infer_long_args(true)
         .arg(
             Arg::new(options::BYTES)
diff --git a/src/uu/date/Cargo.toml b/src/uu/date/Cargo.toml
index cd7c50513..e28762493 100644
--- a/src/uu/date/Cargo.toml
+++ b/src/uu/date/Cargo.toml
@@ -1,6 +1,7 @@
+# spell-checker:ignore datetime
 [package]
 name = "uu_date"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "date ~ (uutils) display or set the current time"
@@ -15,15 +16,19 @@ edition = "2021"
 path = "src/date.rs"
 
 [dependencies]
-chrono = { workspace=true }
-clap = { workspace=true }
-uucore = { workspace=true }
+chrono = { workspace = true }
+clap = { workspace = true }
+uucore = { workspace = true }
+parse_datetime = { workspace = true }
 
 [target.'cfg(unix)'.dependencies]
-libc = { workspace=true }
+libc = { workspace = true }
 
 [target.'cfg(windows)'.dependencies]
-windows-sys = { workspace=true, features = ["Win32_Foundation", "Win32_System_SystemInformation"] }
+windows-sys = { workspace = true, features = [
+  "Win32_Foundation",
+  "Win32_System_SystemInformation",
+] }
 
 [[bin]]
 name = "date"
diff --git a/src/uu/date/date-usage.md b/src/uu/date/date-usage.md
new file mode 100644
index 000000000..bf2dc469d
--- /dev/null
+++ b/src/uu/date/date-usage.md
@@ -0,0 +1,87 @@
+# `date` usage
+
+<!-- spell-checker:ignore (format) hhmm -->
+
+FORMAT controls the output.  Interpreted sequences are:
+
+| Sequence | Description                                                          | Example                |
+| -------- | -------------------------------------------------------------------- | ---------------------- |
+| %%       | a literal %                                                          | %                      |
+| %a       | locale's abbreviated weekday name                                    | Sun                    |
+| %A       | locale's full weekday name                                           | Sunday                 |
+| %b       | locale's abbreviated month name                                      | Jan                    |
+| %B       | locale's full month name                                             | January                |
+| %c       | locale's date and time                                               | Thu Mar 3 23:05:25 2005|
+| %C       | century; like %Y, except omit last two digits                        | 20                     |
+| %d       | day of month                                                         | 01                     |
+| %D       | date; same as %m/%d/%y                                               | 12/31/99               |
+| %e       | day of month, space padded; same as %_d                              | 3                      |
+| %F       | full date; same as %Y-%m-%d                                          | 2005-03-03             |
+| %g       | last two digits of year of ISO week number (see %G)                  | 05                     |
+| %G       | year of ISO week number (see %V); normally useful only with %V       | 2005                   |
+| %h       | same as %b                                                           | Jan                    |
+| %H       | hour (00..23)                                                        | 23                     |
+| %I       | hour (01..12)                                                        | 11                     |
+| %j       | day of year (001..366)                                               | 062                    |
+| %k       | hour, space padded ( 0..23); same as %_H                             |  3                     |
+| %l       | hour, space padded ( 1..12); same as %_I                             |  9                     |
+| %m       | month (01..12)                                                       | 03                     |
+| %M       | minute (00..59)                                                      | 30                     |
+| %n       | a newline                                                            | \n                     |
+| %N       | nanoseconds (000000000..999999999)                                   | 123456789              |
+| %p       | locale's equivalent of either AM or PM; blank if not known           | PM                     |
+| %P       | like %p, but lower case                                              | pm                     |
+| %q       | quarter of year (1..4)                                               | 1                      |
+| %r       | locale's 12-hour clock time                                          | 11:11:04 PM            |
+| %R       | 24-hour hour and minute; same as %H:%M                               | 23:30                  |
+| %s       | seconds since 1970-01-01 00:00:00 UTC                                | 1615432800             |
+| %S       | second (00..60)                                                      | 30                     |
+| %t       | a tab                                                                | \t                     |
+| %T       | time; same as %H:%M:%S                                               | 23:30:30               |
+| %u       | day of week (1..7); 1 is Monday                                      | 4                      |
+| %U       | week number of year, with Sunday as first day of week (00..53)       | 10                     |
+| %V       | ISO week number, with Monday as first day of week (01..53)           | 12                     |
+| %w       | day of week (0..6); 0 is Sunday                                      | 4                      |
+| %W       | week number of year, with Monday as first day of week (00..53)       | 11                     |
+| %x       | locale's date representation                                         | 03/03/2005             |
+| %X       | locale's time representation                                         | 23:30:30               |
+| %y       | last two digits of year (00..99)                                     | 05                     |
+| %Y       | year                                                                 | 2005                   |
+| %z       | +hhmm numeric time zone                                              | -0400                  |
+| %:z      | +hh:mm numeric time zone                                             | -04:00                 |
+| %::z     | +hh:mm:ss numeric time zone                                          | -04:00:00              |
+| %:::z    | numeric time zone with : to necessary precision                      | -04, +05:30            |
+| %Z       | alphabetic time zone abbreviation                                    | EDT                    |
+
+By default, date pads numeric fields with zeroes.
+The following optional flags may follow '%':
+
+* `-` (hyphen) do not pad the field
+* `_` (underscore) pad with spaces
+* `0` (zero) pad with zeros
+* `^` use upper case if possible
+* `#` use opposite case if possible
+
+After any flags comes an optional field width, as a decimal number;
+then an optional modifier, which is either
+E to use the locale's alternate representations if available, or
+O to use the locale's alternate numeric symbols if available.
+
+Examples:
+Convert seconds since the epoch (1970-01-01 UTC) to a date
+
+```
+date --date='@2147483647'
+```
+
+Show the time on the west coast of the US (use tzselect(1) to find TZ)
+
+```
+TZ='America/Los_Angeles' date
+```
+
+Show the local time for 9AM next Friday on the west coast of the US
+
+```
+date --date='TZ="America/Los_Angeles" 09:00 next Fri'
+```
diff --git a/src/uu/date/date-usage.mkd b/src/uu/date/date-usage.mkd
deleted file mode 100644
index 829001095..000000000
--- a/src/uu/date/date-usage.mkd
+++ /dev/null
@@ -1,78 +0,0 @@
-# `date` usage
-
-<!-- spell-checker:ignore (format) hhmm -->
-
-``` text
-FORMAT controls the output.  Interpreted sequences are:
-
-  %%   a literal %
-  %a   locale's abbreviated weekday name (e.g., Sun)
-  %A   locale's full weekday name (e.g., Sunday)
-  %b   locale's abbreviated month name (e.g., Jan)
-  %B   locale's full month name (e.g., January)
-  %c   locale's date and time (e.g., Thu Mar  3 23:05:25 2005)
-  %C   century; like %Y, except omit last two digits (e.g., 20)
-  %d   day of month (e.g., 01)
-  %D   date; same as %m/%d/%y
-  %e   day of month, space padded; same as %_d
-  %F   full date; same as %Y-%m-%d
-  %g   last two digits of year of ISO week number (see %G)
-  %G   year of ISO week number (see %V); normally useful only with %V
-  %h   same as %b
-  %H   hour (00..23)
-  %I   hour (01..12)
-  %j   day of year (001..366)
-  %k   hour, space padded ( 0..23); same as %_H
-  %l   hour, space padded ( 1..12); same as %_I
-  %m   month (01..12)
-  %M   minute (00..59)
-  %n   a newline
-  %N   nanoseconds (000000000..999999999)
-  %p   locale's equivalent of either AM or PM; blank if not known
-  %P   like %p, but lower case
-  %q   quarter of year (1..4)
-  %r   locale's 12-hour clock time (e.g., 11:11:04 PM)
-  %R   24-hour hour and minute; same as %H:%M
-  %s   seconds since 1970-01-01 00:00:00 UTC
-  %S   second (00..60)
-  %t   a tab
-  %T   time; same as %H:%M:%S
-  %u   day of week (1..7); 1 is Monday
-  %U   week number of year, with Sunday as first day of week (00..53)
-  %V   ISO week number, with Monday as first day of week (01..53)
-  %w   day of week (0..6); 0 is Sunday
-  %W   week number of year, with Monday as first day of week (00..53)
-  %x   locale's date representation (e.g., 12/31/99)
-  %X   locale's time representation (e.g., 23:13:48)
-  %y   last two digits of year (00..99)
-  %Y   year
-  %z   +hhmm numeric time zone (e.g., -0400)
-  %:z  +hh:mm numeric time zone (e.g., -04:00)
-  %::z  +hh:mm:ss numeric time zone (e.g., -04:00:00)
-  %:::z  numeric time zone with : to necessary precision (e.g., -04, +05:30)
-  %Z   alphabetic time zone abbreviation (e.g., EDT)
-
-By default, date pads numeric fields with zeroes.
-The following optional flags may follow '%':
-
-  -  (hyphen) do not pad the field
-  _  (underscore) pad with spaces
-  0  (zero) pad with zeros
-  ^  use upper case if possible
-  #  use opposite case if possible
-
-After any flags comes an optional field width, as a decimal number;
-then an optional modifier, which is either
-E to use the locale's alternate representations if available, or
-O to use the locale's alternate numeric symbols if available.
-
-Examples:
-Convert seconds since the epoch (1970-01-01 UTC) to a date
-  $ date --date='@2147483647'
-
-Show the time on the west coast of the US (use tzselect(1) to find TZ)
-  $ TZ='America/Los_Angeles' date
-
-Show the local time for 9AM next Friday on the west coast of the US
-  $ date --date='TZ="America/Los_Angeles" 09:00 next Fri'
-```
diff --git a/src/uu/date/date.md b/src/uu/date/date.md
new file mode 100644
index 000000000..97f134016
--- /dev/null
+++ b/src/uu/date/date.md
@@ -0,0 +1,10 @@
+<!-- spell-checker:ignore Dhhmm -->
+
+# date
+
+```
+date [OPTION]... [+FORMAT]...
+date [OPTION]... [MMDDhhmm[[CC]YY][.ss]]
+```
+
+Print or set the system date and time
diff --git a/src/uu/date/src/date.rs b/src/uu/date/src/date.rs
index f433ce73d..7bd64839c 100644
--- a/src/uu/date/src/date.rs
+++ b/src/uu/date/src/date.rs
@@ -9,7 +9,7 @@
 // spell-checker:ignore (chrono) Datelike Timelike ; (format) DATEFILE MMDDhhmm ; (vars) datetime datetimes
 
 use chrono::format::{Item, StrftimeItems};
-use chrono::{DateTime, FixedOffset, Local, Offset, Utc};
+use chrono::{DateTime, Duration, FixedOffset, Local, Offset, Utc};
 #[cfg(windows)]
 use chrono::{Datelike, Timelike};
 use clap::{crate_version, Arg, ArgAction, Command};
@@ -19,10 +19,10 @@ use std::fs::File;
 use std::io::{BufRead, BufReader};
 use std::path::PathBuf;
 use uucore::display::Quotable;
-#[cfg(not(any(target_os = "macos", target_os = "redox")))]
+#[cfg(not(any(target_os = "redox")))]
 use uucore::error::FromIo;
 use uucore::error::{UResult, USimpleError};
-use uucore::{format_usage, show_error};
+use uucore::{format_usage, help_about, help_usage, show};
 #[cfg(windows)]
 use windows_sys::Win32::{Foundation::SYSTEMTIME, System::SystemInformation::SetSystemTime};
 
@@ -36,10 +36,8 @@ const MINUTE: &str = "minute";
 const SECOND: &str = "second";
 const NS: &str = "ns";
 
-const ABOUT: &str = "Print or set the system date and time";
-const USAGE: &str = "\
-    {} [OPTION]... [+FORMAT]...
-    {} [OPTION]... [MMDDhhmm[[CC]YY][.ss]]";
+const ABOUT: &str = help_about!("date.md");
+const USAGE: &str = help_usage!("date.md");
 
 const OPT_DATE: &str = "date";
 const OPT_FORMAT: &str = "format";
@@ -98,6 +96,7 @@ enum DateSource {
     Now,
     Custom(String),
     File(PathBuf),
+    Human(Duration),
 }
 
 enum Iso8601Format {
@@ -116,8 +115,8 @@ impl<'a> From<&'a str> for Iso8601Format {
             SECONDS | SECOND => Self::Seconds,
             NS => Self::Ns,
             DATE => Self::Date,
-            // Should be caught by clap
-            _ => panic!("Invalid format: {s}"),
+            // Note: This is caught by clap via `possible_values`
+            _ => unreachable!(),
         }
     }
 }
@@ -141,6 +140,7 @@ impl<'a> From<&'a str> for Rfc3339Format {
 }
 
 #[uucore::main]
+#[allow(clippy::cognitive_complexity)]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app().try_get_matches_from(args)?;
 
@@ -170,7 +170,11 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     };
 
     let date_source = if let Some(date) = matches.get_one::<String>(OPT_DATE) {
-        DateSource::Custom(date.into())
+        if let Ok(duration) = parse_datetime::from_str(date.as_str()) {
+            DateSource::Human(duration)
+        } else {
+            DateSource::Custom(date.into())
+        }
     } else if let Some(file) = matches.get_one::<String>(OPT_FILE) {
         DateSource::File(file.into())
     } else {
@@ -205,9 +209,6 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
         return set_system_datetime(date);
     } else {
-        // Declare a file here because it needs to outlive the `dates` iterator.
-        let file: File;
-
         // Get the current time, either in the local time zone or UTC.
         let now: DateTime<FixedOffset> = if settings.utc {
             let now = Utc::now();
@@ -224,10 +225,23 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
                 let iter = std::iter::once(date);
                 Box::new(iter)
             }
+            DateSource::Human(relative_time) => {
+                // Get the current DateTime<FixedOffset> for things like "1 year ago"
+                let current_time = DateTime::<FixedOffset>::from(Local::now());
+                let iter = std::iter::once(Ok(current_time + relative_time));
+                Box::new(iter)
+            }
             DateSource::File(ref path) => {
-                file = File::open(path).unwrap();
+                if path.is_dir() {
+                    return Err(USimpleError::new(
+                        2,
+                        format!("expected file, got directory {}", path.quote()),
+                    ));
+                }
+                let file = File::open(path)
+                    .map_err_context(|| path.as_os_str().to_string_lossy().to_string())?;
                 let lines = BufReader::new(file).lines();
-                let iter = lines.filter_map(Result::ok).map(parse_date);
+                let iter = lines.map_while(Result::ok).map(parse_date);
                 Box::new(iter)
             }
             DateSource::Now => {
@@ -244,6 +258,13 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
                 Ok(date) => {
                     // GNU `date` uses `%N` for nano seconds, however crate::chrono uses `%f`
                     let format_string = &format_string.replace("%N", "%f");
+                    // Refuse to pass this string to chrono as it is crashing in this crate
+                    if format_string.contains("%#z") {
+                        return Err(USimpleError::new(
+                            1,
+                            format!("invalid format {}", format_string.replace("%f", "%N")),
+                        ));
+                    }
                     // Hack to work around panic in chrono,
                     // TODO - remove when a fix for https://github.com/chronotope/chrono/issues/623 is released
                     let format_items = StrftimeItems::new(format_string);
@@ -259,7 +280,10 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
                         .replace("%f", "%N");
                     println!("{formatted}");
                 }
-                Err((input, _err)) => show_error!("invalid date {}", input.quote()),
+                Err((input, _err)) => show!(USimpleError::new(
+                    1,
+                    format!("invalid date {}", input.quote())
+                )),
             }
         }
     }
@@ -293,6 +317,9 @@ pub fn uu_app() -> Command {
                 .short('I')
                 .long(OPT_ISO_8601)
                 .value_name("FMT")
+                .value_parser([DATE, HOUR, HOURS, MINUTE, MINUTES, SECOND, SECONDS, NS])
+                .num_args(0..=1)
+                .default_missing_value(OPT_DATE)
                 .help(ISO_8601_HELP_STRING),
         )
         .arg(
@@ -306,6 +333,7 @@ pub fn uu_app() -> Command {
             Arg::new(OPT_RFC_3339)
                 .long(OPT_RFC_3339)
                 .value_name("FMT")
+                .value_parser([DATE, SECOND, SECONDS, NS])
                 .help(RFC_3339_HELP_STRING),
         )
         .arg(
@@ -405,10 +433,10 @@ fn set_system_datetime(date: DateTime<Utc>) -> UResult<()> {
 
     let result = unsafe { clock_settime(CLOCK_REALTIME, &timespec) };
 
-    if result != 0 {
-        Err(std::io::Error::last_os_error().map_err_context(|| "cannot set date".to_string()))
-    } else {
+    if result == 0 {
         Ok(())
+    } else {
+        Err(std::io::Error::last_os_error().map_err_context(|| "cannot set date".to_string()))
     }
 }
 
diff --git a/src/uu/dd/BENCHMARKING.md b/src/uu/dd/BENCHMARKING.md
index 5fbfe8ae9..4bf27b8ad 100644
--- a/src/uu/dd/BENCHMARKING.md
+++ b/src/uu/dd/BENCHMARKING.md
@@ -45,7 +45,7 @@ be roughly equivalent to the total bytes copied (`blocksize` x `count`).
 
 Some useful invocations for testing would be the following:
 
-```
+```shell
 hyperfine "./target/release/dd bs=4k count=1000000 < /dev/zero > /dev/null"
 hyperfine "./target/release/dd bs=1M count=20000 < /dev/zero > /dev/null"
 hyperfine "./target/release/dd bs=1G count=10 < /dev/zero > /dev/null"
@@ -57,7 +57,7 @@ Typically you would choose a small blocksize for measuring the performance of
 typically does some set amount of work per block which only depends on the size
 of the block if conversions are used.
 
-As an example, https://github.com/uutils/coreutils/pull/3600 made a change to
+As an example, <https://github.com/uutils/coreutils/pull/3600> made a change to
 reuse the same buffer between block copies, avoiding the need to reallocate a
 new block of memory for each copy. The impact of that change mostly had an
 impact on large block size copies because those are the circumstances where the
diff --git a/src/uu/dd/Cargo.toml b/src/uu/dd/Cargo.toml
index 1cc813bc9..0ac25657e 100644
--- a/src/uu/dd/Cargo.toml
+++ b/src/uu/dd/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_dd"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "dd ~ (uutils) copy and convert files"
@@ -15,13 +15,16 @@ edition = "2021"
 path = "src/dd.rs"
 
 [dependencies]
-clap = { workspace=true }
-gcd = { workspace=true }
-libc = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+gcd = { workspace = true }
+libc = { workspace = true }
+uucore = { workspace = true, features = ["memo"] }
+
+[target.'cfg(any(target_os = "linux"))'.dependencies]
+nix = { workspace = true, features = ["fs"] }
 
 [target.'cfg(any(target_os = "linux", target_os = "android"))'.dependencies]
-signal-hook = { workspace=true }
+signal-hook = { workspace = true }
 
 [[bin]]
 name = "dd"
diff --git a/src/uu/dd/dd.md b/src/uu/dd/dd.md
index 7f0acd718..b60fc14fa 100644
--- a/src/uu/dd/dd.md
+++ b/src/uu/dd/dd.md
@@ -1,6 +1,7 @@
-<!-- spell-checker:ignore convs iseek oseek -->
 # dd
 
+<!-- spell-checker:ignore convs iseek oseek -->
+
 ```
 dd [OPERAND]...
 dd OPTION
@@ -10,117 +11,116 @@ Copy, and optionally convert, a file system resource
 
 ## After Help
 
-OPERANDS:
+### Operands
 
-    bs=BYTES        read and write up to BYTES bytes at a time (default: 512);
-                    overwrites ibs and obs.
-    cbs=BYTES       the 'conversion block size' in bytes. Applies to
-                    the conv=block, and conv=unblock operations.
-    conv=CONVS      a comma-separated list of conversion options or
-                    (for legacy reasons) file flags.
-    count=N         stop reading input after N ibs-sized read operations rather
-                    than proceeding until EOF. See iflag=count_bytes if stopping 
-                    after N bytes is preferred
-    ibs=N           the size of buffer used for reads (default: 512)
-    if=FILE         the file used for input. When not specified, stdin is used instead
-    iflag=FLAGS     a comma-separated list of input flags which specify how the input
-                    source is treated. FLAGS may be any of the input-flags or 
-                    general-flags specified below.
-    skip=N          (or iseek=N) skip N ibs-sized records into input before beginning 
-                    copy/convert operations. See iflag=seek_bytes if seeking N bytes 
-                    is preferred.
-    obs=N           the size of buffer used for writes (default: 512)
-    of=FILE         the file used for output. When not specified, stdout is used 
-                    instead
-    oflag=FLAGS     comma separated list of output flags which specify how the output 
-                    source is treated. FLAGS may be any of the output flags or 
-                    general flags specified below
-    seek=N          (or oseek=N) seeks N obs-sized records into output before 
-                    beginning copy/convert operations. See oflag=seek_bytes if 
-                    seeking N bytes is preferred
-    status=LEVEL    controls whether volume and performance stats are written to 
-                    stderr.
-                             
-                    When unspecified, dd will print stats upon completion. An example is below.
-                        6+0 records in
-                        16+0 records out
-                        8192 bytes (8.2 kB, 8.0 KiB) copied, 0.00057009 s, 14.4 MB/s
-                    The first two lines are the 'volume' stats and the final line is 
-                    the 'performance' stats.
-                    The volume stats indicate the number of complete and partial 
-                    ibs-sized reads, or obs-sized writes that took place during the 
-                    copy. The format of the volume stats is
-                    <complete>+<partial>. If records have been truncated (see 
-                    conv=block), the volume stats will contain the number of 
-                    truncated records.
-                    
-                    Possible LEVEL values are:
-                        progress: Print periodic performance stats as the copy 
-                            proceeds.
-                        noxfer: Print final volume stats, but not performance stats.
-                        none: Do not print any stats.
+- `Bs=BYTES` : read and write up to BYTES bytes at a time (default: 512);
+   overwrites `ibs` and `obs`.
+- `cbs=BYTES` : the 'conversion block size' in bytes. Applies to the
+   `conv=block`, and `conv=unblock` operations.
+- `conv=CONVS` : a comma-separated list of conversion options or (for legacy
+   reasons) file flags.
+- `count=N` : stop reading input after N ibs-sized read operations rather
+   than proceeding until EOF. See `iflag=count_bytes` if stopping after N bytes
+   is preferred
+- `ibs=N` : the size of buffer used for reads (default: 512)
+- `if=FILE` : the file used for input. When not specified, stdin is used instead
+- `iflag=FLAGS` : a comma-separated list of input flags which specify how the
+   input source is treated. FLAGS may be any of the input-flags or general-flags
+   specified below.
+- `skip=N` (or `iseek=N`) : skip N ibs-sized records into input before beginning
+   copy/convert operations. See iflag=seek_bytes if seeking N bytes is preferred.
+- `obs=N` : the size of buffer used for writes (default: 512)
+- `of=FILE` : the file used for output. When not specified, stdout is used
+   instead
+- `oflag=FLAGS` : comma separated list of output flags which specify how the
+   output source is treated. FLAGS may be any of the output flags or general
+   flags specified below
+- `seek=N` (or `oseek=N`) : seeks N obs-sized records into output before
+   beginning copy/convert operations. See oflag=seek_bytes if seeking N bytes is
+   preferred
+- `status=LEVEL` : controls whether volume and performance stats are written to
+   stderr.
 
-                    Printing performance stats is also triggered by the INFO signal 
-                    (where supported), or the USR1 signal. Setting the 
-                    POSIXLY_CORRECT environment variable to any value (including an
-                    empty value) will cause the USR1 signal to be ignored.
+  When unspecified, dd will print stats upon completion. An example is below.
 
-CONVERSION OPTIONS:
+  ```plain
+    6+0 records in
+    16+0 records out
+    8192 bytes (8.2 kB, 8.0 KiB) copied, 0.00057009 s,
+    14.4 MB/s
+  ```
 
-    ascii       convert from EBCDIC to ASCII. This is the inverse of the 'ebcdic'
-                option. Implies conv=unblock.
-    ebcdic      convert from ASCII to EBCDIC. This is the inverse of the 'ascii'
-                option. Implies conv=block.
-    ibm         convert from ASCII to EBCDIC, applying the conventions for '[', ']' 
-                and '~' specified in POSIX. Implies conv=block.
+  The first two lines are the 'volume' stats and the final line is the
+  'performance' stats.
+  The volume stats indicate the number of complete and partial ibs-sized reads,
+  or obs-sized writes that took place during the copy. The format of the volume
+  stats is `<complete>+<partial>`. If records have been truncated (see
+  `conv=block`), the volume stats will contain the number of truncated records.
 
-    ucase       convert from lower-case to upper-case
-    lcase       converts from upper-case to lower-case.
+  Possible LEVEL values are:
+  - `progress` : Print periodic performance stats as the copy proceeds.
+  - `noxfer` : Print final volume stats, but not performance stats.
+  - `none` : Do not print any stats.
 
-    block       for each newline less than the size indicated by cbs=BYTES, remove 
-                the newline and pad with spaces up to cbs. Lines longer than cbs are 
-                truncated.
-    unblock     for each block of input of the size indicated by cbs=BYTES, remove
-                right-trailing spaces and replace with a newline character.
+  Printing performance stats is also triggered by the INFO signal (where supported),
+  or the USR1 signal. Setting the POSIXLY_CORRECT environment variable to any value
+  (including an empty value) will cause the USR1 signal to be ignored.
 
-    sparse      attempts to seek the output when an obs-sized block consists of only
-                zeros.
-    swab        swaps each adjacent pair of bytes. If an odd number of bytes is
-                present, the final byte is omitted.
-    sync        pad each ibs-sided block with zeros. If 'block' or 'unblock' is
-                specified, pad with spaces instead.
-    excl        the output file must be created. Fail if the output file is already
-                present.
-    nocreat     the output file will not be created. Fail if the output file in not
-                already present.
-    notrunc     the output file will not be truncated. If this option is not
-                present, output will be truncated when opened.
-    noerror     all read errors will be ignored. If this option is not present, dd
-                will only ignore Error::Interrupted.
-    fdatasync   data will be written before finishing.
-    fsync       data and metadata will be written before finishing.
+### Conversion Options
 
-INPUT FLAGS:
+- `ascii` : convert from EBCDIC to ASCII. This is the inverse of the `ebcdic`
+  option. Implies `conv=unblock`.
+- `ebcdic` : convert from ASCII to EBCDIC. This is the inverse of the `ascii`
+  option. Implies `conv=block`.
+- `ibm` : convert from ASCII to EBCDIC, applying the conventions for `[`, `]`
+  and `~` specified in POSIX. Implies `conv=block`.
 
-    count_bytes     a value to count=N will be interpreted as bytes.
-    skip_bytes      a value to skip=N will be interpreted as bytes.
-    fullblock       wait for ibs bytes from each read. zero-length reads are still
-                    considered EOF.
+- `ucase` : convert from lower-case to upper-case.
+- `lcase` : converts from upper-case to lower-case.
 
-OUTPUT FLAGS:
+- `block` : for each newline less than the size indicated by cbs=BYTES, remove
+  the newline and pad with spaces up to cbs. Lines longer than cbs are truncated.
+- `unblock` : for each block of input of the size indicated by cbs=BYTES, remove
+  right-trailing spaces and replace with a newline character.
 
-    append      open file in append mode. Consider setting conv=notrunc as well.
-    seek_bytes  a value to seek=N will be interpreted as bytes.
+- `sparse` : attempts to seek the output when an obs-sized block consists of
+  only zeros.
+- `swab` : swaps each adjacent pair of bytes. If an odd number of bytes is
+  present, the final byte is omitted.
+- `sync` : pad each ibs-sided block with zeros. If `block` or `unblock` is
+  specified, pad with spaces instead.
+- `excl` : the output file must be created. Fail if the output file is already
+  present.
+- `nocreat` : the output file will not be created. Fail if the output file in
+  not already present.
+- `notrunc` : the output file will not be truncated. If this option is not
+  present, output will be truncated when opened.
+- `noerror` : all read errors will be ignored. If this option is not present,
+  dd will only ignore Error::Interrupted.
+- `fdatasync` : data will be written before finishing.
+- `fsync` : data and metadata will be written before finishing.
 
-GENERAL FLAGS:
+### Input flags
 
-    direct      use direct I/O for data.
-    directory   fail unless the given input (if used as an iflag) or output (if used 
-                as an oflag) is a directory.
-    dsync       use synchronized I/O for data.
-    sync        use synchronized I/O for data and metadata.
-    nonblock    use non-blocking I/O.
-    noatime     do not update access time.
-    nocache     request that OS drop cache.
-    noctty      do not assign a controlling tty.
-    nofollow    do not follow system links.
+- `count_bytes` : a value to `count=N` will be interpreted as bytes.
+- `skip_bytes` : a value to `skip=N` will be interpreted as bytes.
+- `fullblock` : wait for ibs bytes from each read. zero-length reads are still
+  considered EOF.
+
+### Output flags
+
+- `append` : open file in append mode. Consider setting conv=notrunc as well.
+- `seek_bytes` : a value to seek=N will be interpreted as bytes.
+
+### General Flags
+
+- `Direct` : use direct I/O for data.
+- `directory` : fail unless the given input (if used as an iflag) or
+  output (if used as an oflag) is a directory.
+- `dsync` : use synchronized I/O for data.
+- `sync` : use synchronized I/O for data and metadata.
+- `nonblock` : use non-blocking I/O.
+- `noatime` : do not update access time.
+- `nocache` : request that OS drop cache.
+- `noctty` : do not assign a controlling tty.
+- `nofollow` : do not follow system links.
diff --git a/src/uu/dd/src/dd.rs b/src/uu/dd/src/dd.rs
index 41b7eb773..4e1287939 100644
--- a/src/uu/dd/src/dd.rs
+++ b/src/uu/dd/src/dd.rs
@@ -5,7 +5,7 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore fname, tname, fpath, specfile, testfile, unspec, ifile, ofile, outfile, fullblock, urand, fileio, atoe, atoibm, behaviour, bmax, bremain, cflags, creat, ctable, ctty, datastructures, doesnt, etoa, fileout, fname, gnudd, iconvflags, iseek, nocache, noctty, noerror, nofollow, nolinks, nonblock, oconvflags, oseek, outfile, parseargs, rlen, rmax, rremain, rsofar, rstat, sigusr, wlen, wstat seekable oconv canonicalized
+// spell-checker:ignore fname, tname, fpath, specfile, testfile, unspec, ifile, ofile, outfile, fullblock, urand, fileio, atoe, atoibm, behaviour, bmax, bremain, cflags, creat, ctable, ctty, datastructures, doesnt, etoa, fileout, fname, gnudd, iconvflags, iseek, nocache, noctty, noerror, nofollow, nolinks, nonblock, oconvflags, oseek, outfile, parseargs, rlen, rmax, rremain, rsofar, rstat, sigusr, wlen, wstat seekable oconv canonicalized fadvise Fadvise FADV DONTNEED ESPIPE
 
 mod datastructures;
 use datastructures::*;
@@ -27,11 +27,14 @@ use std::cmp;
 use std::env;
 use std::ffi::OsString;
 use std::fs::{File, OpenOptions};
-use std::io::{self, Read, Seek, SeekFrom, Stdin, Stdout, Write};
-#[cfg(unix)]
-use std::os::unix::fs::FileTypeExt;
+use std::io::{self, Read, Seek, SeekFrom, Stdout, Write};
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use std::os::unix::fs::OpenOptionsExt;
+#[cfg(unix)]
+use std::os::unix::{
+    fs::FileTypeExt,
+    io::{AsRawFd, FromRawFd},
+};
 use std::path::Path;
 use std::sync::{
     atomic::{AtomicBool, Ordering::Relaxed},
@@ -42,9 +45,16 @@ use std::time::{Duration, Instant};
 
 use clap::{crate_version, Arg, Command};
 use gcd::Gcd;
+#[cfg(target_os = "linux")]
+use nix::{
+    errno::Errno,
+    fcntl::{posix_fadvise, PosixFadviseAdvice},
+};
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult};
 use uucore::{format_usage, help_about, help_section, help_usage, show_error};
+#[cfg(target_os = "linux")]
+use uucore::{show, show_if_err};
 
 const ABOUT: &str = help_about!("dd.md");
 const AFTER_HELP: &str = help_section!("after help", "dd.md");
@@ -135,21 +145,54 @@ impl Num {
 }
 
 /// Data sources.
+///
+/// Use [`Source::stdin_as_file`] if available to enable more
+/// fine-grained access to reading from stdin.
 enum Source {
     /// Input from stdin.
-    Stdin(Stdin),
+    #[cfg(not(unix))]
+    Stdin(io::Stdin),
 
     /// Input from a file.
     File(File),
 
+    /// Input from stdin, opened from its file descriptor.
+    #[cfg(unix)]
+    StdinFile(File),
+
     /// Input from a named pipe, also known as a FIFO.
     #[cfg(unix)]
     Fifo(File),
 }
 
 impl Source {
+    /// Create a source from stdin using its raw file descriptor.
+    ///
+    /// This returns an instance of the `Source::StdinFile` variant,
+    /// using the raw file descriptor of [`std::io::Stdin`] to create
+    /// the [`std::fs::File`] parameter. You can use this instead of
+    /// `Source::Stdin` to allow reading from stdin without consuming
+    /// the entire contents of stdin when this process terminates.
+    #[cfg(unix)]
+    fn stdin_as_file() -> Self {
+        let fd = io::stdin().as_raw_fd();
+        let f = unsafe { File::from_raw_fd(fd) };
+        Self::StdinFile(f)
+    }
+
+    /// The length of the data source in number of bytes.
+    ///
+    /// If it cannot be determined, then this function returns 0.
+    fn len(&self) -> std::io::Result<i64> {
+        match self {
+            Self::File(f) => Ok(f.metadata()?.len().try_into().unwrap_or(i64::MAX)),
+            _ => Ok(0),
+        }
+    }
+
     fn skip(&mut self, n: u64) -> io::Result<u64> {
         match self {
+            #[cfg(not(unix))]
             Self::Stdin(stdin) => match io::copy(&mut stdin.take(n), &mut io::sink()) {
                 Ok(m) if m < n => {
                     show_error!("'standard input': cannot skip to specified offset");
@@ -158,19 +201,48 @@ impl Source {
                 Ok(m) => Ok(m),
                 Err(e) => Err(e),
             },
+            #[cfg(unix)]
+            Self::StdinFile(f) => match io::copy(&mut f.take(n), &mut io::sink()) {
+                Ok(m) if m < n => {
+                    show_error!("'standard input': cannot skip to specified offset");
+                    Ok(m)
+                }
+                Ok(m) => Ok(m),
+                Err(e) => Err(e),
+            },
             Self::File(f) => f.seek(io::SeekFrom::Start(n)),
             #[cfg(unix)]
             Self::Fifo(f) => io::copy(&mut f.take(n), &mut io::sink()),
         }
     }
+
+    /// Discard the system file cache for the given portion of the data source.
+    ///
+    /// `offset` and `len` specify a contiguous portion of the data
+    /// source. This function informs the kernel that the specified
+    /// portion of the source is no longer needed. If not possible,
+    /// then this function returns an error.
+    #[cfg(target_os = "linux")]
+    fn discard_cache(&self, offset: libc::off_t, len: libc::off_t) -> nix::Result<()> {
+        match self {
+            Self::File(f) => {
+                let advice = PosixFadviseAdvice::POSIX_FADV_DONTNEED;
+                posix_fadvise(f.as_raw_fd(), offset, len, advice)
+            }
+            _ => Err(Errno::ESPIPE), // "Illegal seek"
+        }
+    }
 }
 
 impl Read for Source {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         match self {
+            #[cfg(not(unix))]
             Self::Stdin(stdin) => stdin.read(buf),
             Self::File(f) => f.read(buf),
             #[cfg(unix)]
+            Self::StdinFile(f) => f.read(buf),
+            #[cfg(unix)]
             Self::Fifo(f) => f.read(buf),
         }
     }
@@ -193,7 +265,10 @@ struct Input<'a> {
 impl<'a> Input<'a> {
     /// Instantiate this struct with stdin as a source.
     fn new_stdin(settings: &'a Settings) -> UResult<Self> {
+        #[cfg(not(unix))]
         let mut src = Source::Stdin(io::stdin());
+        #[cfg(unix)]
+        let mut src = Source::stdin_as_file();
         if settings.skip > 0 {
             src.skip(settings.skip)?;
         }
@@ -266,10 +341,10 @@ fn make_linux_iflags(iflags: &IFlags) -> Option<libc::c_int> {
         flag |= libc::O_SYNC;
     }
 
-    if flag != 0 {
-        Some(flag)
-    } else {
+    if flag == 0 {
         None
+    } else {
+        Some(flag)
     }
 }
 
@@ -297,6 +372,29 @@ impl<'a> Read for Input<'a> {
 }
 
 impl<'a> Input<'a> {
+    /// Discard the system file cache for the given portion of the input.
+    ///
+    /// `offset` and `len` specify a contiguous portion of the input.
+    /// This function informs the kernel that the specified portion of
+    /// the input file is no longer needed. If not possible, then this
+    /// function prints an error message to stderr and sets the exit
+    /// status code to 1.
+    #[allow(unused_variables)]
+    fn discard_cache(&self, offset: libc::off_t, len: libc::off_t) {
+        #[cfg(target_os = "linux")]
+        {
+            show_if_err!(self
+                .src
+                .discard_cache(offset, len)
+                .map_err_context(|| "failed to discard cache for: 'standard input'".to_string()));
+        }
+        #[cfg(not(target_os = "linux"))]
+        {
+            // TODO Is there a way to discard filesystem cache on
+            // these other operating systems?
+        }
+    }
+
     /// Fills a given buffer.
     /// Reads in increments of 'self.ibs'.
     /// The start of each ibs-sized read follows the previous one.
@@ -318,13 +416,13 @@ impl<'a> Input<'a> {
                 _ => break,
             }
         }
-
         buf.truncate(bytes_total);
         Ok(ReadStat {
             reads_complete,
             reads_partial,
             // Records are not truncated when filling.
             records_truncated: 0,
+            bytes_total: bytes_total.try_into().unwrap(),
         })
     }
 
@@ -335,6 +433,7 @@ impl<'a> Input<'a> {
         let mut reads_complete = 0;
         let mut reads_partial = 0;
         let mut base_idx = 0;
+        let mut bytes_total = 0;
 
         while base_idx < buf.len() {
             let next_blk = cmp::min(base_idx + self.settings.ibs, buf.len());
@@ -343,11 +442,13 @@ impl<'a> Input<'a> {
             match self.read(&mut buf[base_idx..next_blk])? {
                 0 => break,
                 rlen if rlen < target_len => {
+                    bytes_total += rlen;
                     reads_partial += 1;
                     let padding = vec![pad; target_len - rlen];
                     buf.splice(base_idx + rlen..next_blk, padding.into_iter());
                 }
-                _ => {
+                rlen => {
+                    bytes_total += rlen;
                     reads_complete += 1;
                 }
             }
@@ -360,6 +461,7 @@ impl<'a> Input<'a> {
             reads_complete,
             reads_partial,
             records_truncated: 0,
+            bytes_total: bytes_total.try_into().unwrap(),
         })
     }
 }
@@ -448,6 +550,33 @@ impl Dest {
             _ => Ok(()),
         }
     }
+
+    /// Discard the system file cache for the given portion of the destination.
+    ///
+    /// `offset` and `len` specify a contiguous portion of the
+    /// destination. This function informs the kernel that the
+    /// specified portion of the destination is no longer needed. If
+    /// not possible, then this function returns an error.
+    #[cfg(target_os = "linux")]
+    fn discard_cache(&self, offset: libc::off_t, len: libc::off_t) -> nix::Result<()> {
+        match self {
+            Self::File(f, _) => {
+                let advice = PosixFadviseAdvice::POSIX_FADV_DONTNEED;
+                posix_fadvise(f.as_raw_fd(), offset, len, advice)
+            }
+            _ => Err(Errno::ESPIPE), // "Illegal seek"
+        }
+    }
+
+    /// The length of the data destination in number of bytes.
+    ///
+    /// If it cannot be determined, then this function returns 0.
+    fn len(&self) -> std::io::Result<i64> {
+        match self {
+            Self::File(f, _) => Ok(f.metadata()?.len().try_into().unwrap_or(i64::MAX)),
+            _ => Ok(0),
+        }
+    }
 }
 
 /// Decide whether the given buffer is all zeros.
@@ -581,6 +710,29 @@ impl<'a> Output<'a> {
         Ok(Self { dst, settings })
     }
 
+    /// Discard the system file cache for the given portion of the output.
+    ///
+    /// `offset` and `len` specify a contiguous portion of the output.
+    /// This function informs the kernel that the specified portion of
+    /// the output file is no longer needed. If not possible, then
+    /// this function prints an error message to stderr and sets the
+    /// exit status code to 1.
+    #[allow(unused_variables)]
+    fn discard_cache(&self, offset: libc::off_t, len: libc::off_t) {
+        #[cfg(target_os = "linux")]
+        {
+            show_if_err!(self
+                .dst
+                .discard_cache(offset, len)
+                .map_err_context(|| "failed to discard cache for: 'standard output'".to_string()));
+        }
+        #[cfg(target_os = "linux")]
+        {
+            // TODO Is there a way to discard filesystem cache on
+            // these other operating systems?
+        }
+    }
+
     /// Write the given bytes one block at a time.
     ///
     /// This may write partial blocks (for example, if the underlying
@@ -674,6 +826,27 @@ fn dd_copy(mut i: Input, mut o: Output) -> std::io::Result<()> {
     // Optimization: if no blocks are to be written, then don't
     // bother allocating any buffers.
     if let Some(Num::Blocks(0) | Num::Bytes(0)) = i.settings.count {
+        // Even though we are not reading anything from the input
+        // file, we still need to honor the `nocache` flag, which
+        // requests that we inform the system that we no longer
+        // need the contents of the input file in a system cache.
+        //
+        // TODO Better error handling for overflowing `len`.
+        if i.settings.iflags.nocache {
+            let offset = 0;
+            #[allow(clippy::useless_conversion)]
+            let len = i.src.len()?.try_into().unwrap();
+            i.discard_cache(offset, len);
+        }
+        // Similarly, discard the system cache for the output file.
+        //
+        // TODO Better error handling for overflowing `len`.
+        if i.settings.oflags.nocache {
+            let offset = 0;
+            #[allow(clippy::useless_conversion)]
+            let len = o.dst.len()?.try_into().unwrap();
+            o.discard_cache(offset, len);
+        }
         return finalize(&mut o, rstat, wstat, start, &prog_tx, output_thread);
     };
 
@@ -687,6 +860,13 @@ fn dd_copy(mut i: Input, mut o: Output) -> std::io::Result<()> {
     // This avoids the need to query the OS monotonic clock for every block.
     let alarm = Alarm::with_interval(Duration::from_secs(1));
 
+    // Index in the input file where we are reading bytes and in
+    // the output file where we are writing bytes.
+    //
+    // These are updated on each iteration of the main loop.
+    let mut read_offset = 0;
+    let mut write_offset = 0;
+
     // The main read/write loop.
     //
     // Each iteration reads blocks from the input and writes
@@ -706,6 +886,30 @@ fn dd_copy(mut i: Input, mut o: Output) -> std::io::Result<()> {
         }
         let wstat_update = o.write_blocks(&buf)?;
 
+        // Discard the system file cache for the read portion of
+        // the input file.
+        //
+        // TODO Better error handling for overflowing `offset` and `len`.
+        let read_len = rstat_update.bytes_total;
+        if i.settings.iflags.nocache {
+            let offset = read_offset.try_into().unwrap();
+            let len = read_len.try_into().unwrap();
+            i.discard_cache(offset, len);
+        }
+        read_offset += read_len;
+
+        // Discard the system file cache for the written portion
+        // of the output file.
+        //
+        // TODO Better error handling for overflowing `offset` and `len`.
+        let write_len = wstat_update.bytes_total;
+        if o.settings.oflags.nocache {
+            let offset = write_offset.try_into().unwrap();
+            let len = write_len.try_into().unwrap();
+            o.discard_cache(offset, len);
+        }
+        write_offset += write_len;
+
         // Update the read/write stats and inform the progress thread once per second.
         //
         // If the receiver is disconnected, `send()` returns an
@@ -757,6 +961,7 @@ fn finalize<T>(
 }
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(clippy::cognitive_complexity)]
 fn make_linux_oflags(oflags: &OFlags) -> Option<libc::c_int> {
     let mut flag = 0;
 
@@ -789,10 +994,10 @@ fn make_linux_oflags(oflags: &OFlags) -> Option<libc::c_int> {
         flag |= libc::O_SYNC;
     }
 
-    if flag != 0 {
-        Some(flag)
-    } else {
+    if flag == 0 {
         None
+    } else {
+        Some(flag)
     }
 }
 
diff --git a/src/uu/dd/src/parseargs.rs b/src/uu/dd/src/parseargs.rs
index 96f6ebfaa..20a8da1ee 100644
--- a/src/uu/dd/src/parseargs.rs
+++ b/src/uu/dd/src/parseargs.rs
@@ -293,8 +293,9 @@ impl Parser {
         }
     }
 
+    #[allow(clippy::cognitive_complexity)]
     fn parse_input_flags(&mut self, val: &str) -> Result<(), ParseError> {
-        let mut i = &mut self.iflag;
+        let i = &mut self.iflag;
         for f in val.split(',') {
             match f {
                 // Common flags
@@ -303,7 +304,7 @@ impl Parser {
                 "directory" => linux_only!(f, i.directory = true),
                 "dsync" => linux_only!(f, i.dsync = true),
                 "sync" => linux_only!(f, i.sync = true),
-                "nocache" => return Err(ParseError::Unimplemented(f.to_string())),
+                "nocache" => linux_only!(f, i.nocache = true),
                 "nonblock" => linux_only!(f, i.nonblock = true),
                 "noatime" => linux_only!(f, i.noatime = true),
                 "noctty" => linux_only!(f, i.noctty = true),
@@ -324,8 +325,9 @@ impl Parser {
         Ok(())
     }
 
+    #[allow(clippy::cognitive_complexity)]
     fn parse_output_flags(&mut self, val: &str) -> Result<(), ParseError> {
-        let mut o = &mut self.oflag;
+        let o = &mut self.oflag;
         for f in val.split(',') {
             match f {
                 // Common flags
@@ -334,7 +336,7 @@ impl Parser {
                 "directory" => linux_only!(f, o.directory = true),
                 "dsync" => linux_only!(f, o.dsync = true),
                 "sync" => linux_only!(f, o.sync = true),
-                "nocache" => return Err(ParseError::Unimplemented(f.to_string())),
+                "nocache" => linux_only!(f, o.nocache = true),
                 "nonblock" => linux_only!(f, o.nonblock = true),
                 "noatime" => linux_only!(f, o.noatime = true),
                 "noctty" => linux_only!(f, o.noctty = true),
@@ -355,7 +357,7 @@ impl Parser {
     }
 
     fn parse_conv_flags(&mut self, val: &str) -> Result<(), ParseError> {
-        let mut c = &mut self.conv;
+        let c = &mut self.conv;
         for f in val.split(',') {
             match f {
                 // Conversion
diff --git a/src/uu/dd/src/parseargs/unit_tests.rs b/src/uu/dd/src/parseargs/unit_tests.rs
index a135c3572..54e17b882 100644
--- a/src/uu/dd/src/parseargs/unit_tests.rs
+++ b/src/uu/dd/src/parseargs/unit_tests.rs
@@ -55,7 +55,7 @@ fn unimplemented_flags_should_error() {
     let mut succeeded = Vec::new();
 
     // The following flags are not implemented
-    for flag in ["cio", "nocache", "nolinks", "text", "binary"] {
+    for flag in ["cio", "nolinks", "text", "binary"] {
         let args = vec![format!("iflag={flag}")];
 
         if Parser::new()
diff --git a/src/uu/dd/src/progress.rs b/src/uu/dd/src/progress.rs
index 6afd841d2..65af053b8 100644
--- a/src/uu/dd/src/progress.rs
+++ b/src/uu/dd/src/progress.rs
@@ -13,6 +13,9 @@ use std::io::Write;
 use std::sync::mpsc;
 use std::time::Duration;
 
+use uucore::error::UResult;
+use uucore::memo::sprintf;
+
 use crate::numbers::{to_magnitude_and_suffix, SuffixType};
 
 // On Linux, we register a signal handler that prints progress updates.
@@ -76,9 +79,9 @@ impl ProgUpdate {
     /// ```rust,ignore
     /// use std::io::Cursor;
     /// use std::time::Duration;
-    /// use crate::progress::{ProgUpdate, ReadState, WriteStat};
+    /// use crate::progress::{ProgUpdate, ReadStat, WriteStat};
     ///
-    /// let read_stat = ReadStat::new(1, 2, 3);
+    /// let read_stat = ReadStat::new(1, 2, 3, 999);
     /// let write_stat = WriteStat::new(4, 5, 6);
     /// let duration = Duration::new(789, 0);
     /// let prog_update = ProgUpdate {
@@ -118,7 +121,7 @@ impl ProgUpdate {
     /// ```rust,ignore
     /// use std::io::Cursor;
     /// use std::time::Duration;
-    /// use crate::progress::{ProgUpdate, ReadState, WriteStat};
+    /// use crate::progress::ProgUpdate;
     ///
     /// let prog_update = ProgUpdate {
     ///     read_stat: Default::default(),
@@ -131,7 +134,7 @@ impl ProgUpdate {
     /// prog_update.write_prog_line(&mut cursor, rewrite).unwrap();
     /// assert_eq!(cursor.get_ref(), b"0 bytes copied, 1.0 s, 0.0 B/s\n");
     /// ```
-    fn write_prog_line(&self, w: &mut impl Write, rewrite: bool) -> std::io::Result<()> {
+    fn write_prog_line(&self, w: &mut impl Write, rewrite: bool) -> UResult<()> {
         // The total number of bytes written as a string, in SI and IEC format.
         let btotal = self.write_stat.bytes_total;
         let btotal_metric = to_magnitude_and_suffix(btotal, SuffixType::Si);
@@ -148,27 +151,31 @@ impl ProgUpdate {
         // (`\n`) at the end.
         let (carriage_return, newline) = if rewrite { ("\r", "") } else { ("", "\n") };
 
+        // The duration should be formatted as in `printf %g`.
+        let duration_str = sprintf("%g", &[duration.to_string()])?;
+
         // If the number of bytes written is sufficiently large, then
         // print a more concise representation of the number, like
         // "1.2 kB" and "1.0 KiB".
         match btotal {
             1 => write!(
                 w,
-                "{carriage_return}{btotal} byte copied, {duration:.1} s, {transfer_rate}/s{newline}",
-            ),
+                "{carriage_return}{btotal} byte copied, {duration_str} s, {transfer_rate}/s{newline}",
+            )?,
             0..=999 => write!(
                 w,
-                "{carriage_return}{btotal} bytes copied, {duration:.1} s, {transfer_rate}/s{newline}",
-            ),
+                "{carriage_return}{btotal} bytes copied, {duration_str} s, {transfer_rate}/s{newline}",
+            )?,
             1000..=1023 => write!(
                 w,
-                "{carriage_return}{btotal} bytes ({btotal_metric}) copied, {duration:.1} s, {transfer_rate}/s{newline}",
-            ),
+                "{carriage_return}{btotal} bytes ({btotal_metric}) copied, {duration_str} s, {transfer_rate}/s{newline}",
+            )?,
             _ => write!(
                 w,
-                "{carriage_return}{btotal} bytes ({btotal_metric}, {btotal_bin}) copied, {duration:.1} s, {transfer_rate}/s{newline}",
-            ),
-        }
+                "{carriage_return}{btotal} bytes ({btotal_metric}, {btotal_bin}) copied, {duration_str} s, {transfer_rate}/s{newline}",
+            )?,
+        };
+        Ok(())
     }
 
     /// Write all summary statistics.
@@ -184,7 +191,7 @@ impl ProgUpdate {
     /// ```rust,ignore
     /// use std::io::Cursor;
     /// use std::time::Duration;
-    /// use crate::progress::{ProgUpdate, ReadState, WriteStat};
+    /// use crate::progress::ProgUpdate;
     ///
     /// let prog_update = ProgUpdate {
     ///     read_stat: Default::default(),
@@ -200,7 +207,7 @@ impl ProgUpdate {
     /// assert_eq!(iter.next().unwrap(), b"");
     /// assert!(iter.next().is_none());
     /// ```
-    fn write_transfer_stats(&self, w: &mut impl Write, new_line: bool) -> std::io::Result<()> {
+    fn write_transfer_stats(&self, w: &mut impl Write, new_line: bool) -> UResult<()> {
         if new_line {
             writeln!(w)?;
         }
@@ -269,16 +276,20 @@ pub(crate) struct ReadStat {
     ///
     /// A truncated record can only occur in `conv=block` mode.
     pub(crate) records_truncated: u32,
+
+    /// The total number of bytes read.
+    pub(crate) bytes_total: u64,
 }
 
 impl ReadStat {
     /// Create a new instance.
     #[allow(dead_code)]
-    fn new(complete: u64, partial: u64, truncated: u32) -> Self {
+    fn new(complete: u64, partial: u64, truncated: u32, bytes_total: u64) -> Self {
         Self {
             reads_complete: complete,
             reads_partial: partial,
             records_truncated: truncated,
+            bytes_total,
         }
     }
 
@@ -308,6 +319,7 @@ impl std::ops::AddAssign for ReadStat {
             reads_complete: self.reads_complete + other.reads_complete,
             reads_partial: self.reads_partial + other.reads_partial,
             records_truncated: self.records_truncated + other.records_truncated,
+            bytes_total: self.bytes_total + other.bytes_total,
         }
     }
 }
@@ -496,9 +508,18 @@ mod tests {
         }
     }
 
+    fn prog_update_duration(duration: Duration) -> ProgUpdate {
+        ProgUpdate {
+            read_stat: Default::default(),
+            write_stat: Default::default(),
+            duration,
+            complete: false,
+        }
+    }
+
     #[test]
     fn test_read_stat_report() {
-        let read_stat = ReadStat::new(1, 2, 3);
+        let read_stat = ReadStat::new(1, 2, 3, 4);
         let mut cursor = Cursor::new(vec![]);
         read_stat.report(&mut cursor).unwrap();
         assert_eq!(cursor.get_ref(), b"1+2 records in\n");
@@ -514,7 +535,7 @@ mod tests {
 
     #[test]
     fn test_prog_update_write_io_lines() {
-        let read_stat = ReadStat::new(1, 2, 3);
+        let read_stat = ReadStat::new(1, 2, 3, 4);
         let write_stat = WriteStat::new(4, 5, 6);
         let duration = Duration::new(789, 0);
         let complete = false;
@@ -552,24 +573,24 @@ mod tests {
         //     0 bytes copied, 7.9151e-05 s, 0.0 kB/s
         //
         // The throughput still does not match GNU dd.
-        assert_eq!(cursor.get_ref(), b"0 bytes copied, 1.0 s, 0.0 B/s\n");
+        assert_eq!(cursor.get_ref(), b"0 bytes copied, 1 s, 0.0 B/s\n");
 
         let prog_update = prog_update_write(1);
         let mut cursor = Cursor::new(vec![]);
         prog_update.write_prog_line(&mut cursor, rewrite).unwrap();
-        assert_eq!(cursor.get_ref(), b"1 byte copied, 1.0 s, 0.0 B/s\n");
+        assert_eq!(cursor.get_ref(), b"1 byte copied, 1 s, 0.0 B/s\n");
 
         let prog_update = prog_update_write(999);
         let mut cursor = Cursor::new(vec![]);
         prog_update.write_prog_line(&mut cursor, rewrite).unwrap();
-        assert_eq!(cursor.get_ref(), b"999 bytes copied, 1.0 s, 0.0 B/s\n");
+        assert_eq!(cursor.get_ref(), b"999 bytes copied, 1 s, 0.0 B/s\n");
 
         let prog_update = prog_update_write(1000);
         let mut cursor = Cursor::new(vec![]);
         prog_update.write_prog_line(&mut cursor, rewrite).unwrap();
         assert_eq!(
             cursor.get_ref(),
-            b"1000 bytes (1.0 kB) copied, 1.0 s, 1.0 kB/s\n"
+            b"1000 bytes (1.0 kB) copied, 1 s, 1.0 kB/s\n"
         );
 
         let prog_update = prog_update_write(1023);
@@ -577,7 +598,7 @@ mod tests {
         prog_update.write_prog_line(&mut cursor, rewrite).unwrap();
         assert_eq!(
             cursor.get_ref(),
-            b"1023 bytes (1.0 kB) copied, 1.0 s, 1.0 kB/s\n"
+            b"1023 bytes (1.0 kB) copied, 1 s, 1.0 kB/s\n"
         );
 
         let prog_update = prog_update_write(1024);
@@ -585,7 +606,7 @@ mod tests {
         prog_update.write_prog_line(&mut cursor, rewrite).unwrap();
         assert_eq!(
             cursor.get_ref(),
-            b"1024 bytes (1.0 kB, 1.0 KiB) copied, 1.0 s, 1.0 kB/s\n"
+            b"1024 bytes (1.0 kB, 1.0 KiB) copied, 1 s, 1.0 kB/s\n"
         );
     }
 
@@ -604,7 +625,7 @@ mod tests {
         let mut iter = cursor.get_ref().split(|v| *v == b'\n');
         assert_eq!(iter.next().unwrap(), b"0+0 records in");
         assert_eq!(iter.next().unwrap(), b"0+0 records out");
-        assert_eq!(iter.next().unwrap(), b"0 bytes copied, 1.0 s, 0.0 B/s");
+        assert_eq!(iter.next().unwrap(), b"0 bytes copied, 1 s, 0.0 B/s");
         assert_eq!(iter.next().unwrap(), b"");
         assert!(iter.next().is_none());
     }
@@ -623,11 +644,20 @@ mod tests {
         prog_update.write_prog_line(&mut cursor, rewrite).unwrap();
         prog_update.write_transfer_stats(&mut cursor, true).unwrap();
         let mut iter = cursor.get_ref().split(|v| *v == b'\n');
-        assert_eq!(iter.next().unwrap(), b"\r0 bytes copied, 1.0 s, 0.0 B/s");
+        assert_eq!(iter.next().unwrap(), b"\r0 bytes copied, 1 s, 0.0 B/s");
         assert_eq!(iter.next().unwrap(), b"0+0 records in");
         assert_eq!(iter.next().unwrap(), b"0+0 records out");
-        assert_eq!(iter.next().unwrap(), b"0 bytes copied, 1.0 s, 0.0 B/s");
+        assert_eq!(iter.next().unwrap(), b"0 bytes copied, 1 s, 0.0 B/s");
         assert_eq!(iter.next().unwrap(), b"");
         assert!(iter.next().is_none());
     }
+
+    #[test]
+    fn test_duration_precision() {
+        let prog_update = prog_update_duration(Duration::from_nanos(123));
+        let mut cursor = Cursor::new(vec![]);
+        let rewrite = false;
+        prog_update.write_prog_line(&mut cursor, rewrite).unwrap();
+        assert_eq!(cursor.get_ref(), b"0 bytes copied, 1.23e-07 s, 0.0 B/s\n");
+    }
 }
diff --git a/src/uu/df/Cargo.toml b/src/uu/df/Cargo.toml
index 83ae2ae14..2be3967af 100644
--- a/src/uu/df/Cargo.toml
+++ b/src/uu/df/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_df"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "df ~ (uutils) display file system information"
@@ -15,9 +15,12 @@ edition = "2021"
 path = "src/df.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true, features=["libc", "fsext"] }
-unicode-width = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["libc", "fsext"] }
+unicode-width = { workspace = true }
+
+[dev-dependencies]
+tempfile = "3"
 
 [[bin]]
 name = "df"
diff --git a/src/uu/df/src/filesystem.rs b/src/uu/df/src/filesystem.rs
index aac63ac9d..813846a6c 100644
--- a/src/uu/df/src/filesystem.rs
+++ b/src/uu/df/src/filesystem.rs
@@ -42,7 +42,7 @@ pub(crate) struct Filesystem {
 /// This function returns the element of `mounts` on which `path` is
 /// mounted. If there are no matches, this function returns
 /// [`None`]. If there are two or more matches, then the single
-/// [`MountInfo`] with the longest mount directory is returned.
+/// [`MountInfo`] with the device name corresponding to the entered path.
 ///
 /// If `canonicalize` is `true`, then the `path` is canonicalized
 /// before checking whether it matches any mount directories.
@@ -68,9 +68,19 @@ where
         path.as_ref().to_path_buf()
     };
 
+    // Find the potential mount point that matches entered path
     let maybe_mount_point = mounts
         .iter()
-        .find(|mi| mi.dev_name.eq(&path.to_string_lossy()));
+        // Create pair MountInfo, canonicalized device name
+        // TODO Abstract from accessing real filesystem to
+        // make code more testable
+        .map(|m| (m, std::fs::canonicalize(&m.dev_name)))
+        // Ignore non existing paths
+        .filter(|m| m.1.is_ok())
+        .map(|m| (m.0, m.1.ok().unwrap()))
+        // Try to find canonicalized device name corresponding to entered path
+        .find(|m| m.1.eq(&path))
+        .map(|m| m.0);
 
     maybe_mount_point.or_else(|| {
         mounts
@@ -83,9 +93,7 @@ where
 impl Filesystem {
     // TODO: resolve uuid in `mount_info.dev_name` if exists
     pub(crate) fn new(mount_info: MountInfo, file: Option<String>) -> Option<Self> {
-        let _stat_path = if !mount_info.mount_dir.is_empty() {
-            mount_info.mount_dir.clone()
-        } else {
+        let _stat_path = if mount_info.mount_dir.is_empty() {
             #[cfg(unix)]
             {
                 mount_info.dev_name.clone()
@@ -95,6 +103,8 @@ impl Filesystem {
                 // On windows, we expect the volume id
                 mount_info.dev_id.clone()
             }
+        } else {
+            mount_info.mount_dir.clone()
         };
         #[cfg(unix)]
         let usage = FsUsage::new(statfs(_stat_path).ok()?);
@@ -211,10 +221,16 @@ mod tests {
 
         #[test]
         fn test_dev_name_match() {
+            let tmp = tempfile::TempDir::new().expect("Failed to create temp dir");
+            let dev_name = std::fs::canonicalize(tmp.path())
+                .expect("Failed to canonicalize tmp path")
+                .to_string_lossy()
+                .to_string();
+
             let mut mount_info = mount_info("/foo");
-            mount_info.dev_name = "/dev/sda2".to_string();
+            mount_info.dev_name = dev_name.clone();
             let mounts = [mount_info];
-            let actual = mount_info_from_path(&mounts, "/dev/sda2", false).unwrap();
+            let actual = mount_info_from_path(&mounts, dev_name, false).unwrap();
             assert!(mount_info_eq(actual, &mounts[0]));
         }
     }
diff --git a/src/uu/dir/Cargo.toml b/src/uu/dir/Cargo.toml
index 03235fdfc..d61b041dc 100644
--- a/src/uu/dir/Cargo.toml
+++ b/src/uu/dir/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_dir"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "shortcut to ls -C -b"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/dir.rs"
 
 [dependencies]
-clap = { workspace=true, features = ["env"] }
-uucore = { workspace=true, features=["entries", "fs"] }
-uu_ls = { workspace=true }
+clap = { workspace = true, features = ["env"] }
+uucore = { workspace = true, features = ["entries", "fs"] }
+uu_ls = { workspace = true }
 
 [[bin]]
 name = "dir"
diff --git a/src/uu/dircolors/Cargo.toml b/src/uu/dircolors/Cargo.toml
index 9a3479426..952e7ad3f 100644
--- a/src/uu/dircolors/Cargo.toml
+++ b/src/uu/dircolors/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_dircolors"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "dircolors ~ (uutils) display commands to set LS_COLORS"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/dircolors.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "dircolors"
diff --git a/src/uu/dircolors/README.md b/src/uu/dircolors/README.md
index 7a02c0c4b..ce8aa965f 100644
--- a/src/uu/dircolors/README.md
+++ b/src/uu/dircolors/README.md
@@ -1,18 +1,18 @@
-## How to update the internal database
+# How to update the internal database
 
 Create the test fixtures by writing the output of the GNU dircolors commands to the fixtures folder:
 
-```
-$ dircolors --print-database > /PATH_TO_COREUTILS/tests/fixtures/dircolors/internal.expected
-$ dircolors --print-ls-colors > /PATH_TO_COREUTILS/tests/fixtures/dircolors/ls_colors.expected
-$ dircolors -b > /PATH_TO_COREUTILS/tests/fixtures/dircolors/bash_def.expected
-$ dircolors -c > /PATH_TO_COREUTILS/tests/fixtures/dircolors/csh_def.expected
+```shell
+dircolors --print-database > /PATH_TO_COREUTILS/tests/fixtures/dircolors/internal.expected
+dircolors --print-ls-colors > /PATH_TO_COREUTILS/tests/fixtures/dircolors/ls_colors.expected
+dircolors -b > /PATH_TO_COREUTILS/tests/fixtures/dircolors/bash_def.expected
+dircolors -c > /PATH_TO_COREUTILS/tests/fixtures/dircolors/csh_def.expected
 ```
 
 Run the tests:
 
-```
-$ cargo test --features "dircolors" --no-default-features
+```shell
+cargo test --features "dircolors" --no-default-features
 ```
 
 Edit `/PATH_TO_COREUTILS/src/uu/dircolors/src/colors.rs` until the tests pass.
diff --git a/src/uu/dircolors/src/dircolors.rs b/src/uu/dircolors/src/dircolors.rs
index abab966af..19c3f7e31 100644
--- a/src/uu/dircolors/src/dircolors.rs
+++ b/src/uu/dircolors/src/dircolors.rs
@@ -12,6 +12,7 @@ use std::borrow::Borrow;
 use std::env;
 use std::fs::File;
 use std::io::{BufRead, BufReader};
+use std::path::Path;
 
 use clap::{crate_version, Arg, ArgAction, Command};
 use uucore::display::Quotable;
@@ -42,7 +43,6 @@ pub enum OutputFmt {
 }
 
 pub fn guess_syntax() -> OutputFmt {
-    use std::path::Path;
     match env::var("SHELL") {
         Ok(ref s) if !s.is_empty() => {
             let shell_path: &Path = s.as_ref();
@@ -136,17 +136,28 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         ));
     } else if files[0].eq("-") {
         let fin = BufReader::new(std::io::stdin());
-        result = parse(fin.lines().filter_map(Result::ok), &out_format, files[0]);
+        result = parse(fin.lines().map_while(Result::ok), &out_format, files[0]);
     } else {
-        match File::open(files[0]) {
+        let path = Path::new(files[0]);
+        if path.is_dir() {
+            return Err(USimpleError::new(
+                2,
+                format!("expected file, got directory {}", path.quote()),
+            ));
+        }
+        match File::open(path) {
             Ok(f) => {
                 let fin = BufReader::new(f);
-                result = parse(fin.lines().filter_map(Result::ok), &out_format, files[0]);
+                result = parse(
+                    fin.lines().map_while(Result::ok),
+                    &out_format,
+                    &path.to_string_lossy(),
+                );
             }
             Err(e) => {
                 return Err(USimpleError::new(
                     1,
-                    format!("{}: {}", files[0].maybe_quote(), e),
+                    format!("{}: {}", path.maybe_quote(), e),
                 ));
             }
         }
@@ -273,6 +284,7 @@ enum ParseState {
 use std::collections::HashMap;
 use uucore::{format_usage, parse_glob};
 
+#[allow(clippy::cognitive_complexity)]
 fn parse<T>(lines: T, fmt: &OutputFmt, fp: &str) -> Result<String, String>
 where
     T: IntoIterator,
diff --git a/src/uu/dirname/Cargo.toml b/src/uu/dirname/Cargo.toml
index 1186a4697..46dec707d 100644
--- a/src/uu/dirname/Cargo.toml
+++ b/src/uu/dirname/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_dirname"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "dirname ~ (uutils) display parent directory of PATHNAME"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/dirname.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "dirname"
diff --git a/src/uu/dirname/src/dirname.rs b/src/uu/dirname/src/dirname.rs
index 687aaa550..cecd6aec8 100644
--- a/src/uu/dirname/src/dirname.rs
+++ b/src/uu/dirname/src/dirname.rs
@@ -38,7 +38,9 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         .map(|s| s.to_owned())
         .collect();
 
-    if !dirnames.is_empty() {
+    if dirnames.is_empty() {
+        return Err(UUsageError::new(1, "missing operand"));
+    } else {
         for path in &dirnames {
             let p = Path::new(path);
             match p.parent() {
@@ -59,8 +61,6 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             }
             print!("{separator}");
         }
-    } else {
-        return Err(UUsageError::new(1, "missing operand"));
     }
 
     Ok(())
diff --git a/src/uu/du/Cargo.toml b/src/uu/du/Cargo.toml
index a8e8aead5..693e7c81c 100644
--- a/src/uu/du/Cargo.toml
+++ b/src/uu/du/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_du"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "du ~ (uutils) display disk usage"
@@ -15,14 +15,17 @@ edition = "2021"
 path = "src/du.rs"
 
 [dependencies]
-chrono = { workspace=true }
+chrono = { workspace = true }
 # For the --exclude & --exclude-from options
-glob = { workspace=true }
-clap = { workspace=true }
-uucore = { workspace=true }
+glob = { workspace = true }
+clap = { workspace = true }
+uucore = { workspace = true }
 
 [target.'cfg(target_os = "windows")'.dependencies]
-windows-sys = { workspace=true, features = ["Win32_Storage_FileSystem", "Win32_Foundation"] }
+windows-sys = { workspace = true, features = [
+  "Win32_Storage_FileSystem",
+  "Win32_Foundation",
+] }
 
 [[bin]]
 name = "du"
diff --git a/src/uu/du/du.md b/src/uu/du/du.md
index 6f154d047..ae3319ad6 100644
--- a/src/uu/du/du.md
+++ b/src/uu/du/du.md
@@ -19,6 +19,6 @@ of 1000).
 
 PATTERN allows some advanced exclusions. For example, the following syntaxes
 are supported:
-? will match only one character
-* will match zero or more characters
-{a,b} will match a or b
+`?` will match only one character
+`*` will match zero or more characters
+`{a,b}` will match a or b
diff --git a/src/uu/du/src/du.rs b/src/uu/du/src/du.rs
index c35bbf119..3325ca1f5 100644
--- a/src/uu/du/src/du.rs
+++ b/src/uu/du/src/du.rs
@@ -33,7 +33,7 @@ use std::time::{Duration, UNIX_EPOCH};
 use std::{error::Error, fmt::Display};
 use uucore::display::{print_verbatim, Quotable};
 use uucore::error::FromIo;
-use uucore::error::{UError, UResult};
+use uucore::error::{set_exit_code, UError, UResult};
 use uucore::parse_glob;
 use uucore::parse_size::{parse_size, ParseSizeError};
 use uucore::{
@@ -68,6 +68,7 @@ mod options {
     pub const TIME_STYLE: &str = "time-style";
     pub const ONE_FILE_SYSTEM: &str = "one-file-system";
     pub const DEREFERENCE: &str = "dereference";
+    pub const DEREFERENCE_ARGS: &str = "dereference-args";
     pub const INODES: &str = "inodes";
     pub const EXCLUDE: &str = "exclude";
     pub const EXCLUDE_FROM: &str = "exclude-from";
@@ -88,11 +89,18 @@ struct Options {
     total: bool,
     separate_dirs: bool,
     one_file_system: bool,
-    dereference: bool,
+    dereference: Deref,
     inodes: bool,
     verbose: bool,
 }
 
+#[derive(PartialEq)]
+enum Deref {
+    All,
+    Args(Vec<PathBuf>),
+    None,
+}
+
 #[derive(PartialEq, Eq, Hash, Clone, Copy)]
 struct FileInfo {
     file_id: u128,
@@ -112,13 +120,22 @@ struct Stat {
 }
 
 impl Stat {
-    fn new(path: PathBuf, options: &Options) -> Result<Self> {
-        let metadata = if options.dereference {
-            fs::metadata(&path)?
-        } else {
-            fs::symlink_metadata(&path)?
+    fn new(path: &Path, options: &Options) -> Result<Self> {
+        // Determine whether to dereference (follow) the symbolic link
+        let should_dereference = match &options.dereference {
+            Deref::All => true,
+            Deref::Args(paths) => paths.contains(&path.to_path_buf()),
+            Deref::None => false,
         };
 
+        let metadata = if should_dereference {
+            // Get metadata, following symbolic links if necessary
+            fs::metadata(path)
+        } else {
+            // Get metadata without following symbolic links
+            fs::symlink_metadata(path)
+        }?;
+
         #[cfg(not(windows))]
         let file_info = FileInfo {
             file_id: metadata.ino() as u128,
@@ -126,7 +143,7 @@ impl Stat {
         };
         #[cfg(not(windows))]
         return Ok(Self {
-            path,
+            path: path.to_path_buf(),
             is_dir: metadata.is_dir(),
             size: metadata.len(),
             blocks: metadata.blocks(),
@@ -138,12 +155,12 @@ impl Stat {
         });
 
         #[cfg(windows)]
-        let size_on_disk = get_size_on_disk(&path);
+        let size_on_disk = get_size_on_disk(path);
         #[cfg(windows)]
-        let file_info = get_file_info(&path);
+        let file_info = get_file_info(path);
         #[cfg(windows)]
         Ok(Self {
-            path,
+            path: path.to_path_buf(),
             is_dir: metadata.is_dir(),
             size: metadata.len(),
             blocks: size_on_disk / 1024 * 2,
@@ -272,6 +289,7 @@ fn choose_size(matches: &ArgMatches, stat: &Stat) -> u64 {
 
 // this takes `my_stat` to avoid having to stat files multiple times.
 // XXX: this should use the impl Trait return type when it is stabilized
+#[allow(clippy::cognitive_complexity)]
 fn du(
     mut my_stat: Stat,
     options: &Options,
@@ -296,7 +314,7 @@ fn du(
         'file_loop: for f in read {
             match f {
                 Ok(entry) => {
-                    match Stat::new(entry.path(), options) {
+                    match Stat::new(&entry.path(), options) {
                         Ok(this_stat) => {
                             // We have an exclude list
                             for pattern in exclude {
@@ -397,6 +415,20 @@ fn convert_size_other(size: u64, _multiplier: u64, block_size: u64) -> String {
     format!("{}", ((size as f64) / (block_size as f64)).ceil())
 }
 
+fn get_convert_size_fn(matches: &ArgMatches) -> Box<dyn Fn(u64, u64, u64) -> String> {
+    if matches.get_flag(options::HUMAN_READABLE) || matches.get_flag(options::SI) {
+        Box::new(convert_size_human)
+    } else if matches.get_flag(options::BYTES) {
+        Box::new(convert_size_b)
+    } else if matches.get_flag(options::BLOCK_SIZE_1K) {
+        Box::new(convert_size_k)
+    } else if matches.get_flag(options::BLOCK_SIZE_1M) {
+        Box::new(convert_size_m)
+    } else {
+        Box::new(convert_size_other)
+    }
+}
+
 #[derive(Debug)]
 enum DuError {
     InvalidMaxDepthArg(String),
@@ -505,26 +537,33 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         summarize,
     )?;
 
+    let files = match matches.get_one::<String>(options::FILE) {
+        Some(_) => matches
+            .get_many::<String>(options::FILE)
+            .unwrap()
+            .map(PathBuf::from)
+            .collect(),
+        None => vec![PathBuf::from(".")],
+    };
+
     let options = Options {
         all: matches.get_flag(options::ALL),
         max_depth,
         total: matches.get_flag(options::TOTAL),
         separate_dirs: matches.get_flag(options::SEPARATE_DIRS),
         one_file_system: matches.get_flag(options::ONE_FILE_SYSTEM),
-        dereference: matches.get_flag(options::DEREFERENCE),
+        dereference: if matches.get_flag(options::DEREFERENCE) {
+            Deref::All
+        } else if matches.get_flag(options::DEREFERENCE_ARGS) {
+            // We don't care about the cost of cloning as it is rarely used
+            Deref::Args(files.clone())
+        } else {
+            Deref::None
+        },
         inodes: matches.get_flag(options::INODES),
         verbose: matches.get_flag(options::VERBOSE),
     };
 
-    let files = match matches.get_one::<String>(options::FILE) {
-        Some(_) => matches
-            .get_many::<String>(options::FILE)
-            .unwrap()
-            .map(|s| s.as_str())
-            .collect(),
-        None => vec!["."],
-    };
-
     if options.inodes
         && (matches.get_flag(options::APPARENT_SIZE) || matches.get_flag(options::BYTES))
     {
@@ -547,19 +586,9 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     } else {
         1024
     };
-    let convert_size_fn = {
-        if matches.get_flag(options::HUMAN_READABLE) || matches.get_flag(options::SI) {
-            convert_size_human
-        } else if matches.get_flag(options::BYTES) {
-            convert_size_b
-        } else if matches.get_flag(options::BLOCK_SIZE_1K) {
-            convert_size_k
-        } else if matches.get_flag(options::BLOCK_SIZE_1M) {
-            convert_size_m
-        } else {
-            convert_size_other
-        }
-    };
+
+    let convert_size_fn = get_convert_size_fn(&matches);
+
     let convert_size = |size: u64| {
         if options.inodes {
             size.to_string()
@@ -580,11 +609,12 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let excludes = build_exclude_patterns(&matches)?;
 
     let mut grand_total = 0;
-    'loop_file: for path_string in files {
+    'loop_file: for path in files {
         // Skip if we don't want to ignore anything
         if !&excludes.is_empty() {
+            let path_string = path.to_string_lossy();
             for pattern in &excludes {
-                if pattern.matches(path_string) {
+                if pattern.matches(&path_string) {
                     // if the directory is ignored, leave early
                     if options.verbose {
                         println!("{} ignored", path_string.quote());
@@ -594,9 +624,8 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             }
         }
 
-        let path = PathBuf::from(&path_string);
         // Check existence of path provided in argument
-        if let Ok(stat) = Stat::new(path, &options) {
+        if let Ok(stat) = Stat::new(&path, &options) {
             // Kick off the computation of disk usage from the initial path
             let mut inodes: HashSet<FileInfo> = HashSet::new();
             if let Some(inode) = stat.inode {
@@ -616,20 +645,11 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
                 if matches.contains_id(options::TIME) {
                     let tm = {
-                        let secs = {
-                            match matches.get_one::<String>(options::TIME) {
-                                Some(s) => match s.as_str() {
-                                    "ctime" | "status" => stat.modified,
-                                    "access" | "atime" | "use" => stat.accessed,
-                                    "birth" | "creation" => stat
-                                        .created
-                                        .ok_or_else(|| DuError::InvalidTimeArg(s.into()))?,
-                                    // below should never happen as clap already restricts the values.
-                                    _ => unreachable!("Invalid field for --time"),
-                                },
-                                None => stat.modified,
-                            }
-                        };
+                        let secs = matches
+                            .get_one::<String>(options::TIME)
+                            .map(|s| get_time_secs(s, &stat))
+                            .transpose()?
+                            .unwrap_or(stat.modified);
                         DateTime::<Local>::from(UNIX_EPOCH + Duration::from_secs(secs))
                     };
                     if !summarize || index == len - 1 {
@@ -652,9 +672,10 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         } else {
             show_error!(
                 "{}: {}",
-                path_string.maybe_quote(),
+                path.to_string_lossy().maybe_quote(),
                 "No such file or directory"
             );
+            set_exit_code(1);
         }
     }
 
@@ -666,6 +687,19 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     Ok(())
 }
 
+fn get_time_secs(s: &str, stat: &Stat) -> std::result::Result<u64, DuError> {
+    let secs = match s {
+        "ctime" | "status" => stat.modified,
+        "access" | "atime" | "use" => stat.accessed,
+        "birth" | "creation" => stat
+            .created
+            .ok_or_else(|| DuError::InvalidTimeArg(s.into()))?,
+        // below should never happen as clap already restricts the values.
+        _ => unreachable!("Invalid field for --time"),
+    };
+    Ok(secs)
+}
+
 fn parse_time_style(s: Option<&str>) -> UResult<&str> {
     match s {
         Some(s) => match s {
@@ -785,7 +819,14 @@ pub fn uu_app() -> Command {
             Arg::new(options::DEREFERENCE)
                 .short('L')
                 .long(options::DEREFERENCE)
-                .help("dereference all symbolic links")
+                .help("follow all symbolic links")
+                .action(ArgAction::SetTrue)
+        )
+        .arg(
+            Arg::new(options::DEREFERENCE_ARGS)
+                .short('D')
+                .long(options::DEREFERENCE_ARGS)
+                .help("follow only symlinks that are listed on the command line")
                 .action(ArgAction::SetTrue)
         )
         // .arg(
@@ -913,6 +954,11 @@ impl FromStr for Threshold {
         let size = parse_size(&s[offset..])?;
 
         if s.starts_with('-') {
+            // Threshold of '-0' excludes everything besides 0 sized entries
+            // GNU's du treats '-0' as an invalid argument
+            if size == 0 {
+                return Err(ParseSizeError::ParseFailure(s.to_string()));
+            }
             Ok(Self::Upper(size))
         } else {
             Ok(Self::Lower(size))
diff --git a/src/uu/echo/Cargo.toml b/src/uu/echo/Cargo.toml
index 0ae385cbe..e12460a51 100644
--- a/src/uu/echo/Cargo.toml
+++ b/src/uu/echo/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_echo"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "echo ~ (uutils) display TEXT"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/echo.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "echo"
diff --git a/src/uu/echo/echo.md b/src/uu/echo/echo.md
new file mode 100644
index 000000000..4330ecd88
--- /dev/null
+++ b/src/uu/echo/echo.md
@@ -0,0 +1,26 @@
+# echo
+
+```
+echo [OPTIONS]... [STRING]...
+```
+
+Display a line of text
+
+## After Help
+
+Echo the STRING(s) to standard output.
+
+If -e is in effect, the following sequences are recognized:
+
+\\      backslash
+\a      alert (BEL)
+\b      backspace
+\c      produce no further output
+\e      escape
+\f      form feed
+\n      new line
+\r      carriage return
+\t      horizontal tab
+\v      vertical tab
+\0NNN   byte with octal value NNN (1 to 3 digits)
+\xHH    byte with hexadecimal value HH (1 to 2 digits)
\ No newline at end of file
diff --git a/src/uu/echo/src/echo.rs b/src/uu/echo/src/echo.rs
index 6c6959aff..659dc836c 100644
--- a/src/uu/echo/src/echo.rs
+++ b/src/uu/echo/src/echo.rs
@@ -11,28 +11,11 @@ use std::io::{self, Write};
 use std::iter::Peekable;
 use std::str::Chars;
 use uucore::error::{FromIo, UResult};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_section, help_usage};
 
-const ABOUT: &str = "Display a line of text";
-const USAGE: &str = "{} [OPTIONS]... [STRING]...";
-const AFTER_HELP: &str = r#"
- Echo the STRING(s) to standard output.
-
- If -e is in effect, the following sequences are recognized:
-
- \\\\      backslash
- \\a      alert (BEL)
- \\b      backspace
- \\c      produce no further output
- \\e      escape
- \\f      form feed
- \\n      new line
- \\r      carriage return
- \\t      horizontal tab
- \\v      vertical tab
- \\0NNN   byte with octal value NNN (1 to 3 digits)
- \\xHH    byte with hexadecimal value HH (1 to 2 digits)
-"#;
+const ABOUT: &str = help_about!("echo.md");
+const USAGE: &str = help_usage!("echo.md");
+const AFTER_HELP: &str = help_section!("after help", "echo.md");
 
 mod options {
     pub const STRING: &str = "STRING";
diff --git a/src/uu/env/Cargo.toml b/src/uu/env/Cargo.toml
index b2224c405..2b05cd3e7 100644
--- a/src/uu/env/Cargo.toml
+++ b/src/uu/env/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_env"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "env ~ (uutils) set each NAME to VALUE in the environment and run COMMAND"
@@ -15,12 +15,12 @@ edition = "2021"
 path = "src/env.rs"
 
 [dependencies]
-clap = { workspace=true }
-rust-ini = { workspace=true }
-uucore = { workspace=true, features=["signals"]}
+clap = { workspace = true }
+rust-ini = { workspace = true }
+uucore = { workspace = true, features = ["signals"] }
 
 [target.'cfg(unix)'.dependencies]
-nix = { workspace=true, features = ["signal"] }
+nix = { workspace = true, features = ["signal"] }
 
 
 [[bin]]
diff --git a/src/uu/env/env.md b/src/uu/env/env.md
new file mode 100644
index 000000000..fc3341a61
--- /dev/null
+++ b/src/uu/env/env.md
@@ -0,0 +1,13 @@
+# env
+
+```
+env [OPTION]... [-] [NAME=VALUE]... [COMMAND [ARG]...]
+```
+
+
+Set each NAME to VALUE in the environment and run COMMAND
+
+
+## After Help
+
+A mere - implies -i. If no COMMAND, print the resulting environment.
diff --git a/src/uu/env/src/env.rs b/src/uu/env/src/env.rs
index b3fa871d3..b293bc9bf 100644
--- a/src/uu/env/src/env.rs
+++ b/src/uu/env/src/env.rs
@@ -23,13 +23,11 @@ use std::os::unix::process::ExitStatusExt;
 use std::process;
 use uucore::display::Quotable;
 use uucore::error::{UClapError, UResult, USimpleError, UUsageError};
-use uucore::{format_usage, show_warning};
+use uucore::{format_usage, help_about, help_section, help_usage, show_warning};
 
-const ABOUT: &str = "Set each NAME to VALUE in the environment and run COMMAND";
-const USAGE: &str = "{} [OPTION]... [-] [NAME=VALUE]... [COMMAND [ARG]...]";
-const AFTER_HELP: &str = "\
-A mere - implies -i. If no COMMAND, print the resulting environment.
-";
+const ABOUT: &str = help_about!("env.md");
+const USAGE: &str = help_usage!("env.md");
+const AFTER_HELP: &str = help_section!("after help", "env.md");
 
 struct Options<'a> {
     ignore_env: bool,
@@ -177,6 +175,7 @@ pub fn uu_app() -> Command {
         .arg(Arg::new("vars").action(ArgAction::Append))
 }
 
+#[allow(clippy::cognitive_complexity)]
 fn run_env(args: impl uucore::Args) -> UResult<()> {
     let app = uu_app();
     let matches = app.try_get_matches_from(args).with_exit_code(125)?;
@@ -301,7 +300,10 @@ fn run_env(args: impl uucore::Args) -> UResult<()> {
         env::set_var(name, val);
     }
 
-    if !opts.program.is_empty() {
+    if opts.program.is_empty() {
+        // no program provided, so just dump all env vars to stdout
+        print_env(opts.null);
+    } else {
         // we need to execute a command
         let (prog, args) = build_command(&mut opts.program);
 
@@ -346,9 +348,6 @@ fn run_env(args: impl uucore::Args) -> UResult<()> {
             Err(_) => return Err(126.into()),
             Ok(_) => (),
         }
-    } else {
-        // no program provided, so just dump all env vars to stdout
-        print_env(opts.null);
     }
 
     Ok(())
diff --git a/src/uu/expand/Cargo.toml b/src/uu/expand/Cargo.toml
index 362ed5a3a..dd0b76982 100644
--- a/src/uu/expand/Cargo.toml
+++ b/src/uu/expand/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_expand"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "expand ~ (uutils) convert input tabs to spaces"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/expand.rs"
 
 [dependencies]
-clap = { workspace=true }
-unicode-width = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+unicode-width = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "expand"
diff --git a/src/uu/expand/expand.md b/src/uu/expand/expand.md
new file mode 100644
index 000000000..df7294c30
--- /dev/null
+++ b/src/uu/expand/expand.md
@@ -0,0 +1,8 @@
+# expand
+
+```
+expand [OPTION]... [FILE]...
+```
+
+Convert tabs in each `FILE` to spaces, writing to standard output.
+With no `FILE`, or when `FILE` is `-`, read standard input.
diff --git a/src/uu/expand/src/expand.rs b/src/uu/expand/src/expand.rs
index 7976a0a97..98b292771 100644
--- a/src/uu/expand/src/expand.rs
+++ b/src/uu/expand/src/expand.rs
@@ -19,11 +19,10 @@ use std::str::from_utf8;
 use unicode_width::UnicodeWidthChar;
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UError, UResult};
-use uucore::{crash, format_usage};
+use uucore::{crash, format_usage, help_about, help_usage};
 
-static ABOUT: &str = "Convert tabs in each FILE to spaces, writing to standard output.
- With no FILE, or when FILE is -, read standard input.";
-const USAGE: &str = "{} [OPTION]... [FILE]...";
+const ABOUT: &str = help_about!("expand.md");
+const USAGE: &str = help_usage!("expand.md");
 
 pub mod options {
     pub static TABS: &str = "tabs";
@@ -374,6 +373,7 @@ enum CharType {
     Other,
 }
 
+#[allow(clippy::cognitive_complexity)]
 fn expand(options: &Options) -> std::io::Result<()> {
     use self::CharType::*;
 
diff --git a/src/uu/expr/Cargo.toml b/src/uu/expr/Cargo.toml
index 4ee2b5b1a..68224ee45 100644
--- a/src/uu/expr/Cargo.toml
+++ b/src/uu/expr/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_expr"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "expr ~ (uutils) display the value of EXPRESSION"
@@ -15,11 +15,11 @@ edition = "2021"
 path = "src/expr.rs"
 
 [dependencies]
-clap = { workspace=true }
-num-bigint = { workspace=true }
-num-traits = { workspace=true }
-onig = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+num-bigint = { workspace = true }
+num-traits = { workspace = true }
+onig = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "expr"
diff --git a/src/uu/expr/expr.md b/src/uu/expr/expr.md
index eaa748076..ab0824651 100644
--- a/src/uu/expr/expr.md
+++ b/src/uu/expr/expr.md
@@ -10,49 +10,44 @@ Print the value of `EXPRESSION` to standard output
 ## After help
 
 Print the value of `EXPRESSION` to standard output.  A blank line below
-separates increasing precedence groups. 
+separates increasing precedence groups.
 
 `EXPRESSION` may be:
 
-    ARG1 | ARG2       ARG1 if it is neither null nor 0, otherwise ARG2
-
-    ARG1 & ARG2       ARG1 if neither argument is null or 0, otherwise 0
-
-    ARG1 < ARG2       ARG1 is less than ARG2
-    ARG1 <= ARG2      ARG1 is less than or equal to ARG2
-    ARG1 = ARG2       ARG1 is equal to ARG2
-    ARG1 != ARG2      ARG1 is unequal to ARG2
-    ARG1 >= ARG2      ARG1 is greater than or equal to ARG2
-    ARG1 > ARG2       ARG1 is greater than ARG2
-
-    ARG1 + ARG2       arithmetic sum of ARG1 and ARG2
-    ARG1 - ARG2       arithmetic difference of ARG1 and ARG2
-
-    ARG1 * ARG2       arithmetic product of ARG1 and ARG2
-    ARG1 / ARG2       arithmetic quotient of ARG1 divided by ARG2
-    ARG1 % ARG2       arithmetic remainder of ARG1 divided by ARG2
-
-    STRING : REGEXP   anchored pattern match of REGEXP in STRING
-
-    match STRING REGEXP        same as STRING : REGEXP
-    substr STRING POS LENGTH   substring of STRING, POS counted from 1
-    index STRING CHARS         index in STRING where any CHARS is found, or 0
-    length STRING              length of STRING
-    + TOKEN                    interpret TOKEN as a string, even if it is a
-                                 keyword like 'match' or an operator like '/'
-
-    ( EXPRESSION )             value of EXPRESSION
+- `ARG1 | ARG2`: `ARG1` if it is neither null nor 0, otherwise `ARG2`
+- `ARG1 & ARG2`: `ARG1` if neither argument is null or 0, otherwise 0
+- `ARG1 < ARG2`: `ARG1` is less than `ARG2`
+- `ARG1 <= ARG2`: `ARG1` is less than or equal to `ARG2`
+- `ARG1 = ARG2`: `ARG1` is equal to `ARG2`
+- `ARG1 != ARG2`: `ARG1` is unequal to `ARG2`
+- `ARG1 >= ARG2`: `ARG1` is greater than or equal to `ARG2`
+- `ARG1 > ARG2`: `ARG1` is greater than `ARG2`
+- `ARG1 + ARG2`: arithmetic sum of `ARG1` and `ARG2`
+- `ARG1 - ARG2`: arithmetic difference of `ARG1` and `ARG2`
+- `ARG1 * ARG2`: arithmetic product of `ARG1` and `ARG2`
+- `ARG1 / ARG2`: arithmetic quotient of `ARG1` divided by `ARG2`
+- `ARG1 % ARG2`: arithmetic remainder of `ARG1` divided by `ARG2`
+- `STRING : REGEXP`: anchored pattern match of `REGEXP` in `STRING`
+- `match STRING REGEXP`: same as `STRING : REGEXP`
+- `substr STRING POS LENGTH`: substring of `STRING`, `POS` counted from 1
+- `index STRING CHARS`: index in `STRING` where any `CHARS` is found, or 0
+- `length STRING`: length of `STRING`
+- `+ TOKEN`: interpret `TOKEN` as a string, even if it is a keyword like `match`
+  or an operator like `/`
+- `( EXPRESSION )`: value of `EXPRESSION`
 
 Beware that many operators need to be escaped or quoted for shells.
 Comparisons are arithmetic if both ARGs are numbers, else lexicographical.
 Pattern matches return the string matched between \( and \) or null; if
 \( and \) are not used, they return the number of characters matched or 0.
 
-Exit status is `0` if `EXPRESSION` is neither null nor `0`, `1` if `EXPRESSION` is null
-or `0`, `2` if `EXPRESSION` is syntactically invalid, and `3` if an error occurred.
+Exit status is `0` if `EXPRESSION` is neither null nor `0`, `1` if `EXPRESSION`
+is null or `0`, `2` if `EXPRESSION` is syntactically invalid, and `3` if an
+error occurred.
 
 Environment variables:
- - `EXPR_DEBUG_TOKENS=1`: dump expression's tokens
- - `EXPR_DEBUG_RPN=1`: dump expression represented in reverse polish notation
- - `EXPR_DEBUG_SYA_STEP=1`: dump each parser step
- - `EXPR_DEBUG_AST=1`: dump expression represented abstract syntax tree
+
+- `EXPR_DEBUG_TOKENS=1`: dump expression's tokens
+- `EXPR_DEBUG_RPN=1`: dump expression represented in reverse polish notation
+- `EXPR_DEBUG_SYA_STEP=1`: dump each parser step
+- `EXPR_DEBUG_AST=1`: dump expression represented abstract syntax tree
diff --git a/src/uu/expr/src/syntax_tree.rs b/src/uu/expr/src/syntax_tree.rs
index 936760f27..1d2ddbced 100644
--- a/src/uu/expr/src/syntax_tree.rs
+++ b/src/uu/expr/src/syntax_tree.rs
@@ -185,14 +185,14 @@ pub fn tokens_to_ast(
 
         maybe_dump_rpn(&out_stack);
         let result = ast_from_rpn(&mut out_stack);
-        if !out_stack.is_empty() {
+        if out_stack.is_empty() {
+            maybe_dump_ast(&result);
+            result
+        } else {
             Err(
                 "syntax error (first RPN token does not represent the root of the expression AST)"
                     .to_owned(),
             )
-        } else {
-            maybe_dump_ast(&result);
-            result
         }
     })
 }
diff --git a/src/uu/factor/BENCHMARKING.md b/src/uu/factor/BENCHMARKING.md
index 0f9afaff0..d5fdb47d6 100644
--- a/src/uu/factor/BENCHMARKING.md
+++ b/src/uu/factor/BENCHMARKING.md
@@ -53,19 +53,19 @@ which I recommend reading if you want to add benchmarks to `factor`.
      so each sample takes a very short time, minimizing variability and
      maximizing the numbers of samples we can take in a given time.
 
-2. Benchmarks are immutable (once merged in `uutils`)
+1. Benchmarks are immutable (once merged in `uutils`)
 
    Modifying a benchmark means previously-collected values cannot meaningfully
    be compared, silently giving nonsensical results.  If you must modify an
    existing benchmark, rename it.
 
-3. Test common cases
+1. Test common cases
 
    We are interested in overall performance, rather than specific edge-cases;
    use **reproducibly-randomized inputs**, sampling from either all possible
    input values or some subset of interest.
 
-4. Use [`criterion`], `criterion::black_box`, ...
+1. Use [`criterion`], `criterion::black_box`, ...
 
    `criterion` isn't perfect, but it is also much better than ad-hoc
    solutions in each benchmark.
@@ -103,7 +103,7 @@ characteristics:
 1. integer factoring algorithms are randomized, with large variance in
    execution time ;
 
-2. various inputs also have large differences in factoring time, that
+1. various inputs also have large differences in factoring time, that
    corresponds to no natural, linear ordering of the inputs.
 
 If (1) was untrue (i.e. if execution time wasn't random), we could faithfully
diff --git a/src/uu/factor/Cargo.toml b/src/uu/factor/Cargo.toml
index 73be80738..a0fc539e1 100644
--- a/src/uu/factor/Cargo.toml
+++ b/src/uu/factor/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_factor"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "factor ~ (uutils) display the prime factors of each NUMBER"
@@ -12,18 +12,17 @@ categories = ["command-line-utilities"]
 edition = "2021"
 
 [build-dependencies]
-num-traits = { workspace=true } # used in src/numerics.rs, which is included by build.rs
+num-traits = { workspace = true } # used in src/numerics.rs, which is included by build.rs
 
 [dependencies]
-clap = { workspace=true }
-coz = { workspace=true, optional = true }
-num-traits = { workspace=true }
-rand = { workspace=true }
-smallvec = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+coz = { workspace = true, optional = true }
+num-traits = { workspace = true }
+rand = { workspace = true }
+smallvec = { workspace = true }
+uucore = { workspace = true }
 
 [dev-dependencies]
-paste = "1.0.6"
 quickcheck = "1.0.3"
 
 [[bin]]
diff --git a/src/uu/factor/factor.md b/src/uu/factor/factor.md
new file mode 100644
index 000000000..ccce4f252
--- /dev/null
+++ b/src/uu/factor/factor.md
@@ -0,0 +1,8 @@
+# factor
+
+```
+factor [OPTION]... [NUMBER]...
+```
+
+Print the prime factors of the given NUMBER(s).
+If none are specified, read from standard input.
diff --git a/src/uu/factor/src/cli.rs b/src/uu/factor/src/cli.rs
index 0b50599ae..714b38e5e 100644
--- a/src/uu/factor/src/cli.rs
+++ b/src/uu/factor/src/cli.rs
@@ -16,17 +16,19 @@ use clap::{crate_version, Arg, ArgAction, Command};
 pub use factor::*;
 use uucore::display::Quotable;
 use uucore::error::UResult;
-use uucore::{show_error, show_warning};
+use uucore::{format_usage, help_about, help_usage, show_error, show_warning};
 
 mod miller_rabin;
 pub mod numeric;
 mod rho;
 pub mod table;
 
-static ABOUT: &str = r#"Print the prime factors of the given NUMBER(s).
-If none are specified, read from standard input."#;
+const ABOUT: &str = help_about!("factor.md");
+const USAGE: &str = help_usage!("factor.md");
 
 mod options {
+    pub static EXPONENTS: &str = "exponents";
+    pub static HELP: &str = "help";
     pub static NUMBER: &str = "NUMBER";
 }
 
@@ -34,6 +36,7 @@ fn print_factors_str(
     num_str: &str,
     w: &mut io::BufWriter<impl io::Write>,
     factors_buffer: &mut String,
+    print_exponents: bool,
 ) -> Result<(), Box<dyn Error>> {
     num_str
         .trim()
@@ -41,8 +44,15 @@ fn print_factors_str(
         .map_err(|e| e.into())
         .and_then(|x| {
             factors_buffer.clear();
-            writeln!(factors_buffer, "{}:{}", x, factor(x))?;
+            // If print_exponents is true, use the alternate format specifier {:#} from fmt to print the factors
+            // of x in the form of p^e.
+            if print_exponents {
+                writeln!(factors_buffer, "{}:{:#}", x, factor(x))?;
+            } else {
+                writeln!(factors_buffer, "{}:{}", x, factor(x))?;
+            }
             w.write_all(factors_buffer.as_bytes())?;
+            w.flush()?;
             Ok(())
         })
 }
@@ -50,6 +60,10 @@ fn print_factors_str(
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app().try_get_matches_from(args)?;
+
+    // If matches find --exponents flag than variable print_exponents is true and p^e output format will be used.
+    let print_exponents = matches.get_flag(options::EXPONENTS);
+
     let stdout = stdout();
     // We use a smaller buffer here to pass a gnu test. 4KiB appears to be the default pipe size for bash.
     let mut w = io::BufWriter::with_capacity(4 * 1024, stdout.lock());
@@ -57,7 +71,8 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
     if let Some(values) = matches.get_many::<String>(options::NUMBER) {
         for number in values {
-            if let Err(e) = print_factors_str(number, &mut w, &mut factors_buffer) {
+            if let Err(e) = print_factors_str(number, &mut w, &mut factors_buffer, print_exponents)
+            {
                 show_warning!("{}: {}", number.maybe_quote(), e);
             }
         }
@@ -66,7 +81,9 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         let lines = stdin.lock().lines();
         for line in lines {
             for number in line.unwrap().split_whitespace() {
-                if let Err(e) = print_factors_str(number, &mut w, &mut factors_buffer) {
+                if let Err(e) =
+                    print_factors_str(number, &mut w, &mut factors_buffer, print_exponents)
+                {
                     show_warning!("{}: {}", number.maybe_quote(), e);
                 }
             }
@@ -84,6 +101,21 @@ pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
         .infer_long_args(true)
+        .disable_help_flag(true)
         .arg(Arg::new(options::NUMBER).action(ArgAction::Append))
+        .arg(
+            Arg::new(options::EXPONENTS)
+                .short('h')
+                .long(options::EXPONENTS)
+                .help("Print factors in the form p^e")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::HELP)
+                .long(options::HELP)
+                .help("Print help information.")
+                .action(ArgAction::Help),
+        )
 }
diff --git a/src/uu/factor/src/factor.rs b/src/uu/factor/src/factor.rs
index 5d1615342..a87f4219e 100644
--- a/src/uu/factor/src/factor.rs
+++ b/src/uu/factor/src/factor.rs
@@ -97,9 +97,14 @@ impl fmt::Display for Factors {
         let v = &mut (self.0).borrow_mut().0;
         v.sort_unstable();
 
+        let include_exponents = f.alternate();
         for (p, exp) in v.iter() {
-            for _ in 0..*exp {
-                write!(f, " {p}")?;
+            if include_exponents && *exp > 1 {
+                write!(f, " {p}^{exp}")?;
+            } else {
+                for _ in 0..*exp {
+                    write!(f, " {p}")?;
+                }
             }
         }
 
diff --git a/src/uu/factor/src/miller_rabin.rs b/src/uu/factor/src/miller_rabin.rs
index 4908959fb..de2f8a924 100644
--- a/src/uu/factor/src/miller_rabin.rs
+++ b/src/uu/factor/src/miller_rabin.rs
@@ -112,7 +112,6 @@ pub(crate) fn is_prime(n: u64) -> bool {
 mod tests {
     use super::*;
     use crate::numeric::{traits::DoubleInt, Arithmetic, Montgomery};
-    use crate::parametrized_check;
     use quickcheck::quickcheck;
     use std::iter;
     const LARGEST_U64_PRIME: u64 = 0xFFFFFFFFFFFFFFC5;
@@ -157,7 +156,16 @@ mod tests {
             );
         }
     }
-    parametrized_check!(first_primes);
+
+    #[test]
+    fn first_primes_u32() {
+        first_primes::<u32>();
+    }
+
+    #[test]
+    fn first_primes_u64() {
+        first_primes::<u64>();
+    }
 
     #[test]
     fn one() {
@@ -195,7 +203,16 @@ mod tests {
             }
         }
     }
-    parametrized_check!(small_semiprimes);
+
+    #[test]
+    fn small_semiprimes_u32() {
+        small_semiprimes::<u32>();
+    }
+
+    #[test]
+    fn small_semiprimes_u64() {
+        small_semiprimes::<u64>();
+    }
 
     quickcheck! {
         fn composites(i: u64, j: u64) -> bool {
diff --git a/src/uu/factor/src/numeric/modular_inverse.rs b/src/uu/factor/src/numeric/modular_inverse.rs
index edf3c6cce..992253a43 100644
--- a/src/uu/factor/src/numeric/modular_inverse.rs
+++ b/src/uu/factor/src/numeric/modular_inverse.rs
@@ -46,7 +46,6 @@ pub(crate) fn modular_inverse<T: Int>(a: T) -> T {
 #[cfg(test)]
 mod tests {
     use super::{super::traits::Int, *};
-    use crate::parametrized_check;
     use quickcheck::quickcheck;
 
     fn small_values<T: Int>() {
@@ -59,7 +58,16 @@ mod tests {
 
         assert!(test_values.all(|x| x.wrapping_mul(&modular_inverse(x)) == one));
     }
-    parametrized_check!(small_values);
+
+    #[test]
+    fn small_values_u32() {
+        small_values::<u32>();
+    }
+
+    #[test]
+    fn small_values_u64() {
+        small_values::<u64>();
+    }
 
     quickcheck! {
         fn random_values_u32(n: u32) -> bool {
diff --git a/src/uu/factor/src/numeric/montgomery.rs b/src/uu/factor/src/numeric/montgomery.rs
index e07b95358..d411d0d41 100644
--- a/src/uu/factor/src/numeric/montgomery.rs
+++ b/src/uu/factor/src/numeric/montgomery.rs
@@ -82,10 +82,10 @@ impl<T: DoubleInt> Montgomery<T> {
         // (x + n*m) / R
         // in case of overflow, this is (2¹²⁸ + xnm)/2⁶⁴ - n = xnm/2⁶⁴ + (2⁶⁴ - n)
         let y = T::from_double_width(xnm >> t_bits)
-            + if !overflow {
-                T::zero()
-            } else {
+            + if overflow {
                 n.wrapping_neg()
+            } else {
+                T::zero()
             };
 
         if y >= *n {
@@ -132,10 +132,10 @@ impl<T: DoubleInt> Arithmetic for Montgomery<T> {
         let (r, overflow) = a.overflowing_add(&b);
 
         // In case of overflow, a+b = 2⁶⁴ + r = (2⁶⁴ - n) + r (working mod n)
-        let r = if !overflow {
-            r
-        } else {
+        let r = if overflow {
             r + self.n.wrapping_neg()
+        } else {
+            r
         };
 
         // Normalize to [0; n[
@@ -182,8 +182,6 @@ impl<T: DoubleInt> Arithmetic for Montgomery<T> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::parametrized_check;
-
     fn test_add<A: DoubleInt>() {
         for n in 0..100 {
             let n = 2 * n + 1;
@@ -198,7 +196,16 @@ mod tests {
             }
         }
     }
-    parametrized_check!(test_add);
+
+    #[test]
+    fn add_u32() {
+        test_add::<u32>();
+    }
+
+    #[test]
+    fn add_u64() {
+        test_add::<u64>();
+    }
 
     fn test_multiplication<A: DoubleInt>() {
         for n in 0..100 {
@@ -213,7 +220,16 @@ mod tests {
             }
         }
     }
-    parametrized_check!(test_multiplication);
+
+    #[test]
+    fn multiplication_u32() {
+        test_multiplication::<u32>();
+    }
+
+    #[test]
+    fn multiplication_u64() {
+        test_multiplication::<u64>();
+    }
 
     fn test_roundtrip<A: DoubleInt>() {
         for n in 0..100 {
@@ -225,5 +241,14 @@ mod tests {
             }
         }
     }
-    parametrized_check!(test_roundtrip);
+
+    #[test]
+    fn roundtrip_u32() {
+        test_roundtrip::<u32>();
+    }
+
+    #[test]
+    fn roundtrip_u64() {
+        test_roundtrip::<u64>();
+    }
 }
diff --git a/src/uu/false/Cargo.toml b/src/uu/false/Cargo.toml
index 1bd0bc260..88b5751cb 100644
--- a/src/uu/false/Cargo.toml
+++ b/src/uu/false/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_false"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "false ~ (uutils) do nothing and fail"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/false.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "false"
diff --git a/src/uu/false/false.md b/src/uu/false/false.md
new file mode 100644
index 000000000..3f0594767
--- /dev/null
+++ b/src/uu/false/false.md
@@ -0,0 +1,11 @@
+# false
+
+```
+false
+```
+
+Returns false, an unsuccessful exit status.
+
+Immediately returns with the exit status `1`. When invoked with one of the recognized options it
+will try to write the help or version text. Any IO error during this operation is diagnosed, yet
+the program will also return `1`.
diff --git a/src/uu/false/src/false.rs b/src/uu/false/src/false.rs
index 3a74142e0..27b6be291 100644
--- a/src/uu/false/src/false.rs
+++ b/src/uu/false/src/false.rs
@@ -7,14 +7,9 @@
 use clap::{Arg, ArgAction, Command};
 use std::{ffi::OsString, io::Write};
 use uucore::error::{set_exit_code, UResult};
+use uucore::help_about;
 
-static ABOUT: &str = "\
-Returns false, an unsuccessful exit status.
-
-Immediately returns with the exit status `1`. When invoked with one of the recognized options it
-will try to write the help or version text. Any IO error during this operation is diagnosed, yet
-the program will also return `1`.
-";
+const ABOUT: &str = help_about!("false.md");
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
diff --git a/src/uu/fmt/Cargo.toml b/src/uu/fmt/Cargo.toml
index f37e9468a..0de6218b8 100644
--- a/src/uu/fmt/Cargo.toml
+++ b/src/uu/fmt/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_fmt"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "fmt ~ (uutils) reformat each paragraph of input"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/fmt.rs"
 
 [dependencies]
-clap = { workspace=true }
-unicode-width = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+unicode-width = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "fmt"
diff --git a/src/uu/fmt/src/fmt.rs b/src/uu/fmt/src/fmt.rs
index bd03b5497..d144bdd8a 100644
--- a/src/uu/fmt/src/fmt.rs
+++ b/src/uu/fmt/src/fmt.rs
@@ -11,7 +11,7 @@ use clap::{crate_version, Arg, ArgAction, Command};
 use std::cmp;
 use std::fs::File;
 use std::io::{stdin, stdout, Write};
-use std::io::{BufReader, BufWriter, Read};
+use std::io::{BufReader, BufWriter, Read, Stdout};
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult, USimpleError};
 use uucore::{format_usage, help_about, help_usage, show_warning};
@@ -60,10 +60,17 @@ pub struct FmtOptions {
     goal: usize,
     tabwidth: usize,
 }
-
-#[uucore::main]
+/// Parse the command line arguments and return the list of files and formatting options.
+///
+/// # Arguments
+///
+/// * `args` - Command line arguments.
+///
+/// # Returns
+///
+/// A tuple containing a vector of file names and a `FmtOptions` struct.
 #[allow(clippy::cognitive_complexity)]
-pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+fn parse_arguments(args: impl uucore::Args) -> UResult<(Vec<String>, FmtOptions)> {
     let matches = uu_app().try_get_matches_from(args)?;
 
     let mut files: Vec<String> = matches
@@ -177,39 +184,68 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         files.push("-".to_owned());
     }
 
+    Ok((files, fmt_opts))
+}
+
+/// Process the content of a file and format it according to the provided options.
+///
+/// # Arguments
+///
+/// * `file_name` - The name of the file to process. A value of "-" represents the standard input.
+/// * `fmt_opts` - A reference to a `FmtOptions` struct containing the formatting options.
+/// * `ostream` - A mutable reference to a `BufWriter` wrapping the standard output.
+///
+/// # Returns
+///
+/// A `UResult<()>` indicating success or failure.
+fn process_file(
+    file_name: &str,
+    fmt_opts: &FmtOptions,
+    ostream: &mut BufWriter<Stdout>,
+) -> UResult<()> {
+    let mut fp = match file_name {
+        "-" => BufReader::new(Box::new(stdin()) as Box<dyn Read + 'static>),
+        _ => match File::open(file_name) {
+            Ok(f) => BufReader::new(Box::new(f) as Box<dyn Read + 'static>),
+            Err(e) => {
+                show_warning!("{}: {}", file_name.maybe_quote(), e);
+                return Ok(());
+            }
+        },
+    };
+
+    let p_stream = ParagraphStream::new(fmt_opts, &mut fp);
+    for para_result in p_stream {
+        match para_result {
+            Err(s) => {
+                ostream
+                    .write_all(s.as_bytes())
+                    .map_err_context(|| "failed to write output".to_string())?;
+                ostream
+                    .write_all(b"\n")
+                    .map_err_context(|| "failed to write output".to_string())?;
+            }
+            Ok(para) => break_lines(&para, fmt_opts, ostream)
+                .map_err_context(|| "failed to write output".to_string())?,
+        }
+    }
+
+    // flush the output after each file
+    ostream
+        .flush()
+        .map_err_context(|| "failed to write output".to_string())?;
+
+    Ok(())
+}
+
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let (files, fmt_opts) = parse_arguments(args)?;
+
     let mut ostream = BufWriter::new(stdout());
 
-    for i in files.iter().map(|x| &x[..]) {
-        let mut fp = match i {
-            "-" => BufReader::new(Box::new(stdin()) as Box<dyn Read + 'static>),
-            _ => match File::open(i) {
-                Ok(f) => BufReader::new(Box::new(f) as Box<dyn Read + 'static>),
-                Err(e) => {
-                    show_warning!("{}: {}", i.maybe_quote(), e);
-                    continue;
-                }
-            },
-        };
-        let p_stream = ParagraphStream::new(&fmt_opts, &mut fp);
-        for para_result in p_stream {
-            match para_result {
-                Err(s) => {
-                    ostream
-                        .write_all(s.as_bytes())
-                        .map_err_context(|| "failed to write output".to_string())?;
-                    ostream
-                        .write_all(b"\n")
-                        .map_err_context(|| "failed to write output".to_string())?;
-                }
-                Ok(para) => break_lines(&para, &fmt_opts, &mut ostream)
-                    .map_err_context(|| "failed to write output".to_string())?,
-            }
-        }
-
-        // flush the output after each file
-        ostream
-            .flush()
-            .map_err_context(|| "failed to write output".to_string())?;
+    for file_name in &files {
+        process_file(file_name, &fmt_opts, &mut ostream)?;
     }
 
     Ok(())
diff --git a/src/uu/fmt/src/linebreak.rs b/src/uu/fmt/src/linebreak.rs
index 75cd633bb..e86623c88 100644
--- a/src/uu/fmt/src/linebreak.rs
+++ b/src/uu/fmt/src/linebreak.rs
@@ -223,6 +223,7 @@ struct LineBreak<'a> {
     fresh: bool,
 }
 
+#[allow(clippy::cognitive_complexity)]
 fn find_kp_breakpoints<'a, T: Iterator<Item = &'a WordInfo<'a>>>(
     iter: T,
     args: &BreakArgs<'a>,
diff --git a/src/uu/fmt/src/parasplit.rs b/src/uu/fmt/src/parasplit.rs
index c60be0a47..a2d70b088 100644
--- a/src/uu/fmt/src/parasplit.rs
+++ b/src/uu/fmt/src/parasplit.rs
@@ -275,6 +275,7 @@ impl<'a> ParagraphStream<'a> {
 impl<'a> Iterator for ParagraphStream<'a> {
     type Item = Result<Paragraph, String>;
 
+    #[allow(clippy::cognitive_complexity)]
     fn next(&mut self) -> Option<Result<Paragraph, String>> {
         // return a NoFormatLine in an Err; it should immediately be output
         let noformat = match self.lines.peek() {
@@ -580,11 +581,11 @@ impl<'a> Iterator for WordSplit<'a> {
         // points to whitespace character OR end of string
         let mut word_nchars = 0;
         self.position = match self.string[word_start..].find(|x: char| {
-            if !x.is_whitespace() {
+            if x.is_whitespace() {
+                true
+            } else {
                 word_nchars += char_width(x);
                 false
-            } else {
-                true
             }
         }) {
             None => self.length,
diff --git a/src/uu/fold/Cargo.toml b/src/uu/fold/Cargo.toml
index d3e4417e1..f0377c5ab 100644
--- a/src/uu/fold/Cargo.toml
+++ b/src/uu/fold/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_fold"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "fold ~ (uutils) wrap each line of input"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/fold.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "fold"
diff --git a/src/uu/fold/fold.md b/src/uu/fold/fold.md
new file mode 100644
index 000000000..13062c858
--- /dev/null
+++ b/src/uu/fold/fold.md
@@ -0,0 +1,8 @@
+# fold
+
+```
+fold [OPTION]... [FILE]...
+```
+
+Writes each file (or standard input if no files are given)
+to standard output whilst breaking long lines
diff --git a/src/uu/fold/src/fold.rs b/src/uu/fold/src/fold.rs
index dee30b258..d53573d82 100644
--- a/src/uu/fold/src/fold.rs
+++ b/src/uu/fold/src/fold.rs
@@ -13,13 +13,12 @@ use std::io::{stdin, BufRead, BufReader, Read};
 use std::path::Path;
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult, USimpleError};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
 
 const TAB_WIDTH: usize = 8;
 
-static USAGE: &str = "{} [OPTION]... [FILE]...";
-static ABOUT: &str = "Writes each file (or standard input if no files are given)
- to standard output whilst breaking long lines";
+const USAGE: &str = help_usage!("fold.md");
+const ABOUT: &str = help_about!("fold.md");
 
 mod options {
     pub const BYTES: &str = "bytes";
@@ -208,6 +207,7 @@ fn fold_file_bytewise<T: Read>(mut file: BufReader<T>, spaces: bool, width: usiz
 ///
 /// If `spaces` is `true`, attempt to break lines at whitespace boundaries.
 #[allow(unused_assignments)]
+#[allow(clippy::cognitive_complexity)]
 fn fold_file<T: Read>(mut file: BufReader<T>, spaces: bool, width: usize) -> UResult<()> {
     let mut line = String::new();
     let mut output = String::new();
diff --git a/src/uu/groups/Cargo.toml b/src/uu/groups/Cargo.toml
index 49034a4b3..a33b34f76 100644
--- a/src/uu/groups/Cargo.toml
+++ b/src/uu/groups/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_groups"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "groups ~ (uutils) display group memberships for USERNAME"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/groups.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true, features=["entries", "process"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["entries", "process"] }
 
 [[bin]]
 name = "groups"
diff --git a/src/uu/groups/groups.md b/src/uu/groups/groups.md
new file mode 100644
index 000000000..1d11d5e46
--- /dev/null
+++ b/src/uu/groups/groups.md
@@ -0,0 +1,8 @@
+# groups
+
+```
+groups [OPTION]... [USERNAME]...
+```
+
+Print group memberships for each `USERNAME` or, if no `USERNAME` is specified, for
+the current process (which may differ if the groups data‐base has changed).
diff --git a/src/uu/groups/src/groups.rs b/src/uu/groups/src/groups.rs
index c866d0e1b..dd1cd9b04 100644
--- a/src/uu/groups/src/groups.rs
+++ b/src/uu/groups/src/groups.rs
@@ -21,7 +21,7 @@ use uucore::{
     display::Quotable,
     entries::{get_groups_gnu, gid2grp, Locate, Passwd},
     error::{UError, UResult},
-    format_usage, show,
+    format_usage, help_about, help_usage, show,
 };
 
 use clap::{crate_version, Arg, ArgAction, Command};
@@ -29,11 +29,8 @@ use clap::{crate_version, Arg, ArgAction, Command};
 mod options {
     pub const USERS: &str = "USERNAME";
 }
-static ABOUT: &str = "Print group memberships for each USERNAME or, \
-                      if no USERNAME is specified, for\nthe current process \
-                      (which may differ if the groups data‐base has changed).";
-
-const USAGE: &str = "{} [OPTION]... [USERNAME]...";
+const ABOUT: &str = help_about!("groups.md");
+const USAGE: &str = help_usage!("groups.md");
 
 #[derive(Debug)]
 enum GroupsError {
diff --git a/src/uu/hashsum/BENCHMARKING.md b/src/uu/hashsum/BENCHMARKING.md
index cef710a19..9508cae1b 100644
--- a/src/uu/hashsum/BENCHMARKING.md
+++ b/src/uu/hashsum/BENCHMARKING.md
@@ -1,9 +1,11 @@
-## Benchmarking hashsum
+# Benchmarking hashsum
 
-### To bench blake2
+## To bench blake2
 
-Taken from: https://github.com/uutils/coreutils/pull/2296
+Taken from: <https://github.com/uutils/coreutils/pull/2296>
 
 With a large file:
-$ hyperfine "./target/release/coreutils hashsum --b2sum large-file" "b2sum large-file"
 
+```shell
+hyperfine "./target/release/coreutils hashsum --b2sum large-file" "b2sum large-file"
+```
diff --git a/src/uu/hashsum/Cargo.toml b/src/uu/hashsum/Cargo.toml
index f335211b8..0a12254d0 100644
--- a/src/uu/hashsum/Cargo.toml
+++ b/src/uu/hashsum/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_hashsum"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "hashsum ~ (uutils) display or check input digests"
@@ -15,11 +15,11 @@ edition = "2021"
 path = "src/hashsum.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true }
-memchr = { workspace=true }
-regex = { workspace=true }
-hex = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["sum"] }
+memchr = { workspace = true }
+regex = { workspace = true }
+hex = { workspace = true }
 
 [[bin]]
 name = "hashsum"
diff --git a/src/uu/hashsum/hashsum.md b/src/uu/hashsum/hashsum.md
new file mode 100644
index 000000000..a632eedf3
--- /dev/null
+++ b/src/uu/hashsum/hashsum.md
@@ -0,0 +1,7 @@
+# hashsum
+
+```
+hashsum [OPTIONS] [FILE]...
+```
+
+Compute and check message digests.
diff --git a/src/uu/hashsum/src/hashsum.rs b/src/uu/hashsum/src/hashsum.rs
index c49c530e4..7b571efcd 100644
--- a/src/uu/hashsum/src/hashsum.rs
+++ b/src/uu/hashsum/src/hashsum.rs
@@ -14,6 +14,7 @@ use clap::crate_version;
 use clap::ArgAction;
 use clap::{Arg, ArgMatches, Command};
 use hex::encode;
+use regex::Captures;
 use regex::Regex;
 use std::cmp::Ordering;
 use std::error::Error;
@@ -29,8 +30,11 @@ use uucore::sum::{
     Sha3_384, Sha3_512, Sha512, Shake128, Shake256,
 };
 use uucore::{crash, display::Quotable, show_warning};
+use uucore::{format_usage, help_about, help_usage};
 
 const NAME: &str = "hashsum";
+const ABOUT: &str = help_about!("hashsum.md");
+const USAGE: &str = help_usage!("hashsum.md");
 
 struct Options {
     algoname: &'static str,
@@ -44,52 +48,143 @@ struct Options {
     strict: bool,
     warn: bool,
     output_bits: usize,
+    zero: bool,
 }
 
-#[allow(clippy::cognitive_complexity)]
+/// Creates a Blake2b hasher instance based on the specified length argument.
+///
+/// # Returns
+///
+/// Returns a tuple containing the algorithm name, the hasher instance, and the output length in bits.
+///
+/// # Panics
+///
+/// Panics if the length is not a multiple of 8 or if it is greater than 512.
+fn create_blake2b(matches: &ArgMatches) -> (&'static str, Box<dyn Digest>, usize) {
+    match matches.get_one::<usize>("length") {
+        Some(0) | None => ("BLAKE2", Box::new(Blake2b::new()) as Box<dyn Digest>, 512),
+        Some(length_in_bits) => {
+            if *length_in_bits > 512 {
+                crash!(1, "Invalid length (maximum digest length is 512 bits)")
+            }
+
+            if length_in_bits % 8 == 0 {
+                let length_in_bytes = length_in_bits / 8;
+                (
+                    "BLAKE2",
+                    Box::new(Blake2b::with_output_bytes(length_in_bytes)),
+                    *length_in_bits,
+                )
+            } else {
+                crash!(1, "Invalid length (expected a multiple of 8)")
+            }
+        }
+    }
+}
+
+/// Creates a SHA3 hasher instance based on the specified bits argument.
+///
+/// # Returns
+///
+/// Returns a tuple containing the algorithm name, the hasher instance, and the output length in bits.
+///
+/// # Panics
+///
+/// Panics if an unsupported output size is provided, or if the `--bits` flag is missing.
+fn create_sha3(matches: &ArgMatches) -> (&'static str, Box<dyn Digest>, usize) {
+    match matches.get_one::<usize>("bits") {
+        Some(224) => (
+            "SHA3-224",
+            Box::new(Sha3_224::new()) as Box<dyn Digest>,
+            224,
+        ),
+        Some(256) => (
+            "SHA3-256",
+            Box::new(Sha3_256::new()) as Box<dyn Digest>,
+            256,
+        ),
+        Some(384) => (
+            "SHA3-384",
+            Box::new(Sha3_384::new()) as Box<dyn Digest>,
+            384,
+        ),
+        Some(512) => (
+            "SHA3-512",
+            Box::new(Sha3_512::new()) as Box<dyn Digest>,
+            512,
+        ),
+        Some(_) => crash!(
+            1,
+            "Invalid output size for SHA3 (expected 224, 256, 384, or 512)"
+        ),
+        None => crash!(1, "--bits required for SHA3"),
+    }
+}
+
+/// Creates a SHAKE-128 hasher instance based on the specified bits argument.
+///
+/// # Returns
+///
+/// Returns a tuple containing the algorithm name, the hasher instance, and the output length in bits.
+///
+/// # Panics
+///
+/// Panics if the `--bits` flag is missing.
+fn create_shake128(matches: &ArgMatches) -> (&'static str, Box<dyn Digest>, usize) {
+    match matches.get_one::<usize>("bits") {
+        Some(bits) => (
+            "SHAKE128",
+            Box::new(Shake128::new()) as Box<dyn Digest>,
+            *bits,
+        ),
+        None => crash!(1, "--bits required for SHAKE-128"),
+    }
+}
+
+/// Creates a SHAKE-256 hasher instance based on the specified bits argument.
+///
+/// # Returns
+///
+/// Returns a tuple containing the algorithm name, the hasher instance, and the output length in bits.
+///
+/// # Panics
+///
+/// Panics if the `--bits` flag is missing.
+fn create_shake256(matches: &ArgMatches) -> (&'static str, Box<dyn Digest>, usize) {
+    match matches.get_one::<usize>("bits") {
+        Some(bits) => (
+            "SHAKE256",
+            Box::new(Shake256::new()) as Box<dyn Digest>,
+            *bits,
+        ),
+        None => crash!(1, "--bits required for SHAKE-256"),
+    }
+}
+
+/// Detects the hash algorithm from the program name or command-line arguments.
+///
+/// # Arguments
+///
+/// * `program` - A string slice containing the program name.
+/// * `matches` - A reference to the `ArgMatches` object containing the command-line arguments.
+///
+/// # Returns
+///
+/// Returns a tuple containing the algorithm name, the hasher instance, and the output length in bits.
 fn detect_algo(
     program: &str,
     matches: &ArgMatches,
 ) -> (&'static str, Box<dyn Digest + 'static>, usize) {
-    let mut alg: Option<Box<dyn Digest>> = None;
-    let mut name: &'static str = "";
-    let mut output_bits = 0;
-    match program {
+    let (name, alg, output_bits) = match program {
         "md5sum" => ("MD5", Box::new(Md5::new()) as Box<dyn Digest>, 128),
         "sha1sum" => ("SHA1", Box::new(Sha1::new()) as Box<dyn Digest>, 160),
         "sha224sum" => ("SHA224", Box::new(Sha224::new()) as Box<dyn Digest>, 224),
         "sha256sum" => ("SHA256", Box::new(Sha256::new()) as Box<dyn Digest>, 256),
         "sha384sum" => ("SHA384", Box::new(Sha384::new()) as Box<dyn Digest>, 384),
         "sha512sum" => ("SHA512", Box::new(Sha512::new()) as Box<dyn Digest>, 512),
-        "b2sum" => ("BLAKE2", Box::new(Blake2b::new()) as Box<dyn Digest>, 512),
+        "b2sum" => create_blake2b(matches),
         "b3sum" => ("BLAKE3", Box::new(Blake3::new()) as Box<dyn Digest>, 256),
-        "sha3sum" => match matches.get_one::<usize>("bits") {
-            Some(224) => (
-                "SHA3-224",
-                Box::new(Sha3_224::new()) as Box<dyn Digest>,
-                224,
-            ),
-            Some(256) => (
-                "SHA3-256",
-                Box::new(Sha3_256::new()) as Box<dyn Digest>,
-                256,
-            ),
-            Some(384) => (
-                "SHA3-384",
-                Box::new(Sha3_384::new()) as Box<dyn Digest>,
-                384,
-            ),
-            Some(512) => (
-                "SHA3-512",
-                Box::new(Sha3_512::new()) as Box<dyn Digest>,
-                512,
-            ),
-            Some(_) => crash!(
-                1,
-                "Invalid output size for SHA3 (expected 224, 256, 384, or 512)"
-            ),
-            None => crash!(1, "--bits required for SHA3"),
-        },
+        "sha3sum" => create_sha3(matches),
         "sha3-224sum" => (
             "SHA3-224",
             Box::new(Sha3_224::new()) as Box<dyn Digest>,
@@ -110,114 +205,95 @@ fn detect_algo(
             Box::new(Sha3_512::new()) as Box<dyn Digest>,
             512,
         ),
-        "shake128sum" => match matches.get_one::<usize>("bits") {
-            Some(bits) => (
-                "SHAKE128",
-                Box::new(Shake128::new()) as Box<dyn Digest>,
-                *bits,
-            ),
+        "shake128sum" => create_shake128(matches),
+        "shake256sum" => create_shake256(matches),
+        _ => create_algorithm_from_flags(matches),
+    };
+    (name, alg, output_bits)
+}
+
+/// Creates a hasher instance based on the command-line flags.
+///
+/// # Arguments
+///
+/// * `matches` - A reference to the `ArgMatches` object containing the command-line arguments.
+///
+/// # Returns
+///
+/// Returns a tuple containing the algorithm name, the hasher instance, and the output length in bits.
+///
+/// # Panics
+///
+/// Panics if multiple hash algorithms are specified or if a required flag is missing.
+#[allow(clippy::cognitive_complexity)]
+fn create_algorithm_from_flags(matches: &ArgMatches) -> (&'static str, Box<dyn Digest>, usize) {
+    let mut alg: Option<Box<dyn Digest>> = None;
+    let mut name: &'static str = "";
+    let mut output_bits = 0;
+    let mut set_or_crash = |n, val, bits| {
+        if alg.is_some() {
+            crash!(1, "You cannot combine multiple hash algorithms!");
+        };
+        name = n;
+        alg = Some(val);
+        output_bits = bits;
+    };
+
+    if matches.get_flag("md5") {
+        set_or_crash("MD5", Box::new(Md5::new()), 128);
+    }
+    if matches.get_flag("sha1") {
+        set_or_crash("SHA1", Box::new(Sha1::new()), 160);
+    }
+    if matches.get_flag("sha224") {
+        set_or_crash("SHA224", Box::new(Sha224::new()), 224);
+    }
+    if matches.get_flag("sha256") {
+        set_or_crash("SHA256", Box::new(Sha256::new()), 256);
+    }
+    if matches.get_flag("sha384") {
+        set_or_crash("SHA384", Box::new(Sha384::new()), 384);
+    }
+    if matches.get_flag("sha512") {
+        set_or_crash("SHA512", Box::new(Sha512::new()), 512);
+    }
+    if matches.get_flag("b2sum") {
+        set_or_crash("BLAKE2", Box::new(Blake2b::new()), 512);
+    }
+    if matches.get_flag("b3sum") {
+        set_or_crash("BLAKE3", Box::new(Blake3::new()), 256);
+    }
+    if matches.get_flag("sha3") {
+        let (n, val, bits) = create_sha3(matches);
+        set_or_crash(n, val, bits);
+    }
+    if matches.get_flag("sha3-224") {
+        set_or_crash("SHA3-224", Box::new(Sha3_224::new()), 224);
+    }
+    if matches.get_flag("sha3-256") {
+        set_or_crash("SHA3-256", Box::new(Sha3_256::new()), 256);
+    }
+    if matches.get_flag("sha3-384") {
+        set_or_crash("SHA3-384", Box::new(Sha3_384::new()), 384);
+    }
+    if matches.get_flag("sha3-512") {
+        set_or_crash("SHA3-512", Box::new(Sha3_512::new()), 512);
+    }
+    if matches.get_flag("shake128") {
+        match matches.get_one::<usize>("bits") {
+            Some(bits) => set_or_crash("SHAKE128", Box::new(Shake128::new()), *bits),
             None => crash!(1, "--bits required for SHAKE-128"),
-        },
-        "shake256sum" => match matches.get_one::<usize>("bits") {
-            Some(bits) => (
-                "SHAKE256",
-                Box::new(Shake256::new()) as Box<dyn Digest>,
-                *bits,
-            ),
-            None => crash!(1, "--bits required for SHAKE-256"),
-        },
-        _ => {
-            {
-                let mut set_or_crash = |n, val, bits| {
-                    if alg.is_some() {
-                        crash!(1, "You cannot combine multiple hash algorithms!")
-                    };
-                    name = n;
-                    alg = Some(val);
-                    output_bits = bits;
-                };
-                if matches.get_flag("md5") {
-                    set_or_crash("MD5", Box::new(Md5::new()), 128);
-                }
-                if matches.get_flag("sha1") {
-                    set_or_crash("SHA1", Box::new(Sha1::new()), 160);
-                }
-                if matches.get_flag("sha224") {
-                    set_or_crash("SHA224", Box::new(Sha224::new()), 224);
-                }
-                if matches.get_flag("sha256") {
-                    set_or_crash("SHA256", Box::new(Sha256::new()), 256);
-                }
-                if matches.get_flag("sha384") {
-                    set_or_crash("SHA384", Box::new(Sha384::new()), 384);
-                }
-                if matches.get_flag("sha512") {
-                    set_or_crash("SHA512", Box::new(Sha512::new()), 512);
-                }
-                if matches.get_flag("b2sum") {
-                    set_or_crash("BLAKE2", Box::new(Blake2b::new()), 512);
-                }
-                if matches.get_flag("b3sum") {
-                    set_or_crash("BLAKE3", Box::new(Blake3::new()), 256);
-                }
-                if matches.get_flag("sha3") {
-                    match matches.get_one::<usize>("bits") {
-                        Some(224) => set_or_crash(
-                            "SHA3-224",
-                            Box::new(Sha3_224::new()) as Box<dyn Digest>,
-                            224,
-                        ),
-                        Some(256) => set_or_crash(
-                            "SHA3-256",
-                            Box::new(Sha3_256::new()) as Box<dyn Digest>,
-                            256,
-                        ),
-                        Some(384) => set_or_crash(
-                            "SHA3-384",
-                            Box::new(Sha3_384::new()) as Box<dyn Digest>,
-                            384,
-                        ),
-                        Some(512) => set_or_crash(
-                            "SHA3-512",
-                            Box::new(Sha3_512::new()) as Box<dyn Digest>,
-                            512,
-                        ),
-                        Some(_) => crash!(
-                            1,
-                            "Invalid output size for SHA3 (expected 224, 256, 384, or 512)"
-                        ),
-                        None => crash!(1, "--bits required for SHA3"),
-                    }
-                }
-                if matches.get_flag("sha3-224") {
-                    set_or_crash("SHA3-224", Box::new(Sha3_224::new()), 224);
-                }
-                if matches.get_flag("sha3-256") {
-                    set_or_crash("SHA3-256", Box::new(Sha3_256::new()), 256);
-                }
-                if matches.get_flag("sha3-384") {
-                    set_or_crash("SHA3-384", Box::new(Sha3_384::new()), 384);
-                }
-                if matches.get_flag("sha3-512") {
-                    set_or_crash("SHA3-512", Box::new(Sha3_512::new()), 512);
-                }
-                if matches.get_flag("shake128") {
-                    match matches.get_one::<usize>("bits") {
-                        Some(bits) => set_or_crash("SHAKE128", Box::new(Shake128::new()), *bits),
-                        None => crash!(1, "--bits required for SHAKE-128"),
-                    }
-                }
-                if matches.get_flag("shake256") {
-                    match matches.get_one::<usize>("bits") {
-                        Some(bits) => set_or_crash("SHAKE256", Box::new(Shake256::new()), *bits),
-                        None => crash!(1, "--bits required for SHAKE-256"),
-                    }
-                }
-            }
-            let alg = alg.unwrap_or_else(|| crash!(1, "You must specify hash algorithm!"));
-            (name, alg, output_bits)
         }
     }
+    if matches.get_flag("shake256") {
+        match matches.get_one::<usize>("bits") {
+            Some(bits) => set_or_crash("SHAKE256", Box::new(Shake256::new()), *bits),
+            None => crash!(1, "--bits required for SHAKE-256"),
+        }
+    }
+
+    let alg = alg.unwrap_or_else(|| crash!(1, "You must specify hash algorithm!"));
+    (name, alg, output_bits)
 }
 
 // TODO: return custom error type
@@ -266,6 +342,7 @@ pub fn uumain(mut args: impl uucore::Args) -> UResult<()> {
     let quiet = matches.get_flag("quiet") || status;
     let strict = matches.get_flag("strict");
     let warn = matches.get_flag("warn") && !status;
+    let zero = matches.get_flag("zero");
 
     let opts = Options {
         algoname: name,
@@ -279,6 +356,7 @@ pub fn uumain(mut args: impl uucore::Args) -> UResult<()> {
         quiet,
         strict,
         warn,
+        zero,
     };
 
     match matches.get_many::<OsString>("FILE") {
@@ -298,7 +376,8 @@ pub fn uu_app_common() -> Command {
     const TEXT_HELP: &str = "read in text mode (default)";
     Command::new(uucore::util_name())
         .version(crate_version!())
-        .about("Compute and check message digests.")
+        .about(ABOUT)
+        .override_usage(format_usage(USAGE))
         .infer_long_args(true)
         .arg(
             Arg::new("binary")
@@ -355,6 +434,13 @@ pub fn uu_app_common() -> Command {
                 .help("warn about improperly formatted checksum lines")
                 .action(ArgAction::SetTrue),
         )
+        .arg(
+            Arg::new("zero")
+                .short('z')
+                .long("zero")
+                .help("end each output line with NUL, not newline")
+                .action(ArgAction::SetTrue),
+        )
         .arg(
             Arg::new("FILE")
                 .index(1)
@@ -365,6 +451,21 @@ pub fn uu_app_common() -> Command {
         )
 }
 
+pub fn uu_app_length() -> Command {
+    uu_app_opt_length(uu_app_common())
+}
+
+fn uu_app_opt_length(command: Command) -> Command {
+    command.arg(
+        Arg::new("length")
+            .short('l')
+            .long("length")
+            .help("digest length in bits; must not exceed the max for the blake2 algorithm (512) and must be a multiple of 8")
+            .value_name("BITS")
+            .value_parser(parse_bit_num),
+    )
+}
+
 pub fn uu_app_b3sum() -> Command {
     uu_app_b3sum_opts(uu_app_common())
 }
@@ -440,7 +541,7 @@ fn uu_app(binary_name: &str) -> Command {
             uu_app_common()
         }
         // b2sum supports the md5sum options plus -l/--length.
-        "b2sum" => uu_app_common(), // TODO: Implement -l/--length
+        "b2sum" => uu_app_length(),
         // These have never been part of GNU Coreutils, but can function with the same
         // options as md5sum.
         "sha3-224sum" | "sha3-256sum" | "sha3-384sum" | "sha3-512sum" => uu_app_common(),
@@ -504,22 +605,65 @@ where
             // regular expression, otherwise we use the `{n}` modifier,
             // where `n` is the number of bytes.
             let bytes = options.digest.output_bits() / 4;
-            let modifier = if bytes > 0 {
+            let bytes_marker = if bytes > 0 {
                 format!("{{{bytes}}}")
             } else {
                 "+".to_string()
             };
-            let gnu_re = Regex::new(&format!(
-                r"^(?P<digest>[a-fA-F0-9]{modifier}) (?P<binary>[ \*])(?P<fileName>.*)",
-            ))
-            .map_err(|_| HashsumError::InvalidRegex)?;
+            // BSD reversed mode format is similar to the default mode, but doesn’t use a character to distinguish binary and text modes.
+            let mut bsd_reversed = None;
+
+            /// Creates a Regex for parsing lines based on the given format.
+            /// The default value of `gnu_re` created with this function has to be recreated
+            /// after the initial line has been parsed, as this line dictates the format
+            /// for the rest of them, and mixing of formats is disallowed.
+            fn gnu_re_template(
+                bytes_marker: &str,
+                format_marker: &str,
+            ) -> Result<Regex, HashsumError> {
+                Regex::new(&format!(
+                    r"^(?P<digest>[a-fA-F0-9]{bytes_marker}) {format_marker}(?P<fileName>.*)"
+                ))
+                .map_err(|_| HashsumError::InvalidRegex)
+            }
+            let mut gnu_re = gnu_re_template(&bytes_marker, r"(?P<binary>[ \*])?")?;
             let bsd_re = Regex::new(&format!(
                 r"^{algorithm} \((?P<fileName>.*)\) = (?P<digest>[a-fA-F0-9]{digest_size})",
                 algorithm = options.algoname,
-                digest_size = modifier,
+                digest_size = bytes_marker,
             ))
             .map_err(|_| HashsumError::InvalidRegex)?;
 
+            fn handle_captures(
+                caps: &Captures,
+                bytes_marker: &str,
+                bsd_reversed: &mut Option<bool>,
+                gnu_re: &mut Regex,
+            ) -> Result<(String, String, bool), HashsumError> {
+                if bsd_reversed.is_none() {
+                    let is_bsd_reversed = caps.name("binary").is_none();
+                    let format_marker = if is_bsd_reversed {
+                        ""
+                    } else {
+                        r"(?P<binary>[ \*])"
+                    }
+                    .to_string();
+
+                    *bsd_reversed = Some(is_bsd_reversed);
+                    *gnu_re = gnu_re_template(bytes_marker, &format_marker)?;
+                }
+
+                Ok((
+                    caps.name("fileName").unwrap().as_str().to_string(),
+                    caps.name("digest").unwrap().as_str().to_ascii_lowercase(),
+                    if *bsd_reversed == Some(false) {
+                        caps.name("binary").unwrap().as_str() == "*"
+                    } else {
+                        false
+                    },
+                ))
+            }
+
             let buffer = file;
             for (i, maybe_line) in buffer.lines().enumerate() {
                 let line = match maybe_line {
@@ -527,14 +671,12 @@ where
                     Err(e) => return Err(e.map_err_context(|| "failed to read file".to_string())),
                 };
                 let (ck_filename, sum, binary_check) = match gnu_re.captures(&line) {
-                    Some(caps) => (
-                        caps.name("fileName").unwrap().as_str(),
-                        caps.name("digest").unwrap().as_str().to_ascii_lowercase(),
-                        caps.name("binary").unwrap().as_str() == "*",
-                    ),
+                    Some(caps) => {
+                        handle_captures(&caps, &bytes_marker, &mut bsd_reversed, &mut gnu_re)?
+                    }
                     None => match bsd_re.captures(&line) {
                         Some(caps) => (
-                            caps.name("fileName").unwrap().as_str(),
+                            caps.name("fileName").unwrap().as_str().to_string(),
                             caps.name("digest").unwrap().as_str().to_ascii_lowercase(),
                             true,
                         ),
@@ -555,7 +697,7 @@ where
                         }
                     },
                 };
-                let f = match File::open(ck_filename) {
+                let f = match File::open(ck_filename.clone()) {
                     Err(_) => {
                         failed_open_file += 1;
                         println!(
@@ -606,9 +748,11 @@ where
             )
             .map_err_context(|| "failed to read input".to_string())?;
             if options.tag {
-                println!("{} ({}) = {}", options.algoname, filename.display(), sum);
+                println!("{} ({:?}) = {}", options.algoname, filename.display(), sum);
             } else if options.nonames {
                 println!("{sum}");
+            } else if options.zero {
+                print!("{} {}{}\0", sum, binary_marker, filename.display());
             } else {
                 println!("{} {}{}", sum, binary_marker, filename.display());
             }
diff --git a/src/uu/head/BENCHMARKING.md b/src/uu/head/BENCHMARKING.md
index 29ce4c46b..d751d1f7f 100644
--- a/src/uu/head/BENCHMARKING.md
+++ b/src/uu/head/BENCHMARKING.md
@@ -5,23 +5,31 @@ GNU version of `head`, you can use a benchmarking tool like
 [hyperfine][0]. On Ubuntu 18.04 or later, you can install `hyperfine` by
 running
 
-    sudo apt-get install hyperfine
+```shell
+sudo apt-get install hyperfine
+```
 
 Next, build the `head` binary under the release profile:
 
-    cargo build --release -p uu_head
+```shell
+cargo build --release -p uu_head
+```
 
 Now, get a text file to test `head` on. I used the *Complete Works of
 William Shakespeare*, which is in the public domain in the United States
 and most other parts of the world.
 
-    wget -O shakespeare.txt https://www.gutenberg.org/files/100/100-0.txt
+```shell
+wget -O shakespeare.txt https://www.gutenberg.org/files/100/100-0.txt
+```
 
 This particular file has about 170,000 lines, each of which is no longer
 than 96 characters:
 
-    $ wc -lL shakespeare.txt
-    170592      96 shakespeare.txt
+```shell
+$ wc -lL shakespeare.txt
+170592      96 shakespeare.txt
+```
 
 You could use files of different shapes and sizes to test the
 performance of `head` in different situations. For a larger file, you
@@ -32,9 +40,11 @@ contains about 130 million lines.
 Finally, you can compare the performance of the two versions of `head`
 by running, for example,
 
-    hyperfine \
-        "head -n 100000 shakespeare.txt" \
-        "target/release/head -n 100000 shakespeare.txt"
+```shell
+hyperfine \
+    "head -n 100000 shakespeare.txt" \
+    "target/release/head -n 100000 shakespeare.txt"
+```
 
 [0]: https://github.com/sharkdp/hyperfine
 [1]: https://www.wikidata.org/wiki/Wikidata:Database_download
diff --git a/src/uu/head/Cargo.toml b/src/uu/head/Cargo.toml
index c631cf331..6b53b1526 100644
--- a/src/uu/head/Cargo.toml
+++ b/src/uu/head/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_head"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "head ~ (uutils) display the first lines of input"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/head.rs"
 
 [dependencies]
-clap = { workspace=true }
-memchr = { workspace=true }
-uucore = { workspace=true, features=["ringbuffer", "lines"] }
+clap = { workspace = true }
+memchr = { workspace = true }
+uucore = { workspace = true, features = ["ringbuffer", "lines"] }
 
 [[bin]]
 name = "head"
diff --git a/src/uu/head/head.md b/src/uu/head/head.md
new file mode 100644
index 000000000..476f3affc
--- /dev/null
+++ b/src/uu/head/head.md
@@ -0,0 +1,11 @@
+# head
+
+```
+head [FLAG]... [FILE]...
+```
+
+Print the first 10 lines of each `FILE` to standard output.
+With more than one `FILE`, precede each with a header giving the file name.
+With no `FILE`, or when `FILE` is `-`, read standard input.
+
+Mandatory arguments to long flags are mandatory for short flags too.
diff --git a/src/uu/head/src/head.rs b/src/uu/head/src/head.rs
index 48debc81f..a336c91d4 100644
--- a/src/uu/head/src/head.rs
+++ b/src/uu/head/src/head.rs
@@ -11,21 +11,15 @@ use std::io::{self, BufWriter, ErrorKind, Read, Seek, SeekFrom, Write};
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UError, UResult, USimpleError};
 use uucore::lines::lines;
-use uucore::{format_usage, show};
+use uucore::{format_usage, help_about, help_usage, show};
 
 const BUF_SIZE: usize = 65536;
 
 /// The capacity in bytes for buffered writers.
 const BUFWRITER_CAPACITY: usize = 16_384; // 16 kilobytes
 
-const ABOUT: &str = "\
-                     Print the first 10 lines of each FILE to standard output.\n\
-                     With more than one FILE, precede each with a header giving the file name.\n\
-                     With no FILE, or when FILE is -, read standard input.\n\
-                     \n\
-                     Mandatory arguments to long flags are mandatory for short flags too.\
-                     ";
-const USAGE: &str = "{} [FLAG]... [FILE]...";
+const ABOUT: &str = help_about!("head.md");
+const USAGE: &str = help_usage!("head.md");
 
 mod options {
     pub const BYTES_NAME: &str = "BYTES";
@@ -438,6 +432,7 @@ fn head_file(input: &mut std::fs::File, options: &HeadOptions) -> std::io::Resul
     }
 }
 
+#[allow(clippy::cognitive_complexity)]
 fn uu_head(options: &HeadOptions) -> UResult<()> {
     let mut first = true;
     for file in &options.files {
@@ -627,12 +622,10 @@ mod tests {
     #[test]
     #[cfg(target_os = "linux")]
     fn test_arg_iterate_bad_encoding() {
-        #[allow(clippy::invalid_utf8_in_unchecked)]
-        let invalid = unsafe { std::str::from_utf8_unchecked(b"\x80\x81") };
+        use std::os::unix::ffi::OsStringExt;
+        let invalid = OsString::from_vec(vec![b'\x80', b'\x81']);
         // this arises from a conversion from OsString to &str
-        assert!(
-            arg_iterate(vec![OsString::from("head"), OsString::from(invalid)].into_iter()).is_err()
-        );
+        assert!(arg_iterate(vec![OsString::from("head"), invalid].into_iter()).is_err());
     }
     #[test]
     fn read_early_exit() {
diff --git a/src/uu/head/src/parse.rs b/src/uu/head/src/parse.rs
index cbfc97152..56c359a0c 100644
--- a/src/uu/head/src/parse.rs
+++ b/src/uu/head/src/parse.rs
@@ -13,6 +13,7 @@ pub enum ParseError {
 }
 /// Parses obsolete syntax
 /// head -NUM\[kmzv\] // spell-checker:disable-line
+#[allow(clippy::cognitive_complexity)]
 pub fn parse_obsolete(src: &str) -> Option<Result<impl Iterator<Item = OsString>, ParseError>> {
     let mut chars = src.char_indices();
     if let Some((_, '-')) = chars.next() {
@@ -113,7 +114,13 @@ pub fn parse_num(src: &str) -> Result<(u64, bool), ParseSizeError> {
         return Err(ParseSizeError::ParseFailure(src.to_string()));
     }
 
-    parse_size(size_string).map(|n| (n, all_but_last))
+    // remove leading zeros so that size is interpreted as decimal, not octal
+    let trimmed_string = size_string.trim_start_matches('0');
+    if trimmed_string.is_empty() {
+        Ok((0, all_but_last))
+    } else {
+        parse_size(trimmed_string).map(|n| (n, all_but_last))
+    }
 }
 
 #[cfg(test)]
diff --git a/src/uu/hostid/Cargo.toml b/src/uu/hostid/Cargo.toml
index 7aa28328a..175c31930 100644
--- a/src/uu/hostid/Cargo.toml
+++ b/src/uu/hostid/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_hostid"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "hostid ~ (uutils) display the numeric identifier of the current host"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/hostid.rs"
 
 [dependencies]
-clap = { workspace=true }
-libc = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+libc = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "hostid"
diff --git a/src/uu/hostid/hostid.md b/src/uu/hostid/hostid.md
new file mode 100644
index 000000000..940cf5e5d
--- /dev/null
+++ b/src/uu/hostid/hostid.md
@@ -0,0 +1,7 @@
+# hostid
+
+```
+hostid [options]
+```
+
+Print the numeric identifier (in hexadecimal) for the current host
diff --git a/src/uu/hostid/src/hostid.rs b/src/uu/hostid/src/hostid.rs
index 147c7c548..3657d137a 100644
--- a/src/uu/hostid/src/hostid.rs
+++ b/src/uu/hostid/src/hostid.rs
@@ -9,10 +9,10 @@
 
 use clap::{crate_version, Command};
 use libc::c_long;
-use uucore::{error::UResult, format_usage};
+use uucore::{error::UResult, format_usage, help_about, help_usage};
 
-const USAGE: &str = "{} [options]";
-const ABOUT: &str = "Print the numeric identifier (in hexadecimal) for the current host";
+const USAGE: &str = help_usage!("hostid.md");
+const ABOUT: &str = help_about!("hostid.md");
 
 // currently rust libc interface doesn't include gethostid
 extern "C" {
diff --git a/src/uu/hostname/Cargo.toml b/src/uu/hostname/Cargo.toml
index e57e5c364..d94a703eb 100644
--- a/src/uu/hostname/Cargo.toml
+++ b/src/uu/hostname/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_hostname"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "hostname ~ (uutils) display or set the host name of the current host"
@@ -15,12 +15,15 @@ edition = "2021"
 path = "src/hostname.rs"
 
 [dependencies]
-clap = { workspace=true }
+clap = { workspace = true }
 hostname = { version = "0.3", features = ["set"] }
-uucore = { workspace=true, features=["wide"] }
+uucore = { workspace = true, features = ["wide"] }
 
 [target.'cfg(target_os = "windows")'.dependencies]
-windows-sys = { workspace=true, features = ["Win32_Networking_WinSock", "Win32_Foundation"] }
+windows-sys = { workspace = true, features = [
+  "Win32_Networking_WinSock",
+  "Win32_Foundation",
+] }
 
 [[bin]]
 name = "hostname"
diff --git a/src/uu/hostname/hostname.md b/src/uu/hostname/hostname.md
new file mode 100644
index 000000000..f9e852c4b
--- /dev/null
+++ b/src/uu/hostname/hostname.md
@@ -0,0 +1,7 @@
+# hostname
+
+```
+hostname [OPTION]... [HOSTNAME]
+```
+
+Display or set the system's host name.
diff --git a/src/uu/hostname/src/hostname.rs b/src/uu/hostname/src/hostname.rs
index 03e9fe2e0..83a22a82f 100644
--- a/src/uu/hostname/src/hostname.rs
+++ b/src/uu/hostname/src/hostname.rs
@@ -16,11 +16,11 @@ use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
 
 use uucore::{
     error::{FromIo, UResult},
-    format_usage,
+    format_usage, help_about, help_usage,
 };
 
-static ABOUT: &str = "Display or set the system's host name.";
-const USAGE: &str = "{} [OPTION]... [HOSTNAME]";
+const ABOUT: &str = help_about!("hostname.md");
+const USAGE: &str = help_usage!("hostname.md");
 
 static OPT_DOMAIN: &str = "domain";
 static OPT_IP_ADDRESS: &str = "ip-address";
@@ -41,10 +41,10 @@ mod wsa {
             let mut data = std::mem::MaybeUninit::<WSADATA>::uninit();
             WSAStartup(0x0202, data.as_mut_ptr())
         };
-        if err != 0 {
-            Err(io::Error::from_raw_os_error(err))
-        } else {
+        if err == 0 {
             Ok(WsaHandle(()))
+        } else {
+            Err(io::Error::from_raw_os_error(err))
         }
     }
 
diff --git a/src/uu/id/Cargo.toml b/src/uu/id/Cargo.toml
index 3a157ada4..4d32f6e59 100644
--- a/src/uu/id/Cargo.toml
+++ b/src/uu/id/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_id"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "id ~ (uutils) display user and group information for USER"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/id.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true, features=["entries", "process"] }
-selinux = { workspace=true, optional=true }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["entries", "process"] }
+selinux = { workspace = true, optional = true }
 
 [[bin]]
 name = "id"
diff --git a/src/uu/id/id.md b/src/uu/id/id.md
new file mode 100644
index 000000000..bb7330314
--- /dev/null
+++ b/src/uu/id/id.md
@@ -0,0 +1,18 @@
+# id
+
+```
+id [OPTION]... [USER]...
+```
+
+Print user and group information for each specified `USER`,
+or (when `USER` omitted) for the current user.
+
+## After help
+
+The id utility displays the user and group names and numeric IDs, of the
+calling process, to the standard output. If the real and effective IDs are
+different, both are displayed, otherwise only the real ID is displayed.
+
+If a user (login name or user ID) is specified, the user and group IDs of
+that user are displayed. In this case, the real and effective IDs are
+assumed to be the same.
diff --git a/src/uu/id/src/id.rs b/src/uu/id/src/id.rs
index 9aa6e2f31..7a8e40059 100644
--- a/src/uu/id/src/id.rs
+++ b/src/uu/id/src/id.rs
@@ -45,7 +45,7 @@ use uucore::error::{set_exit_code, USimpleError};
 pub use uucore::libc;
 use uucore::libc::{getlogin, uid_t};
 use uucore::process::{getegid, geteuid, getgid, getuid};
-use uucore::{format_usage, show_error};
+use uucore::{format_usage, help_about, help_section, help_usage, show_error};
 
 macro_rules! cstr2cow {
     ($v:expr) => {
@@ -53,9 +53,9 @@ macro_rules! cstr2cow {
     };
 }
 
-static ABOUT: &str = "Print user and group information for each specified USER,
-or (when USER omitted) for the current user.";
-const USAGE: &str = "{} [OPTION]... [USER]...";
+const ABOUT: &str = help_about!("id.md");
+const USAGE: &str = help_usage!("id.md");
+const AFTER_HELP: &str = help_section!("after help", "id.md");
 
 #[cfg(not(feature = "selinux"))]
 static CONTEXT_HELP_TEXT: &str = "print only the security context of the process (not enabled)";
@@ -76,15 +76,6 @@ mod options {
     pub const ARG_USERS: &str = "USER";
 }
 
-fn get_description() -> &'static str {
-    "The id utility displays the user and group names and numeric IDs, of the \
-    calling process, to the standard output. If the real and effective IDs are \
-    different, both are displayed, otherwise only the real ID is displayed.\n\n\
-    If a user (login name or user ID) is specified, the user and group IDs of \
-    that user are displayed. In this case, the real and effective IDs are \
-    assumed to be the same."
-}
-
 struct Ids {
     uid: u32,  // user id
     gid: u32,  // group id
@@ -121,9 +112,7 @@ struct State {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let matches = uu_app()
-        .after_help(get_description())
-        .try_get_matches_from(args)?;
+    let matches = uu_app().after_help(AFTER_HELP).try_get_matches_from(args)?;
 
     let users: Vec<String> = matches
         .get_many::<String>(options::ARG_USERS)
@@ -214,9 +203,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     }
 
     for i in 0..=users.len() {
-        let possible_pw = if !state.user_specified {
-            None
-        } else {
+        let possible_pw = if state.user_specified {
             match Passwd::locate(users[i].as_str()) {
                 Ok(p) => Some(p),
                 Err(_) => {
@@ -229,6 +216,8 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
                     }
                 }
             }
+        } else {
+            None
         };
 
         // GNU's `id` does not support the flags: -p/-P/-A.
diff --git a/src/uu/install/Cargo.toml b/src/uu/install/Cargo.toml
index 0890fe8c9..14be22a97 100644
--- a/src/uu/install/Cargo.toml
+++ b/src/uu/install/Cargo.toml
@@ -1,10 +1,7 @@
 [package]
 name = "uu_install"
-version = "0.0.17"
-authors = [
-    "Ben Eills <ben@beneills.com>",
-    "uutils developers",
-]
+version = "0.0.19"
+authors = ["Ben Eills <ben@beneills.com>", "uutils developers"]
 license = "MIT"
 description = "install ~ (uutils) copy files from SOURCE to DESTINATION (with specified attributes)"
 
@@ -18,14 +15,11 @@ edition = "2021"
 path = "src/install.rs"
 
 [dependencies]
-clap = { workspace=true }
-filetime = { workspace=true }
-file_diff = { workspace=true }
-libc = { workspace=true }
-uucore = { workspace=true, features=["fs", "mode", "perms", "entries"] }
-
-[dev-dependencies]
-time = { workspace=true }
+clap = { workspace = true }
+filetime = { workspace = true }
+file_diff = { workspace = true }
+libc = { workspace = true }
+uucore = { workspace = true, features = ["fs", "mode", "perms", "entries"] }
 
 [[bin]]
 name = "install"
diff --git a/src/uu/install/install.md b/src/uu/install/install.md
new file mode 100644
index 000000000..ac6a70f42
--- /dev/null
+++ b/src/uu/install/install.md
@@ -0,0 +1,8 @@
+# install
+
+```
+install [OPTION]... [FILE]...
+```
+
+Copy SOURCE to DEST or multiple SOURCE(s) to the existing
+DIRECTORY, while setting permission modes and owner/group
diff --git a/src/uu/install/src/install.rs b/src/uu/install/src/install.rs
index c4c8f095b..e0307fe34 100644
--- a/src/uu/install/src/install.rs
+++ b/src/uu/install/src/install.rs
@@ -19,7 +19,7 @@ use uucore::error::{FromIo, UError, UIoError, UResult, UUsageError};
 use uucore::fs::dir_strip_dot_for_creation;
 use uucore::mode::get_umask;
 use uucore::perms::{wrap_chown, Verbosity, VerbosityLevel};
-use uucore::{format_usage, show, show_error, show_if_err, uio_error};
+use uucore::{format_usage, help_about, help_usage, show, show_error, show_if_err, uio_error};
 
 use libc::{getegid, geteuid};
 use std::error::Error;
@@ -144,9 +144,8 @@ impl Behavior {
     }
 }
 
-static ABOUT: &str = "Copy SOURCE to DEST or multiple SOURCE(s) to the existing
- DIRECTORY, while setting permission modes and owner/group";
-const USAGE: &str = "{} [OPTION]... [FILE]...";
+const ABOUT: &str = help_about!("install.md");
+const USAGE: &str = help_usage!("install.md");
 
 static OPT_COMPARE: &str = "compare";
 static OPT_DIRECTORY: &str = "directory";
@@ -400,13 +399,13 @@ fn behavior(matches: &ArgMatches) -> UResult<Behavior> {
         .unwrap_or("")
         .to_string();
 
-    let owner_id = if !owner.is_empty() {
+    let owner_id = if owner.is_empty() {
+        None
+    } else {
         match usr2uid(&owner) {
             Ok(u) => Some(u),
             Err(_) => return Err(InstallError::InvalidUser(owner.clone()).into()),
         }
-    } else {
-        None
     };
 
     let group = matches
@@ -415,13 +414,13 @@ fn behavior(matches: &ArgMatches) -> UResult<Behavior> {
         .unwrap_or("")
         .to_string();
 
-    let group_id = if !group.is_empty() {
+    let group_id = if group.is_empty() {
+        None
+    } else {
         match grp2gid(&group) {
             Ok(g) => Some(g),
             Err(_) => return Err(InstallError::InvalidGroup(group.clone()).into()),
         }
-    } else {
-        None
     };
 
     Ok(Behavior {
@@ -683,6 +682,151 @@ fn chown_optional_user_group(path: &Path, b: &Behavior) -> UResult<()> {
     Ok(())
 }
 
+/// Perform backup before overwriting.
+///
+/// # Parameters
+///
+/// * `to` - The destination file path.
+/// * `b` - The behavior configuration.
+///
+/// # Returns
+///
+/// Returns an Option containing the backup path, or None if backup is not needed.
+///
+fn perform_backup(to: &Path, b: &Behavior) -> UResult<Option<PathBuf>> {
+    if to.exists() {
+        if b.verbose {
+            println!("removed {}", to.quote());
+        }
+        let backup_path = backup_control::get_backup_path(b.backup_mode, to, &b.suffix);
+        if let Some(ref backup_path) = backup_path {
+            // TODO!!
+            if let Err(err) = fs::rename(to, backup_path) {
+                return Err(InstallError::BackupFailed(
+                    to.to_path_buf(),
+                    backup_path.to_path_buf(),
+                    err,
+                )
+                .into());
+            }
+        }
+        Ok(backup_path)
+    } else {
+        Ok(None)
+    }
+}
+
+/// Copy a file from one path to another.
+///
+/// # Parameters
+///
+/// * `from` - The source file path.
+/// * `to` - The destination file path.
+///
+/// # Returns
+///
+/// Returns an empty Result or an error in case of failure.
+///
+fn copy_file(from: &Path, to: &Path) -> UResult<()> {
+    if from.as_os_str() == "/dev/null" {
+        /* workaround a limitation of fs::copy
+         * https://github.com/rust-lang/rust/issues/79390
+         */
+        if let Err(err) = File::create(to) {
+            return Err(
+                InstallError::InstallFailed(from.to_path_buf(), to.to_path_buf(), err).into(),
+            );
+        }
+    } else if let Err(err) = fs::copy(from, to) {
+        return Err(InstallError::InstallFailed(from.to_path_buf(), to.to_path_buf(), err).into());
+    }
+    Ok(())
+}
+
+/// Strip a file using an external program.
+///
+/// # Parameters
+///
+/// * `to` - The destination file path.
+/// * `b` - The behavior configuration.
+///
+/// # Returns
+///
+/// Returns an empty Result or an error in case of failure.
+///
+fn strip_file(to: &Path, b: &Behavior) -> UResult<()> {
+    match process::Command::new(&b.strip_program).arg(to).output() {
+        Ok(o) => {
+            if !o.status.success() {
+                // Follow GNU's behavior: if strip fails, removes the target
+                let _ = fs::remove_file(to);
+                return Err(InstallError::StripProgramFailed(
+                    String::from_utf8(o.stderr).unwrap_or_default(),
+                )
+                .into());
+            }
+        }
+        Err(e) => {
+            // Follow GNU's behavior: if strip fails, removes the target
+            let _ = fs::remove_file(to);
+            return Err(InstallError::StripProgramFailed(e.to_string()).into());
+        }
+    }
+    Ok(())
+}
+
+/// Set ownership and permissions on the destination file.
+///
+/// # Parameters
+///
+/// * `to` - The destination file path.
+/// * `b` - The behavior configuration.
+///
+/// # Returns
+///
+/// Returns an empty Result or an error in case of failure.
+///
+fn set_ownership_and_permissions(to: &Path, b: &Behavior) -> UResult<()> {
+    // Silent the warning as we want to the error message
+    #[allow(clippy::question_mark)]
+    if mode::chmod(to, b.mode()).is_err() {
+        return Err(InstallError::ChmodFailed(to.to_path_buf()).into());
+    }
+
+    chown_optional_user_group(to, b)?;
+
+    Ok(())
+}
+
+/// Preserve timestamps on the destination file.
+///
+/// # Parameters
+///
+/// * `from` - The source file path.
+/// * `to` - The destination file path.
+///
+/// # Returns
+///
+/// Returns an empty Result or an error in case of failure.
+///
+fn preserve_timestamps(from: &Path, to: &Path) -> UResult<()> {
+    let meta = match fs::metadata(from) {
+        Ok(meta) => meta,
+        Err(e) => return Err(InstallError::MetadataFailed(e).into()),
+    };
+
+    let modified_time = FileTime::from_last_modification_time(&meta);
+    let accessed_time = FileTime::from_last_access_time(&meta);
+
+    match set_file_times(to, accessed_time, modified_time) {
+        Ok(_) => Ok(()),
+        Err(e) => {
+            show_error!("{}", e);
+            Ok(())
+        }
+    }
+}
+
 /// Copy one file to a new location, changing metadata.
 ///
 /// Returns a Result type with the Err variant containing the error message.
@@ -696,90 +840,24 @@ fn chown_optional_user_group(path: &Path, b: &Behavior) -> UResult<()> {
 ///
 /// If the copy system call fails, we print a verbose error and return an empty error value.
 ///
-#[allow(clippy::cognitive_complexity)]
 fn copy(from: &Path, to: &Path, b: &Behavior) -> UResult<()> {
     if b.compare && !need_copy(from, to, b)? {
         return Ok(());
     }
     // Declare the path here as we may need it for the verbose output below.
-    let mut backup_path = None;
+    let backup_path = perform_backup(to, b)?;
 
-    // Perform backup, if any, before overwriting 'to'
-    //
-    // The codes actually making use of the backup process don't seem to agree
-    // on how best to approach the issue. (mv and ln, for example)
-    if to.exists() {
-        if b.verbose {
-            println!("removed {}", to.quote());
-        }
-        backup_path = backup_control::get_backup_path(b.backup_mode, to, &b.suffix);
-        if let Some(ref backup_path) = backup_path {
-            // TODO!!
-            if let Err(err) = fs::rename(to, backup_path) {
-                return Err(InstallError::BackupFailed(
-                    to.to_path_buf(),
-                    backup_path.to_path_buf(),
-                    err,
-                )
-                .into());
-            }
-        }
+    copy_file(from, to)?;
+
+    #[cfg(not(windows))]
+    if b.strip {
+        strip_file(to, b)?;
     }
 
-    if from.as_os_str() == "/dev/null" {
-        /* workaround a limitation of fs::copy
-         * https://github.com/rust-lang/rust/issues/79390
-         */
-        if let Err(err) = File::create(to) {
-            return Err(
-                InstallError::InstallFailed(from.to_path_buf(), to.to_path_buf(), err).into(),
-            );
-        }
-    } else if let Err(err) = fs::copy(from, to) {
-        return Err(InstallError::InstallFailed(from.to_path_buf(), to.to_path_buf(), err).into());
-    }
-
-    if b.strip && cfg!(not(windows)) {
-        match process::Command::new(&b.strip_program).arg(to).output() {
-            Ok(o) => {
-                if !o.status.success() {
-                    // Follow GNU's behavior: if strip fails, removes the target
-                    let _ = fs::remove_file(to);
-                    return Err(InstallError::StripProgramFailed(
-                        String::from_utf8(o.stderr).unwrap_or_default(),
-                    )
-                    .into());
-                }
-            }
-            Err(e) => {
-                // Follow GNU's behavior: if strip fails, removes the target
-                let _ = fs::remove_file(to);
-                return Err(InstallError::StripProgramFailed(e.to_string()).into());
-            }
-        }
-    }
-
-    // Silent the warning as we want to the error message
-    #[allow(clippy::question_mark)]
-    if mode::chmod(to, b.mode()).is_err() {
-        return Err(InstallError::ChmodFailed(to.to_path_buf()).into());
-    }
-
-    chown_optional_user_group(to, b)?;
+    set_ownership_and_permissions(to, b)?;
 
     if b.preserve_timestamps {
-        let meta = match fs::metadata(from) {
-            Ok(meta) => meta,
-            Err(e) => return Err(InstallError::MetadataFailed(e).into()),
-        };
-
-        let modified_time = FileTime::from_last_modification_time(&meta);
-        let accessed_time = FileTime::from_last_access_time(&meta);
-
-        match set_file_times(to, accessed_time, modified_time) {
-            Ok(_) => {}
-            Err(e) => show_error!("{}", e),
-        }
+        preserve_timestamps(from, to)?;
     }
 
     if b.verbose {
diff --git a/src/uu/join/BENCHMARKING.md b/src/uu/join/BENCHMARKING.md
index 07a006b2d..80814ed1c 100644
--- a/src/uu/join/BENCHMARKING.md
+++ b/src/uu/join/BENCHMARKING.md
@@ -17,11 +17,14 @@ A benchmark with `-j` and `-i` shows the following time:
 | libc             | 25% | I/O and memory allocation. |
 
 More detailed profiles can be obtained via [flame graphs](https://github.com/flamegraph-rs/flamegraph):
-```
+
+```shell
 cargo flamegraph --bin join --package uu_join -- file1 file2 > /dev/null
 ```
+
 You may need to add the following lines to the top-level `Cargo.toml` to get full stack traces:
-```
+
+```toml
 [profile.release]
 debug = true
 ```
@@ -34,22 +37,26 @@ in practice many CSV datasets will function well after being sorted.
 
 Like most of the utils, the recommended tool for benchmarking is [hyperfine](https://github.com/sharkdp/hyperfine).
 To benchmark your changes:
- - checkout the main branch (without your changes), do a `--release` build, and back up the executable produced at `target/release/join`
- - checkout your working branch (with your changes), do a `--release` build
- - run
-   ```
-   hyperfine -w 5 "/path/to/main/branch/build/join file1 file2" "/path/to/working/branch/build/join file1 file2"
-   ```
-   - you'll likely need to add additional options to both commands, such as a field separator, or if you're benchmarking some particular behavior
-   - you can also optionally benchmark against GNU's join
+
+- checkout the main branch (without your changes), do a `--release` build, and back up the executable produced at `target/release/join`
+- checkout your working branch (with your changes), do a `--release` build
+- run
+
+  ```shell
+  hyperfine -w 5 "/path/to/main/branch/build/join file1 file2" "/path/to/working/branch/build/join file1 file2"
+  ```
+
+  - you'll likely need to add additional options to both commands, such as a field separator, or if you're benchmarking some particular behavior
+  - you can also optionally benchmark against GNU's join
 
 ## What to benchmark
 
 The following options can have a non-trivial impact on performance:
- - `-a`/`-v` if one of the two files has significantly more lines than the other
- - `-j`/`-1`/`-2` cause work to be done to grab the appropriate field
- - `-i` adds a call to `to_ascii_lowercase()` that adds some time for allocating and dropping memory for the lowercase key
- - `--nocheck-order` causes some calls of `Input::compare` to be skipped
+
+- `-a`/`-v` if one of the two files has significantly more lines than the other
+- `-j`/`-1`/`-2` cause work to be done to grab the appropriate field
+- `-i` adds a call to `to_ascii_lowercase()` that adds some time for allocating and dropping memory for the lowercase key
+- `--nocheck-order` causes some calls of `Input::compare` to be skipped
 
 The content of the files being joined has a very significant impact on the performance.
 Things like how long each line is, how many fields there are, how long the key fields are, how many lines there are, how many lines can be joined, and how many lines each line can be joined with all change the behavior of the hotpaths.
diff --git a/src/uu/join/Cargo.toml b/src/uu/join/Cargo.toml
index 5be4af1a7..946056cc1 100644
--- a/src/uu/join/Cargo.toml
+++ b/src/uu/join/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_join"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "join ~ (uutils) merge lines from inputs with matching join fields"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/join.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true }
-memchr = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true }
+memchr = { workspace = true }
 
 [[bin]]
 name = "join"
diff --git a/src/uu/join/join.md b/src/uu/join/join.md
new file mode 100644
index 000000000..ec91950b8
--- /dev/null
+++ b/src/uu/join/join.md
@@ -0,0 +1,10 @@
+# join
+
+```
+join [OPTIONS] <FILE1> <FILE2>
+```
+
+For each pair of input lines with identical join fields, write a line to
+standard output. The default join field is the first, delimited by blanks.
+
+When `FILE1` or `FILE2` (not both) is `-`, read standard input.
diff --git a/src/uu/join/src/join.rs b/src/uu/join/src/join.rs
index ffcf6fdcd..de1a9181b 100644
--- a/src/uu/join/src/join.rs
+++ b/src/uu/join/src/join.rs
@@ -22,7 +22,10 @@ use std::num::IntErrorKind;
 use std::os::unix::ffi::OsStrExt;
 use uucore::display::Quotable;
 use uucore::error::{set_exit_code, UError, UResult, USimpleError};
-use uucore::{crash, crash_if_err};
+use uucore::{crash, crash_if_err, format_usage, help_about, help_usage};
+
+const ABOUT: &str = help_about!("join.md");
+const USAGE: &str = help_usage!("join.md");
 
 #[derive(Debug)]
 enum JoinError {
@@ -597,6 +600,7 @@ impl<'a> State<'a> {
 }
 
 #[uucore::main]
+#[allow(clippy::cognitive_complexity)]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app().try_get_matches_from(args)?;
 
@@ -699,12 +703,8 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
         .version(crate_version!())
-        .about(
-            "For each pair of input lines with identical join fields, write a line to
-standard output. The default join field is the first, delimited by blanks.
-
-When FILE1 or FILE2 (not both) is -, read standard input.",
-        )
+        .about(ABOUT)
+        .override_usage(format_usage(USAGE))
         .infer_long_args(true)
         .arg(
             Arg::new("a")
diff --git a/src/uu/kill/Cargo.toml b/src/uu/kill/Cargo.toml
index 817190083..1f5515d03 100644
--- a/src/uu/kill/Cargo.toml
+++ b/src/uu/kill/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_kill"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "kill ~ (uutils) send a signal to a process"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/kill.rs"
 
 [dependencies]
-clap = { workspace=true }
-nix = { workspace=true, features = ["signal"] }
-uucore = { workspace=true, features=["signals"] }
+clap = { workspace = true }
+nix = { workspace = true, features = ["signal"] }
+uucore = { workspace = true, features = ["signals"] }
 
 [[bin]]
 name = "kill"
diff --git a/src/uu/link/Cargo.toml b/src/uu/link/Cargo.toml
index e35e23cfc..fae9d59d9 100644
--- a/src/uu/link/Cargo.toml
+++ b/src/uu/link/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_link"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "link ~ (uutils) create a hard (file system) link to FILE"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/link.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "link"
diff --git a/src/uu/ln/Cargo.toml b/src/uu/ln/Cargo.toml
index f08f04e41..c4260cb8f 100644
--- a/src/uu/ln/Cargo.toml
+++ b/src/uu/ln/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_ln"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "ln ~ (uutils) create a (file system) link to TARGET"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/ln.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true, features=["fs"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["fs"] }
 
 [[bin]]
 name = "ln"
diff --git a/src/uu/ln/src/ln.rs b/src/uu/ln/src/ln.rs
index c583aac1e..c2bf25c5c 100644
--- a/src/uu/ln/src/ln.rs
+++ b/src/uu/ln/src/ln.rs
@@ -199,7 +199,7 @@ pub fn uu_app() -> Command {
             Arg::new(options::LOGICAL)
                 .short('L')
                 .long(options::LOGICAL)
-                .help("dereference TARGETs that are symbolic links")
+                .help("follow TARGETs that are symbolic links")
                 .overrides_with(options::PHYSICAL)
                 .action(ArgAction::SetTrue),
         )
@@ -292,6 +292,7 @@ fn exec(files: &[PathBuf], settings: &Settings) -> UResult<()> {
     link(&files[0], &files[1], settings)
 }
 
+#[allow(clippy::cognitive_complexity)]
 fn link_files_in_dir(files: &[PathBuf], target_dir: &Path, settings: &Settings) -> UResult<()> {
     if !target_dir.is_dir() {
         return Err(LnError::TargetIsDirectory(target_dir.to_owned()).into());
@@ -364,6 +365,7 @@ fn relative_path<'a>(src: &'a Path, dst: &Path) -> Cow<'a, Path> {
     src.into()
 }
 
+#[allow(clippy::cognitive_complexity)]
 fn link(src: &Path, dst: &Path, settings: &Settings) -> UResult<()> {
     let mut backup_path = None;
     let source: Cow<'_, Path> = if settings.relative {
@@ -391,8 +393,8 @@ fn link(src: &Path, dst: &Path, settings: &Settings) -> UResult<()> {
         match settings.overwrite {
             OverwriteMode::NoClobber => {}
             OverwriteMode::Interactive => {
-                if !prompt_yes!("overwrite {}?", dst.quote()) {
-                    return Ok(());
+                if !prompt_yes!("replace {}?", dst.quote()) {
+                    return Err(LnError::SomeLinksFailed.into());
                 }
 
                 if fs::remove_file(dst).is_ok() {};
diff --git a/src/uu/logname/Cargo.toml b/src/uu/logname/Cargo.toml
index 18ecdc9ab..a6bb6b0b7 100644
--- a/src/uu/logname/Cargo.toml
+++ b/src/uu/logname/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_logname"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "logname ~ (uutils) display the login name of the current user"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/logname.rs"
 
 [dependencies]
-libc = { workspace=true }
-clap = { workspace=true }
-uucore = { workspace=true }
+libc = { workspace = true }
+clap = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "logname"
diff --git a/src/uu/logname/logname.md b/src/uu/logname/logname.md
new file mode 100644
index 000000000..b997c206b
--- /dev/null
+++ b/src/uu/logname/logname.md
@@ -0,0 +1,7 @@
+# logname
+
+```
+logname
+```
+
+Print user's login name
diff --git a/src/uu/logname/src/logname.rs b/src/uu/logname/src/logname.rs
index fd5ab904e..b3cd06243 100644
--- a/src/uu/logname/src/logname.rs
+++ b/src/uu/logname/src/logname.rs
@@ -11,7 +11,7 @@
 
 use clap::{crate_version, Command};
 use std::ffi::CStr;
-use uucore::{error::UResult, show_error};
+use uucore::{error::UResult, format_usage, help_about, help_usage, show_error};
 
 extern "C" {
     // POSIX requires using getlogin (or equivalent code)
@@ -29,7 +29,8 @@ fn get_userlogin() -> Option<String> {
     }
 }
 
-static ABOUT: &str = "Print user's login name";
+const ABOUT: &str = help_about!("logname.md");
+const USAGE: &str = help_usage!("logname.md");
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
@@ -48,7 +49,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
         .version(crate_version!())
-        .override_usage(uucore::execution_phrase())
+        .override_usage(format_usage(USAGE))
         .about(ABOUT)
         .infer_long_args(true)
 }
diff --git a/src/uu/ls/BENCHMARKING.md b/src/uu/ls/BENCHMARKING.md
index 6bc157805..3103e43b0 100644
--- a/src/uu/ls/BENCHMARKING.md
+++ b/src/uu/ls/BENCHMARKING.md
@@ -9,13 +9,13 @@ Run `cargo build --release` before benchmarking after you make a change!
 
 ## Simple recursive ls
 
--   Get a large tree, for example linux kernel source tree.
--   Benchmark simple recursive ls with hyperfine: `hyperfine --warmup 2 "target/release/coreutils ls -R tree > /dev/null"`.
+- Get a large tree, for example linux kernel source tree.
+- Benchmark simple recursive ls with hyperfine: `hyperfine --warmup 2 "target/release/coreutils ls -R tree > /dev/null"`.
 
 ## Recursive ls with all and long options
 
--   Same tree as above
--   Benchmark recursive ls with -al -R options with hyperfine: `hyperfine --warmup 2 "target/release/coreutils ls -al -R tree > /dev/null"`.
+- Same tree as above
+- Benchmark recursive ls with -al -R options with hyperfine: `hyperfine --warmup 2 "target/release/coreutils ls -al -R tree > /dev/null"`.
 
 ## Comparing with GNU ls
 
@@ -29,7 +29,8 @@ Example: `hyperfine --warmup 2 "target/release/coreutils ls -al -R tree > /dev/n
 This can also be used to compare with version of ls built before your changes to ensure your change does not regress this.
 
 Here is a `bash` script for doing this comparison:
-```bash
+
+```shell
 #!/bin/bash
 cargo build --no-default-features --features ls --release
 args="$@"
@@ -46,12 +47,14 @@ hyperfine "ls $args" "target/release/coreutils ls $args"
 ## Cargo Flamegraph
 
 With Cargo Flamegraph you can easily make a flamegraph of `ls`:
-```bash
+
+```shell
 cargo flamegraph --cmd coreutils -- ls [additional parameters]
 ```
 
 However, if the `-R` option is given, the output becomes pretty much useless due to recursion. We can fix this by merging all the direct recursive calls with `uniq`, below is a `bash` script that does this.
-```bash
+
+```shell
 #!/bin/bash
 cargo build --release --no-default-features --features ls
 perf record target/release/coreutils ls "$@"
diff --git a/src/uu/ls/Cargo.toml b/src/uu/ls/Cargo.toml
index 7c7add294..196e29795 100644
--- a/src/uu/ls/Cargo.toml
+++ b/src/uu/ls/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_ls"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "ls ~ (uutils) display directory contents"
@@ -15,18 +15,18 @@ edition = "2021"
 path = "src/ls.rs"
 
 [dependencies]
-clap = { workspace=true, features = ["env"] }
-chrono = { workspace=true }
-unicode-width = { workspace=true }
-number_prefix = { workspace=true }
-term_grid = { workspace=true }
-terminal_size = { workspace=true }
-glob = { workspace=true }
-lscolors = { workspace=true }
-uucore = { workspace=true, features = ["entries", "fs"] }
-once_cell = { workspace=true }
-is-terminal = { workspace=true }
-selinux = { workspace=true, optional = true }
+clap = { workspace = true, features = ["env"] }
+chrono = { workspace = true }
+unicode-width = { workspace = true }
+number_prefix = { workspace = true }
+term_grid = { workspace = true }
+terminal_size = { workspace = true }
+glob = { workspace = true }
+lscolors = { workspace = true }
+uucore = { workspace = true, features = ["entries", "fs"] }
+once_cell = { workspace = true }
+is-terminal = { workspace = true }
+selinux = { workspace = true, optional = true }
 
 [[bin]]
 name = "ls"
diff --git a/src/uu/ls/ls.md b/src/uu/ls/ls.md
new file mode 100644
index 000000000..01eec7e50
--- /dev/null
+++ b/src/uu/ls/ls.md
@@ -0,0 +1,12 @@
+# ls
+
+```
+ls [OPTION]... [FILE]...
+```
+
+List directory contents.
+Ignore files and directories starting with a '.' by default
+
+## After help
+
+The TIME_STYLE argument can be full-iso, long-iso, iso, locale or +FORMAT. FORMAT is interpreted like in date. Also the TIME_STYLE environment variable sets the default style to use.
diff --git a/src/uu/ls/src/ls.rs b/src/uu/ls/src/ls.rs
index abf05676f..7db591cf3 100644
--- a/src/uu/ls/src/ls.rs
+++ b/src/uu/ls/src/ls.rs
@@ -41,7 +41,13 @@ use unicode_width::UnicodeWidthStr;
     target_os = "linux",
     target_os = "macos",
     target_os = "android",
-    target_os = "ios"
+    target_os = "ios",
+    target_os = "freebsd",
+    target_os = "dragonfly",
+    target_os = "netbsd",
+    target_os = "openbsd",
+    target_os = "illumos",
+    target_os = "solaris"
 ))]
 use uucore::libc::{dev_t, major, minor};
 #[cfg(unix)]
@@ -55,17 +61,16 @@ use uucore::{
     parse_size::parse_size,
     version_cmp::version_cmp,
 };
-use uucore::{parse_glob, show, show_error, show_warning};
+use uucore::{help_about, help_section, help_usage, parse_glob, show, show_error, show_warning};
 
 #[cfg(not(feature = "selinux"))]
 static CONTEXT_HELP_TEXT: &str = "print any security context of each file (not enabled)";
 #[cfg(feature = "selinux")]
 static CONTEXT_HELP_TEXT: &str = "print any security context of each file";
 
-const ABOUT: &str = r#"List directory contents.
-Ignore files and directories starting with a '.' by default"#;
-
-const USAGE: &str = "{} [OPTION]... [FILE]...";
+const ABOUT: &str = help_about!("ls.md");
+const AFTER_HELP: &str = help_section!("after help", "ls.md");
+const USAGE: &str = help_usage!("ls.md");
 
 pub mod options {
     pub mod format {
@@ -289,6 +294,7 @@ enum Sort {
     Time,
     Version,
     Extension,
+    Width,
 }
 
 #[derive(PartialEq)]
@@ -427,36 +433,236 @@ struct PaddingCollection {
     block_size: usize,
 }
 
+/// Extracts the format to display the information based on the options provided.
+///
+/// # Returns
+///
+/// A tuple containing the Format variant and an Option containing a &'static str
+/// which corresponds to the option used to define the format.
+fn extract_format(options: &clap::ArgMatches) -> (Format, Option<&'static str>) {
+    if let Some(format_) = options.get_one::<String>(options::FORMAT) {
+        (
+            match format_.as_str() {
+                "long" | "verbose" => Format::Long,
+                "single-column" => Format::OneLine,
+                "columns" | "vertical" => Format::Columns,
+                "across" | "horizontal" => Format::Across,
+                "commas" => Format::Commas,
+                // below should never happen as clap already restricts the values.
+                _ => unreachable!("Invalid field for --format"),
+            },
+            Some(options::FORMAT),
+        )
+    } else if options.get_flag(options::format::LONG) {
+        (Format::Long, Some(options::format::LONG))
+    } else if options.get_flag(options::format::ACROSS) {
+        (Format::Across, Some(options::format::ACROSS))
+    } else if options.get_flag(options::format::COMMAS) {
+        (Format::Commas, Some(options::format::COMMAS))
+    } else if options.get_flag(options::format::COLUMNS) {
+        (Format::Columns, Some(options::format::COLUMNS))
+    } else if std::io::stdout().is_terminal() {
+        (Format::Columns, None)
+    } else {
+        (Format::OneLine, None)
+    }
+}
+
+/// Extracts the type of files to display
+///
+/// # Returns
+///
+/// A Files variant representing the type of files to display.
+fn extract_files(options: &clap::ArgMatches) -> Files {
+    if options.get_flag(options::files::ALL) {
+        Files::All
+    } else if options.get_flag(options::files::ALMOST_ALL) {
+        Files::AlmostAll
+    } else {
+        Files::Normal
+    }
+}
+
+/// Extracts the sorting method to use based on the options provided.
+///
+/// # Returns
+///
+/// A Sort variant representing the sorting method to use.
+fn extract_sort(options: &clap::ArgMatches) -> Sort {
+    if let Some(field) = options.get_one::<String>(options::SORT) {
+        match field.as_str() {
+            "none" => Sort::None,
+            "name" => Sort::Name,
+            "time" => Sort::Time,
+            "size" => Sort::Size,
+            "version" => Sort::Version,
+            "extension" => Sort::Extension,
+            "width" => Sort::Width,
+            // below should never happen as clap already restricts the values.
+            _ => unreachable!("Invalid field for --sort"),
+        }
+    } else if options.get_flag(options::sort::TIME) {
+        Sort::Time
+    } else if options.get_flag(options::sort::SIZE) {
+        Sort::Size
+    } else if options.get_flag(options::sort::NONE) {
+        Sort::None
+    } else if options.get_flag(options::sort::VERSION) {
+        Sort::Version
+    } else if options.get_flag(options::sort::EXTENSION) {
+        Sort::Extension
+    } else {
+        Sort::Name
+    }
+}
+
+/// Extracts the time to use based on the options provided.
+///
+/// # Returns
+///
+/// A Time variant representing the time to use.
+fn extract_time(options: &clap::ArgMatches) -> Time {
+    if let Some(field) = options.get_one::<String>(options::TIME) {
+        match field.as_str() {
+            "ctime" | "status" => Time::Change,
+            "access" | "atime" | "use" => Time::Access,
+            "birth" | "creation" => Time::Birth,
+            // below should never happen as clap already restricts the values.
+            _ => unreachable!("Invalid field for --time"),
+        }
+    } else if options.get_flag(options::time::ACCESS) {
+        Time::Access
+    } else if options.get_flag(options::time::CHANGE) {
+        Time::Change
+    } else {
+        Time::Modification
+    }
+}
+
+/// Extracts the color option to use based on the options provided.
+///
+/// # Returns
+///
+/// A boolean representing whether or not to use color.
+fn extract_color(options: &clap::ArgMatches) -> bool {
+    match options.get_one::<String>(options::COLOR) {
+        None => options.contains_id(options::COLOR),
+        Some(val) => match val.as_str() {
+            "" | "always" | "yes" | "force" => true,
+            "auto" | "tty" | "if-tty" => std::io::stdout().is_terminal(),
+            /* "never" | "no" | "none" | */ _ => false,
+        },
+    }
+}
+
+/// Extracts the quoting style to use based on the options provided.
+///
+/// # Arguments
+///
+/// * `options` - A reference to a clap::ArgMatches object containing command line arguments.
+/// * `show_control` - A boolean value representing whether or not to show control characters.
+///
+/// # Returns
+///
+/// A QuotingStyle variant representing the quoting style to use.
+fn extract_quoting_style(options: &clap::ArgMatches, show_control: bool) -> QuotingStyle {
+    let opt_quoting_style = options
+        .get_one::<String>(options::QUOTING_STYLE)
+        .map(|cmd_line_qs| cmd_line_qs.to_owned());
+
+    if let Some(style) = opt_quoting_style {
+        match style.as_str() {
+            "literal" => QuotingStyle::Literal { show_control },
+            "shell" => QuotingStyle::Shell {
+                escape: false,
+                always_quote: false,
+                show_control,
+            },
+            "shell-always" => QuotingStyle::Shell {
+                escape: false,
+                always_quote: true,
+                show_control,
+            },
+            "shell-escape" => QuotingStyle::Shell {
+                escape: true,
+                always_quote: false,
+                show_control,
+            },
+            "shell-escape-always" => QuotingStyle::Shell {
+                escape: true,
+                always_quote: true,
+                show_control,
+            },
+            "c" => QuotingStyle::C {
+                quotes: quoting_style::Quotes::Double,
+            },
+            "escape" => QuotingStyle::C {
+                quotes: quoting_style::Quotes::None,
+            },
+            _ => unreachable!("Should have been caught by Clap"),
+        }
+    } else if options.get_flag(options::quoting::LITERAL) {
+        QuotingStyle::Literal { show_control }
+    } else if options.get_flag(options::quoting::ESCAPE) {
+        QuotingStyle::C {
+            quotes: quoting_style::Quotes::None,
+        }
+    } else if options.get_flag(options::quoting::C) {
+        QuotingStyle::C {
+            quotes: quoting_style::Quotes::Double,
+        }
+    } else {
+        // TODO: use environment variable if available
+        QuotingStyle::Shell {
+            escape: true,
+            always_quote: false,
+            show_control,
+        }
+    }
+}
+
+/// Extracts the indicator style to use based on the options provided.
+///
+/// # Returns
+///
+/// An IndicatorStyle variant representing the indicator style to use.
+fn extract_indicator_style(options: &clap::ArgMatches) -> IndicatorStyle {
+    if let Some(field) = options.get_one::<String>(options::INDICATOR_STYLE) {
+        match field.as_str() {
+            "none" => IndicatorStyle::None,
+            "file-type" => IndicatorStyle::FileType,
+            "classify" => IndicatorStyle::Classify,
+            "slash" => IndicatorStyle::Slash,
+            &_ => IndicatorStyle::None,
+        }
+    } else if let Some(field) = options.get_one::<String>(options::indicator_style::CLASSIFY) {
+        match field.as_str() {
+            "never" | "no" | "none" => IndicatorStyle::None,
+            "always" | "yes" | "force" => IndicatorStyle::Classify,
+            "auto" | "tty" | "if-tty" => {
+                if std::io::stdout().is_terminal() {
+                    IndicatorStyle::Classify
+                } else {
+                    IndicatorStyle::None
+                }
+            }
+            &_ => IndicatorStyle::None,
+        }
+    } else if options.get_flag(options::indicator_style::SLASH) {
+        IndicatorStyle::Slash
+    } else if options.get_flag(options::indicator_style::FILE_TYPE) {
+        IndicatorStyle::FileType
+    } else {
+        IndicatorStyle::None
+    }
+}
+
 impl Config {
     #[allow(clippy::cognitive_complexity)]
     pub fn from(options: &clap::ArgMatches) -> UResult<Self> {
         let context = options.get_flag(options::CONTEXT);
-        let (mut format, opt) = if let Some(format_) = options.get_one::<String>(options::FORMAT) {
-            (
-                match format_.as_str() {
-                    "long" | "verbose" => Format::Long,
-                    "single-column" => Format::OneLine,
-                    "columns" | "vertical" => Format::Columns,
-                    "across" | "horizontal" => Format::Across,
-                    "commas" => Format::Commas,
-                    // below should never happen as clap already restricts the values.
-                    _ => unreachable!("Invalid field for --format"),
-                },
-                Some(options::FORMAT),
-            )
-        } else if options.get_flag(options::format::LONG) {
-            (Format::Long, Some(options::format::LONG))
-        } else if options.get_flag(options::format::ACROSS) {
-            (Format::Across, Some(options::format::ACROSS))
-        } else if options.get_flag(options::format::COMMAS) {
-            (Format::Commas, Some(options::format::COMMAS))
-        } else if options.get_flag(options::format::COLUMNS) {
-            (Format::Columns, Some(options::format::COLUMNS))
-        } else if std::io::stdout().is_terminal() {
-            (Format::Columns, None)
-        } else {
-            (Format::OneLine, None)
-        };
+        let (mut format, opt) = extract_format(options);
+        let files = extract_files(options);
 
         // The -o, -n and -g options are tricky. They cannot override with each
         // other because it's possible to combine them. For example, the option
@@ -505,63 +711,11 @@ impl Config {
             }
         }
 
-        let files = if options.get_flag(options::files::ALL) {
-            Files::All
-        } else if options.get_flag(options::files::ALMOST_ALL) {
-            Files::AlmostAll
-        } else {
-            Files::Normal
-        };
+        let sort = extract_sort(options);
 
-        let sort = if let Some(field) = options.get_one::<String>(options::SORT) {
-            match field.as_str() {
-                "none" => Sort::None,
-                "name" => Sort::Name,
-                "time" => Sort::Time,
-                "size" => Sort::Size,
-                "version" => Sort::Version,
-                "extension" => Sort::Extension,
-                // below should never happen as clap already restricts the values.
-                _ => unreachable!("Invalid field for --sort"),
-            }
-        } else if options.get_flag(options::sort::TIME) {
-            Sort::Time
-        } else if options.get_flag(options::sort::SIZE) {
-            Sort::Size
-        } else if options.get_flag(options::sort::NONE) {
-            Sort::None
-        } else if options.get_flag(options::sort::VERSION) {
-            Sort::Version
-        } else if options.get_flag(options::sort::EXTENSION) {
-            Sort::Extension
-        } else {
-            Sort::Name
-        };
+        let time = extract_time(options);
 
-        let time = if let Some(field) = options.get_one::<String>(options::TIME) {
-            match field.as_str() {
-                "ctime" | "status" => Time::Change,
-                "access" | "atime" | "use" => Time::Access,
-                "birth" | "creation" => Time::Birth,
-                // below should never happen as clap already restricts the values.
-                _ => unreachable!("Invalid field for --time"),
-            }
-        } else if options.get_flag(options::time::ACCESS) {
-            Time::Access
-        } else if options.get_flag(options::time::CHANGE) {
-            Time::Change
-        } else {
-            Time::Modification
-        };
-
-        let mut needs_color = match options.get_one::<String>(options::COLOR) {
-            None => options.contains_id(options::COLOR),
-            Some(val) => match val.as_str() {
-                "" | "always" | "yes" | "force" => true,
-                "auto" | "tty" | "if-tty" => std::io::stdout().is_terminal(),
-                /* "never" | "no" | "none" | */ _ => false,
-            },
-        };
+        let mut needs_color = extract_color(options);
 
         let cmd_line_bs = options.get_one::<String>(options::size::BLOCK_SIZE);
         let opt_si = cmd_line_bs.is_some()
@@ -682,90 +836,8 @@ impl Config {
             !std::io::stdout().is_terminal()
         };
 
-        let opt_quoting_style = options
-            .get_one::<String>(options::QUOTING_STYLE)
-            .map(|cmd_line_qs| cmd_line_qs.to_owned());
-
-        let mut quoting_style = if let Some(style) = opt_quoting_style {
-            match style.as_str() {
-                "literal" => QuotingStyle::Literal { show_control },
-                "shell" => QuotingStyle::Shell {
-                    escape: false,
-                    always_quote: false,
-                    show_control,
-                },
-                "shell-always" => QuotingStyle::Shell {
-                    escape: false,
-                    always_quote: true,
-                    show_control,
-                },
-                "shell-escape" => QuotingStyle::Shell {
-                    escape: true,
-                    always_quote: false,
-                    show_control,
-                },
-                "shell-escape-always" => QuotingStyle::Shell {
-                    escape: true,
-                    always_quote: true,
-                    show_control,
-                },
-                "c" => QuotingStyle::C {
-                    quotes: quoting_style::Quotes::Double,
-                },
-                "escape" => QuotingStyle::C {
-                    quotes: quoting_style::Quotes::None,
-                },
-                _ => unreachable!("Should have been caught by Clap"),
-            }
-        } else if options.get_flag(options::quoting::LITERAL) {
-            QuotingStyle::Literal { show_control }
-        } else if options.get_flag(options::quoting::ESCAPE) {
-            QuotingStyle::C {
-                quotes: quoting_style::Quotes::None,
-            }
-        } else if options.get_flag(options::quoting::C) {
-            QuotingStyle::C {
-                quotes: quoting_style::Quotes::Double,
-            }
-        } else {
-            // TODO: use environment variable if available
-            QuotingStyle::Shell {
-                escape: true,
-                always_quote: false,
-                show_control,
-            }
-        };
-
-        let indicator_style = if let Some(field) =
-            options.get_one::<String>(options::INDICATOR_STYLE)
-        {
-            match field.as_str() {
-                "none" => IndicatorStyle::None,
-                "file-type" => IndicatorStyle::FileType,
-                "classify" => IndicatorStyle::Classify,
-                "slash" => IndicatorStyle::Slash,
-                &_ => IndicatorStyle::None,
-            }
-        } else if let Some(field) = options.get_one::<String>(options::indicator_style::CLASSIFY) {
-            match field.as_str() {
-                "never" | "no" | "none" => IndicatorStyle::None,
-                "always" | "yes" | "force" => IndicatorStyle::Classify,
-                "auto" | "tty" | "if-tty" => {
-                    if std::io::stdout().is_terminal() {
-                        IndicatorStyle::Classify
-                    } else {
-                        IndicatorStyle::None
-                    }
-                }
-                &_ => IndicatorStyle::None,
-            }
-        } else if options.get_flag(options::indicator_style::SLASH) {
-            IndicatorStyle::Slash
-        } else if options.get_flag(options::indicator_style::FILE_TYPE) {
-            IndicatorStyle::FileType
-        } else {
-            IndicatorStyle::None
-        };
+        let mut quoting_style = extract_quoting_style(options, show_control);
+        let indicator_style = extract_indicator_style(options);
         let time_style = parse_time_style(options)?;
 
         let mut ignore_patterns: Vec<Pattern> = Vec::new();
@@ -1252,9 +1324,9 @@ pub fn uu_app() -> Command {
         .arg(
             Arg::new(options::SORT)
                 .long(options::SORT)
-                .help("Sort by <field>: name, none (-U), time (-t), size (-S) or extension (-X)")
+                .help("Sort by <field>: name, none (-U), time (-t), size (-S), extension (-X) or width")
                 .value_name("field")
-                .value_parser(["name", "none", "time", "size", "version", "extension"])
+                .value_parser(["name", "none", "time", "size", "version", "extension", "width"])
                 .require_equals(true)
                 .overrides_with_all([
                     options::SORT,
@@ -1359,7 +1431,7 @@ pub fn uu_app() -> Command {
             Arg::new(options::dereference::DIR_ARGS)
                 .long(options::dereference::DIR_ARGS)
                 .help(
-                    "Do not dereference symlinks except when they link to directories and are \
+                    "Do not follow symlinks except when they link to directories and are \
                     given as command line arguments.",
                 )
                 .overrides_with_all([
@@ -1373,7 +1445,7 @@ pub fn uu_app() -> Command {
             Arg::new(options::dereference::ARGS)
                 .short('H')
                 .long(options::dereference::ARGS)
-                .help("Do not dereference symlinks except when given as command line arguments.")
+                .help("Do not follow symlinks except when given as command line arguments.")
                 .overrides_with_all([
                     options::dereference::ALL,
                     options::dereference::DIR_ARGS,
@@ -1621,10 +1693,7 @@ pub fn uu_app() -> Command {
                 .value_hint(clap::ValueHint::AnyPath)
                 .value_parser(ValueParser::os_string()),
         )
-        .after_help(
-            "The TIME_STYLE argument can be full-iso, long-iso, iso, locale or +FORMAT. FORMAT is interpreted like in date. \
-            Also the TIME_STYLE environment variable sets the default style to use.",
-        )
+        .after_help(AFTER_HELP)
 }
 
 /// Represents a Path along with it's associated data.
@@ -1870,6 +1939,12 @@ fn sort_entries(entries: &mut [PathData], config: &Config, out: &mut BufWriter<S
                 .cmp(&b.p_buf.extension())
                 .then(a.p_buf.file_stem().cmp(&b.p_buf.file_stem()))
         }),
+        Sort::Width => entries.sort_by(|a, b| {
+            a.display_name
+                .len()
+                .cmp(&b.display_name.len())
+                .then(a.display_name.cmp(&b.display_name))
+        }),
         Sort::None => {}
     }
 
@@ -1930,13 +2005,19 @@ fn should_display(entry: &DirEntry, config: &Config) -> bool {
         require_literal_separator: false,
         case_sensitive: true,
     };
-    let file_name = entry.file_name().into_string().unwrap();
+    let file_name = entry.file_name();
+    // If the decoding fails, still show an incorrect rendering
+    let file_name = match file_name.to_str() {
+        Some(s) => s.to_string(),
+        None => file_name.to_string_lossy().into_owned(),
+    };
     !config
         .ignore_patterns
         .iter()
         .any(|p| p.matches_with(&file_name, options))
 }
 
+#[allow(clippy::cognitive_complexity)]
 fn enter_directory(
     path_data: &PathData,
     read_dir: ReadDir,
@@ -2012,16 +2093,16 @@ fn enter_directory(
                     continue;
                 }
                 Ok(rd) => {
-                    if !listed_ancestors
+                    if listed_ancestors
                         .insert(FileInformation::from_path(&e.p_buf, e.must_dereference)?)
                     {
-                        out.flush()?;
-                        show!(LsError::AlreadyListedError(e.p_buf.clone()));
-                    } else {
                         writeln!(out, "\n{}:", e.p_buf.display())?;
                         enter_directory(e, rd, config, out, listed_ancestors)?;
                         listed_ancestors
                             .remove(&FileInformation::from_path(&e.p_buf, e.must_dereference)?);
+                    } else {
+                        out.flush()?;
+                        show!(LsError::AlreadyListedError(e.p_buf.clone()));
                     }
                 }
             }
@@ -2127,6 +2208,7 @@ fn display_additional_leading_info(
     Ok(result)
 }
 
+#[allow(clippy::cognitive_complexity)]
 fn display_items(items: &[PathData], config: &Config, out: &mut BufWriter<Stdout>) -> UResult<()> {
     // `-Z`, `--context`:
     // Display the SELinux security context or '?' if none is found. When used with the `-l`
@@ -2316,6 +2398,7 @@ fn display_grid(
 /// ```
 /// that decide the maximum possible character count of each field.
 #[allow(clippy::write_literal)]
+#[allow(clippy::cognitive_complexity)]
 fn display_item_long(
     item: &PathData,
     padding: &PaddingCollection,
@@ -2652,7 +2735,13 @@ fn display_len_or_rdev(metadata: &Metadata, config: &Config) -> SizeOrDeviceId {
         target_os = "linux",
         target_os = "macos",
         target_os = "android",
-        target_os = "ios"
+        target_os = "ios",
+        target_os = "freebsd",
+        target_os = "dragonfly",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "illumos",
+        target_os = "solaris"
     ))]
     {
         let ft = metadata.file_type();
@@ -2746,6 +2835,7 @@ fn classify_file(path: &PathData, out: &mut BufWriter<Stdout>) -> Option<char> {
 /// Note that non-unicode sequences in symlink targets are dealt with using
 /// [`std::path::Path::to_string_lossy`].
 #[allow(unused_variables)]
+#[allow(clippy::cognitive_complexity)]
 fn display_file_name(
     path: &PathData,
     config: &Config,
@@ -2871,10 +2961,10 @@ fn display_file_name(
     // to get correct alignment from later calls to`display_grid()`.
     if config.context {
         if let Some(pad_count) = prefix_context {
-            let security_context = if !matches!(config.format, Format::Commas) {
-                pad_left(&path.security_context, pad_count)
-            } else {
+            let security_context = if matches!(config.format, Format::Commas) {
                 path.security_context.to_owned()
+            } else {
+                pad_left(&path.security_context, pad_count)
             };
             name = format!("{security_context} {name}");
             width += security_context.len() + 1;
diff --git a/src/uu/mkdir/Cargo.toml b/src/uu/mkdir/Cargo.toml
index b8bc1dddf..9d1edc5c6 100644
--- a/src/uu/mkdir/Cargo.toml
+++ b/src/uu/mkdir/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_mkdir"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "mkdir ~ (uutils) create DIRECTORY"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/mkdir.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true, features=["fs", "mode"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["fs", "mode"] }
 
 [[bin]]
 name = "mkdir"
diff --git a/src/uu/mkdir/mkdir.md b/src/uu/mkdir/mkdir.md
index 8773d15f4..1698842cd 100644
--- a/src/uu/mkdir/mkdir.md
+++ b/src/uu/mkdir/mkdir.md
@@ -1,6 +1,7 @@
-<!-- spell-checker:ignore ugoa -->
 # mkdir
 
+<!-- spell-checker:ignore ugoa -->
+
 ```
 mkdir [OPTION]... [USER]
 ```
diff --git a/src/uu/mkdir/src/mkdir.rs b/src/uu/mkdir/src/mkdir.rs
index 9f490ecf9..a94439af5 100644
--- a/src/uu/mkdir/src/mkdir.rs
+++ b/src/uu/mkdir/src/mkdir.rs
@@ -20,7 +20,7 @@ use uucore::mode;
 use uucore::{display::Quotable, fs::dir_strip_dot_for_creation};
 use uucore::{format_usage, help_about, help_section, help_usage, show, show_if_err};
 
-static DEFAULT_PERM: u32 = 0o755;
+static DEFAULT_PERM: u32 = 0o777;
 
 const ABOUT: &str = help_about!("mkdir.md");
 const USAGE: &str = help_usage!("mkdir.md");
@@ -41,7 +41,7 @@ fn get_mode(_matches: &ArgMatches, _mode_had_minus_prefix: bool) -> Result<u32,
 #[cfg(not(windows))]
 fn get_mode(matches: &ArgMatches, mode_had_minus_prefix: bool) -> Result<u32, String> {
     let digits: &[char] = &['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
-    // Translate a ~str in octal form to u16, default to 755
+    // Translate a ~str in octal form to u16, default to 777
     // Not tested on Windows
     let mut new_mode = DEFAULT_PERM;
     match matches.get_one::<String>(options::MODE) {
@@ -158,7 +158,7 @@ fn exec(dirs: ValuesRef<OsString>, recursive: bool, mode: u32, verbose: bool) ->
 }
 
 fn mkdir(path: &Path, recursive: bool, mode: u32, verbose: bool) -> UResult<()> {
-    create_dir(path, recursive, verbose)?;
+    create_dir(path, recursive, verbose, false)?;
     chmod(path, mode)
 }
 
@@ -179,7 +179,9 @@ fn chmod(_path: &Path, _mode: u32) -> UResult<()> {
     Ok(())
 }
 
-fn create_dir(path: &Path, recursive: bool, verbose: bool) -> UResult<()> {
+// `is_parent` argument is not used on windows
+#[allow(unused_variables)]
+fn create_dir(path: &Path, recursive: bool, verbose: bool, is_parent: bool) -> UResult<()> {
     if path.exists() && !recursive {
         return Err(USimpleError::new(
             1,
@@ -192,7 +194,7 @@ fn create_dir(path: &Path, recursive: bool, verbose: bool) -> UResult<()> {
 
     if recursive {
         match path.parent() {
-            Some(p) => create_dir(p, recursive, verbose)?,
+            Some(p) => create_dir(p, recursive, verbose, true)?,
             None => {
                 USimpleError::new(1, "failed to create whole tree");
             }
@@ -207,6 +209,12 @@ fn create_dir(path: &Path, recursive: bool, verbose: bool) -> UResult<()> {
                     path.quote()
                 );
             }
+            #[cfg(not(windows))]
+            if is_parent {
+                // directories created by -p have permission bits set to '=rwx,u+wx',
+                // which is umask modified by 'u+wx'
+                chmod(path, (!mode::get_umask() & 0o0777) | 0o0300)?;
+            }
             Ok(())
         }
         Err(_) if path.is_dir() => Ok(()),
diff --git a/src/uu/mkfifo/Cargo.toml b/src/uu/mkfifo/Cargo.toml
index 9ffe3c765..54a4a51b5 100644
--- a/src/uu/mkfifo/Cargo.toml
+++ b/src/uu/mkfifo/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_mkfifo"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "mkfifo ~ (uutils) create FIFOs (named pipes)"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/mkfifo.rs"
 
 [dependencies]
-clap = { workspace=true }
-libc = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+libc = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "mkfifo"
diff --git a/src/uu/mkfifo/mkfifo.md b/src/uu/mkfifo/mkfifo.md
new file mode 100644
index 000000000..b63437829
--- /dev/null
+++ b/src/uu/mkfifo/mkfifo.md
@@ -0,0 +1,7 @@
+# mkfifo
+
+```
+mkfifo [OPTION]... NAME...
+```
+
+Create a FIFO with the given name.
diff --git a/src/uu/mkfifo/src/mkfifo.rs b/src/uu/mkfifo/src/mkfifo.rs
index 99c16acff..dc338cf12 100644
--- a/src/uu/mkfifo/src/mkfifo.rs
+++ b/src/uu/mkfifo/src/mkfifo.rs
@@ -10,10 +10,10 @@ use libc::mkfifo;
 use std::ffi::CString;
 use uucore::display::Quotable;
 use uucore::error::{UResult, USimpleError};
-use uucore::{format_usage, show};
+use uucore::{format_usage, help_about, help_usage, show};
 
-static USAGE: &str = "{} [OPTION]... NAME...";
-static ABOUT: &str = "Create a FIFO with the given name.";
+static USAGE: &str = help_usage!("mkfifo.md");
+static ABOUT: &str = help_about!("mkfifo.md");
 
 mod options {
     pub static MODE: &str = "mode";
diff --git a/src/uu/mknod/Cargo.toml b/src/uu/mknod/Cargo.toml
index b74ed3b46..d73ea59b7 100644
--- a/src/uu/mknod/Cargo.toml
+++ b/src/uu/mknod/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_mknod"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "mknod ~ (uutils) create special file NAME of TYPE"
@@ -16,9 +16,9 @@ name = "uu_mknod"
 path = "src/mknod.rs"
 
 [dependencies]
-clap = { workspace=true }
-libc = { workspace=true }
-uucore = { workspace=true, features=["mode"] }
+clap = { workspace = true }
+libc = { workspace = true }
+uucore = { workspace = true, features = ["mode"] }
 
 [[bin]]
 name = "mknod"
diff --git a/src/uu/mknod/mknod.md b/src/uu/mknod/mknod.md
new file mode 100644
index 000000000..78da97025
--- /dev/null
+++ b/src/uu/mknod/mknod.md
@@ -0,0 +1,25 @@
+# mknod
+
+```
+mknod [OPTION]... NAME TYPE [MAJOR MINOR]
+```
+
+Create the special file NAME of the given TYPE.
+
+## After Help
+
+Mandatory arguments to long options are mandatory for short options too.
+`-m`, `--mode=MODE`    set file permission bits to `MODE`, not `a=rw - umask`
+
+Both `MAJOR` and `MINOR` must be specified when `TYPE` is `b`, `c`, or `u`, and they
+must be omitted when `TYPE` is `p`.  If `MAJOR` or `MINOR` begins with `0x` or `0X`,
+it is interpreted as hexadecimal; otherwise, if it begins with 0, as octal;
+otherwise, as decimal.  `TYPE` may be:
+
+* `b`      create a block (buffered) special file
+* `c`, `u`   create a character (unbuffered) special file
+* `p`      create a FIFO
+
+NOTE: your shell may have its own version of mknod, which usually supersedes
+the version described here.  Please refer to your shell's documentation
+for details about the options it supports.
diff --git a/src/uu/mknod/src/mknod.rs b/src/uu/mknod/src/mknod.rs
index f4c6f5732..ad7618cc8 100644
--- a/src/uu/mknod/src/mknod.rs
+++ b/src/uu/mknod/src/mknod.rs
@@ -14,28 +14,11 @@ use std::ffi::CString;
 
 use uucore::display::Quotable;
 use uucore::error::{set_exit_code, UResult, USimpleError, UUsageError};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_section, help_usage};
 
-static ABOUT: &str = "Create the special file NAME of the given TYPE.";
-static USAGE: &str = "{} [OPTION]... NAME TYPE [MAJOR MINOR]";
-static LONG_HELP: &str = "Mandatory arguments to long options are mandatory for short options too.
--m, --mode=MODE    set file permission bits to MODE, not a=rw - umask
---help     display this help and exit
---version  output version information and exit
-
-Both MAJOR and MINOR must be specified when TYPE is b, c, or u, and they
-must be omitted when TYPE is p.  If MAJOR or MINOR begins with 0x or 0X,
-it is interpreted as hexadecimal; otherwise, if it begins with 0, as octal;
-otherwise, as decimal.  TYPE may be:
-
-b      create a block (buffered) special file
-c, u   create a character (unbuffered) special file
-p      create a FIFO
-
-NOTE: your shell may have its own version of mknod, which usually supersedes
-the version described here.  Please refer to your shell's documentation
-for details about the options it supports.
-";
+const ABOUT: &str = help_about!("mknod.md");
+const USAGE: &str = help_usage!("mknod.md");
+const AFTER_HELP: &str = help_section!("after help", "mknod.md");
 
 const MODE_RW_UGO: mode_t = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
 
@@ -142,7 +125,7 @@ pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
         .version(crate_version!())
         .override_usage(format_usage(USAGE))
-        .after_help(LONG_HELP)
+        .after_help(AFTER_HELP)
         .about(ABOUT)
         .infer_long_args(true)
         .arg(
diff --git a/src/uu/mktemp/Cargo.toml b/src/uu/mktemp/Cargo.toml
index 029e89bc9..001bf5411 100644
--- a/src/uu/mktemp/Cargo.toml
+++ b/src/uu/mktemp/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_mktemp"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "mktemp ~ (uutils) create and display a temporary file or directory from TEMPLATE"
@@ -15,10 +15,10 @@ edition = "2021"
 path = "src/mktemp.rs"
 
 [dependencies]
-clap = { workspace=true }
-rand = { workspace=true }
-tempfile = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+rand = { workspace = true }
+tempfile = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "mktemp"
diff --git a/src/uu/mktemp/mktemp.md b/src/uu/mktemp/mktemp.md
new file mode 100644
index 000000000..75b56d667
--- /dev/null
+++ b/src/uu/mktemp/mktemp.md
@@ -0,0 +1,7 @@
+# mktemp
+
+```
+mktemp [OPTION]... [TEMPLATE]
+```
+
+Create a temporary file or directory.
diff --git a/src/uu/mktemp/src/mktemp.rs b/src/uu/mktemp/src/mktemp.rs
index 390c77bfa..fc360d0f5 100644
--- a/src/uu/mktemp/src/mktemp.rs
+++ b/src/uu/mktemp/src/mktemp.rs
@@ -11,7 +11,7 @@
 use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
 use uucore::display::{println_verbatim, Quotable};
 use uucore::error::{FromIo, UError, UResult, UUsageError};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
 
 use std::env;
 use std::error::Error;
@@ -28,8 +28,8 @@ use std::os::unix::prelude::PermissionsExt;
 use rand::Rng;
 use tempfile::Builder;
 
-static ABOUT: &str = "Create a temporary file or directory.";
-const USAGE: &str = "{} [OPTION]... [TEMPLATE]";
+const ABOUT: &str = help_about!("mktemp.md");
+const USAGE: &str = help_usage!("mktemp.md");
 
 static DEFAULT_TEMPLATE: &str = "tmp.XXXXXXXXXX";
 
@@ -42,6 +42,11 @@ static OPT_T: &str = "t";
 
 static ARG_TEMPLATE: &str = "template";
 
+#[cfg(not(windows))]
+const TMPDIR_ENV_VAR: &str = "TMPDIR";
+#[cfg(windows)]
+const TMPDIR_ENV_VAR: &str = "TMP";
+
 #[derive(Debug)]
 enum MkTempError {
     PersistError(PathBuf),
@@ -191,7 +196,16 @@ impl Options {
                     (tmpdir, template.to_string())
                 }
                 Some(template) => {
-                    let tmpdir = matches.get_one::<String>(OPT_TMPDIR).map(String::from);
+                    let tmpdir = if env::var(TMPDIR_ENV_VAR).is_ok() && matches.get_flag(OPT_T) {
+                        env::var(TMPDIR_ENV_VAR).ok()
+                    } else if matches.contains_id(OPT_TMPDIR) {
+                        matches.get_one::<String>(OPT_TMPDIR).map(String::from)
+                    } else if matches.get_flag(OPT_T) {
+                        // mktemp -t foo.xxx should export in TMPDIR
+                        Some(env::temp_dir().display().to_string())
+                    } else {
+                        matches.get_one::<String>(OPT_TMPDIR).map(String::from)
+                    };
                     (tmpdir, template.to_string())
                 }
             }
@@ -281,7 +295,7 @@ impl Params {
             .join(prefix_from_template)
             .display()
             .to_string();
-        if options.treat_as_template && prefix.contains(MAIN_SEPARATOR) {
+        if options.treat_as_template && prefix_from_template.contains(MAIN_SEPARATOR) {
             return Err(MkTempError::PrefixContainsDirSeparator(options.template));
         }
         if tmpdir.is_some() && Path::new(prefix_from_template).is_absolute() {
diff --git a/src/uu/more/Cargo.toml b/src/uu/more/Cargo.toml
index 01bb96183..ff677ad87 100644
--- a/src/uu/more/Cargo.toml
+++ b/src/uu/more/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_more"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "more ~ (uutils) input perusal filter"
@@ -15,15 +15,15 @@ edition = "2021"
 path = "src/more.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true }
-crossterm = { workspace=true }
-is-terminal = { workspace=true }
-unicode-width = { workspace=true }
-unicode-segmentation = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true }
+crossterm = { workspace = true }
+is-terminal = { workspace = true }
+unicode-width = { workspace = true }
+unicode-segmentation = { workspace = true }
 
 [target.'cfg(all(unix, not(target_os = "fuchsia")))'.dependencies]
-nix = { workspace=true }
+nix = { workspace = true }
 
 [[bin]]
 name = "more"
diff --git a/src/uu/more/more.md b/src/uu/more/more.md
new file mode 100644
index 000000000..cb626060e
--- /dev/null
+++ b/src/uu/more/more.md
@@ -0,0 +1,8 @@
+# more
+
+```
+more [OPTIONS] <FILE>...
+```
+
+Display the contents of a text file
+
diff --git a/src/uu/more/src/more.rs b/src/uu/more/src/more.rs
index 31b1640a2..a43489566 100644
--- a/src/uu/more/src/more.rs
+++ b/src/uu/more/src/more.rs
@@ -14,13 +14,14 @@ use std::{
     time::Duration,
 };
 
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{crate_version, value_parser, Arg, ArgAction, ArgMatches, Command};
 use crossterm::event::KeyEventKind;
 use crossterm::{
+    cursor::{MoveTo, MoveUp},
     event::{self, Event, KeyCode, KeyEvent, KeyModifiers},
     execute, queue,
     style::Attribute,
-    terminal,
+    terminal::{self, Clear, ClearType},
 };
 
 use is_terminal::IsTerminal;
@@ -28,7 +29,10 @@ use unicode_segmentation::UnicodeSegmentation;
 use unicode_width::UnicodeWidthStr;
 use uucore::display::Quotable;
 use uucore::error::{UResult, USimpleError, UUsageError};
+use uucore::{format_usage, help_about, help_usage};
 
+const ABOUT: &str = help_about!("more.md");
+const USAGE: &str = help_usage!("more.md");
 const BELL: &str = "\x07";
 
 pub mod options {
@@ -48,12 +52,48 @@ pub mod options {
 
 const MULTI_FILE_TOP_PROMPT: &str = "::::::::::::::\n{}\n::::::::::::::\n";
 
+struct Options {
+    clean_print: bool,
+    lines: Option<u16>,
+    print_over: bool,
+    silent: bool,
+    squeeze: bool,
+}
+
+impl Options {
+    fn from(matches: &ArgMatches) -> Self {
+        let lines = match (
+            matches.get_one::<u16>(options::LINES).copied(),
+            matches.get_one::<u16>(options::NUMBER).copied(),
+        ) {
+            // We add 1 to the number of lines to display because the last line
+            // is used for the banner
+            (Some(number), _) if number > 0 => Some(number + 1),
+            (None, Some(number)) if number > 0 => Some(number + 1),
+            (_, _) => None,
+        };
+        Self {
+            clean_print: matches.get_flag(options::CLEAN_PRINT),
+            lines,
+            print_over: matches.get_flag(options::PRINT_OVER),
+            silent: matches.get_flag(options::SILENT),
+            squeeze: matches.get_flag(options::SQUEEZE),
+        }
+    }
+}
+
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let matches = uu_app().get_matches_from(args);
+    let args = args.collect_lossy();
+    let matches = match uu_app().try_get_matches_from(&args) {
+        Ok(m) => m,
+        Err(e) => return Err(e.into()),
+    };
+
+    let options = Options::from(&matches);
 
     let mut buff = String::new();
-    let silent = matches.get_flag(options::SILENT);
+
     if let Some(files) = matches.get_many::<String>(options::FILES) {
         let mut stdout = setup_term();
         let length = files.len();
@@ -78,16 +118,26 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             if length > 1 {
                 buff.push_str(&MULTI_FILE_TOP_PROMPT.replace("{}", file.to_str().unwrap()));
             }
-            let mut reader = BufReader::new(File::open(file).unwrap());
+            let opened_file = match File::open(file) {
+                Err(why) => {
+                    terminal::disable_raw_mode().unwrap();
+                    return Err(USimpleError::new(
+                        1,
+                        format!("cannot open {}: {}", file.quote(), why.kind()),
+                    ));
+                }
+                Ok(opened_file) => opened_file,
+            };
+            let mut reader = BufReader::new(opened_file);
             reader.read_to_string(&mut buff).unwrap();
-            more(&buff, &mut stdout, next_file.copied(), silent)?;
+            more(&buff, &mut stdout, next_file.copied(), &options)?;
             buff.clear();
         }
         reset_term(&mut stdout);
     } else if !std::io::stdin().is_terminal() {
         stdin().read_to_string(&mut buff).unwrap();
         let mut stdout = setup_term();
-        more(&buff, &mut stdout, None, silent)?;
+        more(&buff, &mut stdout, None, &options)?;
         reset_term(&mut stdout);
     } else {
         return Err(UUsageError::new(1, "bad usage"));
@@ -97,9 +147,17 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .about("A file perusal filter for CRT viewing.")
+        .about(ABOUT)
+        .override_usage(format_usage(USAGE))
         .version(crate_version!())
         .infer_long_args(true)
+        .arg(
+            Arg::new(options::PRINT_OVER)
+                .short('c')
+                .long(options::PRINT_OVER)
+                .help("Do not scroll, display text and clean line ends")
+                .action(ArgAction::SetTrue),
+        )
         .arg(
             Arg::new(options::SILENT)
                 .short('d')
@@ -107,6 +165,37 @@ pub fn uu_app() -> Command {
                 .help("Display help instead of ringing bell")
                 .action(ArgAction::SetTrue),
         )
+        .arg(
+            Arg::new(options::CLEAN_PRINT)
+                .short('p')
+                .long(options::CLEAN_PRINT)
+                .help("Do not scroll, clean screen and display text")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::SQUEEZE)
+                .short('s')
+                .long(options::SQUEEZE)
+                .help("Squeeze multiple blank lines into one")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::LINES)
+                .short('n')
+                .long(options::LINES)
+                .value_name("number")
+                .num_args(1)
+                .value_parser(value_parser!(u16).range(0..))
+                .help("The number of lines per screen full"),
+        )
+        .arg(
+            Arg::new(options::NUMBER)
+                .long(options::NUMBER)
+                .required(false)
+                .num_args(1)
+                .value_parser(value_parser!(u16).range(0..))
+                .help("Same as --lines"),
+        )
         // The commented arguments below are unimplemented:
         /*
         .arg(
@@ -121,46 +210,12 @@ pub fn uu_app() -> Command {
                 .long(options::NO_PAUSE)
                 .help("Suppress pause after form feed"),
         )
-        .arg(
-            Arg::new(options::PRINT_OVER)
-                .short('c')
-                .long(options::PRINT_OVER)
-                .help("Do not scroll, display text and clean line ends"),
-        )
-        .arg(
-            Arg::new(options::CLEAN_PRINT)
-                .short('p')
-                .long(options::CLEAN_PRINT)
-                .help("Do not scroll, clean screen and display text"),
-        )
-        .arg(
-            Arg::new(options::SQUEEZE)
-                .short('s')
-                .long(options::SQUEEZE)
-                .help("Squeeze multiple blank lines into one"),
-        )
         .arg(
             Arg::new(options::PLAIN)
                 .short('u')
                 .long(options::PLAIN)
                 .help("Suppress underlining and bold"),
         )
-        .arg(
-            Arg::new(options::LINES)
-                .short('n')
-                .long(options::LINES)
-                .value_name("number")
-                .takes_value(true)
-                .help("The number of lines per screen full"),
-        )
-        .arg(
-            Arg::new(options::NUMBER)
-                .allow_hyphen_values(true)
-                .long(options::NUMBER)
-                .required(false)
-                .takes_value(true)
-                .help("Same as --lines"),
-        )
         .arg(
             Arg::new(options::FROM_LINE)
                 .short('F')
@@ -205,7 +260,7 @@ fn setup_term() -> usize {
 fn reset_term(stdout: &mut std::io::Stdout) {
     terminal::disable_raw_mode().unwrap();
     // Clear the prompt
-    queue!(stdout, terminal::Clear(terminal::ClearType::CurrentLine)).unwrap();
+    queue!(stdout, terminal::Clear(ClearType::CurrentLine)).unwrap();
     // Move cursor to the beginning without printing new line
     print!("\r");
     stdout.flush().unwrap();
@@ -215,11 +270,20 @@ fn reset_term(stdout: &mut std::io::Stdout) {
 #[inline(always)]
 fn reset_term(_: &mut usize) {}
 
-fn more(buff: &str, stdout: &mut Stdout, next_file: Option<&str>, silent: bool) -> UResult<()> {
-    let (cols, rows) = terminal::size().unwrap();
+fn more(
+    buff: &str,
+    stdout: &mut Stdout,
+    next_file: Option<&str>,
+    options: &Options,
+) -> UResult<()> {
+    let (cols, mut rows) = terminal::size().unwrap();
+    if let Some(number) = options.lines {
+        rows = number;
+    }
+
     let lines = break_buff(buff, usize::from(cols));
 
-    let mut pager = Pager::new(rows, lines, next_file, silent);
+    let mut pager = Pager::new(rows, lines, next_file, options);
     pager.draw(stdout, None);
     if pager.should_close() {
         return Ok(());
@@ -253,6 +317,11 @@ fn more(buff: &str, stdout: &mut Stdout, next_file: Option<&str>, silent: bool)
                     modifiers: KeyModifiers::NONE,
                     ..
                 })
+                | Event::Key(KeyEvent {
+                    code: KeyCode::PageDown,
+                    modifiers: KeyModifiers::NONE,
+                    ..
+                })
                 | Event::Key(KeyEvent {
                     code: KeyCode::Char(' '),
                     modifiers: KeyModifiers::NONE,
@@ -268,8 +337,14 @@ fn more(buff: &str, stdout: &mut Stdout, next_file: Option<&str>, silent: bool)
                     code: KeyCode::Up,
                     modifiers: KeyModifiers::NONE,
                     ..
+                })
+                | Event::Key(KeyEvent {
+                    code: KeyCode::PageUp,
+                    modifiers: KeyModifiers::NONE,
+                    ..
                 }) => {
                     pager.page_up();
+                    paging_add_back_message(options, stdout)?;
                 }
                 Event::Key(KeyEvent {
                     code: KeyCode::Char('j'),
@@ -290,7 +365,7 @@ fn more(buff: &str, stdout: &mut Stdout, next_file: Option<&str>, silent: bool)
                     pager.prev_line();
                 }
                 Event::Resize(col, row) => {
-                    pager.page_resize(col, row);
+                    pager.page_resize(col, row, options.lines);
                 }
                 Event::Key(KeyEvent {
                     code: KeyCode::Char(k),
@@ -299,6 +374,16 @@ fn more(buff: &str, stdout: &mut Stdout, next_file: Option<&str>, silent: bool)
                 _ => continue,
             }
 
+            if options.print_over {
+                execute!(
+                    std::io::stdout(),
+                    MoveTo(0, 0),
+                    Clear(ClearType::FromCursorDown)
+                )
+                .unwrap();
+            } else if options.clean_print {
+                execute!(std::io::stdout(), Clear(ClearType::All), MoveTo(0, 0)).unwrap();
+            }
             pager.draw(stdout, wrong_key);
         }
     }
@@ -313,10 +398,12 @@ struct Pager<'a> {
     next_file: Option<&'a str>,
     line_count: usize,
     silent: bool,
+    squeeze: bool,
+    line_squeezed: usize,
 }
 
 impl<'a> Pager<'a> {
-    fn new(rows: u16, lines: Vec<String>, next_file: Option<&'a str>, silent: bool) -> Self {
+    fn new(rows: u16, lines: Vec<String>, next_file: Option<&'a str>, options: &Options) -> Self {
         let line_count = lines.len();
         Self {
             upper_mark: 0,
@@ -324,7 +411,9 @@ impl<'a> Pager<'a> {
             lines,
             next_file,
             line_count,
-            silent,
+            silent: options.silent,
+            squeeze: options.squeeze,
+            line_squeezed: 0,
         }
     }
 
@@ -350,7 +439,21 @@ impl<'a> Pager<'a> {
     }
 
     fn page_up(&mut self) {
-        self.upper_mark = self.upper_mark.saturating_sub(self.content_rows.into());
+        let content_row_usize: usize = self.content_rows.into();
+        self.upper_mark = self
+            .upper_mark
+            .saturating_sub(content_row_usize.saturating_add(self.line_squeezed));
+
+        if self.squeeze {
+            let iter = self.lines.iter().take(self.upper_mark).rev();
+            for line in iter {
+                if line.is_empty() {
+                    self.upper_mark = self.upper_mark.saturating_sub(1);
+                } else {
+                    break;
+                }
+            }
+        }
     }
 
     fn next_line(&mut self) {
@@ -362,11 +465,13 @@ impl<'a> Pager<'a> {
     }
 
     // TODO: Deal with column size changes.
-    fn page_resize(&mut self, _: u16, row: u16) {
-        self.content_rows = row.saturating_sub(1);
+    fn page_resize(&mut self, _: u16, row: u16, option_line: Option<u16>) {
+        if option_line.is_none() {
+            self.content_rows = row.saturating_sub(1);
+        };
     }
 
-    fn draw(&self, stdout: &mut std::io::Stdout, wrong_key: Option<char>) {
+    fn draw(&mut self, stdout: &mut std::io::Stdout, wrong_key: Option<char>) {
         let lower_mark = self
             .line_count
             .min(self.upper_mark.saturating_add(self.content_rows.into()));
@@ -375,13 +480,44 @@ impl<'a> Pager<'a> {
         stdout.flush().unwrap();
     }
 
-    fn draw_lines(&self, stdout: &mut std::io::Stdout) {
+    fn draw_lines(&mut self, stdout: &mut std::io::Stdout) {
         execute!(stdout, terminal::Clear(terminal::ClearType::CurrentLine)).unwrap();
-        let displayed_lines = self
-            .lines
-            .iter()
-            .skip(self.upper_mark)
-            .take(self.content_rows.into());
+
+        self.line_squeezed = 0;
+        let mut previous_line_blank = false;
+        let mut displayed_lines = Vec::new();
+        let mut iter = self.lines.iter().skip(self.upper_mark);
+
+        while displayed_lines.len() < self.content_rows as usize {
+            match iter.next() {
+                Some(line) => {
+                    if self.squeeze {
+                        match (line.is_empty(), previous_line_blank) {
+                            (true, false) => {
+                                previous_line_blank = true;
+                                displayed_lines.push(line);
+                            }
+                            (false, true) => {
+                                previous_line_blank = false;
+                                displayed_lines.push(line);
+                            }
+                            (false, false) => displayed_lines.push(line),
+                            (true, true) => {
+                                self.line_squeezed += 1;
+                                self.upper_mark += 1;
+                            }
+                        }
+                    } else {
+                        displayed_lines.push(line);
+                    }
+                }
+                // if none the end of the file is reached
+                None => {
+                    self.upper_mark = self.line_count;
+                    break;
+                }
+            }
+        }
 
         for line in displayed_lines {
             stdout.write_all(format!("\r{line}\n").as_bytes()).unwrap();
@@ -420,6 +556,14 @@ impl<'a> Pager<'a> {
     }
 }
 
+fn paging_add_back_message(options: &Options, stdout: &mut std::io::Stdout) -> UResult<()> {
+    if options.lines.is_some() {
+        execute!(stdout, MoveUp(1))?;
+        stdout.write_all("\n\r...back 1 page\n".as_bytes())?;
+    }
+    Ok(())
+}
+
 // Break the lines on the cols of the terminal
 fn break_buff(buff: &str, cols: usize) -> Vec<String> {
     let mut lines = Vec::with_capacity(buff.lines().count());
diff --git a/src/uu/mv/Cargo.toml b/src/uu/mv/Cargo.toml
index 87ce36c5f..2e67ec151 100644
--- a/src/uu/mv/Cargo.toml
+++ b/src/uu/mv/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_mv"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "mv ~ (uutils) move (rename) SOURCE to DESTINATION"
@@ -15,10 +15,10 @@ edition = "2021"
 path = "src/mv.rs"
 
 [dependencies]
-clap = { workspace=true }
-fs_extra = { workspace=true }
-indicatif = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+fs_extra = { workspace = true }
+indicatif = { workspace = true }
+uucore = { workspace = true, features = ["fs"] }
 
 [[bin]]
 name = "mv"
diff --git a/src/uu/mv/mv.md b/src/uu/mv/mv.md
new file mode 100644
index 000000000..6fcee4697
--- /dev/null
+++ b/src/uu/mv/mv.md
@@ -0,0 +1,23 @@
+# mv
+
+```
+mv [OPTION]... [-T] SOURCE DEST
+mv [OPTION]... SOURCE... DIRECTORY
+mv [OPTION]... -t DIRECTORY SOURCE...
+```
+Move `SOURCE` to `DEST`, or multiple `SOURCE`(s) to `DIRECTORY`.
+
+## After Help
+
+When specifying more than one of -i, -f, -n, only the final one will take effect.
+
+Do not move a non-directory that has an existing destination with the same or newer modification timestamp;
+instead, silently skip the file without failing. If the move is across file system boundaries, the comparison is
+to the source timestamp truncated to the resolutions of the destination file system and of the system calls used
+to update timestamps; this avoids duplicate work if several `mv -u` commands are executed with the same source
+and destination. This option is ignored if the `-n` or `--no-clobber` option is also specified. which gives more control
+over which existing files in the destination are replaced, and its value can be one of the following:
+
+* `all`    This is the default operation when an `--update` option is not specified, and results in all existing files in the destination being replaced.
+* `none`   This is similar to the `--no-clobber` option, in that no files in the destination are replaced, but also skipping a file does not induce a failure.
+* `older`  This is the default operation when `--update` is specified, and results in files being replaced if they’re older than the corresponding source file.
diff --git a/src/uu/mv/src/error.rs b/src/uu/mv/src/error.rs
index 103c1116a..7810c3a95 100644
--- a/src/uu/mv/src/error.rs
+++ b/src/uu/mv/src/error.rs
@@ -15,6 +15,7 @@ pub enum MvError {
     DirectoryToNonDirectory(String),
     NonDirectoryToDirectory(String, String),
     NotADirectory(String),
+    TargetNotADirectory(String),
 }
 
 impl Error for MvError {}
@@ -34,7 +35,8 @@ impl Display for MvError {
             Self::NonDirectoryToDirectory(s, t) => {
                 write!(f, "cannot overwrite non-directory {t} with directory {s}")
             }
-            Self::NotADirectory(t) => write!(f, "target {t} is not a directory"),
+            Self::NotADirectory(t) => write!(f, "target {t}: Not a directory"),
+            Self::TargetNotADirectory(t) => write!(f, "target directory {t}: Not a directory"),
         }
     }
 }
diff --git a/src/uu/mv/src/mv.rs b/src/uu/mv/src/mv.rs
index 0a1394594..523183b0b 100644
--- a/src/uu/mv/src/mv.rs
+++ b/src/uu/mv/src/mv.rs
@@ -24,8 +24,10 @@ use std::os::windows;
 use std::path::{Path, PathBuf};
 use uucore::backup_control::{self, BackupMode};
 use uucore::display::Quotable;
-use uucore::error::{FromIo, UError, UResult, USimpleError, UUsageError};
-use uucore::{format_usage, prompt_yes, show};
+use uucore::error::{set_exit_code, FromIo, UError, UResult, USimpleError, UUsageError};
+use uucore::fs::are_hardlinks_or_one_way_symlink_to_same_file;
+use uucore::update_control::{self, UpdateMode};
+use uucore::{format_usage, help_about, help_section, help_usage, prompt_yes, show};
 
 use fs_extra::dir::{
     get_size as dir_get_size, move_dir, move_dir_with_progress, CopyOptions as DirCopyOptions,
@@ -38,7 +40,7 @@ pub struct Behavior {
     overwrite: OverwriteMode,
     backup: BackupMode,
     suffix: String,
-    update: bool,
+    update: UpdateMode,
     target_dir: Option<OsString>,
     no_target_dir: bool,
     verbose: bool,
@@ -53,12 +55,9 @@ pub enum OverwriteMode {
     Force,
 }
 
-static ABOUT: &str = "Move SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY.";
-static LONG_HELP: &str = "";
-const USAGE: &str = "\
-    {} [OPTION]... [-T] SOURCE DEST
-    {} [OPTION]... SOURCE... DIRECTORY
-    {} [OPTION]... -t DIRECTORY SOURCE...";
+const ABOUT: &str = help_about!("mv.md");
+const USAGE: &str = help_usage!("mv.md");
+const AFTER_HELP: &str = help_section!("after help", "mv.md");
 
 static OPT_FORCE: &str = "force";
 static OPT_INTERACTIVE: &str = "interactive";
@@ -66,19 +65,13 @@ static OPT_NO_CLOBBER: &str = "no-clobber";
 static OPT_STRIP_TRAILING_SLASHES: &str = "strip-trailing-slashes";
 static OPT_TARGET_DIRECTORY: &str = "target-directory";
 static OPT_NO_TARGET_DIRECTORY: &str = "no-target-directory";
-static OPT_UPDATE: &str = "update";
 static OPT_VERBOSE: &str = "verbose";
 static OPT_PROGRESS: &str = "progress";
 static ARG_FILES: &str = "files";
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let help = format!(
-        "{}\n{}",
-        LONG_HELP,
-        backup_control::BACKUP_CONTROL_LONG_HELP
-    );
-    let mut app = uu_app().after_help(help);
+    let mut app = uu_app();
     let matches = app.try_get_matches_from_mut(args)?;
 
     if !matches.contains_id(OPT_TARGET_DIRECTORY)
@@ -105,6 +98,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
     let overwrite_mode = determine_overwrite_mode(&matches);
     let backup_mode = backup_control::determine_backup_mode(&matches)?;
+    let update_mode = update_control::determine_update_mode(&matches);
 
     if overwrite_mode == OverwriteMode::NoClobber && backup_mode != BackupMode::NoBackup {
         return Err(UUsageError::new(
@@ -115,14 +109,22 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
     let backup_suffix = backup_control::determine_backup_suffix(&matches);
 
+    let target_dir = matches
+        .get_one::<OsString>(OPT_TARGET_DIRECTORY)
+        .map(OsString::from);
+
+    if let Some(ref maybe_dir) = target_dir {
+        if !Path::new(&maybe_dir).is_dir() {
+            return Err(MvError::TargetNotADirectory(maybe_dir.quote().to_string()).into());
+        }
+    }
+
     let behavior = Behavior {
         overwrite: overwrite_mode,
         backup: backup_mode,
         suffix: backup_suffix,
-        update: matches.get_flag(OPT_UPDATE),
-        target_dir: matches
-            .get_one::<OsString>(OPT_TARGET_DIRECTORY)
-            .map(OsString::from),
+        update: update_mode,
+        target_dir,
         no_target_dir: matches.get_flag(OPT_NO_TARGET_DIRECTORY),
         verbose: matches.get_flag(OPT_VERBOSE),
         strip_slashes: matches.get_flag(OPT_STRIP_TRAILING_SLASHES),
@@ -137,14 +139,17 @@ pub fn uu_app() -> Command {
         .version(crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
+        .after_help(format!(
+            "{AFTER_HELP}\n\n{}",
+            backup_control::BACKUP_CONTROL_LONG_HELP
+        ))
         .infer_long_args(true)
-        .arg(backup_control::arguments::backup())
-        .arg(backup_control::arguments::backup_no_args())
         .arg(
             Arg::new(OPT_FORCE)
                 .short('f')
                 .long(OPT_FORCE)
                 .help("do not prompt before overwriting")
+                .overrides_with_all([OPT_INTERACTIVE, OPT_NO_CLOBBER])
                 .action(ArgAction::SetTrue),
         )
         .arg(
@@ -152,6 +157,7 @@ pub fn uu_app() -> Command {
                 .short('i')
                 .long(OPT_INTERACTIVE)
                 .help("prompt before override")
+                .overrides_with_all([OPT_FORCE, OPT_NO_CLOBBER])
                 .action(ArgAction::SetTrue),
         )
         .arg(
@@ -159,6 +165,7 @@ pub fn uu_app() -> Command {
                 .short('n')
                 .long(OPT_NO_CLOBBER)
                 .help("do not overwrite an existing file")
+                .overrides_with_all([OPT_FORCE, OPT_INTERACTIVE])
                 .action(ArgAction::SetTrue),
         )
         .arg(
@@ -167,7 +174,11 @@ pub fn uu_app() -> Command {
                 .help("remove any trailing slashes from each SOURCE argument")
                 .action(ArgAction::SetTrue),
         )
+        .arg(backup_control::arguments::backup())
+        .arg(backup_control::arguments::backup_no_args())
         .arg(backup_control::arguments::suffix())
+        .arg(update_control::arguments::update())
+        .arg(update_control::arguments::update_no_args())
         .arg(
             Arg::new(OPT_TARGET_DIRECTORY)
                 .short('t')
@@ -185,16 +196,6 @@ pub fn uu_app() -> Command {
                 .help("treat DEST as a normal file")
                 .action(ArgAction::SetTrue),
         )
-        .arg(
-            Arg::new(OPT_UPDATE)
-                .short('u')
-                .long(OPT_UPDATE)
-                .help(
-                    "move only when the SOURCE file is newer than the destination file \
-                       or when the destination file is missing",
-                )
-                .action(ArgAction::SetTrue),
-        )
         .arg(
             Arg::new(OPT_VERBOSE)
                 .short('v')
@@ -237,96 +238,94 @@ fn determine_overwrite_mode(matches: &ArgMatches) -> OverwriteMode {
     }
 }
 
-fn exec(files: &[OsString], b: &Behavior) -> UResult<()> {
-    let paths: Vec<PathBuf> = {
-        let paths = files.iter().map(Path::new);
+fn parse_paths(files: &[OsString], b: &Behavior) -> Vec<PathBuf> {
+    let paths = files.iter().map(Path::new);
 
-        // Strip slashes from path, if strip opt present
-        if b.strip_slashes {
-            paths
-                .map(|p| p.components().as_path().to_owned())
-                .collect::<Vec<PathBuf>>()
+    if b.strip_slashes {
+        paths
+            .map(|p| p.components().as_path().to_owned())
+            .collect::<Vec<PathBuf>>()
+    } else {
+        paths.map(|p| p.to_owned()).collect::<Vec<PathBuf>>()
+    }
+}
+
+fn handle_two_paths(source: &Path, target: &Path, b: &Behavior) -> UResult<()> {
+    if source.symlink_metadata().is_err() {
+        return Err(MvError::NoSuchFile(source.quote().to_string()).into());
+    }
+
+    if (source.eq(target) || are_hardlinks_or_one_way_symlink_to_same_file(source, target))
+        && b.backup != BackupMode::SimpleBackup
+    {
+        if source.eq(Path::new(".")) || source.ends_with("/.") || source.is_file() {
+            return Err(
+                MvError::SameFile(source.quote().to_string(), target.quote().to_string()).into(),
+            );
         } else {
-            paths.map(|p| p.to_owned()).collect::<Vec<PathBuf>>()
+            return Err(MvError::SelfSubdirectory(source.display().to_string()).into());
         }
-    };
+    }
+
+    if target.is_dir() {
+        if b.no_target_dir {
+            if source.is_dir() {
+                rename(source, target, b, None).map_err_context(|| {
+                    format!("cannot move {} to {}", source.quote(), target.quote())
+                })
+            } else {
+                Err(MvError::DirectoryToNonDirectory(target.quote().to_string()).into())
+            }
+        } else {
+            move_files_into_dir(&[source.to_path_buf()], target, b)
+        }
+    } else if target.exists() && source.is_dir() {
+        match b.overwrite {
+            OverwriteMode::NoClobber => return Ok(()),
+            OverwriteMode::Interactive => {
+                if !prompt_yes!("overwrite {}? ", target.quote()) {
+                    return Err(io::Error::new(io::ErrorKind::Other, "").into());
+                }
+            }
+            OverwriteMode::Force => {}
+        };
+        Err(MvError::NonDirectoryToDirectory(
+            source.quote().to_string(),
+            target.quote().to_string(),
+        )
+        .into())
+    } else {
+        rename(source, target, b, None).map_err(|e| USimpleError::new(1, format!("{e}")))
+    }
+}
+
+fn handle_multiple_paths(paths: &[PathBuf], b: &Behavior) -> UResult<()> {
+    if b.no_target_dir {
+        return Err(UUsageError::new(
+            1,
+            format!("mv: extra operand {}", paths[2].quote()),
+        ));
+    }
+    let target_dir = paths.last().unwrap();
+    let sources = &paths[..paths.len() - 1];
+
+    move_files_into_dir(sources, target_dir, b)
+}
+
+fn exec(files: &[OsString], b: &Behavior) -> UResult<()> {
+    let paths = parse_paths(files, b);
 
     if let Some(ref name) = b.target_dir {
         return move_files_into_dir(&paths, &PathBuf::from(name), b);
     }
+
     match paths.len() {
-        /* case 0/1 are not possible thanks to clap */
-        2 => {
-            let source = &paths[0];
-            let target = &paths[1];
-            // Here we use the `symlink_metadata()` method instead of `exists()`,
-            // since it handles dangling symlinks correctly. The method gives an
-            // `Ok()` results unless the source does not exist, or the user
-            // lacks permission to access metadata.
-            if source.symlink_metadata().is_err() {
-                return Err(MvError::NoSuchFile(source.quote().to_string()).into());
-            }
-
-            // GNU semantics are: if the source and target are the same, no move occurs and we print an error
-            if source.eq(target) {
-                // Done to match GNU semantics for the dot file
-                if source.eq(Path::new(".")) || source.ends_with("/.") || source.is_file() {
-                    return Err(MvError::SameFile(
-                        source.quote().to_string(),
-                        target.quote().to_string(),
-                    )
-                    .into());
-                } else {
-                    return Err(MvError::SelfSubdirectory(source.display().to_string()).into());
-                }
-            }
-
-            if target.is_dir() {
-                if b.no_target_dir {
-                    if source.is_dir() {
-                        rename(source, target, b, None).map_err_context(|| {
-                            format!("cannot move {} to {}", source.quote(), target.quote())
-                        })
-                    } else {
-                        Err(MvError::DirectoryToNonDirectory(target.quote().to_string()).into())
-                    }
-                } else {
-                    move_files_into_dir(&[source.clone()], target, b)
-                }
-            } else if target.exists() && source.is_dir() {
-                match b.overwrite {
-                    OverwriteMode::NoClobber => return Ok(()),
-                    OverwriteMode::Interactive => {
-                        if !prompt_yes!("overwrite {}? ", target.quote()) {
-                            return Ok(());
-                        }
-                    }
-                    OverwriteMode::Force => {}
-                };
-                Err(MvError::NonDirectoryToDirectory(
-                    source.quote().to_string(),
-                    target.quote().to_string(),
-                )
-                .into())
-            } else {
-                rename(source, target, b, None).map_err(|e| USimpleError::new(1, format!("{e}")))
-            }
-        }
-        _ => {
-            if b.no_target_dir {
-                return Err(UUsageError::new(
-                    1,
-                    format!("mv: extra operand {}", files[2].quote()),
-                ));
-            }
-            let target_dir = paths.last().unwrap();
-            let sources = &paths[..paths.len() - 1];
-
-            move_files_into_dir(sources, target_dir, b)
-        }
+        2 => handle_two_paths(&paths[0], &paths[1], b),
+        _ => handle_multiple_paths(&paths, b),
     }
 }
 
+#[allow(clippy::cognitive_complexity)]
 fn move_files_into_dir(files: &[PathBuf], target_dir: &Path, b: &Behavior) -> UResult<()> {
     if !target_dir.is_dir() {
         return Err(MvError::NotADirectory(target_dir.quote().to_string()).into());
@@ -387,21 +386,23 @@ fn move_files_into_dir(files: &[PathBuf], target_dir: &Path, b: &Behavior) -> UR
             }
         }
 
-        let rename_result = rename(sourcepath, &targetpath, b, multi_progress.as_ref())
-            .map_err_context(|| {
-                format!(
-                    "cannot move {} to {}",
-                    sourcepath.quote(),
-                    targetpath.quote()
-                )
-            });
-
-        if let Err(e) = rename_result {
-            match multi_progress {
-                Some(ref pb) => pb.suspend(|| show!(e)),
-                None => show!(e),
-            };
-        };
+        match rename(sourcepath, &targetpath, b, multi_progress.as_ref()) {
+            Err(e) if e.to_string() == "" => set_exit_code(1),
+            Err(e) => {
+                let e = e.map_err_context(|| {
+                    format!(
+                        "cannot move {} to {}",
+                        sourcepath.quote(),
+                        targetpath.quote()
+                    )
+                });
+                match multi_progress {
+                    Some(ref pb) => pb.suspend(|| show!(e)),
+                    None => show!(e),
+                };
+            }
+            Ok(()) => (),
+        }
 
         if let Some(ref pb) = count_progress {
             pb.inc(1);
@@ -419,17 +420,40 @@ fn rename(
     let mut backup_path = None;
 
     if to.exists() {
-        if b.update && b.overwrite == OverwriteMode::Interactive {
+        if (b.update == UpdateMode::ReplaceIfOlder || b.update == UpdateMode::ReplaceNone)
+            && b.overwrite == OverwriteMode::Interactive
+        {
             // `mv -i --update old new` when `new` exists doesn't move anything
             // and exit with 0
             return Ok(());
         }
 
+        if b.update == UpdateMode::ReplaceNone {
+            return Ok(());
+        }
+
+        if (b.update == UpdateMode::ReplaceIfOlder)
+            && fs::metadata(from)?.modified()? <= fs::metadata(to)?.modified()?
+        {
+            return Ok(());
+        }
+
         match b.overwrite {
-            OverwriteMode::NoClobber => return Ok(()),
+            OverwriteMode::NoClobber => {
+                let err_msg = if b.verbose {
+                    println!("skipped {}", to.quote());
+                    String::new()
+                } else {
+                    format!("not replacing {}", to.quote())
+                };
+                return Err(io::Error::new(io::ErrorKind::Other, err_msg));
+            }
             OverwriteMode::Interactive => {
                 if !prompt_yes!("overwrite {}?", to.quote()) {
-                    return Ok(());
+                    if b.verbose {
+                        println!("skipped {}", to.quote());
+                    }
+                    return Err(io::Error::new(io::ErrorKind::Other, ""));
                 }
             }
             OverwriteMode::Force => {}
@@ -439,10 +463,6 @@ fn rename(
         if let Some(ref backup_path) = backup_path {
             rename_with_fallback(to, backup_path, multi_progress)?;
         }
-
-        if b.update && fs::metadata(from)?.modified()? <= fs::metadata(to)?.modified()? {
-            return Ok(());
-        }
     }
 
     // "to" may no longer exist if it was backed up
@@ -462,12 +482,12 @@ fn rename(
     if b.verbose {
         let message = match backup_path {
             Some(path) => format!(
-                "{} -> {} (backup: {})",
+                "renamed {} -> {} (backup: {})",
                 from.quote(),
                 to.quote(),
                 path.quote()
             ),
-            None => format!("{} -> {}", from.quote(), to.quote()),
+            None => format!("renamed {} -> {}", from.quote(), to.quote()),
         };
 
         match multi_progress {
diff --git a/src/uu/nice/Cargo.toml b/src/uu/nice/Cargo.toml
index 054daf273..70d6f0f87 100644
--- a/src/uu/nice/Cargo.toml
+++ b/src/uu/nice/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_nice"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "nice ~ (uutils) run PROGRAM with modified scheduling priority"
@@ -15,10 +15,10 @@ edition = "2021"
 path = "src/nice.rs"
 
 [dependencies]
-clap = { workspace=true }
-libc = { workspace=true }
-nix = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+libc = { workspace = true }
+nix = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "nice"
diff --git a/src/uu/nice/nice.md b/src/uu/nice/nice.md
new file mode 100644
index 000000000..872c239ca
--- /dev/null
+++ b/src/uu/nice/nice.md
@@ -0,0 +1,10 @@
+# nice
+
+```
+nice [OPTIONS] [COMMAND [ARGS]]
+```
+
+Run `COMMAND` with an adjusted niceness, which affects process scheduling.
+With no `COMMAND`, print the current niceness.  Niceness values range from at
+least -20 (most favorable to the process) to 19 (least favorable to the
+process).
diff --git a/src/uu/nice/src/nice.rs b/src/uu/nice/src/nice.rs
index a059e13b7..b23608ff6 100644
--- a/src/uu/nice/src/nice.rs
+++ b/src/uu/nice/src/nice.rs
@@ -15,7 +15,7 @@ use std::ptr;
 use clap::{crate_version, Arg, ArgAction, Command};
 use uucore::{
     error::{set_exit_code, UClapError, UResult, USimpleError, UUsageError},
-    format_usage, show_error,
+    format_usage, help_about, help_usage, show_error,
 };
 
 pub mod options {
@@ -23,12 +23,8 @@ pub mod options {
     pub static COMMAND: &str = "COMMAND";
 }
 
-const ABOUT: &str = "\
-    Run COMMAND with an adjusted niceness, which affects process scheduling. \
-    With no COMMAND, print the current niceness.  Niceness values range from at \
-    least -20 (most favorable to the process) to 19 (least favorable to the \
-    process).";
-const USAGE: &str = "{} [OPTIONS] [COMMAND [ARGS]]";
+const ABOUT: &str = help_about!("nice.md");
+const USAGE: &str = help_usage!("nice.md");
 
 fn is_prefix_of(maybe_prefix: &str, target: &str, min_match: usize) -> bool {
     if maybe_prefix.len() < min_match || maybe_prefix.len() > target.len() {
diff --git a/src/uu/nl/Cargo.toml b/src/uu/nl/Cargo.toml
index 5dd539db8..020eba829 100644
--- a/src/uu/nl/Cargo.toml
+++ b/src/uu/nl/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_nl"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "nl ~ (uutils) display input with added line numbers"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/nl.rs"
 
 [dependencies]
-clap = { workspace=true }
-regex = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+regex = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "nl"
diff --git a/src/uu/nl/nl.md b/src/uu/nl/nl.md
new file mode 100644
index 000000000..b64b9f627
--- /dev/null
+++ b/src/uu/nl/nl.md
@@ -0,0 +1,7 @@
+#nl
+
+```
+nl [OPTION]... [FILE]...
+```
+
+Number lines of files
diff --git a/src/uu/nl/src/helper.rs b/src/uu/nl/src/helper.rs
index fa59d329a..a62936d75 100644
--- a/src/uu/nl/src/helper.rs
+++ b/src/uu/nl/src/helper.rs
@@ -25,6 +25,7 @@ fn parse_style(chars: &[char]) -> Result<crate::NumberingStyle, String> {
 
 // parse_options loads the options into the settings, returning an array of
 // error messages.
+#[allow(clippy::cognitive_complexity)]
 pub fn parse_options(settings: &mut crate::Settings, opts: &clap::ArgMatches) -> Vec<String> {
     // This vector holds error messages encountered.
     let mut errs: Vec<String> = vec![];
diff --git a/src/uu/nl/src/nl.rs b/src/uu/nl/src/nl.rs
index 54d0cfea9..44fdec8c7 100644
--- a/src/uu/nl/src/nl.rs
+++ b/src/uu/nl/src/nl.rs
@@ -14,12 +14,12 @@ use std::io::{stdin, BufRead, BufReader, Read};
 use std::iter::repeat;
 use std::path::Path;
 use uucore::error::{FromIo, UResult, USimpleError};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
 
 mod helper;
 
-static ABOUT: &str = "Number lines of files";
-static USAGE: &str = "{} [OPTION]... [FILE]...";
+static ABOUT: &str = help_about!("nl.md");
+static USAGE: &str = help_usage!("nl.md");
 
 // Settings store options used by nl to produce its output.
 pub struct Settings {
@@ -236,6 +236,7 @@ pub fn uu_app() -> Command {
 }
 
 // nl implements the main functionality for an individual buffer.
+#[allow(clippy::cognitive_complexity)]
 fn nl<T: Read>(reader: &mut BufReader<T>, settings: &Settings) -> UResult<()> {
     let regexp: regex::Regex = regex::Regex::new(r".?").unwrap();
     let mut line_no = settings.starting_line_number;
diff --git a/src/uu/nohup/Cargo.toml b/src/uu/nohup/Cargo.toml
index f35869506..74bdd89ae 100644
--- a/src/uu/nohup/Cargo.toml
+++ b/src/uu/nohup/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_nohup"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "nohup ~ (uutils) run COMMAND, ignoring hangup signals"
@@ -15,10 +15,10 @@ edition = "2021"
 path = "src/nohup.rs"
 
 [dependencies]
-clap = { workspace=true }
-libc = { workspace=true }
-is-terminal = { workspace=true }
-uucore = { workspace=true, features=["fs"] }
+clap = { workspace = true }
+libc = { workspace = true }
+is-terminal = { workspace = true }
+uucore = { workspace = true, features = ["fs"] }
 
 [[bin]]
 name = "nohup"
diff --git a/src/uu/nproc/Cargo.toml b/src/uu/nproc/Cargo.toml
index c2c224a40..239afef5e 100644
--- a/src/uu/nproc/Cargo.toml
+++ b/src/uu/nproc/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_nproc"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "nproc ~ (uutils) display the number of processing units available"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/nproc.rs"
 
 [dependencies]
-libc = { workspace=true }
-clap = { workspace=true }
-uucore = { workspace=true, features=["fs"] }
+libc = { workspace = true }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["fs"] }
 
 [[bin]]
 name = "nproc"
diff --git a/src/uu/nproc/nproc.md b/src/uu/nproc/nproc.md
new file mode 100644
index 000000000..fee958a92
--- /dev/null
+++ b/src/uu/nproc/nproc.md
@@ -0,0 +1,9 @@
+# nproc
+
+```
+nproc [OPTIONS]...
+```
+
+Print the number of cores available to the current process.
+If the `OMP_NUM_THREADS` or `OMP_THREAD_LIMIT` environment variables are set, then
+they will determine the minimum and maximum returned value respectively.
diff --git a/src/uu/nproc/src/nproc.rs b/src/uu/nproc/src/nproc.rs
index fbfeebb23..2b6cae04e 100644
--- a/src/uu/nproc/src/nproc.rs
+++ b/src/uu/nproc/src/nproc.rs
@@ -11,7 +11,7 @@ use clap::{crate_version, Arg, ArgAction, Command};
 use std::{env, thread};
 use uucore::display::Quotable;
 use uucore::error::{UResult, USimpleError};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
 pub const _SC_NPROCESSORS_CONF: libc::c_int = 83;
@@ -25,10 +25,8 @@ pub const _SC_NPROCESSORS_CONF: libc::c_int = 1001;
 static OPT_ALL: &str = "all";
 static OPT_IGNORE: &str = "ignore";
 
-static ABOUT: &str = r#"Print the number of cores available to the current process.
-If the OMP_NUM_THREADS or OMP_THREAD_LIMIT environment variables are set, then
-they will determine the minimum and maximum returned value respectively."#;
-const USAGE: &str = "{} [OPTIONS]...";
+const ABOUT: &str = help_about!("nproc.md");
+const USAGE: &str = help_usage!("nproc.md");
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
diff --git a/src/uu/numfmt/Cargo.toml b/src/uu/numfmt/Cargo.toml
index 2e68cbab2..e17b4e56e 100644
--- a/src/uu/numfmt/Cargo.toml
+++ b/src/uu/numfmt/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_numfmt"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "numfmt ~ (uutils) reformat NUMBER"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/numfmt.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "numfmt"
diff --git a/src/uu/numfmt/numfmt.md b/src/uu/numfmt/numfmt.md
index 74af2b016..7c75736c1 100644
--- a/src/uu/numfmt/numfmt.md
+++ b/src/uu/numfmt/numfmt.md
@@ -1,6 +1,7 @@
-<!-- spell-checker:ignore N'th M'th -->
 # numfmt
 
+<!-- spell-checker:ignore N'th M'th -->
+
 ```
 numfmt [OPTION]... [NUMBER]...
 ```
@@ -10,24 +11,25 @@ Convert numbers from/to human-readable strings
 ## After Help
 
 `UNIT` options:
- - `none`: no auto-scaling is done; suffixes will trigger an error
- - `auto`: accept optional single/two letter suffix:
 
-       1K = 1000, 1Ki = 1024, 1M = 1000000, 1Mi = 1048576,
+- `none`: no auto-scaling is done; suffixes will trigger an error
+- `auto`: accept optional single/two letter suffix:
 
- - `si`: accept optional single letter suffix:
+    1K = 1000, 1Ki = 1024, 1M = 1000000, 1Mi = 1048576,
 
-       1K = 1000, 1M = 1000000, ...
+- `si`: accept optional single letter suffix:
 
- - `iec`: accept optional single letter suffix:
+    1K = 1000, 1M = 1000000, ...
 
-       1K = 1024, 1M = 1048576, ...
+- `iec`: accept optional single letter suffix:
+
+    1K = 1024, 1M = 1048576, ...
 
 - `iec-i`: accept optional two-letter suffix:
 
-       1Ki = 1024, 1Mi = 1048576, ...
+    1Ki = 1024, 1Mi = 1048576, ...
 
-`FIELDS` supports `cut(1)` style field ranges:
+- `FIELDS` supports `cut(1)` style field ranges:
 
     N    N'th field, counted from 1
     N-   from N'th field, to end of line
diff --git a/src/uu/numfmt/src/format.rs b/src/uu/numfmt/src/format.rs
index 3e20d00ee..eb75f7554 100644
--- a/src/uu/numfmt/src/format.rs
+++ b/src/uu/numfmt/src/format.rs
@@ -55,7 +55,7 @@ impl<'a> Iterator for WhitespaceSplitter<'a> {
                 .unwrap_or(field.len()),
         );
 
-        self.s = if !rest.is_empty() { Some(rest) } else { None };
+        self.s = if rest.is_empty() { None } else { Some(rest) };
 
         Some((prefix, field))
     }
diff --git a/src/uu/numfmt/src/options.rs b/src/uu/numfmt/src/options.rs
index 79d7461ae..b70cf87e4 100644
--- a/src/uu/numfmt/src/options.rs
+++ b/src/uu/numfmt/src/options.rs
@@ -95,6 +95,7 @@ impl FromStr for FormatOptions {
     // An optional zero (%010f) will zero pad the number.
     // An optional negative value (%-10f) will left align.
     // An optional precision (%.1f) determines the precision of the number.
+    #[allow(clippy::cognitive_complexity)]
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let mut iter = s.chars().peekable();
         let mut options = Self::default();
@@ -190,14 +191,12 @@ impl FromStr for FormatOptions {
                 }
             }
 
-            if !precision.is_empty() {
-                if let Ok(p) = precision.parse() {
-                    options.precision = Some(p);
-                } else {
-                    return Err(format!("invalid precision in format '{s}'"));
-                }
-            } else {
+            if precision.is_empty() {
                 options.precision = Some(0);
+            } else if let Ok(p) = precision.parse() {
+                options.precision = Some(p);
+            } else {
+                return Err(format!("invalid precision in format '{s}'"));
             }
         }
 
diff --git a/src/uu/od/Cargo.toml b/src/uu/od/Cargo.toml
index c2bc93731..f26006d7e 100644
--- a/src/uu/od/Cargo.toml
+++ b/src/uu/od/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_od"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "od ~ (uutils) display formatted representation of input"
@@ -15,10 +15,10 @@ edition = "2021"
 path = "src/od.rs"
 
 [dependencies]
-byteorder = { workspace=true }
-clap = { workspace=true }
-half = { workspace=true }
-uucore = { workspace=true }
+byteorder = { workspace = true }
+clap = { workspace = true }
+half = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "od"
diff --git a/src/uu/od/src/inputdecoder.rs b/src/uu/od/src/inputdecoder.rs
index 31e833698..318571cf3 100644
--- a/src/uu/od/src/inputdecoder.rs
+++ b/src/uu/od/src/inputdecoder.rs
@@ -56,7 +56,7 @@ where
     I: PeekRead,
 {
     /// calls `peek_read` on the internal stream to (re)fill the buffer. Returns a
-    /// MemoryDecoder providing access to the result or returns an i/o error.
+    /// `MemoryDecoder` providing access to the result or returns an i/o error.
     pub fn peek_read(&mut self) -> io::Result<MemoryDecoder> {
         match self
             .input
@@ -81,7 +81,7 @@ impl<'a, I> HasError for InputDecoder<'a, I>
 where
     I: HasError,
 {
-    /// calls has_error on the internal stream.
+    /// calls `has_error` on the internal stream.
     fn has_error(&self) -> bool {
         self.input.has_error()
     }
diff --git a/src/uu/od/src/od.rs b/src/uu/od/src/od.rs
index e41776ac4..09765ed2b 100644
--- a/src/uu/od/src/od.rs
+++ b/src/uu/od/src/od.rs
@@ -28,17 +28,17 @@ mod prn_int;
 use std::cmp;
 use std::fmt::Write;
 
-use crate::byteorder_io::*;
-use crate::formatteriteminfo::*;
+use crate::byteorder_io::ByteOrder;
+use crate::formatteriteminfo::FormatWriter;
 use crate::inputdecoder::{InputDecoder, MemoryDecoder};
 use crate::inputoffset::{InputOffset, Radix};
-use crate::multifilereader::*;
+use crate::multifilereader::{HasError, InputSource, MultifileReader};
 use crate::output_info::OutputInfo;
 use crate::parse_formats::{parse_format_flags, ParsedFormatterItemInfo};
 use crate::parse_inputs::{parse_inputs, CommandLineInputs};
 use crate::parse_nrofbytes::parse_number_of_bytes;
-use crate::partialreader::*;
-use crate::peekreader::*;
+use crate::partialreader::PartialReader;
+use crate::peekreader::{PeekRead, PeekReader};
 use crate::prn_char::format_ascii_dump;
 use clap::ArgAction;
 use clap::{crate_version, parser::ValueSource, Arg, ArgMatches, Command};
@@ -48,10 +48,9 @@ use uucore::parse_size::ParseSizeError;
 use uucore::{format_usage, help_about, help_section, help_usage, show_error, show_warning};
 
 const PEEK_BUFFER_SIZE: usize = 4; // utf-8 can be 4 bytes
+
 const ABOUT: &str = help_about!("od.md");
-
 const USAGE: &str = help_usage!("od.md");
-
 const AFTER_HELP: &str = help_section!("after help", "od.md");
 
 pub(crate) mod options {
@@ -172,12 +171,7 @@ impl OdOptions {
             None => Radix::Octal,
             Some(s) => {
                 let st = s.as_bytes();
-                if st.len() != 1 {
-                    return Err(USimpleError::new(
-                        1,
-                        "Radix must be one of [d, o, n, x]".to_string(),
-                    ));
-                } else {
+                if st.len() == 1 {
                     let radix: char = *(st
                         .first()
                         .expect("byte string of length 1 lacks a 0th elem"))
@@ -194,6 +188,11 @@ impl OdOptions {
                             ))
                         }
                     }
+                } else {
+                    return Err(USimpleError::new(
+                        1,
+                        "Radix must be one of [d, o, n, x]".to_string(),
+                    ));
                 }
             }
         };
@@ -460,7 +459,7 @@ pub fn uu_app() -> Command {
         )
 }
 
-/// Loops through the input line by line, calling print_bytes to take care of the output.
+/// Loops through the input line by line, calling `print_bytes` to take care of the output.
 fn odfunc<I>(
     input_offset: &mut InputOffset,
     input_decoder: &mut InputDecoder<I>,
diff --git a/src/uu/od/src/output_info.rs b/src/uu/od/src/output_info.rs
index 60cbaf5ab..211574a61 100644
--- a/src/uu/od/src/output_info.rs
+++ b/src/uu/od/src/output_info.rs
@@ -139,7 +139,7 @@ impl OutputInfo {
     /// ```
     ///
     /// This algorithm assumes the size of all types is a power of 2 (1, 2, 4, 8, 16, ...)
-    /// Increase MAX_BYTES_PER_UNIT to allow larger types.
+    /// Increase `MAX_BYTES_PER_UNIT` to allow larger types.
     fn calculate_alignment(
         sf: &dyn TypeSizeInfo,
         byte_size_block: usize,
diff --git a/src/uu/od/src/parse_formats.rs b/src/uu/od/src/parse_formats.rs
index 9614ed9c0..c414abebe 100644
--- a/src/uu/od/src/parse_formats.rs
+++ b/src/uu/od/src/parse_formats.rs
@@ -96,6 +96,7 @@ fn od_argument_with_option(ch: char) -> bool {
 /// arguments with parameters like -w16 can only appear at the end: -fvoxw16
 /// parameters of -t/--format specify 1 or more formats.
 /// if -- appears on the command line, parsing should stop.
+#[allow(clippy::cognitive_complexity)]
 pub fn parse_format_flags(args: &[String]) -> Result<Vec<ParsedFormatterItemInfo>, String> {
     let mut formats = Vec::new();
 
diff --git a/src/uu/od/src/parse_inputs.rs b/src/uu/od/src/parse_inputs.rs
index 275ab8cfc..3093843d4 100644
--- a/src/uu/od/src/parse_inputs.rs
+++ b/src/uu/od/src/parse_inputs.rs
@@ -90,8 +90,8 @@ pub fn parse_inputs(matches: &dyn CommandLineOpts) -> Result<CommandLineInputs,
 
 /// interprets inputs when --traditional is on the command line
 ///
-/// normally returns CommandLineInputs::FileAndOffset, but if no offset is found,
-/// it returns CommandLineInputs::FileNames (also to differentiate from the offset == 0)
+/// normally returns `CommandLineInputs::FileAndOffset`, but if no offset is found,
+/// it returns `CommandLineInputs::FileNames` (also to differentiate from the offset == 0)
 pub fn parse_inputs_traditional(input_strings: &[&str]) -> Result<CommandLineInputs, String> {
     match input_strings.len() {
         0 => Ok(CommandLineInputs::FileNames(vec!["-".to_string()])),
diff --git a/src/uu/od/src/prn_char.rs b/src/uu/od/src/prn_char.rs
index 495b8eace..7ae6f084c 100644
--- a/src/uu/od/src/prn_char.rs
+++ b/src/uu/od/src/prn_char.rs
@@ -1,6 +1,6 @@
 use std::str::from_utf8;
 
-use crate::formatteriteminfo::*;
+use crate::formatteriteminfo::{FormatWriter, FormatterItemInfo};
 
 pub static FORMAT_ITEM_A: FormatterItemInfo = FormatterItemInfo {
     byte_size: 1,
diff --git a/src/uu/od/src/prn_float.rs b/src/uu/od/src/prn_float.rs
index be1463163..496275574 100644
--- a/src/uu/od/src/prn_float.rs
+++ b/src/uu/od/src/prn_float.rs
@@ -3,7 +3,7 @@ use std::f32;
 use std::f64;
 use std::num::FpCategory;
 
-use crate::formatteriteminfo::*;
+use crate::formatteriteminfo::{FormatWriter, FormatterItemInfo};
 
 pub static FORMAT_ITEM_F16: FormatterItemInfo = FormatterItemInfo {
     byte_size: 2,
diff --git a/src/uu/paste/Cargo.toml b/src/uu/paste/Cargo.toml
index aa1f5fe90..e9a78d828 100644
--- a/src/uu/paste/Cargo.toml
+++ b/src/uu/paste/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_paste"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "paste ~ (uutils) merge lines from inputs"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/paste.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "paste"
diff --git a/src/uu/paste/paste.md b/src/uu/paste/paste.md
new file mode 100644
index 000000000..741605888
--- /dev/null
+++ b/src/uu/paste/paste.md
@@ -0,0 +1,8 @@
+# paste
+
+```
+paste [OPTIONS] [FILE]...
+```
+
+Write lines consisting of the sequentially corresponding lines from each
+`FILE`, separated by `TAB`s, to standard output.
diff --git a/src/uu/paste/src/paste.rs b/src/uu/paste/src/paste.rs
index 3635ae967..6e52727f7 100644
--- a/src/uu/paste/src/paste.rs
+++ b/src/uu/paste/src/paste.rs
@@ -12,10 +12,11 @@ use std::fmt::Display;
 use std::fs::File;
 use std::io::{stdin, stdout, BufRead, BufReader, Read, Write};
 use std::path::Path;
-use uucore::error::{FromIo, UResult};
+use uucore::error::{FromIo, UResult, USimpleError};
+use uucore::{format_usage, help_about, help_usage};
 
-static ABOUT: &str = "Write lines consisting of the sequentially corresponding lines from each
-FILE, separated by TABs, to standard output.";
+const ABOUT: &str = help_about!("paste.md");
+const USAGE: &str = help_usage!("paste.md");
 
 mod options {
     pub const DELIMITER: &str = "delimiters";
@@ -76,6 +77,7 @@ pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
         .infer_long_args(true)
         .arg(
             Arg::new(options::SERIAL)
@@ -109,6 +111,7 @@ pub fn uu_app() -> Command {
         )
 }
 
+#[allow(clippy::cognitive_complexity)]
 fn paste(
     filenames: Vec<String>,
     serial: bool,
@@ -127,6 +130,16 @@ fn paste(
         files.push(file);
     }
 
+    if delimiters.ends_with('\\') && !delimiters.ends_with("\\\\") {
+        return Err(USimpleError::new(
+            1,
+            format!(
+                "delimiter list ends with an unescaped backslash: {}",
+                delimiters
+            ),
+        ));
+    }
+
     let delimiters: Vec<char> = unescape(delimiters).chars().collect();
     let mut delim_count = 0;
     let mut delim_length = 1;
@@ -220,10 +233,8 @@ fn paste(
 }
 
 // Unescape all special characters
-// TODO: this will need work to conform to GNU implementation
 fn unescape(s: &str) -> String {
     s.replace("\\n", "\n")
         .replace("\\t", "\t")
         .replace("\\\\", "\\")
-        .replace('\\', "")
 }
diff --git a/src/uu/pathchk/Cargo.toml b/src/uu/pathchk/Cargo.toml
index 134f5bb5d..f11d85b5c 100644
--- a/src/uu/pathchk/Cargo.toml
+++ b/src/uu/pathchk/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_pathchk"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "pathchk ~ (uutils) diagnose invalid or non-portable PATHNAME"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/pathchk.rs"
 
 [dependencies]
-clap = { workspace=true }
-libc = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+libc = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "pathchk"
diff --git a/src/uu/pathchk/pathchk.md b/src/uu/pathchk/pathchk.md
new file mode 100644
index 000000000..2e5eca959
--- /dev/null
+++ b/src/uu/pathchk/pathchk.md
@@ -0,0 +1,7 @@
+# pathchk
+
+```
+pathchk [OPTION]... NAME...
+```
+
+Check whether file names are valid or portable
diff --git a/src/uu/pathchk/src/pathchk.rs b/src/uu/pathchk/src/pathchk.rs
index 6dad9f79d..598b9718b 100644
--- a/src/uu/pathchk/src/pathchk.rs
+++ b/src/uu/pathchk/src/pathchk.rs
@@ -13,7 +13,7 @@ use std::fs;
 use std::io::{ErrorKind, Write};
 use uucore::display::Quotable;
 use uucore::error::{set_exit_code, UResult, UUsageError};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
 
 // operating mode
 enum Mode {
@@ -23,8 +23,8 @@ enum Mode {
     Both,    // a combination of `Basic` and `Extra`
 }
 
-static ABOUT: &str = "Check whether file names are valid or portable";
-const USAGE: &str = "{} [OPTION]... NAME...";
+const ABOUT: &str = help_about!("pathchk.md");
+const USAGE: &str = help_usage!("pathchk.md");
 
 mod options {
     pub const POSIX: &str = "posix";
diff --git a/src/uu/pinky/Cargo.toml b/src/uu/pinky/Cargo.toml
index a9abee40b..ee17a46c5 100644
--- a/src/uu/pinky/Cargo.toml
+++ b/src/uu/pinky/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_pinky"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "pinky ~ (uutils) display user information"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/pinky.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true, features=["utmpx", "entries"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["utmpx", "entries"] }
 
 [[bin]]
 name = "pinky"
diff --git a/src/uu/pinky/pinky.md b/src/uu/pinky/pinky.md
new file mode 100644
index 000000000..965ae4cd0
--- /dev/null
+++ b/src/uu/pinky/pinky.md
@@ -0,0 +1,7 @@
+# pinky
+
+```
+pinky [OPTION]... [USER]...
+```
+
+Displays brief user information on Unix-based systems
diff --git a/src/uu/pinky/src/pinky.rs b/src/uu/pinky/src/pinky.rs
index 7e21fba9e..172a9e138 100644
--- a/src/uu/pinky/src/pinky.rs
+++ b/src/uu/pinky/src/pinky.rs
@@ -20,10 +20,10 @@ use std::os::unix::fs::MetadataExt;
 
 use clap::{crate_version, Arg, ArgAction, Command};
 use std::path::PathBuf;
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
 
-static ABOUT: &str = "Lightweight finger";
-const USAGE: &str = "{} [OPTION]... [USER]...";
+const ABOUT: &str = help_about!("pinky.md");
+const USAGE: &str = help_usage!("pinky.md");
 
 mod options {
     pub const LONG_FORMAT: &str = "long_format";
@@ -218,10 +218,10 @@ impl Capitalize for str {
     fn capitalize(&self) -> String {
         self.char_indices()
             .fold(String::with_capacity(self.len()), |mut acc, x| {
-                if x.0 != 0 {
-                    acc.push(x.1);
-                } else {
+                if x.0 == 0 {
                     acc.push(x.1.to_ascii_uppercase());
+                } else {
+                    acc.push(x.1);
                 }
                 acc
             })
@@ -281,10 +281,10 @@ impl Pinky {
         match pts_path.metadata() {
             #[allow(clippy::unnecessary_cast)]
             Ok(meta) => {
-                mesg = if meta.mode() & S_IWGRP as u32 != 0 {
-                    ' '
-                } else {
+                mesg = if meta.mode() & S_IWGRP as u32 == 0 {
                     '*'
+                } else {
+                    ' '
                 };
                 last_change = meta.atime();
             }
@@ -312,10 +312,10 @@ impl Pinky {
         print!(" {}{:<8.*}", mesg, utmpx::UT_LINESIZE, ut.tty_device());
 
         if self.include_idle {
-            if last_change != 0 {
-                print!(" {:<6}", idle_string(last_change));
-            } else {
+            if last_change == 0 {
                 print!(" {:<6}", "?????");
+            } else {
+                print!(" {:<6}", idle_string(last_change));
             }
         }
 
diff --git a/src/uu/pr/Cargo.toml b/src/uu/pr/Cargo.toml
index 773a71b7f..bae1b251d 100644
--- a/src/uu/pr/Cargo.toml
+++ b/src/uu/pr/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_pr"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "pr ~ (uutils) convert text files for printing"
@@ -15,12 +15,12 @@ edition = "2021"
 path = "src/pr.rs"
 
 [dependencies]
-clap = { workspace=true }
-time = { workspace=true, features = ["local-offset", "macros", "formatting"] }
-uucore = { workspace=true, features=["entries"] }
-quick-error = { workspace=true }
-itertools = { workspace=true }
-regex = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["entries"] }
+quick-error = { workspace = true }
+itertools = { workspace = true }
+regex = { workspace = true }
+chrono = { workspace = true }
 
 [[bin]]
 name = "pr"
diff --git a/src/uu/pr/pr.md b/src/uu/pr/pr.md
new file mode 100644
index 000000000..2c246b25f
--- /dev/null
+++ b/src/uu/pr/pr.md
@@ -0,0 +1,27 @@
+# pr
+
+```
+pr [OPTIONS] [files]...
+```
+
+Write content of given file or standard input to standard output with pagination filter
+
+## After help
+
+`+PAGE`           Begin output at page number page of the formatted input.
+`-COLUMN`         Produce multi-column output. See `--column`
+
+The pr utility is a printing and pagination filter for text files.
+When multiple input files are specified, each is read, formatted, and written to standard output.
+By default, the input is separated into 66-line pages, each with
+
+* A 5-line header with the page number, date, time, and the pathname of the file.
+* A 5-line trailer consisting of blank lines.
+
+If standard output is associated with a terminal, diagnostic messages are suppressed until the pr
+utility has completed processing.
+
+When multiple column output is specified, text columns are of equal width.
+By default, text columns are separated by at least one `<blank>`.
+Input lines that do not fit into a text column are truncated.
+Lines are not truncated under single column output.
diff --git a/src/uu/pr/src/pr.rs b/src/uu/pr/src/pr.rs
index 9f1b64483..37674bad7 100644
--- a/src/uu/pr/src/pr.rs
+++ b/src/uu/pr/src/pr.rs
@@ -6,6 +6,7 @@
 
 // spell-checker:ignore (ToDO) adFfmprt, kmerge
 
+use chrono::{DateTime, Local};
 use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
 use itertools::Itertools;
 use quick_error::ResultExt;
@@ -15,39 +16,15 @@ use std::fs::{metadata, File};
 use std::io::{stdin, stdout, BufRead, BufReader, Lines, Read, Write};
 #[cfg(unix)]
 use std::os::unix::fs::FileTypeExt;
-use time::macros::format_description;
-use time::OffsetDateTime;
 
 use quick_error::quick_error;
 use uucore::display::Quotable;
 use uucore::error::UResult;
+use uucore::{format_usage, help_about, help_section, help_usage};
 
-const ABOUT: &str =
-    "Write content of given file or standard input to standard output with pagination filter";
-const AFTER_HELP: &str =
-    "    +PAGE\n            Begin output at page number page of the formatted input.
-    -COLUMN\n            Produce multi-column output. See --column
-
-The pr utility is a printing and pagination filter
-for text files.  When multiple input files are specified,
-each is read, formatted, and written to standard
-output.  By default, the input is separated
-into 66-line pages, each with
-
-o   A 5-line header with the page number, date,
-    time, and the pathname of the file.
-
-o   A 5-line trailer consisting of blank lines.
-
-If standard output is associated with a terminal,
-diagnostic messages are suppressed until the pr
-utility has completed processing.
-
-When multiple column output is specified, text columns
-are of equal width.  By default text columns
-are separated by at least one <blank>.  Input lines
-that do not fit into a text column are truncated.
-Lines are not truncated under single column output.";
+const ABOUT: &str = help_about!("pr.md");
+const USAGE: &str = help_usage!("pr.md");
+const AFTER_HELP: &str = help_section!("after help", "pr.md");
 const TAB: char = '\t';
 const LINES_PER_PAGE: usize = 66;
 const LINES_PER_PAGE_FOR_FORM_FEED: usize = 63;
@@ -59,8 +36,7 @@ const DEFAULT_COLUMN_WIDTH: usize = 72;
 const DEFAULT_COLUMN_WIDTH_WITH_S_OPTION: usize = 512;
 const DEFAULT_COLUMN_SEPARATOR: &char = &TAB;
 const FF: u8 = 0x0C_u8;
-const DATE_TIME_FORMAT: &[time::format_description::FormatItem] =
-    format_description!("[month repr:short] [day] [hour]:[minute] [year]");
+const DATE_TIME_FORMAT: &str = "%b %d %H:%M %Y";
 
 mod options {
     pub const HEADER: &str = "header";
@@ -195,6 +171,7 @@ pub fn uu_app() -> Command {
         .version(crate_version!())
         .about(ABOUT)
         .after_help(AFTER_HELP)
+        .override_usage(format_usage(USAGE))
         .infer_long_args(true)
         .args_override_self(true)
         .disable_help_flag(true)
@@ -509,6 +486,7 @@ fn parse_usize(matches: &ArgMatches, opt: &str) -> Option<Result<usize, PrError>
         .map(from_parse_error_to_pr_error)
 }
 
+#[allow(clippy::cognitive_complexity)]
 fn build_options(
     matches: &ArgMatches,
     paths: &[&str],
@@ -591,10 +569,8 @@ fn build_options(
     let line_separator = "\n".to_string();
 
     let last_modified_time = if is_merge_mode || paths[0].eq(FILE_STDIN) {
-        // let date_time = Local::now();
-        // date_time.format("%b %d %H:%M %Y").to_string()
-        let date_time = OffsetDateTime::now_local().unwrap();
-        date_time.format(&DATE_TIME_FORMAT).unwrap()
+        let date_time = Local::now();
+        date_time.format(DATE_TIME_FORMAT).to_string()
     } else {
         file_last_modified_time(paths.first().unwrap())
     };
@@ -1042,6 +1018,7 @@ fn print_page(
     Ok(lines_written)
 }
 
+#[allow(clippy::cognitive_complexity)]
 fn write_columns(
     lines: &[FileLine],
     options: &OutputOptions,
@@ -1234,12 +1211,8 @@ fn file_last_modified_time(path: &str) -> String {
         .map(|i| {
             i.modified()
                 .map(|x| {
-                    let date_time: OffsetDateTime = x.into();
-                    let offset = OffsetDateTime::now_local().unwrap().offset();
-                    date_time
-                        .to_offset(offset)
-                        .format(&DATE_TIME_FORMAT)
-                        .unwrap()
+                    let date_time: DateTime<Local> = x.into();
+                    date_time.format(DATE_TIME_FORMAT).to_string()
                 })
                 .unwrap_or_default()
         })
diff --git a/src/uu/printenv/Cargo.toml b/src/uu/printenv/Cargo.toml
index 7f179e411..59dcee778 100644
--- a/src/uu/printenv/Cargo.toml
+++ b/src/uu/printenv/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_printenv"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "printenv ~ (uutils) display value of environment VAR"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/printenv.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "printenv"
diff --git a/src/uu/printenv/printenv.md b/src/uu/printenv/printenv.md
new file mode 100644
index 000000000..929da7947
--- /dev/null
+++ b/src/uu/printenv/printenv.md
@@ -0,0 +1,7 @@
+# printenv
+
+```
+printenv [VARIABLE]... [OPTION]...
+```
+
+Display the values of the specified environment VARIABLE(s), or (with no VARIABLE) display name and value pairs for them all.
diff --git a/src/uu/printenv/src/printenv.rs b/src/uu/printenv/src/printenv.rs
index dd58f4ee1..beeb7285b 100644
--- a/src/uu/printenv/src/printenv.rs
+++ b/src/uu/printenv/src/printenv.rs
@@ -9,10 +9,10 @@
 
 use clap::{crate_version, Arg, ArgAction, Command};
 use std::env;
-use uucore::{error::UResult, format_usage};
+use uucore::{error::UResult, format_usage, help_about, help_usage};
 
-static ABOUT: &str = "Display the values of the specified environment VARIABLE(s), or (with no VARIABLE) display name and value pairs for them all.";
-const USAGE: &str = "{} [VARIABLE]... [OPTION]...";
+const ABOUT: &str = help_about!("printenv.md");
+const USAGE: &str = help_usage!("printenv.md");
 
 static OPT_NULL: &str = "null";
 
diff --git a/src/uu/printf/Cargo.toml b/src/uu/printf/Cargo.toml
index ffb266f18..51812945f 100644
--- a/src/uu/printf/Cargo.toml
+++ b/src/uu/printf/Cargo.toml
@@ -1,10 +1,7 @@
 [package]
 name = "uu_printf"
-version = "0.0.17"
-authors = [
-  "Nathan Ross",
-  "uutils developers",
-]
+version = "0.0.19"
+authors = ["Nathan Ross", "uutils developers"]
 license = "MIT"
 description = "printf ~ (uutils) FORMAT and display ARGUMENTS"
 
@@ -18,8 +15,8 @@ edition = "2021"
 path = "src/printf.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true, features=["memo"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["memo"] }
 
 [[bin]]
 name = "printf"
diff --git a/src/uu/printf/printf.md b/src/uu/printf/printf.md
new file mode 100644
index 000000000..60b50354c
--- /dev/null
+++ b/src/uu/printf/printf.md
@@ -0,0 +1,264 @@
+<!-- spell-checker:ignore formatstring templating parameterizing each's -->
+
+# printf
+
+```
+printf FORMATSTRING [ARGUMENT]...
+```
+
+Print output based off of the format string and proceeding arguments.
+
+## After Help
+
+basic anonymous string templating:
+
+prints format string at least once, repeating as long as there are remaining arguments
+output prints escaped literals in the format string as character literals
+output replaces anonymous fields with the next unused argument, formatted according to the field.
+
+Prints the `,` replacing escaped character sequences with character literals
+and substitution field sequences with passed arguments
+
+literally, with the exception of the below
+escaped character sequences, and the substitution sequences described further down.
+
+### ESCAPE SEQUENCES
+
+The following escape sequences, organized here in alphabetical order,
+will print the corresponding character literal:
+
+* `\"`      double quote
+
+* `\\\\`    backslash
+
+* `\\a`     alert (BEL)
+
+* `\\b`     backspace
+
+* `\\c`     End-of-Input
+
+* `\\e`     escape
+
+* `\\f`     form feed
+
+* `\\n`     new line
+
+* `\\r`     carriage return
+
+* `\\t`     horizontal tab
+
+* `\\v`     vertical tab
+
+* `\\NNN`   byte with value expressed in octal value NNN (1 to 3 digits)
+          values greater than 256 will be treated
+
+* `\\xHH`   byte with value expressed in hexadecimal value NN (1 to 2 digits)
+
+* `\\uHHHH` Unicode (IEC 10646) character with value expressed in hexadecimal value HHHH (4 digits)
+
+* `\\uHHHH` Unicode character with value expressed in hexadecimal value HHHH (8 digits)
+
+* `%%`      a single %
+
+### SUBSTITUTIONS
+
+#### SUBSTITUTION QUICK REFERENCE
+
+Fields
+
+* `%s`: string
+* `%b`: string parsed for literals second parameter is max length
+
+* `%c`: char no second parameter
+
+* `%i` or `%d`: 64-bit integer
+* `%u`:       64 bit unsigned integer
+* `%x` or `%X`: 64-bit unsigned integer as hex
+* `%o`:       64-bit unsigned integer as octal
+            second parameter is min-width, integer
+            output below that width is padded with leading zeroes
+
+* `%f` or `%F`: decimal floating point value
+* `%e` or `%E`: scientific notation floating point value
+* `%g` or `%G`: shorter of specially interpreted decimal or SciNote floating point value.
+            second parameter is
+              `-max` places after decimal point for floating point output
+              `-max` number of significant digits for scientific notation output
+
+parameterizing fields
+
+examples:
+
+```
+printf '%4.3i' 7
+```
+
+It has a first parameter of 4 and a second parameter of 3 and will result in ' 007'
+
+```
+printf '%.1s' abcde
+```
+
+It has no first parameter and a second parameter of 1 and will result in 'a'
+
+```
+printf '%4c' q
+```
+
+It has a first parameter of 4 and no second parameter and will result in  '   q'
+
+The first parameter of a field is the minimum width to pad the output to
+if the output is less than this absolute value of this width,
+it will be padded with leading spaces, or, if the argument is negative,
+with trailing spaces. the default is zero.
+
+The second parameter of a field is particular to the output field type.
+defaults can be found in the full substitution help below
+
+special prefixes to numeric arguments
+
+* `0`:  (e.g. 010)   interpret argument as octal (integer output fields only)
+* `0x`: (e.g. 0xABC) interpret argument as hex (numeric output fields only)
+* `\'`: (e.g. \'a)   interpret argument as a character constant
+
+#### HOW TO USE SUBSTITUTIONS
+
+Substitutions are used to pass additional argument(s) into the FORMAT string, to be formatted a
+particular way. E.g.
+
+```
+printf 'the letter %X comes before the letter %X' 10 11
+```
+
+will print
+
+```
+the letter A comes before the letter B
+```
+
+because the substitution field `%X` means
+'take an integer argument and write it as a hexadecimal number'
+
+Passing more arguments than are in the format string will cause the format string to be
+repeated for the remaining substitutions
+
+```
+printf 'it is %i F in %s \n' 22 Portland 25 Boston 27 New York
+```
+
+will print
+
+```
+it is 22 F in Portland
+it is 25 F in Boston
+it is 27 F in Boston
+```
+
+If a format string is printed but there are less arguments remaining
+than there are substitution fields, substitution fields without
+an argument will default to empty strings, or for numeric fields
+the value 0
+
+#### AVAILABLE SUBSTITUTIONS
+
+This program, like GNU coreutils printf,
+interprets a modified subset of the POSIX C printf spec,
+a quick reference to substitutions is below.
+
+#### STRING SUBSTITUTIONS
+
+All string fields have a 'max width' parameter
+`%.3s` means 'print no more than three characters of the original input'
+
+* `%s`: string
+
+* `%b`: escaped string - the string will be checked for any escaped literals from
+      the escaped literal list above, and translate them to literal characters.
+      e.g. `\\n` will be transformed into a newline character.
+      One special rule about `%b` mode is that octal literals are interpreted differently
+      In arguments passed by `%b`, pass octal-interpreted literals must be in the form of `\\0NNN`
+      instead of `\\NNN`. (Although, for legacy reasons, octal literals in the form of `\\NNN` will
+      still be interpreted and not throw a warning, you will have problems if you use this for a
+      literal whose code begins with zero, as it will be viewed as in `\\0NNN` form.)
+
+#### CHAR SUBSTITUTIONS
+
+The character field does not have a secondary parameter.
+
+* `%c`: a single character
+
+#### INTEGER SUBSTITUTIONS
+
+All integer fields have a 'pad with zero' parameter
+`%.4i` means an integer which if it is less than 4 digits in length,
+is padded with leading zeros until it is 4 digits in length.
+
+* `%d` or `%i`: 64-bit integer
+
+* `%u`: 64-bit unsigned integer
+
+* `%x` or `%X`: 64-bit unsigned integer printed in Hexadecimal (base 16)
+            `%X` instead of `%x` means to use uppercase letters for 'a' through 'f'
+
+* `%o`: 64-bit unsigned integer printed in octal (base 8)
+
+#### FLOATING POINT SUBSTITUTIONS
+
+All floating point fields have a 'max decimal places / max significant digits' parameter
+`%.10f` means a decimal floating point with 7 decimal places past 0
+`%.10e` means a scientific notation number with 10 significant digits
+`%.10g` means the same behavior for decimal and Sci. Note, respectively, and provides the shortest
+of each's output.
+
+Like with GNU coreutils, the value after the decimal point is these outputs is parsed as a
+double first before being rendered to text. For both implementations do not expect meaningful
+precision past the 18th decimal place. When using a number of decimal places that is 18 or
+higher, you can expect variation in output between GNU coreutils printf and this printf at the
+18th decimal place of +/- 1
+
+* `%f`: floating point value presented in decimal, truncated and displayed to 6 decimal places by
+      default. There is not past-double behavior parity with Coreutils printf, values are not
+      estimated or adjusted beyond input values.
+
+* `%e` or `%E`: floating point value presented in scientific notation
+            7 significant digits by default
+            `%E` means use to use uppercase E for the mantissa.
+
+* `%g` or `%G`: floating point value presented in the shortest of decimal and scientific notation
+            behaves differently from `%f` and `%E`, please see posix printf spec for full details,
+            some examples of different behavior:
+            Sci Note has 6 significant digits by default
+            Trailing zeroes are removed
+            Instead of being truncated, digit after last is rounded
+
+Like other behavior in this utility, the design choices of floating point
+behavior in this utility is selected to reproduce in exact
+the behavior of GNU coreutils' printf from an inputs and outputs standpoint.
+
+### USING PARAMETERS
+
+Most substitution fields can be parameterized using up to 2 numbers that can
+be passed to the field, between the % sign and the field letter.
+
+The 1st parameter always indicates the minimum width of output, it is useful for creating
+columnar output. Any output that would be less than this minimum width is padded with
+leading spaces
+The 2nd parameter is proceeded by a dot.
+You do not have to use parameters
+
+### SPECIAL FORMS OF INPUT
+
+For numeric input, the following additional forms of input are accepted besides decimal:
+
+Octal (only with integer): if the argument begins with a 0 the proceeding characters
+will be interpreted as octal (base 8) for integer fields
+
+Hexadecimal: if the argument begins with 0x the proceeding characters will be interpreted
+will be interpreted as hex (base 16) for any numeric fields
+for float fields, hexadecimal input results in a precision
+limit (in converting input past the decimal point) of 10^-15
+
+Character Constant: if the argument begins with a single quote character, the first byte
+of the next character will be interpreted as an 8-bit unsigned integer. If there are
+additional bytes, they will throw an error (unless the environment variable POSIXLY_CORRECT
+is set)
diff --git a/src/uu/printf/src/printf.rs b/src/uu/printf/src/printf.rs
index 2592f212d..bf79369cc 100644
--- a/src/uu/printf/src/printf.rs
+++ b/src/uu/printf/src/printf.rs
@@ -4,265 +4,14 @@
 
 use clap::{crate_version, Arg, ArgAction, Command};
 use uucore::error::{UResult, UUsageError};
-use uucore::format_usage;
 use uucore::memo::printf;
+use uucore::{format_usage, help_about, help_section, help_usage};
 
 const VERSION: &str = "version";
 const HELP: &str = "help";
-const USAGE: &str = "{} FORMATSTRING [ARGUMENT]...";
-const ABOUT: &str = "Print output based off of the format string and proceeding arguments.";
-const AFTER_HELP: &str = "
-basic anonymous string templating:
-
-prints format string at least once, repeating as long as there are remaining arguments
-output prints escaped literals in the format string as character literals
-output replaces anonymous fields with the next unused argument, formatted according to the field.
-
-Prints the , replacing escaped character sequences with character literals
-  and substitution field sequences with passed arguments
-
-literally, with the exception of the below
-  escaped character sequences, and the substitution sequences described further down.
-
-ESCAPE SEQUENCES
-
-The following escape sequences, organized here in alphabetical order,
-will print the corresponding character literal:
-
-\"   double quote
-
-\\\\    backslash
-
-\\a  alert (BEL)
-
-\\b  backspace
-
-\\c  End-of-Input
-
-\\e  escape
-
-\\f  form feed
-
-\\n  new line
-
-\\r  carriage return
-
-\\t  horizontal tab
-
-\\v  vertical tab
-
-\\NNN byte with value expressed in octal value NNN (1 to 3 digits)
-      values greater than 256 will be treated
-
-\\xHH byte with value expressed in hexadecimal value NN (1 to 2 digits)
-
-\\uHHHH Unicode (IEC 10646) character with value expressed in hexadecimal value HHHH (4 digits)
-
-\\uHHHH Unicode character with value expressed in hexadecimal value HHHH (8 digits)
-
-%% a single %
-
-SUBSTITUTIONS
-
-SUBSTITUTION QUICK REFERENCE
-
-Fields
-
-%s - string
-%b - string parsed for literals
-  second parameter is max length
-
-%c - char
-  no second parameter
-
-%i or %d - 64-bit integer
-%u - 64 bit unsigned integer
-%x or %X - 64-bit unsigned integer as hex
-%o - 64-bit unsigned integer as octal
-  second parameter is min-width, integer
-   output below that width is padded with leading zeroes
-
-%f or %F - decimal floating point value
-%e or %E - scientific notation floating point value
-%g or %G - shorter of specially interpreted decimal or SciNote floating point value.
-  second parameter is
-    -max places after decimal point for floating point output
-    -max number of significant digits for scientific notation output
-
-parameterizing fields
-
-examples:
-
-printf '%4.3i' 7
-has a first parameter of 4
-   and a second parameter of 3
-will result in ' 007'
-
-printf '%.1s' abcde
-has no first parameter
-   and a second parameter of 1
-will result in 'a'
-
-printf '%4c' q
-has a first parameter of 4
-   and no second parameter
-will result in  '   q'
-
-The first parameter of a field is the minimum width to pad the output to
- if the output is less than this absolute value of this width,
- it will be padded with leading spaces, or, if the argument is negative,
- with trailing spaces. the default is zero.
-
-The second parameter of a field is particular to the output field type.
- defaults can be found in the full substitution help below
-
-special prefixes to numeric arguments
-  0 (e.g. 010) - interpret argument as octal (integer output fields only)
-  0x (e.g. 0xABC) - interpret argument as hex (numeric output fields only)
-  \' (e.g. \'a) - interpret argument as a character constant
-
-HOW TO USE SUBSTITUTIONS
-
-Substitutions are used to pass additional argument(s) into the FORMAT string, to be formatted a
-particular way. E.g.
-
-    printf 'the letter %X comes before the letter %X' 10 11
-
-will print
-
-   'the letter A comes before the letter B'
-
-because the substitution field %X means
-'take an integer argument and write it as a hexadecimal number'
-
-Passing more arguments than are in the format string will cause the format string to be
- repeated for the remaining substitutions
-
-   printf 'it is %i F in %s \n' 22 Portland 25 Boston 27 New York
-
-will print
-
-   'it is 22 F in Portland
-    it is 25 F in Boston
-    it is 27 F in Boston
-   '
-If a format string is printed but there are less arguments remaining
- than there are substitution fields, substitution fields without
- an argument will default to empty strings, or for numeric fields
- the value 0
-
-AVAILABLE SUBSTITUTIONS
-
-This program, like GNU coreutils printf,
-interprets a modified subset of the POSIX C printf spec,
-a quick reference to substitutions is below.
-
- STRING SUBSTITUTIONS
-  All string fields have a 'max width' parameter
-  %.3s means 'print no more than three characters of the original input'
-
- %s - string
-
- %b - escaped string - the string will be checked for any escaped literals from
-       the escaped literal list above, and translate them to literal characters.
-       e.g. \\n will be transformed into a newline character.
-
-      One special rule about %b mode is that octal literals are interpreted differently
-      In arguments passed by %b, pass octal-interpreted literals must be in the form of \\0NNN
-      instead of \\NNN. (Although, for legacy reasons, octal literals in the form of \\NNN will
-      still be interpreted and not throw a warning, you will have problems if you use this for a
-      literal whose code begins with zero, as it will be viewed as in \\0NNN form.)
-
- CHAR SUBSTITUTIONS
-  The character field does not have a secondary parameter.
-
- %c - a single character
-
- INTEGER SUBSTITUTIONS
-  All integer fields have a 'pad with zero' parameter
-  %.4i means an integer which if it is less than 4 digits in length,
-  is padded with leading zeros until it is 4 digits in length.
-
- %d or %i - 64-bit integer
-
- %u - 64 bit unsigned integer
-
- %x or %X - 64 bit unsigned integer printed in Hexadecimal (base 16)
-          %X instead of %x means to use uppercase letters for 'a' through 'f'
-
- %o - 64 bit unsigned integer printed in octal (base 8)
-
- FLOATING POINT SUBSTITUTIONS
-
-  All floating point fields have a 'max decimal places / max significant digits' parameter
-  %.10f means a decimal floating point with 7 decimal places past 0
-  %.10e means a scientific notation number with 10 significant digits
-  %.10g means the same behavior for decimal and Sci. Note, respectively, and provides the shorter
-        of each's output.
-
-  Like with GNU coreutils, the value after the decimal point is these outputs is parsed as a
-  double first before being rendered to text. For both implementations do not expect meaningful
-  precision past the 18th decimal place. When using a number of decimal places that is 18 or
-  higher, you can expect variation in output between GNU coreutils printf and this printf at the
-  18th decimal place of +/- 1
-
- %f - floating point value presented in decimal, truncated and displayed to 6 decimal places by
-      default. There is not past-double behavior parity with Coreutils printf, values are not
-      estimated or adjusted beyond input values.
-
- %e or %E - floating point value presented in scientific notation
-          7 significant digits by default
-          %E means use to use uppercase E for the mantissa.
-
- %g or %G - floating point value presented in the shorter of decimal and scientific notation
-          behaves differently from %f and %E, please see posix printf spec for full details,
-          some examples of different behavior:
-
-          Sci Note has 6 significant digits by default
-          Trailing zeroes are removed
-          Instead of being truncated, digit after last is rounded
-
- Like other behavior in this utility, the design choices of floating point
-  behavior in this utility is selected to reproduce in exact
-  the behavior of GNU coreutils' printf from an inputs and outputs standpoint.
-
-USING PARAMETERS
- Most substitution fields can be parameterized using up to 2 numbers that can
- be passed to the field, between the % sign and the field letter.
-
- The 1st parameter always indicates the minimum width of output, it is useful for creating
-   columnar output. Any output that would be less than this minimum width is padded with
-   leading spaces
- The 2nd parameter is proceeded by a dot.
- You do not have to use parameters
-
-SPECIAL FORMS OF INPUT
- For numeric input, the following additional forms of input are accepted besides decimal:
-
-  Octal (only with integer): if the argument begins with a 0 the proceeding characters
-    will be interpreted as octal (base 8) for integer fields
-
-  Hexadecimal: if the argument begins with 0x the proceeding characters will be interpreted
-    will be interpreted as hex (base 16) for any numeric fields
-    for float fields, hexadecimal input results in a precision
-    limit (in converting input past the decimal point) of 10^-15
-
-  Character Constant: if the argument begins with a single quote character, the first byte
-    of the next character will be interpreted as an 8-bit unsigned integer. If there are
-    additional bytes, they will throw an error (unless the environment variable POSIXLY_CORRECT
-    is set)
-
-WRITTEN BY :
-  Nathan E. Ross, et al. for the uutils project
-
-MORE INFO :
-  https://github.com/uutils/coreutils
-
-COPYRIGHT :
-  Copyright 2015 uutils project.
-  Licensed under the MIT License, please see LICENSE file for details
-
-";
+const USAGE: &str = help_usage!("printf.md");
+const ABOUT: &str = help_about!("printf.md");
+const AFTER_HELP: &str = help_section!("after help", "printf.md");
 
 mod options {
     pub const FORMATSTRING: &str = "FORMATSTRING";
diff --git a/src/uu/ptx/Cargo.toml b/src/uu/ptx/Cargo.toml
index 1cb2857d3..358c640db 100644
--- a/src/uu/ptx/Cargo.toml
+++ b/src/uu/ptx/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_ptx"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "ptx ~ (uutils) display a permuted index of input"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/ptx.rs"
 
 [dependencies]
-clap = { workspace=true }
-regex = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+regex = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "ptx"
diff --git a/src/uu/ptx/ptx.md b/src/uu/ptx/ptx.md
new file mode 100644
index 000000000..b8717776c
--- /dev/null
+++ b/src/uu/ptx/ptx.md
@@ -0,0 +1,11 @@
+# ptx
+
+```
+ptx [OPTION]... [INPUT]...
+ptx -G [OPTION]... [INPUT [OUTPUT]]
+```
+
+Produce a permuted index of file contents
+Output a permuted index, including context, of the words in the input files.
+Mandatory arguments to long options are mandatory for short options too.
+With no FILE, or when FILE is -, read standard input. Default is '-F /'.
\ No newline at end of file
diff --git a/src/uu/ptx/src/ptx.rs b/src/uu/ptx/src/ptx.rs
index 9716aaf30..ecfd67ce8 100644
--- a/src/uu/ptx/src/ptx.rs
+++ b/src/uu/ptx/src/ptx.rs
@@ -19,16 +19,10 @@ use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Write};
 use std::num::ParseIntError;
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UError, UResult};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
 
-const USAGE: &str = "\
-    {} [OPTION]... [INPUT]...
-    {} -G [OPTION]... [INPUT [OUTPUT]]";
-
-const ABOUT: &str = "\
-    Output a permuted index, including context, of the words in the input files. \n\n\
-    Mandatory arguments to long options are mandatory for short options too.\n\
-    With no FILE, or when FILE is -, read standard input. Default is '-F /'.";
+const USAGE: &str = help_usage!("ptx.md");
+const ABOUT: &str = help_about!("ptx.md");
 
 const REGEX_CHARCLASS: &str = "^-]\\";
 
@@ -113,6 +107,7 @@ struct WordFilter {
 }
 
 impl WordFilter {
+    #[allow(clippy::cognitive_complexity)]
     fn new(matches: &clap::ArgMatches, config: &Config) -> UResult<Self> {
         let (o, oset): (bool, HashSet<String>) = if matches.contains_id(options::ONLY_FILE) {
             let words =
diff --git a/src/uu/pwd/Cargo.toml b/src/uu/pwd/Cargo.toml
index 2be204608..60cb9aae0 100644
--- a/src/uu/pwd/Cargo.toml
+++ b/src/uu/pwd/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_pwd"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "pwd ~ (uutils) display current working directory"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/pwd.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "pwd"
diff --git a/src/uu/pwd/pwd.md b/src/uu/pwd/pwd.md
new file mode 100644
index 000000000..89ccee2db
--- /dev/null
+++ b/src/uu/pwd/pwd.md
@@ -0,0 +1,7 @@
+# pwd
+
+```
+pwd [OPTION]... [FILE]...
+```
+
+Display the full filename of the current working directory.
diff --git a/src/uu/pwd/src/pwd.rs b/src/uu/pwd/src/pwd.rs
index 029ba6625..9e04dd38b 100644
--- a/src/uu/pwd/src/pwd.rs
+++ b/src/uu/pwd/src/pwd.rs
@@ -10,15 +10,15 @@ use clap::{crate_version, Arg, Command};
 use std::env;
 use std::io;
 use std::path::PathBuf;
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
 
 use uucore::display::println_verbatim;
 use uucore::error::{FromIo, UResult};
 
-static ABOUT: &str = "Display the full filename of the current working directory.";
-const USAGE: &str = "{} [OPTION]... FILE...";
-static OPT_LOGICAL: &str = "logical";
-static OPT_PHYSICAL: &str = "physical";
+const ABOUT: &str = help_about!("pwd.md");
+const USAGE: &str = help_usage!("pwd.md");
+const OPT_LOGICAL: &str = "logical";
+const OPT_PHYSICAL: &str = "physical";
 
 fn physical_path() -> io::Result<PathBuf> {
     // std::env::current_dir() is a thin wrapper around libc::getcwd().
@@ -84,36 +84,22 @@ fn logical_path() -> io::Result<PathBuf> {
             {
                 use std::fs::metadata;
                 use std::os::unix::fs::MetadataExt;
-                let path_info = match metadata(path) {
-                    Ok(info) => info,
-                    Err(_) => return false,
-                };
-                let real_info = match metadata(".") {
-                    Ok(info) => info,
-                    Err(_) => return false,
-                };
-                if path_info.dev() != real_info.dev() || path_info.ino() != real_info.ino() {
-                    return false;
+                match (metadata(path), metadata(".")) {
+                    (Ok(info1), Ok(info2)) => {
+                        info1.dev() == info2.dev() && info1.ino() == info2.ino()
+                    }
+                    _ => false,
                 }
             }
 
             #[cfg(not(unix))]
             {
                 use std::fs::canonicalize;
-                let canon_path = match canonicalize(path) {
-                    Ok(path) => path,
-                    Err(_) => return false,
-                };
-                let real_path = match canonicalize(".") {
-                    Ok(path) => path,
-                    Err(_) => return false,
-                };
-                if canon_path != real_path {
-                    return false;
+                match (canonicalize(path), canonicalize(".")) {
+                    (Ok(path1), Ok(path2)) => path1 == path2,
+                    _ => false,
                 }
             }
-
-            true
         }
 
         match env::var_os("PWD").map(PathBuf::from) {
@@ -129,7 +115,9 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     // if POSIXLY_CORRECT is set, we want to a logical resolution.
     // This produces a different output when doing mkdir -p a/b && ln -s a/b c && cd c && pwd
     // We should get c in this case instead of a/b at the end of the path
-    let cwd = if matches.get_flag(OPT_LOGICAL) || env::var("POSIXLY_CORRECT").is_ok() {
+    let cwd = if matches.get_flag(OPT_PHYSICAL) {
+        physical_path()
+    } else if matches.get_flag(OPT_LOGICAL) || env::var("POSIXLY_CORRECT").is_ok() {
         logical_path()
     } else {
         physical_path()
diff --git a/src/uu/readlink/Cargo.toml b/src/uu/readlink/Cargo.toml
index 59acd7731..4a0ad66e5 100644
--- a/src/uu/readlink/Cargo.toml
+++ b/src/uu/readlink/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_readlink"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "readlink ~ (uutils) display resolved path of PATHNAME"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/readlink.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true, features=["fs"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["fs"] }
 
 [[bin]]
 name = "readlink"
diff --git a/src/uu/readlink/readlink.md b/src/uu/readlink/readlink.md
new file mode 100644
index 000000000..7215acbec
--- /dev/null
+++ b/src/uu/readlink/readlink.md
@@ -0,0 +1,7 @@
+# readlink
+
+```
+readlink [OPTION]... [FILE]... 
+```
+
+Print value of a symbolic link or canonical file name.
diff --git a/src/uu/readlink/src/readlink.rs b/src/uu/readlink/src/readlink.rs
index 8afb184be..e247c6146 100644
--- a/src/uu/readlink/src/readlink.rs
+++ b/src/uu/readlink/src/readlink.rs
@@ -14,10 +14,10 @@ use std::path::{Path, PathBuf};
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
 use uucore::fs::{canonicalize, MissingHandling, ResolveMode};
-use uucore::{format_usage, show_error};
+use uucore::{format_usage, help_about, help_usage, show_error};
 
-const ABOUT: &str = "Print value of a symbolic link or canonical file name.";
-const USAGE: &str = "{} [OPTION]... [FILE]...";
+const ABOUT: &str = help_about!("readlink.md");
+const USAGE: &str = help_usage!("readlink.md");
 const OPT_CANONICALIZE: &str = "canonicalize";
 const OPT_CANONICALIZE_MISSING: &str = "canonicalize-missing";
 const OPT_CANONICALIZE_EXISTING: &str = "canonicalize-existing";
@@ -99,7 +99,7 @@ pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
-        .override_help(format_usage(USAGE))
+        .override_usage(format_usage(USAGE))
         .infer_long_args(true)
         .arg(
             Arg::new(OPT_CANONICALIZE)
diff --git a/src/uu/realpath/Cargo.toml b/src/uu/realpath/Cargo.toml
index cf23d60af..9b2b5352c 100644
--- a/src/uu/realpath/Cargo.toml
+++ b/src/uu/realpath/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_realpath"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "realpath ~ (uutils) display resolved absolute path of PATHNAME"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/realpath.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true, features=["fs"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["fs"] }
 
 [[bin]]
 name = "realpath"
diff --git a/src/uu/realpath/realpath.md b/src/uu/realpath/realpath.md
index 69fb39407..25e4a3726 100644
--- a/src/uu/realpath/realpath.md
+++ b/src/uu/realpath/realpath.md
@@ -4,4 +4,4 @@
 realpath [OPTION]... FILE...
 ```
 
-Print the resolved path
\ No newline at end of file
+Print the resolved path
diff --git a/src/uu/relpath/Cargo.toml b/src/uu/relpath/Cargo.toml
index 99e37f5f8..4108d612c 100644
--- a/src/uu/relpath/Cargo.toml
+++ b/src/uu/relpath/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_relpath"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "relpath ~ (uutils) display relative path of PATHNAME_TO from PATHNAME_FROM"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/relpath.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true, features=["fs"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["fs"] }
 
 [[bin]]
 name = "relpath"
diff --git a/src/uu/relpath/relpath.md b/src/uu/relpath/relpath.md
new file mode 100644
index 000000000..a1ff9bf4a
--- /dev/null
+++ b/src/uu/relpath/relpath.md
@@ -0,0 +1,8 @@
+# relpath
+
+```
+relpath [-d DIR] TO [FROM]
+```
+
+Convert TO destination to the relative path from the FROM dir.
+If FROM path is omitted, current working dir will be used.
\ No newline at end of file
diff --git a/src/uu/relpath/src/relpath.rs b/src/uu/relpath/src/relpath.rs
index 522cc54e5..ef7c43474 100644
--- a/src/uu/relpath/src/relpath.rs
+++ b/src/uu/relpath/src/relpath.rs
@@ -12,12 +12,11 @@ use std::env;
 use std::path::{Path, PathBuf};
 use uucore::display::println_verbatim;
 use uucore::error::{FromIo, UResult};
-use uucore::format_usage;
 use uucore::fs::{canonicalize, MissingHandling, ResolveMode};
+use uucore::{format_usage, help_about, help_usage};
 
-static ABOUT: &str = "Convert TO destination to the relative path from the FROM dir.
-If FROM path is omitted, current working dir will be used.";
-const USAGE: &str = "{} [-d DIR] TO [FROM]";
+const USAGE: &str = help_usage!("relpath.md");
+const ABOUT: &str = help_about!("relpath.md");
 
 mod options {
     pub const DIR: &str = "DIR";
diff --git a/src/uu/rm/Cargo.toml b/src/uu/rm/Cargo.toml
index af63aee78..ec46031d0 100644
--- a/src/uu/rm/Cargo.toml
+++ b/src/uu/rm/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_rm"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "rm ~ (uutils) remove PATHNAME"
@@ -15,15 +15,15 @@ edition = "2021"
 path = "src/rm.rs"
 
 [dependencies]
-clap = { workspace=true }
-walkdir = { workspace=true }
-uucore = { workspace=true, features=["fs"] }
+clap = { workspace = true }
+walkdir = { workspace = true }
+uucore = { workspace = true, features = ["fs"] }
 
 [target.'cfg(unix)'.dependencies]
-libc = { workspace=true }
+libc = { workspace = true }
 
 [target.'cfg(windows)'.dependencies]
-windows-sys = { workspace=true, features = ["Win32_Storage_FileSystem"] }
+windows-sys = { workspace = true, features = ["Win32_Storage_FileSystem"] }
 
 [[bin]]
 name = "rm"
diff --git a/src/uu/rm/src/rm.rs b/src/uu/rm/src/rm.rs
index 05d03cee2..f2e2050d9 100644
--- a/src/uu/rm/src/rm.rs
+++ b/src/uu/rm/src/rm.rs
@@ -7,8 +7,9 @@
 
 // spell-checker:ignore (path) eacces
 
-use clap::{crate_version, parser::ValueSource, Arg, ArgAction, Command};
+use clap::{builder::ValueParser, crate_version, parser::ValueSource, Arg, ArgAction, Command};
 use std::collections::VecDeque;
+use std::ffi::{OsStr, OsString};
 use std::fs::{self, File, Metadata};
 use std::io::ErrorKind;
 use std::ops::BitOr;
@@ -59,9 +60,9 @@ static ARG_FILES: &str = "files";
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app().after_help(AFTER_HELP).try_get_matches_from(args)?;
 
-    let files: Vec<String> = matches
-        .get_many::<String>(ARG_FILES)
-        .map(|v| v.map(ToString::to_string).collect())
+    let files: Vec<&OsStr> = matches
+        .get_many::<OsString>(ARG_FILES)
+        .map(|v| v.map(OsString::as_os_str).collect())
         .unwrap_or_default();
 
     let force_flag = matches.get_flag(OPT_FORCE);
@@ -114,11 +115,20 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             verbose: matches.get_flag(OPT_VERBOSE),
         };
         if options.interactive == InteractiveMode::Once && (options.recursive || files.len() > 3) {
-            let msg = if options.recursive {
-                "Remove all arguments recursively?"
-            } else {
-                "Remove all arguments?"
-            };
+            let msg: String = format!(
+                "remove {} {}{}",
+                files.len(),
+                if files.len() > 1 {
+                    "arguments"
+                } else {
+                    "argument"
+                },
+                if options.recursive {
+                    " recursively?"
+                } else {
+                    "?"
+                }
+            );
             if !prompt_yes!("{}", msg) {
                 return Ok(());
             }
@@ -168,6 +178,9 @@ pub fn uu_app() -> Command {
                     prompts always",
                 )
                 .value_name("WHEN")
+                .num_args(0..=1)
+                .require_equals(true)
+                .default_missing_value("always")
                 .overrides_with_all([OPT_PROMPT, OPT_PROMPT_MORE]),
         )
         .arg(
@@ -231,13 +244,14 @@ pub fn uu_app() -> Command {
         .arg(
             Arg::new(ARG_FILES)
                 .action(ArgAction::Append)
+                .value_parser(ValueParser::os_string())
                 .num_args(1..)
                 .value_hint(clap::ValueHint::AnyPath),
         )
 }
 
 // TODO: implement one-file-system (this may get partially implemented in walkdir)
-fn remove(files: &[String], options: &Options) -> bool {
+fn remove(files: &[&OsStr], options: &Options) -> bool {
     let mut had_err = false;
 
     for filename in files {
@@ -257,14 +271,14 @@ fn remove(files: &[String], options: &Options) -> bool {
                 // TODO: When the error is not about missing files
                 // (e.g., permission), even rm -f should fail with
                 // outputting the error, but there's no easy eay.
-                if !options.force {
+                if options.force {
+                    false
+                } else {
                     show_error!(
                         "cannot remove {}: No such file or directory",
                         filename.quote()
                     );
                     true
-                } else {
-                    false
                 }
             }
         }
@@ -274,6 +288,7 @@ fn remove(files: &[String], options: &Options) -> bool {
     had_err
 }
 
+#[allow(clippy::cognitive_complexity)]
 fn handle_dir(path: &Path, options: &Options) -> bool {
     let mut had_err = false;
 
@@ -422,6 +437,7 @@ fn remove_file(path: &Path, options: &Options) -> bool {
     false
 }
 
+#[allow(clippy::cognitive_complexity)]
 fn prompt_file(path: &Path, options: &Options, is_dir: bool) -> bool {
     // If interactive is Never we never want to send prompts
     if options.interactive == InteractiveMode::Never {
diff --git a/src/uu/rmdir/Cargo.toml b/src/uu/rmdir/Cargo.toml
index 6e6bbcb15..6c152a82a 100644
--- a/src/uu/rmdir/Cargo.toml
+++ b/src/uu/rmdir/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_rmdir"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "rmdir ~ (uutils) remove empty DIRECTORY"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/rmdir.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true, features=["fs"] }
-libc = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["fs"] }
+libc = { workspace = true }
 
 [[bin]]
 name = "rmdir"
diff --git a/src/uu/runcon/Cargo.toml b/src/uu/runcon/Cargo.toml
index 46d565223..191d9f013 100644
--- a/src/uu/runcon/Cargo.toml
+++ b/src/uu/runcon/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_runcon"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "runcon ~ (uutils) run command with specified security context"
@@ -14,11 +14,11 @@ edition = "2021"
 path = "src/runcon.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true, features=["entries", "fs", "perms"] }
-selinux = { workspace=true }
-thiserror = { workspace=true }
-libc = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["entries", "fs", "perms"] }
+selinux = { workspace = true }
+thiserror = { workspace = true }
+libc = { workspace = true }
 
 [[bin]]
 name = "runcon"
diff --git a/src/uu/runcon/runcon.md b/src/uu/runcon/runcon.md
new file mode 100644
index 000000000..1911c5044
--- /dev/null
+++ b/src/uu/runcon/runcon.md
@@ -0,0 +1,18 @@
+# runcon
+
+```
+runcon [CONTEXT COMMAND [ARG...]]
+runcon [-c] [-u USER] [-r ROLE] [-t TYPE] [-l RANGE] COMMAND [ARG...]";
+```
+
+Run command with specified security context under SELinux enabled systems.
+
+## After Help
+
+Run COMMAND with completely-specified CONTEXT, or with current or transitioned security context modified by one or more of LEVEL, ROLE, TYPE, and USER.
+
+If none of --compute, --type, --user, --role or --range is specified, then the first argument is used as the complete context.
+
+Note that only carefully-chosen contexts are likely to successfully run.
+
+With neither CONTEXT nor COMMAND are specified, then this prints the current security context.
diff --git a/src/uu/runcon/src/runcon.rs b/src/uu/runcon/src/runcon.rs
index 365038907..a22bff470 100644
--- a/src/uu/runcon/src/runcon.rs
+++ b/src/uu/runcon/src/runcon.rs
@@ -3,9 +3,9 @@
 use clap::builder::ValueParser;
 use uucore::error::{UResult, UUsageError};
 
-use clap::{Arg, ArgAction, Command};
+use clap::{crate_version, Arg, ArgAction, Command};
 use selinux::{OpaqueSecurityContext, SecurityClass, SecurityContext};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_section, help_usage};
 
 use std::borrow::Cow;
 use std::ffi::{CStr, CString, OsStr, OsString};
@@ -18,19 +18,9 @@ mod errors;
 use errors::error_exit_status;
 use errors::{Error, Result, RunconError};
 
-const VERSION: &str = env!("CARGO_PKG_VERSION");
-const ABOUT: &str = "Run command with specified security context.";
-const USAGE: &str = "\
-    {} [CONTEXT COMMAND [ARG...]]
-    {} [-c] [-u USER] [-r ROLE] [-t TYPE] [-l RANGE] COMMAND [ARG...]";
-const DESCRIPTION: &str = "Run COMMAND with completely-specified CONTEXT, or with current or \
-                      transitioned security context modified by one or more of \
-                      LEVEL, ROLE, TYPE, and USER.\n\n\
-                      If none of --compute, --type, --user, --role or --range is specified, \
-                      then the first argument is used as the complete context.\n\n\
-                      Note that only carefully-chosen contexts are likely to successfully run.\n\n\
-                      With neither CONTEXT nor COMMAND are specified, \
-                      then this prints the current security context.";
+const ABOUT: &str = help_about!("runcon.md");
+const USAGE: &str = help_usage!("runcon.md");
+const DESCRIPTION: &str = help_section!("after help", "runcon.md");
 
 pub mod options {
     pub const COMPUTE: &str = "compute";
@@ -107,7 +97,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(VERSION)
+        .version(crate_version!())
         .about(ABOUT)
         .after_help(DESCRIPTION)
         .override_usage(format_usage(USAGE))
diff --git a/src/uu/seq/BENCHMARKING.md b/src/uu/seq/BENCHMARKING.md
index 4d2f82afe..c4b24b8d2 100644
--- a/src/uu/seq/BENCHMARKING.md
+++ b/src/uu/seq/BENCHMARKING.md
@@ -5,15 +5,21 @@ GNU version of `seq`, you can use a benchmarking tool like
 [hyperfine][0]. On Ubuntu 18.04 or later, you can install `hyperfine` by
 running
 
-    sudo apt-get install hyperfine
+```shell
+sudo apt-get install hyperfine
+```
 
 Next, build the `seq` binary under the release profile:
 
-    cargo build --release -p uu_seq
+```shell
+cargo build --release -p uu_seq
+```
 
 Finally, you can compare the performance of the two versions of `head`
 by running, for example,
 
-    hyperfine "seq 1000000" "target/release/seq 1000000"
+```shell
+hyperfine "seq 1000000" "target/release/seq 1000000"
+```
 
 [0]: https://github.com/sharkdp/hyperfine
diff --git a/src/uu/seq/Cargo.toml b/src/uu/seq/Cargo.toml
index d8c861aae..e327b3eba 100644
--- a/src/uu/seq/Cargo.toml
+++ b/src/uu/seq/Cargo.toml
@@ -1,7 +1,7 @@
 # spell-checker:ignore bigdecimal
 [package]
 name = "uu_seq"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "seq ~ (uutils) display a sequence of numbers"
@@ -16,11 +16,11 @@ edition = "2021"
 path = "src/seq.rs"
 
 [dependencies]
-bigdecimal = { workspace=true }
-clap = { workspace=true }
-num-bigint = { workspace=true }
-num-traits = { workspace=true }
-uucore = { workspace=true, features=["memo"] }
+bigdecimal = { workspace = true }
+clap = { workspace = true }
+num-bigint = { workspace = true }
+num-traits = { workspace = true }
+uucore = { workspace = true, features = ["memo"] }
 
 [[bin]]
 name = "seq"
diff --git a/src/uu/seq/seq.md b/src/uu/seq/seq.md
new file mode 100644
index 000000000..065404e20
--- /dev/null
+++ b/src/uu/seq/seq.md
@@ -0,0 +1,9 @@
+# seq
+
+Display numbers from FIRST to LAST, in steps of INCREMENT.
+
+```
+seq [OPTION]... LAST
+seq [OPTION]... FIRST LAST
+seq [OPTION]... FIRST INCREMENT LAST";
+```
diff --git a/src/uu/seq/src/seq.rs b/src/uu/seq/src/seq.rs
index 40bac8449..97382ed1b 100644
--- a/src/uu/seq/src/seq.rs
+++ b/src/uu/seq/src/seq.rs
@@ -2,7 +2,6 @@
 //  *
 //  * For the full copyright and license information, please view the LICENSE
 //  * file that was distributed with this source code.
-// TODO: Support -f flag
 // spell-checker:ignore (ToDO) istr chiter argptr ilen extendedbigdecimal extendedbigint numberparse
 use std::io::{stdout, ErrorKind, Write};
 use std::process::exit;
@@ -12,9 +11,9 @@ use num_traits::Zero;
 
 use uucore::error::FromIo;
 use uucore::error::UResult;
-use uucore::format_usage;
 use uucore::memo::printf;
 use uucore::show;
+use uucore::{format_usage, help_about, help_usage};
 
 mod error;
 mod extendedbigdecimal;
@@ -27,17 +26,15 @@ use crate::extendedbigint::ExtendedBigInt;
 use crate::number::Number;
 use crate::number::PreciseNumber;
 
-static ABOUT: &str = "Display numbers from FIRST to LAST, in steps of INCREMENT.";
-const USAGE: &str = "\
-    {} [OPTION]... LAST
-    {} [OPTION]... FIRST LAST
-    {} [OPTION]... FIRST INCREMENT LAST";
-static OPT_SEPARATOR: &str = "separator";
-static OPT_TERMINATOR: &str = "terminator";
-static OPT_WIDTHS: &str = "widths";
-static OPT_FORMAT: &str = "format";
+const ABOUT: &str = help_about!("seq.md");
+const USAGE: &str = help_usage!("seq.md");
 
-static ARG_NUMBERS: &str = "numbers";
+const OPT_SEPARATOR: &str = "separator";
+const OPT_TERMINATOR: &str = "terminator";
+const OPT_WIDTHS: &str = "widths";
+const OPT_FORMAT: &str = "format";
+
+const ARG_NUMBERS: &str = "numbers";
 
 #[derive(Clone)]
 struct SeqOptions<'a> {
diff --git a/src/uu/shred/Cargo.toml b/src/uu/shred/Cargo.toml
index 94a741bb3..3da23ff2b 100644
--- a/src/uu/shred/Cargo.toml
+++ b/src/uu/shred/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_shred"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "shred ~ (uutils) hide former FILE contents with repeated overwrites"
@@ -15,9 +15,10 @@ edition = "2021"
 path = "src/shred.rs"
 
 [dependencies]
-clap = { workspace=true }
-rand = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+rand = { workspace = true }
+uucore = { workspace = true }
+libc = { workspace = true }
 
 [[bin]]
 name = "shred"
diff --git a/src/uu/shred/shred.md b/src/uu/shred/shred.md
new file mode 100644
index 000000000..6d6398cce
--- /dev/null
+++ b/src/uu/shred/shred.md
@@ -0,0 +1,47 @@
+# shred
+
+<!-- spell-checker:ignore writeback -->
+
+```
+shred [OPTION]... FILE...
+```
+
+Overwrite the specified FILE(s) repeatedly, in order to make it harder for even
+very expensive hardware probing to recover the data.
+
+## After help
+
+Delete `FILE(s)` if `--remove` (`-u`) is specified.  The default is not to remove
+the files because it is common to operate on device files like `/dev/hda`, and
+those files usually should not be removed.
+
+CAUTION: Note that shred relies on a very important assumption: that the file
+system overwrites data in place.  This is the traditional way to do things, but
+many modern file system designs do not satisfy this assumption.  The following
+are examples of file systems on which shred is not effective, or is not
+guaranteed to be effective in all file system modes:
+
+ * log-structured or journal file systems, such as those supplied with
+   AIX and Solaris (and JFS, ReiserFS, XFS, Ext3, etc.)
+
+ * file systems that write redundant data and carry on even if some writes
+   fail, such as RAID-based file systems
+
+ * file systems that make snapshots, such as Network Appliance's NFS server
+
+ * file systems that cache in temporary locations, such as NFS
+   version 3 clients
+
+ * compressed file systems
+
+In the case of ext3 file systems, the above disclaimer applies (and shred is
+thus of limited effectiveness) only in `data=journal` mode, which journals file
+data in addition to just metadata.  In both the `data=ordered` (default) and
+`data=writeback` modes, shred works as usual. Ext3 journal modes can be changed
+by adding the `data=something` option to the mount options for a particular
+file system in the `/etc/fstab` file, as documented in the mount man page (`man
+mount`).
+
+In addition, file system backups and remote mirrors may contain copies of
+the file that cannot be removed, and that will allow a shredded file to be
+recovered later.
diff --git a/src/uu/shred/src/shred.rs b/src/uu/shred/src/shred.rs
index 55a36bfe2..5ec1d1213 100644
--- a/src/uu/shred/src/shred.rs
+++ b/src/uu/shred/src/shred.rs
@@ -6,248 +6,25 @@
 // * For the full copyright and license information, please view the LICENSE
 // * file that was distributed with this source code.
 
-// spell-checker:ignore (words) writeback wipesync
+// spell-checker:ignore (words) wipesync prefill
 
 use clap::{crate_version, Arg, ArgAction, Command};
-use rand::prelude::SliceRandom;
-use rand::Rng;
-use std::cell::{Cell, RefCell};
-use std::fs;
-use std::fs::{File, OpenOptions};
-use std::io;
-use std::io::prelude::*;
+#[cfg(unix)]
+use libc::S_IWUSR;
+use rand::{rngs::StdRng, seq::SliceRandom, Rng, SeedableRng};
+use std::fs::{self, File, OpenOptions};
+use std::io::{self, Seek, Write};
+#[cfg(unix)]
+use std::os::unix::prelude::PermissionsExt;
 use std::path::{Path, PathBuf};
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
-use uucore::{format_usage, show, show_if_err, util_name};
+use uucore::parse_size::parse_size;
+use uucore::{format_usage, help_about, help_section, help_usage, show, show_error, show_if_err};
 
-const BLOCK_SIZE: usize = 512;
-const NAME_CHARSET: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_.";
-
-// Patterns as shown in the GNU coreutils shred implementation
-const PATTERNS: [&[u8]; 22] = [
-    b"\x00",
-    b"\xFF",
-    b"\x55",
-    b"\xAA",
-    b"\x24\x92\x49",
-    b"\x49\x24\x92",
-    b"\x6D\xB6\xDB",
-    b"\x92\x49\x24",
-    b"\xB6\xDB\x6D",
-    b"\xDB\x6D\xB6",
-    b"\x11",
-    b"\x22",
-    b"\x33",
-    b"\x44",
-    b"\x66",
-    b"\x77",
-    b"\x88",
-    b"\x99",
-    b"\xBB",
-    b"\xCC",
-    b"\xDD",
-    b"\xEE",
-];
-
-#[derive(Clone, Copy)]
-enum PassType<'a> {
-    Pattern(&'a [u8]),
-    Random,
-}
-
-// Used to generate all possible filenames of a certain length using NAME_CHARSET as an alphabet
-struct FilenameGenerator {
-    name_len: usize,
-    name_charset_indices: RefCell<Vec<usize>>, // Store the indices of the letters of our filename in NAME_CHARSET
-    exhausted: Cell<bool>,
-}
-
-impl FilenameGenerator {
-    fn new(name_len: usize) -> Self {
-        let indices: Vec<usize> = vec![0; name_len];
-        Self {
-            name_len,
-            name_charset_indices: RefCell::new(indices),
-            exhausted: Cell::new(false),
-        }
-    }
-}
-
-impl Iterator for FilenameGenerator {
-    type Item = String;
-
-    fn next(&mut self) -> Option<String> {
-        if self.exhausted.get() {
-            return None;
-        }
-
-        let mut name_charset_indices = self.name_charset_indices.borrow_mut();
-
-        // Make the return value, then increment
-        let mut ret = String::new();
-        for i in name_charset_indices.iter() {
-            let c = char::from(NAME_CHARSET[*i]);
-            ret.push(c);
-        }
-
-        if name_charset_indices[0] == NAME_CHARSET.len() - 1 {
-            self.exhausted.set(true);
-        }
-        // Now increment the least significant index
-        for i in (0..self.name_len).rev() {
-            if name_charset_indices[i] == NAME_CHARSET.len() - 1 {
-                name_charset_indices[i] = 0; // Carry the 1
-                continue;
-            } else {
-                name_charset_indices[i] += 1;
-                break;
-            }
-        }
-
-        Some(ret)
-    }
-}
-
-// Used to generate blocks of bytes of size <= BLOCK_SIZE based on either a give pattern
-// or randomness
-struct BytesGenerator<'a> {
-    total_bytes: u64,
-    bytes_generated: Cell<u64>,
-    block_size: usize,
-    exact: bool, // if false, every block's size is block_size
-    gen_type: PassType<'a>,
-    rng: Option<RefCell<rand::rngs::ThreadRng>>,
-    bytes: [u8; BLOCK_SIZE],
-}
-
-impl<'a> BytesGenerator<'a> {
-    fn new(total_bytes: u64, gen_type: PassType<'a>, exact: bool) -> BytesGenerator {
-        let rng = match gen_type {
-            PassType::Random => Some(RefCell::new(rand::thread_rng())),
-            PassType::Pattern(_) => None,
-        };
-
-        let bytes = [0; BLOCK_SIZE];
-
-        BytesGenerator {
-            total_bytes,
-            bytes_generated: Cell::new(0u64),
-            block_size: BLOCK_SIZE,
-            exact,
-            gen_type,
-            rng,
-            bytes,
-        }
-    }
-
-    pub fn reset(&mut self, total_bytes: u64, gen_type: PassType<'a>) {
-        if let PassType::Random = gen_type {
-            if self.rng.is_none() {
-                self.rng = Some(RefCell::new(rand::thread_rng()));
-            }
-        }
-
-        self.total_bytes = total_bytes;
-        self.gen_type = gen_type;
-
-        self.bytes_generated.set(0);
-    }
-
-    pub fn next(&mut self) -> Option<&[u8]> {
-        // We go over the total_bytes limit when !self.exact and total_bytes isn't a multiple
-        // of self.block_size
-        if self.bytes_generated.get() >= self.total_bytes {
-            return None;
-        }
-
-        let this_block_size = if !self.exact {
-            self.block_size
-        } else {
-            let bytes_left = self.total_bytes - self.bytes_generated.get();
-            if bytes_left >= self.block_size as u64 {
-                self.block_size
-            } else {
-                (bytes_left % self.block_size as u64) as usize
-            }
-        };
-
-        let bytes = &mut self.bytes[..this_block_size];
-
-        match self.gen_type {
-            PassType::Random => {
-                let mut rng = self.rng.as_ref().unwrap().borrow_mut();
-                rng.fill(bytes);
-            }
-            PassType::Pattern(pattern) => {
-                let skip = if self.bytes_generated.get() == 0 {
-                    0
-                } else {
-                    (pattern.len() as u64 % self.bytes_generated.get()) as usize
-                };
-
-                // Copy the pattern in chunks rather than simply one byte at a time
-                let mut i = 0;
-                while i < this_block_size {
-                    let start = (i + skip) % pattern.len();
-                    let end = (this_block_size - i).min(pattern.len());
-                    let len = end - start;
-
-                    bytes[i..i + len].copy_from_slice(&pattern[start..end]);
-
-                    i += len;
-                }
-            }
-        };
-
-        let new_bytes_generated = self.bytes_generated.get() + this_block_size as u64;
-        self.bytes_generated.set(new_bytes_generated);
-
-        Some(bytes)
-    }
-}
-
-static ABOUT: &str = "Overwrite the specified FILE(s) repeatedly, in order to make it harder\n\
-for even very expensive hardware probing to recover the data.
-";
-const USAGE: &str = "{} [OPTION]... FILE...";
-
-static AFTER_HELP: &str =
-    "Delete FILE(s) if --remove (-u) is specified.  The default is not to remove\n\
-     the files because it is common to operate on device files like /dev/hda,\n\
-     and those files usually should not be removed.\n\
-     \n\
-     CAUTION: Note that shred relies on a very important assumption:\n\
-     that the file system overwrites data in place.  This is the traditional\n\
-     way to do things, but many modern file system designs do not satisfy this\n\
-     assumption.  The following are examples of file systems on which shred is\n\
-     not effective, or is not guaranteed to be effective in all file system modes:\n\
-     \n\
-     * log-structured or journal file systems, such as those supplied with\n\
-     AIX and Solaris (and JFS, ReiserFS, XFS, Ext3, etc.)\n\
-     \n\
-     * file systems that write redundant data and carry on even if some writes\n\
-     fail, such as RAID-based file systems\n\
-     \n\
-     * file systems that make snapshots, such as Network Appliance's NFS server\n\
-     \n\
-     * file systems that cache in temporary locations, such as NFS\n\
-     version 3 clients\n\
-     \n\
-     * compressed file systems\n\
-     \n\
-     In the case of ext3 file systems, the above disclaimer applies\n\
-     and shred is thus of limited effectiveness) only in data=journal mode,\n\
-     which journals file data in addition to just metadata.  In both the\n\
-     data=ordered (default) and data=writeback modes, shred works as usual.\n\
-     Ext3 journal modes can be changed by adding the data=something option\n\
-     to the mount options for a particular file system in the /etc/fstab file,\n\
-     as documented in the mount man page (man mount).\n\
-     \n\
-     In addition, file system backups and remote mirrors may contain copies\n\
-     of the file that cannot be removed, and that will allow a shredded file\n\
-     to be recovered later.\n\
-     ";
+const ABOUT: &str = help_about!("shred.md");
+const USAGE: &str = help_usage!("shred.md");
+const AFTER_HELP: &str = help_section!("after help", "shred.md");
 
 pub mod options {
     pub const FORCE: &str = "force";
@@ -260,6 +37,170 @@ pub mod options {
     pub const ZERO: &str = "zero";
 }
 
+// This block size seems to match GNU (2^16 = 65536)
+const BLOCK_SIZE: usize = 1 << 16;
+const NAME_CHARSET: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_.";
+
+const PATTERN_LENGTH: usize = 3;
+const PATTERN_BUFFER_SIZE: usize = BLOCK_SIZE + PATTERN_LENGTH - 1;
+
+/// Patterns that appear in order for the passes
+///
+/// They are all extended to 3 bytes for consistency, even though some could be
+/// expressed as single bytes.
+const PATTERNS: [Pattern; 22] = [
+    Pattern::Single(b'\x00'),
+    Pattern::Single(b'\xFF'),
+    Pattern::Single(b'\x55'),
+    Pattern::Single(b'\xAA'),
+    Pattern::Multi([b'\x24', b'\x92', b'\x49']),
+    Pattern::Multi([b'\x49', b'\x24', b'\x92']),
+    Pattern::Multi([b'\x6D', b'\xB6', b'\xDB']),
+    Pattern::Multi([b'\x92', b'\x49', b'\x24']),
+    Pattern::Multi([b'\xB6', b'\xDB', b'\x6D']),
+    Pattern::Multi([b'\xDB', b'\x6D', b'\xB6']),
+    Pattern::Single(b'\x11'),
+    Pattern::Single(b'\x22'),
+    Pattern::Single(b'\x33'),
+    Pattern::Single(b'\x44'),
+    Pattern::Single(b'\x66'),
+    Pattern::Single(b'\x77'),
+    Pattern::Single(b'\x88'),
+    Pattern::Single(b'\x99'),
+    Pattern::Single(b'\xBB'),
+    Pattern::Single(b'\xCC'),
+    Pattern::Single(b'\xDD'),
+    Pattern::Single(b'\xEE'),
+];
+
+#[derive(Clone, Copy)]
+enum Pattern {
+    Single(u8),
+    Multi([u8; 3]),
+}
+
+enum PassType {
+    Pattern(Pattern),
+    Random,
+}
+
+/// Iterates over all possible filenames of a certain length using NAME_CHARSET as an alphabet
+struct FilenameIter {
+    // Store the indices of the letters of our filename in NAME_CHARSET
+    name_charset_indices: Vec<usize>,
+    exhausted: bool,
+}
+
+impl FilenameIter {
+    fn new(name_len: usize) -> Self {
+        Self {
+            name_charset_indices: vec![0; name_len],
+            exhausted: false,
+        }
+    }
+}
+
+impl Iterator for FilenameIter {
+    type Item = String;
+
+    fn next(&mut self) -> Option<String> {
+        if self.exhausted {
+            return None;
+        }
+
+        // First, make the return value using the current state
+        let ret: String = self
+            .name_charset_indices
+            .iter()
+            .map(|i| char::from(NAME_CHARSET[*i]))
+            .collect();
+
+        // Now increment the least significant index and possibly each next
+        // index if necessary.
+        for index in self.name_charset_indices.iter_mut().rev() {
+            if *index == NAME_CHARSET.len() - 1 {
+                // Carry the 1
+                *index = 0;
+                continue;
+            } else {
+                *index += 1;
+                return Some(ret);
+            }
+        }
+
+        // If we get here, we flipped all bits back to 0, so we exhausted all options.
+        self.exhausted = true;
+        Some(ret)
+    }
+}
+
+/// Used to generate blocks of bytes of size <= BLOCK_SIZE based on either a give pattern
+/// or randomness
+// The lint warns about a large difference because StdRng is big, but the buffers are much
+// larger anyway, so it's fine.
+#[allow(clippy::large_enum_variant)]
+enum BytesWriter {
+    Random {
+        rng: StdRng,
+        buffer: [u8; BLOCK_SIZE],
+    },
+    // To write patterns we only write to the buffer once. To be able to do
+    // this, we need to extend the buffer with 2 bytes. We can then easily
+    // obtain a buffer starting with any character of the pattern that we
+    // want with an offset of either 0, 1 or 2.
+    //
+    // For example, if we have the pattern ABC, but we want to write a block
+    // of BLOCK_SIZE starting with B, we just pick the slice [1..BLOCK_SIZE+1]
+    // This means that we only have to fill the buffer once and can just reuse
+    // it afterwards.
+    Pattern {
+        offset: usize,
+        buffer: [u8; PATTERN_BUFFER_SIZE],
+    },
+}
+
+impl BytesWriter {
+    fn from_pass_type(pass: &PassType) -> Self {
+        match pass {
+            PassType::Random => Self::Random {
+                rng: StdRng::from_entropy(),
+                buffer: [0; BLOCK_SIZE],
+            },
+            PassType::Pattern(pattern) => {
+                // Copy the pattern in chunks rather than simply one byte at a time
+                // We prefill the pattern so that the buffer can be reused at each
+                // iteration as a small optimization.
+                let buffer = match pattern {
+                    Pattern::Single(byte) => [*byte; PATTERN_BUFFER_SIZE],
+                    Pattern::Multi(bytes) => {
+                        let mut buf = [0; PATTERN_BUFFER_SIZE];
+                        for chunk in buf.chunks_exact_mut(PATTERN_LENGTH) {
+                            chunk.copy_from_slice(bytes);
+                        }
+                        buf
+                    }
+                };
+                Self::Pattern { offset: 0, buffer }
+            }
+        }
+    }
+
+    fn bytes_for_pass(&mut self, size: usize) -> &[u8] {
+        match self {
+            Self::Random { rng, buffer } => {
+                let bytes = &mut buffer[..size];
+                rng.fill(bytes);
+                bytes
+            }
+            Self::Pattern { offset, buffer } => {
+                let bytes = &buffer[*offset..size + *offset];
+                *offset = (*offset + size) % PATTERN_LENGTH;
+                bytes
+            }
+        }
+    }
+}
+
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args.collect_ignore();
@@ -298,7 +239,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         .get_one::<String>(options::SIZE)
         .map(|s| s.to_string());
     let size = get_size(size_arg);
-    let exact = matches.get_flag(options::EXACT) && size.is_none(); // if -s is given, ignore -x
+    let exact = matches.get_flag(options::EXACT) || size.is_some();
     let zero = matches.get_flag(options::ZERO);
     let verbose = matches.get_flag(options::VERBOSE);
 
@@ -378,61 +319,29 @@ pub fn uu_app() -> Command {
         )
 }
 
-// TODO: Add support for all postfixes here up to and including EiB
-//       http://www.gnu.org/software/coreutils/manual/coreutils.html#Block-size
 fn get_size(size_str_opt: Option<String>) -> Option<u64> {
-    size_str_opt.as_ref()?;
-
-    let mut size_str = size_str_opt.as_ref().unwrap().clone();
-    // Immutably look at last character of size string
-    let unit = match size_str.chars().last().unwrap() {
-        'K' => {
-            size_str.pop();
-            1024u64
-        }
-        'M' => {
-            size_str.pop();
-            (1024 * 1024) as u64
-        }
-        'G' => {
-            size_str.pop();
-            (1024 * 1024 * 1024) as u64
-        }
-        _ => 1u64,
-    };
-
-    let coefficient = match size_str.parse::<u64>() {
-        Ok(u) => u,
-        Err(_) => {
-            println!(
-                "{}: {}: Invalid file size",
-                util_name(),
-                size_str_opt.unwrap().maybe_quote()
-            );
-            std::process::exit(1);
-        }
-    };
-
-    Some(coefficient * unit)
+    size_str_opt
+        .as_ref()
+        .and_then(|size| parse_size(size.as_str()).ok())
+        .or_else(|| {
+            if let Some(size) = size_str_opt {
+                show_error!("invalid file size: {}", size.quote());
+                std::process::exit(1);
+            }
+            None
+        })
 }
 
-fn pass_name(pass_type: PassType) -> String {
+fn pass_name(pass_type: &PassType) -> String {
     match pass_type {
         PassType::Random => String::from("random"),
-        PassType::Pattern(bytes) => {
-            let mut s: String = String::new();
-            while s.len() < 6 {
-                for b in bytes {
-                    let readable: String = format!("{b:x}");
-                    s.push_str(&readable);
-                }
-            }
-            s
-        }
+        PassType::Pattern(Pattern::Single(byte)) => format!("{byte:x}{byte:x}{byte:x}"),
+        PassType::Pattern(Pattern::Multi([a, b, c])) => format!("{a:x}{b:x}{c:x}"),
     }
 }
 
 #[allow(clippy::too_many_arguments)]
+#[allow(clippy::cognitive_complexity)]
 fn wipe_file(
     path_str: &str,
     n_passes: usize,
@@ -444,7 +353,7 @@ fn wipe_file(
     force: bool,
 ) -> UResult<()> {
     // Get these potential errors out of the way first
-    let path: &Path = Path::new(path_str);
+    let path = Path::new(path_str);
     if !path.exists() {
         return Err(USimpleError::new(
             1,
@@ -462,30 +371,41 @@ fn wipe_file(
     if force {
         let metadata = fs::metadata(path).map_err_context(String::new)?;
         let mut perms = metadata.permissions();
+        #[cfg(unix)]
+        #[allow(clippy::useless_conversion)]
+        {
+            // NOTE: set_readonly(false) makes the file world-writable on Unix.
+            // NOTE: S_IWUSR type is u16 on macOS.
+            if (perms.mode() & u32::from(S_IWUSR)) == 0 {
+                perms.set_mode(u32::from(S_IWUSR));
+            }
+        }
+        #[cfg(not(unix))]
+        // TODO: Remove the following once https://github.com/rust-lang/rust-clippy/issues/10477 is resolved.
+        #[allow(clippy::permissions_set_readonly_false)]
         perms.set_readonly(false);
         fs::set_permissions(path, perms).map_err_context(String::new)?;
     }
 
     // Fill up our pass sequence
-    let mut pass_sequence: Vec<PassType> = Vec::new();
+    let mut pass_sequence = Vec::new();
 
     if n_passes <= 3 {
         // Only random passes if n_passes <= 3
         for _ in 0..n_passes {
             pass_sequence.push(PassType::Random);
         }
-    }
-    // First fill it with Patterns, shuffle it, then evenly distribute Random
-    else {
+    } else {
+        // First fill it with Patterns, shuffle it, then evenly distribute Random
         let n_full_arrays = n_passes / PATTERNS.len(); // How many times can we go through all the patterns?
         let remainder = n_passes % PATTERNS.len(); // How many do we get through on our last time through?
 
         for _ in 0..n_full_arrays {
-            for p in &PATTERNS {
+            for p in PATTERNS {
                 pass_sequence.push(PassType::Pattern(p));
             }
         }
-        for pattern in PATTERNS.iter().take(remainder) {
+        for pattern in PATTERNS.into_iter().take(remainder) {
             pass_sequence.push(PassType::Pattern(pattern));
         }
         let mut rng = rand::thread_rng();
@@ -500,49 +420,46 @@ fn wipe_file(
 
     // --zero specifies whether we want one final pass of 0x00 on our file
     if zero {
-        pass_sequence.push(PassType::Pattern(b"\x00"));
+        pass_sequence.push(PassType::Pattern(PATTERNS[0]));
     }
 
-    {
-        let total_passes: usize = pass_sequence.len();
-        let mut file: File = OpenOptions::new()
-            .write(true)
-            .truncate(false)
-            .open(path)
-            .map_err_context(|| format!("{}: failed to open for writing", path.maybe_quote()))?;
+    let total_passes = pass_sequence.len();
+    let mut file = OpenOptions::new()
+        .write(true)
+        .truncate(false)
+        .open(path)
+        .map_err_context(|| format!("{}: failed to open for writing", path.maybe_quote()))?;
 
-        // NOTE: it does not really matter what we set for total_bytes and gen_type here, so just
-        //       use bogus values
-        let mut generator = BytesGenerator::new(0, PassType::Pattern(&[]), exact);
+    let size = match size {
+        Some(size) => size,
+        None => get_file_size(path)?,
+    };
 
-        for (i, pass_type) in pass_sequence.iter().enumerate() {
-            if verbose {
-                let pass_name: String = pass_name(*pass_type);
-                if total_passes.to_string().len() == 1 {
-                    println!(
-                        "{}: {}: pass {}/{} ({})... ",
-                        util_name(),
-                        path.maybe_quote(),
-                        i + 1,
-                        total_passes,
-                        pass_name
-                    );
-                } else {
-                    println!(
-                        "{}: {}: pass {:2.0}/{:2.0} ({})... ",
-                        util_name(),
-                        path.maybe_quote(),
-                        i + 1,
-                        total_passes,
-                        pass_name
-                    );
-                }
+    for (i, pass_type) in pass_sequence.into_iter().enumerate() {
+        if verbose {
+            let pass_name = pass_name(&pass_type);
+            if total_passes < 10 {
+                show_error!(
+                    "{}: pass {}/{} ({})... ",
+                    path.maybe_quote(),
+                    i + 1,
+                    total_passes,
+                    pass_name
+                );
+            } else {
+                show_error!(
+                    "{}: pass {:2.0}/{:2.0} ({})... ",
+                    path.maybe_quote(),
+                    i + 1,
+                    total_passes,
+                    pass_name
+                );
             }
-            // size is an optional argument for exactly how many bytes we want to shred
-            show_if_err!(do_pass(&mut file, path, &mut generator, *pass_type, size)
-                .map_err_context(|| format!("{}: File write pass failed", path.maybe_quote())));
-            // Ignore failed writes; just keep trying
         }
+        // size is an optional argument for exactly how many bytes we want to shred
+        // Ignore failed writes; just keep trying
+        show_if_err!(do_pass(&mut file, &pass_type, exact, size)
+            .map_err_context(|| format!("{}: File write pass failed", path.maybe_quote())));
     }
 
     if remove {
@@ -552,21 +469,29 @@ fn wipe_file(
     Ok(())
 }
 
-fn do_pass<'a>(
+fn do_pass(
     file: &mut File,
-    path: &Path,
-    generator: &mut BytesGenerator<'a>,
-    generator_type: PassType<'a>,
-    given_file_size: Option<u64>,
+    pass_type: &PassType,
+    exact: bool,
+    file_size: u64,
 ) -> Result<(), io::Error> {
+    // We might be at the end of the file due to a previous iteration, so rewind.
     file.rewind()?;
 
-    // Use the given size or the whole file if not specified
-    let size: u64 = given_file_size.unwrap_or(get_file_size(path)?);
+    let mut writer = BytesWriter::from_pass_type(pass_type);
 
-    generator.reset(size, generator_type);
+    // We start by writing BLOCK_SIZE times as many time as possible.
+    for _ in 0..(file_size / BLOCK_SIZE as u64) {
+        let block = writer.bytes_for_pass(BLOCK_SIZE);
+        file.write_all(block)?;
+    }
 
-    while let Some(block) = generator.next() {
+    // Now we might have some bytes left, so we write either that
+    // many bytes if exact is true, or BLOCK_SIZE bytes if not.
+    let bytes_left = (file_size % BLOCK_SIZE as u64) as usize;
+    if bytes_left > 0 {
+        let size = if exact { bytes_left } else { BLOCK_SIZE };
+        let block = writer.bytes_for_pass(size);
         file.write_all(block)?;
     }
 
@@ -576,21 +501,21 @@ fn do_pass<'a>(
 }
 
 fn get_file_size(path: &Path) -> Result<u64, io::Error> {
-    let size: u64 = fs::metadata(path)?.len();
-
-    Ok(size)
+    Ok(fs::metadata(path)?.len())
 }
 
 // Repeatedly renames the file with strings of decreasing length (most likely all 0s)
 // Return the path of the file after its last renaming or None if error
 fn wipe_name(orig_path: &Path, verbose: bool) -> Option<PathBuf> {
-    let file_name_len: usize = orig_path.file_name().unwrap().to_str().unwrap().len();
+    let file_name_len = orig_path.file_name().unwrap().to_str().unwrap().len();
 
-    let mut last_path: PathBuf = PathBuf::from(orig_path);
+    let mut last_path = PathBuf::from(orig_path);
 
     for length in (1..=file_name_len).rev() {
-        for name in FilenameGenerator::new(length) {
-            let new_path: PathBuf = orig_path.with_file_name(name);
+        // Try all filenames of a given length.
+        // If every possible filename already exists, just reduce the length and try again
+        for name in FilenameIter::new(length) {
+            let new_path = orig_path.with_file_name(name);
             // We don't want the filename to already exist (don't overwrite)
             // If it does, find another name that doesn't
             if new_path.exists() {
@@ -599,28 +524,24 @@ fn wipe_name(orig_path: &Path, verbose: bool) -> Option<PathBuf> {
             match fs::rename(&last_path, &new_path) {
                 Ok(()) => {
                     if verbose {
-                        println!(
-                            "{}: {}: renamed to {}",
-                            util_name(),
+                        show_error!(
+                            "{}: renamed to {}",
                             last_path.maybe_quote(),
                             new_path.quote()
                         );
                     }
 
                     // Sync every file rename
-                    {
-                        let new_file: File = File::open(new_path.clone())
-                            .expect("Failed to open renamed file for syncing");
-                        new_file.sync_all().expect("Failed to sync renamed file");
-                    }
+                    let new_file = File::open(new_path.clone())
+                        .expect("Failed to open renamed file for syncing");
+                    new_file.sync_all().expect("Failed to sync renamed file");
 
                     last_path = new_path;
                     break;
                 }
                 Err(e) => {
-                    println!(
-                        "{}: {}: Couldn't rename to {}: {}",
-                        util_name(),
+                    show_error!(
+                        "{}: Couldn't rename to {}: {}",
                         last_path.maybe_quote(),
                         new_path.quote(),
                         e
@@ -628,7 +549,7 @@ fn wipe_name(orig_path: &Path, verbose: bool) -> Option<PathBuf> {
                     return None;
                 }
             }
-        } // If every possible filename already exists, just reduce the length and try again
+        }
     }
 
     Some(last_path)
@@ -636,16 +557,15 @@ fn wipe_name(orig_path: &Path, verbose: bool) -> Option<PathBuf> {
 
 fn do_remove(path: &Path, orig_filename: &str, verbose: bool) -> Result<(), io::Error> {
     if verbose {
-        println!("{}: {}: removing", util_name(), orig_filename.maybe_quote());
+        show_error!("{}: removing", orig_filename.maybe_quote());
     }
 
-    let renamed_path: Option<PathBuf> = wipe_name(path, verbose);
-    if let Some(rp) = renamed_path {
+    if let Some(rp) = wipe_name(path, verbose) {
         fs::remove_file(rp)?;
     }
 
     if verbose {
-        println!("{}: {}: removed", util_name(), orig_filename.maybe_quote());
+        show_error!("{}: removed", orig_filename.maybe_quote());
     }
 
     Ok(())
diff --git a/src/uu/shuf/BENCHMARKING.md b/src/uu/shuf/BENCHMARKING.md
index 23f647e9e..6fa9028af 100644
--- a/src/uu/shuf/BENCHMARKING.md
+++ b/src/uu/shuf/BENCHMARKING.md
@@ -21,10 +21,10 @@ To avoid distortions from IO, it is recommended to store input data in tmpfs.
 
 ## Without repetition
 
-By default, `shuf` samples without repetition. 
+By default, `shuf` samples without repetition.
 
-To benchmark only the randomization and not IO, we can pass the `-i` flag with 
-a range of numbers to randomly sample from. An example of a command that works 
+To benchmark only the randomization and not IO, we can pass the `-i` flag with
+a range of numbers to randomly sample from. An example of a command that works
 well for testing:
 
 ```shell
diff --git a/src/uu/shuf/Cargo.toml b/src/uu/shuf/Cargo.toml
index eed9065c7..974791ee1 100644
--- a/src/uu/shuf/Cargo.toml
+++ b/src/uu/shuf/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_shuf"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "shuf ~ (uutils) display random permutations of input lines"
@@ -15,11 +15,11 @@ edition = "2021"
 path = "src/shuf.rs"
 
 [dependencies]
-clap = { workspace=true }
-memchr = { workspace=true }
-rand = { workspace=true }
-rand_core = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+memchr = { workspace = true }
+rand = { workspace = true }
+rand_core = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "shuf"
diff --git a/src/uu/shuf/shuf.md b/src/uu/shuf/shuf.md
index 41a275035..b59799c33 100644
--- a/src/uu/shuf/shuf.md
+++ b/src/uu/shuf/shuf.md
@@ -8,4 +8,4 @@ shuf -i LO-HI [OPTION]...;
 
 Shuffle the input by outputting a random permutation of input lines.
 Each output permutation is equally likely.
-With no FILE, or when FILE is -, read standard input.
\ No newline at end of file
+With no FILE, or when FILE is -, read standard input.
diff --git a/src/uu/sleep/Cargo.toml b/src/uu/sleep/Cargo.toml
index 048f551c1..2cd38988e 100644
--- a/src/uu/sleep/Cargo.toml
+++ b/src/uu/sleep/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_sleep"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "sleep ~ (uutils) pause for DURATION"
@@ -15,8 +15,9 @@ edition = "2021"
 path = "src/sleep.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+fundu = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "sleep"
diff --git a/src/uu/sleep/sleep.md b/src/uu/sleep/sleep.md
index 0a9a39a19..b5c07fb49 100644
--- a/src/uu/sleep/sleep.md
+++ b/src/uu/sleep/sleep.md
@@ -13,4 +13,4 @@ Pause for NUMBER seconds.  SUFFIX may be 's' for seconds (the default),
 'm' for minutes, 'h' for hours or 'd' for days.  Unlike most implementations
 that require NUMBER be an integer, here NUMBER may be an arbitrary floating
 point number.  Given two or more arguments, pause for the amount of time
-specified by the sum of their values.
\ No newline at end of file
+specified by the sum of their values.
diff --git a/src/uu/sleep/src/sleep.rs b/src/uu/sleep/src/sleep.rs
index 517fda098..8acb7724f 100644
--- a/src/uu/sleep/src/sleep.rs
+++ b/src/uu/sleep/src/sleep.rs
@@ -10,10 +10,11 @@ use std::time::Duration;
 
 use uucore::{
     error::{UResult, USimpleError, UUsageError},
-    format_usage, help_about, help_section, help_usage, show,
+    format_usage, help_about, help_section, help_usage, show_error,
 };
 
 use clap::{crate_version, Arg, ArgAction, Command};
+use fundu::{self, DurationParser, ParseError, SaturatingInto};
 
 static ABOUT: &str = help_about!("sleep.md");
 const USAGE: &str = help_usage!("sleep.md");
@@ -61,15 +62,39 @@ pub fn uu_app() -> Command {
 
 fn sleep(args: &[&str]) -> UResult<()> {
     let mut arg_error = false;
-    let intervals = args.iter().map(|s| match uucore::parse_time::from_str(s) {
-        Ok(result) => result,
-        Err(err) => {
-            arg_error = true;
-            show!(USimpleError::new(1, err));
-            Duration::new(0, 0)
-        }
-    });
-    let sleep_dur = intervals.fold(Duration::new(0, 0), |acc, n| acc + n);
+
+    use fundu::TimeUnit::{Day, Hour, Minute, Second};
+    let parser = DurationParser::with_time_units(&[Second, Minute, Hour, Day]);
+
+    let sleep_dur = args
+        .iter()
+        .filter_map(|input| match parser.parse(input.trim()) {
+            Ok(duration) => Some(duration),
+            Err(error) => {
+                arg_error = true;
+
+                let reason = match error {
+                    ParseError::Empty if input.is_empty() => "Input was empty".to_string(),
+                    ParseError::Empty => "Found only whitespace in input".to_string(),
+                    ParseError::Syntax(pos, description)
+                    | ParseError::TimeUnit(pos, description) => {
+                        format!("{description} at position {}", pos.saturating_add(1))
+                    }
+                    ParseError::NegativeExponentOverflow | ParseError::PositiveExponentOverflow => {
+                        "Exponent was out of bounds".to_string()
+                    }
+                    ParseError::NegativeNumber => "Number was negative".to_string(),
+                    error => error.to_string(),
+                };
+                show_error!("invalid time interval '{input}': {reason}");
+
+                None
+            }
+        })
+        .fold(Duration::ZERO, |acc, n| {
+            acc.saturating_add(SaturatingInto::<std::time::Duration>::saturating_into(n))
+        });
+
     if arg_error {
         return Err(UUsageError::new(1, ""));
     };
diff --git a/src/uu/sort/BENCHMARKING.md b/src/uu/sort/BENCHMARKING.md
index 77186318a..0cc344c31 100644
--- a/src/uu/sort/BENCHMARKING.md
+++ b/src/uu/sort/BENCHMARKING.md
@@ -12,64 +12,59 @@ Run `cargo build --release` before benchmarking after you make a change!
 
 ## Sorting a wordlist
 
--   Get a wordlist, for example with [words](<https://en.wikipedia.org/wiki/Words_(Unix)>) on Linux. The exact wordlist
+- Get a wordlist, for example with [words](<https://en.wikipedia.org/wiki/Words_(Unix)>) on Linux. The exact wordlist
     doesn't matter for performance comparisons. In this example I'm using `/usr/share/dict/american-english` as the wordlist.
--   Shuffle the wordlist by running `sort -R /usr/share/dict/american-english > shuffled_wordlist.txt`.
--   Benchmark sorting the wordlist with hyperfine: `hyperfine "target/release/coreutils sort shuffled_wordlist.txt -o output.txt"`.
+- Shuffle the wordlist by running `sort -R /usr/share/dict/american-english > shuffled_wordlist.txt`.
+- Benchmark sorting the wordlist with hyperfine: `hyperfine "target/release/coreutils sort shuffled_wordlist.txt -o output.txt"`.
 
 ## Sorting a wordlist with ignore_case
 
--   Same wordlist as above
--   Benchmark sorting the wordlist ignoring the case with hyperfine: `hyperfine "target/release/coreutils sort shuffled_wordlist.txt -f -o output.txt"`.
+- Same wordlist as above
+- Benchmark sorting the wordlist ignoring the case with hyperfine: `hyperfine "target/release/coreutils sort shuffled_wordlist.txt -f -o output.txt"`.
 
 ## Sorting numbers
 
--   Generate a list of numbers: `seq 0 100000 | sort -R > shuffled_numbers.txt`.
--   Benchmark numeric sorting with hyperfine: `hyperfine "target/release/coreutils sort shuffled_numbers.txt -n -o output.txt"`.
+- Generate a list of numbers: `seq 0 100000 | sort -R > shuffled_numbers.txt`.
+- Benchmark numeric sorting with hyperfine: `hyperfine "target/release/coreutils sort shuffled_numbers.txt -n -o output.txt"`.
 
 ## Sorting numbers with -g
 
--   Same list of numbers as above.
--   Benchmark numeric sorting with hyperfine: `hyperfine "target/release/coreutils sort shuffled_numbers.txt -g -o output.txt"`.
+- Same list of numbers as above.
+- Benchmark numeric sorting with hyperfine: `hyperfine "target/release/coreutils sort shuffled_numbers.txt -g -o output.txt"`.
 
 ## Sorting numbers with SI prefixes
 
--   Generate a list of numbers:
-    <details>
-      <summary>Rust script</summary>
+- Generate a list of numbers:
 
-    ## Cargo.toml
+## Cargo.toml
 
-    ```toml
-    [dependencies]
-    rand = "0.8.3"
-    ```
+```toml
+[dependencies]
+rand = "0.8.3"
+```
 
-    ## main.rs
+## main.rs
 
-    ```rust
-    use rand::prelude::*;
-    fn main() {
-      let suffixes = ['k', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
-      let mut rng = thread_rng();
-      for _ in 0..100000 {
-          println!(
-              "{}{}",
-              rng.gen_range(0..1000000),
-              suffixes.choose(&mut rng).unwrap()
-          )
-      }
+```rust
+use rand::prelude::*;
+fn main() {
+    let suffixes = ['k', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
+    let mut rng = thread_rng();
+    for _ in 0..100000 {
+        println!(
+            "{}{}",
+            rng.gen_range(0..1000000),
+            suffixes.choose(&mut rng).unwrap()
+        )
     }
+}
+```
 
-    ```
+## running
 
-    ## running
+`cargo run > shuffled_numbers_si.txt`
 
-    `cargo run > shuffled_numbers_si.txt`
-
-    </details>
-
--   Benchmark numeric sorting with hyperfine: `hyperfine "target/release/coreutils sort shuffled_numbers_si.txt -h -o output.txt"`.
+- Benchmark numeric sorting with hyperfine: `hyperfine "target/release/coreutils sort shuffled_numbers_si.txt -h -o output.txt"`.
 
 ## External sorting
 
@@ -83,28 +78,28 @@ Example: Run `hyperfine './target/release/coreutils sort shuffled_wordlist.txt -
 
 "Merge" sort merges already sorted files. It is a sub-step of external sorting, so benchmarking it separately may be helpful.
 
--   Splitting `shuffled_wordlist.txt` can be achieved by running `split shuffled_wordlist.txt shuffled_wordlist_slice_ --additional-suffix=.txt`
--   Sort each part by running `for f in shuffled_wordlist_slice_*; do sort $f -o $f; done`
--   Benchmark merging by running `hyperfine "target/release/coreutils sort -m shuffled_wordlist_slice_*"`
+- Splitting `shuffled_wordlist.txt` can be achieved by running `split shuffled_wordlist.txt shuffled_wordlist_slice_ --additional-suffix=.txt`
+- Sort each part by running `for f in shuffled_wordlist_slice_*; do sort $f -o $f; done`
+- Benchmark merging by running `hyperfine "target/release/coreutils sort -m shuffled_wordlist_slice_*"`
 
 ## Check
 
 When invoked with -c, we simply check if the input is already ordered. The input for benchmarking should be an already sorted file.
 
--   Benchmark checking by running `hyperfine "target/release/coreutils sort -c sorted_wordlist.txt"`
+- Benchmark checking by running `hyperfine "target/release/coreutils sort -c sorted_wordlist.txt"`
 
 ## Stdout and stdin performance
 
 Try to run the above benchmarks by piping the input through stdin (standard input) and redirect the
 output through stdout (standard output):
 
--   Remove the input file from the arguments and add `cat [input_file] | ` at the beginning.
--   Remove `-o output.txt` and add `> output.txt` at the end.
+- Remove the input file from the arguments and add ```cat [input_file] |``` at the beginning.
+- Remove `-o output.txt` and add `> output.txt` at the end.
 
 Example: `hyperfine "target/release/coreutils sort shuffled_numbers.txt -n -o output.txt"` becomes
 `hyperfine "cat shuffled_numbers.txt | target/release/coreutils sort -n > output.txt`
 
--   Check that performance is similar to the original benchmark.
+- Check that performance is similar to the original benchmark.
 
 ## Comparing with GNU sort
 
@@ -121,37 +116,34 @@ The above benchmarks use hyperfine to measure the speed of sorting. There are ho
 resource usage. One way to measure them is the `time` command. This is not to be confused with the `time` that is built in to the bash shell.
 You may have to install `time` first, then you have to run it with `/bin/time -v` to give it precedence over the built in `time`.
 
-<details>
-      <summary>Example output</summary>
-
-      Command being timed: "target/release/coreutils sort shuffled_numbers.txt"
-      User time (seconds): 0.10
-      System time (seconds): 0.00
-      Percent of CPU this job got: 365%
-      Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.02
-      Average shared text size (kbytes): 0
-      Average unshared data size (kbytes): 0
-      Average stack size (kbytes): 0
-      Average total size (kbytes): 0
-      Maximum resident set size (kbytes): 25360
-      Average resident set size (kbytes): 0
-      Major (requiring I/O) page faults: 0
-      Minor (reclaiming a frame) page faults: 5802
-      Voluntary context switches: 462
-      Involuntary context switches: 73
-      Swaps: 0
-      File system inputs: 1184
-      File system outputs: 0
-      Socket messages sent: 0
-      Socket messages received: 0
-      Signals delivered: 0
-      Page size (bytes): 4096
-      Exit status: 0
-
-</details>
+```plain
+Command being timed: "target/release/coreutils sort shuffled_numbers.txt"
+User time (seconds): 0.10
+System time (seconds): 0.00
+Percent of CPU this job got: 365%
+Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.02
+Average shared text size (kbytes): 0
+Average unshared data size (kbytes): 0
+Average stack size (kbytes): 0
+Average total size (kbytes): 0
+Maximum resident set size (kbytes): 25360
+Average resident set size (kbytes): 0
+Major (requiring I/O) page faults: 0
+Minor (reclaiming a frame) page faults: 5802
+Voluntary context switches: 462
+Involuntary context switches: 73
+Swaps: 0
+File system inputs: 1184
+File system outputs: 0
+Socket messages sent: 0
+Socket messages received: 0
+Signals delivered: 0
+Page size (bytes): 4096
+Exit status: 0
+```
 
 Useful metrics to look at could be:
 
--   User time
--   Percent of CPU this job got
--   Maximum resident set size
+- User time
+- Percent of CPU this job got
+- Maximum resident set size
diff --git a/src/uu/sort/Cargo.toml b/src/uu/sort/Cargo.toml
index e940d08e5..7540522ed 100644
--- a/src/uu/sort/Cargo.toml
+++ b/src/uu/sort/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_sort"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "sort ~ (uutils) sort input lines"
@@ -15,19 +15,19 @@ edition = "2021"
 path = "src/sort.rs"
 
 [dependencies]
-binary-heap-plus = { workspace=true }
-clap = { workspace=true }
-compare = { workspace=true }
-ctrlc = { workspace=true }
-fnv = { workspace=true }
-itertools = { workspace=true }
-memchr = { workspace=true }
-ouroboros = { workspace=true }
-rand = { workspace=true }
-rayon = { workspace=true }
-tempfile = { workspace=true }
-unicode-width = { workspace=true }
-uucore = { workspace=true, features=["fs"] }
+binary-heap-plus = { workspace = true }
+clap = { workspace = true }
+compare = { workspace = true }
+ctrlc = { workspace = true }
+fnv = { workspace = true }
+itertools = { workspace = true }
+memchr = { workspace = true }
+ouroboros = { workspace = true }
+rand = { workspace = true }
+rayon = { workspace = true }
+tempfile = { workspace = true }
+unicode-width = { workspace = true }
+uucore = { workspace = true, features = ["fs"] }
 
 [[bin]]
 name = "sort"
diff --git a/src/uu/sort/sort.md b/src/uu/sort/sort.md
new file mode 100644
index 000000000..1d1aa5d5f
--- /dev/null
+++ b/src/uu/sort/sort.md
@@ -0,0 +1,21 @@
+<!-- spell-checker:ignore MbdfhnRrV -->
+
+# sort
+
+```
+sort [OPTION]... [FILE]...
+```
+
+Display sorted concatenation of all FILE(s). With no FILE, or when FILE is -, read standard input.
+
+## After help
+
+The key format is `FIELD[.CHAR][OPTIONS][,FIELD[.CHAR]][OPTIONS]`.
+
+Fields by default are separated by the first whitespace after a non-whitespace character. Use `-t` to specify a custom separator.
+In the default case, whitespace is appended at the beginning of each field. Custom separators however are not included in fields.
+
+`FIELD` and `CHAR` both start at 1 (i.e. they are 1-indexed). If there is no end specified after a comma, the end will be the end of the line.
+If `CHAR` is set 0, it means the end of the field. `CHAR` defaults to 1 for the start position and to 0 for the end position.
+
+Valid options are: `MbdfhnRrV`. They override the global options for this key.
diff --git a/src/uu/sort/src/merge.rs b/src/uu/sort/src/merge.rs
index a7b4417e3..f6da0ee32 100644
--- a/src/uu/sort/src/merge.rs
+++ b/src/uu/sort/src/merge.rs
@@ -362,16 +362,16 @@ impl<'a> Compare<MergeableFile> for FileComparator<'a> {
 
 // Wait for the child to exit and check its exit code.
 fn check_child_success(mut child: Child, program: &str) -> UResult<()> {
-    if !matches!(
+    if matches!(
         child.wait().map(|e| e.code()),
         Ok(Some(0)) | Ok(None) | Err(_)
     ) {
+        Ok(())
+    } else {
         Err(SortError::CompressProgTerminatedAbnormally {
             prog: program.to_owned(),
         }
         .into())
-    } else {
-        Ok(())
     }
 }
 
diff --git a/src/uu/sort/src/numeric_str_cmp.rs b/src/uu/sort/src/numeric_str_cmp.rs
index 70f8c2cd8..05f81c897 100644
--- a/src/uu/sort/src/numeric_str_cmp.rs
+++ b/src/uu/sort/src/numeric_str_cmp.rs
@@ -52,6 +52,7 @@ impl NumInfo {
     /// an empty range (idx..idx) is returned so that idx is the char after the last zero.
     /// If the input is not a number (which has to be treated as zero), the returned empty range
     /// will be 0..0.
+    #[allow(clippy::cognitive_complexity)]
     pub fn parse(num: &str, parse_settings: &NumInfoParseSettings) -> (Self, Range<usize>) {
         let mut exponent = -1;
         let mut had_decimal_pt = false;
@@ -198,15 +199,13 @@ pub fn human_numeric_str_cmp(
     let a_unit = get_unit(a.chars().next_back());
     let b_unit = get_unit(b.chars().next_back());
     let ordering = a_unit.cmp(&b_unit);
-    if ordering != Ordering::Equal {
-        if a_info.sign == Sign::Negative {
-            ordering.reverse()
-        } else {
-            ordering
-        }
-    } else {
+    if ordering == Ordering::Equal {
         // 3. Number
         numeric_str_cmp((a, a_info), (b, b_info))
+    } else if a_info.sign == Sign::Negative {
+        ordering.reverse()
+    } else {
+        ordering
     }
 }
 
diff --git a/src/uu/sort/src/sort.rs b/src/uu/sort/src/sort.rs
index a681026f6..80c2275e9 100644
--- a/src/uu/sort/src/sort.rs
+++ b/src/uu/sort/src/sort.rs
@@ -45,26 +45,15 @@ use std::str::Utf8Error;
 use unicode_width::UnicodeWidthStr;
 use uucore::display::Quotable;
 use uucore::error::{set_exit_code, strip_errno, UError, UResult, USimpleError, UUsageError};
-use uucore::format_usage;
 use uucore::parse_size::{ParseSizeError, Parser};
 use uucore::version_cmp::version_cmp;
+use uucore::{format_usage, help_about, help_section, help_usage};
 
 use crate::tmp_dir::TmpDirWrapper;
 
-const ABOUT: &str = "\
-    Display sorted concatenation of all FILE(s). \
-    With no FILE, or when FILE is -, read standard input.";
-const USAGE: &str = "{} [OPTION]... [FILE]...";
-
-const LONG_HELP_KEYS: &str = "The key format is FIELD[.CHAR][OPTIONS][,FIELD[.CHAR]][OPTIONS].
-
-Fields by default are separated by the first whitespace after a non-whitespace character. Use -t to specify a custom separator.
-In the default case, whitespace is appended at the beginning of each field. Custom separators however are not included in fields.
-
-FIELD and CHAR both start at 1 (i.e. they are 1-indexed). If there is no end specified after a comma, the end will be the end of the line.
-If CHAR is set 0, it means the end of the field. CHAR defaults to 1 for the start position and to 0 for the end position.
-
-Valid options are: MbdfhnRrV. They override the global options for this key.";
+const ABOUT: &str = help_about!("sort.md");
+const USAGE: &str = help_usage!("sort.md");
+const AFTER_HELP: &str = help_section!("after help", "sort.md");
 
 mod options {
     pub mod modes {
@@ -185,7 +174,9 @@ impl Display for SortError {
                 line,
                 silent,
             } => {
-                if !silent {
+                if *silent {
+                    Ok(())
+                } else {
                     write!(
                         f,
                         "{}:{}: disorder: {}",
@@ -193,8 +184,6 @@ impl Display for SortError {
                         line_number,
                         line
                     )
-                } else {
-                    Ok(())
                 }
             }
             Self::OpenFailed { path, error } => {
@@ -582,7 +571,15 @@ impl<'a> Line<'a> {
                     selection.start += num_range.start;
                     selection.end = selection.start + num_range.len();
 
-                    if num_range != (0..0) {
+                    if num_range == (0..0) {
+                        // This was not a valid number.
+                        // Report no match at the first non-whitespace character.
+                        let leading_whitespace = self.line[selection.clone()]
+                            .find(|c: char| !c.is_whitespace())
+                            .unwrap_or(0);
+                        selection.start += leading_whitespace;
+                        selection.end += leading_whitespace;
+                    } else {
                         // include a trailing si unit
                         if selector.settings.mode == SortMode::HumanNumeric
                             && self.line[selection.end..initial_selection.end]
@@ -597,14 +594,6 @@ impl<'a> Line<'a> {
                         {
                             selection.start -= 1;
                         }
-                    } else {
-                        // This was not a valid number.
-                        // Report no match at the first non-whitespace character.
-                        let leading_whitespace = self.line[selection.clone()]
-                            .find(|c: char| !c.is_whitespace())
-                            .unwrap_or(0);
-                        selection.start += leading_whitespace;
-                        selection.end += leading_whitespace;
                     }
                 }
                 SortMode::GeneralNumeric => {
@@ -1044,6 +1033,7 @@ fn make_sort_mode_arg(mode: &'static str, short: char, help: &'static str) -> Ar
 }
 
 #[uucore::main]
+#[allow(clippy::cognitive_complexity)]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args.collect_ignore();
     let mut settings = GlobalSettings::default();
@@ -1292,7 +1282,7 @@ pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
-        .after_help(LONG_HELP_KEYS)
+        .after_help(AFTER_HELP)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
         .disable_help_flag(true)
@@ -1572,10 +1562,7 @@ fn compare_by<'a>(
     let mut num_info_index = 0;
     let mut parsed_float_index = 0;
     for selector in &global_settings.selectors {
-        let (a_str, b_str) = if !selector.needs_selection {
-            // We can select the whole line.
-            (a.line, b.line)
-        } else {
+        let (a_str, b_str) = if selector.needs_selection {
             let selections = (
                 a_line_data.selections
                     [a.index * global_settings.precomputed.selections_per_line + selection_index],
@@ -1584,6 +1571,9 @@ fn compare_by<'a>(
             );
             selection_index += 1;
             selections
+        } else {
+            // We can select the whole line.
+            (a.line, b.line)
         };
 
         let settings = &selector.settings;
@@ -1665,6 +1655,7 @@ fn compare_by<'a>(
 // In contrast to numeric compare, GNU general numeric/FP sort *should* recognize positive signs and
 // scientific notation, so we strip those lines only after the end of the following numeric string.
 // For example, 5e10KFD would be 5e10 or 5x10^10 and +10000HFKJFK would become 10000.
+#[allow(clippy::cognitive_complexity)]
 fn get_leading_gen(input: &str) -> Range<usize> {
     let trimmed = input.trim_start();
     let leading_whitespace_len = input.len() - trimmed.len();
diff --git a/src/uu/split/BENCHMARKING.md b/src/uu/split/BENCHMARKING.md
index 9c8d5d17c..1495891ba 100644
--- a/src/uu/split/BENCHMARKING.md
+++ b/src/uu/split/BENCHMARKING.md
@@ -7,11 +7,15 @@ GNU version of `split`, you can use a benchmarking tool like
 [hyperfine][0]. On Ubuntu 18.04 or later, you can install `hyperfine` by
 running
 
-    sudo apt-get install hyperfine
+```
+sudo apt-get install hyperfine
+```
 
 Next, build the `split` binary under the release profile:
 
-    cargo build --release -p uu_split
+```
+cargo build --release -p uu_split
+```
 
 Now, get a text file to test `split` on. The `split` program has three
 main modes of operation: chunk by lines, chunk by bytes, and chunk by
@@ -21,7 +25,9 @@ operation. For example, to test chunking by bytes on a large input file,
 you can create a file named `testfile.txt` containing one million null
 bytes like this:
 
-    printf "%0.s\0" {1..1000000} > testfile.txt
+```
+printf "%0.s\0" {1..1000000} > testfile.txt
+```
 
 For another example, to test chunking by bytes on a large real-world
 input file, you could download a [database dump of Wikidata][1] or some
@@ -31,10 +37,12 @@ file][2] contains about 130 million lines.
 Finally, you can compare the performance of the two versions of `split`
 by running, for example,
 
-    cd /tmp && hyperfine \
-        --prepare 'rm x* || true' \
-	"split -b 1000 testfile.txt" \
-	"target/release/split -b 1000 testfile.txt"
+```
+cd /tmp && hyperfine \
+   --prepare 'rm x* || true' \
+   "split -b 1000 testfile.txt" \
+   "target/release/split -b 1000 testfile.txt"
+```
 
 Since `split` creates a lot of files on the filesystem, I recommend
 changing to the `/tmp` directory before running the benchmark. The
diff --git a/src/uu/split/Cargo.toml b/src/uu/split/Cargo.toml
index 2d379a373..32cfd6fda 100644
--- a/src/uu/split/Cargo.toml
+++ b/src/uu/split/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_split"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "split ~ (uutils) split input into output files"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/split.rs"
 
 [dependencies]
-clap = { workspace=true }
-memchr = { workspace=true }
-uucore = { workspace=true, features=["fs"] }
+clap = { workspace = true }
+memchr = { workspace = true }
+uucore = { workspace = true, features = ["fs"] }
 
 [[bin]]
 name = "split"
diff --git a/src/uu/split/README.md b/src/uu/split/README.md
index 112a4416f..902c4a597 100644
--- a/src/uu/split/README.md
+++ b/src/uu/split/README.md
@@ -4,7 +4,8 @@
 
 ### Flags
 
-* [ ] `--verbose` - created file printing is implemented, don't know if there is anything else
+* [ ] `--verbose` - created file printing is implemented, don't know
+  if there is anything else
 
 ## Possible Optimizations
 
diff --git a/src/uu/split/split.md b/src/uu/split/split.md
new file mode 100644
index 000000000..d3a481fd3
--- /dev/null
+++ b/src/uu/split/split.md
@@ -0,0 +1,13 @@
+<!-- spell-checker:ignore PREFI -->
+
+# split
+
+```
+split [OPTION]... [INPUT [PREFIX]]
+```
+
+Create output files containing consecutive or interleaved sections of input
+
+## After Help
+
+Output fixed-size pieces of INPUT to PREFIXaa, PREFIXab, ...; default size is 1000, and default PREFIX is 'x'. With no INPUT, or when INPUT is -, read standard input.
diff --git a/src/uu/split/src/number.rs b/src/uu/split/src/number.rs
index 778e24f7c..567526538 100644
--- a/src/uu/split/src/number.rs
+++ b/src/uu/split/src/number.rs
@@ -200,10 +200,10 @@ impl FixedWidthNumber {
                 break;
             }
         }
-        if suffix_start != 0 {
-            Err(Overflow)
-        } else {
+        if suffix_start == 0 {
             Ok(Self { radix, digits })
+        } else {
+            Err(Overflow)
         }
     }
 
diff --git a/src/uu/split/src/split.rs b/src/uu/split/src/split.rs
index d737c8513..6e29e6f4b 100644
--- a/src/uu/split/src/split.rs
+++ b/src/uu/split/src/split.rs
@@ -5,7 +5,7 @@
 //  * For the full copyright and license information, please view the LICENSE
 //  * file that was distributed with this source code.
 
-// spell-checker:ignore (ToDO) PREFIXaa PREFIXab nbbbb ncccc
+// spell-checker:ignore nbbbb ncccc
 
 mod filenames;
 mod number;
@@ -23,9 +23,9 @@ use std::io::{stdin, BufRead, BufReader, BufWriter, ErrorKind, Read, Write};
 use std::path::Path;
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UIoError, UResult, USimpleError, UUsageError};
-use uucore::format_usage;
 use uucore::parse_size::{parse_size, ParseSizeError};
 use uucore::uio_error;
+use uucore::{format_usage, help_about, help_section, help_usage};
 
 static OPT_BYTES: &str = "bytes";
 static OPT_LINE_BYTES: &str = "line-bytes";
@@ -47,11 +47,9 @@ static OPT_ELIDE_EMPTY_FILES: &str = "elide-empty-files";
 static ARG_INPUT: &str = "input";
 static ARG_PREFIX: &str = "prefix";
 
-const USAGE: &str = "{} [OPTION]... [INPUT [PREFIX]]";
-const AFTER_HELP: &str = "\
-    Output fixed-size pieces of INPUT to PREFIXaa, PREFIXab, ...; default \
-    size is 1000, and default PREFIX is 'x'. With no INPUT, or when INPUT is \
-    -, read standard input.";
+const ABOUT: &str = help_about!("split.md");
+const USAGE: &str = help_usage!("split.md");
+const AFTER_HELP: &str = help_section!("after help", "split.md");
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
@@ -66,7 +64,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
         .version(crate_version!())
-        .about("Create output files containing consecutive or interleaved sections of input")
+        .about(ABOUT)
         .after_help(AFTER_HELP)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
diff --git a/src/uu/stat/Cargo.toml b/src/uu/stat/Cargo.toml
index 1c84eaf1e..3f165c357 100644
--- a/src/uu/stat/Cargo.toml
+++ b/src/uu/stat/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_stat"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "stat ~ (uutils) display FILE status"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/stat.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true, features=["entries", "libc", "fs", "fsext"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["entries", "libc", "fs", "fsext"] }
 
 [[bin]]
 name = "stat"
diff --git a/src/uu/stat/src/stat.rs b/src/uu/stat/src/stat.rs
index fbbed8c21..69f3c2760 100644
--- a/src/uu/stat/src/stat.rs
+++ b/src/uu/stat/src/stat.rs
@@ -205,7 +205,16 @@ struct Stater {
     default_dev_tokens: Vec<Token>,
 }
 
-#[allow(clippy::cognitive_complexity)]
+/// Prints a formatted output based on the provided output type, flags, width, and precision.
+///
+/// # Arguments
+///
+/// * `output` - A reference to the OutputType enum containing the value to be printed.
+/// * `flags` - A Flags struct containing formatting flags.
+/// * `width` - The width of the field for the printed output.
+/// * `precision` - An Option containing the precision value.
+///
+/// This function delegates the printing process to more specialized functions depending on the output type.
 fn print_it(output: &OutputType, flags: Flags, width: usize, precision: Option<usize>) {
     // If the precision is given as just '.', the precision is taken to be zero.
     // A negative precision is taken as if the precision were omitted.
@@ -236,71 +245,166 @@ fn print_it(output: &OutputType, flags: Flags, width: usize, precision: Option<u
     // A sign (+ or -) should always be placed before a number produced by a signed conversion.
     // By default, a sign  is  used only for negative numbers.
     // A + overrides a space if both are used.
-
-    let padding_char = if flags.zero && !flags.left && precision.is_none() {
-        Padding::Zero
-    } else {
-        Padding::Space
-    };
+    let padding_char = determine_padding_char(&flags, &precision);
 
     match output {
-        OutputType::Str(s) => {
-            let s = match precision {
-                Some(p) if p < s.len() => &s[..p],
-                _ => s,
-            };
-            pad_and_print(s, flags.left, width, Padding::Space);
-        }
-        OutputType::Integer(num) => {
-            let num = num.to_string();
-            let arg = if flags.group {
-                group_num(&num)
-            } else {
-                Cow::Borrowed(num.as_str())
-            };
-            let prefix = if flags.sign {
-                "+"
-            } else if flags.space {
-                " "
-            } else {
-                ""
-            };
-            let extended = format!(
-                "{prefix}{arg:0>precision$}",
-                precision = precision.unwrap_or(0)
-            );
-            pad_and_print(&extended, flags.left, width, padding_char);
-        }
-        OutputType::Unsigned(num) => {
-            let num = num.to_string();
-            let s = if flags.group {
-                group_num(&num)
-            } else {
-                Cow::Borrowed(num.as_str())
-            };
-            let s = format!("{s:0>precision$}", precision = precision.unwrap_or(0));
-            pad_and_print(&s, flags.left, width, padding_char);
-        }
+        OutputType::Str(s) => print_str(s, &flags, width, precision),
+        OutputType::Integer(num) => print_integer(*num, &flags, width, precision, padding_char),
+        OutputType::Unsigned(num) => print_unsigned(*num, &flags, width, precision, padding_char),
         OutputType::UnsignedOct(num) => {
-            let prefix = if flags.alter { "0" } else { "" };
-            let s = format!(
-                "{prefix}{num:0>precision$o}",
-                precision = precision.unwrap_or(0)
-            );
-            pad_and_print(&s, flags.left, width, padding_char);
+            print_unsigned_oct(*num, &flags, width, precision, padding_char);
         }
         OutputType::UnsignedHex(num) => {
-            let prefix = if flags.alter { "0x" } else { "" };
-            let s = format!(
-                "{prefix}{num:0>precision$x}",
-                precision = precision.unwrap_or(0)
-            );
-            pad_and_print(&s, flags.left, width, padding_char);
+            print_unsigned_hex(*num, &flags, width, precision, padding_char);
         }
         OutputType::Unknown => print!("?"),
     }
 }
 
+/// Determines the padding character based on the provided flags and precision.
+///
+/// # Arguments
+///
+/// * `flags` - A reference to the Flags struct containing formatting flags.
+/// * `precision` - An Option containing the precision value.
+///
+/// # Returns
+///
+/// * Padding - An instance of the Padding enum representing the padding character.
+fn determine_padding_char(flags: &Flags, precision: &Option<usize>) -> Padding {
+    if flags.zero && !flags.left && precision.is_none() {
+        Padding::Zero
+    } else {
+        Padding::Space
+    }
+}
+
+/// Prints a string value based on the provided flags, width, and precision.
+///
+/// # Arguments
+///
+/// * `s` - The string to be printed.
+/// * `flags` - A reference to the Flags struct containing formatting flags.
+/// * `width` - The width of the field for the printed string.
+/// * `precision` - An Option containing the precision value.
+fn print_str(s: &str, flags: &Flags, width: usize, precision: Option<usize>) {
+    let s = match precision {
+        Some(p) if p < s.len() => &s[..p],
+        _ => s,
+    };
+    pad_and_print(s, flags.left, width, Padding::Space);
+}
+
+/// Prints an integer value based on the provided flags, width, and precision.
+///
+/// # Arguments
+///
+/// * `num` - The integer value to be printed.
+/// * `flags` - A reference to the Flags struct containing formatting flags.
+/// * `width` - The width of the field for the printed integer.
+/// * `precision` - An Option containing the precision value.
+/// * `padding_char` - The padding character as determined by `determine_padding_char`.
+fn print_integer(
+    num: i64,
+    flags: &Flags,
+    width: usize,
+    precision: Option<usize>,
+    padding_char: Padding,
+) {
+    let num = num.to_string();
+    let arg = if flags.group {
+        group_num(&num)
+    } else {
+        Cow::Borrowed(num.as_str())
+    };
+    let prefix = if flags.sign {
+        "+"
+    } else if flags.space {
+        " "
+    } else {
+        ""
+    };
+    let extended = format!(
+        "{prefix}{arg:0>precision$}",
+        precision = precision.unwrap_or(0)
+    );
+    pad_and_print(&extended, flags.left, width, padding_char);
+}
+
+/// Prints an unsigned integer value based on the provided flags, width, and precision.
+///
+/// # Arguments
+///
+/// * `num` - The unsigned integer value to be printed.
+/// * `flags` - A reference to the Flags struct containing formatting flags.
+/// * `width` - The width of the field for the printed unsigned integer.
+/// * `precision` - An Option containing the precision value.
+/// * `padding_char` - The padding character as determined by `determine_padding_char`.
+fn print_unsigned(
+    num: u64,
+    flags: &Flags,
+    width: usize,
+    precision: Option<usize>,
+    padding_char: Padding,
+) {
+    let num = num.to_string();
+    let s = if flags.group {
+        group_num(&num)
+    } else {
+        Cow::Borrowed(num.as_str())
+    };
+    let s = format!("{s:0>precision$}", precision = precision.unwrap_or(0));
+    pad_and_print(&s, flags.left, width, padding_char);
+}
+
+/// Prints an unsigned octal integer value based on the provided flags, width, and precision.
+///
+/// # Arguments
+///
+/// * `num` - The unsigned octal integer value to be printed.
+/// * `flags` - A reference to the Flags struct containing formatting flags.
+/// * `width` - The width of the field for the printed unsigned octal integer.
+/// * `precision` - An Option containing the precision value.
+/// * `padding_char` - The padding character as determined by `determine_padding_char`.
+fn print_unsigned_oct(
+    num: u32,
+    flags: &Flags,
+    width: usize,
+    precision: Option<usize>,
+    padding_char: Padding,
+) {
+    let prefix = if flags.alter { "0" } else { "" };
+    let s = format!(
+        "{prefix}{num:0>precision$o}",
+        precision = precision.unwrap_or(0)
+    );
+    pad_and_print(&s, flags.left, width, padding_char);
+}
+
+/// Prints an unsigned hexadecimal integer value based on the provided flags, width, and precision.
+///
+/// # Arguments
+///
+/// * `num` - The unsigned hexadecimal integer value to be printed.
+/// * `flags` - A reference to the Flags struct containing formatting flags.
+/// * `width` - The width of the field for the printed unsigned hexadecimal integer.
+/// * `precision` - An Option containing the precision value.
+/// * `padding_char` - The padding character as determined by `determine_padding_char`.
+fn print_unsigned_hex(
+    num: u64,
+    flags: &Flags,
+    width: usize,
+    precision: Option<usize>,
+    padding_char: Padding,
+) {
+    let prefix = if flags.alter { "0x" } else { "" };
+    let s = format!(
+        "{prefix}{num:0>precision$x}",
+        precision = precision.unwrap_or(0)
+    );
+    pad_and_print(&s, flags.left, width, padding_char);
+}
+
 impl Stater {
     fn generate_tokens(format_str: &str, use_printf: bool) -> UResult<Vec<Token>> {
         let mut tokens = Vec::new();
@@ -375,9 +479,7 @@ impl Stater {
                     });
                 }
                 '\\' => {
-                    if !use_printf {
-                        tokens.push(Token::Char('\\'));
-                    } else {
+                    if use_printf {
                         i += 1;
                         if i >= bound {
                             show_warning!("backslash at end of format");
@@ -414,6 +516,8 @@ impl Stater {
                                 tokens.push(Token::Char(c));
                             }
                         }
+                    } else {
+                        tokens.push(Token::Char('\\'));
                     }
                 }
 
@@ -519,7 +623,67 @@ impl Stater {
             OsString::from(file)
         };
 
-        if !self.show_fs {
+        if self.show_fs {
+            #[cfg(unix)]
+            let p = file.as_bytes();
+            #[cfg(not(unix))]
+            let p = file.into_string().unwrap();
+            match statfs(p) {
+                Ok(meta) => {
+                    let tokens = &self.default_tokens;
+
+                    for t in tokens.iter() {
+                        match *t {
+                            Token::Char(c) => print!("{c}"),
+                            Token::Directive {
+                                flag,
+                                width,
+                                precision,
+                                format,
+                            } => {
+                                let output = match format {
+                                    // free blocks available to non-superuser
+                                    'a' => OutputType::Unsigned(meta.avail_blocks()),
+                                    // total data blocks in file system
+                                    'b' => OutputType::Unsigned(meta.total_blocks()),
+                                    // total file nodes in file system
+                                    'c' => OutputType::Unsigned(meta.total_file_nodes()),
+                                    // free file nodes in file system
+                                    'd' => OutputType::Unsigned(meta.free_file_nodes()),
+                                    // free blocks in file system
+                                    'f' => OutputType::Unsigned(meta.free_blocks()),
+                                    // file system ID in hex
+                                    'i' => OutputType::UnsignedHex(meta.fsid()),
+                                    // maximum length of filenames
+                                    'l' => OutputType::Unsigned(meta.namelen()),
+                                    // file name
+                                    'n' => OutputType::Str(display_name.to_string()),
+                                    // block size (for faster transfers)
+                                    's' => OutputType::Unsigned(meta.io_size()),
+                                    // fundamental block size (for block counts)
+                                    'S' => OutputType::Integer(meta.block_size()),
+                                    // file system type in hex
+                                    't' => OutputType::UnsignedHex(meta.fs_type() as u64),
+                                    // file system type in human readable form
+                                    'T' => OutputType::Str(pretty_fstype(meta.fs_type()).into()),
+                                    _ => OutputType::Unknown,
+                                };
+
+                                print_it(&output, flag, width, precision);
+                            }
+                        }
+                    }
+                }
+                Err(e) => {
+                    show_error!(
+                        "cannot read file system information for {}: {}",
+                        display_name.quote(),
+                        e
+                    );
+                    return 1;
+                }
+            }
+        } else {
             let result = if self.follow || stdin_is_fifo && display_name == "-" {
                 fs::metadata(&file)
             } else {
@@ -660,66 +824,6 @@ impl Stater {
                     return 1;
                 }
             }
-        } else {
-            #[cfg(unix)]
-            let p = file.as_bytes();
-            #[cfg(not(unix))]
-            let p = file.into_string().unwrap();
-            match statfs(p) {
-                Ok(meta) => {
-                    let tokens = &self.default_tokens;
-
-                    for t in tokens.iter() {
-                        match *t {
-                            Token::Char(c) => print!("{c}"),
-                            Token::Directive {
-                                flag,
-                                width,
-                                precision,
-                                format,
-                            } => {
-                                let output = match format {
-                                    // free blocks available to non-superuser
-                                    'a' => OutputType::Unsigned(meta.avail_blocks()),
-                                    // total data blocks in file system
-                                    'b' => OutputType::Unsigned(meta.total_blocks()),
-                                    // total file nodes in file system
-                                    'c' => OutputType::Unsigned(meta.total_file_nodes()),
-                                    // free file nodes in file system
-                                    'd' => OutputType::Unsigned(meta.free_file_nodes()),
-                                    // free blocks in file system
-                                    'f' => OutputType::Unsigned(meta.free_blocks()),
-                                    // file system ID in hex
-                                    'i' => OutputType::UnsignedHex(meta.fsid()),
-                                    // maximum length of filenames
-                                    'l' => OutputType::Unsigned(meta.namelen()),
-                                    // file name
-                                    'n' => OutputType::Str(display_name.to_string()),
-                                    // block size (for faster transfers)
-                                    's' => OutputType::Unsigned(meta.io_size()),
-                                    // fundamental block size (for block counts)
-                                    'S' => OutputType::Integer(meta.block_size()),
-                                    // file system type in hex
-                                    't' => OutputType::UnsignedHex(meta.fs_type() as u64),
-                                    // file system type in human readable form
-                                    'T' => OutputType::Str(pretty_fstype(meta.fs_type()).into()),
-                                    _ => OutputType::Unknown,
-                                };
-
-                                print_it(&output, flag, width, precision);
-                            }
-                        }
-                    }
-                }
-                Err(e) => {
-                    show_error!(
-                        "cannot read file system information for {}: {}",
-                        display_name.quote(),
-                        e
-                    );
-                    return 1;
-                }
-            }
         }
         0
     }
diff --git a/src/uu/stat/stat.md b/src/uu/stat/stat.md
index 9228ba9dc..ac63edd18 100644
--- a/src/uu/stat/stat.md
+++ b/src/uu/stat/stat.md
@@ -8,53 +8,53 @@ Display file or file system status.
 
 ## Long Usage
 
-The valid format sequences for files (without `--file-system`):
+Valid format sequences for files (without `--file-system`):
 
-    %a   access rights in octal (note '#' and '0' printf flags)
-    %A   access rights in human readable form
-    %b   number of blocks allocated (see %B)
-    %B   the size in bytes of each block reported by %b
-    %C   SELinux security context string
-    %d   device number in decimal
-    %D   device number in hex
-    %f   raw mode in hex
-    %F   file type
-    %g   group ID of owner
-    %G   group name of owner
-    %h   number of hard links
-    %i   inode number
-    %m   mount point
-    %n   file name
-    %N   quoted file name with dereference if symbolic link
-    %o   optimal I/O transfer size hint
-    %s   total size, in bytes
-    %t   major device type in hex, for character/block device special files
-    %T   minor device type in hex, for character/block device special files
-    %u   user ID of owner
-    %U   user name of owner
-    %w   time of file birth, human-readable; - if unknown
-    %W   time of file birth, seconds since Epoch; 0 if unknown
-    %x   time of last access, human-readable
-    %X   time of last access, seconds since Epoch
-    %y   time of last data modification, human-readable
-    %Y   time of last data modification, seconds since Epoch
-    %z   time of last status change, human-readable
-    %Z   time of last status change, seconds since Epoch
+- `%a`: access rights in octal (note '#' and '0' printf flags)
+- `%A`: access rights in human readable form
+- `%b`: number of blocks allocated (see %B)
+- `%B`: the size in bytes of each block reported by %b
+- `%C`: SELinux security context string
+- `%d`: device number in decimal
+- `%D`: device number in hex
+- `%f`: raw mode in hex
+- `%F`: file type
+- `%g`: group ID of owner
+- `%G`: group name of owner
+- `%h`: number of hard links
+- `%i`: inode number
+- `%m`: mount point
+- `%n`: file name
+- `%N`: quoted file name with dereference (follow) if symbolic link
+- `%o`: optimal I/O transfer size hint
+- `%s`: total size, in bytes
+- `%t`: major device type in hex, for character/block device special files
+- `%T`: minor device type in hex, for character/block device special files
+- `%u`: user ID of owner
+- `%U`: user name of owner
+- `%w`: time of file birth, human-readable; - if unknown
+- `%W`: time of file birth, seconds since Epoch; 0 if unknown
+- `%x`: time of last access, human-readable
+- `%X`: time of last access, seconds since Epoch
+- `%y`: time of last data modification, human-readable
+- `%Y`: time of last data modification, seconds since Epoch
+- `%z`: time of last status change, human-readable
+- `%Z`: time of last status change, seconds since Epoch
 
 Valid format sequences for file systems:
 
-    %a   free blocks available to non-superuser
-    %b   total data blocks in file system
-    %c   total file nodes in file system
-    %d   free file nodes in file system
-    %f   free blocks in file system
-    %i   file system ID in hex
-    %l   maximum length of filenames
-    %n   file name
-    %s   block size (for faster transfers)
-    %S   fundamental block size (for block counts)
-    %t   file system type in hex
-    %T   file system type in human readable form
+- `%a`: free blocks available to non-superuser
+- `%b`: total data blocks in file system
+- `%c`: total file nodes in file system
+- `%d`: free file nodes in file system
+- `%f`: free blocks in file system
+- `%i`: file system ID in hex
+- `%l`: maximum length of filenames
+- `%n`: file name
+- `%s`: block size (for faster transfers)
+- `%S`: fundamental block size (for block counts)
+- `%t`: file system type in hex
+- `%T`: file system type in human readable form
 
 NOTE: your shell may have its own version of stat, which usually supersedes
 the version described here.  Please refer to your shell's documentation
diff --git a/src/uu/stdbuf/Cargo.toml b/src/uu/stdbuf/Cargo.toml
index 164188f9f..bce2f8dba 100644
--- a/src/uu/stdbuf/Cargo.toml
+++ b/src/uu/stdbuf/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_stdbuf"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "stdbuf ~ (uutils) run COMMAND with modified standard stream buffering"
@@ -15,12 +15,12 @@ edition = "2021"
 path = "src/stdbuf.rs"
 
 [dependencies]
-clap = { workspace=true }
-tempfile = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+tempfile = { workspace = true }
+uucore = { workspace = true }
 
 [build-dependencies]
-libstdbuf = { version="0.0.17", package="uu_stdbuf_libstdbuf", path="src/libstdbuf" }
+libstdbuf = { version = "0.0.19", package = "uu_stdbuf_libstdbuf", path = "src/libstdbuf" }
 
 [[bin]]
 name = "stdbuf"
diff --git a/src/uu/stdbuf/build.rs b/src/uu/stdbuf/build.rs
index 9d36f20f4..9ed9a6207 100644
--- a/src/uu/stdbuf/build.rs
+++ b/src/uu/stdbuf/build.rs
@@ -23,19 +23,34 @@ fn main() {
     let out_dir = env::var("OUT_DIR").unwrap();
     let mut target_dir = Path::new(&out_dir);
 
-    // Depending on how this is util is built, the directory structure. This seems to work for now.
-    // Here are three cases to test when changing this:
+    // Depending on how this is util is built, the directory structure changes.
+    // This seems to work for now. Here are three cases to test when changing
+    // this:
+    //
     // - cargo run
     // - cross run
     // - cargo install --git
     // - cargo publish --dry-run
+    //
+    // The goal is to find the directory in which we are installing, but that
+    // depends on the build method, which is annoying. Additionally the env
+    // var for the profile can only be "debug" or "release", not a custom
+    // profile name, so we have to use the name of the directory within target
+    // as the profile name.
+    //
+    // Adapted from https://stackoverflow.com/questions/73595435/how-to-get-profile-from-cargo-toml-in-build-rs-or-at-runtime
+    let profile_name = out_dir
+        .split(std::path::MAIN_SEPARATOR)
+        .nth_back(3)
+        .unwrap();
+
     let mut name = target_dir.file_name().unwrap().to_string_lossy();
     while name != "target" && !name.starts_with("cargo-install") {
         target_dir = target_dir.parent().unwrap();
         name = target_dir.file_name().unwrap().to_string_lossy();
     }
     let mut dir = target_dir.to_path_buf();
-    dir.push(env::var("PROFILE").unwrap());
+    dir.push(profile_name);
     dir.push("deps");
     let mut path = None;
 
diff --git a/src/uu/stdbuf/src/libstdbuf/Cargo.toml b/src/uu/stdbuf/src/libstdbuf/Cargo.toml
index 2498f7671..b3f186118 100644
--- a/src/uu/stdbuf/src/libstdbuf/Cargo.toml
+++ b/src/uu/stdbuf/src/libstdbuf/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_stdbuf_libstdbuf"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "stdbuf/libstdbuf ~ (uutils); dynamic library required for stdbuf"
@@ -14,12 +14,15 @@ edition = "2021"
 [lib]
 name = "libstdbuf"
 path = "src/libstdbuf.rs"
-crate-type = ["cdylib", "rlib"] # XXX: note: the rlib is just to prevent Cargo from spitting out a warning
+crate-type = [
+  "cdylib",
+  "rlib",
+] # XXX: note: the rlib is just to prevent Cargo from spitting out a warning
 
 [dependencies]
 cpp = "0.5"
-libc = { workspace=true }
-uucore = { version=">=0.0.17", package="uucore", path="../../../../uucore" }
+libc = { workspace = true }
+uucore = { version = ">=0.0.19", package = "uucore", path = "../../../../uucore" }
 
 [build-dependencies]
 cpp_build = "0.5"
diff --git a/src/uu/stdbuf/src/stdbuf.rs b/src/uu/stdbuf/src/stdbuf.rs
index 2bfb6f908..e02dd28bc 100644
--- a/src/uu/stdbuf/src/stdbuf.rs
+++ b/src/uu/stdbuf/src/stdbuf.rs
@@ -17,23 +17,11 @@ use tempfile::tempdir;
 use tempfile::TempDir;
 use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
 use uucore::parse_size::parse_size;
-use uucore::{crash, format_usage};
+use uucore::{crash, format_usage, help_about, help_section, help_usage};
 
-static ABOUT: &str =
-    "Run COMMAND, with modified buffering operations for its standard streams.\n\n\
-     Mandatory arguments to long options are mandatory for short options too.";
-const USAGE: &str = "{} OPTION... COMMAND";
-static LONG_HELP: &str = "If MODE is 'L' the corresponding stream will be line buffered.\n\
-     This option is invalid with standard input.\n\n\
-     If MODE is '0' the corresponding stream will be unbuffered.\n\n\
-     Otherwise MODE is a number which may be followed by one of the following:\n\n\
-     KB 1000, K 1024, MB 1000*1000, M 1024*1024, and so on for G, T, P, E, Z, Y.\n\
-     In this case the corresponding stream will be fully buffered with the buffer size set to \
-     MODE bytes.\n\n\
-     NOTE: If COMMAND adjusts the buffering of its standard streams ('tee' does for e.g.) then \
-     that will override corresponding settings changed by 'stdbuf'.\n\
-     Also some filters (like 'dd' and 'cat' etc.) don't use streams for I/O, \
-     and are thus unaffected by 'stdbuf' settings.\n";
+const ABOUT: &str = help_about!("stdbuf.md");
+const USAGE: &str = help_usage!("stdbuf.md");
+const LONG_HELP: &str = help_section!("after help", "stdbuf.md");
 
 mod options {
     pub const INPUT: &str = "input";
diff --git a/src/uu/stdbuf/stdbuf.md b/src/uu/stdbuf/stdbuf.md
new file mode 100644
index 000000000..e0062e627
--- /dev/null
+++ b/src/uu/stdbuf/stdbuf.md
@@ -0,0 +1,24 @@
+# stdbuf
+
+```
+stdbuf [OPTION]... COMMAND
+```
+
+Run `COMMAND`, with modified buffering operations for its standard streams.
+
+Mandatory arguments to long options are mandatory for short options too.
+
+## After Help
+
+If `MODE` is 'L' the corresponding stream will be line buffered.
+This option is invalid with standard input.
+
+If `MODE` is '0' the corresponding stream will be unbuffered.
+
+Otherwise, `MODE` is a number which may be followed by one of the following:
+
+KB 1000, K 1024, MB 1000*1000, M 1024*1024, and so on for G, T, P, E, Z, Y.
+In this case the corresponding stream will be fully buffered with the buffer size set to `MODE` bytes.
+
+NOTE: If `COMMAND` adjusts the buffering of its standard streams (`tee` does for e.g.) then that will override corresponding settings changed by `stdbuf`.
+Also some filters (like `dd` and `cat` etc.) don't use streams for I/O, and are thus unaffected by `stdbuf` settings.
diff --git a/src/uu/stty/Cargo.toml b/src/uu/stty/Cargo.toml
index 9c94f8cb1..220651003 100644
--- a/src/uu/stty/Cargo.toml
+++ b/src/uu/stty/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_stty"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "stty ~ (uutils) print or change terminal characteristics"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/stty.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true }
-nix = { workspace=true, features = ["term", "ioctl"] }
+clap = { workspace = true }
+uucore = { workspace = true }
+nix = { workspace = true, features = ["term", "ioctl"] }
 
 [[bin]]
 name = "stty"
diff --git a/src/uu/stty/src/stty.rs b/src/uu/stty/src/stty.rs
index 928c3f177..e09662471 100644
--- a/src/uu/stty/src/stty.rs
+++ b/src/uu/stty/src/stty.rs
@@ -18,7 +18,7 @@ use std::ops::ControlFlow;
 use std::os::unix::fs::OpenOptionsExt;
 use std::os::unix::io::{AsRawFd, IntoRawFd, RawFd};
 use uucore::error::{UResult, USimpleError};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
 
 #[cfg(not(any(
     target_os = "freebsd",
@@ -31,11 +31,8 @@ use uucore::format_usage;
 use flags::BAUD_RATES;
 use flags::{CONTROL_FLAGS, INPUT_FLAGS, LOCAL_FLAGS, OUTPUT_FLAGS};
 
-const USAGE: &str = "\
-    {} [-F DEVICE | --file=DEVICE] [SETTING]...
-    {} [-F DEVICE | --file=DEVICE] [-a|--all]
-    {} [-F DEVICE | --file=DEVICE] [-g|--save]";
-const SUMMARY: &str = "Print or change terminal characteristics.";
+const USAGE: &str = help_usage!("stty.md");
+const SUMMARY: &str = help_about!("stty.md");
 
 #[derive(Clone, Copy, Debug)]
 pub struct Flag<T> {
diff --git a/src/uu/stty/stty.md b/src/uu/stty/stty.md
new file mode 100644
index 000000000..6aa1decf5
--- /dev/null
+++ b/src/uu/stty/stty.md
@@ -0,0 +1,9 @@
+# stty
+
+```
+stty [-F DEVICE | --file=DEVICE] [SETTING]...
+stty [-F DEVICE | --file=DEVICE] [-a|--all]
+stty [-F DEVICE | --file=DEVICE] [-g|--save]
+```
+
+Print or change terminal characteristics.
diff --git a/src/uu/sum/BENCHMARKING.md b/src/uu/sum/BENCHMARKING.md
index d93e4220f..30cda7471 100644
--- a/src/uu/sum/BENCHMARKING.md
+++ b/src/uu/sum/BENCHMARKING.md
@@ -1,4 +1,4 @@
-## Benchmarking `sum`
+# Benchmarking `sum`
 
 <!-- spell-checker:ignore wikidatawiki -->
 
@@ -7,17 +7,17 @@ Large sample files can for example be found in the [Wikipedia database dumps](ht
 After you have obtained and uncompressed such a file, you need to build `sum` in release mode
 
 ```shell
-$ cargo build --release --package uu_sum
+cargo build --release --package uu_sum
 ```
 
 and then you can time how it long it takes to checksum the file by running
 
 ```shell
-$ time ./target/release/sum wikidatawiki-20211001-pages-logging.xml
+time ./target/release/sum wikidatawiki-20211001-pages-logging.xml
 ```
 
 For more systematic measurements that include warm-ups, repetitions and comparisons, [Hyperfine](https://github.com/sharkdp/hyperfine) can be helpful. For example, to compare this implementation to the one provided by your distribution run
 
 ```shell
-$ hyperfine "./target/release/sum wikidatawiki-20211001-pages-logging.xml" "sum wikidatawiki-20211001-pages-logging.xml"
+hyperfine "./target/release/sum wikidatawiki-20211001-pages-logging.xml" "sum wikidatawiki-20211001-pages-logging.xml"
 ```
diff --git a/src/uu/sum/Cargo.toml b/src/uu/sum/Cargo.toml
index 0997f22fc..37b4d21e0 100644
--- a/src/uu/sum/Cargo.toml
+++ b/src/uu/sum/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_sum"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "sum ~ (uutils) display checksum and block counts for input"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/sum.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "sum"
diff --git a/src/uu/sum/src/sum.rs b/src/uu/sum/src/sum.rs
index 1134f2444..0ea415b13 100644
--- a/src/uu/sum/src/sum.rs
+++ b/src/uu/sum/src/sum.rs
@@ -13,11 +13,10 @@ use std::io::{stdin, Read};
 use std::path::Path;
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult, USimpleError};
-use uucore::{format_usage, show};
+use uucore::{format_usage, help_about, help_usage, show};
 
-static USAGE: &str = "{} [OPTION]... [FILE]...";
-static ABOUT: &str = "Checksum and count the blocks in a file.\n\n\
-                      With no FILE, or when FILE is -, read standard input.";
+const USAGE: &str = help_usage!("sum.md");
+const ABOUT: &str = help_about!("sum.md");
 
 // This can be replaced with usize::div_ceil once it is stabilized.
 // This implementation approach is optimized for when `b` is a constant,
diff --git a/src/uu/sum/sum.md b/src/uu/sum/sum.md
new file mode 100644
index 000000000..ca3adb81f
--- /dev/null
+++ b/src/uu/sum/sum.md
@@ -0,0 +1,9 @@
+# sum
+
+```
+sum [OPTION]... [FILE]..."
+```
+
+Checksum and count the blocks in a file.
+
+With no FILE, or when FILE is -, read standard input.
diff --git a/src/uu/sync/Cargo.toml b/src/uu/sync/Cargo.toml
index 19696d881..36d110046 100644
--- a/src/uu/sync/Cargo.toml
+++ b/src/uu/sync/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_sync"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "sync ~ (uutils) synchronize cache writes to storage"
@@ -15,15 +15,19 @@ edition = "2021"
 path = "src/sync.rs"
 
 [dependencies]
-clap = { workspace=true }
-libc = { workspace=true }
-uucore = { workspace=true, features=["wide"] }
+clap = { workspace = true }
+libc = { workspace = true }
+uucore = { workspace = true, features = ["wide"] }
 
 [target.'cfg(any(target_os = "linux", target_os = "android"))'.dependencies]
-nix = { workspace=true }
+nix = { workspace = true }
 
 [target.'cfg(target_os = "windows")'.dependencies]
-windows-sys = { workspace=true, features = ["Win32_Storage_FileSystem", "Win32_System_WindowsProgramming", "Win32_Foundation"] }
+windows-sys = { workspace = true, features = [
+  "Win32_Storage_FileSystem",
+  "Win32_System_WindowsProgramming",
+  "Win32_Foundation",
+] }
 
 [[bin]]
 name = "sync"
diff --git a/src/uu/sync/src/sync.rs b/src/uu/sync/src/sync.rs
index d4bc1604d..e12703bca 100644
--- a/src/uu/sync/src/sync.rs
+++ b/src/uu/sync/src/sync.rs
@@ -7,8 +7,6 @@
 
 /* Last synced with: sync (GNU coreutils) 8.13 */
 
-extern crate libc;
-
 use clap::{crate_version, Arg, ArgAction, Command};
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use nix::errno::Errno;
@@ -21,10 +19,11 @@ use uucore::display::Quotable;
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use uucore::error::FromIo;
 use uucore::error::{UResult, USimpleError};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
+
+const ABOUT: &str = help_about!("sync.md");
+const USAGE: &str = help_usage!("sync.md");
 
-static ABOUT: &str = "Synchronize cached writes to persistent storage";
-const USAGE: &str = "{} [OPTION]... FILE...";
 pub mod options {
     pub static FILE_SYSTEM: &str = "file-system";
     pub static DATA: &str = "data";
@@ -34,7 +33,6 @@ static ARG_FILES: &str = "files";
 
 #[cfg(unix)]
 mod platform {
-    use super::libc;
     #[cfg(any(target_os = "linux", target_os = "android"))]
     use std::fs::File;
     #[cfg(any(target_os = "linux", target_os = "android"))]
diff --git a/src/uu/sync/sync.md b/src/uu/sync/sync.md
new file mode 100644
index 000000000..2fdd36339
--- /dev/null
+++ b/src/uu/sync/sync.md
@@ -0,0 +1,7 @@
+# sync
+
+```
+sync [OPTION]... FILE...
+```
+
+Synchronize cached writes to persistent storage
diff --git a/src/uu/tac/BENCHMARKING.md b/src/uu/tac/BENCHMARKING.md
index 4e6d13ea2..c972d1453 100644
--- a/src/uu/tac/BENCHMARKING.md
+++ b/src/uu/tac/BENCHMARKING.md
@@ -1,25 +1,36 @@
-## Benchmarking `tac`
+# Benchmarking `tac`
 
 <!-- spell-checker:ignore wikidatawiki -->
 
-`tac` is often used to process log files in reverse chronological order, i.e. from newer towards older entries. In this case, the performance target to yield results as fast as possible, i.e. without reading in the whole file that is to be reversed line-by-line. Therefore, a sensible benchmark is to read a large log file containing N lines and measure how long it takes to produce the last K lines from that file.
+`tac` is often used to process log files in reverse chronological order, i.e.
+from newer towards older entries. In this case, the performance target to yield
+results as fast as possible, i.e. without reading in the whole file that is to
+be reversed line-by-line. Therefore, a sensible benchmark is to read a large log
+file containing N lines and measure how long it takes to produce the last K
+lines from that file.
 
-Large text files can for example be found in the [Wikipedia database dumps](https://dumps.wikimedia.org/wikidatawiki/latest/), usually sized at multiple gigabytes and comprising more than 100M lines.
+Large text files can for example be found in the
+[Wikipedia database dumps](https://dumps.wikimedia.org/wikidatawiki/latest/),
+usually sized at multiple gigabytes and comprising more than 100M lines.
 
-After you have obtained and uncompressed such a file, you need to build `tac` in release mode
+After you have obtained and uncompressed such a file, you need to build `tac`
+in release mode
 
 ```shell
-$ cargo build --release --package uu_tac
+cargo build --release --package uu_tac
 ```
 
-and then you can time how it long it takes to extract the last 10M lines by running
+and then you can time how it long it takes to extract the last 10M lines by
+running
 
 ```shell
-$ /usr/bin/time ./target/release/tac wikidatawiki-20211001-pages-logging.xml | head -n10000000 >/dev/null
+/usr/bin/time ./target/release/tac wikidatawiki-20211001-pages-logging.xml | head -n10000000 >/dev/null
 ```
 
-For more systematic measurements that include warm-ups, repetitions and comparisons, [Hyperfine](https://github.com/sharkdp/hyperfine) can be helpful. For example, to compare this implementation to the one provided by your distribution run
+For more systematic measurements that include warm-ups, repetitions and comparisons,
+[Hyperfine](https://github.com/sharkdp/hyperfine) can be helpful.
+For example, to compare this implementation to the one provided by your distribution run
 
 ```shell
-$ hyperfine "./target/release/tac wikidatawiki-20211001-pages-logging.xml | head -n10000000 >/dev/null" "/usr/bin/tac wikidatawiki-20211001-pages-logging.xml | head -n10000000 >/dev/null"
+hyperfine "./target/release/tac wikidatawiki-20211001-pages-logging.xml | head -n10000000 >/dev/null" "/usr/bin/tac wikidatawiki-20211001-pages-logging.xml | head -n10000000 >/dev/null"
 ```
diff --git a/src/uu/tac/Cargo.toml b/src/uu/tac/Cargo.toml
index 3df365bad..4455ebe13 100644
--- a/src/uu/tac/Cargo.toml
+++ b/src/uu/tac/Cargo.toml
@@ -2,7 +2,7 @@
 
 [package]
 name = "uu_tac"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "tac ~ (uutils) concatenate and display input lines in reverse order"
@@ -17,11 +17,11 @@ edition = "2021"
 path = "src/tac.rs"
 
 [dependencies]
-memchr = { workspace=true }
-memmap2 = "0.5"
-regex = { workspace=true }
-clap = { workspace=true }
-uucore = { workspace=true }
+memchr = { workspace = true }
+memmap2 = "0.7"
+regex = { workspace = true }
+clap = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "tac"
diff --git a/src/uu/tac/src/tac.rs b/src/uu/tac/src/tac.rs
index aef9932a2..96bb82f1e 100644
--- a/src/uu/tac/src/tac.rs
+++ b/src/uu/tac/src/tac.rs
@@ -222,6 +222,7 @@ fn buffer_tac(data: &[u8], before: bool, separator: &str) -> std::io::Result<()>
     Ok(())
 }
 
+#[allow(clippy::cognitive_complexity)]
 fn tac(filenames: &[&str], before: bool, regex: bool, separator: &str) -> UResult<()> {
     // Compile the regular expression pattern if it is provided.
     let maybe_pattern = if regex {
diff --git a/src/uu/tail/Cargo.toml b/src/uu/tail/Cargo.toml
index 88b82a8e6..81213b588 100644
--- a/src/uu/tail/Cargo.toml
+++ b/src/uu/tail/Cargo.toml
@@ -1,7 +1,7 @@
 # spell-checker:ignore (libs) kqueue fundu
 [package]
 name = "uu_tail"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "tail ~ (uutils) display the last lines of input"
@@ -16,18 +16,24 @@ edition = "2021"
 path = "src/tail.rs"
 
 [dependencies]
-clap = { workspace=true }
-libc = { workspace=true }
-memchr = { workspace=true }
-notify = { workspace=true }
-uucore = { workspace=true }
-same-file = { workspace=true }
-is-terminal = { workspace=true }
-fundu = { workspace=true }
+clap = { workspace = true }
+libc = { workspace = true }
+memchr = { workspace = true }
+notify = { workspace = true }
+uucore = { workspace = true }
+same-file = { workspace = true }
+is-terminal = { workspace = true }
+fundu = { workspace = true }
 
 [target.'cfg(windows)'.dependencies]
-windows-sys = { workspace=true, features = ["Win32_System_Threading", "Win32_Foundation"] }
-winapi-util = { workspace=true }
+windows-sys = { workspace = true, features = [
+  "Win32_System_Threading",
+  "Win32_Foundation",
+] }
+winapi-util = { workspace = true }
+
+[dev-dependencies]
+rstest = { workspace = true }
 
 [[bin]]
 name = "tail"
diff --git a/src/uu/tail/README.md b/src/uu/tail/README.md
index f59e9e147..ef7cfbd6c 100644
--- a/src/uu/tail/README.md
+++ b/src/uu/tail/README.md
@@ -7,40 +7,59 @@
 * `--max-unchanged-stats`
 
 Note:
-There's a stub for `--max-unchanged-stats` so GNU test-suite checks using it can run, however this flag has no functionality yet.
+There's a stub for `--max-unchanged-stats` so GNU test-suite checks using it
+can run, however this flag has no functionality yet.
 
 ### Platform support for `--follow` and `--retry`
-The `--follow=descriptor`, `--follow=name` and `--retry` flags have very good support on Linux (inotify backend).
-They work good enough on macOS/BSD (kqueue backend) with some tests failing due to differences of how kqueue works compared to inotify.
-Windows support is there in theory due to ReadDirectoryChanges support by the notify-crate, however these flags are completely untested on Windows.
+
+The `--follow=descriptor`, `--follow=name` and `--retry` flags have very good
+support on Linux (inotify backend).
+They work good enough on macOS/BSD (kqueue backend) with some tests failing due
+to differences of how kqueue works compared to inotify.
+Windows support is there in theory due to ReadDirectoryChanges support by the
+notify-crate, however these flags are completely untested on Windows.
 
 Note:
-The undocumented `---disable-inotify` flag is used to disable the inotify backend to test polling. 
-However inotify is a Linux only backend and polling is now supported also for the other backends.
-Because of this, `disable-inotify` is now an alias to the new and more versatile flag name: `--use-polling`.
+The undocumented `---disable-inotify` flag is used to disable the inotify
+backend to test polling.
+However inotify is a Linux only backend and polling is now supported also
+for the other backends.
+Because of this, `disable-inotify` is now an alias to the new and more versatile
+flag name: `--use-polling`.
 
 ## Possible optimizations
 
-* Don't read the whole file if not using `-f` and input is regular file. Read in chunks from the end going backwards, reading each individual chunk forward.
+* Don't read the whole file if not using `-f` and input is regular file.
+  Read in chunks from the end going backwards, reading each individual chunk
+  forward.
 * Reduce number of system calls to e.g. `fstat`
-* Improve resource management by adding more system calls to `inotify_rm_watch` when appropriate.
+* Improve resource management by adding more system calls to `inotify_rm_watch`
+  when appropriate.
 
 # GNU test-suite results (9.1.8-e08752)
 
 The functionality for the test "gnu/tests/tail-2/follow-stdin.sh" is implemented.
-It fails because it is provoking closing a file descriptor with `tail -f <&-` and as part of a workaround, Rust's stdlib reopens closed FDs as `/dev/null` which means uu_tail cannot detect this.
-See also, e.g. the discussion at: https://github.com/uutils/coreutils/issues/2873
+It fails because it is provoking closing a file descriptor with `tail -f <&-`
+and as part of a workaround, Rust's stdlib reopens closed FDs as `/dev/null`
+which means uu_tail cannot detect this.
+See also, e.g. the discussion at:
+<https://github.com/uutils/coreutils/issues/2873>
 
-The functionality for the test "gnu/tests/tail-2/inotify-rotate-resources.sh" is implemented.
-It fails with an error because it is using `strace` to look for calls to `inotify_add_watch` and `inotify_rm_watch`,
+The functionality for the test "gnu/tests/tail-2/inotify-rotate-resources.sh"
+is implemented.
+It fails with an error because it is using `strace` to look for calls to
+`inotify_add_watch` and `inotify_rm_watch`,
 however in uu_tail these system calls are invoked from a separate thread.
-If the GNU test would follow threads, i.e. use `strace -f`, this issue could be resolved.
+If the GNU test would follow threads, i.e. use `strace -f`, this issue could be
+resolved.
 
-There are 5 tests which are fixed but do not (always) pass the test suite if it's run inside the CI.
+There are 5 tests which are fixed but do not (always) pass the test suite
+if it's run inside the CI.
 The reason for this is probably related to load/scheduling on the CI test VM.
 The tests in question are:
-- [x] `tail-2/F-vs-rename.sh`
-- [x] `tail-2/follow-name.sh`
-- [x] `tail-2/inotify-rotate.sh`
-- [x] `tail-2/overlay-headers.sh`
-- [x] `tail-2/retry.sh`
+
+* [x] `tail-2/F-vs-rename.sh`
+* [x] `tail-2/follow-name.sh`
+* [x] `tail-2/inotify-rotate.sh`
+* [x] `tail-2/overlay-headers.sh`
+* [x] `tail-2/retry.sh`
diff --git a/src/uu/tail/src/args.rs b/src/uu/tail/src/args.rs
index 6cb77757c..a7ddb077d 100644
--- a/src/uu/tail/src/args.rs
+++ b/src/uu/tail/src/args.rs
@@ -8,8 +8,8 @@
 use crate::paths::Input;
 use crate::{parse, platform, Quotable};
 use clap::crate_version;
-use clap::{parser::ValueSource, Arg, ArgAction, ArgMatches, Command};
-use fundu::DurationParser;
+use clap::{Arg, ArgAction, ArgMatches, Command};
+use fundu::{DurationParser, SaturatingInto};
 use is_terminal::IsTerminal;
 use same_file::Handle;
 use std::collections::VecDeque;
@@ -24,22 +24,22 @@ const USAGE: &str = help_usage!("tail.md");
 
 pub mod options {
     pub mod verbosity {
-        pub static QUIET: &str = "quiet";
-        pub static VERBOSE: &str = "verbose";
+        pub const QUIET: &str = "quiet";
+        pub const VERBOSE: &str = "verbose";
     }
-    pub static BYTES: &str = "bytes";
-    pub static FOLLOW: &str = "follow";
-    pub static LINES: &str = "lines";
-    pub static PID: &str = "pid";
-    pub static SLEEP_INT: &str = "sleep-interval";
-    pub static ZERO_TERM: &str = "zero-terminated";
-    pub static DISABLE_INOTIFY_TERM: &str = "-disable-inotify"; // NOTE: three hyphens is correct
-    pub static USE_POLLING: &str = "use-polling";
-    pub static RETRY: &str = "retry";
-    pub static FOLLOW_RETRY: &str = "F";
-    pub static MAX_UNCHANGED_STATS: &str = "max-unchanged-stats";
-    pub static ARG_FILES: &str = "files";
-    pub static PRESUME_INPUT_PIPE: &str = "-presume-input-pipe"; // NOTE: three hyphens is correct
+    pub const BYTES: &str = "bytes";
+    pub const FOLLOW: &str = "follow";
+    pub const LINES: &str = "lines";
+    pub const PID: &str = "pid";
+    pub const SLEEP_INT: &str = "sleep-interval";
+    pub const ZERO_TERM: &str = "zero-terminated";
+    pub const DISABLE_INOTIFY_TERM: &str = "-disable-inotify"; // NOTE: three hyphens is correct
+    pub const USE_POLLING: &str = "use-polling";
+    pub const RETRY: &str = "retry";
+    pub const FOLLOW_RETRY: &str = "F";
+    pub const MAX_UNCHANGED_STATS: &str = "max-unchanged-stats";
+    pub const ARG_FILES: &str = "files";
+    pub const PRESUME_INPUT_PIPE: &str = "-presume-input-pipe"; // NOTE: three hyphens is correct
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -59,12 +59,30 @@ pub enum FilterMode {
 }
 
 impl FilterMode {
+    fn from_obsolete_args(args: &parse::ObsoleteArgs) -> Self {
+        let signum = if args.plus {
+            Signum::Positive(args.num)
+        } else {
+            Signum::Negative(args.num)
+        };
+        if args.lines {
+            Self::Lines(signum, b'\n')
+        } else {
+            Self::Bytes(signum)
+        }
+    }
+
     fn from(matches: &ArgMatches) -> UResult<Self> {
         let zero_term = matches.get_flag(options::ZERO_TERM);
         let mode = if let Some(arg) = matches.get_one::<String>(options::BYTES) {
             match parse_num(arg) {
                 Ok(signum) => Self::Bytes(signum),
-                Err(e) => return Err(UUsageError::new(1, format!("invalid number of bytes: {e}"))),
+                Err(e) => {
+                    return Err(USimpleError::new(
+                        1,
+                        format!("invalid number of bytes: '{e}'"),
+                    ))
+                }
             }
         } else if let Some(arg) = matches.get_one::<String>(options::LINES) {
             match parse_num(arg) {
@@ -72,7 +90,12 @@ impl FilterMode {
                     let delimiter = if zero_term { 0 } else { b'\n' };
                     Self::Lines(signum, delimiter)
                 }
-                Err(e) => return Err(UUsageError::new(1, format!("invalid number of lines: {e}"))),
+                Err(e) => {
+                    return Err(USimpleError::new(
+                        1,
+                        format!("invalid number of lines: {e}"),
+                    ))
+                }
             }
         } else if zero_term {
             Self::default_zero()
@@ -107,7 +130,7 @@ pub enum VerificationResult {
     NoOutput,
 }
 
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct Settings {
     pub follow: Option<FollowMode>,
     pub max_unchanged_stats: u32,
@@ -121,28 +144,89 @@ pub struct Settings {
     pub inputs: VecDeque<Input>,
 }
 
-impl Settings {
-    pub fn from(matches: &clap::ArgMatches) -> UResult<Self> {
-        let mut settings: Self = Self {
-            sleep_sec: Duration::from_secs_f32(1.0),
+impl Default for Settings {
+    fn default() -> Self {
+        Self {
             max_unchanged_stats: 5,
+            sleep_sec: Duration::from_secs_f32(1.0),
+            follow: Default::default(),
+            mode: Default::default(),
+            pid: Default::default(),
+            retry: Default::default(),
+            use_polling: Default::default(),
+            verbose: Default::default(),
+            presume_input_pipe: Default::default(),
+            inputs: Default::default(),
+        }
+    }
+}
+
+impl Settings {
+    pub fn from_obsolete_args(args: &parse::ObsoleteArgs, name: Option<&OsString>) -> Self {
+        let mut settings: Self = Default::default();
+        if args.follow {
+            settings.follow = if name.is_some() {
+                Some(FollowMode::Name)
+            } else {
+                Some(FollowMode::Descriptor)
+            };
+        }
+        settings.mode = FilterMode::from_obsolete_args(args);
+        let input = if let Some(name) = name {
+            Input::from(&name)
+        } else {
+            Input::default()
+        };
+        settings.inputs.push_back(input);
+        settings
+    }
+
+    pub fn from(matches: &clap::ArgMatches) -> UResult<Self> {
+        // We're parsing --follow, -F and --retry under the following conditions:
+        // * -F sets --retry and --follow=name
+        // * plain --follow or short -f is the same like specifying --follow=descriptor
+        // * All these options and flags can occur multiple times as command line arguments
+        let follow_retry = matches.get_flag(options::FOLLOW_RETRY);
+        // We don't need to check for occurrences of --retry if -F was specified which already sets
+        // retry
+        let retry = follow_retry || matches.get_flag(options::RETRY);
+        let follow = match (
+            follow_retry,
+            matches
+                .get_one::<String>(options::FOLLOW)
+                .map(|s| s.as_str()),
+        ) {
+            // -F and --follow if -F is specified after --follow. We don't need to care about the
+            // value of --follow.
+            (true, Some(_))
+                // It's ok to use `index_of` instead of `indices_of` since -F and  --follow
+                // overwrite themselves (not only the value but also the index).
+                if matches.index_of(options::FOLLOW_RETRY) > matches.index_of(options::FOLLOW) =>
+            {
+                Some(FollowMode::Name)
+            }
+            // * -F and --follow=name if --follow=name is specified after -F
+            // * No occurrences of -F but --follow=name
+            // * -F and no occurrences of --follow
+            (_, Some("name")) | (true, None) => Some(FollowMode::Name),
+            // * -F and --follow=descriptor (or plain --follow, -f) if --follow=descriptor is
+            // specified after -F
+            // * No occurrences of -F but --follow=descriptor, --follow, -f
+            (_, Some(_)) => Some(FollowMode::Descriptor),
+            // The default for no occurrences of -F or --follow
+            (false, None) => None,
+        };
+
+        let mut settings: Self = Self {
+            follow,
+            retry,
+            use_polling: matches.get_flag(options::USE_POLLING),
+            mode: FilterMode::from(matches)?,
+            verbose: matches.get_flag(options::verbosity::VERBOSE),
+            presume_input_pipe: matches.get_flag(options::PRESUME_INPUT_PIPE),
             ..Default::default()
         };
 
-        settings.follow = if matches.get_flag(options::FOLLOW_RETRY) {
-            Some(FollowMode::Name)
-        } else if matches.value_source(options::FOLLOW) != Some(ValueSource::CommandLine) {
-            None
-        } else if matches.get_one::<String>(options::FOLLOW) == Some(String::from("name")).as_ref()
-        {
-            Some(FollowMode::Name)
-        } else {
-            Some(FollowMode::Descriptor)
-        };
-
-        settings.retry =
-            matches.get_flag(options::RETRY) || matches.get_flag(options::FOLLOW_RETRY);
-
         if let Some(source) = matches.get_one::<String>(options::SLEEP_INT) {
             // Advantage of `fundu` over `Duration::(try_)from_secs_f64(source.parse().unwrap())`:
             // * doesn't panic on errors like `Duration::from_secs_f64` would.
@@ -151,16 +235,17 @@ impl Settings {
             //   `DURATION::MAX` or `infinity` was given
             // * not applied here but it supports customizable time units and provides better error
             //   messages
-            settings.sleep_sec =
-                DurationParser::without_time_units()
-                    .parse(source)
-                    .map_err(|_| {
-                        UUsageError::new(1, format!("invalid number of seconds: '{source}'"))
-                    })?;
+            settings.sleep_sec = match DurationParser::without_time_units().parse(source) {
+                Ok(duration) => SaturatingInto::<std::time::Duration>::saturating_into(duration),
+                Err(_) => {
+                    return Err(UUsageError::new(
+                        1,
+                        format!("invalid number of seconds: '{source}'"),
+                    ))
+                }
+            }
         }
 
-        settings.use_polling = matches.get_flag(options::USE_POLLING);
-
         if let Some(s) = matches.get_one::<String>(options::MAX_UNCHANGED_STATS) {
             settings.max_unchanged_stats = match s.parse::<u32>() {
                 Ok(s) => s,
@@ -200,11 +285,9 @@ impl Settings {
             }
         }
 
-        settings.mode = FilterMode::from(matches)?;
-
         let mut inputs: VecDeque<Input> = matches
             .get_many::<String>(options::ARG_FILES)
-            .map(|v| v.map(|string| Input::from(string.clone())).collect())
+            .map(|v| v.map(|string| Input::from(&string)).collect())
             .unwrap_or_default();
 
         // apply default and add '-' to inputs if none is present
@@ -212,13 +295,10 @@ impl Settings {
             inputs.push_front(Input::default());
         }
 
-        settings.verbose = (matches.get_flag(options::verbosity::VERBOSE) || inputs.len() > 1)
-            && !matches.get_flag(options::verbosity::QUIET);
+        settings.verbose = inputs.len() > 1 && !matches.get_flag(options::verbosity::QUIET);
 
         settings.inputs = inputs;
 
-        settings.presume_input_pipe = matches.get_flag(options::PRESUME_INPUT_PIPE);
-
         Ok(settings)
     }
 
@@ -298,32 +378,31 @@ impl Settings {
     }
 }
 
-pub fn arg_iterate<'a>(
-    mut args: impl uucore::Args + 'a,
-) -> UResult<Box<dyn Iterator<Item = OsString> + 'a>> {
-    // argv[0] is always present
-    let first = args.next().unwrap();
-    if let Some(second) = args.next() {
-        if let Some(s) = second.to_str() {
-            match parse::parse_obsolete(s) {
-                Some(Ok(iter)) => Ok(Box::new(vec![first].into_iter().chain(iter).chain(args))),
-                Some(Err(e)) => Err(UUsageError::new(
-                    1,
-                    match e {
-                        parse::ParseError::Syntax => format!("bad argument format: {}", s.quote()),
-                        parse::ParseError::Overflow => format!(
-                            "invalid argument: {} Value too large for defined datatype",
-                            s.quote()
-                        ),
-                    },
-                )),
-                None => Ok(Box::new(vec![first, second].into_iter().chain(args))),
-            }
-        } else {
-            Err(UUsageError::new(1, "bad argument encoding".to_owned()))
+pub fn parse_obsolete(arg: &OsString, input: Option<&OsString>) -> UResult<Option<Settings>> {
+    match parse::parse_obsolete(arg) {
+        Some(Ok(args)) => Ok(Some(Settings::from_obsolete_args(&args, input))),
+        None => Ok(None),
+        Some(Err(e)) => {
+            let arg_str = arg.to_string_lossy();
+            Err(USimpleError::new(
+                1,
+                match e {
+                    parse::ParseError::OutOfRange => format!(
+                        "invalid number: {}: Numerical result out of range",
+                        arg_str.quote()
+                    ),
+                    parse::ParseError::Overflow => format!("invalid number: {}", arg_str.quote()),
+                    // this ensures compatibility to GNU's error message (as tested in misc/tail)
+                    parse::ParseError::Context => format!(
+                        "option used in invalid context -- {}",
+                        arg_str.chars().nth(1).unwrap_or_default()
+                    ),
+                    parse::ParseError::InvalidEncoding => {
+                        format!("bad argument encoding: '{arg_str}'")
+                    }
+                },
+            ))
         }
-    } else {
-        Ok(Box::new(vec![first].into_iter()))
     }
 }
 
@@ -339,31 +418,67 @@ fn parse_num(src: &str) -> Result<Signum, ParseSizeError> {
                 starting_with = true;
             }
         }
-    } else {
-        return Err(ParseSizeError::ParseFailure(src.to_string()));
     }
 
-    parse_size(size_string).map(|n| match (n, starting_with) {
-        (0, true) => Signum::PlusZero,
-        (0, false) => Signum::MinusZero,
-        (n, true) => Signum::Positive(n),
-        (n, false) => Signum::Negative(n),
-    })
+    match parse_size(size_string) {
+        Ok(n) => match (n, starting_with) {
+            (0, true) => Ok(Signum::PlusZero),
+            (0, false) => Ok(Signum::MinusZero),
+            (n, true) => Ok(Signum::Positive(n)),
+            (n, false) => Ok(Signum::Negative(n)),
+        },
+        Err(_) => Err(ParseSizeError::ParseFailure(size_string.to_string())),
+    }
 }
 
 pub fn parse_args(args: impl uucore::Args) -> UResult<Settings> {
-    let matches = uu_app().try_get_matches_from(arg_iterate(args)?)?;
-    Settings::from(&matches)
+    let args_vec: Vec<OsString> = args.collect();
+    let clap_args = uu_app().try_get_matches_from(args_vec.clone());
+    let clap_result = match clap_args {
+        Ok(matches) => Ok(Settings::from(&matches)?),
+        Err(err) => Err(err.into()),
+    };
+
+    // clap isn't able to handle obsolete syntax.
+    // therefore, we want to check further for obsolete arguments.
+    // argv[0] is always present, argv[1] might be obsolete arguments
+    // argv[2] might contain an input file, argv[3] isn't allowed in obsolete mode
+    if args_vec.len() != 2 && args_vec.len() != 3 {
+        return clap_result;
+    }
+
+    // At this point, there are a few possible cases:
+    //
+    //    1. clap has succeeded and the arguments would be invalid for the obsolete syntax.
+    //    2. The case of `tail -c 5` is ambiguous. clap parses this as `tail -c5`,
+    //       but it could also be interpreted as valid obsolete syntax (tail -c on file '5').
+    //       GNU chooses to interpret this as `tail -c5`, like clap.
+    //    3. `tail -f foo` is also ambiguous, but has the same effect in both cases. We can safely
+    //        use the clap result here.
+    //    4. clap succeeded for obsolete arguments starting with '+', but misinterprets them as
+    //       input files (e.g. 'tail +f').
+    //    5. clap failed because of unknown flags, but possibly valid obsolete arguments
+    //        (e.g. tail -l; tail -10c).
+    //
+    // In cases 4 & 5, we want to try parsing the obsolete arguments, which corresponds to
+    // checking whether clap succeeded or the first argument starts with '+'.
+    let possible_obsolete_args = &args_vec[1];
+    if clap_result.is_ok() && !possible_obsolete_args.to_string_lossy().starts_with('+') {
+        return clap_result;
+    }
+    match parse_obsolete(possible_obsolete_args, args_vec.get(2))? {
+        Some(settings) => Ok(settings),
+        None => clap_result,
+    }
 }
 
 pub fn uu_app() -> Command {
     #[cfg(target_os = "linux")]
-    pub static POLLING_HELP: &str = "Disable 'inotify' support and use polling instead";
+    const POLLING_HELP: &str = "Disable 'inotify' support and use polling instead";
     #[cfg(all(unix, not(target_os = "linux")))]
-    pub static POLLING_HELP: &str = "Disable 'kqueue' support and use polling instead";
+    const POLLING_HELP: &str = "Disable 'kqueue' support and use polling instead";
     #[cfg(target_os = "windows")]
-    pub static POLLING_HELP: &str =
-        "Disable 'ReadDirectoryChanges' support and use polling instead";
+    const POLLING_HELP: &str = "Disable 'ReadDirectoryChanges' support and use polling instead";
 
     Command::new(uucore::util_name())
         .version(crate_version!())
@@ -382,10 +497,11 @@ pub fn uu_app() -> Command {
             Arg::new(options::FOLLOW)
                 .short('f')
                 .long(options::FOLLOW)
-                .default_value("descriptor")
+                .default_missing_value("descriptor")
                 .num_args(0..=1)
                 .require_equals(true)
                 .value_parser(["descriptor", "name"])
+                .overrides_with(options::FOLLOW)
                 .help("Print the file as it grows"),
         )
         .arg(
@@ -456,13 +572,14 @@ pub fn uu_app() -> Command {
             Arg::new(options::RETRY)
                 .long(options::RETRY)
                 .help("Keep trying to open a file if it is inaccessible")
+                .overrides_with(options::RETRY)
                 .action(ArgAction::SetTrue),
         )
         .arg(
             Arg::new(options::FOLLOW_RETRY)
                 .short('F')
                 .help("Same as --follow=name --retry")
-                .overrides_with_all([options::RETRY, options::FOLLOW])
+                .overrides_with(options::FOLLOW_RETRY)
                 .action(ArgAction::SetTrue),
         )
         .arg(
@@ -482,6 +599,10 @@ pub fn uu_app() -> Command {
 
 #[cfg(test)]
 mod tests {
+    use rstest::rstest;
+
+    use crate::parse::ObsoleteArgs;
+
     use super::*;
 
     #[test]
@@ -513,4 +634,52 @@ mod tests {
         assert!(result.is_ok());
         assert_eq!(result.unwrap(), Signum::Negative(1));
     }
+
+    #[test]
+    fn test_parse_obsolete_settings_f() {
+        let args = ObsoleteArgs {
+            follow: true,
+            ..Default::default()
+        };
+        let result = Settings::from_obsolete_args(&args, None);
+        assert_eq!(result.follow, Some(FollowMode::Descriptor));
+
+        let result = Settings::from_obsolete_args(&args, Some(&"file".into()));
+        assert_eq!(result.follow, Some(FollowMode::Name));
+    }
+
+    #[rstest]
+    #[case::default(vec![], None, false)]
+    #[case::retry(vec!["--retry"], None, true)]
+    #[case::multiple_retry(vec!["--retry", "--retry"], None, true)]
+    #[case::follow_long(vec!["--follow"], Some(FollowMode::Descriptor), false)]
+    #[case::follow_short(vec!["-f"], Some(FollowMode::Descriptor), false)]
+    #[case::follow_long_with_retry(vec!["--follow", "--retry"], Some(FollowMode::Descriptor), true)]
+    #[case::follow_short_with_retry(vec!["-f", "--retry"], Some(FollowMode::Descriptor), true)]
+    #[case::follow_overwrites_previous_selection_1(vec!["--follow=name", "--follow=descriptor"], Some(FollowMode::Descriptor), false)]
+    #[case::follow_overwrites_previous_selection_2(vec!["--follow=descriptor", "--follow=name"], Some(FollowMode::Name), false)]
+    #[case::big_f(vec!["-F"], Some(FollowMode::Name), true)]
+    #[case::multiple_big_f(vec!["-F", "-F"], Some(FollowMode::Name), true)]
+    #[case::big_f_with_retry_then_does_not_change(vec!["-F", "--retry"], Some(FollowMode::Name), true)]
+    #[case::big_f_with_follow_descriptor_then_change(vec!["-F", "--follow=descriptor"], Some(FollowMode::Descriptor), true)]
+    #[case::multiple_big_f_with_follow_descriptor_then_no_change(vec!["-F", "--follow=descriptor", "-F"], Some(FollowMode::Name), true)]
+    #[case::big_f_with_follow_short_then_change(vec!["-F", "-f"], Some(FollowMode::Descriptor), true)]
+    #[case::follow_descriptor_with_big_f_then_change(vec!["--follow=descriptor", "-F"], Some(FollowMode::Name), true)]
+    #[case::follow_short_with_big_f_then_change(vec!["-f", "-F"], Some(FollowMode::Name), true)]
+    #[case::big_f_with_follow_name_then_not_change(vec!["-F", "--follow=name"], Some(FollowMode::Name), true)]
+    #[case::follow_name_with_big_f_then_not_change(vec!["--follow=name", "-F"], Some(FollowMode::Name), true)]
+    #[case::big_f_with_multiple_long_follow(vec!["--follow=name", "-F", "--follow=descriptor"], Some(FollowMode::Descriptor), true)]
+    #[case::big_f_with_multiple_long_follow_name(vec!["--follow=name", "-F", "--follow=name"], Some(FollowMode::Name), true)]
+    #[case::big_f_with_multiple_short_follow(vec!["-f", "-F", "-f"], Some(FollowMode::Descriptor), true)]
+    #[case::multiple_big_f_with_multiple_short_follow(vec!["-f", "-F", "-f", "-F"], Some(FollowMode::Name), true)]
+    fn test_parse_settings_follow_mode_and_retry(
+        #[case] args: Vec<&str>,
+        #[case] expected_follow_mode: Option<FollowMode>,
+        #[case] expected_retry: bool,
+    ) {
+        let settings =
+            Settings::from(&uu_app().no_binary_name(true).get_matches_from(args)).unwrap();
+        assert_eq!(settings.follow, expected_follow_mode);
+        assert_eq!(settings.retry, expected_retry);
+    }
 }
diff --git a/src/uu/tail/src/chunks.rs b/src/uu/tail/src/chunks.rs
index 4b934c1d7..3aa380e20 100644
--- a/src/uu/tail/src/chunks.rs
+++ b/src/uu/tail/src/chunks.rs
@@ -579,16 +579,16 @@ impl LinesChunkBuffer {
             }
         }
 
-        if !&self.chunks.is_empty() {
+        if self.chunks.is_empty() {
+            // chunks is empty when a file is empty so quitting early here
+            return Ok(());
+        } else {
             let length = &self.chunks.len();
             let last = &mut self.chunks[length - 1];
             if !last.get_buffer().ends_with(&[self.delimiter]) {
                 last.lines += 1;
                 self.lines += 1;
             }
-        } else {
-            // chunks is empty when a file is empty so quitting early here
-            return Ok(());
         }
 
         // skip unnecessary chunks and save the first chunk which may hold some lines we have to
diff --git a/src/uu/tail/src/follow/watch.rs b/src/uu/tail/src/follow/watch.rs
index 2c3cf10b8..67ad8f0c2 100644
--- a/src/uu/tail/src/follow/watch.rs
+++ b/src/uu/tail/src/follow/watch.rs
@@ -303,6 +303,7 @@ impl Observer {
         Ok(())
     }
 
+    #[allow(clippy::cognitive_complexity)]
     fn handle_event(
         &mut self,
         event: &notify::Event,
@@ -471,6 +472,7 @@ impl Observer {
     }
 }
 
+#[allow(clippy::cognitive_complexity)]
 pub fn follow(mut observer: Observer, settings: &Settings) -> UResult<()> {
     if observer.files.no_files_remaining(settings) && !observer.files.only_stdin_remaining() {
         return Err(USimpleError::new(1, text::NO_FILES_REMAINING.to_string()));
diff --git a/src/uu/tail/src/parse.rs b/src/uu/tail/src/parse.rs
index 2129d8e29..96cf1e918 100644
--- a/src/uu/tail/src/parse.rs
+++ b/src/uu/tail/src/parse.rs
@@ -5,157 +5,185 @@
 
 use std::ffi::OsString;
 
+#[derive(PartialEq, Eq, Debug, Copy, Clone)]
+pub struct ObsoleteArgs {
+    pub num: u64,
+    pub plus: bool,
+    pub lines: bool,
+    pub follow: bool,
+}
+
+impl Default for ObsoleteArgs {
+    fn default() -> Self {
+        Self {
+            num: 10,
+            plus: false,
+            lines: true,
+            follow: false,
+        }
+    }
+}
+
 #[derive(PartialEq, Eq, Debug)]
 pub enum ParseError {
-    Syntax,
+    OutOfRange,
     Overflow,
+    Context,
+    InvalidEncoding,
 }
 /// Parses obsolete syntax
-/// tail -NUM\[kmzv\] // spell-checker:disable-line
-pub fn parse_obsolete(src: &str) -> Option<Result<impl Iterator<Item = OsString>, ParseError>> {
-    let mut chars = src.char_indices();
-    if let Some((_, '-')) = chars.next() {
-        let mut num_end = 0usize;
-        let mut has_num = false;
-        let mut last_char = 0 as char;
-        for (n, c) in &mut chars {
-            if c.is_ascii_digit() {
-                has_num = true;
-                num_end = n;
-            } else {
-                last_char = c;
-                break;
-            }
-        }
-        if has_num {
-            match src[1..=num_end].parse::<usize>() {
-                Ok(num) => {
-                    let mut quiet = false;
-                    let mut verbose = false;
-                    let mut zero_terminated = false;
-                    let mut multiplier = None;
-                    let mut c = last_char;
-                    loop {
-                        // not that here, we only match lower case 'k', 'c', and 'm'
-                        match c {
-                            // we want to preserve order
-                            // this also saves us 1 heap allocation
-                            'q' => {
-                                quiet = true;
-                                verbose = false;
-                            }
-                            'v' => {
-                                verbose = true;
-                                quiet = false;
-                            }
-                            'z' => zero_terminated = true,
-                            'c' => multiplier = Some(1),
-                            'b' => multiplier = Some(512),
-                            'k' => multiplier = Some(1024),
-                            'm' => multiplier = Some(1024 * 1024),
-                            '\0' => {}
-                            _ => return Some(Err(ParseError::Syntax)),
-                        }
-                        if let Some((_, next)) = chars.next() {
-                            c = next;
-                        } else {
-                            break;
-                        }
-                    }
-                    let mut options = Vec::new();
-                    if quiet {
-                        options.push(OsString::from("-q"));
-                    }
-                    if verbose {
-                        options.push(OsString::from("-v"));
-                    }
-                    if zero_terminated {
-                        options.push(OsString::from("-z"));
-                    }
-                    if let Some(n) = multiplier {
-                        options.push(OsString::from("-c"));
-                        let num = match num.checked_mul(n) {
-                            Some(n) => n,
-                            None => return Some(Err(ParseError::Overflow)),
-                        };
-                        options.push(OsString::from(format!("{num}")));
-                    } else {
-                        options.push(OsString::from("-n"));
-                        options.push(OsString::from(format!("{num}")));
-                    }
-                    Some(Ok(options.into_iter()))
-                }
-                Err(_) => Some(Err(ParseError::Overflow)),
-            }
+/// tail -\[NUM\]\[bcl\]\[f\] and tail +\[NUM\]\[bcl\]\[f\] // spell-checker:disable-line
+pub fn parse_obsolete(src: &OsString) -> Option<Result<ObsoleteArgs, ParseError>> {
+    let mut rest = match src.to_str() {
+        Some(src) => src,
+        None => return Some(Err(ParseError::InvalidEncoding)),
+    };
+    let sign = if let Some(r) = rest.strip_prefix('-') {
+        rest = r;
+        '-'
+    } else if let Some(r) = rest.strip_prefix('+') {
+        rest = r;
+        '+'
+    } else {
+        return None;
+    };
+
+    let end_num = rest
+        .find(|c: char| !c.is_ascii_digit())
+        .unwrap_or(rest.len());
+    let has_num = !rest[..end_num].is_empty();
+    let num: u64 = if has_num {
+        if let Ok(num) = rest[..end_num].parse() {
+            num
         } else {
-            None
+            return Some(Err(ParseError::OutOfRange));
         }
     } else {
-        None
+        10
+    };
+    rest = &rest[end_num..];
+
+    let mode = if let Some(r) = rest.strip_prefix('l') {
+        rest = r;
+        'l'
+    } else if let Some(r) = rest.strip_prefix('c') {
+        rest = r;
+        'c'
+    } else if let Some(r) = rest.strip_prefix('b') {
+        rest = r;
+        'b'
+    } else {
+        'l'
+    };
+
+    let follow = rest.contains('f');
+    if !rest.chars().all(|f| f == 'f') {
+        // GNU allows an arbitrary amount of following fs, but nothing else
+        if sign == '-' && has_num {
+            return Some(Err(ParseError::Context));
+        }
+        return None;
     }
+
+    let multiplier = if mode == 'b' { 512 } else { 1 };
+    let num = match num.checked_mul(multiplier) {
+        Some(n) => n,
+        None => return Some(Err(ParseError::Overflow)),
+    };
+
+    Some(Ok(ObsoleteArgs {
+        num,
+        plus: sign == '+',
+        lines: mode == 'l',
+        follow,
+    }))
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    fn obsolete(src: &str) -> Option<Result<Vec<String>, ParseError>> {
-        let r = parse_obsolete(src);
-        match r {
-            Some(s) => match s {
-                Ok(v) => Some(Ok(v.map(|s| s.to_str().unwrap().to_owned()).collect())),
-                Err(e) => Some(Err(e)),
-            },
-            None => None,
-        }
-    }
-    fn obsolete_result(src: &[&str]) -> Option<Result<Vec<String>, ParseError>> {
-        Some(Ok(src.iter().map(|s| s.to_string()).collect()))
-    }
     #[test]
     fn test_parse_numbers_obsolete() {
-        assert_eq!(obsolete("-5"), obsolete_result(&["-n", "5"]));
-        assert_eq!(obsolete("-100"), obsolete_result(&["-n", "100"]));
-        assert_eq!(obsolete("-5m"), obsolete_result(&["-c", "5242880"]));
-        assert_eq!(obsolete("-1k"), obsolete_result(&["-c", "1024"]));
-        assert_eq!(obsolete("-2b"), obsolete_result(&["-c", "1024"]));
-        assert_eq!(obsolete("-1mmk"), obsolete_result(&["-c", "1024"]));
-        assert_eq!(obsolete("-1vz"), obsolete_result(&["-v", "-z", "-n", "1"]));
         assert_eq!(
-            obsolete("-1vzqvq"), // spell-checker:disable-line
-            obsolete_result(&["-q", "-z", "-n", "1"])
+            parse_obsolete(&OsString::from("+2c")),
+            Some(Ok(ObsoleteArgs {
+                num: 2,
+                plus: true,
+                lines: false,
+                follow: false,
+            }))
         );
-        assert_eq!(obsolete("-1vzc"), obsolete_result(&["-v", "-z", "-c", "1"]));
         assert_eq!(
-            obsolete("-105kzm"),
-            obsolete_result(&["-z", "-c", "110100480"])
+            parse_obsolete(&OsString::from("-5")),
+            Some(Ok(ObsoleteArgs {
+                num: 5,
+                plus: false,
+                lines: true,
+                follow: false,
+            }))
+        );
+        assert_eq!(
+            parse_obsolete(&OsString::from("+100f")),
+            Some(Ok(ObsoleteArgs {
+                num: 100,
+                plus: true,
+                lines: true,
+                follow: true,
+            }))
+        );
+        assert_eq!(
+            parse_obsolete(&OsString::from("-2b")),
+            Some(Ok(ObsoleteArgs {
+                num: 1024,
+                plus: false,
+                lines: false,
+                follow: false,
+            }))
         );
     }
     #[test]
     fn test_parse_errors_obsolete() {
-        assert_eq!(obsolete("-5n"), Some(Err(ParseError::Syntax)));
-        assert_eq!(obsolete("-5c5"), Some(Err(ParseError::Syntax)));
+        assert_eq!(
+            parse_obsolete(&OsString::from("-5n")),
+            Some(Err(ParseError::Context))
+        );
+        assert_eq!(
+            parse_obsolete(&OsString::from("-5c5")),
+            Some(Err(ParseError::Context))
+        );
+        assert_eq!(
+            parse_obsolete(&OsString::from("-1vzc")),
+            Some(Err(ParseError::Context))
+        );
+        assert_eq!(
+            parse_obsolete(&OsString::from("-5m")),
+            Some(Err(ParseError::Context))
+        );
+        assert_eq!(
+            parse_obsolete(&OsString::from("-1k")),
+            Some(Err(ParseError::Context))
+        );
+        assert_eq!(
+            parse_obsolete(&OsString::from("-1mmk")),
+            Some(Err(ParseError::Context))
+        );
+        assert_eq!(
+            parse_obsolete(&OsString::from("-105kzm")),
+            Some(Err(ParseError::Context))
+        );
+        assert_eq!(
+            parse_obsolete(&OsString::from("-1vz")),
+            Some(Err(ParseError::Context))
+        );
+        assert_eq!(
+            parse_obsolete(&OsString::from("-1vzqvq")), // spell-checker:disable-line
+            Some(Err(ParseError::Context))
+        );
     }
     #[test]
     fn test_parse_obsolete_no_match() {
-        assert_eq!(obsolete("-k"), None);
-        assert_eq!(obsolete("asd"), None);
-    }
-    #[test]
-    #[cfg(target_pointer_width = "64")]
-    fn test_parse_obsolete_overflow_x64() {
-        assert_eq!(
-            obsolete("-1000000000000000m"),
-            Some(Err(ParseError::Overflow))
-        );
-        assert_eq!(
-            obsolete("-10000000000000000000000"),
-            Some(Err(ParseError::Overflow))
-        );
-    }
-    #[test]
-    #[cfg(target_pointer_width = "32")]
-    fn test_parse_obsolete_overflow_x32() {
-        assert_eq!(obsolete("-42949672960"), Some(Err(ParseError::Overflow)));
-        assert_eq!(obsolete("-42949672k"), Some(Err(ParseError::Overflow)));
+        assert_eq!(parse_obsolete(&OsString::from("-k")), None);
+        assert_eq!(parse_obsolete(&OsString::from("asd")), None);
+        assert_eq!(parse_obsolete(&OsString::from("-cc")), None);
     }
 }
diff --git a/src/uu/tail/src/paths.rs b/src/uu/tail/src/paths.rs
index d8e6ece9a..4badd6866 100644
--- a/src/uu/tail/src/paths.rs
+++ b/src/uu/tail/src/paths.rs
@@ -6,6 +6,7 @@
 // spell-checker:ignore tailable seekable stdlib (stdlib)
 
 use crate::text;
+use std::ffi::OsStr;
 use std::fs::{File, Metadata};
 use std::io::{Seek, SeekFrom};
 #[cfg(unix)]
@@ -26,21 +27,20 @@ pub struct Input {
 }
 
 impl Input {
-    // TODO: from &str may be the better choice
-    pub fn from(string: String) -> Self {
-        let kind = if string == text::DASH {
+    pub fn from<T: AsRef<OsStr>>(string: &T) -> Self {
+        let kind = if string.as_ref() == Path::new(text::DASH) {
             InputKind::Stdin
         } else {
-            InputKind::File(PathBuf::from(&string))
+            InputKind::File(PathBuf::from(string.as_ref()))
         };
 
         let display_name = match kind {
-            InputKind::File(_) => string,
+            InputKind::File(_) => string.as_ref().to_string_lossy().to_string(),
             InputKind::Stdin => {
                 if cfg!(unix) {
                     text::STDIN_HEADER.to_string()
                 } else {
-                    string
+                    string.as_ref().to_string_lossy().to_string()
                 }
             }
         };
diff --git a/src/uu/tail/src/tail.rs b/src/uu/tail/src/tail.rs
index 9e3273638..e07616c6f 100644
--- a/src/uu/tail/src/tail.rs
+++ b/src/uu/tail/src/tail.rs
@@ -125,10 +125,10 @@ fn tail_file(
 
         show_error!("error reading '{}': {}", input.display_name, err_msg);
         if settings.follow.is_some() {
-            let msg = if !settings.retry {
-                "; giving up on this name"
-            } else {
+            let msg = if settings.retry {
                 ""
+            } else {
+                "; giving up on this name"
             };
             show_error!(
                 "{}: cannot follow end of this type of file{}",
@@ -215,11 +215,7 @@ fn tail_stdin(
         // pipe
         None => {
             header_printer.print_input(input);
-            if !paths::stdin_is_bad_fd() {
-                let mut reader = BufReader::new(stdin());
-                unbounded_tail(&mut reader, settings)?;
-                observer.add_stdin(input.display_name.as_str(), Some(Box::new(reader)), true)?;
-            } else {
+            if paths::stdin_is_bad_fd() {
                 set_exit_code(1);
                 show_error!(
                     "cannot fstat {}: {}",
@@ -233,6 +229,10 @@ fn tail_stdin(
                         text::BAD_FD
                     );
                 }
+            } else {
+                let mut reader = BufReader::new(stdin());
+                unbounded_tail(&mut reader, settings)?;
+                observer.add_stdin(input.display_name.as_str(), Some(Box::new(reader)), true)?;
             }
         }
     };
diff --git a/src/uu/tail/src/text.rs b/src/uu/tail/src/text.rs
index 0e4a26f39..e7686d301 100644
--- a/src/uu/tail/src/text.rs
+++ b/src/uu/tail/src/text.rs
@@ -5,20 +5,20 @@
 
 // spell-checker:ignore (ToDO) kqueue
 
-pub static DASH: &str = "-";
-pub static DEV_STDIN: &str = "/dev/stdin";
-pub static STDIN_HEADER: &str = "standard input";
-pub static NO_FILES_REMAINING: &str = "no files remaining";
-pub static NO_SUCH_FILE: &str = "No such file or directory";
-pub static BECOME_INACCESSIBLE: &str = "has become inaccessible";
-pub static BAD_FD: &str = "Bad file descriptor";
+pub const DASH: &str = "-";
+pub const DEV_STDIN: &str = "/dev/stdin";
+pub const STDIN_HEADER: &str = "standard input";
+pub const NO_FILES_REMAINING: &str = "no files remaining";
+pub const NO_SUCH_FILE: &str = "No such file or directory";
+pub const BECOME_INACCESSIBLE: &str = "has become inaccessible";
+pub const BAD_FD: &str = "Bad file descriptor";
 #[cfg(target_os = "linux")]
-pub static BACKEND: &str = "inotify";
+pub const BACKEND: &str = "inotify";
 #[cfg(all(unix, not(target_os = "linux")))]
-pub static BACKEND: &str = "kqueue";
+pub const BACKEND: &str = "kqueue";
 #[cfg(target_os = "windows")]
-pub static BACKEND: &str = "ReadDirectoryChanges";
-pub static FD0: &str = "/dev/fd/0";
-pub static IS_A_DIRECTORY: &str = "Is a directory";
-pub static DEV_TTY: &str = "/dev/tty";
-pub static DEV_PTMX: &str = "/dev/ptmx";
+pub const BACKEND: &str = "ReadDirectoryChanges";
+pub const FD0: &str = "/dev/fd/0";
+pub const IS_A_DIRECTORY: &str = "Is a directory";
+pub const DEV_TTY: &str = "/dev/tty";
+pub const DEV_PTMX: &str = "/dev/ptmx";
diff --git a/src/uu/tee/Cargo.toml b/src/uu/tee/Cargo.toml
index 52a2accea..21d64c0c2 100644
--- a/src/uu/tee/Cargo.toml
+++ b/src/uu/tee/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_tee"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "tee ~ (uutils) display input and copy to FILE"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/tee.rs"
 
 [dependencies]
-clap = { workspace=true }
-libc = { workspace=true }
-uucore = { workspace=true, features=["libc"] }
+clap = { workspace = true }
+libc = { workspace = true }
+uucore = { workspace = true, features = ["libc", "signals"] }
 
 [[bin]]
 name = "tee"
diff --git a/src/uu/tee/src/tee.rs b/src/uu/tee/src/tee.rs
index 96c318afd..5c388dd0e 100644
--- a/src/uu/tee/src/tee.rs
+++ b/src/uu/tee/src/tee.rs
@@ -16,7 +16,7 @@ use uucore::{format_usage, help_about, help_section, help_usage, show_error};
 // spell-checker:ignore nopipe
 
 #[cfg(unix)]
-use uucore::libc;
+use uucore::signals::{enable_pipe_errors, ignore_interrupts};
 
 const ABOUT: &str = help_about!("tee.md");
 const USAGE: &str = help_usage!("tee.md");
@@ -135,44 +135,19 @@ pub fn uu_app() -> Command {
         )
 }
 
-#[cfg(unix)]
-fn ignore_interrupts() -> Result<()> {
-    let ret = unsafe { libc::signal(libc::SIGINT, libc::SIG_IGN) };
-    if ret == libc::SIG_ERR {
-        return Err(Error::new(ErrorKind::Other, ""));
-    }
-    Ok(())
-}
-
-#[cfg(not(unix))]
-fn ignore_interrupts() -> Result<()> {
-    // Do nothing.
-    Ok(())
-}
-
-#[cfg(unix)]
-fn enable_pipe_errors() -> Result<()> {
-    let ret = unsafe { libc::signal(libc::SIGPIPE, libc::SIG_DFL) };
-    if ret == libc::SIG_ERR {
-        return Err(Error::new(ErrorKind::Other, ""));
-    }
-    Ok(())
-}
-
-#[cfg(not(unix))]
-fn enable_pipe_errors() -> Result<()> {
-    // Do nothing.
-    Ok(())
-}
-
 fn tee(options: &Options) -> Result<()> {
-    if options.ignore_interrupts {
-        ignore_interrupts()?;
-    }
-    if options.output_error.is_none() {
-        enable_pipe_errors()?;
-    }
+    #[cfg(unix)]
+    {
+        // ErrorKind::Other is raised by MultiWriter when all writers have exited.
+        // This is therefore just a clever way to stop all writers
 
+        if options.ignore_interrupts {
+            ignore_interrupts().map_err(|_| Error::from(ErrorKind::Other))?;
+        }
+        if options.output_error.is_none() {
+            enable_pipe_errors().map_err(|_| Error::from(ErrorKind::Other))?;
+        }
+    }
     let mut writers: Vec<NamedWriter> = options
         .files
         .clone()
@@ -286,11 +261,11 @@ fn process_error(
             Err(f)
         }
         Some(OutputErrorMode::ExitNoPipe) => {
-            if f.kind() != ErrorKind::BrokenPipe {
+            if f.kind() == ErrorKind::BrokenPipe {
+                Ok(())
+            } else {
                 show_error!("{}: {}", writer.name.maybe_quote(), f);
                 Err(f)
-            } else {
-                Ok(())
             }
         }
     }
diff --git a/src/uu/test/Cargo.toml b/src/uu/test/Cargo.toml
index 5e7d2e23a..3c2f27401 100644
--- a/src/uu/test/Cargo.toml
+++ b/src/uu/test/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_test"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "test ~ (uutils) evaluate comparison and file type expressions"
@@ -15,12 +15,12 @@ edition = "2021"
 path = "src/test.rs"
 
 [dependencies]
-clap = { workspace=true }
-libc = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+libc = { workspace = true }
+uucore = { workspace = true }
 
 [target.'cfg(target_os = "redox")'.dependencies]
-redox_syscall = { workspace=true }
+redox_syscall = { workspace = true }
 
 [[bin]]
 name = "test"
diff --git a/src/uu/test/src/error.rs b/src/uu/test/src/error.rs
new file mode 100644
index 000000000..ced4b216a
--- /dev/null
+++ b/src/uu/test/src/error.rs
@@ -0,0 +1,37 @@
+/// Represents an error encountered while parsing a test expression
+#[derive(Debug)]
+pub enum ParseError {
+    ExpectedValue,
+    Expected(String),
+    ExtraArgument(String),
+    MissingArgument(String),
+    UnknownOperator(String),
+    InvalidInteger(String),
+}
+
+/// A Result type for parsing test expressions
+pub type ParseResult<T> = Result<T, ParseError>;
+
+/// Implement Display trait for ParseError to make it easier to print useful errors.
+impl std::fmt::Display for ParseError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Expected(s) => write!(f, "expected {s}"),
+            Self::ExpectedValue => write!(f, "expected value"),
+            Self::MissingArgument(s) => write!(f, "missing argument after {s}"),
+            Self::ExtraArgument(s) => write!(f, "extra argument {s}"),
+            Self::UnknownOperator(s) => write!(f, "unknown operator {s}"),
+            Self::InvalidInteger(s) => write!(f, "invalid integer {s}"),
+        }
+    }
+}
+
+/// Implement UError trait for ParseError to make it easier to return useful error codes from main().
+impl uucore::error::UError for ParseError {
+    fn code(&self) -> i32 {
+        2
+    }
+}
+
+/// Implement standard Error trait for UError
+impl std::error::Error for ParseError {}
diff --git a/src/uu/test/src/parser.rs b/src/uu/test/src/parser.rs
index b76333930..db90098a1 100644
--- a/src/uu/test/src/parser.rs
+++ b/src/uu/test/src/parser.rs
@@ -7,11 +7,12 @@
 
 // spell-checker:ignore (grammar) BOOLOP STRLEN FILETEST FILEOP INTOP STRINGOP ; (vars) LParen StrlenOp
 
-use std::ffi::OsString;
+use std::ffi::{OsStr, OsString};
 use std::iter::Peekable;
 
+use super::error::{ParseError, ParseResult};
+
 use uucore::display::Quotable;
-use uucore::show_error;
 
 /// Represents one of the binary comparison operators for strings, integers, or files
 #[derive(Debug, PartialEq, Eq)]
@@ -90,6 +91,27 @@ impl Symbol {
     }
 }
 
+/// Implement Display trait for Symbol to make it easier to print useful errors.
+/// We will try to match the format in which the symbol appears in the input.
+impl std::fmt::Display for Symbol {
+    /// Format a Symbol for printing
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let s = match &self {
+            Self::LParen => OsStr::new("("),
+            Self::Bang => OsStr::new("!"),
+            Self::BoolOp(s)
+            | Self::Literal(s)
+            | Self::Op(Operator::String(s))
+            | Self::Op(Operator::Int(s))
+            | Self::Op(Operator::File(s))
+            | Self::UnaryOp(UnaryOperator::StrlenOp(s))
+            | Self::UnaryOp(UnaryOperator::FiletestOp(s)) => OsStr::new(s),
+            Self::None => OsStr::new("None"),
+        };
+        write!(f, "{}", s.quote())
+    }
+}
+
 /// Recursive descent parser for test, which converts a list of OsStrings
 /// (typically command line arguments) into a stack of Symbols in postfix
 /// order.
@@ -133,16 +155,10 @@ impl Parser {
     }
 
     /// Consume the next token & verify that it matches the provided value.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the next token does not match the provided value.
-    ///
-    /// TODO: remove panics and convert Parser to return error messages.
-    fn expect(&mut self, value: &str) {
+    fn expect(&mut self, value: &str) -> ParseResult<()> {
         match self.next_token() {
-            Symbol::Literal(s) if s == value => (),
-            _ => panic!("expected ‘{value}’"),
+            Symbol::Literal(s) if s == value => Ok(()),
+            _ => Err(ParseError::Expected(value.quote().to_string())),
         }
     }
 
@@ -162,25 +178,27 @@ impl Parser {
     /// Parse an expression.
     ///
     ///   EXPR → TERM | EXPR BOOLOP EXPR
-    fn expr(&mut self) {
+    fn expr(&mut self) -> ParseResult<()> {
         if !self.peek_is_boolop() {
-            self.term();
+            self.term()?;
         }
-        self.maybe_boolop();
+        self.maybe_boolop()?;
+        Ok(())
     }
 
     /// Parse a term token and possible subsequent symbols: "(", "!", UOP,
     /// literal, or None.
-    fn term(&mut self) {
+    fn term(&mut self) -> ParseResult<()> {
         let symbol = self.next_token();
 
         match symbol {
-            Symbol::LParen => self.lparen(),
-            Symbol::Bang => self.bang(),
+            Symbol::LParen => self.lparen()?,
+            Symbol::Bang => self.bang()?,
             Symbol::UnaryOp(_) => self.uop(symbol),
             Symbol::None => self.stack.push(symbol),
-            literal => self.literal(literal),
+            literal => self.literal(literal)?,
         }
+        Ok(())
     }
 
     /// Parse a (possibly) parenthesized expression.
@@ -192,7 +210,7 @@ impl Parser {
     /// * when followed by a binary operator that is not _itself_ interpreted
     ///   as a literal
     ///
-    fn lparen(&mut self) {
+    fn lparen(&mut self) -> ParseResult<()> {
         // Look ahead up to 3 tokens to determine if the lparen is being used
         // as a grouping operator or should be treated as a literal string
         let peek3: Vec<Symbol> = self
@@ -204,13 +222,13 @@ impl Parser {
 
         match peek3.as_slice() {
             // case 1: lparen is a literal when followed by nothing
-            [] => self.literal(Symbol::LParen.into_literal()),
+            [] => {
+                self.literal(Symbol::LParen.into_literal())?;
+                Ok(())
+            }
 
             // case 2: error if end of stream is `( <any_token>`
-            [symbol] => {
-                show_error!("missing argument after ‘{:?}’", symbol);
-                std::process::exit(2);
-            }
+            [symbol] => Err(ParseError::MissingArgument(format!("{symbol}"))),
 
             // case 3: `( uop <any_token> )` → parenthesized unary operation;
             //         this case ensures we don’t get confused by `( -f ) )`
@@ -218,43 +236,49 @@ impl Parser {
             [Symbol::UnaryOp(_), _, Symbol::Literal(s)] if s == ")" => {
                 let symbol = self.next_token();
                 self.uop(symbol);
-                self.expect(")");
+                self.expect(")")?;
+                Ok(())
             }
 
             // case 4: binary comparison of literal lparen, e.g. `( != )`
             [Symbol::Op(_), Symbol::Literal(s)] | [Symbol::Op(_), Symbol::Literal(s), _]
                 if s == ")" =>
             {
-                self.literal(Symbol::LParen.into_literal());
+                self.literal(Symbol::LParen.into_literal())?;
+                Ok(())
             }
 
             // case 5: after handling the prior cases, any single token inside
             //         parentheses is a literal, e.g. `( -f )`
             [_, Symbol::Literal(s)] | [_, Symbol::Literal(s), _] if s == ")" => {
                 let symbol = self.next_token();
-                self.literal(symbol);
-                self.expect(")");
+                self.literal(symbol)?;
+                self.expect(")")?;
+                Ok(())
             }
 
             // case 6: two binary ops in a row, treat the first op as a literal
             [Symbol::Op(_), Symbol::Op(_), _] => {
                 let symbol = self.next_token();
-                self.literal(symbol);
-                self.expect(")");
+                self.literal(symbol)?;
+                self.expect(")")?;
+                Ok(())
             }
 
             // case 7: if earlier cases didn’t match, `( op <any_token>…`
             //         indicates binary comparison of literal lparen with
             //         anything _except_ ")" (case 4)
             [Symbol::Op(_), _] | [Symbol::Op(_), _, _] => {
-                self.literal(Symbol::LParen.into_literal());
+                self.literal(Symbol::LParen.into_literal())?;
+                Ok(())
             }
 
             // Otherwise, lparen indicates the start of a parenthesized
             // expression
             _ => {
-                self.expr();
-                self.expect(")");
+                self.expr()?;
+                self.expect(")")?;
+                Ok(())
             }
         }
     }
@@ -276,7 +300,7 @@ impl Parser {
     /// * `! str BOOLOP str`: negate the entire Boolean expression
     /// * `! str BOOLOP EXPR BOOLOP EXPR`: negate the value of the first `str` term
     ///
-    fn bang(&mut self) {
+    fn bang(&mut self) -> ParseResult<()> {
         match self.peek() {
             Symbol::Op(_) | Symbol::BoolOp(_) => {
                 // we need to peek ahead one more token to disambiguate the first
@@ -289,14 +313,14 @@ impl Parser {
                     Symbol::Op(_) | Symbol::None => {
                         // op is literal
                         let op = self.next_token().into_literal();
-                        self.literal(op);
+                        self.literal(op)?;
                         self.stack.push(Symbol::Bang);
                     }
                     // case 2: `<! as literal> OP str [BOOLOP EXPR]`.
                     _ => {
                         // bang is literal; parsing continues with op
-                        self.literal(Symbol::Bang.into_literal());
-                        self.maybe_boolop();
+                        self.literal(Symbol::Bang.into_literal())?;
+                        self.maybe_boolop()?;
                     }
                 }
             }
@@ -317,32 +341,34 @@ impl Parser {
                 match peek4.as_slice() {
                     // we peeked ahead 4 but there were only 3 tokens left
                     [Symbol::Literal(_), Symbol::BoolOp(_), Symbol::Literal(_)] => {
-                        self.expr();
+                        self.expr()?;
                         self.stack.push(Symbol::Bang);
                     }
                     _ => {
-                        self.term();
+                        self.term()?;
                         self.stack.push(Symbol::Bang);
                     }
                 }
             }
         }
+        Ok(())
     }
 
     /// Peek at the next token and parse it as a BOOLOP or string literal,
     /// as appropriate.
-    fn maybe_boolop(&mut self) {
+    fn maybe_boolop(&mut self) -> ParseResult<()> {
         if self.peek_is_boolop() {
             let symbol = self.next_token();
 
             // BoolOp by itself interpreted as Literal
             if let Symbol::None = self.peek() {
-                self.literal(symbol.into_literal());
+                self.literal(symbol.into_literal())?;
             } else {
-                self.boolop(symbol);
-                self.maybe_boolop();
+                self.boolop(symbol)?;
+                self.maybe_boolop()?;
             }
         }
+        Ok(())
     }
 
     /// Parse a Boolean expression.
@@ -350,13 +376,14 @@ impl Parser {
     /// Logical and (-a) has higher precedence than or (-o), so in an
     /// expression like `foo -o '' -a ''`, the and subexpression is evaluated
     /// first.
-    fn boolop(&mut self, op: Symbol) {
+    fn boolop(&mut self, op: Symbol) -> ParseResult<()> {
         if op == Symbol::BoolOp(OsString::from("-a")) {
-            self.term();
+            self.term()?;
         } else {
-            self.expr();
+            self.expr()?;
         }
         self.stack.push(op);
+        Ok(())
     }
 
     /// Parse a (possible) unary argument test (string length or file
@@ -375,7 +402,7 @@ impl Parser {
 
     /// Parse a string literal, optionally followed by a comparison operator
     /// and a second string literal.
-    fn literal(&mut self, token: Symbol) {
+    fn literal(&mut self, token: Symbol) -> ParseResult<()> {
         self.stack.push(token.into_literal());
 
         // EXPR → str OP str
@@ -383,21 +410,24 @@ impl Parser {
             let op = self.next_token();
 
             match self.next_token() {
-                Symbol::None => panic!("missing argument after {op:?}"),
+                Symbol::None => {
+                    return Err(ParseError::MissingArgument(format!("{op}")));
+                }
                 token => self.stack.push(token.into_literal()),
             }
 
             self.stack.push(op);
         }
+        Ok(())
     }
 
     /// Parser entry point: parse the token stream `self.tokens`, storing the
     /// resulting `Symbol` stack in `self.stack`.
-    fn parse(&mut self) -> Result<(), String> {
-        self.expr();
+    fn parse(&mut self) -> ParseResult<()> {
+        self.expr()?;
 
         match self.tokens.next() {
-            Some(token) => Err(format!("extra argument {}", token.quote())),
+            Some(token) => Err(ParseError::ExtraArgument(token.quote().to_string())),
             None => Ok(()),
         }
     }
@@ -405,7 +435,7 @@ impl Parser {
 
 /// Parse the token stream `args`, returning a `Symbol` stack representing the
 /// operations to perform in postfix order.
-pub fn parse(args: Vec<OsString>) -> Result<Vec<Symbol>, String> {
+pub fn parse(args: Vec<OsString>) -> ParseResult<Vec<Symbol>> {
     let mut p = Parser::new(args);
     p.parse()?;
     Ok(p.stack)
diff --git a/src/uu/test/src/test.rs b/src/uu/test/src/test.rs
index 8ce4564a3..b0a8fc613 100644
--- a/src/uu/test/src/test.rs
+++ b/src/uu/test/src/test.rs
@@ -8,9 +8,11 @@
 
 // spell-checker:ignore (vars) egid euid FiletestOp StrlenOp
 
+pub(crate) mod error;
 mod parser;
 
 use clap::{crate_version, Command};
+use error::{ParseError, ParseResult};
 use parser::{parse, Operator, Symbol, UnaryOperator};
 use std::ffi::{OsStr, OsString};
 use std::fs;
@@ -18,82 +20,27 @@ use std::fs;
 use std::os::unix::fs::MetadataExt;
 use uucore::display::Quotable;
 use uucore::error::{UResult, USimpleError};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_section};
 
+const ABOUT: &str = help_about!("test.md");
+
+// The help_usage method replaces util name (the first word) with {}.
+// And, The format_usage method replaces {} with execution_phrase ( e.g. test or [ ).
+// However, This test command has two util names.
+// So, we use test or [ instead of {} so that the usage string is correct.
 const USAGE: &str = "\
-    {} EXPRESSION
-    {}
-    [ EXPRESSION ]
-    [ ]
-    [ OPTION";
+test EXPRESSION
+test
+[ EXPRESSION ]
+[ ]
+[ OPTION";
 
 // We use after_help so that this comes after the usage string (it would come before if we used about)
-const AFTER_HELP: &str = "
-Exit with the status determined by EXPRESSION.
-
-An omitted EXPRESSION defaults to false.  Otherwise,
-EXPRESSION is true or false and sets exit status.  It is one of:
-
-  ( EXPRESSION )               EXPRESSION is true
-  ! EXPRESSION                 EXPRESSION is false
-  EXPRESSION1 -a EXPRESSION2   both EXPRESSION1 and EXPRESSION2 are true
-  EXPRESSION1 -o EXPRESSION2   either EXPRESSION1 or EXPRESSION2 is true
-
-  -n STRING            the length of STRING is nonzero
-  STRING               equivalent to -n STRING
-  -z STRING            the length of STRING is zero
-  STRING1 = STRING2    the strings are equal
-  STRING1 != STRING2   the strings are not equal
-
-  INTEGER1 -eq INTEGER2   INTEGER1 is equal to INTEGER2
-  INTEGER1 -ge INTEGER2   INTEGER1 is greater than or equal to INTEGER2
-  INTEGER1 -gt INTEGER2   INTEGER1 is greater than INTEGER2
-  INTEGER1 -le INTEGER2   INTEGER1 is less than or equal to INTEGER2
-  INTEGER1 -lt INTEGER2   INTEGER1 is less than INTEGER2
-  INTEGER1 -ne INTEGER2   INTEGER1 is not equal to INTEGER2
-
-  FILE1 -ef FILE2   FILE1 and FILE2 have the same device and inode numbers
-  FILE1 -nt FILE2   FILE1 is newer (modification date) than FILE2
-  FILE1 -ot FILE2   FILE1 is older than FILE2
-
-  -b FILE     FILE exists and is block special
-  -c FILE     FILE exists and is character special
-  -d FILE     FILE exists and is a directory
-  -e FILE     FILE exists
-  -f FILE     FILE exists and is a regular file
-  -g FILE     FILE exists and is set-group-ID
-  -G FILE     FILE exists and is owned by the effective group ID
-  -h FILE     FILE exists and is a symbolic link (same as -L)
-  -k FILE     FILE exists and has its sticky bit set
-  -L FILE     FILE exists and is a symbolic link (same as -h)
-  -N FILE     FILE exists and has been modified since it was last read
-  -O FILE     FILE exists and is owned by the effective user ID
-  -p FILE     FILE exists and is a named pipe
-  -r FILE     FILE exists and read permission is granted
-  -s FILE     FILE exists and has a size greater than zero
-  -S FILE     FILE exists and is a socket
-  -t FD       file descriptor FD is opened on a terminal
-  -u FILE     FILE exists and its set-user-ID bit is set
-  -w FILE     FILE exists and write permission is granted
-  -x FILE     FILE exists and execute (or search) permission is granted
-
-Except for -h and -L, all FILE-related tests dereference symbolic links.
-Beware that parentheses need to be escaped (e.g., by backslashes) for shells.
-INTEGER may also be -l STRING, which evaluates to the length of STRING.
-
-NOTE: Binary -a and -o are inherently ambiguous.  Use 'test EXPR1 && test
-EXPR2' or 'test EXPR1 || test EXPR2' instead.
-
-NOTE: [ honors the --help and --version options, but test does not.
-test treats each of those as it treats any other nonempty STRING.
-
-NOTE: your shell may have its own version of test and/or [, which usually supersedes
-the version described here.  Please refer to your shell's documentation
-for details about the options it supports.";
-
-const ABOUT: &str = "Check file types and compare values.";
+const AFTER_HELP: &str = help_section!("after help", "test.md");
 
 pub fn uu_app() -> Command {
+    // Disable printing of -h and -v as valid alternatives for --help and --version,
+    // since we don't recognize -h and -v as help/version flags.
     Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
@@ -110,15 +57,7 @@ pub fn uumain(mut args: impl uucore::Args) -> UResult<()> {
     if binary_name.ends_with('[') {
         // If invoked as [ we should recognize --help and --version (but not -h or -v)
         if args.len() == 1 && (args[0] == "--help" || args[0] == "--version") {
-            // Let clap pretty-print help and version
-            Command::new(binary_name)
-                .version(crate_version!())
-                .about(ABOUT)
-                .override_usage(format_usage(USAGE))
-                .after_help(AFTER_HELP)
-                // Disable printing of -h and -v as valid alternatives for --help and --version,
-                // since we don't recognize -h and -v as help/version flags.
-                .get_matches_from(std::iter::once(program).chain(args.into_iter()));
+            uu_app().get_matches_from(std::iter::once(program).chain(args.into_iter()));
             return Ok(());
         }
         // If invoked via name '[', matching ']' must be in the last arg
@@ -128,23 +67,18 @@ pub fn uumain(mut args: impl uucore::Args) -> UResult<()> {
         }
     }
 
-    let result = parse(args).and_then(|mut stack| eval(&mut stack));
+    let result = parse(args).map(|mut stack| eval(&mut stack))??;
 
-    match result {
-        Ok(result) => {
-            if result {
-                Ok(())
-            } else {
-                Err(1.into())
-            }
-        }
-        Err(e) => Err(USimpleError::new(2, e)),
+    if result {
+        Ok(())
+    } else {
+        Err(1.into())
     }
 }
 
 /// Evaluate a stack of Symbols, returning the result of the evaluation or
 /// an error message if evaluation failed.
-fn eval(stack: &mut Vec<Symbol>) -> Result<bool, String> {
+fn eval(stack: &mut Vec<Symbol>) -> ParseResult<bool> {
     macro_rules! pop_literal {
         () => {
             match stack.pop() {
@@ -186,7 +120,7 @@ fn eval(stack: &mut Vec<Symbol>) -> Result<bool, String> {
                     return Ok(true);
                 }
                 _ => {
-                    return Err(format!("missing argument after '{op:?}'"));
+                    return Err(ParseError::MissingArgument(op.quote().to_string()));
                 }
             };
 
@@ -233,7 +167,7 @@ fn eval(stack: &mut Vec<Symbol>) -> Result<bool, String> {
 
             Ok(if op == "-a" { a && b } else { a || b })
         }
-        _ => Err("expected value".to_string()),
+        _ => Err(ParseError::ExpectedValue),
     }
 }
 
@@ -241,19 +175,17 @@ fn eval(stack: &mut Vec<Symbol>) -> Result<bool, String> {
 /// `a` is the left hand side
 /// `b` is the left hand side
 /// `op` the operation (ex: -eq, -lt, etc)
-fn integers(a: &OsStr, b: &OsStr, op: &OsStr) -> Result<bool, String> {
-    let format_err = |value: &OsStr| format!("invalid integer {}", value.quote());
-
+fn integers(a: &OsStr, b: &OsStr, op: &OsStr) -> ParseResult<bool> {
     // Parse the two inputs
     let a: i128 = a
         .to_str()
         .and_then(|s| s.parse().ok())
-        .ok_or_else(|| format_err(a))?;
+        .ok_or_else(|| ParseError::InvalidInteger(a.quote().to_string()))?;
 
     let b: i128 = b
         .to_str()
         .and_then(|s| s.parse().ok())
-        .ok_or_else(|| format_err(b))?;
+        .ok_or_else(|| ParseError::InvalidInteger(b.quote().to_string()))?;
 
     // Do the maths
     Ok(match op.to_str() {
@@ -263,7 +195,7 @@ fn integers(a: &OsStr, b: &OsStr, op: &OsStr) -> Result<bool, String> {
         Some("-ge") => a >= b,
         Some("-lt") => a < b,
         Some("-le") => a <= b,
-        _ => return Err(format!("unknown operator {}", op.quote())),
+        _ => return Err(ParseError::UnknownOperator(op.quote().to_string())),
     })
 }
 
@@ -271,7 +203,7 @@ fn integers(a: &OsStr, b: &OsStr, op: &OsStr) -> Result<bool, String> {
 /// `a` is the left hand side
 /// `b` is the left hand side
 /// `op` the operation (ex: -ef, -nt, etc)
-fn files(a: &OsStr, b: &OsStr, op: &OsStr) -> Result<bool, String> {
+fn files(a: &OsStr, b: &OsStr, op: &OsStr) -> ParseResult<bool> {
     // Don't manage the error. GNU doesn't show error when doing
     // test foo -nt bar
     let f_a = match fs::metadata(a) {
@@ -290,14 +222,14 @@ fn files(a: &OsStr, b: &OsStr, op: &OsStr) -> Result<bool, String> {
         Some("-ef") => unimplemented!(),
         Some("-nt") => f_a.modified().unwrap() > f_b.modified().unwrap(),
         Some("-ot") => f_a.created().unwrap() > f_b.created().unwrap(),
-        _ => return Err(format!("unknown operator {}", op.quote())),
+        _ => return Err(ParseError::UnknownOperator(op.quote().to_string())),
     })
 }
 
-fn isatty(fd: &OsStr) -> Result<bool, String> {
+fn isatty(fd: &OsStr) -> ParseResult<bool> {
     fd.to_str()
         .and_then(|s| s.parse().ok())
-        .ok_or_else(|| format!("invalid integer {}", fd.quote()))
+        .ok_or_else(|| ParseError::InvalidInteger(fd.quote().to_string()))
         .map(|i| {
             #[cfg(not(target_os = "redox"))]
             unsafe {
diff --git a/src/uu/test/test.md b/src/uu/test/test.md
new file mode 100644
index 000000000..e67eb1824
--- /dev/null
+++ b/src/uu/test/test.md
@@ -0,0 +1,79 @@
+# test
+
+```
+test EXPRESSION
+test
+[ EXPRESSION ]
+[ ]
+[ OPTION
+```
+
+Check file types and compare values.
+
+## After Help
+
+Exit with the status determined by `EXPRESSION`.
+
+An omitted `EXPRESSION` defaults to false.
+Otherwise, `EXPRESSION` is true or false and sets exit status. 
+
+It is one of:
+
+* ( EXPRESSION )               `EXPRESSION` is true
+* ! EXPRESSION                 `EXPRESSION` is false
+* EXPRESSION1 -a EXPRESSION2   both `EXPRESSION1` and `EXPRESSION2` are true
+* EXPRESSION1 -o EXPRESSION2   either `EXPRESSION1` or `EXPRESSION2` is true
+
+String operations:
+* -n STRING            the length of `STRING` is nonzero
+* STRING               equivalent to -n `STRING`
+* -z STRING            the length of `STRING` is zero
+* STRING1 = STRING2    the strings are equal
+* STRING1 != STRING2   the strings are not equal
+
+Integer comparisons:
+* INTEGER1 -eq INTEGER2   `INTEGER1` is equal to `INTEGER2`
+* INTEGER1 -ge INTEGER2   `INTEGER1` is greater than or equal to `INTEGER2`
+* INTEGER1 -gt INTEGER2   `INTEGER1` is greater than `INTEGER2`
+* INTEGER1 -le INTEGER2   `INTEGER1` is less than or equal to `INTEGER2`
+* INTEGER1 -lt INTEGER2   `INTEGER1` is less than `INTEGER2`
+* INTEGER1 -ne INTEGER2   `INTEGER1` is not equal to `INTEGER2`
+
+File operations:
+* FILE1 -ef FILE2   `FILE1` and `FILE2` have the same device and inode numbers
+* FILE1 -nt FILE2   `FILE1` is newer (modification date) than `FILE2`
+* FILE1 -ot FILE2   `FILE1` is older than `FILE2`
+
+* -b FILE     `FILE` exists and is block special
+* -c FILE     `FILE` exists and is character special
+* -d FILE     `FILE` exists and is a directory
+* -e FILE     `FILE` exists
+* -f FILE     `FILE` exists and is a regular file
+* -g FILE     `FILE` exists and is set-group-ID
+* -G FILE     `FILE` exists and is owned by the effective group ID
+* -h FILE     `FILE` exists and is a symbolic link (same as -L)
+* -k FILE     `FILE` exists and has its sticky bit set
+* -L FILE     `FILE` exists and is a symbolic link (same as -h)
+* -N FILE     `FILE` exists and has been modified since it was last read
+* -O FILE     `FILE` exists and is owned by the effective user ID
+* -p FILE     `FILE` exists and is a named pipe
+* -r FILE     `FILE` exists and read permission is granted
+* -s FILE     `FILE` exists and has a size greater than zero
+* -S FILE     `FILE` exists and is a socket
+* -t FD       `file` descriptor `FD` is opened on a terminal
+* -u FILE     `FILE` exists and its set-user-ID bit is set
+* -w FILE     `FILE` exists and write permission is granted
+* -x FILE     `FILE` exists and execute (or search) permission is granted
+
+Except for `-h` and `-L`, all FILE-related tests dereference (follow) symbolic links.
+Beware that parentheses need to be escaped (e.g., by backslashes) for shells.
+`INTEGER` may also be -l `STRING`, which evaluates to the length of `STRING`.
+
+NOTE: Binary `-a` and `-o` are inherently ambiguous.
+Use `test EXPR1 && test EXPR2` or `test EXPR1 || test EXPR2` instead.
+
+NOTE: `[` honors the `--help` and `--version` options, but test does not.
+test treats each of those as it treats any other nonempty `STRING`.
+
+NOTE: your shell may have its own version of `test` and/or `[`, which usually supersedes the version described here.
+Please refer to your shell's documentation for details about the options it supports.
diff --git a/src/uu/timeout/Cargo.toml b/src/uu/timeout/Cargo.toml
index b19a2e999..43cadf3e5 100644
--- a/src/uu/timeout/Cargo.toml
+++ b/src/uu/timeout/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_timeout"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "timeout ~ (uutils) run COMMAND with a DURATION time limit"
@@ -15,10 +15,10 @@ edition = "2021"
 path = "src/timeout.rs"
 
 [dependencies]
-clap = { workspace=true }
-libc = { workspace=true }
-nix = { workspace=true, features = ["signal"] }
-uucore = { workspace=true, features=["process", "signals"] }
+clap = { workspace = true }
+libc = { workspace = true }
+nix = { workspace = true, features = ["signal"] }
+uucore = { workspace = true, features = ["process", "signals"] }
 
 [[bin]]
 name = "timeout"
diff --git a/src/uu/timeout/src/timeout.rs b/src/uu/timeout/src/timeout.rs
index 26235e0df..531f29e82 100644
--- a/src/uu/timeout/src/timeout.rs
+++ b/src/uu/timeout/src/timeout.rs
@@ -17,11 +17,17 @@ use std::time::Duration;
 use uucore::display::Quotable;
 use uucore::error::{UClapError, UResult, USimpleError, UUsageError};
 use uucore::process::ChildExt;
-use uucore::signals::{signal_by_name_or_value, signal_name_by_value};
-use uucore::{format_usage, show_error};
 
-static ABOUT: &str = "Start COMMAND, and kill it if still running after DURATION.";
-const USAGE: &str = "{} [OPTION] DURATION COMMAND...";
+#[cfg(unix)]
+use uucore::signals::enable_pipe_errors;
+
+use uucore::{
+    format_usage, help_about, help_usage, show_error,
+    signals::{signal_by_name_or_value, signal_name_by_value},
+};
+
+const ABOUT: &str = help_about!("timeout.md");
+const USAGE: &str = help_usage!("timeout.md");
 
 pub mod options {
     pub static FOREGROUND: &str = "foreground";
@@ -196,6 +202,22 @@ fn report_if_verbose(signal: usize, cmd: &str, verbose: bool) {
     }
 }
 
+fn send_signal(process: &mut Child, signal: usize, foreground: bool) {
+    // NOTE: GNU timeout doesn't check for errors of signal.
+    // The subprocess might have exited just after the timeout.
+    // Sending a signal now would return "No such process", but we should still try to kill the children.
+    _ = process.send_signal(signal);
+    if !foreground {
+        _ = process.send_signal_group(signal);
+        let kill_signal = signal_by_name_or_value("KILL").unwrap();
+        let continued_signal = signal_by_name_or_value("CONT").unwrap();
+        if signal != kill_signal && signal != continued_signal {
+            _ = process.send_signal(continued_signal);
+            _ = process.send_signal_group(continued_signal);
+        }
+    }
+}
+
 /// Wait for a child process and send a kill signal if it does not terminate.
 ///
 /// This function waits for the child `process` for the time period
@@ -217,10 +239,11 @@ fn report_if_verbose(signal: usize, cmd: &str, verbose: bool) {
 /// If there is a problem sending the `SIGKILL` signal or waiting for
 /// the process after that signal is sent.
 fn wait_or_kill_process(
-    mut process: Child,
+    process: &mut Child,
     cmd: &str,
     duration: Duration,
     preserve_status: bool,
+    foreground: bool,
     verbose: bool,
 ) -> std::io::Result<i32> {
     match process.wait_or_timeout(duration) {
@@ -234,7 +257,7 @@ fn wait_or_kill_process(
         Ok(None) => {
             let signal = signal_by_name_or_value("KILL").unwrap();
             report_if_verbose(signal, cmd, verbose);
-            process.send_signal(signal)?;
+            send_signal(process, signal, foreground);
             process.wait()?;
             Ok(ExitStatus::SignalSent(signal).into())
         }
@@ -268,21 +291,6 @@ fn preserve_signal_info(signal: libc::c_int) -> libc::c_int {
     signal
 }
 
-#[cfg(unix)]
-fn enable_pipe_errors() -> std::io::Result<()> {
-    let ret = unsafe { libc::signal(libc::SIGPIPE, libc::SIG_DFL) };
-    if ret == libc::SIG_ERR {
-        return Err(std::io::Error::new(std::io::ErrorKind::Other, ""));
-    }
-    Ok(())
-}
-
-#[cfg(not(unix))]
-fn enable_pipe_errors() -> std::io::Result<()> {
-    // Do nothing.
-    Ok(())
-}
-
 /// TODO: Improve exit codes, and make them consistent with the GNU Coreutils exit codes.
 
 fn timeout(
@@ -297,10 +305,10 @@ fn timeout(
     if !foreground {
         unsafe { libc::setpgid(0, 0) };
     }
-
+    #[cfg(unix)]
     enable_pipe_errors()?;
 
-    let mut process = process::Command::new(&cmd[0])
+    let process = &mut process::Command::new(&cmd[0])
         .args(&cmd[1..])
         .stdin(Stdio::inherit())
         .stdout(Stdio::inherit())
@@ -335,7 +343,7 @@ fn timeout(
             .into()),
         Ok(None) => {
             report_if_verbose(signal, &cmd[0], verbose);
-            process.send_signal(signal)?;
+            send_signal(process, signal, foreground);
             match kill_after {
                 None => {
                     if preserve_status {
@@ -350,6 +358,7 @@ fn timeout(
                         &cmd[0],
                         kill_after,
                         preserve_status,
+                        foreground,
                         verbose,
                     ) {
                         Ok(status) => Err(status.into()),
@@ -363,11 +372,8 @@ fn timeout(
         }
         Err(_) => {
             // We're going to return ERR_EXIT_STATUS regardless of
-            // whether `send_signal()` succeeds or fails, so just
-            // ignore the return value.
-            process
-                .send_signal(signal)
-                .map_err(|e| USimpleError::new(ExitStatus::TimeoutFailed.into(), format!("{e}")))?;
+            // whether `send_signal()` succeeds or fails
+            send_signal(process, signal, foreground);
             Err(ExitStatus::TimeoutFailed.into())
         }
     }
diff --git a/src/uu/timeout/timeout.md b/src/uu/timeout/timeout.md
new file mode 100644
index 000000000..f992ab327
--- /dev/null
+++ b/src/uu/timeout/timeout.md
@@ -0,0 +1,7 @@
+# timeout
+
+```
+timeout [OPTION] DURATION COMMAND...
+```
+
+Start `COMMAND`, and kill it if still running after `DURATION`.
diff --git a/src/uu/touch/Cargo.toml b/src/uu/touch/Cargo.toml
index 1fad22c02..f90725197 100644
--- a/src/uu/touch/Cargo.toml
+++ b/src/uu/touch/Cargo.toml
@@ -1,6 +1,7 @@
+# spell-checker:ignore humantime
 [package]
 name = "uu_touch"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "touch ~ (uutils) change FILE timestamps"
@@ -15,13 +16,23 @@ edition = "2021"
 path = "src/touch.rs"
 
 [dependencies]
-filetime = { workspace=true }
-clap = { workspace=true }
-time = { workspace=true, features = ["parsing", "formatting", "local-offset", "macros"] }
-uucore = { workspace=true, features=["libc"] }
+filetime = { workspace = true }
+clap = { workspace = true }
+# TODO: use workspace dependency (0.3) when switching from time to chrono
+humantime_to_duration = "0.2.1"
+time = { workspace = true, features = [
+  "parsing",
+  "formatting",
+  "local-offset",
+  "macros",
+] }
+uucore = { workspace = true, features = ["libc"] }
 
 [target.'cfg(target_os = "windows")'.dependencies]
-windows-sys = { workspace=true, features = ["Win32_Storage_FileSystem", "Win32_Foundation"] }
+windows-sys = { workspace = true, features = [
+  "Win32_Storage_FileSystem",
+  "Win32_Foundation",
+] }
 
 [[bin]]
 name = "touch"
diff --git a/src/uu/touch/src/touch.rs b/src/uu/touch/src/touch.rs
index a7d3557bd..55663fdab 100644
--- a/src/uu/touch/src/touch.rs
+++ b/src/uu/touch/src/touch.rs
@@ -6,12 +6,11 @@
 // For the full copyright and license information, please view the LICENSE file
 // that was distributed with this source code.
 
-// spell-checker:ignore (ToDO) filetime strptime utcoff strs datetime MMDDhhmm clapv PWSTR lpszfilepath hresult mktime YYYYMMDDHHMM YYMMDDHHMM DATETIME YYYYMMDDHHMMS subsecond
-pub extern crate filetime;
+// spell-checker:ignore (ToDO) filetime strptime utcoff strs datetime MMDDhhmm clapv PWSTR lpszfilepath hresult mktime YYYYMMDDHHMM YYMMDDHHMM DATETIME YYYYMMDDHHMMS subsecond humantime
 
 use clap::builder::ValueParser;
 use clap::{crate_version, Arg, ArgAction, ArgGroup, Command};
-use filetime::*;
+use filetime::{set_symlink_file_times, FileTime};
 use std::ffi::OsString;
 use std::fs::{self, File};
 use std::path::{Path, PathBuf};
@@ -19,10 +18,11 @@ use time::macros::{format_description, offset, time};
 use time::Duration;
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UError, UResult, USimpleError};
-use uucore::{format_usage, show};
+use uucore::{format_usage, help_about, help_usage, show};
+
+const ABOUT: &str = help_about!("touch.md");
+const USAGE: &str = help_usage!("touch.md");
 
-static ABOUT: &str = "Update the access and modification times of each FILE to the current time.";
-const USAGE: &str = "{} [OPTION]... [USER]";
 pub mod options {
     // Both SOURCES and sources are needed as we need to be able to refer to the ArgGroup.
     pub static SOURCES: &str = "sources";
@@ -65,6 +65,7 @@ fn dt_to_filename(tm: time::PrimitiveDateTime) -> FileTime {
 }
 
 #[uucore::main]
+#[allow(clippy::cognitive_complexity)]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app().try_get_matches_from(args)?;
 
@@ -77,19 +78,57 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             ),
         )
     })?;
-    let (mut atime, mut mtime) =
-        if let Some(reference) = matches.get_one::<OsString>(options::sources::REFERENCE) {
-            stat(Path::new(reference), !matches.get_flag(options::NO_DEREF))?
-        } else {
-            let timestamp = if let Some(date) = matches.get_one::<String>(options::sources::DATE) {
-                parse_date(date)?
-            } else if let Some(current) = matches.get_one::<String>(options::sources::CURRENT) {
-                parse_timestamp(current)?
+    let (mut atime, mut mtime) = match (
+        matches.get_one::<OsString>(options::sources::REFERENCE),
+        matches.get_one::<String>(options::sources::DATE),
+    ) {
+        (Some(reference), Some(date)) => {
+            let (atime, mtime) = stat(Path::new(reference), !matches.get_flag(options::NO_DEREF))?;
+            if let Ok(offset) = humantime_to_duration::from_str(date) {
+                let mut seconds = offset.whole_seconds();
+                let mut nanos = offset.subsec_nanoseconds();
+                if nanos < 0 {
+                    nanos += 1_000_000_000;
+                    seconds -= 1;
+                }
+
+                let ref_atime_secs = atime.unix_seconds();
+                let ref_atime_nanos = atime.nanoseconds();
+                let atime = FileTime::from_unix_time(
+                    ref_atime_secs + seconds,
+                    ref_atime_nanos + nanos as u32,
+                );
+
+                let ref_mtime_secs = mtime.unix_seconds();
+                let ref_mtime_nanos = mtime.nanoseconds();
+                let mtime = FileTime::from_unix_time(
+                    ref_mtime_secs + seconds,
+                    ref_mtime_nanos + nanos as u32,
+                );
+
+                (atime, mtime)
             } else {
-                local_dt_to_filetime(time::OffsetDateTime::now_local().unwrap())
-            };
+                let timestamp = parse_date(date)?;
+                (timestamp, timestamp)
+            }
+        }
+        (Some(reference), None) => {
+            stat(Path::new(reference), !matches.get_flag(options::NO_DEREF))?
+        }
+        (None, Some(date)) => {
+            let timestamp = parse_date(date)?;
             (timestamp, timestamp)
-        };
+        }
+        (None, None) => {
+            let timestamp =
+                if let Some(current) = matches.get_one::<String>(options::sources::CURRENT) {
+                    parse_timestamp(current)?
+                } else {
+                    local_dt_to_filetime(time::OffsetDateTime::now_local().unwrap())
+                };
+            (timestamp, timestamp)
+        }
+    };
 
     for filename in files {
         // FIXME: find a way to avoid having to clone the path
@@ -101,7 +140,13 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
         let path = pathbuf.as_path();
 
-        if let Err(e) = path.metadata() {
+        let metadata_result = if matches.get_flag(options::NO_DEREF) {
+            path.symlink_metadata()
+        } else {
+            path.metadata()
+        };
+
+        if let Err(e) = metadata_result {
             if e.kind() != std::io::ErrorKind::NotFound {
                 return Err(e.map_err_context(|| format!("setting times of {}", filename.quote())));
             }
@@ -160,14 +205,21 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             }
         }
 
-        if matches.get_flag(options::NO_DEREF) {
+        // sets the file access and modification times for a file or a symbolic link.
+        // The filename, access time (atime), and modification time (mtime) are provided as inputs.
+
+        // If the filename is not "-", indicating a special case for touch -h -,
+        // the code checks if the NO_DEREF flag is set, which means the user wants to
+        // set the times for a symbolic link itself, rather than the file it points to.
+        if filename == "-" {
+            filetime::set_file_times(path, atime, mtime)
+        } else if matches.get_flag(options::NO_DEREF) {
             set_symlink_file_times(path, atime, mtime)
         } else {
             filetime::set_file_times(path, atime, mtime)
         }
         .map_err_context(|| format!("setting times of {}", path.quote()))?;
     }
-
     Ok(())
 }
 
@@ -202,7 +254,8 @@ pub fn uu_app() -> Command {
                 .long(options::sources::DATE)
                 .allow_hyphen_values(true)
                 .help("parse argument and use it instead of current time")
-                .value_name("STRING"),
+                .value_name("STRING")
+                .conflicts_with(options::sources::CURRENT),
         )
         .arg(
             Arg::new(options::MODIFICATION)
@@ -234,7 +287,8 @@ pub fn uu_app() -> Command {
                 .help("use this file's times instead of the current time")
                 .value_name("FILE")
                 .value_parser(ValueParser::os_string())
-                .value_hint(clap::ValueHint::AnyPath),
+                .value_hint(clap::ValueHint::AnyPath)
+                .conflicts_with(options::sources::CURRENT),
         )
         .arg(
             Arg::new(options::TIME)
@@ -254,20 +308,27 @@ pub fn uu_app() -> Command {
                 .value_parser(ValueParser::os_string())
                 .value_hint(clap::ValueHint::AnyPath),
         )
-        .group(ArgGroup::new(options::SOURCES).args([
-            options::sources::CURRENT,
-            options::sources::DATE,
-            options::sources::REFERENCE,
-        ]))
+        .group(
+            ArgGroup::new(options::SOURCES)
+                .args([
+                    options::sources::CURRENT,
+                    options::sources::DATE,
+                    options::sources::REFERENCE,
+                ])
+                .multiple(true),
+        )
 }
 
+// Get metadata of the provided path
+// If `follow` is `true`, the function will try to follow symlinks
+// If `follow` is `false` or the symlink is broken, the function will return metadata of the symlink itself
 fn stat(path: &Path, follow: bool) -> UResult<(FileTime, FileTime)> {
-    let metadata = if follow {
-        fs::symlink_metadata(path)
-    } else {
-        fs::metadata(path)
-    }
-    .map_err_context(|| format!("failed to get attributes of {}", path.quote()))?;
+    let metadata = match fs::metadata(path) {
+        Ok(metadata) => metadata,
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound && !follow => fs::symlink_metadata(path)
+            .map_err_context(|| format!("failed to get attributes of {}", path.quote()))?,
+        Err(e) => return Err(e.into()),
+    };
 
     Ok((
         FileTime::from_last_access_time(&metadata),
@@ -384,55 +445,7 @@ fn parse_date(s: &str) -> UResult<FileTime> {
         }
     }
 
-    // Relative day, like "today", "tomorrow", or "yesterday".
-    match s {
-        "now" | "today" => {
-            let now_local = time::OffsetDateTime::now_local().unwrap();
-            return Ok(local_dt_to_filetime(now_local));
-        }
-        "tomorrow" => {
-            let duration = time::Duration::days(1);
-            let now_local = time::OffsetDateTime::now_local().unwrap();
-            let diff = now_local.checked_add(duration).unwrap();
-            return Ok(local_dt_to_filetime(diff));
-        }
-        "yesterday" => {
-            let duration = time::Duration::days(1);
-            let now_local = time::OffsetDateTime::now_local().unwrap();
-            let diff = now_local.checked_sub(duration).unwrap();
-            return Ok(local_dt_to_filetime(diff));
-        }
-        _ => {}
-    }
-
-    // Relative time, like "-1 hour" or "+3 days".
-    //
-    // TODO Add support for "year" and "month".
-    // TODO Add support for times without spaces like "-1hour".
-    let tokens: Vec<&str> = s.split_whitespace().collect();
-    let maybe_duration = match &tokens[..] {
-        [num_str, "fortnight" | "fortnights"] => num_str
-            .parse::<i64>()
-            .ok()
-            .map(|n| time::Duration::weeks(2 * n)),
-        ["fortnight" | "fortnights"] => Some(time::Duration::weeks(2)),
-        [num_str, "week" | "weeks"] => num_str.parse::<i64>().ok().map(time::Duration::weeks),
-        ["week" | "weeks"] => Some(time::Duration::weeks(1)),
-        [num_str, "day" | "days"] => num_str.parse::<i64>().ok().map(time::Duration::days),
-        ["day" | "days"] => Some(time::Duration::days(1)),
-        [num_str, "hour" | "hours"] => num_str.parse::<i64>().ok().map(time::Duration::hours),
-        ["hour" | "hours"] => Some(time::Duration::hours(1)),
-        [num_str, "minute" | "minutes" | "min" | "mins"] => {
-            num_str.parse::<i64>().ok().map(time::Duration::minutes)
-        }
-        ["minute" | "minutes" | "min" | "mins"] => Some(time::Duration::minutes(1)),
-        [num_str, "second" | "seconds" | "sec" | "secs"] => {
-            num_str.parse::<i64>().ok().map(time::Duration::seconds)
-        }
-        ["second" | "seconds" | "sec" | "secs"] => Some(time::Duration::seconds(1)),
-        _ => None,
-    };
-    if let Some(duration) = maybe_duration {
+    if let Ok(duration) = humantime_to_duration::from_str(s) {
         let now_local = time::OffsetDateTime::now_local().unwrap();
         let diff = now_local.checked_add(duration).unwrap();
         return Ok(local_dt_to_filetime(diff));
@@ -589,8 +602,7 @@ mod tests {
         // We can trigger an error by not setting stdout to anything (will
         // fail with code 1)
         assert!(super::pathbuf_from_stdout()
-            .err()
-            .expect("pathbuf_from_stdout should have failed")
+            .expect_err("pathbuf_from_stdout should have failed")
             .to_string()
             .contains("GetFinalPathNameByHandleW failed with code 1"));
     }
diff --git a/src/uu/touch/touch.md b/src/uu/touch/touch.md
new file mode 100644
index 000000000..8ce35b686
--- /dev/null
+++ b/src/uu/touch/touch.md
@@ -0,0 +1,7 @@
+# touch
+
+```
+touch [OPTION]... [USER]
+```
+
+Update the access and modification times of each `FILE` to the current time.
diff --git a/src/uu/tr/Cargo.toml b/src/uu/tr/Cargo.toml
index eee6c7cd6..e3eba0a10 100644
--- a/src/uu/tr/Cargo.toml
+++ b/src/uu/tr/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_tr"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "tr ~ (uutils) translate characters within input and display"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/tr.rs"
 
 [dependencies]
-nom = { workspace=true }
-clap = { workspace=true }
-uucore = { workspace=true }
+nom = { workspace = true }
+clap = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "tr"
diff --git a/src/uu/tr/src/tr.rs b/src/uu/tr/src/tr.rs
index 8ccd08366..9abbca631 100644
--- a/src/uu/tr/src/tr.rs
+++ b/src/uu/tr/src/tr.rs
@@ -13,17 +13,15 @@ use clap::{crate_version, Arg, ArgAction, Command};
 use nom::AsBytes;
 use operation::{translate_input, Sequence, SqueezeOperation, TranslateOperation};
 use std::io::{stdin, stdout, BufReader, BufWriter};
-use uucore::{format_usage, show};
+use uucore::{format_usage, help_about, help_section, help_usage, show};
 
 use crate::operation::DeleteOperation;
 use uucore::display::Quotable;
 use uucore::error::{UResult, USimpleError, UUsageError};
 
-const ABOUT: &str = "Translate or delete characters";
-const USAGE: &str = "{} [OPTION]... SET1 [SET2]";
-const LONG_USAGE: &str = "\
-    Translate, squeeze, and/or delete characters from standard input, \
-    writing to standard output.";
+const ABOUT: &str = help_about!("tr.md");
+const AFTER_HELP: &str = help_section!("after help", "tr.md");
+const USAGE: &str = help_usage!("tr.md");
 
 mod options {
     pub const COMPLEMENT: &str = "complement";
@@ -37,7 +35,7 @@ mod options {
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args.collect_lossy();
 
-    let matches = uu_app().after_help(LONG_USAGE).try_get_matches_from(args)?;
+    let matches = uu_app().after_help(AFTER_HELP).try_get_matches_from(args)?;
 
     let delete_flag = matches.get_flag(options::DELETE);
     let complement_flag = matches.get_flag(options::COMPLEMENT);
diff --git a/src/uu/tr/tr.md b/src/uu/tr/tr.md
new file mode 100644
index 000000000..93349eeaa
--- /dev/null
+++ b/src/uu/tr/tr.md
@@ -0,0 +1,11 @@
+# tr
+
+```
+tr [OPTION]... SET1 [SET2]
+```
+
+Translate or delete characters
+
+## After help
+
+Translate, squeeze, and/or delete characters from standard input, writing to standard output.
diff --git a/src/uu/true/Cargo.toml b/src/uu/true/Cargo.toml
index 9954c2906..f7f7e1a6a 100644
--- a/src/uu/true/Cargo.toml
+++ b/src/uu/true/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_true"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "true ~ (uutils) do nothing and succeed"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/true.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "true"
diff --git a/src/uu/true/src/true.rs b/src/uu/true/src/true.rs
index 7c373fb7a..334652ce8 100644
--- a/src/uu/true/src/true.rs
+++ b/src/uu/true/src/true.rs
@@ -7,14 +7,9 @@
 use clap::{Arg, ArgAction, Command};
 use std::{ffi::OsString, io::Write};
 use uucore::error::{set_exit_code, UResult};
+use uucore::help_about;
 
-static ABOUT: &str = "\
-Returns true, a successful exit status.
-
-Immediately returns with the exit status `0`, except when invoked with one of the recognized
-options. In those cases it will try to write the help or version text. Any IO error during this
-operation causes the program to return `1` instead.
-";
+const ABOUT: &str = help_about!("true.md");
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
diff --git a/src/uu/true/true.md b/src/uu/true/true.md
new file mode 100644
index 000000000..b21c9616e
--- /dev/null
+++ b/src/uu/true/true.md
@@ -0,0 +1,11 @@
+# true
+
+```
+true
+```
+
+Returns true, a successful exit status.
+
+Immediately returns with the exit status `0`, except when invoked with one of the recognized
+options. In those cases it will try to write the help or version text. Any IO error during this
+operation causes the program to return `1` instead.
diff --git a/src/uu/truncate/Cargo.toml b/src/uu/truncate/Cargo.toml
index e93751e89..bf36e8257 100644
--- a/src/uu/truncate/Cargo.toml
+++ b/src/uu/truncate/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_truncate"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "truncate ~ (uutils) truncate (or extend) FILE to SIZE"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/truncate.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "truncate"
diff --git a/src/uu/truncate/src/truncate.rs b/src/uu/truncate/src/truncate.rs
index 090865313..f050b52b4 100644
--- a/src/uu/truncate/src/truncate.rs
+++ b/src/uu/truncate/src/truncate.rs
@@ -14,8 +14,8 @@ use std::os::unix::fs::FileTypeExt;
 use std::path::Path;
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
-use uucore::format_usage;
 use uucore::parse_size::{parse_size, ParseSizeError};
+use uucore::{format_usage, help_about, help_section, help_usage};
 
 #[derive(Debug, Eq, PartialEq)]
 enum TruncateMode {
@@ -73,25 +73,9 @@ impl TruncateMode {
     }
 }
 
-const ABOUT: &str = "Shrink or extend the size of each file to the specified size.";
-const USAGE: &str = "{} [OPTION]... [FILE]...";
-const LONG_USAGE: &str = "\
-SIZE is an integer with an optional prefix and optional unit.
-The available units (K, M, G, T, P, E, Z, and Y) use the following format:
-    'KB' =>           1000 (kilobytes)
-    'K'  =>           1024 (kibibytes)
-    'MB' =>      1000*1000 (megabytes)
-    'M'  =>      1024*1024 (mebibytes)
-    'GB' => 1000*1000*1000 (gigabytes)
-    'G'  => 1024*1024*1024 (gibibytes)
-SIZE may also be prefixed by one of the following to adjust the size of each
-file based on its current size:
-    '+'  => extend by
-    '-'  => reduce by
-    '<'  => at most
-    '>'  => at least
-    '/'  => round down to multiple of
-    '%'  => round up to multiple of";
+const ABOUT: &str = help_about!("truncate.md");
+const AFTER_HELP: &str = help_section!("after help", "truncate.md");
+const USAGE: &str = help_usage!("truncate.md");
 
 pub mod options {
     pub static IO_BLOCKS: &str = "io-blocks";
@@ -104,7 +88,7 @@ pub mod options {
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app()
-        .after_help(LONG_USAGE)
+        .after_help(AFTER_HELP)
         .try_get_matches_from(args)
         .map_err(|e| {
             e.print().expect("Error writing clap::Error");
diff --git a/src/uu/truncate/truncate.md b/src/uu/truncate/truncate.md
new file mode 100644
index 000000000..d60a6b7b2
--- /dev/null
+++ b/src/uu/truncate/truncate.md
@@ -0,0 +1,26 @@
+# truncate
+
+```
+truncate [OPTION]... [FILE]...
+```
+
+Shrink or extend the size of each file to the specified size.
+
+## After help
+
+SIZE is an integer with an optional prefix and optional unit.
+The available units (K, M, G, T, P, E, Z, and Y) use the following format:
+    'KB' =>           1000 (kilobytes)
+    'K'  =>           1024 (kibibytes)
+    'MB' =>      1000*1000 (megabytes)
+    'M'  =>      1024*1024 (mebibytes)
+    'GB' => 1000*1000*1000 (gigabytes)
+    'G'  => 1024*1024*1024 (gibibytes)
+SIZE may also be prefixed by one of the following to adjust the size of each
+file based on its current size:
+    '+'  => extend by
+    '-'  => reduce by
+    '<'  => at most
+    '>'  => at least
+    '/'  => round down to multiple of
+    '%'  => round up to multiple of
diff --git a/src/uu/tsort/Cargo.toml b/src/uu/tsort/Cargo.toml
index 2737454eb..b7df32a1d 100644
--- a/src/uu/tsort/Cargo.toml
+++ b/src/uu/tsort/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_tsort"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "tsort ~ (uutils) topologically sort input (partially ordered) pairs"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/tsort.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "tsort"
diff --git a/src/uu/tsort/src/tsort.rs b/src/uu/tsort/src/tsort.rs
index cb179699d..6e11a7f58 100644
--- a/src/uu/tsort/src/tsort.rs
+++ b/src/uu/tsort/src/tsort.rs
@@ -6,18 +6,16 @@
 //  * For the full copyright and license information, please view the LICENSE
 //  * file that was distributed with this source code.
 use clap::{crate_version, Arg, Command};
-use std::collections::{HashMap, HashSet};
+use std::collections::{BTreeMap, BTreeSet};
 use std::fs::File;
 use std::io::{stdin, BufRead, BufReader, Read};
 use std::path::Path;
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult, USimpleError};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
 
-static ABOUT: &str = "Topological sort the strings in FILE.
-Strings are defined as any sequence of tokens separated by whitespace (tab, space, or newline).
-If FILE is not passed in, stdin is used instead.";
-static USAGE: &str = "{} [OPTIONS] FILE";
+const ABOUT: &str = help_about!("tsort.md");
+const USAGE: &str = help_usage!("tsort.md");
 
 mod options {
     pub const FILE: &str = "file";
@@ -105,8 +103,8 @@ pub fn uu_app() -> Command {
 // but using integer may improve performance.
 #[derive(Default)]
 struct Graph {
-    in_edges: HashMap<String, HashSet<String>>,
-    out_edges: HashMap<String, Vec<String>>,
+    in_edges: BTreeMap<String, BTreeSet<String>>,
+    out_edges: BTreeMap<String, Vec<String>>,
     result: Vec<String>,
 }
 
@@ -124,7 +122,7 @@ impl Graph {
     }
 
     fn init_node(&mut self, n: &str) {
-        self.in_edges.insert(n.to_string(), HashSet::new());
+        self.in_edges.insert(n.to_string(), BTreeSet::new());
         self.out_edges.insert(n.to_string(), vec![]);
     }
 
diff --git a/src/uu/tsort/tsort.md b/src/uu/tsort/tsort.md
new file mode 100644
index 000000000..5effbf1e7
--- /dev/null
+++ b/src/uu/tsort/tsort.md
@@ -0,0 +1,10 @@
+# tsort
+
+```
+tsort [OPTIONS] FILE
+```
+
+Topological sort the strings in FILE.
+Strings are defined as any sequence of tokens separated by whitespace (tab, space, or newline), ordering them based on dependencies in a directed acyclic graph (DAG). 
+Useful for scheduling and determining execution order.
+If FILE is not passed in, stdin is used instead.
diff --git a/src/uu/tty/Cargo.toml b/src/uu/tty/Cargo.toml
index ee7fe559b..d3d16d22a 100644
--- a/src/uu/tty/Cargo.toml
+++ b/src/uu/tty/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_tty"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "tty ~ (uutils) display the name of the terminal connected to standard input"
@@ -15,10 +15,10 @@ edition = "2021"
 path = "src/tty.rs"
 
 [dependencies]
-clap = { workspace=true }
-nix = { workspace=true, features=["term"] }
-is-terminal = { workspace=true }
-uucore = { workspace=true, features=["fs"] }
+clap = { workspace = true }
+nix = { workspace = true, features = ["term"] }
+is-terminal = { workspace = true }
+uucore = { workspace = true, features = ["fs"] }
 
 [[bin]]
 name = "tty"
diff --git a/src/uu/tty/src/tty.rs b/src/uu/tty/src/tty.rs
index e3fc0451e..e2d9d1847 100644
--- a/src/uu/tty/src/tty.rs
+++ b/src/uu/tty/src/tty.rs
@@ -14,10 +14,10 @@ use is_terminal::IsTerminal;
 use std::io::Write;
 use std::os::unix::io::AsRawFd;
 use uucore::error::{set_exit_code, UResult};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
 
-static ABOUT: &str = "Print the file name of the terminal connected to standard input.";
-const USAGE: &str = "{} [OPTION]...";
+const ABOUT: &str = help_about!("tty.md");
+const USAGE: &str = help_usage!("tty.md");
 
 mod options {
     pub const SILENT: &str = "silent";
diff --git a/src/uu/tty/tty.md b/src/uu/tty/tty.md
new file mode 100644
index 000000000..230399a20
--- /dev/null
+++ b/src/uu/tty/tty.md
@@ -0,0 +1,7 @@
+# tty
+
+```
+tty [OPTION]...
+```
+
+Print the file name of the terminal connected to standard input.
diff --git a/src/uu/uname/Cargo.toml b/src/uu/uname/Cargo.toml
index 818e6dd06..7b5f455a3 100644
--- a/src/uu/uname/Cargo.toml
+++ b/src/uu/uname/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_uname"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "uname ~ (uutils) display system information"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/uname.rs"
 
 [dependencies]
-platform-info = { workspace=true }
-clap = { workspace=true }
-uucore = { workspace=true }
+platform-info = { workspace = true }
+clap = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "uname"
diff --git a/src/uu/uname/src/uname.rs b/src/uu/uname/src/uname.rs
index f74f18772..8b8679234 100644
--- a/src/uu/uname/src/uname.rs
+++ b/src/uu/uname/src/uname.rs
@@ -13,13 +13,12 @@
 use clap::{crate_version, Arg, ArgAction, Command};
 use platform_info::*;
 use uucore::{
-    error::{FromIo, UResult},
-    format_usage,
+    error::{UResult, USimpleError},
+    format_usage, help_about, help_usage,
 };
 
-const ABOUT: &str = r#"Print certain system information.
-With no OPTION, same as -s."#;
-const USAGE: &str = "{} [OPTION]...";
+const ABOUT: &str = help_about!("uname.md");
+const USAGE: &str = help_usage!("uname.md");
 
 pub mod options {
     pub static ALL: &str = "all";
@@ -37,8 +36,8 @@ pub mod options {
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app().try_get_matches_from(args)?;
 
-    let uname =
-        PlatformInfo::new().map_err_context(|| "failed to create PlatformInfo".to_string())?;
+    let uname = PlatformInfo::new().map_err(|_e| USimpleError::new(1, "cannot get system name"))?;
+
     let mut output = String::new();
 
     let all = matches.get_flag(options::ALL);
@@ -62,33 +61,32 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         || hardware_platform);
 
     if kernel_name || all || none {
-        output.push_str(&uname.sysname());
+        output.push_str(&uname.sysname().to_string_lossy());
         output.push(' ');
     }
 
     if nodename || all {
-        // maint: [2023-01-14; rivy] remove `.trim_end_matches('\0')` when platform-info nodename-NUL bug is fixed (see GH:uutils/platform-info/issues/32)
-        output.push_str(uname.nodename().trim_end_matches('\0'));
+        output.push_str(&uname.nodename().to_string_lossy());
         output.push(' ');
     }
 
     if kernel_release || all {
-        output.push_str(&uname.release());
+        output.push_str(&uname.release().to_string_lossy());
         output.push(' ');
     }
 
     if kernel_version || all {
-        output.push_str(&uname.version());
+        output.push_str(&uname.version().to_string_lossy());
         output.push(' ');
     }
 
     if machine || all {
-        output.push_str(&uname.machine());
+        output.push_str(&uname.machine().to_string_lossy());
         output.push(' ');
     }
 
     if os || all {
-        output.push_str(&uname.osname());
+        output.push_str(&uname.osname().to_string_lossy());
         output.push(' ');
     }
 
diff --git a/src/uu/uname/uname.md b/src/uu/uname/uname.md
new file mode 100644
index 000000000..b90c54cfc
--- /dev/null
+++ b/src/uu/uname/uname.md
@@ -0,0 +1,8 @@
+# uname
+
+```
+uname [OPTION]...
+```
+
+Print certain system information. 
+With no OPTION, same as -s.
diff --git a/src/uu/unexpand/Cargo.toml b/src/uu/unexpand/Cargo.toml
index a80bcdaf5..b3d5e1b40 100644
--- a/src/uu/unexpand/Cargo.toml
+++ b/src/uu/unexpand/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_unexpand"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "unexpand ~ (uutils) convert input spaces to tabs"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/unexpand.rs"
 
 [dependencies]
-clap = { workspace=true }
-unicode-width = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+unicode-width = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "unexpand"
diff --git a/src/uu/unexpand/src/unexpand.rs b/src/uu/unexpand/src/unexpand.rs
index df2348a8c..dd4471e2d 100644
--- a/src/uu/unexpand/src/unexpand.rs
+++ b/src/uu/unexpand/src/unexpand.rs
@@ -19,11 +19,10 @@ use std::str::from_utf8;
 use unicode_width::UnicodeWidthChar;
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UError, UResult};
-use uucore::{crash, crash_if_err, format_usage};
+use uucore::{crash, crash_if_err, format_usage, help_about, help_usage};
 
-static USAGE: &str = "{} [OPTION]... [FILE]...";
-static ABOUT: &str = "Convert blanks in each FILE to tabs, writing to standard output.\n\n\
-                      With no FILE, or when FILE is -, read standard input.";
+const USAGE: &str = help_usage!("unexpand.md");
+const ABOUT: &str = help_about!("unexpand.md");
 
 const DEFAULT_TABSTOP: usize = 8;
 
@@ -319,6 +318,7 @@ fn next_char_info(uflag: bool, buf: &[u8], byte: usize) -> (CharType, usize, usi
     (ctype, cwidth, nbytes)
 }
 
+#[allow(clippy::cognitive_complexity)]
 fn unexpand(options: &Options) -> std::io::Result<()> {
     let mut output = BufWriter::new(stdout());
     let ts = &options.tabstops[..];
diff --git a/src/uu/unexpand/unexpand.md b/src/uu/unexpand/unexpand.md
new file mode 100644
index 000000000..6fc69b93a
--- /dev/null
+++ b/src/uu/unexpand/unexpand.md
@@ -0,0 +1,8 @@
+# unexpand
+
+```
+unexpand [OPTION]... [FILE]...
+```
+
+Convert blanks in each `FILE` to tabs, writing to standard output.
+With no `FILE`, or when `FILE` is `-`, read standard input.
diff --git a/src/uu/uniq/Cargo.toml b/src/uu/uniq/Cargo.toml
index f1b615ea8..dec4bf2a4 100644
--- a/src/uu/uniq/Cargo.toml
+++ b/src/uu/uniq/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_uniq"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "uniq ~ (uutils) filter identical adjacent lines from input"
@@ -15,10 +15,8 @@ edition = "2021"
 path = "src/uniq.rs"
 
 [dependencies]
-clap = { workspace=true }
-strum = { workspace=true }
-strum_macros = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "uniq"
diff --git a/src/uu/uniq/src/uniq.rs b/src/uu/uniq/src/uniq.rs
index 79ed743bb..89141f35f 100644
--- a/src/uu/uniq/src/uniq.rs
+++ b/src/uu/uniq/src/uniq.rs
@@ -5,23 +5,18 @@
 //  * For the full copyright and license information, please view the LICENSE
 //  * file that was distributed with this source code.
 
-use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
+use clap::{builder::ValueParser, crate_version, Arg, ArgAction, ArgMatches, Command};
+use std::ffi::{OsStr, OsString};
 use std::fs::File;
-use std::io::{self, stdin, stdout, BufRead, BufReader, BufWriter, Read, Write};
-use std::path::Path;
+use std::io::{self, stdin, stdout, BufRead, BufReader, BufWriter, Write};
 use std::str::FromStr;
-use strum_macros::{AsRefStr, EnumString};
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_section, help_usage};
 
-const ABOUT: &str = "Report or omit repeated lines.";
-const USAGE: &str = "{} [OPTION]... [INPUT [OUTPUT]]...";
-const LONG_USAGE: &str = "\
-    Filter adjacent matching lines from INPUT (or standard input),\n\
-    writing to OUTPUT (or standard output).\n\n\
-    Note: 'uniq' does not detect repeated lines unless they are adjacent.\n\
-    You may want to sort the input first, or use 'sort -u' without 'uniq'.";
+const ABOUT: &str = help_about!("uniq.md");
+const USAGE: &str = help_usage!("uniq.md");
+const AFTER_HELP: &str = help_section!("after help", "uniq.md");
 
 pub mod options {
     pub static ALL_REPEATED: &str = "all-repeated";
@@ -38,8 +33,7 @@ pub mod options {
 
 static ARG_FILES: &str = "files";
 
-#[derive(PartialEq, Clone, Copy, AsRefStr, EnumString)]
-#[strum(serialize_all = "snake_case")]
+#[derive(PartialEq, Clone, Copy)]
 enum Delimiters {
     Append,
     Prepend,
@@ -70,11 +64,7 @@ macro_rules! write_line_terminator {
 }
 
 impl Uniq {
-    pub fn print_uniq<R: Read, W: Write>(
-        &self,
-        reader: &mut BufReader<R>,
-        writer: &mut BufWriter<W>,
-    ) -> UResult<()> {
+    pub fn print_uniq(&self, reader: impl BufRead, mut writer: impl Write) -> UResult<()> {
         let mut first_line_printed = false;
         let mut group_count = 1;
         let line_terminator = self.get_line_terminator();
@@ -84,6 +74,8 @@ impl Uniq {
             None => return Ok(()),
         };
 
+        let writer = &mut writer;
+
         // compare current `line` with consecutive lines (`next_line`) of the input
         // and if needed, print `line` based on the command line options provided
         for next_line in lines {
@@ -128,7 +120,6 @@ impl Uniq {
                 }
                 match char_indices.find(|(_, c)| c.is_whitespace()) {
                     None => return "",
-
                     Some((next_field_i, _)) => i = next_field_i,
                 }
             }
@@ -201,9 +192,9 @@ impl Uniq {
                 || self.delimiters == Delimiters::Both)
     }
 
-    fn print_line<W: Write>(
+    fn print_line(
         &self,
-        writer: &mut BufWriter<W>,
+        writer: &mut impl Write,
         line: &str,
         count: usize,
         first_line_printed: bool,
@@ -215,7 +206,7 @@ impl Uniq {
         }
 
         if self.show_counts {
-            writer.write_all(format!("{count:7} {line}").as_bytes())
+            write!(writer, "{count:7} {line}")
         } else {
             writer.write_all(line.as_bytes())
         }
@@ -249,22 +240,15 @@ fn opt_parsed<T: FromStr>(opt_name: &str, matches: &ArgMatches) -> UResult<Optio
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let matches = uu_app().after_help(LONG_USAGE).try_get_matches_from(args)?;
+    let matches = uu_app().after_help(AFTER_HELP).try_get_matches_from(args)?;
 
-    let files: Vec<String> = matches
-        .get_many::<String>(ARG_FILES)
-        .map(|v| v.map(ToString::to_string).collect())
+    let files = matches.get_many::<OsString>(ARG_FILES);
+
+    let (in_file_name, out_file_name) = files
+        .map(|fi| fi.map(AsRef::as_ref))
+        .map(|mut fi| (fi.next(), fi.next()))
         .unwrap_or_default();
 
-    let (in_file_name, out_file_name) = match files.len() {
-        0 => ("-".to_owned(), "-".to_owned()),
-        1 => (files[0].clone(), "-".to_owned()),
-        2 => (files[0].clone(), files[1].clone()),
-        _ => {
-            unreachable!() // Cannot happen as clap will fail earlier
-        }
-    };
-
     let uniq = Uniq {
         repeats_only: matches.get_flag(options::REPEATED)
             || matches.contains_id(options::ALL_REPEATED),
@@ -288,8 +272,8 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     }
 
     uniq.print_uniq(
-        &mut open_input_file(&in_file_name)?,
-        &mut open_output_file(&out_file_name)?,
+        open_input_file(in_file_name)?,
+        open_output_file(out_file_name)?,
     )
 }
 
@@ -393,6 +377,7 @@ pub fn uu_app() -> Command {
         .arg(
             Arg::new(ARG_FILES)
                 .action(ArgAction::Append)
+                .value_parser(ValueParser::os_string())
                 .num_args(0..=2)
                 .value_hint(clap::ValueHint::FilePath),
         )
@@ -403,7 +388,14 @@ fn get_delimiter(matches: &ArgMatches) -> Delimiters {
         .get_one::<String>(options::ALL_REPEATED)
         .or_else(|| matches.get_one::<String>(options::GROUP));
     if let Some(delimiter_arg) = value {
-        Delimiters::from_str(delimiter_arg).unwrap() // All possible values for ALL_REPEATED are Delimiters (of type `&str`)
+        match delimiter_arg.as_ref() {
+            "append" => Delimiters::Append,
+            "prepend" => Delimiters::Prepend,
+            "separate" => Delimiters::Separate,
+            "both" => Delimiters::Both,
+            "none" => Delimiters::None,
+            _ => unreachable!("Should have been caught by possible values in clap"),
+        }
     } else if matches.contains_id(options::GROUP) {
         Delimiters::Separate
     } else {
@@ -411,26 +403,26 @@ fn get_delimiter(matches: &ArgMatches) -> Delimiters {
     }
 }
 
-fn open_input_file(in_file_name: &str) -> UResult<BufReader<Box<dyn Read + 'static>>> {
-    let in_file = if in_file_name == "-" {
-        Box::new(stdin()) as Box<dyn Read>
-    } else {
-        let path = Path::new(in_file_name);
-        let in_file = File::open(path)
-            .map_err_context(|| format!("Could not open {}", in_file_name.maybe_quote()))?;
-        Box::new(in_file) as Box<dyn Read>
-    };
-    Ok(BufReader::new(in_file))
+// None or "-" means stdin.
+fn open_input_file(in_file_name: Option<&OsStr>) -> UResult<Box<dyn BufRead>> {
+    Ok(match in_file_name {
+        Some(path) if path != "-" => {
+            let in_file = File::open(path)
+                .map_err_context(|| format!("Could not open {}", path.maybe_quote()))?;
+            Box::new(BufReader::new(in_file))
+        }
+        _ => Box::new(stdin().lock()),
+    })
 }
 
-fn open_output_file(out_file_name: &str) -> UResult<BufWriter<Box<dyn Write + 'static>>> {
-    let out_file = if out_file_name == "-" {
-        Box::new(stdout()) as Box<dyn Write>
-    } else {
-        let path = Path::new(out_file_name);
-        let out_file = File::create(path)
-            .map_err_context(|| format!("Could not create {}", out_file_name.maybe_quote()))?;
-        Box::new(out_file) as Box<dyn Write>
-    };
-    Ok(BufWriter::new(out_file))
+// None or "-" means stdout.
+fn open_output_file(out_file_name: Option<&OsStr>) -> UResult<Box<dyn Write>> {
+    Ok(match out_file_name {
+        Some(path) if path != "-" => {
+            let out_file = File::create(path)
+                .map_err_context(|| format!("Could not open {}", path.maybe_quote()))?;
+            Box::new(BufWriter::new(out_file))
+        }
+        _ => Box::new(stdout().lock()),
+    })
 }
diff --git a/src/uu/uniq/uniq.md b/src/uu/uniq/uniq.md
new file mode 100644
index 000000000..dea57081b
--- /dev/null
+++ b/src/uu/uniq/uniq.md
@@ -0,0 +1,15 @@
+# uniq
+
+```
+uniq [OPTION]... [INPUT [OUTPUT]]...
+```
+
+Report or omit repeated lines.
+
+## After help
+
+Filter adjacent matching lines from `INPUT` (or standard input),
+writing to `OUTPUT` (or standard output).
+
+Note: `uniq` does not detect repeated lines unless they are adjacent.
+You may want to sort the input first, or use `sort -u` without `uniq`.
diff --git a/src/uu/unlink/Cargo.toml b/src/uu/unlink/Cargo.toml
index 6b300dab0..10ec571d1 100644
--- a/src/uu/unlink/Cargo.toml
+++ b/src/uu/unlink/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_unlink"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "unlink ~ (uutils) remove a (file system) link to FILE"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/unlink.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true }
 
 [[bin]]
 name = "unlink"
diff --git a/src/uu/unlink/src/unlink.rs b/src/uu/unlink/src/unlink.rs
index 99dd55791..5d1594a05 100644
--- a/src/uu/unlink/src/unlink.rs
+++ b/src/uu/unlink/src/unlink.rs
@@ -16,8 +16,10 @@ use clap::{crate_version, Arg, Command};
 
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult};
+use uucore::{format_usage, help_about, help_usage};
 
-static ABOUT: &str = "Unlink the file at FILE.";
+const ABOUT: &str = help_about!("unlink.md");
+const USAGE: &str = help_usage!("unlink.md");
 static OPT_PATH: &str = "FILE";
 
 #[uucore::main]
@@ -33,6 +35,7 @@ pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
         .infer_long_args(true)
         .arg(
             Arg::new(OPT_PATH)
diff --git a/src/uu/unlink/unlink.md b/src/uu/unlink/unlink.md
new file mode 100644
index 000000000..4468fb204
--- /dev/null
+++ b/src/uu/unlink/unlink.md
@@ -0,0 +1,7 @@
+# unlink
+
+```
+unlink [FILE]
+```
+
+Unlink the file at `FILE`.
diff --git a/src/uu/uptime/Cargo.toml b/src/uu/uptime/Cargo.toml
index a38a030e8..b92254cda 100644
--- a/src/uu/uptime/Cargo.toml
+++ b/src/uu/uptime/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_uptime"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "uptime ~ (uutils) display dynamic system information"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/uptime.rs"
 
 [dependencies]
-chrono = { workspace=true }
-clap = { workspace=true }
-uucore = { workspace=true, features=["libc", "utmpx"] }
+chrono = { workspace = true }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["libc", "utmpx"] }
 
 [[bin]]
 name = "uptime"
diff --git a/src/uu/uptime/src/uptime.rs b/src/uu/uptime/src/uptime.rs
index 3a561f419..6f4e62084 100644
--- a/src/uu/uptime/src/uptime.rs
+++ b/src/uu/uptime/src/uptime.rs
@@ -11,17 +11,13 @@
 use chrono::{Local, TimeZone, Utc};
 use clap::{crate_version, Arg, ArgAction, Command};
 
-use uucore::format_usage;
-// import crate time from utmpx
-pub use uucore::libc;
 use uucore::libc::time_t;
+use uucore::{format_usage, help_about, help_usage};
 
 use uucore::error::{UResult, USimpleError};
 
-static ABOUT: &str = "Display the current time, the length of time the system has been up,\n\
-                      the number of users on the system, and the average number of jobs\n\
-                      in the run queue over the last 1, 5 and 15 minutes.";
-const USAGE: &str = "{} [OPTION]...";
+const ABOUT: &str = help_about!("uptime.md");
+const USAGE: &str = help_usage!("uptime.md");
 pub mod options {
     pub static SINCE: &str = "since";
 }
diff --git a/src/uu/uptime/uptime.md b/src/uu/uptime/uptime.md
new file mode 100644
index 000000000..fd9c8fd2f
--- /dev/null
+++ b/src/uu/uptime/uptime.md
@@ -0,0 +1,9 @@
+# uptime
+
+```
+uptime [OPTION]...
+```
+
+Display the current time, the length of time the system has been up,
+the number of users on the system, and the average number of jobs
+in the run queue over the last 1, 5 and 15 minutes.
diff --git a/src/uu/users/Cargo.toml b/src/uu/users/Cargo.toml
index 32abd1581..81af58629 100644
--- a/src/uu/users/Cargo.toml
+++ b/src/uu/users/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_users"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "users ~ (uutils) display names of currently logged-in users"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/users.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true, features=["utmpx"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["utmpx"] }
 
 [[bin]]
 name = "users"
diff --git a/src/uu/users/src/users.rs b/src/uu/users/src/users.rs
index b812bfea1..6a5e54f99 100644
--- a/src/uu/users/src/users.rs
+++ b/src/uu/users/src/users.rs
@@ -14,11 +14,11 @@ use std::path::Path;
 use clap::builder::ValueParser;
 use clap::{crate_version, Arg, Command};
 use uucore::error::UResult;
-use uucore::format_usage;
 use uucore::utmpx::{self, Utmpx};
+use uucore::{format_usage, help_about, help_usage};
 
-static ABOUT: &str = "Print the user names of users currently logged in to the current host";
-const USAGE: &str = "{} [FILE]";
+const ABOUT: &str = help_about!("users.md");
+const USAGE: &str = help_usage!("users.md");
 
 static ARG_FILES: &str = "files";
 
@@ -41,10 +41,10 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         .map(|v| v.map(AsRef::as_ref).collect())
         .unwrap_or_default();
 
-    let filename = if !files.is_empty() {
-        files[0]
-    } else {
+    let filename = if files.is_empty() {
         utmpx::DEFAULT_FILE.as_ref()
+    } else {
+        files[0]
     };
 
     let mut users = Utmpx::iter_all_records_from(filename)
diff --git a/src/uu/users/users.md b/src/uu/users/users.md
new file mode 100644
index 000000000..7b126a0f0
--- /dev/null
+++ b/src/uu/users/users.md
@@ -0,0 +1,7 @@
+# users
+
+```
+users [FILE]
+```
+
+Print the user names of users currently logged in to the current host.
diff --git a/src/uu/vdir/Cargo.toml b/src/uu/vdir/Cargo.toml
index 569807af6..68d0c34ae 100644
--- a/src/uu/vdir/Cargo.toml
+++ b/src/uu/vdir/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_vdir"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "shortcut to ls -l -b"
@@ -15,9 +15,9 @@ edition = "2021"
 path = "src/vdir.rs"
 
 [dependencies]
-clap = { workspace=true, features = ["env"] }
-uucore = { workspace=true, features=["entries", "fs"] }
-uu_ls = { workspace=true }
+clap = { workspace = true, features = ["env"] }
+uucore = { workspace = true, features = ["entries", "fs"] }
+uu_ls = { workspace = true }
 
 [[bin]]
 name = "vdir"
diff --git a/src/uu/wc/BENCHMARKING.md b/src/uu/wc/BENCHMARKING.md
index b9d8cc22d..0a34c8cfa 100644
--- a/src/uu/wc/BENCHMARKING.md
+++ b/src/uu/wc/BENCHMARKING.md
@@ -2,45 +2,59 @@
 
 <!-- spell-checker:ignore (words) uuwc uucat largefile somefile Mshortlines moby lwcm cmds tablefmt -->
 
-Much of what makes wc fast is avoiding unnecessary work. It has multiple strategies, depending on which data is requested.
+Much of what makes wc fast is avoiding unnecessary work. It has multiple strategies,
+depending on which data is requested.
 
 ## Strategies
 
 ### Counting bytes
 
-In the case of `wc -c` the content of the input doesn't have to be inspected at all, only the size has to be known. That enables a few optimizations.
+In the case of `wc -c` the content of the input doesn't have to be inspected at all,
+only the size has to be known. That enables a few optimizations.
 
 #### File size
 
-If it can, wc reads the file size directly. This is not interesting to benchmark, except to see if it still works. Try `wc -c largefile`.
+If it can, wc reads the file size directly. This is not interesting to benchmark,
+except to see if it still works. Try `wc -c largefile`.
 
 #### `splice()`
 
 On Linux `splice()` is used to get the input's length while discarding it directly.
 
-The best way I've found to generate a fast input to test `splice()` is to pipe the output of uutils `cat` into it. Note that GNU `cat` is slower and therefore less suitable, and that if a file is given as its input directly (as in `wc -c < largefile`) the first strategy kicks in. Try `uucat somefile | wc -c`.
+The best way I've found to generate a fast input to test `splice()` is to pipe the
+output of uutils `cat` into it. Note that GNU `cat` is slower and therefore less
+suitable, and that if a file is given as its input directly (as in
+`wc -c < largefile`) the first strategy kicks in. Try `uucat somefile | wc -c`.
 
 ### Counting lines
 
-In the case of `wc -l` or `wc -cl` the input doesn't have to be decoded. It's read in chunks and the `bytecount` crate is used to count the newlines.
+In the case of `wc -l` or `wc -cl` the input doesn't have to be decoded. It's
+read in chunks and the `bytecount` crate is used to count the newlines.
 
-It's useful to vary the line length in the input. GNU wc seems particularly bad at short lines.
+It's useful to vary the line length in the input. GNU wc seems particularly
+bad at short lines.
 
 ### Processing unicode
 
-This is the most general strategy, and it's necessary for counting words, characters, and line lengths. Individual steps are still switched on and off depending on what must be reported.
+This is the most general strategy, and it's necessary for counting words,
+characters, and line lengths. Individual steps are still switched on and off
+depending on what must be reported.
 
-Try varying which of the `-w`, `-m`, `-l` and `-L` flags are used. (The `-c` flag is unlikely to make a difference.)
+Try varying which of the `-w`, `-m`, `-l` and `-L` flags are used.
+(The `-c` flag is unlikely to make a difference.)
 
-Passing no flags is equivalent to passing `-wcl`. That case should perhaps be given special attention as it's the default.
+Passing no flags is equivalent to passing `-wcl`. That case should perhaps be
+given special attention as it's the default.
 
 ## Generating files
 
-To generate a file with many very short lines, run `yes | head -c50000000 > 25Mshortlines`.
+To generate a file with many very short lines, run
+`yes | head -c50000000 > 25Mshortlines`.
 
-To get a file with less artificial contents, download a book from Project Gutenberg and concatenate it a lot of times:
+To get a file with less artificial contents, download a book from
+Project Gutenberg and concatenate it a lot of times:
 
-```
+```shell
 wget https://www.gutenberg.org/files/2701/2701-0.txt -O moby.txt
 cat moby.txt moby.txt moby.txt moby.txt > moby4.txt
 cat moby4.txt moby4.txt moby4.txt moby4.txt > moby16.txt
@@ -49,7 +63,7 @@ cat moby16.txt moby16.txt moby16.txt moby16.txt > moby64.txt
 
 And get one with lots of unicode too:
 
-```
+```shell
 wget https://www.gutenberg.org/files/30613/30613-0.txt -O odyssey.txt
 cat odyssey.txt odyssey.txt odyssey.txt odyssey.txt > odyssey4.txt
 cat odyssey4.txt odyssey4.txt odyssey4.txt odyssey4.txt > odyssey16.txt
@@ -57,11 +71,14 @@ cat odyssey16.txt odyssey16.txt odyssey16.txt odyssey16.txt > odyssey64.txt
 cat odyssey64.txt odyssey64.txt odyssey64.txt odyssey64.txt > odyssey256.txt
 ```
 
-Finally, it's interesting to try a binary file. Look for one with `du -sh /usr/bin/* | sort -h`. On my system `/usr/bin/docker` is a good candidate as it's fairly large.
+Finally, it's interesting to try a binary file. Look for one with
+`du -sh /usr/bin/* | sort -h`. On my system `/usr/bin/docker` is a good
+candidate as it's fairly large.
 
 ## Running benchmarks
 
-Use [`hyperfine`](https://github.com/sharkdp/hyperfine) to compare the performance. For example, `hyperfine 'wc somefile' 'uuwc somefile'`.
+Use [`hyperfine`](https://github.com/sharkdp/hyperfine) to compare the
+performance. For example, `hyperfine 'wc somefile' 'uuwc somefile'`.
 
 If you want to get fancy and exhaustive, generate a table:
 
@@ -69,6 +86,7 @@ If you want to get fancy and exhaustive, generate a table:
 |------------------------|--------------|------------------|-----------------|-------------------|
 | `wc <FILE>`            |       1.3965 |           1.6182 |          5.2967 |            2.2294 |
 | `wc -c <FILE>`         |       0.8134 |           1.2774 |          0.7732 |            0.9106 |
+<!-- markdownlint-disable-next-line MD033 -->
 | `uucat <FILE> | wc -c` |       2.7760 |           2.5565 |          2.3769 |            2.3982 |
 | `wc -l <FILE>`         |       1.1441 |           1.2854 |          2.9681 |            1.1493 |
 | `wc -L <FILE>`         |       2.1087 |           1.2551 |          5.4577 |            2.1490 |
@@ -77,12 +95,16 @@ If you want to get fancy and exhaustive, generate a table:
 | `wc -lwcmL <FILE>`     |       1.1687 |           0.9169 |          4.4092 |            2.0663 |
 
 Beware that:
+
 - Results are fuzzy and change from run to run
-- You'll often want to check versions of uutils wc against each other instead of against GNU
+- You'll often want to check versions of uutils wc against each other instead
+  of against GNU
 - This takes a lot of time to generate
-- This only shows the relative speedup, not the absolute time, which may be misleading if the time is very short
+- This only shows the relative speedup, not the absolute time, which may be
+  misleading if the time is very short
 
 Created by the following Python script:
+
 ```python
 import json
 import subprocess
@@ -121,4 +143,6 @@ for cmd in cmds:
     table.append(row)
 print(tabulate(table, [""] + files, tablefmt="github"))
 ```
-(You may have to adjust the `bins` and `files` variables depending on your setup, and please do add other interesting cases to `cmds`.)
+
+(You may have to adjust the `bins` and `files` variables depending on your
+setup, and please do add other interesting cases to `cmds`.)
diff --git a/src/uu/wc/Cargo.toml b/src/uu/wc/Cargo.toml
index 40e0fd03b..363483bf8 100644
--- a/src/uu/wc/Cargo.toml
+++ b/src/uu/wc/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_wc"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "wc ~ (uutils) display newline, word, and byte counts for input"
@@ -15,15 +15,15 @@ edition = "2021"
 path = "src/wc.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true, features=["pipes"] }
-bytecount = { workspace=true }
-utf-8 = { workspace=true }
-unicode-width = { workspace=true }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["pipes"] }
+bytecount = { workspace = true }
+thiserror = { workspace = true }
+unicode-width = { workspace = true }
 
 [target.'cfg(unix)'.dependencies]
-nix = { workspace=true }
-libc = { workspace=true }
+nix = { workspace = true }
+libc = { workspace = true }
 
 [[bin]]
 name = "wc"
diff --git a/src/uu/wc/src/countable.rs b/src/uu/wc/src/countable.rs
index 5596decb3..b86b96fa2 100644
--- a/src/uu/wc/src/countable.rs
+++ b/src/uu/wc/src/countable.rs
@@ -28,6 +28,7 @@ impl WordCountable for StdinLock<'_> {
         self
     }
 }
+
 impl WordCountable for File {
     type Buffered = BufReader<Self>;
 
diff --git a/src/uu/wc/src/utf8/LICENSE b/src/uu/wc/src/utf8/LICENSE
new file mode 100644
index 000000000..6f3c83e68
--- /dev/null
+++ b/src/uu/wc/src/utf8/LICENSE
@@ -0,0 +1,26 @@
+// spell-checker:ignore Sapin
+Copyright (c) Simon Sapin and many others
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/src/uu/wc/src/utf8/mod.rs b/src/uu/wc/src/utf8/mod.rs
new file mode 100644
index 000000000..31638e758
--- /dev/null
+++ b/src/uu/wc/src/utf8/mod.rs
@@ -0,0 +1,93 @@
+// spell-checker:ignore Sapin
+mod read;
+
+pub use read::{BufReadDecoder, BufReadDecoderError};
+
+use std::cmp;
+use std::str;
+
+///
+/// Incremental, zero-copy UTF-8 decoding with error handling
+///
+/// The original implementation was written by Simon Sapin in the utf-8 crate <https://crates.io/crates/utf-8>.
+/// uu_wc used to depend on that crate.
+/// The author archived the repository <https://github.com/SimonSapin/rust-utf8>.
+/// They suggested incorporating the source directly into uu_wc <https://github.com/uutils/coreutils/issues/4289>.
+///
+
+#[derive(Debug, Copy, Clone)]
+pub struct Incomplete {
+    pub buffer: [u8; 4],
+    pub buffer_len: u8,
+}
+
+impl Incomplete {
+    pub fn empty() -> Self {
+        Self {
+            buffer: [0, 0, 0, 0],
+            buffer_len: 0,
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.buffer_len == 0
+    }
+
+    pub fn new(bytes: &[u8]) -> Self {
+        let mut buffer = [0, 0, 0, 0];
+        let len = bytes.len();
+        buffer[..len].copy_from_slice(bytes);
+        Self {
+            buffer,
+            buffer_len: len as u8,
+        }
+    }
+
+    fn take_buffer(&mut self) -> &[u8] {
+        let len = self.buffer_len as usize;
+        self.buffer_len = 0;
+        &self.buffer[..len]
+    }
+
+    /// (consumed_from_input, None): not enough input
+    /// (consumed_from_input, Some(Err(()))): error bytes in buffer
+    /// (consumed_from_input, Some(Ok(()))): UTF-8 string in buffer
+    fn try_complete_offsets(&mut self, input: &[u8]) -> (usize, Option<Result<(), ()>>) {
+        let initial_buffer_len = self.buffer_len as usize;
+        let copied_from_input;
+        {
+            let unwritten = &mut self.buffer[initial_buffer_len..];
+            copied_from_input = cmp::min(unwritten.len(), input.len());
+            unwritten[..copied_from_input].copy_from_slice(&input[..copied_from_input]);
+        }
+        let spliced = &self.buffer[..initial_buffer_len + copied_from_input];
+        match str::from_utf8(spliced) {
+            Ok(_) => {
+                self.buffer_len = spliced.len() as u8;
+                (copied_from_input, Some(Ok(())))
+            }
+            Err(error) => {
+                let valid_up_to = error.valid_up_to();
+                if valid_up_to > 0 {
+                    let consumed = valid_up_to.checked_sub(initial_buffer_len).unwrap();
+                    self.buffer_len = valid_up_to as u8;
+                    (consumed, Some(Ok(())))
+                } else {
+                    match error.error_len() {
+                        Some(invalid_sequence_length) => {
+                            let consumed = invalid_sequence_length
+                                .checked_sub(initial_buffer_len)
+                                .unwrap();
+                            self.buffer_len = invalid_sequence_length as u8;
+                            (consumed, Some(Err(())))
+                        }
+                        None => {
+                            self.buffer_len = spliced.len() as u8;
+                            (copied_from_input, None)
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/uu/wc/src/utf8/read.rs b/src/uu/wc/src/utf8/read.rs
new file mode 100644
index 000000000..1b5bbbe7f
--- /dev/null
+++ b/src/uu/wc/src/utf8/read.rs
@@ -0,0 +1,138 @@
+// spell-checker:ignore bytestream
+use super::*;
+use std::error::Error;
+use std::fmt;
+use std::io::{self, BufRead};
+use std::str;
+
+/// Wraps a `std::io::BufRead` buffered byte stream and decode it as UTF-8.
+pub struct BufReadDecoder<B: BufRead> {
+    buf_read: B,
+    bytes_consumed: usize,
+    incomplete: Incomplete,
+}
+
+#[derive(Debug)]
+pub enum BufReadDecoderError<'a> {
+    /// Represents one UTF-8 error in the byte stream.
+    ///
+    /// In lossy decoding, each such error should be replaced with U+FFFD.
+    /// (See `BufReadDecoder::next_lossy` and `BufReadDecoderError::lossy`.)
+    InvalidByteSequence(&'a [u8]),
+
+    /// An I/O error from the underlying byte stream
+    Io(io::Error),
+}
+
+impl<'a> fmt::Display for BufReadDecoderError<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            BufReadDecoderError::InvalidByteSequence(bytes) => {
+                write!(f, "invalid byte sequence: {bytes:02x?}")
+            }
+            BufReadDecoderError::Io(ref err) => write!(f, "underlying bytestream error: {err}"),
+        }
+    }
+}
+
+impl<'a> Error for BufReadDecoderError<'a> {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match *self {
+            BufReadDecoderError::InvalidByteSequence(_) => None,
+            BufReadDecoderError::Io(ref err) => Some(err),
+        }
+    }
+}
+
+impl<B: BufRead> BufReadDecoder<B> {
+    pub fn new(buf_read: B) -> Self {
+        Self {
+            buf_read,
+            bytes_consumed: 0,
+            incomplete: Incomplete::empty(),
+        }
+    }
+
+    /// Decode and consume the next chunk of UTF-8 input.
+    ///
+    /// This method is intended to be called repeatedly until it returns `None`,
+    /// which represents EOF from the underlying byte stream.
+    /// This is similar to `Iterator::next`,
+    /// except that decoded chunks borrow the decoder (~iterator)
+    /// so they need to be handled or copied before the next chunk can start decoding.
+    #[allow(clippy::cognitive_complexity)]
+    pub fn next_strict(&mut self) -> Option<Result<&str, BufReadDecoderError>> {
+        enum BytesSource {
+            BufRead(usize),
+            Incomplete,
+        }
+        macro_rules! try_io {
+            ($io_result: expr) => {
+                match $io_result {
+                    Ok(value) => value,
+                    Err(error) => return Some(Err(BufReadDecoderError::Io(error))),
+                }
+            };
+        }
+        let (source, result) = loop {
+            if self.bytes_consumed > 0 {
+                self.buf_read.consume(self.bytes_consumed);
+                self.bytes_consumed = 0;
+            }
+            let buf = try_io!(self.buf_read.fill_buf());
+
+            // Force loop iteration to go through an explicit `continue`
+            enum Unreachable {}
+            let _: Unreachable = if self.incomplete.is_empty() {
+                if buf.is_empty() {
+                    return None; // EOF
+                }
+                match str::from_utf8(buf) {
+                    Ok(_) => break (BytesSource::BufRead(buf.len()), Ok(())),
+                    Err(error) => {
+                        let valid_up_to = error.valid_up_to();
+                        if valid_up_to > 0 {
+                            break (BytesSource::BufRead(valid_up_to), Ok(()));
+                        }
+                        match error.error_len() {
+                            Some(invalid_sequence_length) => {
+                                break (BytesSource::BufRead(invalid_sequence_length), Err(()))
+                            }
+                            None => {
+                                self.bytes_consumed = buf.len();
+                                self.incomplete = Incomplete::new(buf);
+                                // need more input bytes
+                                continue;
+                            }
+                        }
+                    }
+                }
+            } else {
+                if buf.is_empty() {
+                    break (BytesSource::Incomplete, Err(())); // EOF with incomplete code point
+                }
+                let (consumed, opt_result) = self.incomplete.try_complete_offsets(buf);
+                self.bytes_consumed = consumed;
+                match opt_result {
+                    None => {
+                        // need more input bytes
+                        continue;
+                    }
+                    Some(result) => break (BytesSource::Incomplete, result),
+                }
+            };
+        };
+        let bytes = match source {
+            BytesSource::BufRead(byte_count) => {
+                self.bytes_consumed = byte_count;
+                let buf = try_io!(self.buf_read.fill_buf());
+                &buf[..byte_count]
+            }
+            BytesSource::Incomplete => self.incomplete.take_buffer(),
+        };
+        match result {
+            Ok(()) => Some(Ok(unsafe { str::from_utf8_unchecked(bytes) })),
+            Err(()) => Some(Err(BufReadDecoderError::InvalidByteSequence(bytes))),
+        }
+    }
+}
diff --git a/src/uu/wc/src/wc.rs b/src/uu/wc/src/wc.rs
index 4a4838350..9fb8ca7a6 100644
--- a/src/uu/wc/src/wc.rs
+++ b/src/uu/wc/src/wc.rs
@@ -5,57 +5,79 @@
 //  * For the full copyright and license information, please view the LICENSE
 //  * file that was distributed with this source code.
 
-// cSpell:ignore wc wc's
+// cSpell:ignore ilog wc wc's
 
 mod count_fast;
 mod countable;
+mod utf8;
 mod word_count;
-use clap::builder::ValueParser;
-use count_fast::{count_bytes_chars_and_lines_fast, count_bytes_fast};
-use countable::WordCountable;
+
+use std::{
+    borrow::{Borrow, Cow},
+    cmp::max,
+    ffi::OsString,
+    fs::{self, File},
+    io::{self, Write},
+    iter,
+    path::{Path, PathBuf},
+};
+
+use clap::{builder::ValueParser, crate_version, Arg, ArgAction, ArgMatches, Command};
+use thiserror::Error;
 use unicode_width::UnicodeWidthChar;
 use utf8::{BufReadDecoder, BufReadDecoderError};
-use uucore::{format_usage, show};
-use word_count::{TitledWordCount, WordCount};
 
-use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
+use uucore::{
+    error::{FromIo, UError, UResult},
+    format_usage, help_about, help_usage,
+    quoting_style::{escape_name, QuotingStyle},
+    show,
+};
 
-use std::cmp::max;
-use std::error::Error;
-use std::ffi::{OsStr, OsString};
-use std::fmt::Display;
-use std::fs::{self, File};
-use std::io::{self, Read, Write};
-use std::path::PathBuf;
-
-use uucore::error::{UError, UResult, USimpleError};
-use uucore::quoting_style::{escape_name, QuotingStyle};
+use crate::{
+    count_fast::{count_bytes_chars_and_lines_fast, count_bytes_fast},
+    countable::WordCountable,
+    word_count::WordCount,
+};
 
 /// The minimum character width for formatting counts when reading from stdin.
 const MINIMUM_WIDTH: usize = 7;
 
-struct Settings {
+struct Settings<'a> {
     show_bytes: bool,
     show_chars: bool,
     show_lines: bool,
     show_words: bool,
     show_max_line_length: bool,
-    files0_from_stdin_mode: bool,
-    title_quoting_style: QuotingStyle,
+    files0_from: Option<Input<'a>>,
+    total_when: TotalWhen,
 }
 
-impl Settings {
-    fn new(matches: &ArgMatches) -> Self {
-        let title_quoting_style = QuotingStyle::Shell {
-            escape: true,
-            always_quote: false,
-            show_control: false,
-        };
+impl Default for Settings<'_> {
+    fn default() -> Self {
+        // Defaults if none of -c, -m, -l, -w, nor -L are specified.
+        Self {
+            show_bytes: true,
+            show_chars: false,
+            show_lines: true,
+            show_words: true,
+            show_max_line_length: false,
+            files0_from: None,
+            total_when: TotalWhen::default(),
+        }
+    }
+}
 
-        let files0_from_stdin_mode = match matches.get_one::<String>(options::FILES0_FROM) {
-            Some(files_0_from) => files_0_from == STDIN_REPR,
-            None => false,
-        };
+impl<'a> Settings<'a> {
+    fn new(matches: &'a ArgMatches) -> Self {
+        let files0_from = matches
+            .get_one::<OsString>(options::FILES0_FROM)
+            .map(Into::into);
+
+        let total_when = matches
+            .get_one::<String>(options::TOTAL)
+            .map(Into::into)
+            .unwrap_or_default();
 
         let settings = Self {
             show_bytes: matches.get_flag(options::BYTES),
@@ -63,131 +85,293 @@ impl Settings {
             show_lines: matches.get_flag(options::LINES),
             show_words: matches.get_flag(options::WORDS),
             show_max_line_length: matches.get_flag(options::MAX_LINE_LENGTH),
-            files0_from_stdin_mode,
-            title_quoting_style,
+            files0_from,
+            total_when,
         };
 
-        if settings.show_bytes
-            || settings.show_chars
-            || settings.show_lines
-            || settings.show_words
-            || settings.show_max_line_length
-        {
-            return settings;
-        }
-
-        Self {
-            show_bytes: true,
-            show_chars: false,
-            show_lines: true,
-            show_words: true,
-            show_max_line_length: false,
-            files0_from_stdin_mode,
-            title_quoting_style: settings.title_quoting_style,
+        if settings.number_enabled() > 0 {
+            settings
+        } else {
+            Self {
+                files0_from: settings.files0_from,
+                total_when,
+                ..Default::default()
+            }
         }
     }
 
     fn number_enabled(&self) -> u32 {
-        let mut result = 0;
-        result += self.show_bytes as u32;
-        result += self.show_chars as u32;
-        result += self.show_lines as u32;
-        result += self.show_max_line_length as u32;
-        result += self.show_words as u32;
-        result
+        [
+            self.show_bytes,
+            self.show_chars,
+            self.show_lines,
+            self.show_max_line_length,
+            self.show_words,
+        ]
+        .into_iter()
+        .map(Into::<u32>::into)
+        .sum()
     }
 }
 
-static ABOUT: &str = "Display newline, word, and byte counts for each FILE, and a total line if
-more than one FILE is specified. With no FILE, or when FILE is -, read standard input.";
-const USAGE: &str = "{} [OPTION]... [FILE]...";
+const ABOUT: &str = help_about!("wc.md");
+const USAGE: &str = help_usage!("wc.md");
 
-pub mod options {
+mod options {
     pub static BYTES: &str = "bytes";
     pub static CHAR: &str = "chars";
     pub static FILES0_FROM: &str = "files0-from";
     pub static LINES: &str = "lines";
     pub static MAX_LINE_LENGTH: &str = "max-line-length";
+    pub static TOTAL: &str = "total";
     pub static WORDS: &str = "words";
 }
-
 static ARG_FILES: &str = "files";
 static STDIN_REPR: &str = "-";
 
-enum StdinKind {
-    /// Stdin specified on command-line with "-".
-    Explicit,
+static QS_ESCAPE: &QuotingStyle = &QuotingStyle::Shell {
+    escape: true,
+    always_quote: false,
+    show_control: false,
+};
+static QS_QUOTE_ESCAPE: &QuotingStyle = &QuotingStyle::Shell {
+    escape: true,
+    always_quote: true,
+    show_control: false,
+};
 
-    /// Stdin implicitly specified on command-line by not passing any positional argument.
+/// Supported inputs.
+#[derive(Debug)]
+enum Inputs<'a> {
+    /// Default Standard input, i.e. no arguments.
+    Stdin,
+    /// Files; "-" means stdin, possibly multiple times!
+    Paths(Vec<Input<'a>>),
+    /// --files0-from; "-" means stdin.
+    Files0From(Input<'a>),
+}
+
+impl<'a> Inputs<'a> {
+    fn new(matches: &'a ArgMatches) -> UResult<Self> {
+        let arg_files = matches.get_many::<OsString>(ARG_FILES);
+        let files0_from = matches.get_one::<OsString>(options::FILES0_FROM);
+
+        match (arg_files, files0_from) {
+            (None, None) => Ok(Self::Stdin),
+            (Some(files), None) => Ok(Self::Paths(files.map(Into::into).collect())),
+            (None, Some(path)) => {
+                // If path is a file, and the file isn't too large, we'll load it ahead
+                // of time. Every path within the file will have its length checked to
+                // hopefully better align the output columns.
+                let input = Input::from(path);
+                match input.try_as_files0()? {
+                    Some(paths) => Ok(Self::Paths(paths)),
+                    None => Ok(Self::Files0From(input)),
+                }
+            }
+            (Some(_), Some(_)) => Err(WcError::FilesDisabled.into()),
+        }
+    }
+
+    // Creates an iterator which yields values borrowed from the command line arguments.
+    // Returns an error if the file specified in --files0-from cannot be opened.
+    fn try_iter(
+        &'a self,
+        settings: &'a Settings<'a>,
+    ) -> UResult<impl Iterator<Item = InputIterItem<'a>>> {
+        let base: Box<dyn Iterator<Item = _>> = match self {
+            Self::Stdin => Box::new(iter::once(Ok(Input::Stdin(StdinKind::Implicit)))),
+            Self::Paths(inputs) => Box::new(inputs.iter().map(|i| Ok(i.as_borrowed()))),
+            Self::Files0From(input) => match input {
+                Input::Path(path) => Box::new(files0_iter_file(path)?),
+                Input::Stdin(_) => Box::new(files0_iter_stdin()),
+            },
+        };
+
+        // The 1-based index of each yielded item must be tracked for error reporting.
+        let mut with_idx = base.enumerate().map(|(i, v)| (i + 1, v));
+        let files0_from_path = settings.files0_from.as_ref().map(|p| p.as_borrowed());
+
+        let iter = iter::from_fn(move || {
+            let (idx, next) = with_idx.next()?;
+            match next {
+                // filter zero length file names...
+                Ok(Input::Path(p)) if p.as_os_str().is_empty() => Some(Err({
+                    let maybe_ctx = files0_from_path.as_ref().map(|p| (p, idx));
+                    WcError::zero_len(maybe_ctx).into()
+                })),
+                _ => Some(next),
+            }
+        });
+        Ok(iter)
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+enum StdinKind {
+    /// Specified on command-line with "-" (STDIN_REPR)
+    Explicit,
+    /// Implied by the lack of any arguments
     Implicit,
 }
 
-/// Supported inputs.
-enum Input {
-    /// A regular file.
-    Path(PathBuf),
-
-    /// Standard input.
+/// Represents a single input, either to be counted or processed for other files names via
+/// --files0-from.
+#[derive(Debug)]
+enum Input<'a> {
+    Path(Cow<'a, Path>),
     Stdin(StdinKind),
 }
 
-impl From<&OsStr> for Input {
-    fn from(input: &OsStr) -> Self {
-        if input == STDIN_REPR {
+impl From<PathBuf> for Input<'_> {
+    fn from(p: PathBuf) -> Self {
+        if p.as_os_str() == STDIN_REPR {
             Self::Stdin(StdinKind::Explicit)
         } else {
-            Self::Path(input.into())
+            Self::Path(Cow::Owned(p))
         }
     }
 }
 
-impl Input {
-    /// Converts input to title that appears in stats.
-    fn to_title(&self, quoting_style: &QuotingStyle) -> Option<String> {
+impl<'a, T: AsRef<Path> + ?Sized> From<&'a T> for Input<'a> {
+    fn from(p: &'a T) -> Self {
+        let p = p.as_ref();
+        if p.as_os_str() == STDIN_REPR {
+            Self::Stdin(StdinKind::Explicit)
+        } else {
+            Self::Path(Cow::Borrowed(p))
+        }
+    }
+}
+
+impl<'a> Input<'a> {
+    /// Translates Path(Cow::Owned(_)) to Path(Cow::Borrowed(_)).
+    fn as_borrowed(&'a self) -> Self {
         match self {
-            Self::Path(path) => Some(escape_name(&path.clone().into_os_string(), quoting_style)),
-            Self::Stdin(StdinKind::Explicit) => {
-                Some(escape_name(OsStr::new(STDIN_REPR), quoting_style))
-            }
+            Self::Path(p) => Self::Path(Cow::Borrowed(p.borrow())),
+            Self::Stdin(k) => Self::Stdin(*k),
+        }
+    }
+
+    /// Converts input to title that appears in stats.
+    fn to_title(&self) -> Option<Cow<str>> {
+        match self {
+            Self::Path(path) => Some(match path.to_str() {
+                Some(s) if !s.contains('\n') => Cow::Borrowed(s),
+                _ => Cow::Owned(escape_name(path.as_os_str(), QS_ESCAPE)),
+            }),
+            Self::Stdin(StdinKind::Explicit) => Some(Cow::Borrowed(STDIN_REPR)),
             Self::Stdin(StdinKind::Implicit) => None,
         }
     }
 
-    fn path_display(&self, quoting_style: &QuotingStyle) -> String {
+    /// Converts input into the form that appears in errors.
+    fn path_display(&self) -> String {
         match self {
-            Self::Path(path) => escape_name(&path.clone().into_os_string(), quoting_style),
-            Self::Stdin(_) => escape_name(OsStr::new("standard input"), quoting_style),
+            Self::Path(path) => escape_name(path.as_os_str(), QS_ESCAPE),
+            Self::Stdin(_) => String::from("standard input"),
+        }
+    }
+
+    /// When given --files0-from, we may be given a path or stdin. Either may be a stream or
+    /// a regular file. If given a file less than 10 MiB, it will be consumed and turned into
+    /// a Vec of Input::Paths which can be scanned to determine the widths of the columns that
+    /// will ultimately be printed.
+    fn try_as_files0(&self) -> UResult<Option<Vec<Input<'static>>>> {
+        match self {
+            Self::Path(path) => match fs::metadata(path) {
+                Ok(meta) if meta.is_file() && meta.len() <= (10 << 20) => Ok(Some(
+                    files0_iter_file(path)?.collect::<Result<Vec<_>, _>>()?,
+                )),
+                _ => Ok(None),
+            },
+            Self::Stdin(_) if is_stdin_small_file() => {
+                Ok(Some(files0_iter_stdin().collect::<Result<Vec<_>, _>>()?))
+            }
+            Self::Stdin(_) => Ok(None),
         }
     }
 }
 
-#[derive(Debug)]
+#[cfg(unix)]
+fn is_stdin_small_file() -> bool {
+    use std::os::unix::io::{AsRawFd, FromRawFd};
+    // Safety: we'll rely on Rust to give us a valid RawFd for stdin with which we can attempt to
+    // open a File, but only for the sake of fetching .metadata().  ManuallyDrop will ensure we
+    // don't do anything else to the FD if anything unexpected happens.
+    let f = std::mem::ManuallyDrop::new(unsafe { File::from_raw_fd(io::stdin().as_raw_fd()) });
+    matches!(f.metadata(), Ok(meta) if meta.is_file() && meta.len() <= (10 << 20))
+}
+
+#[cfg(not(unix))]
+// Windows presents a piped stdin as a "normal file" with a length equal to however many bytes
+// have been buffered at the time it's checked. To be safe, we must never assume it's a file.
+fn is_stdin_small_file() -> bool {
+    false
+}
+
+/// When to show the "total" line
+#[derive(Clone, Copy, Default, PartialEq)]
+enum TotalWhen {
+    #[default]
+    Auto,
+    Always,
+    Only,
+    Never,
+}
+
+impl<T: AsRef<str>> From<T> for TotalWhen {
+    fn from(s: T) -> Self {
+        match s.as_ref() {
+            "auto" => Self::Auto,
+            "always" => Self::Always,
+            "only" => Self::Only,
+            "never" => Self::Never,
+            _ => unreachable!("Should have been caught by clap"),
+        }
+    }
+}
+
+impl TotalWhen {
+    fn is_total_row_visible(&self, num_inputs: usize) -> bool {
+        match self {
+            Self::Auto => num_inputs > 1,
+            Self::Always | Self::Only => true,
+            Self::Never => false,
+        }
+    }
+}
+
+#[derive(Debug, Error)]
 enum WcError {
-    FilesDisabled(String),
-    StdinReprNotAllowed(String),
+    #[error("file operands cannot be combined with --files0-from")]
+    FilesDisabled,
+    #[error("when reading file names from stdin, no file name of '-' allowed")]
+    StdinReprNotAllowed,
+    #[error("invalid zero-length file name")]
+    ZeroLengthFileName,
+    #[error("{path}:{idx}: invalid zero-length file name")]
+    ZeroLengthFileNameCtx { path: Cow<'static, str>, idx: usize },
+}
+
+impl WcError {
+    fn zero_len(ctx: Option<(&Input, usize)>) -> Self {
+        match ctx {
+            Some((input, idx)) => {
+                let path = match input {
+                    Input::Stdin(_) => STDIN_REPR.into(),
+                    Input::Path(path) => escape_name(path.as_os_str(), QS_ESCAPE).into(),
+                };
+                Self::ZeroLengthFileNameCtx { path, idx }
+            }
+            None => Self::ZeroLengthFileName,
+        }
+    }
 }
 
 impl UError for WcError {
-    fn code(&self) -> i32 {
-        match self {
-            Self::FilesDisabled(_) | Self::StdinReprNotAllowed(_) => 1,
-        }
-    }
-
     fn usage(&self) -> bool {
-        matches!(self, Self::FilesDisabled(_))
-    }
-}
-
-impl Error for WcError {}
-
-impl Display for WcError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::FilesDisabled(message) | Self::StdinReprNotAllowed(message) => {
-                write!(f, "{message}")
-            }
-        }
+        matches!(self, Self::FilesDisabled)
     }
 }
 
@@ -195,9 +379,8 @@ impl Display for WcError {
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app().try_get_matches_from(args)?;
 
-    let inputs = inputs(&matches)?;
-
     let settings = Settings::new(&matches);
+    let inputs = Inputs::new(&matches)?;
 
     wc(&inputs, &settings)
 }
@@ -226,11 +409,12 @@ pub fn uu_app() -> Command {
             Arg::new(options::FILES0_FROM)
                 .long(options::FILES0_FROM)
                 .value_name("F")
-                .help(
-                    "read input from the files specified by
-    NUL-terminated names in file F;
-    If F is - then read names from standard input",
-                )
+                .help(concat!(
+                    "read input from the files specified by\n",
+                    "  NUL-terminated names in file F;\n",
+                    "  If F is - then read names from standard input"
+                ))
+                .value_parser(ValueParser::os_string())
                 .value_hint(clap::ValueHint::FilePath),
         )
         .arg(
@@ -247,6 +431,17 @@ pub fn uu_app() -> Command {
                 .help("print the length of the longest line")
                 .action(ArgAction::SetTrue),
         )
+        .arg(
+            Arg::new(options::TOTAL)
+                .long(options::TOTAL)
+                .value_parser(["auto", "always", "only", "never"])
+                .value_name("WHEN")
+                .hide_possible_values(true)
+                .help(concat!(
+                    "when to print a line with total counts;\n",
+                    "  WHEN can be: auto, always, only, never"
+                )),
+        )
         .arg(
             Arg::new(options::WORDS)
                 .short('w')
@@ -262,47 +457,6 @@ pub fn uu_app() -> Command {
         )
 }
 
-fn inputs(matches: &ArgMatches) -> UResult<Vec<Input>> {
-    match matches.get_many::<OsString>(ARG_FILES) {
-        Some(os_values) => {
-            if matches.contains_id(options::FILES0_FROM) {
-                return Err(WcError::FilesDisabled(
-                    "file operands cannot be combined with --files0-from".into(),
-                )
-                .into());
-            }
-
-            Ok(os_values.map(|s| Input::from(s.as_os_str())).collect())
-        }
-        None => match matches.get_one::<String>(options::FILES0_FROM) {
-            Some(files_0_from) => create_paths_from_files0(files_0_from),
-            None => Ok(vec![Input::Stdin(StdinKind::Implicit)]),
-        },
-    }
-}
-
-fn create_paths_from_files0(files_0_from: &str) -> UResult<Vec<Input>> {
-    let mut paths = String::new();
-    let read_from_stdin = files_0_from == STDIN_REPR;
-
-    if read_from_stdin {
-        io::stdin().lock().read_to_string(&mut paths)?;
-    } else {
-        File::open(files_0_from)?.read_to_string(&mut paths)?;
-    }
-
-    let paths: Vec<&str> = paths.split_terminator('\0').collect();
-
-    if read_from_stdin && paths.contains(&STDIN_REPR) {
-        return Err(WcError::StdinReprNotAllowed(
-            "when reading file names from stdin, no file name of '-' allowed".into(),
-        )
-        .into());
-    }
-
-    Ok(paths.iter().map(OsStr::new).map(Input::from).collect())
-}
-
 fn word_count_from_reader<T: WordCountable>(
     mut reader: T,
     settings: &Settings,
@@ -406,6 +560,7 @@ fn word_count_from_reader<T: WordCountable>(
     }
 }
 
+#[allow(clippy::cognitive_complexity)]
 fn word_count_from_reader_specialized<
     T: WordCountable,
     const SHOW_CHARS: bool,
@@ -483,171 +638,250 @@ enum CountResult {
     Failure(io::Error),
 }
 
-/// If we fail opening a file we only show the error. If we fail reading it
-/// we show a count for what we managed to read.
+/// If we fail opening a file, we only show the error. If we fail reading the
+/// file, we show a count for what we managed to read.
 ///
-/// Therefore the reading implementations always return a total and sometimes
+/// Therefore, the reading implementations always return a total and sometimes
 /// return an error: (WordCount, Option<io::Error>).
-fn word_count_from_input(input: &Input, settings: &Settings) -> CountResult {
-    match input {
-        Input::Stdin(_) => {
-            let stdin = io::stdin();
-            let stdin_lock = stdin.lock();
-            let count = word_count_from_reader(stdin_lock, settings);
-            match count {
-                (total, Some(error)) => CountResult::Interrupted(total, error),
-                (total, None) => CountResult::Success(total),
-            }
-        }
+fn word_count_from_input(input: &Input<'_>, settings: &Settings) -> CountResult {
+    let (total, maybe_err) = match input {
+        Input::Stdin(_) => word_count_from_reader(io::stdin().lock(), settings),
         Input::Path(path) => match File::open(path) {
-            Err(error) => CountResult::Failure(error),
-            Ok(file) => match word_count_from_reader(file, settings) {
-                (total, Some(error)) => CountResult::Interrupted(total, error),
-                (total, None) => CountResult::Success(total),
-            },
+            Ok(f) => word_count_from_reader(f, settings),
+            Err(err) => return CountResult::Failure(err),
         },
+    };
+    match maybe_err {
+        None => CountResult::Success(total),
+        Some(err) => CountResult::Interrupted(total, err),
     }
 }
 
 /// Compute the number of digits needed to represent all counts in all inputs.
 ///
-/// `inputs` may include zero or more [`Input::Stdin`] entries, each of
-/// which represents reading from `stdin`. The presence of any such
-/// entry causes this function to return a width that is at least
-/// [`MINIMUM_WIDTH`].
+/// For [`Inputs::Stdin`], [`MINIMUM_WIDTH`] is returned, unless there is only one counter number
+/// to be printed, in which case 1 is returned.
 ///
-/// If `input` is empty, or if only one number needs to be printed (for just
-/// one file) then this function is optimized to return 1 without making any
-/// calls to get file metadata.
+/// For [`Inputs::Files0From`], [`MINIMUM_WIDTH`] is returned.
 ///
-/// If file metadata could not be read from any of the [`Input::Path`] input,
-/// that input does not affect number width computation
+/// An [`Inputs::Paths`] may include zero or more "-" entries, each of which represents reading
+/// from `stdin`. The presence of any such entry causes this function to return a width that is at
+/// least [`MINIMUM_WIDTH`].
 ///
-/// Otherwise, the file sizes in the file metadata are summed and the number of
-/// digits in that total size is returned as the number width
+/// If an [`Inputs::Paths`] contains only one path and only one number needs to be printed then
+/// this function is optimized to return 1 without making any calls to get file metadata.
 ///
-/// To mirror GNU wc's behavior a special case is added. If --files0-from is
-/// used and input is read from stdin and there is only one calculation enabled
-/// columns will not be aligned. This is not exactly GNU wc's behavior, but it
-/// is close enough to pass the GNU test suite.
-fn compute_number_width(inputs: &[Input], settings: &Settings) -> usize {
-    if inputs.is_empty()
-        || (inputs.len() == 1 && settings.number_enabled() == 1)
-        || (settings.files0_from_stdin_mode && settings.number_enabled() == 1)
-    {
-        return 1;
-    }
-
-    let mut minimum_width = 1;
-    let mut total = 0;
-
-    for input in inputs {
-        match input {
-            Input::Stdin(_) => {
-                minimum_width = MINIMUM_WIDTH;
+/// If file metadata could not be read from any of the [`Input::Path`] input, that input does not
+/// affect number width computation.  Otherwise, the file sizes from the files' metadata are summed
+/// and the number of digits in that total size is returned.
+fn compute_number_width(inputs: &Inputs, settings: &Settings) -> usize {
+    match inputs {
+        Inputs::Stdin if settings.number_enabled() == 1 => 1,
+        Inputs::Stdin => MINIMUM_WIDTH,
+        Inputs::Files0From(_) => 1,
+        Inputs::Paths(inputs) => {
+            if settings.number_enabled() == 1 && inputs.len() == 1 {
+                return 1;
             }
-            Input::Path(path) => {
-                if let Ok(meta) = fs::metadata(path) {
-                    if meta.is_file() {
-                        total += meta.len();
-                    } else {
-                        minimum_width = MINIMUM_WIDTH;
+
+            let mut minimum_width = 1;
+            let mut total: u64 = 0;
+            for input in inputs.iter() {
+                match input {
+                    Input::Stdin(_) => minimum_width = MINIMUM_WIDTH,
+                    Input::Path(path) => {
+                        if let Ok(meta) = fs::metadata(path) {
+                            if meta.is_file() {
+                                total += meta.len();
+                            } else {
+                                minimum_width = MINIMUM_WIDTH;
+                            }
+                        }
                     }
                 }
             }
+
+            if total == 0 {
+                minimum_width
+            } else {
+                let total_width = (1 + ilog10_u64(total))
+                    .try_into()
+                    .expect("ilog of a u64 should fit into a usize");
+                max(total_width, minimum_width)
+            }
         }
     }
-
-    max(minimum_width, total.to_string().len())
 }
 
-fn wc(inputs: &[Input], settings: &Settings) -> UResult<()> {
-    let number_width = compute_number_width(inputs, settings);
+type InputIterItem<'a> = Result<Input<'a>, Box<dyn UError>>;
 
+/// To be used with `--files0-from=-`, this applies a filter on the results of files0_iter to
+/// translate '-' into the appropriate error.
+fn files0_iter_stdin<'a>() -> impl Iterator<Item = InputIterItem<'a>> {
+    files0_iter(io::stdin().lock(), STDIN_REPR.into()).map(|i| match i {
+        Ok(Input::Stdin(_)) => Err(WcError::StdinReprNotAllowed.into()),
+        _ => i,
+    })
+}
+
+fn files0_iter_file<'a>(path: &Path) -> UResult<impl Iterator<Item = InputIterItem<'a>>> {
+    match File::open(path) {
+        Ok(f) => Ok(files0_iter(f, path.into())),
+        Err(e) => Err(e.map_err_context(|| {
+            format!(
+                "cannot open {} for reading",
+                escape_name(path.as_os_str(), QS_QUOTE_ESCAPE)
+            )
+        })),
+    }
+}
+
+fn files0_iter<'a>(
+    r: impl io::Read + 'static,
+    err_path: OsString,
+) -> impl Iterator<Item = InputIterItem<'a>> {
+    use std::io::BufRead;
+    let mut i = Some(
+        io::BufReader::new(r)
+            .split(b'\0')
+            .map(move |res| match res {
+                Ok(p) if p == STDIN_REPR.as_bytes() => Ok(Input::Stdin(StdinKind::Explicit)),
+                Ok(p) => {
+                    // On Unix systems, OsStrings are just strings of bytes, not necessarily UTF-8.
+                    #[cfg(unix)]
+                    {
+                        use std::os::unix::ffi::OsStringExt;
+                        Ok(Input::Path(PathBuf::from(OsString::from_vec(p)).into()))
+                    }
+
+                    // ...Windows does not, we must go through Strings.
+                    #[cfg(not(unix))]
+                    {
+                        let s = String::from_utf8(p)
+                            .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+                        Ok(Input::Path(PathBuf::from(s).into()))
+                    }
+                }
+                Err(e) => Err(e.map_err_context(|| {
+                    format!("{}: read error", escape_name(&err_path, QS_ESCAPE))
+                }) as Box<dyn UError>),
+            }),
+    );
+    // Loop until there is an error; yield that error and then nothing else.
+    std::iter::from_fn(move || {
+        let next = i.as_mut().and_then(Iterator::next);
+        if matches!(next, Some(Err(_)) | None) {
+            i = None;
+        }
+        next
+    })
+}
+
+fn wc(inputs: &Inputs, settings: &Settings) -> UResult<()> {
     let mut total_word_count = WordCount::default();
+    let mut num_inputs: usize = 0;
 
-    let num_inputs = inputs.len();
+    let (number_width, are_stats_visible) = match settings.total_when {
+        TotalWhen::Only => (1, false),
+        _ => (compute_number_width(inputs, settings), true),
+    };
 
-    for input in inputs {
-        let word_count = match word_count_from_input(input, settings) {
+    for maybe_input in inputs.try_iter(settings)? {
+        num_inputs += 1;
+
+        let input = match maybe_input {
+            Ok(input) => input,
+            Err(err) => {
+                show!(err);
+                continue;
+            }
+        };
+
+        let word_count = match word_count_from_input(&input, settings) {
             CountResult::Success(word_count) => word_count,
-            CountResult::Interrupted(word_count, error) => {
-                show!(USimpleError::new(
-                    1,
-                    format!(
-                        "{}: {}",
-                        input.path_display(&settings.title_quoting_style),
-                        error
-                    )
-                ));
+            CountResult::Interrupted(word_count, err) => {
+                show!(err.map_err_context(|| input.path_display()));
                 word_count
             }
-            CountResult::Failure(error) => {
-                show!(USimpleError::new(
-                    1,
-                    format!(
-                        "{}: {}",
-                        input.path_display(&settings.title_quoting_style),
-                        error
-                    )
-                ));
+            CountResult::Failure(err) => {
+                show!(err.map_err_context(|| input.path_display()));
                 continue;
             }
         };
         total_word_count += word_count;
-        let result = word_count.with_title(input.to_title(&settings.title_quoting_style));
-        if let Err(err) = print_stats(settings, &result, number_width) {
-            show!(USimpleError::new(
-                1,
-                format!(
-                    "failed to print result for {}: {}",
-                    &result.title.unwrap_or_else(|| String::from("<stdin>")),
-                    err,
-                ),
-            ));
+        if are_stats_visible {
+            let maybe_title = input.to_title();
+            let maybe_title_str = maybe_title.as_deref();
+            if let Err(err) = print_stats(settings, &word_count, maybe_title_str, number_width) {
+                let title = maybe_title_str.unwrap_or("<stdin>");
+                show!(err.map_err_context(|| format!("failed to print result for {title}")));
+            }
         }
     }
 
-    if num_inputs > 1 {
-        let total_result = total_word_count.with_title(Some(String::from("total")));
-        if let Err(err) = print_stats(settings, &total_result, number_width) {
-            show!(USimpleError::new(
-                1,
-                format!("failed to print total: {err}")
-            ));
+    if settings.total_when.is_total_row_visible(num_inputs) {
+        let title = are_stats_visible.then_some("total");
+        if let Err(err) = print_stats(settings, &total_word_count, title, number_width) {
+            show!(err.map_err_context(|| "failed to print total".into()));
         }
     }
 
-    // Although this appears to be returning `Ok`, the exit code may
-    // have been set to a non-zero value by a call to `show!()` above.
+    // Although this appears to be returning `Ok`, the exit code may have been set to a non-zero
+    // value by a call to `record_error!()` above.
     Ok(())
 }
 
 fn print_stats(
     settings: &Settings,
-    result: &TitledWordCount,
+    result: &WordCount,
+    title: Option<&str>,
     number_width: usize,
 ) -> io::Result<()> {
-    let mut columns = Vec::new();
+    let mut stdout = io::stdout().lock();
 
-    if settings.show_lines {
-        columns.push(format!("{:1$}", result.count.lines, number_width));
-    }
-    if settings.show_words {
-        columns.push(format!("{:1$}", result.count.words, number_width));
-    }
-    if settings.show_chars {
-        columns.push(format!("{:1$}", result.count.chars, number_width));
-    }
-    if settings.show_bytes {
-        columns.push(format!("{:1$}", result.count.bytes, number_width));
-    }
-    if settings.show_max_line_length {
-        columns.push(format!("{:1$}", result.count.max_line_length, number_width));
-    }
-    if let Some(title) = &result.title {
-        columns.push(title.clone());
+    let maybe_cols = [
+        (settings.show_lines, result.lines),
+        (settings.show_words, result.words),
+        (settings.show_chars, result.chars),
+        (settings.show_bytes, result.bytes),
+        (settings.show_max_line_length, result.max_line_length),
+    ];
+
+    let mut space = "";
+    for (_, num) in maybe_cols.iter().filter(|(show, _)| *show) {
+        write!(stdout, "{space}{num:number_width$}")?;
+        space = " ";
     }
 
-    writeln!(io::stdout().lock(), "{}", columns.join(" "))
+    if let Some(title) = title {
+        writeln!(stdout, "{space}{title}")
+    } else {
+        writeln!(stdout)
+    }
+}
+
+// TODO: remove and just use usize::ilog10 once the MSRV is >= 1.67.
+fn ilog10_u64(mut u: u64) -> u32 {
+    if u == 0 {
+        panic!("cannot compute log of 0")
+    }
+    let mut log = 0;
+    if u >= 10_000_000_000 {
+        log += 10;
+        u /= 10_000_000_000;
+    }
+    if u >= 100_000 {
+        log += 5;
+        u /= 100_000;
+    }
+    // Rust's standard library in versions >= 1.67 does something even more clever than this, but
+    // this should work just fine for the time being.
+    log + match u {
+        1..=9 => 0,
+        10..=99 => 1,
+        100..=999 => 2,
+        1000..=9999 => 3,
+        10000..=99999 => 4,
+        _ => unreachable!(),
+    }
 }
diff --git a/src/uu/wc/src/word_count.rs b/src/uu/wc/src/word_count.rs
index b2dd70450..cf839175f 100644
--- a/src/uu/wc/src/word_count.rs
+++ b/src/uu/wc/src/word_count.rs
@@ -29,19 +29,3 @@ impl AddAssign for WordCount {
         *self = *self + other;
     }
 }
-
-impl WordCount {
-    pub fn with_title(self, title: Option<String>) -> TitledWordCount {
-        TitledWordCount { title, count: self }
-    }
-}
-
-/// This struct supplements the actual word count with an optional title that is
-/// displayed to the user at the end of the program.
-/// The reason we don't simply include title in the `WordCount` struct is that
-/// it would result in unnecessary copying of `String`.
-#[derive(Debug, Default, Clone)]
-pub struct TitledWordCount {
-    pub title: Option<String>,
-    pub count: WordCount,
-}
diff --git a/src/uu/wc/wc.md b/src/uu/wc/wc.md
new file mode 100644
index 000000000..c7aaf8545
--- /dev/null
+++ b/src/uu/wc/wc.md
@@ -0,0 +1,8 @@
+# wc
+
+```
+wc [OPTION]... [FILE]...
+```
+
+Display newline, word, and byte counts for each FILE, and a total line if
+more than one FILE is specified. With no FILE, or when FILE is -, read standard input.
diff --git a/src/uu/who/Cargo.toml b/src/uu/who/Cargo.toml
index 31c557508..bfbd7909d 100644
--- a/src/uu/who/Cargo.toml
+++ b/src/uu/who/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_who"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "who ~ (uutils) display information about currently logged-in users"
@@ -15,8 +15,8 @@ edition = "2021"
 path = "src/who.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true, features=["utmpx"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["utmpx"] }
 
 [[bin]]
 name = "who"
diff --git a/src/uu/who/src/who.rs b/src/uu/who/src/who.rs
index 935319c31..fbfff80d7 100644
--- a/src/uu/who/src/who.rs
+++ b/src/uu/who/src/who.rs
@@ -18,7 +18,7 @@ use std::ffi::CStr;
 use std::fmt::Write;
 use std::os::unix::fs::MetadataExt;
 use std::path::PathBuf;
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
 
 mod options {
     pub const ALL: &str = "all";
@@ -38,8 +38,8 @@ mod options {
     pub const FILE: &str = "FILE"; // if length=1: FILE, if length=2: ARG1 ARG2
 }
 
-static ABOUT: &str = "Print information about users who are currently logged in.";
-const USAGE: &str = "{} [OPTION]... [ FILE | ARG1 ARG2 ]";
+const ABOUT: &str = help_about!("who.md");
+const USAGE: &str = help_usage!("who.md");
 
 #[cfg(target_os = "linux")]
 static RUNLEVEL_HELP: &str = "print current runlevel";
@@ -316,13 +316,13 @@ fn time_string(ut: &Utmpx) -> String {
 fn current_tty() -> String {
     unsafe {
         let res = ttyname(STDIN_FILENO);
-        if !res.is_null() {
+        if res.is_null() {
+            String::new()
+        } else {
             CStr::from_ptr(res as *const _)
                 .to_string_lossy()
                 .trim_start_matches("/dev/")
                 .to_owned()
-        } else {
-            String::new()
         }
     }
 }
@@ -402,7 +402,7 @@ impl Who {
             &time_string(ut),
             "",
             "",
-            if !last.is_control() { &comment } else { "" },
+            if last.is_control() { "" } else { &comment },
             "",
         );
     }
@@ -482,7 +482,7 @@ impl Who {
                 let iwgrp = S_IWGRP;
                 #[cfg(any(target_os = "android", target_os = "freebsd", target_vendor = "apple"))]
                 let iwgrp = S_IWGRP as u32;
-                mesg = if meta.mode() & iwgrp != 0 { '+' } else { '-' };
+                mesg = if meta.mode() & iwgrp == 0 { '-' } else { '+' };
                 last_change = meta.atime();
             }
             _ => {
@@ -491,10 +491,10 @@ impl Who {
             }
         }
 
-        let idle = if last_change != 0 {
-            idle_string(last_change, 0)
-        } else {
+        let idle = if last_change == 0 {
             "  ?".into()
+        } else {
+            idle_string(last_change, 0)
         };
 
         let s = if self.do_lookup {
diff --git a/src/uu/who/who.md b/src/uu/who/who.md
new file mode 100644
index 000000000..6adc26597
--- /dev/null
+++ b/src/uu/who/who.md
@@ -0,0 +1,8 @@
+# who
+
+```
+who [OPTION]... [ FILE | ARG1 ARG2 ]
+```
+
+Print information about users who are currently logged in.
+
diff --git a/src/uu/whoami/Cargo.toml b/src/uu/whoami/Cargo.toml
index 15a7ad4ce..fe06a0a7e 100644
--- a/src/uu/whoami/Cargo.toml
+++ b/src/uu/whoami/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_whoami"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "whoami ~ (uutils) display user name of current effective user ID"
@@ -15,14 +15,18 @@ edition = "2021"
 path = "src/whoami.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore = { workspace=true, features=["entries"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["entries"] }
 
 [target.'cfg(target_os = "windows")'.dependencies]
-windows-sys = { workspace=true, features = ["Win32_NetworkManagement_NetManagement", "Win32_System_WindowsProgramming", "Win32_Foundation"] }
+windows-sys = { workspace = true, features = [
+  "Win32_NetworkManagement_NetManagement",
+  "Win32_System_WindowsProgramming",
+  "Win32_Foundation",
+] }
 
 [target.'cfg(unix)'.dependencies]
-libc = { workspace=true }
+libc = { workspace = true }
 
 [[bin]]
 name = "whoami"
diff --git a/src/uu/whoami/src/whoami.rs b/src/uu/whoami/src/whoami.rs
index 18c61e28e..04360fe7a 100644
--- a/src/uu/whoami/src/whoami.rs
+++ b/src/uu/whoami/src/whoami.rs
@@ -11,10 +11,12 @@ use clap::{crate_version, Command};
 
 use uucore::display::println_verbatim;
 use uucore::error::{FromIo, UResult};
+use uucore::{format_usage, help_about, help_usage};
 
 mod platform;
 
-static ABOUT: &str = "Print the current username.";
+const ABOUT: &str = help_about!("whoami.md");
+const USAGE: &str = help_usage!("whoami.md");
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
@@ -28,5 +30,6 @@ pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
         .infer_long_args(true)
 }
diff --git a/src/uu/whoami/whoami.md b/src/uu/whoami/whoami.md
new file mode 100644
index 000000000..6106d24ee
--- /dev/null
+++ b/src/uu/whoami/whoami.md
@@ -0,0 +1,7 @@
+# whoami
+
+```
+whoami
+```
+
+Print the current username.
diff --git a/src/uu/yes/Cargo.toml b/src/uu/yes/Cargo.toml
index cf120f2e0..0e2b934f3 100644
--- a/src/uu/yes/Cargo.toml
+++ b/src/uu/yes/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_yes"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "yes ~ (uutils) repeatedly display a line with STRING (or 'y')"
@@ -15,12 +15,15 @@ edition = "2021"
 path = "src/yes.rs"
 
 [dependencies]
-clap = { workspace=true }
-libc = { workspace=true }
-uucore = { workspace=true, features=["pipes"] }
+clap = { workspace = true }
+itertools = { workspace = true }
 
-[target.'cfg(any(target_os = "linux", target_os = "android"))'.dependencies]
-nix = { workspace=true }
+[target.'cfg(unix)'.dependencies]
+uucore = { workspace = true, features = ["pipes", "signals"] }
+nix = { workspace = true }
+
+[target.'cfg(not(unix))'.dependencies]
+uucore = { workspace = true, features = ["pipes"] }
 
 [[bin]]
 name = "yes"
diff --git a/src/uu/yes/src/yes.rs b/src/uu/yes/src/yes.rs
index 714bdcac5..fd5124064 100644
--- a/src/uu/yes/src/yes.rs
+++ b/src/uu/yes/src/yes.rs
@@ -7,13 +7,16 @@
 
 /* last synced with: yes (GNU coreutils) 8.13 */
 
-use std::borrow::Cow;
-use std::io::{self, Result, Write};
+// cSpell:ignore strs
 
-use clap::{Arg, ArgAction, Command};
+use clap::{builder::ValueParser, Arg, ArgAction, Command};
+use std::error::Error;
+use std::ffi::OsString;
+use std::io::{self, Write};
 use uucore::error::{UResult, USimpleError};
+#[cfg(unix)]
+use uucore::signals::enable_pipe_errors;
 use uucore::{format_usage, help_about, help_usage};
-
 #[cfg(any(target_os = "linux", target_os = "android"))]
 mod splice;
 
@@ -28,19 +31,11 @@ const BUF_SIZE: usize = 16 * 1024;
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app().try_get_matches_from(args)?;
 
-    let string = if let Some(values) = matches.get_many::<String>("STRING") {
-        let mut result = values.fold(String::new(), |res, s| res + s + " ");
-        result.pop();
-        result.push('\n');
-        Cow::from(result)
-    } else {
-        Cow::from("y\n")
-    };
+    let mut buffer = Vec::with_capacity(BUF_SIZE);
+    args_into_buffer(&mut buffer, matches.get_many::<OsString>("STRING")).unwrap();
+    prepare_buffer(&mut buffer);
 
-    let mut buffer = [0; BUF_SIZE];
-    let bytes = prepare_buffer(&string, &mut buffer);
-
-    match exec(bytes) {
+    match exec(&buffer) {
         Ok(()) => Ok(()),
         Err(err) if err.kind() == io::ErrorKind::BrokenPipe => Ok(()),
         Err(err) => Err(USimpleError::new(1, format!("standard output: {err}"))),
@@ -51,43 +46,80 @@ pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
-        .arg(Arg::new("STRING").action(ArgAction::Append))
+        .arg(
+            Arg::new("STRING")
+                .value_parser(ValueParser::os_string())
+                .action(ArgAction::Append),
+        )
         .infer_long_args(true)
 }
 
-fn prepare_buffer<'a>(input: &'a str, buffer: &'a mut [u8; BUF_SIZE]) -> &'a [u8] {
-    if input.len() < BUF_SIZE / 2 {
-        let mut size = 0;
-        while size < BUF_SIZE - input.len() {
-            let (_, right) = buffer.split_at_mut(size);
-            right[..input.len()].copy_from_slice(input.as_bytes());
-            size += input.len();
-        }
-        &buffer[..size]
+// Copies words from `i` into `buf`, separated by spaces.
+fn args_into_buffer<'a>(
+    buf: &mut Vec<u8>,
+    i: Option<impl Iterator<Item = &'a OsString>>,
+) -> Result<(), Box<dyn Error>> {
+    // TODO: this should be replaced with let/else once available in the MSRV.
+    let i = if let Some(i) = i {
+        i
     } else {
-        input.as_bytes()
-    }
-}
+        buf.extend_from_slice(b"y\n");
+        return Ok(());
+    };
 
-#[cfg(unix)]
-fn enable_pipe_errors() -> Result<()> {
-    let ret = unsafe { libc::signal(libc::SIGPIPE, libc::SIG_DFL) };
-    if ret == libc::SIG_ERR {
-        return Err(io::Error::new(io::ErrorKind::Other, ""));
+    // On Unix (and wasi), OsStrs are just &[u8]'s underneath...
+    #[cfg(any(unix, target_os = "wasi"))]
+    {
+        #[cfg(unix)]
+        use std::os::unix::ffi::OsStrExt;
+        #[cfg(target_os = "wasi")]
+        use std::os::wasi::ffi::OsStrExt;
+
+        for part in itertools::intersperse(i.map(|a| a.as_bytes()), b" ") {
+            buf.extend_from_slice(part);
+        }
     }
+
+    // But, on Windows, we must hop through a String.
+    #[cfg(not(any(unix, target_os = "wasi")))]
+    {
+        for part in itertools::intersperse(i.map(|a| a.to_str()), Some(" ")) {
+            let bytes = match part {
+                Some(part) => part.as_bytes(),
+                None => return Err("arguments contain invalid UTF-8".into()),
+            };
+            buf.extend_from_slice(bytes);
+        }
+    }
+
+    buf.push(b'\n');
+
     Ok(())
 }
 
-#[cfg(not(unix))]
-fn enable_pipe_errors() -> Result<()> {
-    // Do nothing.
-    Ok(())
+// Assumes buf holds a single output line forged from the command line arguments, copies it
+// repeatedly until the buffer holds as many copies as it can under BUF_SIZE.
+fn prepare_buffer(buf: &mut Vec<u8>) {
+    if buf.len() * 2 > BUF_SIZE {
+        return;
+    }
+
+    assert!(!buf.is_empty());
+
+    let line_len = buf.len();
+    let target_size = line_len * (BUF_SIZE / line_len);
+
+    while buf.len() < target_size {
+        let to_copy = std::cmp::min(target_size - buf.len(), buf.len());
+        debug_assert_eq!(to_copy % line_len, 0);
+        buf.extend_from_within(..to_copy);
+    }
 }
 
 pub fn exec(bytes: &[u8]) -> io::Result<()> {
     let stdout = io::stdout();
     let mut stdout = stdout.lock();
-
+    #[cfg(unix)]
     enable_pipe_errors()?;
 
     #[cfg(any(target_os = "linux", target_os = "android"))]
@@ -103,3 +135,67 @@ pub fn exec(bytes: &[u8]) -> io::Result<()> {
         stdout.write_all(bytes)?;
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_prepare_buffer() {
+        let tests = [
+            (150, 16350),
+            (1000, 16000),
+            (4093, 16372),
+            (4099, 12297),
+            (4111, 12333),
+            (2, 16384),
+            (3, 16383),
+            (4, 16384),
+            (5, 16380),
+            (8192, 16384),
+            (8191, 16382),
+            (8193, 8193),
+            (10000, 10000),
+            (15000, 15000),
+            (25000, 25000),
+        ];
+
+        for (line, final_len) in tests {
+            let mut v = std::iter::repeat(b'a').take(line).collect::<Vec<_>>();
+            prepare_buffer(&mut v);
+            assert_eq!(v.len(), final_len);
+        }
+    }
+
+    #[test]
+    fn test_args_into_buf() {
+        {
+            let mut v = Vec::with_capacity(BUF_SIZE);
+            args_into_buffer(&mut v, None::<std::slice::Iter<OsString>>).unwrap();
+            assert_eq!(String::from_utf8(v).unwrap(), "y\n");
+        }
+
+        {
+            let mut v = Vec::with_capacity(BUF_SIZE);
+            args_into_buffer(&mut v, Some([OsString::from("foo")].iter())).unwrap();
+            assert_eq!(String::from_utf8(v).unwrap(), "foo\n");
+        }
+
+        {
+            let mut v = Vec::with_capacity(BUF_SIZE);
+            args_into_buffer(
+                &mut v,
+                Some(
+                    [
+                        OsString::from("foo"),
+                        OsString::from("bar    baz"),
+                        OsString::from("qux"),
+                    ]
+                    .iter(),
+                ),
+            )
+            .unwrap();
+            assert_eq!(String::from_utf8(v).unwrap(), "foo bar    baz qux\n");
+        }
+    }
+}
diff --git a/src/uucore/Cargo.toml b/src/uucore/Cargo.toml
index f5bec9053..7fa4aa344 100644
--- a/src/uucore/Cargo.toml
+++ b/src/uucore/Cargo.toml
@@ -2,7 +2,7 @@
 
 [package]
 name = "uucore"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["uutils developers"]
 license = "MIT"
 description = "uutils ~ 'core' uutils code library (cross-platform)"
@@ -15,49 +15,58 @@ categories = ["command-line-utilities"]
 edition = "2021"
 
 [lib]
-path="src/lib/lib.rs"
+path = "src/lib/lib.rs"
 
 [dependencies]
-clap = { workspace=true }
-uucore_procs = { workspace=true }
-dns-lookup = { version="1.0.5", optional=true }
-dunce = "1.0.3"
-wild = "2.0"
-glob = "0.3.0"
+clap = { workspace = true }
+uucore_procs = { workspace = true }
+dns-lookup = { version = "2.0.2", optional = true }
+dunce = "1.0.4"
+wild = "2.1"
+glob = "0.3.1"
 # * optional
-itertools = { version="0.10.0", optional=true }
-thiserror = { workspace=true, optional=true }
-time = { workspace=true, optional=true, features = ["formatting", "local-offset", "macros"] }
+itertools = { version = "0.10.5", optional = true }
+thiserror = { workspace = true, optional = true }
+time = { workspace = true, optional = true, features = [
+  "formatting",
+  "local-offset",
+  "macros",
+] }
 # * "problem" dependencies (pinned)
-data-encoding = { version="2.1", optional=true }
-data-encoding-macro = { version="0.1.12", optional=true }
-z85 = { version="3.0.5", optional=true }
-libc = { version="0.2.137", optional=true }
-once_cell = { workspace=true }
+data-encoding = { version = "2.4", optional = true }
+data-encoding-macro = { version = "0.1.13", optional = true }
+z85 = { version = "3.0.5", optional = true }
+libc = { version = "0.2.146", optional = true }
+once_cell = { workspace = true }
 os_display = "0.1.3"
 
-digest = { workspace=true }
-hex = { workspace=true }
-memchr = { workspace=true }
-md-5 = { workspace=true }
-sha1 = { workspace=true }
-sha2 = { workspace=true }
-sha3 = { workspace=true }
-blake2b_simd = { workspace=true }
-blake3 = { workspace=true }
-sm3 = { workspace=true }
+digest = { workspace = true }
+hex = { workspace = true }
+memchr = { workspace = true }
+md-5 = { workspace = true }
+sha1 = { workspace = true }
+sha2 = { workspace = true }
+sha3 = { workspace = true }
+blake2b_simd = { workspace = true }
+blake3 = { workspace = true }
+sm3 = { workspace = true }
 
 [target.'cfg(unix)'.dependencies]
-walkdir = { workspace=true, optional=true }
-nix = { workspace=true, features = ["fs", "uio", "zerocopy"] }
+walkdir = { workspace = true, optional = true }
+nix = { workspace = true, features = ["fs", "uio", "zerocopy", "signal"] }
 
 [dev-dependencies]
-clap = { workspace=true }
-once_cell = { workspace=true }
+clap = { workspace = true }
+once_cell = { workspace = true }
+tempfile = { workspace = true }
 
 [target.'cfg(target_os = "windows")'.dependencies]
-winapi-util = { version= "0.1.5", optional=true }
-windows-sys = { version = "0.42.0", optional = true, default-features = false, features = ["Win32_Storage_FileSystem", "Win32_Foundation", "Win32_System_WindowsProgramming"] }
+winapi-util = { version = "0.1.5", optional = true }
+windows-sys = { version = "0.48.0", optional = true, default-features = false, features = [
+  "Win32_Storage_FileSystem",
+  "Win32_Foundation",
+  "Win32_System_WindowsProgramming",
+] }
 
 [features]
 default = []
diff --git a/src/uucore/src/lib/features/encoding.rs b/src/uucore/src/lib/features/encoding.rs
index db4c4c635..a42044eea 100644
--- a/src/uucore/src/lib/features/encoding.rs
+++ b/src/uucore/src/lib/features/encoding.rs
@@ -67,10 +67,10 @@ pub fn encode(f: Format, input: &[u8]) -> Result<String, EncodeError> {
         Z85 => {
             // According to the spec we should not accept inputs whose len is not a multiple of 4.
             // However, the z85 crate implements a padded encoding and accepts such inputs. We have to manually check for them.
-            if input.len() % 4 != 0 {
-                return Err(EncodeError::Z85InputLenNotMultipleOf4);
-            } else {
+            if input.len() % 4 == 0 {
                 z85::encode(input)
+            } else {
+                return Err(EncodeError::Z85InputLenNotMultipleOf4);
             }
         }
     })
diff --git a/src/uucore/src/lib/features/entries.rs b/src/uucore/src/lib/features/entries.rs
index 561de888b..c0229aa3e 100644
--- a/src/uucore/src/lib/features/entries.rs
+++ b/src/uucore/src/lib/features/entries.rs
@@ -168,10 +168,10 @@ pub struct Passwd {
 /// SAFETY: ptr must point to a valid C string.
 /// Returns None if ptr is null.
 unsafe fn cstr2string(ptr: *const c_char) -> Option<String> {
-    if !ptr.is_null() {
-        Some(CStr::from_ptr(ptr).to_string_lossy().into_owned())
-    } else {
+    if ptr.is_null() {
         None
+    } else {
+        Some(CStr::from_ptr(ptr).to_string_lossy().into_owned())
     }
 }
 
@@ -321,7 +321,8 @@ macro_rules! f {
                 } else {
                     // SAFETY: We're holding PW_LOCK.
                     unsafe {
-                        let data = $fnam(CString::new(k).unwrap().as_ptr());
+                        let cstring = CString::new(k).unwrap();
+                        let data = $fnam(cstring.as_ptr());
                         if !data.is_null() {
                             Ok($st::from_raw(ptr::read(data as *const _)))
                         } else {
diff --git a/src/uucore/src/lib/features/fs.rs b/src/uucore/src/lib/features/fs.rs
index 43c21aa8d..a97e8ac9c 100644
--- a/src/uucore/src/lib/features/fs.rs
+++ b/src/uucore/src/lib/features/fs.rs
@@ -326,6 +326,7 @@ impl<'a> From<Component<'a>> for OwningComponent {
 /// * [`ResolveMode::Logical`] makes this function resolve '..' components
 ///   before symlinks
 ///
+#[allow(clippy::cognitive_complexity)]
 pub fn canonicalize<P: AsRef<Path>>(
     original: P,
     miss_mode: MissingHandling,
@@ -455,6 +456,9 @@ pub fn display_permissions(metadata: &fs::Metadata, display_file_type: bool) ->
     display_permissions_unix(mode, display_file_type)
 }
 
+// The logic below is more readable written this way.
+#[allow(clippy::if_not_else)]
+#[allow(clippy::cognitive_complexity)]
 #[cfg(unix)]
 /// Display the permissions of a file on a unix like system
 pub fn display_permissions_unix(mode: mode_t, display_file_type: bool) -> String {
@@ -582,10 +586,108 @@ pub fn make_path_relative_to<P1: AsRef<Path>, P2: AsRef<Path>>(path: P1, to: P2)
     components.iter().collect()
 }
 
+/// Checks if there is a symlink loop in the given path.
+///
+/// A symlink loop is a chain of symlinks where the last symlink points back to one of the previous symlinks in the chain.
+///
+/// # Arguments
+///
+/// * `path` - A reference to a `Path` representing the starting path to check for symlink loops.
+///
+/// # Returns
+///
+/// * `bool` - Returns `true` if a symlink loop is detected, `false` otherwise.
+pub fn is_symlink_loop(path: &Path) -> bool {
+    let mut visited_symlinks = HashSet::new();
+    let mut current_path = path.to_path_buf();
+
+    while let (Ok(metadata), Ok(link)) = (
+        current_path.symlink_metadata(),
+        fs::read_link(&current_path),
+    ) {
+        if !metadata.file_type().is_symlink() {
+            return false;
+        }
+        if !visited_symlinks.insert(current_path.clone()) {
+            return true;
+        }
+        current_path = link;
+    }
+
+    false
+}
+
+#[cfg(not(unix))]
+// Hard link comparison is not supported on non-Unix platforms
+pub fn are_hardlinks_to_same_file(_source: &Path, _target: &Path) -> bool {
+    false
+}
+
+/// Checks if two paths are hard links to the same file.
+///
+/// # Arguments
+///
+/// * `source` - A reference to a `Path` representing the source path.
+/// * `target` - A reference to a `Path` representing the target path.
+///
+/// # Returns
+///
+/// * `bool` - Returns `true` if the paths are hard links to the same file, and `false` otherwise.
+#[cfg(unix)]
+pub fn are_hardlinks_to_same_file(source: &Path, target: &Path) -> bool {
+    let source_metadata = match fs::metadata(source) {
+        Ok(metadata) => metadata,
+        Err(_) => return false,
+    };
+
+    let target_metadata = match fs::metadata(target) {
+        Ok(metadata) => metadata,
+        Err(_) => return false,
+    };
+
+    source_metadata.ino() == target_metadata.ino() && source_metadata.dev() == target_metadata.dev()
+}
+
+#[cfg(not(unix))]
+pub fn are_hardlinks_or_one_way_symlink_to_same_file(_source: &Path, _target: &Path) -> bool {
+    false
+}
+
+/// Checks if either two paths are hard links to the same file or if the source path is a symbolic link which when fully resolved points to target path
+///
+/// # Arguments
+///
+/// * `source` - A reference to a `Path` representing the source path.
+/// * `target` - A reference to a `Path` representing the target path.
+///
+/// # Returns
+///
+/// * `bool` - Returns `true` if either of above conditions are true, and `false` otherwise.
+#[cfg(unix)]
+pub fn are_hardlinks_or_one_way_symlink_to_same_file(source: &Path, target: &Path) -> bool {
+    let source_metadata = match fs::metadata(source) {
+        Ok(metadata) => metadata,
+        Err(_) => return false,
+    };
+
+    let target_metadata = match fs::symlink_metadata(target) {
+        Ok(metadata) => metadata,
+        Err(_) => return false,
+    };
+
+    source_metadata.ino() == target_metadata.ino() && source_metadata.dev() == target_metadata.dev()
+}
+
 #[cfg(test)]
 mod tests {
     // Note this useful idiom: importing names from outer (for mod tests) scope.
     use super::*;
+    #[cfg(unix)]
+    use std::io::Write;
+    #[cfg(unix)]
+    use std::os::unix;
+    #[cfg(unix)]
+    use tempfile::{tempdir, NamedTempFile};
 
     struct NormalizePathTestCase<'a> {
         path: &'a str,
@@ -693,4 +795,81 @@ mod tests {
             display_permissions_unix(S_IFCHR | S_ISVTX as mode_t | 0o054, true)
         );
     }
+
+    #[cfg(unix)]
+    #[test]
+    fn test_is_symlink_loop_no_loop() {
+        let temp_dir = tempdir().unwrap();
+        let file_path = temp_dir.path().join("file.txt");
+        let symlink_path = temp_dir.path().join("symlink");
+
+        fs::write(&file_path, "test content").unwrap();
+        unix::fs::symlink(&file_path, &symlink_path).unwrap();
+
+        assert!(!is_symlink_loop(&symlink_path));
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn test_is_symlink_loop_direct_loop() {
+        let temp_dir = tempdir().unwrap();
+        let symlink_path = temp_dir.path().join("loop");
+
+        unix::fs::symlink(&symlink_path, &symlink_path).unwrap();
+
+        assert!(is_symlink_loop(&symlink_path));
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn test_is_symlink_loop_indirect_loop() {
+        let temp_dir = tempdir().unwrap();
+        let symlink1_path = temp_dir.path().join("symlink1");
+        let symlink2_path = temp_dir.path().join("symlink2");
+
+        unix::fs::symlink(&symlink1_path, &symlink2_path).unwrap();
+        unix::fs::symlink(&symlink2_path, &symlink1_path).unwrap();
+
+        assert!(is_symlink_loop(&symlink1_path));
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn test_are_hardlinks_to_same_file_same_file() {
+        let mut temp_file = NamedTempFile::new().unwrap();
+        writeln!(temp_file, "Test content").unwrap();
+
+        let path1 = temp_file.path();
+        let path2 = temp_file.path();
+
+        assert_eq!(are_hardlinks_to_same_file(&path1, &path2), true);
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn test_are_hardlinks_to_same_file_different_files() {
+        let mut temp_file1 = NamedTempFile::new().unwrap();
+        writeln!(temp_file1, "Test content 1").unwrap();
+
+        let mut temp_file2 = NamedTempFile::new().unwrap();
+        writeln!(temp_file2, "Test content 2").unwrap();
+
+        let path1 = temp_file1.path();
+        let path2 = temp_file2.path();
+
+        assert_eq!(are_hardlinks_to_same_file(&path1, &path2), false);
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn test_are_hardlinks_to_same_file_hard_link() {
+        let mut temp_file = NamedTempFile::new().unwrap();
+        writeln!(temp_file, "Test content").unwrap();
+        let path1 = temp_file.path();
+
+        let path2 = temp_file.path().with_extension("hardlink");
+        fs::hard_link(&path1, &path2).unwrap();
+
+        assert_eq!(are_hardlinks_to_same_file(&path1, &path2), true);
+    }
 }
diff --git a/src/uucore/src/lib/features/fsext.rs b/src/uucore/src/lib/features/fsext.rs
index 927ae0f7a..89f1d6e71 100644
--- a/src/uucore/src/lib/features/fsext.rs
+++ b/src/uucore/src/lib/features/fsext.rs
@@ -11,7 +11,6 @@
 
 // spell-checker:ignore DATETIME subsecond (arch) bitrig ; (fs) cifs smbfs
 
-extern crate time;
 use time::macros::format_description;
 use time::UtcOffset;
 
@@ -295,10 +294,10 @@ impl MountInfo {
                 fs_type_buf.len() as u32,
             )
         };
-        let fs_type = if 0 != success {
-            Some(LPWSTR2String(&fs_type_buf))
-        } else {
+        let fs_type = if 0 == success {
             None
+        } else {
+            Some(LPWSTR2String(&fs_type_buf))
         };
         let mut mn_info = Self {
             dev_id: volume_name,
@@ -410,7 +409,7 @@ pub fn read_fs_list() -> Result<Vec<MountInfo>, std::io::Error> {
         let reader = BufReader::new(f);
         Ok(reader
             .lines()
-            .filter_map(|line| line.ok())
+            .map_while(Result::ok)
             .filter_map(|line| {
                 let raw_data = line.split_whitespace().collect::<Vec<&str>>();
                 MountInfo::new(file_name, &raw_data)
@@ -862,10 +861,10 @@ pub fn pretty_time(sec: i64, nsec: i64) -> String {
 pub fn pretty_filetype<'a>(mode: mode_t, size: u64) -> &'a str {
     match mode & S_IFMT {
         S_IFREG => {
-            if size != 0 {
-                "regular file"
-            } else {
+            if size == 0 {
                 "regular empty file"
+            } else {
+                "regular file"
             }
         }
         S_IFDIR => "directory",
diff --git a/src/uucore/src/lib/features/mode.rs b/src/uucore/src/lib/features/mode.rs
index 956981254..9435e3201 100644
--- a/src/uucore/src/lib/features/mode.rs
+++ b/src/uucore/src/lib/features/mode.rs
@@ -122,6 +122,15 @@ fn parse_change(mode: &str, fperm: u32, considering_dir: bool) -> (u32, usize) {
             'o' => srwx = ((fperm << 6) & 0o700) | ((fperm << 3) & 0o070) | (fperm & 0o007),
             _ => break,
         };
+        if ch == 'u' || ch == 'g' || ch == 'o' {
+            // symbolic modes only allows perms to be a single letter of 'ugo'
+            // therefore this must either be the first char or it is unexpected
+            if pos != 0 {
+                break;
+            }
+            pos = 1;
+            break;
+        }
         pos += 1;
     }
     if pos == 0 {
@@ -200,7 +209,7 @@ mod test {
         assert_eq!(super::parse_mode("u+x").unwrap(), 0o766);
         assert_eq!(
             super::parse_mode("+x").unwrap(),
-            if !crate::os::is_wsl_1() { 0o777 } else { 0o776 }
+            if crate::os::is_wsl_1() { 0o776 } else { 0o777 }
         );
         assert_eq!(super::parse_mode("a-w").unwrap(), 0o444);
         assert_eq!(super::parse_mode("g-r").unwrap(), 0o626);
diff --git a/src/uucore/src/lib/features/perms.rs b/src/uucore/src/lib/features/perms.rs
index 07203a318..5384b52a1 100644
--- a/src/uucore/src/lib/features/perms.rs
+++ b/src/uucore/src/lib/features/perms.rs
@@ -182,6 +182,7 @@ pub enum TraverseSymlinks {
 pub struct ChownExecutor {
     pub dest_uid: Option<u32>,
     pub dest_gid: Option<u32>,
+    pub raw_owner: String, // The owner of the file as input by the user in the command line.
     pub traverse_symlinks: TraverseSymlinks,
     pub verbosity: Verbosity,
     pub filter: IfFrom,
@@ -203,11 +204,21 @@ impl ChownExecutor {
         Ok(())
     }
 
+    #[allow(clippy::cognitive_complexity)]
     fn traverse<P: AsRef<Path>>(&self, root: P) -> i32 {
         let path = root.as_ref();
         let meta = match self.obtain_meta(path, self.dereference) {
             Some(m) => m,
-            _ => return 1,
+            _ => {
+                if self.verbosity.level == VerbosityLevel::Verbose {
+                    println!(
+                        "failed to change ownership of {} to {}",
+                        path.quote(),
+                        self.raw_owner
+                    );
+                }
+                return 1;
+            }
         };
 
         // Prohibit only if:
@@ -260,16 +271,22 @@ impl ChownExecutor {
                 }
             }
         } else {
+            self.print_verbose_ownership_retained_as(
+                path,
+                meta.uid(),
+                self.dest_gid.map(|_| meta.gid()),
+            );
             0
         };
 
-        if !self.recursive {
-            ret
-        } else {
+        if self.recursive {
             ret | self.dive_into(&root)
+        } else {
+            ret
         }
     }
 
+    #[allow(clippy::cognitive_complexity)]
     fn dive_into<P: AsRef<Path>>(&self, root: P) -> i32 {
         let root = root.as_ref();
 
@@ -320,6 +337,11 @@ impl ChownExecutor {
             };
 
             if !self.matched(meta.uid(), meta.gid()) {
+                self.print_verbose_ownership_retained_as(
+                    path,
+                    meta.uid(),
+                    self.dest_gid.map(|_| meta.gid()),
+                );
                 continue;
             }
 
@@ -381,6 +403,35 @@ impl ChownExecutor {
             IfFrom::UserGroup(u, g) => u == uid && g == gid,
         }
     }
+
+    fn print_verbose_ownership_retained_as(&self, path: &Path, uid: u32, gid: Option<u32>) {
+        if self.verbosity.level == VerbosityLevel::Verbose {
+            match (self.dest_uid, self.dest_gid, gid) {
+                (Some(_), Some(_), Some(gid)) => {
+                    println!(
+                        "ownership of {} retained as {}:{}",
+                        path.quote(),
+                        entries::uid2usr(uid).unwrap_or_else(|_| uid.to_string()),
+                        entries::gid2grp(gid).unwrap_or_else(|_| gid.to_string()),
+                    );
+                }
+                (None, Some(_), Some(gid)) => {
+                    println!(
+                        "ownership of {} retained as {}",
+                        path.quote(),
+                        entries::gid2grp(gid).unwrap_or_else(|_| gid.to_string()),
+                    );
+                }
+                (_, _, _) => {
+                    println!(
+                        "ownership of {} retained as {}",
+                        path.quote(),
+                        entries::uid2usr(uid).unwrap_or_else(|_| uid.to_string()),
+                    );
+                }
+            }
+        }
+    }
 }
 
 pub mod options {
@@ -412,7 +463,13 @@ pub mod options {
     pub const ARG_FILES: &str = "FILE";
 }
 
-type GidUidFilterParser = fn(&ArgMatches) -> UResult<(Option<u32>, Option<u32>, IfFrom)>;
+pub struct GidUidOwnerFilter {
+    pub dest_gid: Option<u32>,
+    pub dest_uid: Option<u32>,
+    pub raw_owner: String,
+    pub filter: IfFrom,
+}
+type GidUidFilterOwnerParser = fn(&ArgMatches) -> UResult<GidUidOwnerFilter>;
 
 /// Base implementation for `chgrp` and `chown`.
 ///
@@ -421,11 +478,12 @@ type GidUidFilterParser = fn(&ArgMatches) -> UResult<(Option<u32>, Option<u32>,
 /// `parse_gid_uid_and_filter` will be called to obtain the target gid and uid, and the filter,
 /// from `ArgMatches`.
 /// `groups_only` determines whether verbose output will only mention the group.
+#[allow(clippy::cognitive_complexity)]
 pub fn chown_base(
     mut command: Command,
     args: impl crate::Args,
     add_arg_if_not_reference: &'static str,
-    parse_gid_uid_and_filter: GidUidFilterParser,
+    parse_gid_uid_and_filter: GidUidFilterOwnerParser,
     groups_only: bool,
 ) -> UResult<()> {
     let args: Vec<_> = args.collect();
@@ -508,12 +566,18 @@ pub fn chown_base(
     } else {
         VerbosityLevel::Normal
     };
-    let (dest_gid, dest_uid, filter) = parse_gid_uid_and_filter(&matches)?;
+    let GidUidOwnerFilter {
+        dest_gid,
+        dest_uid,
+        raw_owner,
+        filter,
+    } = parse_gid_uid_and_filter(&matches)?;
 
     let executor = ChownExecutor {
         traverse_symlinks,
         dest_gid,
         dest_uid,
+        raw_owner,
         verbosity: Verbosity {
             groups_only,
             level: verbosity_level,
diff --git a/src/uucore/src/lib/features/process.rs b/src/uucore/src/lib/features/process.rs
index 933b1f21b..4a52f0fc4 100644
--- a/src/uucore/src/lib/features/process.rs
+++ b/src/uucore/src/lib/features/process.rs
@@ -48,6 +48,9 @@ pub trait ChildExt {
     /// send the signal to an unrelated process that recycled the PID.
     fn send_signal(&mut self, signal: usize) -> io::Result<()>;
 
+    /// Send a signal to a process group.
+    fn send_signal_group(&mut self, signal: usize) -> io::Result<()>;
+
     /// Wait for a process to finish or return after the specified duration.
     /// A `timeout` of zero disables the timeout.
     fn wait_or_timeout(&mut self, timeout: Duration) -> io::Result<Option<ExitStatus>>;
@@ -55,10 +58,22 @@ pub trait ChildExt {
 
 impl ChildExt for Child {
     fn send_signal(&mut self, signal: usize) -> io::Result<()> {
-        if unsafe { libc::kill(self.id() as pid_t, signal as i32) } != 0 {
-            Err(io::Error::last_os_error())
-        } else {
+        if unsafe { libc::kill(self.id() as pid_t, signal as i32) } == 0 {
             Ok(())
+        } else {
+            Err(io::Error::last_os_error())
+        }
+    }
+
+    fn send_signal_group(&mut self, signal: usize) -> io::Result<()> {
+        // Ignore the signal, so we don't go into a signal loop.
+        if unsafe { libc::signal(signal as i32, libc::SIG_IGN) } != 0 {
+            return Err(io::Error::last_os_error());
+        }
+        if unsafe { libc::kill(0, signal as i32) } == 0 {
+            Ok(())
+        } else {
+            Err(io::Error::last_os_error())
         }
     }
 
diff --git a/src/uucore/src/lib/features/signals.rs b/src/uucore/src/lib/features/signals.rs
index b92ecf764..c9f7295ee 100644
--- a/src/uucore/src/lib/features/signals.rs
+++ b/src/uucore/src/lib/features/signals.rs
@@ -7,7 +7,12 @@
 
 // spell-checker:ignore (vars/api) fcntl setrlimit setitimer
 // spell-checker:ignore (vars/signals) ABRT ALRM CHLD SEGV SIGABRT SIGALRM SIGBUS SIGCHLD SIGCONT SIGEMT SIGFPE SIGHUP SIGILL SIGINFO SIGINT SIGIO SIGIOT SIGKILL SIGPIPE SIGPROF SIGPWR SIGQUIT SIGSEGV SIGSTOP SIGSYS SIGTERM SIGTRAP SIGTSTP SIGTHR SIGTTIN SIGTTOU SIGURG SIGUSR SIGVTALRM SIGWINCH SIGXCPU SIGXFSZ STKFLT PWR THR TSTP TTIN TTOU VTALRM XCPU XFSZ
-
+#[cfg(unix)]
+use nix::errno::Errno;
+#[cfg(unix)]
+use nix::sys::signal::{
+    signal, SigHandler::SigDfl, SigHandler::SigIgn, Signal::SIGINT, Signal::SIGPIPE,
+};
 pub static DEFAULT_SIGNAL: usize = 15;
 
 /*
@@ -196,6 +201,19 @@ pub fn signal_name_by_value(signal_value: usize) -> Option<&'static str> {
     ALL_SIGNALS.get(signal_value).copied()
 }
 
+#[cfg(unix)]
+pub fn enable_pipe_errors() -> Result<(), Errno> {
+    // We pass the error as is, the return value would just be Ok(SigDfl), so we can safely ignore it.
+    // SAFETY: this function is safe as long as we do not use a custom SigHandler -- we use the default one.
+    unsafe { signal(SIGPIPE, SigDfl) }.map(|_| ())
+}
+#[cfg(unix)]
+pub fn ignore_interrupts() -> Result<(), Errno> {
+    // We pass the error as is, the return value would just be Ok(SigIgn), so we can safely ignore it.
+    // SAFETY: this function is safe as long as we do not use a custom SigHandler -- we use the default one.
+    unsafe { signal(SIGINT, SigIgn) }.map(|_| ())
+}
+
 #[test]
 fn signal_by_value() {
     assert_eq!(signal_by_name_or_value("0"), Some(0));
diff --git a/src/uucore/src/lib/features/sum.rs b/src/uucore/src/lib/features/sum.rs
index 339414630..c1cfaf5f8 100644
--- a/src/uucore/src/lib/features/sum.rs
+++ b/src/uucore/src/lib/features/sum.rs
@@ -38,10 +38,25 @@ pub trait Digest {
     }
 }
 
-pub struct Blake2b(blake2b_simd::State);
+/// first element of the tuple is the blake2b state
+/// second is the number of output bits
+pub struct Blake2b(blake2b_simd::State, usize);
+
+impl Blake2b {
+    /// Return a new Blake2b instance with a custom output bytes length
+    pub fn with_output_bytes(output_bytes: usize) -> Self {
+        let mut params = blake2b_simd::Params::new();
+        params.hash_length(output_bytes);
+
+        let state = params.to_state();
+        Self(state, output_bytes * 8)
+    }
+}
+
 impl Digest for Blake2b {
     fn new() -> Self {
-        Self(blake2b_simd::State::new())
+        // by default, Blake2b output is 512 bits long (= 64B)
+        Self::with_output_bytes(64)
     }
 
     fn hash_update(&mut self, input: &[u8]) {
@@ -54,11 +69,11 @@ impl Digest for Blake2b {
     }
 
     fn reset(&mut self) {
-        *self = Self::new();
+        *self = Self::with_output_bytes(self.output_bytes());
     }
 
     fn output_bits(&self) -> usize {
-        512
+        self.1
     }
 }
 
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/float_common.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/float_common.rs
index c277e60a6..e0a29217c 100644
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/float_common.rs
+++ b/src/uucore/src/lib/features/tokenize/num_format/formatters/float_common.rs
@@ -40,6 +40,7 @@ fn has_enough_digits(
 }
 
 impl FloatAnalysis {
+    #[allow(clippy::cognitive_complexity)]
     pub fn analyze(
         str_in: &str,
         initial_prefix: &InitialPrefix,
@@ -219,6 +220,7 @@ fn round_terminal_digit(
     (before_dec, after_dec, false)
 }
 
+#[allow(clippy::cognitive_complexity)]
 pub fn get_primitive_dec(
     initial_prefix: &InitialPrefix,
     str_in: &str,
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/intf.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/intf.rs
index e0eb0ffd3..0f6e78de6 100644
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/intf.rs
+++ b/src/uucore/src/lib/features/tokenize/num_format/formatters/intf.rs
@@ -40,6 +40,7 @@ impl Intf {
     // is_zero: true if number is zero, false otherwise
     // len_digits: length of digits used to create the int
     //   important, for example, if we run into a non-valid character
+    #[allow(clippy::cognitive_complexity)]
     fn analyze(str_in: &str, signed_out: bool, initial_prefix: &InitialPrefix) -> IntAnalysis {
         // the maximum number of digits we could conceivably
         // have before the decimal point without exceeding the
diff --git a/src/uucore/src/lib/features/tokenize/num_format/num_format.rs b/src/uucore/src/lib/features/tokenize/num_format/num_format.rs
index 9aa97f811..c9b1178b6 100644
--- a/src/uucore/src/lib/features/tokenize/num_format/num_format.rs
+++ b/src/uucore/src/lib/features/tokenize/num_format/num_format.rs
@@ -87,6 +87,7 @@ fn get_provided(str_in_opt: Option<&String>) -> Option<u8> {
 // a base,
 // and an offset for index after all
 //  initial spacing, sign, base prefix, and leading zeroes
+#[allow(clippy::cognitive_complexity)]
 fn get_initial_prefix(str_in: &str, field_type: &FieldType) -> InitialPrefix {
     let mut str_it = str_in.chars();
     let mut ret = InitialPrefix {
diff --git a/src/uucore/src/lib/features/tokenize/sub.rs b/src/uucore/src/lib/features/tokenize/sub.rs
index 9312040e3..5bdb24dc6 100644
--- a/src/uucore/src/lib/features/tokenize/sub.rs
+++ b/src/uucore/src/lib/features/tokenize/sub.rs
@@ -173,6 +173,7 @@ impl SubParser {
             prefix_char,
         ))
     }
+    #[allow(clippy::cognitive_complexity)]
     fn sub_vals_retrieved(&mut self, it: &mut PutBackN<Chars>) -> UResult<bool> {
         if !Self::successfully_eat_prefix(it, &mut self.text_so_far)? {
             return Ok(false);
@@ -197,30 +198,7 @@ impl SubParser {
             self.text_so_far.push(ch);
             match ch {
                 '-' | '*' | '0'..='9' => {
-                    if !self.past_decimal {
-                        if self.min_width_is_asterisk || self.specifiers_found {
-                            return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
-                        }
-                        if self.min_width_tmp.is_none() {
-                            self.min_width_tmp = Some(String::new());
-                        }
-                        match self.min_width_tmp.as_mut() {
-                            Some(x) => {
-                                if (ch == '-' || ch == '*') && !x.is_empty() {
-                                    return Err(
-                                        SubError::InvalidSpec(self.text_so_far.clone()).into()
-                                    );
-                                }
-                                if ch == '*' {
-                                    self.min_width_is_asterisk = true;
-                                }
-                                x.push(ch);
-                            }
-                            None => {
-                                panic!("should be unreachable");
-                            }
-                        }
-                    } else {
+                    if self.past_decimal {
                         // second field should never have a
                         // negative value
                         if self.second_field_is_asterisk || ch == '-' || self.specifiers_found {
@@ -245,13 +223,36 @@ impl SubParser {
                                 panic!("should be unreachable");
                             }
                         }
+                    } else {
+                        if self.min_width_is_asterisk || self.specifiers_found {
+                            return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
+                        }
+                        if self.min_width_tmp.is_none() {
+                            self.min_width_tmp = Some(String::new());
+                        }
+                        match self.min_width_tmp.as_mut() {
+                            Some(x) => {
+                                if (ch == '-' || ch == '*') && !x.is_empty() {
+                                    return Err(
+                                        SubError::InvalidSpec(self.text_so_far.clone()).into()
+                                    );
+                                }
+                                if ch == '*' {
+                                    self.min_width_is_asterisk = true;
+                                }
+                                x.push(ch);
+                            }
+                            None => {
+                                panic!("should be unreachable");
+                            }
+                        }
                     }
                 }
                 '.' => {
-                    if !self.past_decimal {
-                        self.past_decimal = true;
-                    } else {
+                    if self.past_decimal {
                         return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
+                    } else {
+                        self.past_decimal = true;
                     }
                 }
                 x if legal_fields.binary_search(&x).is_ok() => {
@@ -342,6 +343,7 @@ impl SubParser {
 }
 
 impl Sub {
+    #[allow(clippy::cognitive_complexity)]
     pub(crate) fn write<W>(&self, writer: &mut W, pf_args_it: &mut Peekable<Iter<String>>)
     where
         W: Write,
diff --git a/src/uucore/src/lib/features/tokenize/unescaped_text.rs b/src/uucore/src/lib/features/tokenize/unescaped_text.rs
index e659b11b5..29c657ed8 100644
--- a/src/uucore/src/lib/features/tokenize/unescaped_text.rs
+++ b/src/uucore/src/lib/features/tokenize/unescaped_text.rs
@@ -135,13 +135,13 @@ impl UnescapedText {
                     }
                     _ => {}
                 }
-                if !ignore {
+                if ignore {
+                    byte_vec.push(ch as u8);
+                } else {
                     let val = (Self::base_to_u32(min_len, max_len, base, it) % 256) as u8;
                     byte_vec.push(val);
                     let bvec = [val];
                     flush_bytes(writer, &bvec);
-                } else {
-                    byte_vec.push(ch as u8);
                 }
             }
             e => {
@@ -197,6 +197,7 @@ impl UnescapedText {
     // and return a wrapper around a Vec<u8> of unescaped bytes
     // break on encounter of sub symbol ('%[^%]') unless called
     // through %b subst.
+    #[allow(clippy::cognitive_complexity)]
     pub fn from_it_core<W>(
         writer: &mut W,
         it: &mut PutBackN<Chars>,
diff --git a/src/uucore/src/lib/features/utmpx.rs b/src/uucore/src/lib/features/utmpx.rs
index 599a02778..35c5ac5b0 100644
--- a/src/uucore/src/lib/features/utmpx.rs
+++ b/src/uucore/src/lib/features/utmpx.rs
@@ -42,13 +42,10 @@ use std::ptr;
 use std::sync::{Mutex, MutexGuard};
 
 pub use self::ut::*;
-use libc::utmpx;
-// pub use libc::getutxid;
-// pub use libc::getutxline;
-// pub use libc::pututxline;
 pub use libc::endutxent;
 pub use libc::getutxent;
 pub use libc::setutxent;
+use libc::utmpx;
 #[cfg(any(target_vendor = "apple", target_os = "linux", target_os = "netbsd"))]
 pub use libc::utmpxname;
 
@@ -230,7 +227,6 @@ impl Utmpx {
         let (hostname, display) = host.split_once(':').unwrap_or((&host, ""));
 
         if !hostname.is_empty() {
-            extern crate dns_lookup;
             use dns_lookup::{getaddrinfo, AddrInfoHints};
 
             const AI_CANONNAME: i32 = 0x2;
@@ -336,7 +332,9 @@ impl Iterator for UtmpxIter {
     fn next(&mut self) -> Option<Self::Item> {
         unsafe {
             let res = getutxent();
-            if !res.is_null() {
+            if res.is_null() {
+                None
+            } else {
                 // The data behind this pointer will be replaced by the next
                 // call to getutxent(), so we have to read it now.
                 // All the strings live inline in the struct as arrays, which
@@ -344,8 +342,6 @@ impl Iterator for UtmpxIter {
                 Some(Utmpx {
                     inner: ptr::read(res as *const _),
                 })
-            } else {
-                None
             }
         }
     }
diff --git a/src/uucore/src/lib/lib.rs b/src/uucore/src/lib/lib.rs
index 5cbf58faa..e76e540c8 100644
--- a/src/uucore/src/lib/lib.rs
+++ b/src/uucore/src/lib/lib.rs
@@ -26,6 +26,7 @@ pub use crate::mods::os;
 pub use crate::mods::panic;
 pub use crate::mods::quoting_style;
 pub use crate::mods::ranges;
+pub use crate::mods::update_control;
 pub use crate::mods::version_cmp;
 
 // * string parsing modules
@@ -99,10 +100,13 @@ macro_rules! bin {
 
 /// Generate the usage string for clap.
 ///
-/// This function replaces all occurrences of `{}` with the execution phrase
-/// and returns the resulting `String`. It does **not** support
-/// more advanced formatting features such as `{0}`.
+/// This function does two things. It indents all but the first line to align
+/// the lines because clap adds "Usage: " to the first line. And it replaces
+/// all occurrences of `{}` with the execution phrase and returns the resulting
+/// `String`. It does **not** support more advanced formatting features such
+/// as `{0}`.
 pub fn format_usage(s: &str) -> String {
+    let s = s.replace('\n', &format!("\n{}", " ".repeat(7)));
     s.replace("{}", crate::execution_phrase())
 }
 
@@ -119,13 +123,11 @@ pub fn set_utility_is_second_arg() {
 static ARGV: Lazy<Vec<OsString>> = Lazy::new(|| wild::args_os().collect());
 
 static UTIL_NAME: Lazy<String> = Lazy::new(|| {
-    if get_utility_is_second_arg() {
-        &ARGV[1]
-    } else {
-        &ARGV[0]
-    }
-    .to_string_lossy()
-    .into_owned()
+    let base_index = if get_utility_is_second_arg() { 1 } else { 0 };
+    let is_man = if ARGV[base_index].eq("manpage") { 1 } else { 0 };
+    let argv_index = base_index + is_man;
+
+    ARGV[argv_index].to_string_lossy().into_owned()
 });
 
 /// Derive the utility name.
@@ -273,4 +275,13 @@ mod tests {
         test_invalid_utf8_args_lossy(os_str);
         test_invalid_utf8_args_ignore(os_str);
     }
+
+    #[test]
+    fn test_format_usage() {
+        assert_eq!(format_usage("expr EXPRESSION"), "expr EXPRESSION");
+        assert_eq!(
+            format_usage("expr EXPRESSION\nexpr OPTION"),
+            "expr EXPRESSION\n       expr OPTION"
+        );
+    }
 }
diff --git a/src/uucore/src/lib/mods.rs b/src/uucore/src/lib/mods.rs
index 4b6c53f95..71d288c69 100644
--- a/src/uucore/src/lib/mods.rs
+++ b/src/uucore/src/lib/mods.rs
@@ -6,6 +6,7 @@ pub mod error;
 pub mod os;
 pub mod panic;
 pub mod ranges;
+pub mod update_control;
 pub mod version_cmp;
 // dir and vdir also need access to the quoting_style module
 pub mod quoting_style;
diff --git a/src/uucore/src/lib/mods/backup_control.rs b/src/uucore/src/lib/mods/backup_control.rs
index 52b2771c6..2d161c43f 100644
--- a/src/uucore/src/lib/mods/backup_control.rs
+++ b/src/uucore/src/lib/mods/backup_control.rs
@@ -200,8 +200,6 @@ impl Display for BackupError {
 pub mod arguments {
     use clap::ArgAction;
 
-    extern crate clap;
-
     pub static OPT_BACKUP: &str = "backupopt_backup";
     pub static OPT_BACKUP_NO_ARG: &str = "backupopt_b";
     pub static OPT_SUFFIX: &str = "backupopt_suffix";
diff --git a/src/uucore/src/lib/mods/error.rs b/src/uucore/src/lib/mods/error.rs
index 5d4527d74..e564c7bb5 100644
--- a/src/uucore/src/lib/mods/error.rs
+++ b/src/uucore/src/lib/mods/error.rs
@@ -522,7 +522,7 @@ impl From<std::io::Error> for Box<dyn UError> {
 /// // prints "fix me please!: Permission denied"
 /// println!("{}", uio_result.unwrap_err());
 /// ```
-#[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg(unix)]
 impl<T> FromIo<UResult<T>> for Result<T, nix::Error> {
     fn map_err_context(self, context: impl FnOnce() -> String) -> UResult<T> {
         self.map_err(|e| {
@@ -534,7 +534,7 @@ impl<T> FromIo<UResult<T>> for Result<T, nix::Error> {
     }
 }
 
-#[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg(unix)]
 impl<T> FromIo<UResult<T>> for nix::Error {
     fn map_err_context(self, context: impl FnOnce() -> String) -> UResult<T> {
         Err(Box::new(UIoError {
@@ -544,7 +544,7 @@ impl<T> FromIo<UResult<T>> for nix::Error {
     }
 }
 
-#[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg(unix)]
 impl From<nix::Error> for UIoError {
     fn from(f: nix::Error) -> Self {
         Self {
@@ -554,7 +554,7 @@ impl From<nix::Error> for UIoError {
     }
 }
 
-#[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg(unix)]
 impl From<nix::Error> for Box<dyn UError> {
     fn from(f: nix::Error) -> Self {
         let u_error: UIoError = f.into();
@@ -751,7 +751,7 @@ impl Display for ClapErrorWrapper {
 #[cfg(test)]
 mod tests {
     #[test]
-    #[cfg(any(target_os = "linux", target_os = "android"))]
+    #[cfg(unix)]
     fn test_nix_error_conversion() {
         use super::{FromIo, UIoError};
         use nix::errno::Errno;
diff --git a/src/uucore/src/lib/mods/quoting_style.rs b/src/uucore/src/lib/mods/quoting_style.rs
index 3c8bf686a..a6efb2898 100644
--- a/src/uucore/src/lib/mods/quoting_style.rs
+++ b/src/uucore/src/lib/mods/quoting_style.rs
@@ -259,13 +259,13 @@ fn shell_with_escape(name: &str, quotes: Quotes) -> (String, bool) {
 pub fn escape_name(name: &OsStr, style: &QuotingStyle) -> String {
     match style {
         QuotingStyle::Literal { show_control } => {
-            if !show_control {
+            if *show_control {
+                name.to_string_lossy().into_owned()
+            } else {
                 name.to_string_lossy()
                     .chars()
                     .flat_map(|c| EscapedChar::new_literal(c).hide_control())
                     .collect()
-            } else {
-                name.to_string_lossy().into_owned()
             }
         }
         QuotingStyle::C { quotes } => {
diff --git a/src/uucore/src/lib/mods/update_control.rs b/src/uucore/src/lib/mods/update_control.rs
new file mode 100644
index 000000000..e46afd185
--- /dev/null
+++ b/src/uucore/src/lib/mods/update_control.rs
@@ -0,0 +1,139 @@
+// This file is part of the uutils coreutils package.
+//
+// (c) John Shin <shinhs0506@gmail.com>
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+//! Implement GNU-style update functionality.
+//!
+//! - pre-defined [`clap`-Arguments][1] for inclusion in utilities that
+//!   implement updates
+//! - determination of the [update mode][2]
+//!
+//! Update-functionality is implemented by the following utilities:
+//!
+//! - `cp`
+//! - `mv`
+//!
+//!
+//! [1]: arguments
+//! [2]: `determine_update_mode()`
+//!
+//!
+//! # Usage example
+//!
+//! ```
+//! #[macro_use]
+//! extern crate uucore;
+//!
+//! use clap::{Command, Arg, ArgMatches};
+//! use uucore::update_control::{self, UpdateMode};
+//!
+//! fn main() {
+//!     let matches = Command::new("command")
+//!         .arg(update_control::arguments::update())
+//!         .arg(update_control::arguments::update_no_args())
+//!         .get_matches_from(vec![
+//!             "command", "--update=older"
+//!         ]);
+//!
+//!     let update_mode = update_control::determine_update_mode(&matches);
+//!
+//!     // handle cases
+//!     if update_mode == UpdateMode::ReplaceIfOlder {
+//!         // do
+//!     } else {
+//!         unreachable!()
+//!     }
+//! }
+//! ```
+use clap::ArgMatches;
+
+// Available update mode
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum UpdateMode {
+    // --update=`all`, ``
+    ReplaceAll,
+    // --update=`none`
+    ReplaceNone,
+    // --update=`older`
+    // -u
+    ReplaceIfOlder,
+}
+
+pub mod arguments {
+    use clap::ArgAction;
+
+    pub static OPT_UPDATE: &str = "update";
+    pub static OPT_UPDATE_NO_ARG: &str = "u";
+
+    // `--update` argument, defaults to `older` if no values are provided
+    pub fn update() -> clap::Arg {
+        clap::Arg::new(OPT_UPDATE)
+            .long("update")
+            .help("move only when the SOURCE file is newer than the destination file or when the destination file is missing")
+            .value_parser(["none", "all", "older"])
+            .num_args(0..=1)
+            .default_missing_value("older")
+            .require_equals(true)
+            .overrides_with("update")
+            .action(clap::ArgAction::Set)
+    }
+
+    // `-u` argument
+    pub fn update_no_args() -> clap::Arg {
+        clap::Arg::new(OPT_UPDATE_NO_ARG)
+            .short('u')
+            .help("like --update but does not accept an argument")
+            .action(ArgAction::SetTrue)
+    }
+}
+
+/// Determine the "mode" for the update operation to perform, if any.
+///
+/// Parses the backup options and converts them to an instance of
+/// `UpdateMode` for further processing.
+///
+/// Takes [`clap::ArgMatches`] as argument which **must** contain the options
+/// from [`arguments::update()`] or [`arguments::update_no_args()`]. Otherwise
+/// the `ReplaceAll` mode is returned unconditionally.
+///
+/// # Examples
+///
+/// Here's how one would integrate the update mode determination into an
+/// application.
+///
+/// ```
+/// #[macro_use]
+/// extern crate uucore;
+/// use uucore::update_control::{self, UpdateMode};
+/// use clap::{Command, Arg, ArgMatches};
+///
+/// fn main() {
+///     let matches = Command::new("command")
+///         .arg(update_control::arguments::update())
+///         .arg(update_control::arguments::update_no_args())
+///         .get_matches_from(vec![
+///             "command", "--update=all"
+///         ]);
+///
+///     let update_mode = update_control::determine_update_mode(&matches);
+///     assert_eq!(update_mode, UpdateMode::ReplaceAll)
+/// }
+pub fn determine_update_mode(matches: &ArgMatches) -> UpdateMode {
+    if let Some(mode) = matches.get_one::<String>(arguments::OPT_UPDATE) {
+        match mode.as_str() {
+            "all" => UpdateMode::ReplaceAll,
+            "none" => UpdateMode::ReplaceNone,
+            "older" => UpdateMode::ReplaceIfOlder,
+            _ => unreachable!("other args restricted by clap"),
+        }
+    } else if matches.get_flag(arguments::OPT_UPDATE_NO_ARG) {
+        // short form of this option is equivalent to using --update=older
+        UpdateMode::ReplaceIfOlder
+    } else {
+        // no option was present
+        UpdateMode::ReplaceAll
+    }
+}
diff --git a/src/uucore/src/lib/parser/parse_glob.rs b/src/uucore/src/lib/parser/parse_glob.rs
index 8605f7450..a321d470b 100644
--- a/src/uucore/src/lib/parser/parse_glob.rs
+++ b/src/uucore/src/lib/parser/parse_glob.rs
@@ -10,8 +10,9 @@ fn fix_negation(glob: &str) -> String {
     let mut chars = glob.chars().collect::<Vec<_>>();
 
     let mut i = 0;
-    while i < chars.len() {
-        if chars[i] == '[' && i + 4 <= glob.len() && chars[i + 1] == '^' {
+    // Add 3 to prevent out of bounds in loop
+    while i + 3 < chars.len() {
+        if chars[i] == '[' && chars[i + 1] == '^' {
             match chars[i + 3..].iter().position(|x| *x == ']') {
                 None => (),
                 Some(j) => {
@@ -105,5 +106,8 @@ mod tests {
         assert_eq!(fix_negation("[^]"), "[^]");
         assert_eq!(fix_negation("[^"), "[^");
         assert_eq!(fix_negation("[][^]"), "[][^]");
+
+        // Issue #4479
+        assert_eq!(fix_negation("ààà[^"), "ààà[^");
     }
 }
diff --git a/src/uucore/src/lib/parser/parse_size.rs b/src/uucore/src/lib/parser/parse_size.rs
index d1e571e06..2ea84e389 100644
--- a/src/uucore/src/lib/parser/parse_size.rs
+++ b/src/uucore/src/lib/parser/parse_size.rs
@@ -3,7 +3,7 @@
 //  * For the full copyright and license information, please view the LICENSE
 //  * file that was distributed with this source code.
 
-// spell-checker:ignore (ToDO) hdsf ghead gtail
+// spell-checker:ignore (ToDO) hdsf ghead gtail ACDBK hexdigit
 
 use std::error::Error;
 use std::fmt;
@@ -25,6 +25,12 @@ pub struct Parser<'parser> {
     pub default_unit: Option<&'parser str>,
 }
 
+enum NumberSystem {
+    Decimal,
+    Octal,
+    Hexadecimal,
+}
+
 impl<'parser> Parser<'parser> {
     pub fn with_allow_list(&mut self, allow_list: &'parser [&str]) -> &mut Self {
         self.allow_list = Some(allow_list);
@@ -62,31 +68,26 @@ impl<'parser> Parser<'parser> {
     /// assert_eq!(Ok(123), parse_size("123"));
     /// assert_eq!(Ok(9 * 1000), parse_size("9kB")); // kB is 1000
     /// assert_eq!(Ok(2 * 1024), parse_size("2K")); // K is 1024
+    /// assert_eq!(Ok(44251 * 1024), parse_size("0xACDBK"));
     /// ```
     pub fn parse(&self, size: &str) -> Result<u64, ParseSizeError> {
         if size.is_empty() {
             return Err(ParseSizeError::parse_failure(size));
         }
-        // Get the numeric part of the size argument. For example, if the
-        // argument is "123K", then the numeric part is "123".
-        let numeric_string: String = size.chars().take_while(|c| c.is_ascii_digit()).collect();
-        let number: u64 = if !numeric_string.is_empty() {
-            match numeric_string.parse() {
-                Ok(n) => n,
-                Err(_) => return Err(ParseSizeError::parse_failure(size)),
-            }
-        } else {
-            1
-        };
 
-        // Get the alphabetic units part of the size argument and compute
-        // the factor it represents. For example, if the argument is "123K",
-        // then the unit part is "K" and the factor is 1024. This may be the
-        // empty string, in which case, the factor is 1.
-        //
-        // The lowercase "b" (used by `od`, `head`, `tail`, etc.) means
-        // "block" and the Posix block size is 512. The uppercase "B"
-        // means "byte".
+        let number_system: NumberSystem = self.determine_number_system(size);
+
+        // Split the size argument into numeric and unit parts
+        // For example, if the argument is "123K", the numeric part is "123", and
+        // the unit is "K"
+        let numeric_string: String = match number_system {
+            NumberSystem::Hexadecimal => size
+                .chars()
+                .take(2)
+                .chain(size.chars().skip(2).take_while(|c| c.is_ascii_hexdigit()))
+                .collect(),
+            _ => size.chars().take_while(|c| c.is_ascii_digit()).collect(),
+        };
         let mut unit: &str = &size[numeric_string.len()..];
 
         if let Some(default_unit) = self.default_unit {
@@ -115,6 +116,12 @@ impl<'parser> Parser<'parser> {
             }
         }
 
+        // Compute the factor the unit represents.
+        // empty string means the factor is 1.
+        //
+        // The lowercase "b" (used by `od`, `head`, `tail`, etc.) means
+        // "block" and the Posix block size is 512. The uppercase "B"
+        // means "byte".
         let (base, exponent): (u128, u32) = match unit {
             "" => (1, 0),
             "B" if self.capital_b_bytes => (1, 0),
@@ -142,10 +149,62 @@ impl<'parser> Parser<'parser> {
             Ok(n) => n,
             Err(_) => return Err(ParseSizeError::size_too_big(size)),
         };
+
+        // parse string into u64
+        let number: u64 = match number_system {
+            NumberSystem::Decimal => {
+                if numeric_string.is_empty() {
+                    1
+                } else {
+                    self.parse_number(&numeric_string, 10, size)?
+                }
+            }
+            NumberSystem::Octal => {
+                let trimmed_string = numeric_string.trim_start_matches('0');
+                self.parse_number(trimmed_string, 8, size)?
+            }
+            NumberSystem::Hexadecimal => {
+                let trimmed_string = numeric_string.trim_start_matches("0x");
+                self.parse_number(trimmed_string, 16, size)?
+            }
+        };
+
         number
             .checked_mul(factor)
             .ok_or_else(|| ParseSizeError::size_too_big(size))
     }
+
+    fn determine_number_system(&self, size: &str) -> NumberSystem {
+        if size.len() <= 1 {
+            return NumberSystem::Decimal;
+        }
+
+        if size.starts_with("0x") {
+            return NumberSystem::Hexadecimal;
+        }
+
+        let num_digits: usize = size
+            .chars()
+            .take_while(|c| c.is_ascii_digit())
+            .collect::<String>()
+            .len();
+        let all_zeros = size.chars().all(|c| c == '0');
+        if size.starts_with('0') && num_digits > 1 && !all_zeros {
+            return NumberSystem::Octal;
+        }
+
+        NumberSystem::Decimal
+    }
+
+    fn parse_number(
+        &self,
+        numeric_string: &str,
+        radix: u32,
+        original_size: &str,
+    ) -> Result<u64, ParseSizeError> {
+        u64::from_str_radix(numeric_string, radix)
+            .map_err(|_| ParseSizeError::ParseFailure(original_size.to_string()))
+    }
 }
 
 /// Parse a size string into a number of bytes.
@@ -336,7 +395,7 @@ mod tests {
 
     #[test]
     fn invalid_suffix() {
-        let test_strings = ["328hdsf3290", "5mib", "1e2", "1H", "1.2"];
+        let test_strings = ["5mib", "1eb", "1H"];
         for &test_string in &test_strings {
             assert_eq!(
                 parse_size(test_string).unwrap_err(),
@@ -450,4 +509,18 @@ mod tests {
         assert!(parser.parse("1B").is_err());
         assert!(parser.parse("B").is_err());
     }
+
+    #[test]
+    fn parse_octal_size() {
+        assert_eq!(Ok(63), parse_size("077"));
+        assert_eq!(Ok(528), parse_size("01020"));
+        assert_eq!(Ok(668 * 1024), parse_size("01234K"));
+    }
+
+    #[test]
+    fn parse_hex_size() {
+        assert_eq!(Ok(10), parse_size("0xA"));
+        assert_eq!(Ok(94722), parse_size("0x17202"));
+        assert_eq!(Ok(44251 * 1024), parse_size("0xACDBK"));
+    }
 }
diff --git a/src/uucore_procs/Cargo.toml b/src/uucore_procs/Cargo.toml
index c61d63673..a83baf1d4 100644
--- a/src/uucore_procs/Cargo.toml
+++ b/src/uucore_procs/Cargo.toml
@@ -1,6 +1,7 @@
+# spell-checker:ignore uuhelp
 [package]
 name = "uucore_procs"
-version = "0.0.17"
+version = "0.0.19"
 authors = ["Roy Ivy III <rivy.dev@gmail.com>"]
 license = "MIT"
 description = "uutils ~ 'uucore' proc-macros"
@@ -18,3 +19,4 @@ proc-macro = true
 [dependencies]
 proc-macro2 = "1.0"
 quote = "1.0"
+uuhelp_parser = { path = "../uuhelp_parser", version = "0.0.19" }
diff --git a/src/uucore_procs/src/lib.rs b/src/uucore_procs/src/lib.rs
index c1ef8bc75..b78da7822 100644
--- a/src/uucore_procs/src/lib.rs
+++ b/src/uucore_procs/src/lib.rs
@@ -1,14 +1,11 @@
 // Copyright (C) ~ Roy Ivy III <rivy.dev@gmail.com>; MIT license
-// spell-checker:ignore backticks
+// spell-checker:ignore backticks uuhelp
 
-extern crate proc_macro;
 use std::{fs::File, io::Read, path::PathBuf};
 
 use proc_macro::{Literal, TokenStream, TokenTree};
 use quote::quote;
 
-const MARKDOWN_CODE_FENCES: &str = "```";
-
 //## rust proc-macro background info
 //* ref: <https://dev.to/naufraghi/procedural-macro-in-rust-101-k3f> @@ <http://archive.is/Vbr5e>
 //* ref: [path construction from LitStr](https://oschwald.github.io/maxminddb-rust/syn/struct.LitStr.html) @@ <http://archive.is/8YDua>
@@ -61,7 +58,7 @@ fn render_markdown(s: &str) -> String {
 pub fn help_about(input: TokenStream) -> TokenStream {
     let input: Vec<TokenTree> = input.into_iter().collect();
     let filename = get_argument(&input, 0, "filename");
-    let text: String = parse_about(&read_help(&filename));
+    let text: String = uuhelp_parser::parse_about(&read_help(&filename));
     TokenTree::Literal(Literal::string(&text)).into()
 }
 
@@ -75,7 +72,7 @@ pub fn help_about(input: TokenStream) -> TokenStream {
 pub fn help_usage(input: TokenStream) -> TokenStream {
     let input: Vec<TokenTree> = input.into_iter().collect();
     let filename = get_argument(&input, 0, "filename");
-    let text: String = parse_usage(&read_help(&filename));
+    let text: String = uuhelp_parser::parse_usage(&read_help(&filename));
     TokenTree::Literal(Literal::string(&text)).into()
 }
 
@@ -108,9 +105,15 @@ pub fn help_section(input: TokenStream) -> TokenStream {
     let input: Vec<TokenTree> = input.into_iter().collect();
     let section = get_argument(&input, 0, "section");
     let filename = get_argument(&input, 1, "filename");
-    let text = parse_help_section(&section, &read_help(&filename));
-    let rendered = render_markdown(&text);
-    TokenTree::Literal(Literal::string(&rendered)).into()
+
+    if let Some(text) = uuhelp_parser::parse_section(&section, &read_help(&filename)) {
+        let rendered = render_markdown(&text);
+        TokenTree::Literal(Literal::string(&rendered)).into()
+    } else {
+        panic!(
+            "The section '{section}' could not be found in the help file. Maybe it is spelled wrong?"
+        )
+    }
 }
 
 /// Get an argument from the input vector of `TokenTree`.
@@ -149,186 +152,3 @@ fn read_help(filename: &str) -> String {
 
     content
 }
-
-/// Get a single section from content
-///
-/// The section must be a second level section (i.e. start with `##`).
-fn parse_help_section(section: &str, content: &str) -> String {
-    fn is_section_header(line: &str, section: &str) -> bool {
-        line.strip_prefix("##")
-            .map_or(false, |l| l.trim().to_lowercase() == section)
-    }
-
-    let section = &section.to_lowercase();
-
-    // We cannot distinguish between an empty or non-existing section below,
-    // so we do a quick test to check whether the section exists to provide
-    // a nice error message.
-    if content.lines().all(|l| !is_section_header(l, section)) {
-        panic!(
-            "The section '{section}' could not be found in the help file. Maybe it is spelled wrong?"
-        )
-    }
-
-    content
-        .lines()
-        .skip_while(|&l| !is_section_header(l, section))
-        .skip(1)
-        .take_while(|l| !l.starts_with("##"))
-        .collect::<Vec<_>>()
-        .join("\n")
-        .trim()
-        .to_string()
-}
-
-/// Parses the first markdown code block into a usage string
-///
-/// The code fences are removed and the name of the util is replaced
-/// with `{}` so that it can be replaced with the appropriate name
-/// at runtime.
-fn parse_usage(content: &str) -> String {
-    content
-        .lines()
-        .skip_while(|l| !l.starts_with(MARKDOWN_CODE_FENCES))
-        .skip(1)
-        .take_while(|l| !l.starts_with(MARKDOWN_CODE_FENCES))
-        .map(|l| {
-            // Replace the util name (assumed to be the first word) with "{}"
-            // to be replaced with the runtime value later.
-            if let Some((_util, args)) = l.split_once(' ') {
-                format!("{{}} {args}\n")
-            } else {
-                "{}\n".to_string()
-            }
-        })
-        .collect::<Vec<_>>()
-        .join("")
-        .trim()
-        .to_string()
-}
-
-/// Parses the text between the first markdown code block and the next header, if any,
-/// into an about string.
-fn parse_about(content: &str) -> String {
-    content
-        .lines()
-        .skip_while(|l| !l.starts_with(MARKDOWN_CODE_FENCES))
-        .skip(1)
-        .skip_while(|l| !l.starts_with(MARKDOWN_CODE_FENCES))
-        .skip(1)
-        .take_while(|l| !l.starts_with('#'))
-        .collect::<Vec<_>>()
-        .join("\n")
-        .trim()
-        .to_string()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{parse_about, parse_help_section, parse_usage};
-
-    #[test]
-    fn section_parsing() {
-        let input = "\
-            # ls\n\
-            ## some section\n\
-            This is some section\n\
-            \n\
-            ## ANOTHER SECTION
-            This is the other section\n\
-            with multiple lines\n";
-
-        assert_eq!(
-            parse_help_section("some section", input),
-            "This is some section"
-        );
-        assert_eq!(
-            parse_help_section("SOME SECTION", input),
-            "This is some section"
-        );
-        assert_eq!(
-            parse_help_section("another section", input),
-            "This is the other section\nwith multiple lines"
-        );
-    }
-
-    #[test]
-    #[should_panic]
-    fn section_parsing_panic() {
-        let input = "\
-            # ls\n\
-            ## some section\n\
-            This is some section\n\
-            \n\
-            ## ANOTHER SECTION
-            This is the other section\n\
-            with multiple lines\n";
-        parse_help_section("non-existent section", input);
-    }
-
-    #[test]
-    fn usage_parsing() {
-        let input = "\
-            # ls\n\
-            ```\n\
-            ls -l\n\
-            ```\n\
-            ## some section\n\
-            This is some section\n\
-            \n\
-            ## ANOTHER SECTION
-            This is the other section\n\
-            with multiple lines\n";
-
-        assert_eq!(parse_usage(input), "{} -l");
-    }
-
-    #[test]
-    fn multi_line_usage_parsing() {
-        let input = "\
-            # ls\n\
-            ```\n\
-            ls -a\n\
-            ls -b\n\
-            ls -c\n\
-            ```\n\
-            ## some section\n\
-            This is some section\n";
-
-        assert_eq!(parse_usage(input), "{} -a\n{} -b\n{} -c");
-    }
-
-    #[test]
-    fn about_parsing() {
-        let input = "\
-            # ls\n\
-            ```\n\
-            ls -l\n\
-            ```\n\
-            \n\
-            This is the about section\n\
-            \n\
-            ## some section\n\
-            This is some section\n";
-
-        assert_eq!(parse_about(input), "This is the about section");
-    }
-
-    #[test]
-    fn multi_line_about_parsing() {
-        let input = "\
-            # ls\n\
-            ```\n\
-            ls -l\n\
-            ```\n\
-            \n\
-            about a\n\
-            \n\
-            about b\n\
-            \n\
-            ## some section\n\
-            This is some section\n";
-
-        assert_eq!(parse_about(input), "about a\n\nabout b");
-    }
-}
diff --git a/src/uuhelp_parser/Cargo.toml b/src/uuhelp_parser/Cargo.toml
new file mode 100644
index 000000000..888d07534
--- /dev/null
+++ b/src/uuhelp_parser/Cargo.toml
@@ -0,0 +1,7 @@
+# spell-checker:ignore uuhelp
+[package]
+name = "uuhelp_parser"
+version = "0.0.19"
+edition = "2021"
+license = "MIT"
+description = "A collection of functions to parse the markdown code of help files"
diff --git a/src/uuhelp_parser/src/lib.rs b/src/uuhelp_parser/src/lib.rs
new file mode 100644
index 000000000..8faa4e6ce
--- /dev/null
+++ b/src/uuhelp_parser/src/lib.rs
@@ -0,0 +1,236 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+//! A collection of functions to parse the markdown code of help files.
+//!
+//! The structure of the markdown code is assumed to be:
+//!
+//! # util name
+//!
+//! ```text
+//! usage info
+//! ```
+//!
+//! About text
+//!
+//! ## Section 1
+//!
+//! Some content
+//!
+//! ## Section 2
+//!
+//! Some content
+
+const MARKDOWN_CODE_FENCES: &str = "```";
+
+/// Parses the text between the first markdown code block and the next header, if any,
+/// into an about string.
+pub fn parse_about(content: &str) -> String {
+    content
+        .lines()
+        .skip_while(|l| !l.starts_with(MARKDOWN_CODE_FENCES))
+        .skip(1)
+        .skip_while(|l| !l.starts_with(MARKDOWN_CODE_FENCES))
+        .skip(1)
+        .take_while(|l| !l.starts_with('#'))
+        .collect::<Vec<_>>()
+        .join("\n")
+        .trim()
+        .to_string()
+}
+
+/// Parses the first markdown code block into a usage string
+///
+/// The code fences are removed and the name of the util is replaced
+/// with `{}` so that it can be replaced with the appropriate name
+/// at runtime.
+pub fn parse_usage(content: &str) -> String {
+    content
+        .lines()
+        .skip_while(|l| !l.starts_with(MARKDOWN_CODE_FENCES))
+        .skip(1)
+        .take_while(|l| !l.starts_with(MARKDOWN_CODE_FENCES))
+        .map(|l| {
+            // Replace the util name (assumed to be the first word) with "{}"
+            // to be replaced with the runtime value later.
+            if let Some((_util, args)) = l.split_once(' ') {
+                format!("{{}} {args}\n")
+            } else {
+                "{}\n".to_string()
+            }
+        })
+        .collect::<Vec<_>>()
+        .join("")
+        .trim()
+        .to_string()
+}
+
+/// Get a single section from content
+///
+/// The section must be a second level section (i.e. start with `##`).
+pub fn parse_section(section: &str, content: &str) -> Option<String> {
+    fn is_section_header(line: &str, section: &str) -> bool {
+        line.strip_prefix("##")
+            .map_or(false, |l| l.trim().to_lowercase() == section)
+    }
+
+    let section = &section.to_lowercase();
+
+    // We cannot distinguish between an empty or non-existing section below,
+    // so we do a quick test to check whether the section exists
+    if content.lines().all(|l| !is_section_header(l, section)) {
+        return None;
+    }
+
+    // Prefix includes space to allow processing of section with level 3-6 headers
+    let section_header_prefix = "## ";
+
+    Some(
+        content
+            .lines()
+            .skip_while(|&l| !is_section_header(l, section))
+            .skip(1)
+            .take_while(|l| !l.starts_with(section_header_prefix))
+            .collect::<Vec<_>>()
+            .join("\n")
+            .trim()
+            .to_string(),
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_section() {
+        let input = "\
+            # ls\n\
+            ## some section\n\
+            This is some section\n\
+            \n\
+            ## ANOTHER SECTION
+            This is the other section\n\
+            with multiple lines\n";
+
+        assert_eq!(
+            parse_section("some section", input).unwrap(),
+            "This is some section"
+        );
+        assert_eq!(
+            parse_section("SOME SECTION", input).unwrap(),
+            "This is some section"
+        );
+        assert_eq!(
+            parse_section("another section", input).unwrap(),
+            "This is the other section\nwith multiple lines"
+        );
+    }
+
+    #[test]
+    fn test_parse_section_with_sub_headers() {
+        let input = "\
+            # ls\n\
+            ## after section\n\
+            This is some section\n\
+            \n\
+            ### level 3 header\n\
+            \n\
+            Additional text under the section.\n\
+            \n\
+            #### level 4 header\n\
+            \n\
+            Yet another paragraph\n";
+
+        assert_eq!(
+            parse_section("after section", input).unwrap(),
+            "This is some section\n\n\
+            ### level 3 header\n\n\
+            Additional text under the section.\n\n\
+            #### level 4 header\n\n\
+            Yet another paragraph"
+        );
+    }
+
+    #[test]
+    fn test_parse_non_existing_section() {
+        let input = "\
+            # ls\n\
+            ## some section\n\
+            This is some section\n\
+            \n\
+            ## ANOTHER SECTION
+            This is the other section\n\
+            with multiple lines\n";
+
+        assert!(parse_section("non-existing section", input).is_none());
+    }
+
+    #[test]
+    fn test_parse_usage() {
+        let input = "\
+            # ls\n\
+            ```\n\
+            ls -l\n\
+            ```\n\
+            ## some section\n\
+            This is some section\n\
+            \n\
+            ## ANOTHER SECTION
+            This is the other section\n\
+            with multiple lines\n";
+
+        assert_eq!(parse_usage(input), "{} -l");
+    }
+
+    #[test]
+    fn test_parse_multi_line_usage() {
+        let input = "\
+            # ls\n\
+            ```\n\
+            ls -a\n\
+            ls -b\n\
+            ls -c\n\
+            ```\n\
+            ## some section\n\
+            This is some section\n";
+
+        assert_eq!(parse_usage(input), "{} -a\n{} -b\n{} -c");
+    }
+
+    #[test]
+    fn test_parse_about() {
+        let input = "\
+            # ls\n\
+            ```\n\
+            ls -l\n\
+            ```\n\
+            \n\
+            This is the about section\n\
+            \n\
+            ## some section\n\
+            This is some section\n";
+
+        assert_eq!(parse_about(input), "This is the about section");
+    }
+
+    #[test]
+    fn test_parse_multi_line_about() {
+        let input = "\
+            # ls\n\
+            ```\n\
+            ls -l\n\
+            ```\n\
+            \n\
+            about a\n\
+            \n\
+            about b\n\
+            \n\
+            ## some section\n\
+            This is some section\n";
+
+        assert_eq!(parse_about(input), "about a\n\nabout b");
+    }
+}
diff --git a/tests/benches/factor/Cargo.toml b/tests/benches/factor/Cargo.toml
index efada4b00..26900e78a 100644
--- a/tests/benches/factor/Cargo.toml
+++ b/tests/benches/factor/Cargo.toml
@@ -7,6 +7,8 @@ description = "Benchmarks for the uu_factor integer factorization tool"
 homepage = "https://github.com/uutils/coreutils"
 edition = "2021"
 
+[workspace]
+
 [dependencies]
 uu_factor = { path = "../../../src/uu/factor" }
 
@@ -14,7 +16,7 @@ uu_factor = { path = "../../../src/uu/factor" }
 array-init = "2.0.0"
 criterion = "0.3"
 rand = "0.8"
-rand_chacha = "0.2.2"
+rand_chacha = "0.3.1"
 
 [[bench]]
 name = "gcd"
diff --git a/tests/benches/factor/benches/gcd.rs b/tests/benches/factor/benches/gcd.rs
index f2bae51c7..a9d2a8c55 100644
--- a/tests/benches/factor/benches/gcd.rs
+++ b/tests/benches/factor/benches/gcd.rs
@@ -6,7 +6,7 @@ fn gcd(c: &mut Criterion) {
         // Deterministic RNG; use an explicitly-named RNG to guarantee stability
         use rand::{RngCore, SeedableRng};
         use rand_chacha::ChaCha8Rng;
-        const SEED: u64 = 0xa_b4d_1dea_dead_cafe;
+        const SEED: u64 = 0xab4d_1dea_dead_cafe;
         let mut rng = ChaCha8Rng::seed_from_u64(SEED);
 
         std::iter::repeat_with(move || (rng.next_u64(), rng.next_u64()))
@@ -22,7 +22,7 @@ fn gcd(c: &mut Criterion) {
             },
         );
     }
-    group.finish()
+    group.finish();
 }
 
 criterion_group!(benches, gcd);
diff --git a/tests/benches/factor/benches/table.rs b/tests/benches/factor/benches/table.rs
index 7f749a10f..59e8db1f3 100644
--- a/tests/benches/factor/benches/table.rs
+++ b/tests/benches/factor/benches/table.rs
@@ -7,12 +7,7 @@ fn table(c: &mut Criterion) {
     check_personality();
 
     const INPUT_SIZE: usize = 128;
-    assert!(
-        INPUT_SIZE % CHUNK_SIZE == 0,
-        "INPUT_SIZE ({}) is not divisible by CHUNK_SIZE ({})",
-        INPUT_SIZE,
-        CHUNK_SIZE
-    );
+
     let inputs = {
         // Deterministic RNG; use an explicitly-named RNG to guarantee stability
         use rand::{RngCore, SeedableRng};
@@ -29,42 +24,40 @@ fn table(c: &mut Criterion) {
         let a_str = format!("{:?}", a);
         group.bench_with_input(BenchmarkId::new("factor_chunk", &a_str), &a, |b, &a| {
             b.iter(|| {
-                let mut n_s = a.clone();
+                let mut n_s = a;
                 let mut f_s: [_; INPUT_SIZE] = array_init(|_| Factors::one());
                 for (n_s, f_s) in n_s.chunks_mut(CHUNK_SIZE).zip(f_s.chunks_mut(CHUNK_SIZE)) {
-                    factor_chunk(n_s.try_into().unwrap(), f_s.try_into().unwrap())
+                    factor_chunk(n_s.try_into().unwrap(), f_s.try_into().unwrap());
                 }
-            })
+            });
         });
         group.bench_with_input(BenchmarkId::new("factor", &a_str), &a, |b, &a| {
             b.iter(|| {
-                let mut n_s = a.clone();
+                let mut n_s = a;
                 let mut f_s: [_; INPUT_SIZE] = array_init(|_| Factors::one());
                 for (n, f) in n_s.iter_mut().zip(f_s.iter_mut()) {
-                    factor(n, f)
+                    factor(n, f);
                 }
-            })
+            });
         });
     }
-    group.finish()
+    group.finish();
 }
 
 #[cfg(target_os = "linux")]
 fn check_personality() {
     use std::fs;
     const ADDR_NO_RANDOMIZE: u64 = 0x0040000;
-    const PERSONALITY_PATH: &'static str = "/proc/self/personality";
+    const PERSONALITY_PATH: &str = "/proc/self/personality";
 
     let p_string = fs::read_to_string(PERSONALITY_PATH)
-        .expect(&format!("Couldn't read '{}'", PERSONALITY_PATH))
-        .strip_suffix("\n")
+        .unwrap_or_else(|_| panic!("Couldn't read '{}'", PERSONALITY_PATH))
+        .strip_suffix('\n')
         .unwrap()
         .to_owned();
 
-    let personality = u64::from_str_radix(&p_string, 16).expect(&format!(
-        "Expected a hex value for personality, got '{:?}'",
-        p_string
-    ));
+    let personality = u64::from_str_radix(&p_string, 16)
+        .unwrap_or_else(|_| panic!("Expected a hex value for personality, got '{:?}'", p_string));
     if personality & ADDR_NO_RANDOMIZE == 0 {
         eprintln!(
             "WARNING: Benchmarking with ASLR enabled (personality is {:x}), results might not be reproducible.",
diff --git a/tests/by-util/test_arch.rs b/tests/by-util/test_arch.rs
index 2945a0937..603e1bc49 100644
--- a/tests/by-util/test_arch.rs
+++ b/tests/by-util/test_arch.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_arch() {
diff --git a/tests/by-util/test_base32.rs b/tests/by-util/test_base32.rs
index 0634d114e..395c96c2c 100644
--- a/tests/by-util/test_base32.rs
+++ b/tests/by-util/test_base32.rs
@@ -6,7 +6,7 @@
 // that was distributed with this source code.
 //
 
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_encode() {
@@ -86,7 +86,7 @@ fn test_wrap() {
 fn test_wrap_no_arg() {
     for wrap_param in ["-w", "--wrap"] {
         let ts = TestScenario::new(util_name!());
-        let expected_stderr = "The argument '--wrap <COLS>' requires a value but none was supplied";
+        let expected_stderr = "a value is required for '--wrap <COLS>' but none was supplied";
         ts.ucmd()
             .arg(wrap_param)
             .fails()
diff --git a/tests/by-util/test_base64.rs b/tests/by-util/test_base64.rs
index 6a2563b10..7cd44eefd 100644
--- a/tests/by-util/test_base64.rs
+++ b/tests/by-util/test_base64.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_encode() {
@@ -79,7 +79,7 @@ fn test_wrap_no_arg() {
         new_ucmd!()
             .arg(wrap_param)
             .fails()
-            .stderr_contains("The argument '--wrap <COLS>' requires a value but none was supplied")
+            .stderr_contains("a value is required for '--wrap <COLS>' but none was supplied")
             .no_stdout();
     }
 }
diff --git a/tests/by-util/test_basename.rs b/tests/by-util/test_basename.rs
index 83b598cd4..88b0c71c8 100644
--- a/tests/by-util/test_basename.rs
+++ b/tests/by-util/test_basename.rs
@@ -1,6 +1,6 @@
 // spell-checker:ignore (words) reallylongexecutable
 
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 #[cfg(any(unix, target_os = "redox"))]
 use std::ffi::OsStr;
 
diff --git a/tests/by-util/test_basenc.rs b/tests/by-util/test_basenc.rs
index d2c58b785..401c23d45 100644
--- a/tests/by-util/test_basenc.rs
+++ b/tests/by-util/test_basenc.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_z85_not_padded() {
diff --git a/tests/by-util/test_cat.rs b/tests/by-util/test_cat.rs
index 8b6022c93..c32828a83 100644
--- a/tests/by-util/test_cat.rs
+++ b/tests/by-util/test_cat.rs
@@ -1,6 +1,8 @@
 // spell-checker:ignore NOFILE
 
-use crate::common::util::*;
+#[cfg(not(windows))]
+use crate::common::util::vec_of_size;
+use crate::common::util::TestScenario;
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use rlimit::Resource;
 use std::fs::OpenOptions;
diff --git a/tests/by-util/test_chgrp.rs b/tests/by-util/test_chgrp.rs
index 352ecb513..cf6c62ff7 100644
--- a/tests/by-util/test_chgrp.rs
+++ b/tests/by-util/test_chgrp.rs
@@ -1,7 +1,7 @@
 // spell-checker:ignore (words) nosuchgroup groupname
 
-use crate::common::util::*;
-use rust_users::*;
+use crate::common::util::TestScenario;
+use uucore::process::getegid;
 
 #[test]
 fn test_invalid_option() {
@@ -53,7 +53,7 @@ fn test_invalid_group() {
 
 #[test]
 fn test_1() {
-    if get_effective_gid() != 0 {
+    if getegid() != 0 {
         new_ucmd!().arg("bin").arg(DIR).fails().stderr_contains(
             // linux fails with "Operation not permitted (os error 1)"
             // because of insufficient permissions,
@@ -66,7 +66,7 @@ fn test_1() {
 
 #[test]
 fn test_fail_silently() {
-    if get_effective_gid() != 0 {
+    if getegid() != 0 {
         for opt in ["-f", "--silent", "--quiet", "--sil", "--qui"] {
             new_ucmd!()
                 .arg(opt)
@@ -137,7 +137,7 @@ fn test_reference() {
     // skip for root or MS-WSL
     // * MS-WSL is bugged (as of 2019-12-25), allowing non-root accounts su-level privileges for `chgrp`
     // * for MS-WSL, succeeds and stdout == 'group of /etc retained as root'
-    if !(get_effective_gid() == 0 || uucore::os::is_wsl_1()) {
+    if !(getegid() == 0 || uucore::os::is_wsl_1()) {
         new_ucmd!()
             .arg("-v")
             .arg("--reference=/etc/passwd")
@@ -196,14 +196,14 @@ fn test_missing_files() {
         .arg("groupname")
         .fails()
         .stderr_contains(
-            "error: The following required arguments were not provided:\n  <FILE>...\n",
+            "error: the following required arguments were not provided:\n  <FILE>...\n",
         );
 }
 
 #[test]
 #[cfg(target_os = "linux")]
 fn test_big_p() {
-    if get_effective_gid() != 0 {
+    if getegid() != 0 {
         new_ucmd!()
             .arg("-RP")
             .arg("bin")
@@ -218,7 +218,7 @@ fn test_big_p() {
 #[test]
 #[cfg(any(target_os = "linux", target_os = "android"))]
 fn test_big_h() {
-    if get_effective_gid() != 0 {
+    if getegid() != 0 {
         assert!(
             new_ucmd!()
                 .arg("-RH")
diff --git a/tests/by-util/test_chmod.rs b/tests/by-util/test_chmod.rs
index b5f8ca5c5..9e3c7d2da 100644
--- a/tests/by-util/test_chmod.rs
+++ b/tests/by-util/test_chmod.rs
@@ -1,13 +1,10 @@
-use crate::common::util::*;
+use crate::common::util::{AtPath, TestScenario, UCommand};
 use once_cell::sync::Lazy;
 use std::fs::{metadata, set_permissions, OpenOptions, Permissions};
 use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
 use std::sync::Mutex;
 
-extern crate libc;
-use uucore::mode::strip_minus_from_mode;
-extern crate chmod;
-use self::libc::umask;
+use libc::umask;
 
 static TEST_FILE: &str = "file";
 static REFERENCE_FILE: &str = "reference";
@@ -503,35 +500,6 @@ fn test_chmod_symlink_non_existing_file_recursive() {
         .no_stderr();
 }
 
-#[test]
-fn test_chmod_strip_minus_from_mode() {
-    let tests = vec![
-        // ( before, after )
-        ("chmod -v -xw -R FILE", "chmod -v xw -R FILE"),
-        ("chmod g=rwx FILE -c", "chmod g=rwx FILE -c"),
-        (
-            "chmod -c -R -w,o+w FILE --preserve-root",
-            "chmod -c -R w,o+w FILE --preserve-root",
-        ),
-        ("chmod -c -R +w FILE ", "chmod -c -R +w FILE "),
-        ("chmod a=r,=xX FILE", "chmod a=r,=xX FILE"),
-        (
-            "chmod -v --reference REF_FILE -R FILE",
-            "chmod -v --reference REF_FILE -R FILE",
-        ),
-        ("chmod -Rvc -w-x FILE", "chmod -Rvc w-x FILE"),
-        ("chmod 755 -v FILE", "chmod 755 -v FILE"),
-        ("chmod -v +0004 FILE -R", "chmod -v +0004 FILE -R"),
-        ("chmod -v -0007 FILE -R", "chmod -v 0007 FILE -R"),
-    ];
-
-    for test in tests {
-        let mut args: Vec<String> = test.0.split(' ').map(|v| v.to_string()).collect();
-        let _mode_had_minus_prefix = strip_minus_from_mode(&mut args);
-        assert_eq!(test.1, args.join(" "));
-    }
-}
-
 #[test]
 fn test_chmod_keep_setgid() {
     for (from, arg, to) in [
@@ -570,13 +538,14 @@ fn test_invalid_arg() {
 }
 
 #[test]
+#[cfg(not(target_os = "android"))]
 fn test_mode_after_dash_dash() {
     let (at, ucmd) = at_and_ucmd!();
     run_single_test(
         &TestCase {
             args: vec!["--", "-r", TEST_FILE],
-            before: 0o100777,
-            after: 0o100333,
+            before: 0o100_777,
+            after: 0o100_333,
         },
         &at,
         ucmd,
@@ -600,7 +569,7 @@ fn test_chmod_file_after_non_existing_file() {
         .stderr_contains("chmod: cannot access 'does-not-exist': No such file or directory")
         .code_is(1);
 
-    assert_eq!(at.metadata(TEST_FILE).permissions().mode(), 0o100764);
+    assert_eq!(at.metadata(TEST_FILE).permissions().mode(), 0o100_764);
 
     scene
         .ucmd()
@@ -611,7 +580,7 @@ fn test_chmod_file_after_non_existing_file() {
         .fails()
         .no_stderr()
         .code_is(1);
-    assert_eq!(at.metadata("file2").permissions().mode(), 0o100764);
+    assert_eq!(at.metadata("file2").permissions().mode(), 0o100_764);
 }
 
 #[test]
@@ -647,7 +616,7 @@ fn test_chmod_file_symlink_after_non_existing_file() {
         .stderr_contains(expected_stderr);
     assert_eq!(
         at.metadata(test_existing_symlink).permissions().mode(),
-        0o100764
+        0o100_764
     );
 }
 
@@ -671,3 +640,69 @@ fn test_quiet_n_verbose_used_multiple_times() {
         .arg("file")
         .succeeds();
 }
+
+#[test]
+fn test_gnu_invalid_mode() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch("file");
+    scene.ucmd().arg("u+gr").arg("file").fails();
+}
+
+#[test]
+#[cfg(not(target_os = "android"))]
+fn test_gnu_options() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch("file");
+    scene.ucmd().arg("-w").arg("file").succeeds();
+    scene.ucmd().arg("file").arg("-w").succeeds();
+    scene.ucmd().arg("-w").arg("--").arg("file").succeeds();
+}
+
+#[test]
+fn test_gnu_repeating_options() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch("file");
+    scene.ucmd().arg("-w").arg("-w").arg("file").succeeds();
+    scene
+        .ucmd()
+        .arg("-w")
+        .arg("-w")
+        .arg("-w")
+        .arg("file")
+        .succeeds();
+}
+
+#[test]
+fn test_gnu_special_filenames() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let perms_before = Permissions::from_mode(0o100_640);
+    let perms_after = Permissions::from_mode(0o100_440);
+
+    make_file(&at.plus_as_string("--"), perms_before.mode());
+    scene.ucmd().arg("-w").arg("--").arg("--").succeeds();
+    assert_eq!(at.metadata("--").permissions(), perms_after);
+    set_permissions(at.plus("--"), perms_before.clone()).unwrap();
+    scene.ucmd().arg("--").arg("-w").arg("--").succeeds();
+    assert_eq!(at.metadata("--").permissions(), perms_after);
+    at.remove("--");
+
+    make_file(&at.plus_as_string("-w"), perms_before.mode());
+    scene.ucmd().arg("-w").arg("--").arg("-w").succeeds();
+    assert_eq!(at.metadata("-w").permissions(), perms_after);
+    set_permissions(at.plus("-w"), perms_before).unwrap();
+    scene.ucmd().arg("--").arg("-w").arg("-w").succeeds();
+    assert_eq!(at.metadata("-w").permissions(), perms_after);
+}
+
+#[test]
+fn test_gnu_special_options() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch("file");
+    scene.ucmd().arg("--").arg("--").arg("file").succeeds();
+    scene.ucmd().arg("--").arg("--").fails();
+}
diff --git a/tests/by-util/test_chown.rs b/tests/by-util/test_chown.rs
index c0e210435..7a1a4a6bd 100644
--- a/tests/by-util/test_chown.rs
+++ b/tests/by-util/test_chown.rs
@@ -1,10 +1,8 @@
 // spell-checker:ignore (words) agroupthatdoesntexist auserthatdoesntexist cuuser groupname notexisting passgrp
 
-use crate::common::util::*;
+use crate::common::util::{is_ci, run_ucmd_as_root, CmdResult, TestScenario};
 #[cfg(any(target_os = "linux", target_os = "android"))]
-use rust_users::get_effective_uid;
-
-extern crate chown;
+use uucore::process::geteuid;
 
 // Apparently some CI environments have configuration issues, e.g. with 'whoami' and 'id'.
 // If we are running inside the CI and "needle" is in "stderr" skipping this test is
@@ -36,7 +34,7 @@ fn skipping_test_is_okay(result: &CmdResult, needle: &str) -> bool {
 
 #[cfg(test)]
 mod test_passgrp {
-    use super::chown::entries::{gid2grp, grp2gid, uid2usr, usr2uid};
+    use chown::entries::{gid2grp, grp2gid, uid2usr, usr2uid};
 
     #[test]
     fn test_usr2uid() {
@@ -396,7 +394,7 @@ fn test_chown_only_user_id() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
 
-    let result = scene.cmd("id").keep_env().arg("-u").run();
+    let result = scene.cmd("id").arg("-u").run();
     if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
         return;
     }
@@ -430,7 +428,7 @@ fn test_chown_fail_id() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
 
-    let result = scene.cmd("id").keep_env().arg("-u").run();
+    let result = scene.cmd("id").arg("-u").run();
     if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
         return;
     }
@@ -487,7 +485,7 @@ fn test_chown_only_group_id() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
 
-    let result = scene.cmd("id").keep_env().arg("-g").run();
+    let result = scene.cmd("id").arg("-g").run();
     if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
         return;
     }
@@ -551,14 +549,14 @@ fn test_chown_owner_group_id() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
 
-    let result = scene.cmd("id").keep_env().arg("-u").run();
+    let result = scene.cmd("id").arg("-u").run();
     if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
         return;
     }
     let user_id = String::from(result.stdout_str().trim());
     assert!(!user_id.is_empty());
 
-    let result = scene.cmd("id").keep_env().arg("-g").run();
+    let result = scene.cmd("id").arg("-g").run();
     if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
         return;
     }
@@ -612,14 +610,14 @@ fn test_chown_owner_group_mix() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
 
-    let result = scene.cmd("id").keep_env().arg("-u").run();
+    let result = scene.cmd("id").arg("-u").run();
     if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
         return;
     }
     let user_id = String::from(result.stdout_str().trim());
     assert!(!user_id.is_empty());
 
-    let result = scene.cmd("id").keep_env().arg("-gn").run();
+    let result = scene.cmd("id").arg("-gn").run();
     if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
         return;
     }
@@ -662,10 +660,10 @@ fn test_chown_recursive() {
 
     at.mkdir_all("a/b/c");
     at.mkdir("z");
-    at.touch(&at.plus_as_string("a/a"));
-    at.touch(&at.plus_as_string("a/b/b"));
-    at.touch(&at.plus_as_string("a/b/c/c"));
-    at.touch(&at.plus_as_string("z/y"));
+    at.touch(at.plus_as_string("a/a"));
+    at.touch(at.plus_as_string("a/b/b"));
+    at.touch(at.plus_as_string("a/b/c/c"));
+    at.touch(at.plus_as_string("z/y"));
 
     let result = scene
         .ucmd()
@@ -703,7 +701,7 @@ fn test_root_preserve() {
 #[cfg(any(target_os = "linux", target_os = "android"))]
 #[test]
 fn test_big_p() {
-    if get_effective_uid() != 0 {
+    if geteuid() != 0 {
         new_ucmd!()
             .arg("-RP")
             .arg("bin")
@@ -732,15 +730,275 @@ fn test_chown_file_notexisting() {
     let user_name = String::from(result.stdout_str().trim());
     assert!(!user_name.is_empty());
 
-    let _result = scene
+    scene
         .ucmd()
-        .arg(user_name)
+        .arg(&user_name)
         .arg("--verbose")
         .arg("not_existing")
-        .fails();
-
-    // TODO: uncomment once "failed to change ownership of '{}' to {}" added to stdout
-    // result.stderr_contains("retained as");
+        .fails()
+        .stdout_contains(format!(
+            "failed to change ownership of 'not_existing' to {user_name}"
+        ));
     // TODO: uncomment once message changed from "cannot dereference" to "cannot access"
     // result.stderr_contains("cannot access 'not_existing': No such file or directory");
 }
+
+#[test]
+fn test_chown_no_change_to_user_from_user() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let result = scene.cmd("whoami").run();
+    if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
+        return;
+    }
+    let user_name = String::from(result.stdout_str().trim());
+    assert!(!user_name.is_empty());
+
+    let file = "f";
+    at.touch(file);
+    scene
+        .ucmd()
+        .arg("-v")
+        .arg("--from=42")
+        .arg("43")
+        .arg(file)
+        .succeeds()
+        .stdout_only(format!("ownership of '{file}' retained as {user_name}\n"));
+}
+
+#[test]
+fn test_chown_no_change_to_user_from_group() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let result = scene.cmd("whoami").run();
+    if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
+        return;
+    }
+    let user_name = String::from(result.stdout_str().trim());
+    assert!(!user_name.is_empty());
+
+    let file = "f";
+    at.touch(file);
+    scene
+        .ucmd()
+        .arg("-v")
+        .arg("--from=:42")
+        .arg("43")
+        .arg(file)
+        .succeeds()
+        .stdout_only(format!("ownership of '{file}' retained as {user_name}\n"));
+}
+
+#[test]
+fn test_chown_no_change_to_user_from_user_group() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let result = scene.cmd("whoami").run();
+    if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
+        return;
+    }
+    let user_name = String::from(result.stdout_str().trim());
+    assert!(!user_name.is_empty());
+
+    let file = "f";
+    at.touch(file);
+    scene
+        .ucmd()
+        .arg("-v")
+        .arg("--from=42:42")
+        .arg("43")
+        .arg(file)
+        .succeeds()
+        .stdout_only(format!("ownership of '{file}' retained as {user_name}\n"));
+}
+
+#[test]
+fn test_chown_no_change_to_group_from_user() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let result = scene.cmd("whoami").run();
+    if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
+        return;
+    }
+    let user_name = String::from(result.stdout_str().trim());
+    assert!(!user_name.is_empty());
+
+    let result = scene.cmd("id").arg("-ng").run();
+    if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
+        return;
+    }
+    let group_name = String::from(result.stdout_str().trim());
+    assert!(!group_name.is_empty());
+
+    let file = "f";
+    at.touch(file);
+    scene
+        .ucmd()
+        .arg("-v")
+        .arg("--from=42")
+        .arg(":43")
+        .arg(file)
+        .succeeds()
+        .stdout_only(format!("ownership of '{file}' retained as {group_name}\n"));
+}
+
+#[test]
+fn test_chown_no_change_to_group_from_group() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let result = scene.cmd("whoami").run();
+    if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
+        return;
+    }
+    let user_name = String::from(result.stdout_str().trim());
+    assert!(!user_name.is_empty());
+    let result = scene.cmd("id").arg("-ng").run();
+    if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
+        return;
+    }
+    let group_name = String::from(result.stdout_str().trim());
+    assert!(!group_name.is_empty());
+
+    let file = "f";
+    at.touch(file);
+    scene
+        .ucmd()
+        .arg("-v")
+        .arg("--from=:42")
+        .arg(":43")
+        .arg(file)
+        .succeeds()
+        .stdout_only(format!("ownership of '{file}' retained as {group_name}\n"));
+}
+
+#[test]
+fn test_chown_no_change_to_group_from_user_group() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let result = scene.cmd("whoami").run();
+    if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
+        return;
+    }
+    let user_name = String::from(result.stdout_str().trim());
+    assert!(!user_name.is_empty());
+    let result = scene.cmd("id").arg("-ng").run();
+    if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
+        return;
+    }
+    let group_name = String::from(result.stdout_str().trim());
+    assert!(!group_name.is_empty());
+
+    let file = "f";
+    at.touch(file);
+    scene
+        .ucmd()
+        .arg("-v")
+        .arg("--from=42:42")
+        .arg(":43")
+        .arg(file)
+        .succeeds()
+        .stdout_only(format!("ownership of '{file}' retained as {group_name}\n"));
+}
+
+#[test]
+fn test_chown_no_change_to_user_group_from_user() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let result = scene.cmd("whoami").run();
+    if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
+        return;
+    }
+    let user_name = String::from(result.stdout_str().trim());
+    assert!(!user_name.is_empty());
+
+    let result = scene.cmd("id").arg("-ng").run();
+    if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
+        return;
+    }
+    let group_name = String::from(result.stdout_str().trim());
+    assert!(!group_name.is_empty());
+
+    let file = "f";
+    at.touch(file);
+    scene
+        .ucmd()
+        .arg("-v")
+        .arg("--from=42")
+        .arg("43:43")
+        .arg(file)
+        .succeeds()
+        .stdout_only(format!(
+            "ownership of '{file}' retained as {user_name}:{group_name}\n"
+        ));
+}
+
+#[test]
+fn test_chown_no_change_to_user_group_from_group() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let result = scene.cmd("whoami").run();
+    if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
+        return;
+    }
+    let user_name = String::from(result.stdout_str().trim());
+    assert!(!user_name.is_empty());
+    let result = scene.cmd("id").arg("-ng").run();
+    if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
+        return;
+    }
+    let group_name = String::from(result.stdout_str().trim());
+    assert!(!group_name.is_empty());
+
+    let file = "f";
+    at.touch(file);
+    scene
+        .ucmd()
+        .arg("-v")
+        .arg("--from=:42")
+        .arg("43:43")
+        .arg(file)
+        .succeeds()
+        .stdout_only(format!(
+            "ownership of '{file}' retained as {user_name}:{group_name}\n"
+        ));
+}
+
+#[test]
+fn test_chown_no_change_to_user_group_from_user_group() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let result = scene.cmd("whoami").run();
+    if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
+        return;
+    }
+    let user_name = String::from(result.stdout_str().trim());
+    assert!(!user_name.is_empty());
+    let result = scene.cmd("id").arg("-ng").run();
+    if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
+        return;
+    }
+    let group_name = String::from(result.stdout_str().trim());
+    assert!(!group_name.is_empty());
+
+    let file = "f";
+    at.touch(file);
+    scene
+        .ucmd()
+        .arg("-v")
+        .arg("--from=42:42")
+        .arg("43:43")
+        .arg(file)
+        .succeeds()
+        .stdout_only(format!(
+            "ownership of '{file}' retained as {user_name}:{group_name}\n"
+        ));
+}
diff --git a/tests/by-util/test_chroot.rs b/tests/by-util/test_chroot.rs
index c7e786f93..697be8775 100644
--- a/tests/by-util/test_chroot.rs
+++ b/tests/by-util/test_chroot.rs
@@ -1,6 +1,8 @@
 // spell-checker:ignore (words) araba newroot userspec chdir pwd's isroot
 
-use crate::common::util::*;
+#[cfg(not(target_os = "android"))]
+use crate::common::util::is_ci;
+use crate::common::util::{run_ucmd_as_root, TestScenario};
 
 #[test]
 fn test_invalid_arg() {
@@ -15,7 +17,7 @@ fn test_missing_operand() {
 
     assert!(result
         .stderr_str()
-        .starts_with("error: The following required arguments were not provided"));
+        .starts_with("error: the following required arguments were not provided"));
 
     assert!(result.stderr_str().contains("<newroot>"));
 }
@@ -39,7 +41,7 @@ fn test_enter_chroot_fails() {
 fn test_no_such_directory() {
     let (at, mut ucmd) = at_and_ucmd!();
 
-    at.touch(&at.plus_as_string("a"));
+    at.touch(at.plus_as_string("a"));
 
     ucmd.arg("a")
         .fails()
diff --git a/tests/by-util/test_cksum.rs b/tests/by-util/test_cksum.rs
index 361a9c472..41ddc2ee0 100644
--- a/tests/by-util/test_cksum.rs
+++ b/tests/by-util/test_cksum.rs
@@ -1,6 +1,10 @@
-// spell-checker:ignore (words) asdf
+// spell-checker:ignore (words) asdf algo algos
 
-use crate::common::util::*;
+use crate::common::util::TestScenario;
+
+const ALGOS: [&str; 11] = [
+    "sysv", "bsd", "crc", "md5", "sha1", "sha224", "sha256", "sha384", "sha512", "blake2b", "sm3",
+];
 
 #[test]
 fn test_invalid_arg() {
@@ -12,7 +16,7 @@ fn test_single_file() {
     new_ucmd!()
         .arg("lorem_ipsum.txt")
         .succeeds()
-        .stdout_is_fixture("single_file.expected");
+        .stdout_is_fixture("crc_single_file.expected");
 }
 
 #[test]
@@ -21,7 +25,7 @@ fn test_multiple_files() {
         .arg("lorem_ipsum.txt")
         .arg("alice_in_wonderland.txt")
         .succeeds()
-        .stdout_is_fixture("multiple_files.expected");
+        .stdout_is_fixture("crc_multiple_files.expected");
 }
 
 #[test]
@@ -29,11 +33,11 @@ fn test_stdin() {
     new_ucmd!()
         .pipe_in_fixture("lorem_ipsum.txt")
         .succeeds()
-        .stdout_is_fixture("stdin.expected");
+        .stdout_is_fixture("crc_stdin.expected");
 }
 
 #[test]
-fn test_empty() {
+fn test_empty_file() {
     let (at, mut ucmd) = at_and_ucmd!();
 
     at.touch("a");
@@ -62,25 +66,26 @@ fn test_arg_overrides_stdin() {
 }
 
 #[test]
-fn test_invalid_file() {
-    let ts = TestScenario::new(util_name!());
-    let at = ts.fixtures.clone();
+fn test_nonexisting_file() {
+    let file_name = "asdf";
 
-    let folder_name = "asdf";
-
-    // First check when file doesn't exist
-    ts.ucmd()
-        .arg(folder_name)
+    new_ucmd!()
+        .arg(file_name)
         .fails()
         .no_stdout()
-        .stderr_contains("cksum: asdf: No such file or directory");
+        .stderr_contains(format!("cksum: {file_name}: No such file or directory"));
+}
 
-    // Then check when the file is of an invalid type
+#[test]
+fn test_folder() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let folder_name = "a_folder";
     at.mkdir(folder_name);
-    ts.ucmd()
-        .arg(folder_name)
+
+    ucmd.arg(folder_name)
         .succeeds()
-        .stdout_only("4294967295 0 asdf\n");
+        .stdout_only(format!("4294967295 0 {folder_name}\n"));
 }
 
 // Make sure crc is correct for files larger than 32 bytes
@@ -116,77 +121,106 @@ fn test_stdin_larger_than_128_bytes() {
 }
 
 #[test]
-fn test_sha1_single_file() {
-    new_ucmd!()
-        .arg("-a=sha1")
-        .arg("lorem_ipsum.txt")
-        .succeeds()
-        .stdout_is("ab1dd0bae1d8883a3d18a66de6afbd28252cfbef 772 lorem_ipsum.txt\n");
+fn test_algorithm_single_file() {
+    for algo in ALGOS {
+        for option in ["-a", "--algorithm"] {
+            new_ucmd!()
+                .arg(format!("{option}={algo}"))
+                .arg("lorem_ipsum.txt")
+                .succeeds()
+                .stdout_is_fixture(format!("{algo}_single_file.expected"));
+        }
+    }
 }
 
 #[test]
-fn test_sm3_single_file() {
-    new_ucmd!()
-        .arg("-a=sm3")
-        .arg("lorem_ipsum.txt")
-        .succeeds()
-        .stdout_is(
-        "6d296b805d060bfed22808df308dbb9b4317794dd4ed6740a10770a782699bc2 772 lorem_ipsum.txt\n",
-    );
+fn test_algorithm_multiple_files() {
+    for algo in ALGOS {
+        for option in ["-a", "--algorithm"] {
+            new_ucmd!()
+                .arg(format!("{option}={algo}"))
+                .arg("lorem_ipsum.txt")
+                .arg("alice_in_wonderland.txt")
+                .succeeds()
+                .stdout_is_fixture(format!("{algo}_multiple_files.expected"));
+        }
+    }
 }
 
 #[test]
-fn test_bsd_single_file() {
-    new_ucmd!()
-        .arg("-a=bsd")
-        .arg("lorem_ipsum.txt")
-        .succeeds()
-        .stdout_only_fixture("bsd_single_file.expected");
+fn test_algorithm_stdin() {
+    for algo in ALGOS {
+        for option in ["-a", "--algorithm"] {
+            new_ucmd!()
+                .arg(format!("{option}={algo}"))
+                .pipe_in_fixture("lorem_ipsum.txt")
+                .succeeds()
+                .stdout_is_fixture(format!("{algo}_stdin.expected"));
+        }
+    }
 }
 
 #[test]
-fn test_bsd_multiple_files() {
+fn test_untagged_single_file() {
     new_ucmd!()
-        .arg("-a=bsd")
+        .arg("--untagged")
+        .arg("lorem_ipsum.txt")
+        .succeeds()
+        .stdout_is_fixture("untagged/crc_single_file.expected");
+}
+
+#[test]
+fn test_untagged_multiple_files() {
+    new_ucmd!()
+        .arg("--untagged")
         .arg("lorem_ipsum.txt")
         .arg("alice_in_wonderland.txt")
         .succeeds()
-        .stdout_only_fixture("bsd_multiple_files.expected");
+        .stdout_is_fixture("untagged/crc_multiple_files.expected");
 }
 
 #[test]
-fn test_bsd_stdin() {
+fn test_untagged_stdin() {
     new_ucmd!()
-        .arg("-a=bsd")
+        .arg("--untagged")
         .pipe_in_fixture("lorem_ipsum.txt")
         .succeeds()
-        .stdout_only_fixture("bsd_stdin.expected");
+        .stdout_is_fixture("untagged/crc_stdin.expected");
 }
 
 #[test]
-fn test_sysv_single_file() {
-    new_ucmd!()
-        .arg("-a=sysv")
-        .arg("lorem_ipsum.txt")
-        .succeeds()
-        .stdout_only_fixture("sysv_single_file.expected");
+fn test_untagged_algorithm_single_file() {
+    for algo in ALGOS {
+        new_ucmd!()
+            .arg("--untagged")
+            .arg(format!("--algorithm={algo}"))
+            .arg("lorem_ipsum.txt")
+            .succeeds()
+            .stdout_is_fixture(format!("untagged/{algo}_single_file.expected"));
+    }
 }
 
 #[test]
-fn test_sysv_multiple_files() {
-    new_ucmd!()
-        .arg("-a=sysv")
-        .arg("lorem_ipsum.txt")
-        .arg("alice_in_wonderland.txt")
-        .succeeds()
-        .stdout_only_fixture("sysv_multiple_files.expected");
+fn test_untagged_algorithm_multiple_files() {
+    for algo in ALGOS {
+        new_ucmd!()
+            .arg("--untagged")
+            .arg(format!("--algorithm={algo}"))
+            .arg("lorem_ipsum.txt")
+            .arg("alice_in_wonderland.txt")
+            .succeeds()
+            .stdout_is_fixture(format!("untagged/{algo}_multiple_files.expected"));
+    }
 }
 
 #[test]
-fn test_sysv_stdin() {
-    new_ucmd!()
-        .arg("-a=sysv")
-        .pipe_in_fixture("lorem_ipsum.txt")
-        .succeeds()
-        .stdout_only_fixture("sysv_stdin.expected");
+fn test_untagged_algorithm_stdin() {
+    for algo in ALGOS {
+        new_ucmd!()
+            .arg("--untagged")
+            .arg(format!("--algorithm={algo}"))
+            .pipe_in_fixture("lorem_ipsum.txt")
+            .succeeds()
+            .stdout_is_fixture(format!("untagged/{algo}_stdin.expected"));
+    }
 }
diff --git a/tests/by-util/test_comm.rs b/tests/by-util/test_comm.rs
index 053746908..42c8358bb 100644
--- a/tests/by-util/test_comm.rs
+++ b/tests/by-util/test_comm.rs
@@ -1,6 +1,6 @@
 // spell-checker:ignore (words) defaultcheck nocheck
 
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
@@ -95,19 +95,33 @@ fn output_delimiter_nul() {
         .stdout_only_fixture("ab_delimiter_nul.expected");
 }
 
-// even though (info) documentation suggests this is an option
-// in latest GNU Coreutils comm, it actually is not.
-// this test is essentially an alarm in case some well-intending
-// developer implements it.
-//marked as unimplemented as error message not set yet.
-#[cfg_attr(not(feature = "test_unimplemented"), ignore)]
 #[test]
 fn zero_terminated() {
     for param in ["-z", "--zero-terminated"] {
         new_ucmd!()
-            .args(&[param, "a", "b"])
-            .fails()
-            .stderr_only("error to be defined");
+            .args(&[param, "a_nul", "b_nul"])
+            .succeeds()
+            .stdout_only_fixture("ab_nul.expected");
+    }
+}
+
+#[test]
+fn zero_terminated_provided_multiple_times() {
+    for param in ["-z", "--zero-terminated"] {
+        new_ucmd!()
+            .args(&[param, param, param, "a_nul", "b_nul"])
+            .succeeds()
+            .stdout_only_fixture("ab_nul.expected");
+    }
+}
+
+#[test]
+fn zero_terminated_with_total() {
+    for param in ["-z", "--zero-terminated"] {
+        new_ucmd!()
+            .args(&[param, "--total", "a_nul", "b_nul"])
+            .succeeds()
+            .stdout_only_fixture("ab_nul_total.expected");
     }
 }
 
diff --git a/tests/by-util/test_cp.rs b/tests/by-util/test_cp.rs
index 6c7bcdb4c..fa5845eac 100644
--- a/tests/by-util/test_cp.rs
+++ b/tests/by-util/test_cp.rs
@@ -1,6 +1,6 @@
 // spell-checker:ignore (flags) reflink (fs) tmpfs (linux) rlimit Rlim NOFILE clob btrfs ROOTDIR USERDIR procfs outfile
 
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 #[cfg(not(windows))]
 use std::fs::set_permissions;
 
@@ -15,16 +15,24 @@ use std::os::unix::fs::PermissionsExt;
 use std::os::windows::fs::symlink_file;
 #[cfg(not(windows))]
 use std::path::Path;
+#[cfg(target_os = "linux")]
+use std::path::PathBuf;
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use filetime::FileTime;
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use rlimit::Resource;
+#[cfg(target_os = "linux")]
+use std::ffi::OsString;
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use std::fs as std_fs;
 use std::thread::sleep;
 use std::time::Duration;
 
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg(feature = "truncate")]
+use crate::common::util::PATH;
+
 static TEST_EXISTING_FILE: &str = "existing_file.txt";
 static TEST_HELLO_WORLD_SOURCE: &str = "hello_world.txt";
 static TEST_HELLO_WORLD_SOURCE_SYMLINK: &str = "hello_world.txt.link";
@@ -91,7 +99,7 @@ fn test_cp_existing_target() {
     assert_eq!(at.read(TEST_EXISTING_FILE), "Hello, World!\n");
 
     // No backup should have been created
-    assert!(!at.file_exists(&format!("{TEST_EXISTING_FILE}~")));
+    assert!(!at.file_exists(format!("{TEST_EXISTING_FILE}~")));
 }
 
 #[test]
@@ -226,6 +234,202 @@ fn test_cp_arg_update_interactive() {
         .no_stderr();
 }
 
+#[test]
+fn test_cp_arg_update_interactive_error() {
+    new_ucmd!()
+        .arg(TEST_HELLO_WORLD_SOURCE)
+        .arg(TEST_HOW_ARE_YOU_SOURCE)
+        .arg("-i")
+        .fails()
+        .no_stdout();
+}
+
+#[test]
+fn test_cp_arg_update_none() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    ucmd.arg(TEST_HELLO_WORLD_SOURCE)
+        .arg(TEST_HOW_ARE_YOU_SOURCE)
+        .arg("--update=none")
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+
+    assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "How are you?\n");
+}
+
+#[test]
+fn test_cp_arg_update_all() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    ucmd.arg(TEST_HELLO_WORLD_SOURCE)
+        .arg(TEST_HOW_ARE_YOU_SOURCE)
+        .arg("--update=all")
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+
+    assert_eq!(
+        at.read(TEST_HOW_ARE_YOU_SOURCE),
+        at.read(TEST_HELLO_WORLD_SOURCE)
+    );
+}
+
+#[test]
+fn test_cp_arg_update_older_dest_not_older_than_src() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let old = "test_cp_arg_update_dest_not_older_file1";
+    let new = "test_cp_arg_update_dest_not_older_file2";
+    let old_content = "old content\n";
+    let new_content = "new content\n";
+
+    at.write(old, old_content);
+    at.write(new, new_content);
+
+    ucmd.arg(old)
+        .arg(new)
+        .arg("--update=older")
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+
+    assert_eq!(at.read(new), "new content\n");
+}
+
+#[test]
+fn test_cp_arg_update_older_dest_older_than_src() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let old = "test_cp_arg_update_dest_older_file1";
+    let new = "test_cp_arg_update_dest_older_file2";
+    let old_content = "old content\n";
+    let new_content = "new content\n";
+
+    at.write(old, old_content);
+
+    sleep(Duration::from_secs(1));
+
+    at.write(new, new_content);
+
+    ucmd.arg(new)
+        .arg(old)
+        .arg("--update=older")
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+
+    assert_eq!(at.read(old), "new content\n");
+}
+
+#[test]
+fn test_cp_arg_update_short_no_overwrite() {
+    // same as --update=older
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let old = "test_cp_arg_update_short_no_overwrite_file1";
+    let new = "test_cp_arg_update_short_no_overwrite_file2";
+    let old_content = "old content\n";
+    let new_content = "new content\n";
+
+    at.write(old, old_content);
+
+    sleep(Duration::from_secs(1));
+
+    at.write(new, new_content);
+
+    ucmd.arg(old)
+        .arg(new)
+        .arg("-u")
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+
+    assert_eq!(at.read(new), "new content\n");
+}
+
+#[test]
+fn test_cp_arg_update_short_overwrite() {
+    // same as --update=older
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let old = "test_cp_arg_update_short_overwrite_file1";
+    let new = "test_cp_arg_update_short_overwrite_file2";
+    let old_content = "old content\n";
+    let new_content = "new content\n";
+
+    at.write(old, old_content);
+
+    sleep(Duration::from_secs(1));
+
+    at.write(new, new_content);
+
+    ucmd.arg(new)
+        .arg(old)
+        .arg("-u")
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+
+    assert_eq!(at.read(old), "new content\n");
+}
+
+#[test]
+fn test_cp_arg_update_none_then_all() {
+    // take last if multiple update args are supplied,
+    // update=all wins in this case
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let old = "test_cp_arg_update_none_then_all_file1";
+    let new = "test_cp_arg_update_none_then_all_file2";
+    let old_content = "old content\n";
+    let new_content = "new content\n";
+
+    at.write(old, old_content);
+
+    sleep(Duration::from_secs(1));
+
+    at.write(new, new_content);
+
+    ucmd.arg(old)
+        .arg(new)
+        .arg("--update=none")
+        .arg("--update=all")
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+
+    assert_eq!(at.read(new), "old content\n");
+}
+
+#[test]
+fn test_cp_arg_update_all_then_none() {
+    // take last if multiple update args are supplied,
+    // update=none wins in this case
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let old = "test_cp_arg_update_all_then_none_file1";
+    let new = "test_cp_arg_update_all_then_none_file2";
+    let old_content = "old content\n";
+    let new_content = "new content\n";
+
+    at.write(old, old_content);
+
+    sleep(Duration::from_secs(1));
+
+    at.write(new, new_content);
+
+    ucmd.arg(old)
+        .arg(new)
+        .arg("--update=all")
+        .arg("--update=none")
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+
+    assert_eq!(at.read(new), "new content\n");
+}
+
 #[test]
 fn test_cp_arg_interactive() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -233,11 +437,48 @@ fn test_cp_arg_interactive() {
     at.touch("b");
     ucmd.args(&["-i", "a", "b"])
         .pipe_in("N\n")
-        .succeeds()
+        .fails()
         .no_stdout()
         .stderr_is("cp: overwrite 'b'? ");
 }
 
+#[test]
+#[cfg(not(target_os = "android"))]
+fn test_cp_arg_interactive_update() {
+    // -u -i won't show the prompt to validate the override or not
+    // Therefore, the error code will be 0
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.touch("a");
+    at.touch("b");
+    ucmd.args(&["-i", "-u", "a", "b"])
+        .pipe_in("N\n")
+        .succeeds()
+        .no_stdout();
+}
+
+#[test]
+#[cfg(not(target_os = "android"))]
+fn test_cp_arg_interactive_verbose() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.touch("a");
+    at.touch("b");
+    ucmd.args(&["-vi", "a", "b"])
+        .pipe_in("N\n")
+        .fails()
+        .stdout_is("skipped 'b'\n");
+}
+
+#[test]
+#[cfg(not(target_os = "android"))]
+fn test_cp_arg_interactive_verbose_clobber() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.touch("a");
+    at.touch("b");
+    ucmd.args(&["-vin", "a", "b"])
+        .fails()
+        .stdout_is("skipped 'b'\n");
+}
+
 #[test]
 #[cfg(target_os = "linux")]
 fn test_cp_arg_link() {
@@ -269,7 +510,8 @@ fn test_cp_arg_no_clobber() {
     ucmd.arg(TEST_HELLO_WORLD_SOURCE)
         .arg(TEST_HOW_ARE_YOU_SOURCE)
         .arg("--no-clobber")
-        .succeeds();
+        .fails()
+        .stderr_contains("not replacing");
 
     assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "How are you?\n");
 }
@@ -280,7 +522,7 @@ fn test_cp_arg_no_clobber_inferred_arg() {
     ucmd.arg(TEST_HELLO_WORLD_SOURCE)
         .arg(TEST_HOW_ARE_YOU_SOURCE)
         .arg("--no-clob")
-        .succeeds();
+        .fails();
 
     assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "How are you?\n");
 }
@@ -307,7 +549,7 @@ fn test_cp_arg_no_clobber_twice() {
         .arg("--no-clobber")
         .arg("source.txt")
         .arg("dest.txt")
-        .succeeds();
+        .fails();
 
     assert_eq!(at.read("source.txt"), "some-content");
     // Should be empty as the "no-clobber" should keep
@@ -636,7 +878,7 @@ fn test_cp_backup_none() {
         .no_stderr();
 
     assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "Hello, World!\n");
-    assert!(!at.file_exists(&format!("{TEST_HOW_ARE_YOU_SOURCE}~")));
+    assert!(!at.file_exists(format!("{TEST_HOW_ARE_YOU_SOURCE}~")));
 }
 
 #[test]
@@ -650,7 +892,7 @@ fn test_cp_backup_off() {
         .no_stderr();
 
     assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "Hello, World!\n");
-    assert!(!at.file_exists(&format!("{TEST_HOW_ARE_YOU_SOURCE}~")));
+    assert!(!at.file_exists(format!("{TEST_HOW_ARE_YOU_SOURCE}~")));
 }
 
 #[test]
@@ -700,7 +942,7 @@ fn test_cp_deref() {
         .join(TEST_HELLO_WORLD_SOURCE_SYMLINK);
     // unlike -P/--no-deref, we expect a file, not a link
     assert!(at.file_exists(
-        &path_to_new_symlink
+        path_to_new_symlink
             .clone()
             .into_os_string()
             .into_string()
@@ -857,6 +1099,88 @@ fn test_cp_parents_dest_not_directory() {
         .stderr_contains("with --parents, the destination must be a directory");
 }
 
+#[test]
+fn test_cp_parents_with_permissions_copy_file() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let dir = "dir";
+    let file = "p1/p2/file";
+
+    at.mkdir(dir);
+    at.mkdir_all("p1/p2");
+    at.touch(file);
+
+    let p1_mode = 0o0777;
+    let p2_mode = 0o0711;
+    let file_mode = 0o0702;
+
+    #[cfg(unix)]
+    {
+        at.set_mode("p1", p1_mode);
+        at.set_mode("p1/p2", p2_mode);
+        at.set_mode(file, file_mode);
+    }
+
+    ucmd.arg("-p")
+        .arg("--parents")
+        .arg(file)
+        .arg(dir)
+        .succeeds();
+
+    #[cfg(all(unix, not(target_os = "freebsd")))]
+    {
+        let p1_metadata = at.metadata("p1");
+        let p2_metadata = at.metadata("p1/p2");
+        let file_metadata = at.metadata(file);
+
+        assert_metadata_eq!(p1_metadata, at.metadata("dir/p1"));
+        assert_metadata_eq!(p2_metadata, at.metadata("dir/p1/p2"));
+        assert_metadata_eq!(file_metadata, at.metadata("dir/p1/p2/file"));
+    }
+}
+
+#[test]
+fn test_cp_parents_with_permissions_copy_dir() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let dir1 = "dir";
+    let dir2 = "p1/p2";
+    let file = "p1/p2/file";
+
+    at.mkdir(dir1);
+    at.mkdir_all(dir2);
+    at.touch(file);
+
+    let p1_mode = 0o0777;
+    let p2_mode = 0o0711;
+    let file_mode = 0o0702;
+
+    #[cfg(unix)]
+    {
+        at.set_mode("p1", p1_mode);
+        at.set_mode("p1/p2", p2_mode);
+        at.set_mode(file, file_mode);
+    }
+
+    ucmd.arg("-p")
+        .arg("--parents")
+        .arg("-r")
+        .arg(dir2)
+        .arg(dir1)
+        .succeeds();
+
+    #[cfg(all(unix, not(target_os = "freebsd")))]
+    {
+        let p1_metadata = at.metadata("p1");
+        let p2_metadata = at.metadata("p1/p2");
+        let file_metadata = at.metadata(file);
+
+        assert_metadata_eq!(p1_metadata, at.metadata("dir/p1"));
+        assert_metadata_eq!(p2_metadata, at.metadata("dir/p1/p2"));
+        assert_metadata_eq!(file_metadata, at.metadata("dir/p1/p2/file"));
+    }
+}
+
 #[test]
 #[cfg(unix)]
 fn test_cp_writable_special_file_permissions() {
@@ -899,6 +1223,33 @@ fn test_cp_preserve_no_args() {
     }
 }
 
+#[test]
+fn test_cp_preserve_no_args_before_opts() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let src_file = "a";
+    let dst_file = "b";
+
+    // Prepare the source file
+    at.touch(src_file);
+    #[cfg(unix)]
+    at.set_mode(src_file, 0o0500);
+
+    // Copy
+    ucmd.arg("--preserve")
+        .arg(src_file)
+        .arg(dst_file)
+        .succeeds();
+
+    #[cfg(all(unix, not(target_os = "freebsd")))]
+    {
+        // Assert that the mode, ownership, and timestamps are preserved
+        // NOTICE: the ownership is not modified on the src file, because that requires root permissions
+        let metadata_src = at.metadata(src_file);
+        let metadata_dst = at.metadata(dst_file);
+        assert_metadata_eq!(metadata_src, metadata_dst);
+    }
+}
+
 #[test]
 fn test_cp_preserve_all() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -1062,7 +1413,7 @@ fn test_cp_deref_folder_to_folder() {
         .join(TEST_COPY_TO_FOLDER_NEW)
         .join(TEST_HELLO_WORLD_SOURCE_SYMLINK);
     assert!(at.file_exists(
-        &path_to_new_symlink
+        path_to_new_symlink
             .clone()
             .into_os_string()
             .into_string()
@@ -1180,7 +1531,7 @@ fn test_cp_no_deref_folder_to_folder() {
 #[cfg(target_os = "linux")]
 fn test_cp_archive() {
     let (at, mut ucmd) = at_and_ucmd!();
-    let ts = time::OffsetDateTime::now_local().unwrap();
+    let ts = time::OffsetDateTime::now_utc();
     let previous = FileTime::from_unix_time(ts.unix_timestamp() - 3600, ts.nanosecond());
     // set the file creation/modification an hour ago
     filetime::set_file_times(
@@ -1225,8 +1576,8 @@ fn test_cp_archive_recursive() {
     let file_2 = at.subdir.join(TEST_COPY_TO_FOLDER).join("2");
     let file_2_link = at.subdir.join(TEST_COPY_TO_FOLDER).join("2.link");
 
-    at.touch(&file_1.to_string_lossy());
-    at.touch(&file_2.to_string_lossy());
+    at.touch(file_1);
+    at.touch(file_2);
 
     at.symlink_file("1", &file_1_link.to_string_lossy());
     at.symlink_file("2", &file_2_link.to_string_lossy());
@@ -1252,18 +1603,8 @@ fn test_cp_archive_recursive() {
         .run();
 
     println!("ls dest {}", result.stdout_str());
-    assert!(at.file_exists(
-        &at.subdir
-            .join(TEST_COPY_TO_FOLDER_NEW)
-            .join("1")
-            .to_string_lossy()
-    ));
-    assert!(at.file_exists(
-        &at.subdir
-            .join(TEST_COPY_TO_FOLDER_NEW)
-            .join("2")
-            .to_string_lossy()
-    ));
+    assert!(at.file_exists(at.subdir.join(TEST_COPY_TO_FOLDER_NEW).join("1")));
+    assert!(at.file_exists(at.subdir.join(TEST_COPY_TO_FOLDER_NEW).join("2")));
 
     assert!(at.is_symlink(
         &at.subdir
@@ -1283,7 +1624,7 @@ fn test_cp_archive_recursive() {
 #[cfg(any(target_os = "linux", target_os = "android"))]
 fn test_cp_preserve_timestamps() {
     let (at, mut ucmd) = at_and_ucmd!();
-    let ts = time::OffsetDateTime::now_local().unwrap();
+    let ts = time::OffsetDateTime::now_utc();
     let previous = FileTime::from_unix_time(ts.unix_timestamp() - 3600, ts.nanosecond());
     // set the file creation/modification an hour ago
     filetime::set_file_times(
@@ -1316,7 +1657,7 @@ fn test_cp_preserve_timestamps() {
 #[cfg(any(target_os = "linux", target_os = "android"))]
 fn test_cp_no_preserve_timestamps() {
     let (at, mut ucmd) = at_and_ucmd!();
-    let ts = time::OffsetDateTime::now_local().unwrap();
+    let ts = time::OffsetDateTime::now_utc();
     let previous = FileTime::from_unix_time(ts.unix_timestamp() - 3600, ts.nanosecond());
     // set the file creation/modification an hour ago
     filetime::set_file_times(
@@ -1373,13 +1714,13 @@ fn test_cp_one_file_system() {
     use walkdir::WalkDir;
 
     let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
 
     // Test must be run as root (or with `sudo -E`)
     if scene.cmd("whoami").run().stdout_str() != "root\n" {
         return;
     }
 
-    let at = scene.fixtures.clone();
     let at_src = AtPath::new(&at.plus(TEST_MOUNT_COPY_FROM_FOLDER));
     let at_dst = AtPath::new(&at.plus(TEST_COPY_TO_FOLDER_NEW));
 
@@ -1501,7 +1842,7 @@ fn test_cp_reflink_bad() {
         .arg(TEST_HELLO_WORLD_SOURCE)
         .arg(TEST_EXISTING_FILE)
         .fails()
-        .stderr_contains("error: 'bad' isn't a valid value for '--reflink[=<WHEN>]'");
+        .stderr_contains("error: invalid value 'bad' for '--reflink[=<WHEN>]'");
 }
 
 #[test]
@@ -1521,7 +1862,7 @@ fn test_cp_reflink_insufficient_permission() {
         .stderr_only("cp: 'unreadable' -> 'existing_file.txt': Permission denied (os error 13)\n");
 }
 
-#[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg(target_os = "linux")]
 #[test]
 fn test_closes_file_descriptors() {
     use procfs::process::Process;
@@ -1672,7 +2013,7 @@ fn test_cp_reflink_always_override() {
     let dst_path: &str = &vec![MOUNTPOINT, USERDIR, "dst"].concat();
 
     scene.fixtures.mkdir(ROOTDIR);
-    scene.fixtures.mkdir(&vec![ROOTDIR, USERDIR].concat());
+    scene.fixtures.mkdir(vec![ROOTDIR, USERDIR].concat());
 
     // Setup:
     // Because neither `mkfs.btrfs` not btrfs `mount` options allow us to have a mountpoint owned
@@ -1693,7 +2034,7 @@ fn test_cp_reflink_always_override() {
 
     if !scene
         .cmd("env")
-        .keep_env()
+        .env("PATH", PATH)
         .args(&["mkfs.btrfs", "--rootdir", ROOTDIR, DISK])
         .run()
         .succeeded()
@@ -1706,7 +2047,7 @@ fn test_cp_reflink_always_override() {
 
     let mount = scene
         .cmd("sudo")
-        .keep_env()
+        .env("PATH", PATH)
         .args(&["-E", "--non-interactive", "mount", DISK, MOUNTPOINT])
         .run();
 
@@ -1733,7 +2074,7 @@ fn test_cp_reflink_always_override() {
 
     scene
         .cmd("sudo")
-        .keep_env()
+        .env("PATH", PATH)
         .args(&["-E", "--non-interactive", "umount", MOUNTPOINT])
         .succeeds();
 }
@@ -1881,6 +2222,17 @@ fn test_copy_through_dangling_symlink() {
         .stderr_only("cp: not writing through dangling symlink 'target'\n");
 }
 
+#[test]
+fn test_copy_through_dangling_symlink_posixly_correct() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.touch("file");
+    at.symlink_file("nonexistent", "target");
+    ucmd.arg("file")
+        .arg("target")
+        .env("POSIXLY_CORRECT", "1")
+        .succeeds();
+}
+
 #[test]
 fn test_copy_through_dangling_symlink_no_dereference() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -2276,6 +2628,20 @@ fn test_remove_destination_symbolic_link_loop() {
     assert!(at.file_exists("loop"));
 }
 
+#[test]
+#[cfg(not(windows))]
+fn test_cp_symbolic_link_loop() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.symlink_file("loop", "loop");
+    at.plus("loop");
+    at.touch("f");
+    ucmd.args(&["-f", "f", "loop"])
+        .succeeds()
+        .no_stdout()
+        .no_stderr();
+    assert!(at.file_exists("loop"));
+}
+
 /// Test that copying a directory to itself is disallowed.
 #[test]
 fn test_copy_directory_to_itself_disallowed() {
@@ -2536,6 +2902,54 @@ fn test_src_base_dot() {
     assert!(!at.dir_exists("y/x"));
 }
 
+#[cfg(target_os = "linux")]
+fn non_utf8_name(suffix: &str) -> OsString {
+    use std::os::unix::ffi::OsStringExt;
+    let mut name = OsString::from_vec(vec![0xff, 0xff]);
+    name.push(suffix);
+    name
+}
+
+#[cfg(target_os = "linux")]
+#[test]
+fn test_non_utf8_src() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let src = non_utf8_name("src");
+    std::fs::File::create(at.plus(&src)).unwrap();
+    ucmd.args(&[src, "dest".into()])
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+    assert!(at.file_exists("dest"));
+}
+
+#[cfg(target_os = "linux")]
+#[test]
+fn test_non_utf8_dest() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let dest = non_utf8_name("dest");
+    ucmd.args(&[TEST_HELLO_WORLD_SOURCE.as_ref(), &*dest])
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+    assert!(at.file_exists(dest));
+}
+
+#[cfg(target_os = "linux")]
+#[test]
+fn test_non_utf8_target() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let dest = non_utf8_name("dest");
+    at.mkdir(&dest);
+    ucmd.args(&["-t".as_ref(), &*dest, TEST_HELLO_WORLD_SOURCE.as_ref()])
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+    let mut copied_file = PathBuf::from(dest);
+    copied_file.push(TEST_HELLO_WORLD_SOURCE);
+    assert!(at.file_exists(copied_file));
+}
+
 #[test]
 #[cfg(not(windows))]
 fn test_cp_archive_on_directory_ending_dot() {
@@ -2546,3 +2960,246 @@ fn test_cp_archive_on_directory_ending_dot() {
     ucmd.args(&["-a", "dir1/.", "dir2"]).succeeds();
     assert!(at.file_exists("dir2/file"));
 }
+
+#[test]
+fn test_cp_debug_default() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.touch("a");
+    let result = ts.ucmd().arg("--debug").arg("a").arg("b").succeeds();
+
+    let stdout_str = result.stdout_str();
+    #[cfg(target_os = "macos")]
+    if !stdout_str
+        .contains("copy offload: unknown, reflink: unsupported, sparse detection: unsupported")
+    {
+        panic!("Failure: stdout was \n{stdout_str}");
+    }
+    #[cfg(target_os = "linux")]
+    if !stdout_str.contains("copy offload: unknown, reflink: unsupported, sparse detection: no") {
+        panic!("Failure: stdout was \n{stdout_str}");
+    }
+
+    #[cfg(windows)]
+    if !stdout_str
+        .contains("copy offload: unsupported, reflink: unsupported, sparse detection: unsupported")
+    {
+        panic!("Failure: stdout was \n{stdout_str}");
+    }
+}
+
+#[test]
+fn test_cp_debug_multiple_default() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    let dir = "dir";
+    at.touch("a");
+    at.touch("b");
+    at.mkdir(dir);
+    let result = ts
+        .ucmd()
+        .arg("--debug")
+        .arg("a")
+        .arg("b")
+        .arg(dir)
+        .succeeds();
+
+    let stdout_str = result.stdout_str();
+
+    #[cfg(target_os = "macos")]
+    {
+        if !stdout_str
+            .contains("copy offload: unknown, reflink: unsupported, sparse detection: unsupported")
+        {
+            panic!("Failure: stdout was \n{stdout_str}");
+        }
+
+        // two files, two occurrences
+        assert_eq!(
+            result
+                .stdout_str()
+                .matches(
+                    "copy offload: unknown, reflink: unsupported, sparse detection: unsupported"
+                )
+                .count(),
+            2
+        );
+    }
+
+    #[cfg(target_os = "linux")]
+    {
+        if !stdout_str.contains("copy offload: unknown, reflink: unsupported, sparse detection: no")
+        {
+            panic!("Failure: stdout was \n{stdout_str}");
+        }
+
+        // two files, two occurrences
+        assert_eq!(
+            result
+                .stdout_str()
+                .matches("copy offload: unknown, reflink: unsupported, sparse detection: no")
+                .count(),
+            2
+        );
+    }
+
+    #[cfg(target_os = "windows")]
+    {
+        if !stdout_str.contains(
+            "copy offload: unsupported, reflink: unsupported, sparse detection: unsupported",
+        ) {
+            panic!("Failure: stdout was \n{stdout_str}");
+        }
+
+        // two files, two occurrences
+        assert_eq!(
+            result
+                .stdout_str()
+                .matches("copy offload: unsupported, reflink: unsupported, sparse detection: unsupported")
+                .count(),
+            2
+        );
+    }
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_cp_debug_sparse_reflink() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.touch("a");
+    let result = ts
+        .ucmd()
+        .arg("--debug")
+        .arg("--sparse=always")
+        .arg("--reflink=never")
+        .arg("a")
+        .arg("b")
+        .succeeds();
+
+    let stdout_str = result.stdout_str();
+    if !stdout_str.contains("copy offload: avoided, reflink: no, sparse detection: zeros") {
+        panic!("Failure: stdout was \n{stdout_str}");
+    }
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_cp_debug_sparse_always() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.touch("a");
+    let result = ts
+        .ucmd()
+        .arg("--debug")
+        .arg("--sparse=always")
+        .arg("a")
+        .arg("b")
+        .succeeds();
+    let stdout_str = result.stdout_str();
+    if !stdout_str.contains("copy offload: avoided, reflink: unsupported, sparse detection: zeros")
+    {
+        panic!("Failure: stdout was \n{stdout_str}");
+    }
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_cp_debug_sparse_never() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.touch("a");
+    let result = ts
+        .ucmd()
+        .arg("--debug")
+        .arg("--sparse=never")
+        .arg("a")
+        .arg("b")
+        .succeeds();
+    let stdout_str = result.stdout_str();
+    if !stdout_str.contains("copy offload: unknown, reflink: unsupported, sparse detection: no") {
+        panic!("Failure: stdout was \n{stdout_str}");
+    }
+}
+
+#[test]
+fn test_cp_debug_sparse_auto() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.touch("a");
+    let result = ts
+        .ucmd()
+        .arg("--debug")
+        .arg("--sparse=auto")
+        .arg("a")
+        .arg("b")
+        .succeeds();
+    let stdout_str = result.stdout_str();
+
+    #[cfg(target_os = "macos")]
+    if !stdout_str
+        .contains("copy offload: unknown, reflink: unsupported, sparse detection: unsupported")
+    {
+        panic!("Failure: stdout was \n{stdout_str}");
+    }
+
+    #[cfg(target_os = "linux")]
+    if !stdout_str.contains("copy offload: unknown, reflink: unsupported, sparse detection: no") {
+        panic!("Failure: stdout was \n{stdout_str}");
+    }
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android", target_os = "macos"))]
+fn test_cp_debug_reflink_auto() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.touch("a");
+    let result = ts
+        .ucmd()
+        .arg("--debug")
+        .arg("--reflink=auto")
+        .arg("a")
+        .arg("b")
+        .succeeds();
+
+    #[cfg(target_os = "linux")]
+    {
+        let stdout_str = result.stdout_str();
+        if !stdout_str.contains("copy offload: unknown, reflink: unsupported, sparse detection: no")
+        {
+            panic!("Failure: stdout was \n{stdout_str}");
+        }
+    }
+
+    #[cfg(target_os = "macos")]
+    {
+        let stdout_str = result.stdout_str();
+        if !stdout_str
+            .contains("copy offload: unknown, reflink: unsupported, sparse detection: unsupported")
+        {
+            panic!("Failure: stdout was \n{stdout_str}");
+        }
+    }
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_cp_debug_sparse_always_reflink_auto() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.touch("a");
+    let result = ts
+        .ucmd()
+        .arg("--debug")
+        .arg("--sparse=always")
+        .arg("--reflink=auto")
+        .arg("a")
+        .arg("b")
+        .succeeds();
+    let stdout_str = result.stdout_str();
+    if !stdout_str.contains("copy offload: avoided, reflink: unsupported, sparse detection: zeros")
+    {
+        panic!("Failure: stdout was \n{stdout_str}");
+    }
+}
diff --git a/tests/by-util/test_csplit.rs b/tests/by-util/test_csplit.rs
index 771cd5f81..eecaccfaf 100644
--- a/tests/by-util/test_csplit.rs
+++ b/tests/by-util/test_csplit.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 use glob::glob;
 
 /// Returns a string of numbers with the given range, each on a new line.
diff --git a/tests/by-util/test_cut.rs b/tests/by-util/test_cut.rs
index bad609758..a82950beb 100644
--- a/tests/by-util/test_cut.rs
+++ b/tests/by-util/test_cut.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 static INPUT: &str = "lists.txt";
 
diff --git a/tests/by-util/test_date.rs b/tests/by-util/test_date.rs
index a1064a8fa..669f02e33 100644
--- a/tests/by-util/test_date.rs
+++ b/tests/by-util/test_date.rs
@@ -1,9 +1,7 @@
-extern crate regex;
-
-use self::regex::Regex;
-use crate::common::util::*;
+use crate::common::util::TestScenario;
+use regex::Regex;
 #[cfg(all(unix, not(target_os = "macos")))]
-use rust_users::*;
+use uucore::process::geteuid;
 
 #[test]
 fn test_invalid_arg() {
@@ -44,16 +42,91 @@ fn test_date_rfc_3339() {
 }
 
 #[test]
-fn test_date_rfc_8601() {
+fn test_date_rfc_3339_invalid_arg() {
+    for param in ["--iso-3339", "--rfc-3"] {
+        new_ucmd!().arg(format!("{param}=foo")).fails();
+    }
+}
+
+#[test]
+fn test_date_rfc_8601_default() {
+    let re = Regex::new(r"^\d{4}-\d{2}-\d{2}\n$").unwrap();
     for param in ["--iso-8601", "--i"] {
-        new_ucmd!().arg(format!("{param}=ns")).succeeds();
+        new_ucmd!().arg(param).succeeds().stdout_matches(&re);
+    }
+}
+
+#[test]
+fn test_date_rfc_8601() {
+    let re = Regex::new(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2},\d{9}[+-]\d{2}:\d{2}\n$").unwrap();
+    for param in ["--iso-8601", "--i"] {
+        new_ucmd!()
+            .arg(format!("{param}=ns"))
+            .succeeds()
+            .stdout_matches(&re);
+    }
+}
+
+#[test]
+fn test_date_rfc_8601_invalid_arg() {
+    for param in ["--iso-8601", "--i"] {
+        new_ucmd!().arg(format!("{param}=@")).fails();
     }
 }
 
 #[test]
 fn test_date_rfc_8601_second() {
+    let re = Regex::new(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}[+-]\d{2}:\d{2}\n$").unwrap();
     for param in ["--iso-8601", "--i"] {
-        new_ucmd!().arg(format!("{param}=second")).succeeds();
+        new_ucmd!()
+            .arg(format!("{param}=second"))
+            .succeeds()
+            .stdout_matches(&re);
+        new_ucmd!()
+            .arg(format!("{param}=seconds"))
+            .succeeds()
+            .stdout_matches(&re);
+    }
+}
+
+#[test]
+fn test_date_rfc_8601_minute() {
+    let re = Regex::new(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}[+-]\d{2}:\d{2}\n$").unwrap();
+    for param in ["--iso-8601", "--i"] {
+        new_ucmd!()
+            .arg(format!("{param}=minute"))
+            .succeeds()
+            .stdout_matches(&re);
+        new_ucmd!()
+            .arg(format!("{param}=minutes"))
+            .succeeds()
+            .stdout_matches(&re);
+    }
+}
+
+#[test]
+fn test_date_rfc_8601_hour() {
+    let re = Regex::new(r"^\d{4}-\d{2}-\d{2}T\d{2}[+-]\d{2}:\d{2}\n$").unwrap();
+    for param in ["--iso-8601", "--i"] {
+        new_ucmd!()
+            .arg(format!("{param}=hour"))
+            .succeeds()
+            .stdout_matches(&re);
+        new_ucmd!()
+            .arg(format!("{param}=hours"))
+            .succeeds()
+            .stdout_matches(&re);
+    }
+}
+
+#[test]
+fn test_date_rfc_8601_date() {
+    let re = Regex::new(r"^\d{4}-\d{2}-\d{2}\n$").unwrap();
+    for param in ["--iso-8601", "--i"] {
+        new_ucmd!()
+            .arg(format!("{param}=date"))
+            .succeeds()
+            .stdout_matches(&re);
     }
 }
 
@@ -140,7 +213,7 @@ fn test_date_format_literal() {
 #[test]
 #[cfg(all(unix, not(target_os = "macos")))]
 fn test_date_set_valid() {
-    if get_effective_uid() == 0 {
+    if geteuid() == 0 {
         new_ucmd!()
             .arg("--set")
             .arg("2020-03-12 13:30:00+08:00")
@@ -161,7 +234,7 @@ fn test_date_set_invalid() {
 #[test]
 #[cfg(all(unix, not(any(target_os = "android", target_os = "macos"))))]
 fn test_date_set_permissions_error() {
-    if !(get_effective_uid() == 0 || uucore::os::is_wsl_1()) {
+    if !(geteuid() == 0 || uucore::os::is_wsl_1()) {
         let result = new_ucmd!()
             .arg("--set")
             .arg("2020-03-11 21:45:00+08:00")
@@ -188,7 +261,7 @@ fn test_date_set_mac_unavailable() {
 #[cfg(all(unix, not(target_os = "macos")))]
 /// TODO: expected to fail currently; change to succeeds() when required.
 fn test_date_set_valid_2() {
-    if get_effective_uid() == 0 {
+    if geteuid() == 0 {
         let result = new_ucmd!()
             .arg("--set")
             .arg("Sat 20 Mar 2021 14:53:01 AWST") // spell-checker:disable-line
@@ -198,11 +271,61 @@ fn test_date_set_valid_2() {
     }
 }
 
+#[test]
+fn test_date_for_invalid_file() {
+    let result = new_ucmd!().arg("--file").arg("invalid_file").fails();
+    result.no_stdout();
+    assert_eq!(
+        result.stderr_str().trim(),
+        "date: invalid_file: No such file or directory",
+    );
+}
+
+#[test]
+#[cfg(unix)]
+fn test_date_for_no_permission_file() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    const FILE: &str = "file-no-perm-1";
+
+    use std::os::unix::fs::PermissionsExt;
+    let file = std::fs::OpenOptions::new()
+        .create(true)
+        .write(true)
+        .open(at.plus(FILE))
+        .unwrap();
+    file.set_permissions(std::fs::Permissions::from_mode(0o222))
+        .unwrap();
+    let result = ucmd.arg("--file").arg(FILE).fails();
+    result.no_stdout();
+    assert_eq!(
+        result.stderr_str().trim(),
+        format!("date: {FILE}: Permission denied")
+    );
+}
+
+#[test]
+fn test_date_for_dir_as_file() {
+    let result = new_ucmd!().arg("--file").arg("/").fails();
+    result.no_stdout();
+    assert_eq!(
+        result.stderr_str().trim(),
+        "date: expected file, got directory '/'",
+    );
+}
+
+#[test]
+fn test_date_for_file() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file = "test_date_for_file";
+    at.touch(file);
+    ucmd.arg("--file").arg(file).succeeds();
+}
+
 #[test]
 #[cfg(all(unix, not(target_os = "macos")))]
 /// TODO: expected to fail currently; change to succeeds() when required.
 fn test_date_set_valid_3() {
-    if get_effective_uid() == 0 {
+    if geteuid() == 0 {
         let result = new_ucmd!()
             .arg("--set")
             .arg("Sat 20 Mar 2021 14:53:01") // Local timezone
@@ -216,7 +339,7 @@ fn test_date_set_valid_3() {
 #[cfg(all(unix, not(target_os = "macos")))]
 /// TODO: expected to fail currently; change to succeeds() when required.
 fn test_date_set_valid_4() {
-    if get_effective_uid() == 0 {
+    if geteuid() == 0 {
         let result = new_ucmd!()
             .arg("--set")
             .arg("2020-03-11 21:45:00") // Local timezone
@@ -232,3 +355,43 @@ fn test_invalid_format_string() {
     result.no_stdout();
     assert!(result.stderr_str().starts_with("date: invalid format "));
 }
+
+#[test]
+fn test_unsupported_format() {
+    let result = new_ucmd!().arg("+%#z").fails();
+    result.no_stdout();
+    assert!(result.stderr_str().starts_with("date: invalid format %#z"));
+}
+
+#[test]
+fn test_date_string_human() {
+    let date_formats = vec![
+        "1 year ago",
+        "1 year",
+        "2 months ago",
+        "15 days ago",
+        "1 week ago",
+        "5 hours ago",
+        "30 minutes ago",
+        "10 seconds",
+    ];
+    let re = Regex::new(r"^\d{4}-\d{2}-\d{2} \d{2}:\d{2}\n$").unwrap();
+    for date_format in date_formats {
+        new_ucmd!()
+            .arg("-d")
+            .arg(date_format)
+            .arg("+%Y-%m-%d %S:%M")
+            .succeeds()
+            .stdout_matches(&re);
+    }
+}
+
+#[test]
+fn test_invalid_date_string() {
+    new_ucmd!()
+        .arg("-d")
+        .arg("foo")
+        .fails()
+        .no_stdout()
+        .stderr_contains("invalid date");
+}
diff --git a/tests/by-util/test_dd.rs b/tests/by-util/test_dd.rs
index 5deeb12f0..b43f32c24 100644
--- a/tests/by-util/test_dd.rs
+++ b/tests/by-util/test_dd.rs
@@ -1,11 +1,15 @@
 // spell-checker:ignore fname, tname, fpath, specfile, testfile, unspec, ifile, ofile, outfile, fullblock, urand, fileio, atoe, atoibm, availible, behaviour, bmax, bremain, btotal, cflags, creat, ctable, ctty, datastructures, doesnt, etoa, fileout, fname, gnudd, iconvflags, iseek, nocache, noctty, noerror, nofollow, nolinks, nonblock, oconvflags, oseek, outfile, parseargs, rlen, rmax, rposition, rremain, rsofar, rstat, sigusr, sigval, wlen, wstat abcdefghijklm abcdefghi nabcde nabcdefg abcdefg
 
-use crate::common::util::*;
+use crate::common::util::TestScenario;
+#[cfg(all(not(windows), feature = "printf"))]
+use crate::common::util::{UCommand, TESTS_BINARY};
+
+use regex::Regex;
 
 use std::fs::{File, OpenOptions};
 use std::io::{BufReader, Read, Write};
 use std::path::PathBuf;
-#[cfg(all(not(windows), not(target_os = "macos")))]
+#[cfg(all(unix, not(target_os = "macos"), not(target_os = "freebsd")))]
 use std::process::{Command, Stdio};
 #[cfg(not(windows))]
 use std::thread::sleep;
@@ -261,7 +265,9 @@ fn test_final_stats_noxfer() {
 fn test_final_stats_unspec() {
     new_ucmd!()
         .run()
-        .stderr_only("0+0 records in\n0+0 records out\n0 bytes copied, 0.0 s, 0.0 B/s\n")
+        .stderr_contains("0+0 records in\n0+0 records out\n0 bytes copied, ")
+        .stderr_matches(&Regex::new(r"\d\.\d+(e-\d\d)? s, ").unwrap())
+        .stderr_contains("0.0 B/s")
         .success();
 }
 
@@ -375,9 +381,11 @@ fn test_existing_file_truncated() {
 #[test]
 fn test_null_stats() {
     new_ucmd!()
-        .args(&["if=null.txt"])
+        .arg("if=null.txt")
         .run()
-        .stderr_only("0+0 records in\n0+0 records out\n0 bytes copied, 0.0 s, 0.0 B/s\n")
+        .stderr_contains("0+0 records in\n0+0 records out\n0 bytes copied, ")
+        .stderr_matches(&Regex::new(r"\d\.\d+(e-\d\d)? s, ").unwrap())
+        .stderr_contains("0.0 B/s")
         .success();
 }
 
@@ -1514,3 +1522,43 @@ fn test_skip_input_fifo() {
     assert!(output.stdout.is_empty());
     assert_eq!(&output.stderr, b"1+0 records in\n1+0 records out\n");
 }
+
+/// Test for reading part of stdin from each of two child processes.
+#[cfg(all(not(windows), feature = "printf"))]
+#[test]
+fn test_multiple_processes_reading_stdin() {
+    // TODO Investigate if this is possible on Windows.
+    let printf = format!("{TESTS_BINARY} printf 'abcdef\n'");
+    let dd_skip = format!("{TESTS_BINARY} dd bs=1 skip=3 count=0");
+    let dd = format!("{TESTS_BINARY} dd");
+    UCommand::new()
+        .arg(format!("{printf} | ( {dd_skip} && {dd} ) 2> /dev/null"))
+        .succeeds()
+        .stdout_only("def\n");
+}
+
+/// Test that discarding system file cache fails for stdin.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_nocache_stdin_error() {
+    #[cfg(not(target_env = "musl"))]
+    let detail = "Illegal seek";
+    #[cfg(target_env = "musl")]
+    let detail = "Invalid seek";
+    new_ucmd!()
+        .args(&["iflag=nocache", "count=0", "status=noxfer"])
+        .fails()
+        .code_is(1)
+        .stderr_only(format!("dd: failed to discard cache for: 'standard input': {detail}\n0+0 records in\n0+0 records out\n"));
+}
+
+/// Test for discarding system file cache.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_nocache_file() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.write_bytes("f", b"a".repeat(1 << 20).as_slice());
+    ucmd.args(&["if=f", "of=/dev/null", "iflag=nocache", "status=noxfer"])
+        .succeeds()
+        .stderr_only("2048+0 records in\n2048+0 records out\n");
+}
diff --git a/tests/by-util/test_df.rs b/tests/by-util/test_df.rs
index 0cf27c205..a5100e471 100644
--- a/tests/by-util/test_df.rs
+++ b/tests/by-util/test_df.rs
@@ -1,7 +1,7 @@
 // spell-checker:ignore udev pcent iuse itotal iused ipcent
 use std::collections::HashSet;
 
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
diff --git a/tests/by-util/test_dir.rs b/tests/by-util/test_dir.rs
index 068ffbbcc..fd94f3a8f 100644
--- a/tests/by-util/test_dir.rs
+++ b/tests/by-util/test_dir.rs
@@ -1,11 +1,5 @@
-#[cfg(not(windows))]
-extern crate libc;
-extern crate regex;
-#[cfg(not(windows))]
-extern crate tempfile;
-
-use self::regex::Regex;
-use crate::common::util::*;
+use crate::common::util::TestScenario;
+use regex::Regex;
 
 /*
  * As dir use the same functions than ls, we don't have to retest them here.
diff --git a/tests/by-util/test_dircolors.rs b/tests/by-util/test_dircolors.rs
index aaff02d30..2d83c76b5 100644
--- a/tests/by-util/test_dircolors.rs
+++ b/tests/by-util/test_dircolors.rs
@@ -1,8 +1,7 @@
 // spell-checker:ignore overridable
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
-extern crate dircolors;
-use self::dircolors::{guess_syntax, OutputFmt, StrUtils};
+use dircolors::{guess_syntax, OutputFmt, StrUtils};
 
 #[test]
 fn test_invalid_arg() {
@@ -221,3 +220,13 @@ fn test_helper(file_name: &str, term: &str) {
         .run()
         .stdout_is_fixture(format!("{file_name}.sh.expected"));
 }
+
+#[test]
+fn test_dircolors_for_dir_as_file() {
+    let result = new_ucmd!().args(&["-c", "/"]).fails();
+    result.no_stdout();
+    assert_eq!(
+        result.stderr_str().trim(),
+        "dircolors: expected file, got directory '/'",
+    );
+}
diff --git a/tests/by-util/test_dirname.rs b/tests/by-util/test_dirname.rs
index 952f715e8..ae689041b 100644
--- a/tests/by-util/test_dirname.rs
+++ b/tests/by-util/test_dirname.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
diff --git a/tests/by-util/test_du.rs b/tests/by-util/test_du.rs
index 1232beda9..699746f03 100644
--- a/tests/by-util/test_du.rs
+++ b/tests/by-util/test_du.rs
@@ -3,13 +3,14 @@
 //  * For the full copyright and license information, please view the LICENSE
 //  * file that was distributed with this source code.
 
-// spell-checker:ignore (paths) sublink subwords azerty azeaze xcwww azeaz amaz azea qzerty tazerty
+// spell-checker:ignore (paths) sublink subwords azerty azeaze xcwww azeaz amaz azea qzerty tazerty tsublink
 #[cfg(not(windows))]
 use regex::Regex;
-#[cfg(not(windows))]
 use std::io::Write;
 
-use crate::common::util::*;
+#[cfg(any(target_os = "linux", target_os = "android"))]
+use crate::common::util::expected_result;
+use crate::common::util::TestScenario;
 
 const SUB_DIR: &str = "subdir/deeper";
 const SUB_DEEPER_DIR: &str = "subdir/deeper/deeper_dir";
@@ -82,10 +83,10 @@ fn _du_basics_subdir(s: &str) {
 ))]
 fn _du_basics_subdir(s: &str) {
     // MS-WSL linux has altered expected output
-    if !uucore::os::is_wsl_1() {
-        assert_eq!(s, "8\tsubdir/deeper\n");
-    } else {
+    if uucore::os::is_wsl_1() {
         assert_eq!(s, "0\tsubdir/deeper\n");
+    } else {
+        assert_eq!(s, "8\tsubdir/deeper\n");
     }
 }
 
@@ -120,7 +121,7 @@ fn test_du_invalid_size() {
 fn test_du_basics_bad_name() {
     new_ucmd!()
         .arg("bad_name")
-        .succeeds() // TODO: replace with ".fails()" once `du` is fixed
+        .fails()
         .stderr_only("du: bad_name: No such file or directory\n");
 }
 
@@ -164,10 +165,10 @@ fn _du_soft_link(s: &str) {
 ))]
 fn _du_soft_link(s: &str) {
     // MS-WSL linux has altered expected output
-    if !uucore::os::is_wsl_1() {
-        assert_eq!(s, "16\tsubdir/links\n");
-    } else {
+    if uucore::os::is_wsl_1() {
         assert_eq!(s, "8\tsubdir/links\n");
+    } else {
+        assert_eq!(s, "16\tsubdir/links\n");
     }
 }
 
@@ -212,10 +213,10 @@ fn _du_hard_link(s: &str) {
 ))]
 fn _du_hard_link(s: &str) {
     // MS-WSL linux has altered expected output
-    if !uucore::os::is_wsl_1() {
-        assert_eq!(s, "16\tsubdir/links\n");
-    } else {
+    if uucore::os::is_wsl_1() {
         assert_eq!(s, "8\tsubdir/links\n");
+    } else {
+        assert_eq!(s, "16\tsubdir/links\n");
     }
 }
 
@@ -255,10 +256,10 @@ fn _du_d_flag(s: &str) {
 ))]
 fn _du_d_flag(s: &str) {
     // MS-WSL linux has altered expected output
-    if !uucore::os::is_wsl_1() {
-        assert_eq!(s, "28\t./subdir\n36\t.\n");
-    } else {
+    if uucore::os::is_wsl_1() {
         assert_eq!(s, "8\t./subdir\n8\t.\n");
+    } else {
+        assert_eq!(s, "28\t./subdir\n36\t.\n");
     }
 }
 
@@ -284,6 +285,30 @@ fn test_du_dereference() {
     _du_dereference(result.stdout_str());
 }
 
+#[cfg(not(windows))]
+#[test]
+fn test_du_dereference_args() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.mkdir_all("subdir");
+    let mut file1 = at.make_file("subdir/file-ignore1");
+    file1.write_all(b"azeaze").unwrap();
+    let mut file2 = at.make_file("subdir/file-ignore1");
+    file2.write_all(b"amaz?ng").unwrap();
+    at.symlink_dir("subdir", "sublink");
+
+    let result = ts.ucmd().arg("-D").arg("-s").arg("sublink").succeeds();
+    let stdout = result.stdout_str();
+
+    assert!(!stdout.starts_with('0'));
+    assert!(stdout.contains("sublink"));
+
+    // Without the option
+    let result = ts.ucmd().arg("-s").arg("sublink").succeeds();
+    result.stdout_contains("0\tsublink\n");
+}
+
 #[cfg(target_vendor = "apple")]
 fn _du_dereference(s: &str) {
     assert_eq!(s, "4\tsubdir/links/deeper_dir\n16\tsubdir/links\n");
@@ -303,10 +328,10 @@ fn _du_dereference(s: &str) {
 ))]
 fn _du_dereference(s: &str) {
     // MS-WSL linux has altered expected output
-    if !uucore::os::is_wsl_1() {
-        assert_eq!(s, "8\tsubdir/links/deeper_dir\n24\tsubdir/links\n");
-    } else {
+    if uucore::os::is_wsl_1() {
         assert_eq!(s, "0\tsubdir/links/deeper_dir\n8\tsubdir/links\n");
+    } else {
+        assert_eq!(s, "8\tsubdir/links/deeper_dir\n24\tsubdir/links\n");
     }
 }
 
@@ -391,7 +416,12 @@ fn test_du_h_flag_empty_file() {
 fn test_du_time() {
     let ts = TestScenario::new(util_name!());
 
+    // du --time formats the timestamp according to the local timezone. We set the TZ
+    // environment variable to UTC in the commands below to ensure consistent outputs
+    // and test results regardless of the timezone of the machine this test runs in.
+
     ts.ccmd("touch")
+        .env("TZ", "UTC")
         .arg("-a")
         .arg("-t")
         .arg("201505150000")
@@ -399,19 +429,35 @@ fn test_du_time() {
         .succeeds();
 
     ts.ccmd("touch")
+        .env("TZ", "UTC")
         .arg("-m")
         .arg("-t")
         .arg("201606160000")
         .arg("date_test")
         .succeeds();
 
-    let result = ts.ucmd().arg("--time").arg("date_test").succeeds();
+    let result = ts
+        .ucmd()
+        .env("TZ", "UTC")
+        .arg("--time")
+        .arg("date_test")
+        .succeeds();
     result.stdout_only("0\t2016-06-16 00:00\tdate_test\n");
 
-    let result = ts.ucmd().arg("--time=atime").arg("date_test").succeeds();
+    let result = ts
+        .ucmd()
+        .env("TZ", "UTC")
+        .arg("--time=atime")
+        .arg("date_test")
+        .succeeds();
     result.stdout_only("0\t2015-05-15 00:00\tdate_test\n");
 
-    let result = ts.ucmd().arg("--time=ctime").arg("date_test").succeeds();
+    let result = ts
+        .ucmd()
+        .env("TZ", "UTC")
+        .arg("--time=ctime")
+        .arg("date_test")
+        .succeeds();
     result.stdout_only("0\t2016-06-16 00:00\tdate_test\n");
 
     if birth_supported() {
@@ -523,6 +569,15 @@ fn test_du_threshold() {
         .stdout_contains("deeper_dir");
 }
 
+#[test]
+fn test_du_invalid_threshold() {
+    let ts = TestScenario::new(util_name!());
+
+    let threshold = "-0";
+
+    ts.ucmd().arg(format!("--threshold={threshold}")).fails();
+}
+
 #[test]
 fn test_du_apparent_size() {
     let ts = TestScenario::new(util_name!());
@@ -819,3 +874,29 @@ fn test_du_exclude_invalid_syntax() {
         .fails()
         .stderr_contains("du: Invalid exclude syntax");
 }
+
+#[cfg(not(windows))]
+#[test]
+fn test_du_symlink_fail() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.symlink_file("non-existing.txt", "target.txt");
+
+    ts.ucmd().arg("-L").arg("target.txt").fails().code_is(1);
+}
+
+#[cfg(not(windows))]
+#[test]
+fn test_du_symlink_multiple_fail() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.symlink_file("non-existing.txt", "target.txt");
+    let mut file1 = at.make_file("file1");
+    file1.write_all(b"azeaze").unwrap();
+
+    let result = ts.ucmd().arg("-L").arg("target.txt").arg("file1").fails();
+    assert_eq!(result.code(), 1);
+    result.stdout_contains("4\tfile1\n");
+}
diff --git a/tests/by-util/test_echo.rs b/tests/by-util/test_echo.rs
index f28bc1bb4..1c07a6737 100644
--- a/tests/by-util/test_echo.rs
+++ b/tests/by-util/test_echo.rs
@@ -1,6 +1,6 @@
 // spell-checker:ignore (words) araba merci
 
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_default() {
diff --git a/tests/by-util/test_env.rs b/tests/by-util/test_env.rs
index 9b386541c..bd206c8e5 100644
--- a/tests/by-util/test_env.rs
+++ b/tests/by-util/test_env.rs
@@ -1,6 +1,6 @@
 // spell-checker:ignore (words) bamf chdir rlimit prlimit COMSPEC
 
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 use std::env;
 use std::path::Path;
 use tempfile::tempdir;
@@ -153,11 +153,9 @@ fn test_null_delimiter() {
 
 #[test]
 fn test_unset_variable() {
-    // This test depends on the HOME variable being pre-defined by the
-    // default shell
     let out = TestScenario::new(util_name!())
         .ucmd()
-        .keep_env()
+        .env("HOME", "FOO")
         .arg("-u")
         .arg("HOME")
         .succeeds()
diff --git a/tests/by-util/test_expand.rs b/tests/by-util/test_expand.rs
index 5b4f269ea..88c1b1670 100644
--- a/tests/by-util/test_expand.rs
+++ b/tests/by-util/test_expand.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 use uucore::display::Quotable;
 // spell-checker:ignore (ToDO) taaaa tbbbb tcccc
 
diff --git a/tests/by-util/test_expr.rs b/tests/by-util/test_expr.rs
index 1eebf35f0..235a91120 100644
--- a/tests/by-util/test_expr.rs
+++ b/tests/by-util/test_expr.rs
@@ -1,6 +1,6 @@
 // spell-checker:ignore αbcdef ; (people) kkos
 
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_simple_values() {
diff --git a/tests/by-util/test_factor.rs b/tests/by-util/test_factor.rs
index 7a4d54fb5..1c7541370 100644
--- a/tests/by-util/test_factor.rs
+++ b/tests/by-util/test_factor.rs
@@ -8,19 +8,16 @@
 
 // spell-checker:ignore (methods) hexdigest
 
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 use std::time::{Duration, SystemTime};
 
 #[path = "../../src/uu/factor/sieve.rs"]
 mod sieve;
 
-extern crate conv;
-extern crate rand;
-
-use self::rand::distributions::{Distribution, Uniform};
-use self::rand::{rngs::SmallRng, Rng, SeedableRng};
 use self::sieve::Sieve;
+use rand::distributions::{Distribution, Uniform};
+use rand::{rngs::SmallRng, Rng, SeedableRng};
 
 const NUM_PRIMES: usize = 10000;
 const NUM_TESTS: usize = 100;
@@ -30,9 +27,17 @@ fn test_invalid_arg() {
     new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
 }
 
+#[test]
+fn test_valid_arg_exponents() {
+    new_ucmd!().arg("-h").succeeds().code_is(0);
+    new_ucmd!().arg("--exponents").succeeds().code_is(0);
+}
+
 #[test]
 #[cfg(feature = "sort")]
+#[cfg(not(target_os = "android"))]
 fn test_parallel() {
+    use crate::common::util::AtPath;
     use hex_literal::hex;
     use sha1::{Digest, Sha1};
     use std::{fs::OpenOptions, time::Duration};
@@ -80,7 +85,6 @@ fn test_parallel() {
 
 #[test]
 fn test_first_1000_integers() {
-    extern crate sha1;
     use hex_literal::hex;
     use sha1::{Digest, Sha1};
 
@@ -103,6 +107,33 @@ fn test_first_1000_integers() {
     );
 }
 
+#[test]
+fn test_first_1000_integers_with_exponents() {
+    use hex_literal::hex;
+    use sha1::{Digest, Sha1};
+
+    let n_integers = 1000;
+    let mut input_string = String::new();
+    for i in 0..=n_integers {
+        input_string.push_str(&(format!("{i} "))[..]);
+    }
+
+    println!("STDIN='{input_string}'");
+    let result = new_ucmd!()
+        .arg("-h")
+        .pipe_in(input_string.as_bytes())
+        .succeeds();
+
+    // Using factor from GNU Coreutils 9.2
+    // `seq 0 1000 | factor -h | sha1sum` => "45f5f758a9319870770bd1fec2de23d54331944d"
+    let mut hasher = Sha1::new();
+    hasher.update(result.stdout());
+    let hash_check = hasher.finalize();
+    assert_eq!(
+        hash_check[..],
+        hex!("45f5f758a9319870770bd1fec2de23d54331944d")
+    );
+}
 #[test]
 fn test_cli_args() {
     // Make sure that factor works with CLI arguments as well.
@@ -117,7 +148,7 @@ fn test_cli_args() {
 
 #[test]
 fn test_random() {
-    use conv::prelude::*;
+    use conv::prelude::ValueFrom;
 
     let log_num_primes = f64::value_from(NUM_PRIMES).unwrap().log2().ceil();
     let primes = Sieve::primes().take(NUM_PRIMES).collect::<Vec<u64>>();
@@ -282,6 +313,35 @@ fn run(input_string: &[u8], output_string: &[u8]) {
         .stdout_is(String::from_utf8(output_string.to_owned()).unwrap());
 }
 
+#[test]
+fn test_primes_with_exponents() {
+    let mut input_string = String::new();
+    let mut output_string = String::new();
+    for primes in PRIMES_BY_BITS.iter() {
+        for &prime in *primes {
+            input_string.push_str(&(format!("{prime} "))[..]);
+            output_string.push_str(&(format!("{prime}: {prime}\n"))[..]);
+        }
+    }
+
+    println!(
+        "STDIN='{}'",
+        String::from_utf8_lossy(input_string.as_bytes())
+    );
+    println!(
+        "STDOUT(expected)='{}'",
+        String::from_utf8_lossy(output_string.as_bytes())
+    );
+
+    // run factor with --exponents
+    new_ucmd!()
+        .timeout(Duration::from_secs(240))
+        .arg("--exponents")
+        .pipe_in(input_string)
+        .run()
+        .stdout_is(String::from_utf8(output_string.as_bytes().to_owned()).unwrap());
+}
+
 const PRIMES_BY_BITS: &[&[u64]] = &[
     PRIMES14, PRIMES15, PRIMES16, PRIMES17, PRIMES18, PRIMES19, PRIMES20, PRIMES21, PRIMES22,
     PRIMES23, PRIMES24, PRIMES25, PRIMES26, PRIMES27, PRIMES28, PRIMES29, PRIMES30, PRIMES31,
diff --git a/tests/by-util/test_false.rs b/tests/by-util/test_false.rs
index 5ce64e7a8..c6c663404 100644
--- a/tests/by-util/test_false.rs
+++ b/tests/by-util/test_false.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "netbsd"))]
 use std::fs::OpenOptions;
 
diff --git a/tests/by-util/test_fmt.rs b/tests/by-util/test_fmt.rs
index 02d205466..afce9acd8 100644
--- a/tests/by-util/test_fmt.rs
+++ b/tests/by-util/test_fmt.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
@@ -7,47 +7,39 @@ fn test_invalid_arg() {
 
 #[test]
 fn test_fmt() {
-    let result = new_ucmd!().arg("one-word-per-line.txt").run();
-    //.stdout_is_fixture("call_graph.expected");
-    assert_eq!(
-        result.stdout_str().trim(),
-        "this is a file with one word per line"
-    );
+    new_ucmd!()
+        .arg("one-word-per-line.txt")
+        .succeeds()
+        .stdout_is("this is a file with one word per line\n");
 }
 
 #[test]
-fn test_fmt_q() {
-    let result = new_ucmd!().arg("-q").arg("one-word-per-line.txt").run();
-    //.stdout_is_fixture("call_graph.expected");
-    assert_eq!(
-        result.stdout_str().trim(),
-        "this is a file with one word per line"
-    );
+fn test_fmt_quick() {
+    for param in ["-q", "--quick"] {
+        new_ucmd!()
+            .args(&["one-word-per-line.txt", param])
+            .succeeds()
+            .stdout_is("this is a file with one word per line\n");
+    }
 }
 
 #[test]
-fn test_fmt_w_too_big() {
-    let result = new_ucmd!()
-        .arg("-w")
-        .arg("2501")
-        .arg("one-word-per-line.txt")
-        .run();
-    //.stdout_is_fixture("call_graph.expected");
-    assert_eq!(
-        result.stderr_str().trim(),
-        "fmt: invalid width: '2501': Numerical result out of range"
-    );
+fn test_fmt_width() {
+    for param in ["-w", "--width"] {
+        new_ucmd!()
+            .args(&["one-word-per-line.txt", param, "10"])
+            .succeeds()
+            .stdout_is("this is\na file\nwith one\nword per\nline\n");
+    }
 }
+
 #[test]
-fn test_fmt_w() {
-    let result = new_ucmd!()
-        .arg("-w")
-        .arg("10")
-        .arg("one-word-per-line.txt")
-        .run();
-    //.stdout_is_fixture("call_graph.expected");
-    assert_eq!(
-        result.stdout_str().trim(),
-        "this is\na file\nwith one\nword per\nline"
-    );
+fn test_fmt_width_too_big() {
+    for param in ["-w", "--width"] {
+        new_ucmd!()
+            .args(&["one-word-per-line.txt", param, "2501"])
+            .fails()
+            .code_is(1)
+            .stderr_is("fmt: invalid width: '2501': Numerical result out of range\n");
+    }
 }
diff --git a/tests/by-util/test_fold.rs b/tests/by-util/test_fold.rs
index 049535422..b61d9f5ed 100644
--- a/tests/by-util/test_fold.rs
+++ b/tests/by-util/test_fold.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
diff --git a/tests/by-util/test_groups.rs b/tests/by-util/test_groups.rs
index 1432e8c9c..4f6bb7f1b 100644
--- a/tests/by-util/test_groups.rs
+++ b/tests/by-util/test_groups.rs
@@ -5,7 +5,7 @@
 
 //spell-checker: ignore coreutil
 
-use crate::common::util::*;
+use crate::common::util::{check_coreutil_version, expected_result, whoami, TestScenario};
 
 const VERSION_MIN_MULTIPLE_USERS: &str = "8.31"; // this feature was introduced in GNU's coreutils 8.31
 
diff --git a/tests/by-util/test_hashsum.rs b/tests/by-util/test_hashsum.rs
index 5a9cd1965..3650047b2 100644
--- a/tests/by-util/test_hashsum.rs
+++ b/tests/by-util/test_hashsum.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 // spell-checker:ignore checkfile, nonames, testf, ntestf
 macro_rules! get_hash(
     ($str:expr) => (
@@ -53,6 +53,14 @@ macro_rules! test_digest {
                 .stdout_is("input.txt: OK\n");
         }
 
+        #[test]
+        fn test_zero() {
+            let ts = TestScenario::new("hashsum");
+            assert_eq!(ts.fixtures.read(EXPECTED_FILE),
+                       get_hash!(ts.ucmd().arg(DIGEST_ARG).arg(BITS_ARG).arg("--zero").arg("input.txt").succeeds().no_stderr().stdout_str()));
+        }
+
+
         #[cfg(windows)]
         #[test]
         fn test_text_mode() {
@@ -117,6 +125,70 @@ fn test_check_sha1() {
         .stderr_is("");
 }
 
+#[test]
+fn test_check_b2sum_length_option_0() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("testf", "foobar\n");
+    at.write("testf.b2sum", "9e2bf63e933e610efee4a8d6cd4a9387e80860edee97e27db3b37a828d226ab1eb92a9cdd8ca9ca67a753edaf8bd89a0558496f67a30af6f766943839acf0110  testf\n");
+
+    scene
+        .ccmd("b2sum")
+        .arg("--length=0")
+        .arg("-c")
+        .arg(at.subdir.join("testf.b2sum"))
+        .succeeds()
+        .stdout_only("testf: OK\n");
+}
+
+#[test]
+fn test_check_b2sum_length_option_8() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("testf", "foobar\n");
+    at.write("testf.b2sum", "6a  testf\n");
+
+    scene
+        .ccmd("b2sum")
+        .arg("--length=8")
+        .arg("-c")
+        .arg(at.subdir.join("testf.b2sum"))
+        .succeeds()
+        .stdout_only("testf: OK\n");
+}
+
+#[test]
+fn test_invalid_b2sum_length_option_not_multiple_of_8() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("testf", "foobar\n");
+
+    scene
+        .ccmd("b2sum")
+        .arg("--length=9")
+        .arg(at.subdir.join("testf"))
+        .fails()
+        .code_is(1);
+}
+
+#[test]
+fn test_invalid_b2sum_length_option_too_large() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("testf", "foobar\n");
+
+    scene
+        .ccmd("b2sum")
+        .arg("--length=513")
+        .arg(at.subdir.join("testf"))
+        .fails()
+        .code_is(1);
+}
+
 #[test]
 fn test_check_file_not_found_warning() {
     let scene = TestScenario::new(util_name!());
@@ -137,6 +209,144 @@ fn test_check_file_not_found_warning() {
         .stderr_is("sha1sum: warning: 1 listed file could not be read\n");
 }
 
+// Asterisk `*` is a reserved paths character on win32, nor the path can end with a whitespace.
+// ref: https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#naming-conventions
+#[test]
+fn test_check_md5sum() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    #[cfg(not(windows))]
+    {
+        for f in &["a", " b", "*c", "dd", " "] {
+            at.write(f, &format!("{f}\n"));
+        }
+        at.write(
+            "check.md5sum",
+            "60b725f10c9c85c70d97880dfe8191b3  a\n\
+             bf35d7536c785cf06730d5a40301eba2   b\n\
+             f5b61709718c1ecf8db1aea8547d4698  *c\n\
+             b064a020db8018f18ff5ae367d01b212  dd\n\
+             d784fa8b6d98d27699781bd9a7cf19f0   ",
+        );
+        scene
+            .ccmd("md5sum")
+            .arg("--strict")
+            .arg("-c")
+            .arg("check.md5sum")
+            .succeeds()
+            .stdout_is("a: OK\n b: OK\n*c: OK\ndd: OK\n : OK\n")
+            .stderr_is("");
+    }
+    #[cfg(windows)]
+    {
+        for f in &["a", " b", "dd"] {
+            at.write(f, &format!("{f}\n"));
+        }
+        at.write(
+            "check.md5sum",
+            "60b725f10c9c85c70d97880dfe8191b3  a\n\
+             bf35d7536c785cf06730d5a40301eba2   b\n\
+             b064a020db8018f18ff5ae367d01b212  dd",
+        );
+        scene
+            .ccmd("md5sum")
+            .arg("--strict")
+            .arg("-c")
+            .arg("check.md5sum")
+            .succeeds()
+            .stdout_is("a: OK\n b: OK\ndd: OK\n")
+            .stderr_is("");
+    }
+}
+
+#[test]
+fn test_check_md5sum_reverse_bsd() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    #[cfg(not(windows))]
+    {
+        for f in &["a", " b", "*c", "dd", " "] {
+            at.write(f, &format!("{f}\n"));
+        }
+        at.write(
+            "check.md5sum",
+            "60b725f10c9c85c70d97880dfe8191b3 a\n\
+             bf35d7536c785cf06730d5a40301eba2  b\n\
+             f5b61709718c1ecf8db1aea8547d4698 *c\n\
+             b064a020db8018f18ff5ae367d01b212 dd\n\
+             d784fa8b6d98d27699781bd9a7cf19f0  ",
+        );
+        scene
+            .ccmd("md5sum")
+            .arg("--strict")
+            .arg("-c")
+            .arg("check.md5sum")
+            .succeeds()
+            .stdout_is("a: OK\n b: OK\n*c: OK\ndd: OK\n : OK\n")
+            .stderr_is("");
+    }
+    #[cfg(windows)]
+    {
+        for f in &["a", " b", "dd"] {
+            at.write(f, &format!("{f}\n"));
+        }
+        at.write(
+            "check.md5sum",
+            "60b725f10c9c85c70d97880dfe8191b3 a\n\
+             bf35d7536c785cf06730d5a40301eba2  b\n\
+             b064a020db8018f18ff5ae367d01b212 dd",
+        );
+        scene
+            .ccmd("md5sum")
+            .arg("--strict")
+            .arg("-c")
+            .arg("check.md5sum")
+            .succeeds()
+            .stdout_is("a: OK\n b: OK\ndd: OK\n")
+            .stderr_is("");
+    }
+}
+
+#[test]
+fn test_check_md5sum_mixed_format() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    #[cfg(not(windows))]
+    {
+        for f in &[" b", "*c", "dd", " "] {
+            at.write(f, &format!("{f}\n"));
+        }
+        at.write(
+            "check.md5sum",
+            "bf35d7536c785cf06730d5a40301eba2  b\n\
+             f5b61709718c1ecf8db1aea8547d4698 *c\n\
+             b064a020db8018f18ff5ae367d01b212 dd\n\
+             d784fa8b6d98d27699781bd9a7cf19f0  ",
+        );
+    }
+    #[cfg(windows)]
+    {
+        for f in &[" b", "dd"] {
+            at.write(f, &format!("{f}\n"));
+        }
+        at.write(
+            "check.md5sum",
+            "bf35d7536c785cf06730d5a40301eba2  b\n\
+             b064a020db8018f18ff5ae367d01b212 dd",
+        );
+    }
+    scene
+        .ccmd("md5sum")
+        .arg("--strict")
+        .arg("-c")
+        .arg("check.md5sum")
+        .fails()
+        .code_is(1);
+}
+
 #[test]
 fn test_invalid_arg() {
     new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
diff --git a/tests/by-util/test_head.rs b/tests/by-util/test_head.rs
index 364ed3b45..0e1eafc86 100644
--- a/tests/by-util/test_head.rs
+++ b/tests/by-util/test_head.rs
@@ -5,7 +5,7 @@
 
 // spell-checker:ignore (words) bogusfile emptyfile abcdefghijklmnopqrstuvwxyz abcdefghijklmnopqrstu
 
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 static INPUT: &str = "lorem_ipsum.txt";
 
@@ -189,6 +189,15 @@ fn test_no_such_file_or_directory() {
         .stderr_contains("cannot open 'no_such_file.toml' for reading: No such file or directory");
 }
 
+#[test]
+fn test_lines_leading_zeros() {
+    new_ucmd!()
+        .arg("--lines=010")
+        .pipe_in("\n\n\n\n\n\n\n\n\n\n\n\n")
+        .succeeds()
+        .stdout_is("\n\n\n\n\n\n\n\n\n\n");
+}
+
 /// Test that each non-existent files gets its own error message printed.
 #[test]
 fn test_multiple_nonexistent_files() {
diff --git a/tests/by-util/test_hostid.rs b/tests/by-util/test_hostid.rs
index 3ea818480..b42ec211d 100644
--- a/tests/by-util/test_hostid.rs
+++ b/tests/by-util/test_hostid.rs
@@ -1,6 +1,5 @@
-use crate::common::util::*;
-extern crate regex;
-use self::regex::Regex;
+use crate::common::util::TestScenario;
+use regex::Regex;
 
 #[test]
 fn test_normal() {
diff --git a/tests/by-util/test_hostname.rs b/tests/by-util/test_hostname.rs
index 474be8b3e..3c01a1197 100644
--- a/tests/by-util/test_hostname.rs
+++ b/tests/by-util/test_hostname.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_hostname() {
diff --git a/tests/by-util/test_id.rs b/tests/by-util/test_id.rs
index b7b36c58d..4174bdde6 100644
--- a/tests/by-util/test_id.rs
+++ b/tests/by-util/test_id.rs
@@ -5,7 +5,7 @@
 
 // spell-checker:ignore (ToDO) coreutil
 
-use crate::common::util::*;
+use crate::common::util::{check_coreutil_version, expected_result, is_ci, whoami, TestScenario};
 
 const VERSION_MIN_MULTIPLE_USERS: &str = "8.31"; // this feature was introduced in GNU's coreutils 8.31
 
diff --git a/tests/by-util/test_install.rs b/tests/by-util/test_install.rs
index f5c65b352..d76ce1e01 100644
--- a/tests/by-util/test_install.rs
+++ b/tests/by-util/test_install.rs
@@ -1,13 +1,13 @@
 // spell-checker:ignore (words) helloworld nodir objdump n'source
 
-use crate::common::util::*;
+use crate::common::util::{is_ci, TestScenario};
 use filetime::FileTime;
-use rust_users::*;
 use std::os::unix::fs::PermissionsExt;
 #[cfg(not(any(windows, target_os = "freebsd")))]
 use std::process::Command;
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use std::thread::sleep;
+use uucore::process::{getegid, geteuid};
 
 #[test]
 fn test_invalid_arg() {
@@ -28,8 +28,8 @@ fn test_install_basic() {
 
     assert!(at.file_exists(file1));
     assert!(at.file_exists(file2));
-    assert!(at.file_exists(&format!("{dir}/{file1}")));
-    assert!(at.file_exists(&format!("{dir}/{file2}")));
+    assert!(at.file_exists(format!("{dir}/{file1}")));
+    assert!(at.file_exists(format!("{dir}/{file2}")));
 }
 
 #[test]
@@ -76,7 +76,7 @@ fn test_install_unimplemented_arg() {
         .fails()
         .stderr_contains("Unimplemented");
 
-    assert!(!at.file_exists(&format!("{dir}/{file}")));
+    assert!(!at.file_exists(format!("{dir}/{file}")));
 }
 
 #[test]
@@ -314,7 +314,7 @@ fn test_install_target_new_file() {
         .no_stderr();
 
     assert!(at.file_exists(file));
-    assert!(at.file_exists(&format!("{dir}/{file}")));
+    assert!(at.file_exists(format!("{dir}/{file}")));
 }
 
 #[test]
@@ -322,7 +322,7 @@ fn test_install_target_new_file_with_group() {
     let (at, mut ucmd) = at_and_ucmd!();
     let file = "file";
     let dir = "target_dir";
-    let gid = get_effective_gid();
+    let gid = getegid();
 
     at.touch(file);
     at.mkdir(dir);
@@ -341,7 +341,7 @@ fn test_install_target_new_file_with_group() {
 
     result.success();
     assert!(at.file_exists(file));
-    assert!(at.file_exists(&format!("{dir}/{file}")));
+    assert!(at.file_exists(format!("{dir}/{file}")));
 }
 
 #[test]
@@ -349,7 +349,7 @@ fn test_install_target_new_file_with_owner() {
     let (at, mut ucmd) = at_and_ucmd!();
     let file = "file";
     let dir = "target_dir";
-    let uid = get_effective_uid();
+    let uid = geteuid();
 
     at.touch(file);
     at.mkdir(dir);
@@ -368,7 +368,7 @@ fn test_install_target_new_file_with_owner() {
 
     result.success();
     assert!(at.file_exists(file));
-    assert!(at.file_exists(&format!("{dir}/{file}")));
+    assert!(at.file_exists(format!("{dir}/{file}")));
 }
 
 #[test]
@@ -447,13 +447,13 @@ fn test_install_nested_paths_copy_file() {
 
     at.mkdir(dir1);
     at.mkdir(dir2);
-    at.touch(&format!("{dir1}/{file1}"));
+    at.touch(format!("{dir1}/{file1}"));
 
     ucmd.arg(format!("{dir1}/{file1}"))
         .arg(dir2)
         .succeeds()
         .no_stderr();
-    assert!(at.file_exists(&format!("{dir2}/{file1}")));
+    assert!(at.file_exists(format!("{dir2}/{file1}")));
 }
 
 #[test]
@@ -487,7 +487,7 @@ fn test_install_failing_omitting_directory() {
         .fails()
         .code_is(1)
         .stderr_contains("omitting directory");
-    assert!(at.file_exists(&format!("{dir3}/{file1}")));
+    assert!(at.file_exists(format!("{dir3}/{file1}")));
 
     // install also fails, when only one source param is given
     scene
@@ -785,7 +785,7 @@ fn test_install_creating_leading_dirs_with_single_source_and_target_dir() {
         .succeeds()
         .no_stderr();
 
-    assert!(at.file_exists(&format!("{target_dir}/{source1}")));
+    assert!(at.file_exists(format!("{target_dir}/{source1}")));
 }
 
 #[test]
@@ -863,8 +863,8 @@ fn test_install_dir() {
 
     assert!(at.file_exists(file1));
     assert!(at.file_exists(file2));
-    assert!(at.file_exists(&format!("{dir}/{file1}")));
-    assert!(at.file_exists(&format!("{dir}/{file2}")));
+    assert!(at.file_exists(format!("{dir}/{file1}")));
+    assert!(at.file_exists(format!("{dir}/{file2}")));
 }
 //
 // test backup functionality
@@ -888,7 +888,7 @@ fn test_install_backup_short_no_args_files() {
 
     assert!(at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(at.file_exists(&format!("{file_b}~")));
+    assert!(at.file_exists(format!("{file_b}~")));
 }
 
 #[test]
@@ -913,7 +913,7 @@ fn test_install_backup_short_no_args_file_to_dir() {
 
     assert!(at.file_exists(file));
     assert!(at.file_exists(&expect));
-    assert!(at.file_exists(&format!("{expect}~")));
+    assert!(at.file_exists(format!("{expect}~")));
 }
 
 // Long --backup option is tested separately as it requires a slightly different
@@ -938,7 +938,7 @@ fn test_install_backup_long_no_args_files() {
 
     assert!(at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(at.file_exists(&format!("{file_b}~")));
+    assert!(at.file_exists(format!("{file_b}~")));
 }
 
 #[test]
@@ -963,7 +963,7 @@ fn test_install_backup_long_no_args_file_to_dir() {
 
     assert!(at.file_exists(file));
     assert!(at.file_exists(&expect));
-    assert!(at.file_exists(&format!("{expect}~")));
+    assert!(at.file_exists(format!("{expect}~")));
 }
 
 #[test]
@@ -988,7 +988,7 @@ fn test_install_backup_short_custom_suffix() {
 
     assert!(at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(at.file_exists(&format!("{file_b}{suffix}")));
+    assert!(at.file_exists(format!("{file_b}{suffix}")));
 }
 
 #[test]
@@ -1013,7 +1013,7 @@ fn test_install_backup_short_custom_suffix_hyphen_value() {
 
     assert!(at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(at.file_exists(&format!("{file_b}{suffix}")));
+    assert!(at.file_exists(format!("{file_b}{suffix}")));
 }
 
 #[test]
@@ -1038,7 +1038,7 @@ fn test_install_backup_custom_suffix_via_env() {
 
     assert!(at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(at.file_exists(&format!("{file_b}{suffix}")));
+    assert!(at.file_exists(format!("{file_b}{suffix}")));
 }
 
 #[test]
@@ -1061,7 +1061,7 @@ fn test_install_backup_numbered_with_t() {
 
     assert!(at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(at.file_exists(&format!("{file_b}.~1~")));
+    assert!(at.file_exists(format!("{file_b}.~1~")));
 }
 
 #[test]
@@ -1084,7 +1084,7 @@ fn test_install_backup_numbered_with_numbered() {
 
     assert!(at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(at.file_exists(&format!("{file_b}.~1~")));
+    assert!(at.file_exists(format!("{file_b}.~1~")));
 }
 
 #[test]
@@ -1107,7 +1107,7 @@ fn test_install_backup_existing() {
 
     assert!(at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(at.file_exists(&format!("{file_b}~")));
+    assert!(at.file_exists(format!("{file_b}~")));
 }
 
 #[test]
@@ -1130,7 +1130,7 @@ fn test_install_backup_nil() {
 
     assert!(at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(at.file_exists(&format!("{file_b}~")));
+    assert!(at.file_exists(format!("{file_b}~")));
 }
 
 #[test]
@@ -1156,7 +1156,7 @@ fn test_install_backup_numbered_if_existing_backup_existing() {
     assert!(at.file_exists(file_a));
     assert!(at.file_exists(file_b));
     assert!(at.file_exists(file_b_backup));
-    assert!(at.file_exists(&format!("{file_b}.~2~")));
+    assert!(at.file_exists(format!("{file_b}.~2~")));
 }
 
 #[test]
@@ -1182,7 +1182,7 @@ fn test_install_backup_numbered_if_existing_backup_nil() {
     assert!(at.file_exists(file_a));
     assert!(at.file_exists(file_b));
     assert!(at.file_exists(file_b_backup));
-    assert!(at.file_exists(&format!("{file_b}.~2~")));
+    assert!(at.file_exists(format!("{file_b}.~2~")));
 }
 
 #[test]
@@ -1205,7 +1205,7 @@ fn test_install_backup_simple() {
 
     assert!(at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(at.file_exists(&format!("{file_b}~")));
+    assert!(at.file_exists(format!("{file_b}~")));
 }
 
 #[test]
@@ -1228,7 +1228,7 @@ fn test_install_backup_never() {
 
     assert!(at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(at.file_exists(&format!("{file_b}~")));
+    assert!(at.file_exists(format!("{file_b}~")));
 }
 
 #[test]
@@ -1251,7 +1251,7 @@ fn test_install_backup_none() {
 
     assert!(at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(!at.file_exists(&format!("{file_b}~")));
+    assert!(!at.file_exists(format!("{file_b}~")));
 }
 
 #[test]
@@ -1274,7 +1274,7 @@ fn test_install_backup_off() {
 
     assert!(at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(!at.file_exists(&format!("{file_b}~")));
+    assert!(!at.file_exists(format!("{file_b}~")));
 }
 
 #[test]
diff --git a/tests/by-util/test_join.rs b/tests/by-util/test_join.rs
index 9138e3d6b..f6fbe14c3 100644
--- a/tests/by-util/test_join.rs
+++ b/tests/by-util/test_join.rs
@@ -1,6 +1,6 @@
 // spell-checker:ignore (words) autoformat nocheck
 
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "netbsd"))]
 use std::fs::OpenOptions;
 #[cfg(unix)]
diff --git a/tests/by-util/test_kill.rs b/tests/by-util/test_kill.rs
index 43e281155..d36023298 100644
--- a/tests/by-util/test_kill.rs
+++ b/tests/by-util/test_kill.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 use regex::Regex;
 use std::os::unix::process::ExitStatusExt;
 use std::process::{Child, Command};
diff --git a/tests/by-util/test_link.rs b/tests/by-util/test_link.rs
index e52a31a33..3c068af93 100644
--- a/tests/by-util/test_link.rs
+++ b/tests/by-util/test_link.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
@@ -52,7 +52,7 @@ fn test_link_one_argument() {
     let file = "test_link_argument";
     ucmd.args(&[file])
         .fails()
-        .stderr_contains("requires 2 values");
+        .stderr_contains("2 values required");
 }
 
 #[test]
@@ -65,5 +65,5 @@ fn test_link_three_arguments() {
     ];
     ucmd.args(&arguments[..])
         .fails()
-        .stderr_contains("requires 2 values");
+        .stderr_contains("2 values required");
 }
diff --git a/tests/by-util/test_ln.rs b/tests/by-util/test_ln.rs
index bc51fc107..3be07c4d7 100644
--- a/tests/by-util/test_ln.rs
+++ b/tests/by-util/test_ln.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 use std::path::PathBuf;
 
 #[test]
@@ -116,7 +116,7 @@ fn test_symlink_interactive() {
         .ucmd()
         .args(&["-i", "-s", file, link])
         .pipe_in("n")
-        .succeeds()
+        .fails()
         .no_stdout();
 
     assert!(at.file_exists(file));
@@ -403,7 +403,7 @@ fn test_symlink_implicit_target_dir() {
     let file = &path.to_string_lossy();
 
     at.mkdir(dir);
-    at.touch(file);
+    at.touch(&path);
 
     ucmd.args(&["-s", file]).succeeds().no_stderr();
 
diff --git a/tests/by-util/test_logname.rs b/tests/by-util/test_logname.rs
index 3d2081641..b0cda1a9d 100644
--- a/tests/by-util/test_logname.rs
+++ b/tests/by-util/test_logname.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::{is_ci, TestScenario};
 use std::env;
 
 #[test]
diff --git a/tests/by-util/test_ls.rs b/tests/by-util/test_ls.rs
index 339c78c12..1266a7cab 100644
--- a/tests/by-util/test_ls.rs
+++ b/tests/by-util/test_ls.rs
@@ -1,16 +1,16 @@
-// spell-checker:ignore (words) READMECAREFULLY birthtime doesntexist oneline somebackup lrwx somefile somegroup somehiddenbackup somehiddenfile tabsize aaaaaaaa bbbb cccc dddddddd ncccc
+// spell-checker:ignore (words) READMECAREFULLY birthtime doesntexist oneline somebackup lrwx somefile somegroup somehiddenbackup somehiddenfile tabsize aaaaaaaa bbbb cccc dddddddd ncccc neee naaaaa nbcdef nfffff
 
-#[cfg(not(windows))]
-extern crate libc;
-extern crate regex;
-#[cfg(not(windows))]
-extern crate tempfile;
-
-use self::regex::Regex;
-use crate::common::util::*;
+#[cfg(any(unix, feature = "feat_selinux"))]
+use crate::common::util::expected_result;
+use crate::common::util::TestScenario;
 #[cfg(all(unix, feature = "chmod"))]
 use nix::unistd::{close, dup};
+use regex::Regex;
 use std::collections::HashMap;
+#[cfg(target_os = "linux")]
+use std::ffi::OsStr;
+#[cfg(target_os = "linux")]
+use std::os::unix::ffi::OsStrExt;
 #[cfg(all(unix, feature = "chmod"))]
 use std::os::unix::io::IntoRawFd;
 use std::path::Path;
@@ -609,10 +609,10 @@ fn test_ls_a() {
 fn test_ls_width() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
-    at.touch(&at.plus_as_string("test-width-1"));
-    at.touch(&at.plus_as_string("test-width-2"));
-    at.touch(&at.plus_as_string("test-width-3"));
-    at.touch(&at.plus_as_string("test-width-4"));
+    at.touch(at.plus_as_string("test-width-1"));
+    at.touch(at.plus_as_string("test-width-2"));
+    at.touch(at.plus_as_string("test-width-3"));
+    at.touch(at.plus_as_string("test-width-4"));
 
     for option in [
         "-w 100",
@@ -692,10 +692,10 @@ fn test_ls_width() {
 fn test_ls_columns() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
-    at.touch(&at.plus_as_string("test-columns-1"));
-    at.touch(&at.plus_as_string("test-columns-2"));
-    at.touch(&at.plus_as_string("test-columns-3"));
-    at.touch(&at.plus_as_string("test-columns-4"));
+    at.touch(at.plus_as_string("test-columns-1"));
+    at.touch(at.plus_as_string("test-columns-2"));
+    at.touch(at.plus_as_string("test-columns-3"));
+    at.touch(at.plus_as_string("test-columns-4"));
 
     // Columns is the default
     let result = scene.ucmd().succeeds();
@@ -753,10 +753,10 @@ fn test_ls_columns() {
 fn test_ls_across() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
-    at.touch(&at.plus_as_string("test-across-1"));
-    at.touch(&at.plus_as_string("test-across-2"));
-    at.touch(&at.plus_as_string("test-across-3"));
-    at.touch(&at.plus_as_string("test-across-4"));
+    at.touch(at.plus_as_string("test-across-1"));
+    at.touch(at.plus_as_string("test-across-2"));
+    at.touch(at.plus_as_string("test-across-3"));
+    at.touch(at.plus_as_string("test-across-4"));
 
     for option in ACROSS_ARGS {
         let result = scene.ucmd().arg(option).succeeds();
@@ -781,10 +781,10 @@ fn test_ls_across() {
 fn test_ls_commas() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
-    at.touch(&at.plus_as_string("test-commas-1"));
-    at.touch(&at.plus_as_string("test-commas-2"));
-    at.touch(&at.plus_as_string("test-commas-3"));
-    at.touch(&at.plus_as_string("test-commas-4"));
+    at.touch(at.plus_as_string("test-commas-1"));
+    at.touch(at.plus_as_string("test-commas-2"));
+    at.touch(at.plus_as_string("test-commas-3"));
+    at.touch(at.plus_as_string("test-commas-4"));
 
     for option in COMMA_ARGS {
         let result = scene.ucmd().arg(option).succeeds();
@@ -814,8 +814,8 @@ fn test_ls_zero() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
     at.mkdir("0-test-zero");
-    at.touch(&at.plus_as_string("2-test-zero"));
-    at.touch(&at.plus_as_string("3-test-zero"));
+    at.touch(at.plus_as_string("2-test-zero"));
+    at.touch(at.plus_as_string("3-test-zero"));
 
     let ignored_opts = [
         "--quoting-style=c",
@@ -870,7 +870,7 @@ fn test_ls_zero() {
 
     #[cfg(unix)]
     {
-        at.touch(&at.plus_as_string("1\ntest-zero"));
+        at.touch(at.plus_as_string("1\ntest-zero"));
 
         let ignored_opts = [
             "--quoting-style=c",
@@ -933,9 +933,9 @@ fn test_ls_zero() {
 fn test_ls_commas_trailing() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
-    at.touch(&at.plus_as_string("test-commas-trailing-2"));
+    at.touch(at.plus_as_string("test-commas-trailing-2"));
 
-    at.touch(&at.plus_as_string("test-commas-trailing-1"));
+    at.touch(at.plus_as_string("test-commas-trailing-1"));
     at.append(
         "test-commas-trailing-1",
         &(0..2000)
@@ -957,7 +957,7 @@ fn test_ls_commas_trailing() {
 fn test_ls_long() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
-    at.touch(&at.plus_as_string("test-long"));
+    at.touch(at.plus_as_string("test-long"));
 
     for arg in LONG_ARGS {
         let result = scene.ucmd().arg(arg).arg("test-long").succeeds();
@@ -975,7 +975,7 @@ fn test_ls_long_format() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
     at.mkdir(&at.plus_as_string("test-long-dir"));
-    at.touch(&at.plus_as_string("test-long-dir/test-long-file"));
+    at.touch(at.plus_as_string("test-long-dir/test-long-file"));
     at.mkdir(&at.plus_as_string("test-long-dir/test-long-dir"));
 
     for arg in LONG_ARGS {
@@ -1231,9 +1231,9 @@ fn test_ls_long_symlink_color() {
 fn test_ls_long_total_size() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
-    at.touch(&at.plus_as_string("test-long"));
+    at.touch(at.plus_as_string("test-long"));
     at.append("test-long", "1");
-    at.touch(&at.plus_as_string("test-long2"));
+    at.touch(at.plus_as_string("test-long2"));
     at.append("test-long2", "2");
 
     let expected_prints: HashMap<_, _> = if cfg!(unix) {
@@ -1243,7 +1243,7 @@ fn test_ls_long_total_size() {
             ("long_si", "total 8.2k"),
         ]
         .iter()
-        .cloned()
+        .copied()
         .collect()
     } else {
         [
@@ -1252,7 +1252,7 @@ fn test_ls_long_total_size() {
             ("long_si", "total 2"),
         ]
         .iter()
-        .cloned()
+        .copied()
         .collect()
     };
 
@@ -1275,12 +1275,12 @@ fn test_ls_long_total_size() {
 fn test_ls_long_formats() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
-    at.touch(&at.plus_as_string("test-long-formats"));
+    at.touch(at.plus_as_string("test-long-formats"));
 
     // Zero or one "." for indicating a file with security context
 
     // Regex for three names, so all of author, group and owner
-    let re_three = Regex::new(r"[xrw-]{9}\.? \d ([-0-9_a-z]+ ){3}0").unwrap();
+    let re_three = Regex::new(r"[xrw-]{9}\.? \d ([-0-9_a-z.A-Z]+ ){3}0").unwrap();
 
     #[cfg(unix)]
     let re_three_num = Regex::new(r"[xrw-]{9}\.? \d (\d+ ){3}0").unwrap();
@@ -1289,13 +1289,13 @@ fn test_ls_long_formats() {
     // - group and owner
     // - author and owner
     // - author and group
-    let re_two = Regex::new(r"[xrw-]{9}\.? \d ([-0-9_a-z]+ ){2}0").unwrap();
+    let re_two = Regex::new(r"[xrw-]{9}\.? \d ([-0-9_a-z.A-Z]+ ){2}0").unwrap();
 
     #[cfg(unix)]
     let re_two_num = Regex::new(r"[xrw-]{9}\.? \d (\d+ ){2}0").unwrap();
 
     // Regex for one name: author, group or owner
-    let re_one = Regex::new(r"[xrw-]{9}\.? \d [-0-9_a-z]+ 0").unwrap();
+    let re_one = Regex::new(r"[xrw-]{9}\.? \d [-0-9_a-z.A-Z]+ 0").unwrap();
 
     #[cfg(unix)]
     let re_one_num = Regex::new(r"[xrw-]{9}\.? \d \d+ 0").unwrap();
@@ -1422,8 +1422,8 @@ fn test_ls_long_formats() {
 fn test_ls_oneline() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
-    at.touch(&at.plus_as_string("test-oneline-1"));
-    at.touch(&at.plus_as_string("test-oneline-2"));
+    at.touch(at.plus_as_string("test-oneline-1"));
+    at.touch(at.plus_as_string("test-oneline-2"));
 
     // Bit of a weird situation: in the tests oneline and columns have the same output,
     // except on Windows.
@@ -1443,7 +1443,7 @@ fn test_ls_deref() {
     let path_regexp = r"(.*)test-long.link -> (.*)test-long(.*)";
     let re = Regex::new(path_regexp).unwrap();
 
-    at.touch(&at.plus_as_string("test-long"));
+    at.touch(at.plus_as_string("test-long"));
     at.symlink_file("test-long", "test-long.link");
     assert!(at.is_symlink("test-long.link"));
 
@@ -1564,6 +1564,28 @@ fn test_ls_sort_name() {
         .stdout_is(".a\n.b\na\nb\n");
 }
 
+#[test]
+fn test_ls_sort_width() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("aaaaa");
+    at.touch("bbb");
+    at.touch("cccc");
+    at.touch("eee");
+    at.touch("d");
+    at.touch("fffff");
+    at.touch("abc");
+    at.touch("zz");
+    at.touch("bcdef");
+
+    scene
+        .ucmd()
+        .arg("--sort=width")
+        .succeeds()
+        .stdout_is("d\nzz\nabc\nbbb\neee\ncccc\naaaaa\nbcdef\nfffff\n");
+}
+
 #[test]
 fn test_ls_order_size() {
     let scene = TestScenario::new(util_name!());
@@ -1644,88 +1666,103 @@ fn test_ls_styles() {
     at.touch("test");
 
     let re_full = Regex::new(
-        r"[a-z-]* \d* \w* \w* \d* \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d* (\+|\-)\d{4} test\n",
+        r"[a-z-]* \d* [\w.]* [\w.]* \d* \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d* (\+|\-)\d{4} test\n",
     )
     .unwrap();
     let re_long =
-        Regex::new(r"[a-z-]* \d* \w* \w* \d* \d{4}-\d{2}-\d{2} \d{2}:\d{2} test\n").unwrap();
-    let re_iso = Regex::new(r"[a-z-]* \d* \w* \w* \d* \d{2}-\d{2} \d{2}:\d{2} test\n").unwrap();
+        Regex::new(r"[a-z-]* \d* [\w.]* [\w.]* \d* \d{4}-\d{2}-\d{2} \d{2}:\d{2} test\n").unwrap();
+    let re_iso =
+        Regex::new(r"[a-z-]* \d* [\w.]* [\w.]* \d* \d{2}-\d{2} \d{2}:\d{2} test\n").unwrap();
     let re_locale =
-        Regex::new(r"[a-z-]* \d* \w* \w* \d* [A-Z][a-z]{2} ( |\d)\d \d{2}:\d{2} test\n").unwrap();
-    let re_custom_format = Regex::new(r"[a-z-]* \d* \w* \w* \d* \d{4}__\d{2} test\n").unwrap();
+        Regex::new(r"[a-z-]* \d* [\w.]* [\w.]* \d* [A-Z][a-z]{2} ( |\d)\d \d{2}:\d{2} test\n")
+            .unwrap();
+    let re_custom_format =
+        Regex::new(r"[a-z-]* \d* [\w.]* [\w.]* \d* \d{4}__\d{2} test\n").unwrap();
 
     //full-iso
-    let result = scene
+    scene
         .ucmd()
         .arg("-l")
         .arg("--time-style=full-iso")
-        .succeeds();
-    assert!(re_full.is_match(result.stdout_str()));
+        .succeeds()
+        .stdout_matches(&re_full);
     //long-iso
-    let result = scene
+    scene
         .ucmd()
         .arg("-l")
         .arg("--time-style=long-iso")
-        .succeeds();
-    assert!(re_long.is_match(result.stdout_str()));
+        .succeeds()
+        .stdout_matches(&re_long);
     //iso
-    let result = scene.ucmd().arg("-l").arg("--time-style=iso").succeeds();
-    assert!(re_iso.is_match(result.stdout_str()));
+    scene
+        .ucmd()
+        .arg("-l")
+        .arg("--time-style=iso")
+        .succeeds()
+        .stdout_matches(&re_iso);
     //locale
-    let result = scene.ucmd().arg("-l").arg("--time-style=locale").succeeds();
-    assert!(re_locale.is_match(result.stdout_str()));
+    scene
+        .ucmd()
+        .arg("-l")
+        .arg("--time-style=locale")
+        .succeeds()
+        .stdout_matches(&re_locale);
 
     //+FORMAT
-    let result = scene
+    scene
         .ucmd()
         .arg("-l")
         .arg("--time-style=+%Y__%M")
-        .succeeds();
-    assert!(re_custom_format.is_match(result.stdout_str()));
+        .succeeds()
+        .stdout_matches(&re_custom_format);
 
     // Also fails due to not having full clap support for time_styles
     scene.ucmd().arg("-l").arg("-time-style=invalid").fails();
 
     //Overwrite options tests
-    let result = scene
+    scene
         .ucmd()
         .arg("-l")
         .arg("--time-style=long-iso")
         .arg("--time-style=iso")
-        .succeeds();
-    assert!(re_iso.is_match(result.stdout_str()));
-    let result = scene
+        .succeeds()
+        .stdout_matches(&re_iso);
+    scene
         .ucmd()
         .arg("--time-style=iso")
         .arg("--full-time")
-        .succeeds();
-    assert!(re_full.is_match(result.stdout_str()));
-    let result = scene
+        .succeeds()
+        .stdout_matches(&re_full);
+    scene
         .ucmd()
         .arg("--full-time")
         .arg("--time-style=iso")
-        .succeeds();
-    assert!(re_iso.is_match(result.stdout_str()));
+        .succeeds()
+        .stdout_matches(&re_iso);
 
-    let result = scene
+    scene
         .ucmd()
         .arg("--full-time")
         .arg("--time-style=iso")
         .arg("--full-time")
-        .succeeds();
-    assert!(re_full.is_match(result.stdout_str()));
+        .succeeds()
+        .stdout_matches(&re_full);
 
-    let result = scene
+    scene
         .ucmd()
         .arg("--full-time")
         .arg("-x")
         .arg("-l")
-        .succeeds();
-    assert!(re_full.is_match(result.stdout_str()));
+        .succeeds()
+        .stdout_matches(&re_full);
 
     at.touch("test2");
-    let result = scene.ucmd().arg("--full-time").arg("-x").succeeds();
-    assert_eq!(result.stdout_str(), "test  test2\n");
+    scene
+        .ucmd()
+        .arg("--full-time")
+        .arg("-x")
+        .succeeds()
+        .stdout_is("test  test2\n");
 }
 
 #[test]
@@ -1780,9 +1817,15 @@ fn test_ls_order_time() {
         at.open("test-4").metadata().unwrap().accessed().unwrap();
 
         // It seems to be dependent on the platform whether the access time is actually set
-        #[cfg(all(unix, not(target_os = "android")))]
-        result.stdout_only("test-3\ntest-4\ntest-2\ntest-1\n");
-        #[cfg(any(windows, target_os = "android"))]
+        #[cfg(unix)]
+        {
+            let expected = unwrap_or_return!(expected_result(&scene, &["-t", arg]));
+            at.open("test-3").metadata().unwrap().accessed().unwrap();
+            at.open("test-4").metadata().unwrap().accessed().unwrap();
+
+            result.stdout_only(expected.stdout_str());
+        }
+        #[cfg(windows)]
         result.stdout_only("test-4\ntest-3\ntest-2\ntest-1\n");
     }
 
@@ -1808,8 +1851,8 @@ fn test_ls_files_dirs() {
     at.mkdir("a/b");
     at.mkdir("a/b/c");
     at.mkdir("z");
-    at.touch(&at.plus_as_string("a/a"));
-    at.touch(&at.plus_as_string("a/b/b"));
+    at.touch(at.plus_as_string("a/a"));
+    at.touch(at.plus_as_string("a/b/b"));
 
     scene.ucmd().arg("a").succeeds();
     scene.ucmd().arg("a/a").succeeds();
@@ -1840,8 +1883,8 @@ fn test_ls_recursive() {
     at.mkdir("a/b");
     at.mkdir("a/b/c");
     at.mkdir("z");
-    at.touch(&at.plus_as_string("a/a"));
-    at.touch(&at.plus_as_string("a/b/b"));
+    at.touch(at.plus_as_string("a/a"));
+    at.touch(at.plus_as_string("a/b/b"));
 
     scene.ucmd().arg("a").succeeds();
     scene.ucmd().arg("a/a").succeeds();
@@ -1880,7 +1923,7 @@ fn test_ls_color() {
         .join("nested_file")
         .to_string_lossy()
         .to_string();
-    at.touch(&nested_file);
+    at.touch(nested_file);
     at.touch("test-color");
 
     let a_with_colors = "\x1b[1;34ma\x1b[0m";
@@ -1985,7 +2028,7 @@ fn test_ls_indicator_style() {
     at.mkdir("directory");
     assert!(at.dir_exists("directory"));
 
-    at.touch(&at.plus_as_string("link-src"));
+    at.touch(at.plus_as_string("link-src"));
     at.symlink_file("link-src", "link-dest.link");
     assert!(at.is_symlink("link-dest.link"));
 
@@ -2077,7 +2120,7 @@ fn test_ls_indicator_style() {
     at.mkdir("directory");
     assert!(at.dir_exists("directory"));
 
-    at.touch(&at.plus_as_string("link-src"));
+    at.touch(at.plus_as_string("link-src"));
     at.symlink_file("link-src", "link-dest.link");
     assert!(at.is_symlink("link-dest.link"));
 
@@ -3376,3 +3419,54 @@ fn test_tabsize_formatting() {
         .succeeds()
         .stdout_is("aaaaaaaa bbbb\ncccc     dddddddd");
 }
+
+#[cfg(any(
+    target_os = "linux",
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "freebsd",
+    target_os = "dragonfly",
+    target_os = "netbsd",
+    target_os = "openbsd",
+    target_os = "illumos",
+    target_os = "solaris"
+))]
+#[test]
+fn test_device_number() {
+    use std::fs::{metadata, read_dir};
+    use std::os::unix::fs::{FileTypeExt, MetadataExt};
+    use uucore::libc::{dev_t, major, minor};
+
+    let dev_dir = read_dir("/dev").unwrap();
+    // let's use the first device for test
+    let blk_dev = dev_dir
+        .map(|res_entry| res_entry.unwrap())
+        .find(|entry| {
+            entry.file_type().unwrap().is_block_device()
+                || entry.file_type().unwrap().is_char_device()
+        })
+        .expect("Expect a block/char device");
+    let blk_dev_path = blk_dev.path();
+    let blk_dev_meta = metadata(blk_dev_path.as_path()).unwrap();
+    let blk_dev_number = blk_dev_meta.rdev() as dev_t;
+    let (major, minor) = unsafe { (major(blk_dev_number), minor(blk_dev_number)) };
+    let major_minor_str = format!("{}, {}", major, minor);
+
+    let scene = TestScenario::new(util_name!());
+    scene
+        .ucmd()
+        .arg("-l")
+        .arg(blk_dev_path.to_str().expect("should be UTF-8 encoded"))
+        .succeeds()
+        .stdout_contains(major_minor_str);
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_invalid_utf8() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let filename = OsStr::from_bytes(b"-\xE0-foo");
+    at.touch(filename);
+    ucmd.succeeds();
+}
diff --git a/tests/by-util/test_mkdir.rs b/tests/by-util/test_mkdir.rs
index 59546b847..11a860d5a 100644
--- a/tests/by-util/test_mkdir.rs
+++ b/tests/by-util/test_mkdir.rs
@@ -1,40 +1,35 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
+#[cfg(not(windows))]
+use libc::{mode_t, umask};
+use once_cell::sync::Lazy;
 #[cfg(not(windows))]
 use std::os::unix::fs::PermissionsExt;
-#[cfg(not(windows))]
-extern crate libc;
-#[cfg(not(windows))]
-use self::libc::{mode_t, umask};
+use std::sync::Mutex;
 
-static TEST_DIR1: &str = "mkdir_test1";
-static TEST_DIR2: &str = "mkdir_test2";
-static TEST_DIR3: &str = "mkdir_test3";
-static TEST_DIR4: &str = "mkdir_test4/mkdir_test4_1";
-static TEST_DIR5: &str = "mkdir_test5/mkdir_test5_1";
-static TEST_DIR6: &str = "mkdir_test6";
-static TEST_FILE7: &str = "mkdir_test7";
-static TEST_DIR8: &str = "mkdir_test8/mkdir_test8_1/mkdir_test8_2";
-static TEST_DIR9: &str = "mkdir_test9/../mkdir_test9_1/../mkdir_test9_2";
-static TEST_DIR10: &str = "mkdir_test10/.";
-static TEST_DIR11: &str = "mkdir_test11/..";
-#[cfg(not(windows))]
-static TEST_DIR12: &str = "mkdir_test12";
+// tests in `test_mkdir.rs` cannot run in parallel since some tests alter the umask. This may cause
+// other tests to run under a wrong set of permissions
+//
+// when writing a test case, acquire this mutex before proceeding with the main logic of the test
+static TEST_MUTEX: Lazy<Mutex<()>> = Lazy::new(|| Mutex::new(()));
 
 #[test]
 fn test_invalid_arg() {
+    let _guard = TEST_MUTEX.lock();
     new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
 }
 
 #[test]
 fn test_mkdir_mkdir() {
-    new_ucmd!().arg(TEST_DIR1).succeeds();
+    let _guard = TEST_MUTEX.lock();
+    new_ucmd!().arg("test_dir").succeeds();
 }
 
 #[test]
 fn test_mkdir_verbose() {
-    let expected = "mkdir: created directory 'mkdir_test1'\n";
+    let _guard = TEST_MUTEX.lock();
+    let expected = "mkdir: created directory 'test_dir'\n";
     new_ucmd!()
-        .arg(TEST_DIR1)
+        .arg("test_dir")
         .arg("-v")
         .run()
         .stdout_is(expected);
@@ -42,124 +37,223 @@ fn test_mkdir_verbose() {
 
 #[test]
 fn test_mkdir_dup_dir() {
+    let _guard = TEST_MUTEX.lock();
+
     let scene = TestScenario::new(util_name!());
-    scene.ucmd().arg(TEST_DIR2).succeeds();
-    scene.ucmd().arg(TEST_DIR2).fails();
+    let test_dir = "test_dir";
+
+    scene.ucmd().arg(test_dir).succeeds();
+    scene.ucmd().arg(test_dir).fails();
 }
 
 #[test]
 fn test_mkdir_mode() {
-    new_ucmd!().arg("-m").arg("755").arg(TEST_DIR3).succeeds();
+    let _guard = TEST_MUTEX.lock();
+    new_ucmd!().arg("-m").arg("755").arg("test_dir").succeeds();
 }
 
 #[test]
 fn test_mkdir_parent() {
+    let _guard = TEST_MUTEX.lock();
     let scene = TestScenario::new(util_name!());
-    scene.ucmd().arg("-p").arg(TEST_DIR4).succeeds();
-    scene.ucmd().arg("-p").arg(TEST_DIR4).succeeds();
-    scene.ucmd().arg("--parent").arg(TEST_DIR4).succeeds();
-    scene.ucmd().arg("--parents").arg(TEST_DIR4).succeeds();
+    let test_dir = "parent_dir/child_dir";
+
+    scene.ucmd().arg("-p").arg(test_dir).succeeds();
+    scene.ucmd().arg("-p").arg(test_dir).succeeds();
+    scene.ucmd().arg("--parent").arg(test_dir).succeeds();
+    scene.ucmd().arg("--parents").arg(test_dir).succeeds();
 }
 
 #[test]
 fn test_mkdir_no_parent() {
-    new_ucmd!().arg(TEST_DIR5).fails();
+    let _guard = TEST_MUTEX.lock();
+    new_ucmd!().arg("parent_dir/child_dir").fails();
 }
 
 #[test]
 fn test_mkdir_dup_dir_parent() {
+    let _guard = TEST_MUTEX.lock();
+
     let scene = TestScenario::new(util_name!());
-    scene.ucmd().arg(TEST_DIR6).succeeds();
-    scene.ucmd().arg("-p").arg(TEST_DIR6).succeeds();
+    let test_dir = "test_dir";
+
+    scene.ucmd().arg(test_dir).succeeds();
+    scene.ucmd().arg("-p").arg(test_dir).succeeds();
+}
+
+#[cfg(not(windows))]
+#[test]
+fn test_mkdir_parent_mode() {
+    let _guard = TEST_MUTEX.lock();
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let default_umask: mode_t = 0o160;
+    let original_umask = unsafe { umask(default_umask) };
+
+    ucmd.arg("-p").arg("a/b").succeeds().no_stderr().no_stdout();
+
+    assert!(at.dir_exists("a"));
+    // parents created by -p have permissions set to "=rwx,u+wx"
+    assert_eq!(
+        at.metadata("a").permissions().mode() as mode_t,
+        ((!default_umask & 0o777) | 0o300) + 0o40000
+    );
+    assert!(at.dir_exists("a/b"));
+    // sub directory's permission is determined only by the umask
+    assert_eq!(
+        at.metadata("a/b").permissions().mode() as mode_t,
+        (!default_umask & 0o777) + 0o40000
+    );
+
+    unsafe {
+        umask(original_umask);
+    }
+}
+
+#[cfg(not(windows))]
+#[test]
+fn test_mkdir_parent_mode_check_existing_parent() {
+    let _guard = TEST_MUTEX.lock();
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.mkdir("a");
+
+    let default_umask: mode_t = 0o160;
+    let original_umask = unsafe { umask(default_umask) };
+
+    ucmd.arg("-p")
+        .arg("a/b/c")
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+
+    assert!(at.dir_exists("a"));
+    // parent dirs that already exist do not get their permissions modified
+    assert_eq!(
+        at.metadata("a").permissions().mode() as mode_t,
+        (!original_umask & 0o777) + 0o40000
+    );
+    assert!(at.dir_exists("a/b"));
+    assert_eq!(
+        at.metadata("a/b").permissions().mode() as mode_t,
+        ((!default_umask & 0o777) | 0o300) + 0o40000
+    );
+    assert!(at.dir_exists("a/b/c"));
+    assert_eq!(
+        at.metadata("a/b/c").permissions().mode() as mode_t,
+        (!default_umask & 0o777) + 0o40000
+    );
+
+    unsafe {
+        umask(original_umask);
+    }
 }
 
 #[test]
 fn test_mkdir_dup_file() {
+    let _guard = TEST_MUTEX.lock();
+
     let scene = TestScenario::new(util_name!());
-    scene.fixtures.touch(TEST_FILE7);
-    scene.ucmd().arg(TEST_FILE7).fails();
+    let test_file = "test_file.txt";
+
+    scene.fixtures.touch(test_file);
+
+    scene.ucmd().arg(test_file).fails();
 
     // mkdir should fail for a file even if -p is specified.
-    scene.ucmd().arg("-p").arg(TEST_FILE7).fails();
+    scene.ucmd().arg("-p").arg(test_file).fails();
 }
 
 #[test]
 #[cfg(not(windows))]
 fn test_symbolic_mode() {
+    let _guard = TEST_MUTEX.lock();
     let (at, mut ucmd) = at_and_ucmd!();
+    let test_dir = "test_dir";
 
-    ucmd.arg("-m").arg("a=rwx").arg(TEST_DIR1).succeeds();
-    let perms = at.metadata(TEST_DIR1).permissions().mode();
+    ucmd.arg("-m").arg("a=rwx").arg(test_dir).succeeds();
+    let perms = at.metadata(test_dir).permissions().mode();
     assert_eq!(perms, 0o40777);
 }
 
 #[test]
 #[cfg(not(windows))]
 fn test_symbolic_alteration() {
+    let _guard = TEST_MUTEX.lock();
     let (at, mut ucmd) = at_and_ucmd!();
+    let test_dir = "test_dir";
 
-    ucmd.arg("-m").arg("-w").arg(TEST_DIR1).succeeds();
-    let perms = at.metadata(TEST_DIR1).permissions().mode();
-    assert_eq!(perms, 0o40555);
+    let default_umask = 0o022;
+    let original_umask = unsafe { umask(default_umask) };
+
+    ucmd.arg("-m").arg("-w").arg(test_dir).succeeds();
+    let perms = at.metadata(test_dir).permissions().mode();
+    assert_eq!(perms, 0o40577);
+
+    unsafe { umask(original_umask) };
 }
 
 #[test]
 #[cfg(not(windows))]
 fn test_multi_symbolic() {
+    let _guard = TEST_MUTEX.lock();
     let (at, mut ucmd) = at_and_ucmd!();
+    let test_dir = "test_dir";
 
-    ucmd.arg("-m")
-        .arg("u=rwx,g=rx,o=")
-        .arg(TEST_DIR1)
-        .succeeds();
-    let perms = at.metadata(TEST_DIR1).permissions().mode();
+    ucmd.arg("-m").arg("u=rwx,g=rx,o=").arg(test_dir).succeeds();
+    let perms = at.metadata(test_dir).permissions().mode();
     assert_eq!(perms, 0o40750);
 }
 
 #[test]
 fn test_recursive_reporting() {
+    let _guard = TEST_MUTEX.lock();
+    let test_dir = "test_dir/test_dir_a/test_dir_b";
+
     new_ucmd!()
         .arg("-p")
         .arg("-v")
-        .arg(TEST_DIR8)
+        .arg(test_dir)
         .succeeds()
-        .stdout_contains("created directory 'mkdir_test8'")
-        .stdout_contains("created directory 'mkdir_test8/mkdir_test8_1'")
-        .stdout_contains("created directory 'mkdir_test8/mkdir_test8_1/mkdir_test8_2'");
-    new_ucmd!().arg("-v").arg(TEST_DIR8).fails().no_stdout();
+        .stdout_contains("created directory 'test_dir'")
+        .stdout_contains("created directory 'test_dir/test_dir_a'")
+        .stdout_contains("created directory 'test_dir/test_dir_a/test_dir_b'");
+    new_ucmd!().arg("-v").arg(test_dir).fails().no_stdout();
+
+    let test_dir = "test_dir/../test_dir_a/../test_dir_b";
+
     new_ucmd!()
         .arg("-p")
         .arg("-v")
-        .arg(TEST_DIR9)
+        .arg(test_dir)
         .succeeds()
-        .stdout_contains("created directory 'mkdir_test9'")
-        .stdout_contains("created directory 'mkdir_test9/../mkdir_test9_1'")
-        .stdout_contains("created directory 'mkdir_test9/../mkdir_test9_1/../mkdir_test9_2'");
+        .stdout_contains("created directory 'test_dir'")
+        .stdout_contains("created directory 'test_dir/../test_dir_a'")
+        .stdout_contains("created directory 'test_dir/../test_dir_a/../test_dir_b'");
 }
 
 #[test]
 fn test_mkdir_trailing_dot() {
-    let scene2 = TestScenario::new("ls");
-    new_ucmd!()
-        .arg("-p")
-        .arg("-v")
-        .arg("mkdir_test10-2")
-        .succeeds();
+    let _guard = TEST_MUTEX.lock();
+
+    new_ucmd!().arg("-p").arg("-v").arg("test_dir").succeeds();
 
     new_ucmd!()
         .arg("-p")
         .arg("-v")
-        .arg(TEST_DIR10)
+        .arg("test_dir_a/.")
         .succeeds()
-        .stdout_contains("created directory 'mkdir_test10'");
+        .stdout_contains("created directory 'test_dir_a'");
 
     new_ucmd!()
         .arg("-p")
         .arg("-v")
-        .arg(TEST_DIR11)
+        .arg("test_dir_b/..")
         .succeeds()
-        .stdout_contains("created directory 'mkdir_test11'");
-    let result = scene2.ucmd().arg("-al").run();
+        .stdout_contains("created directory 'test_dir_b'");
+
+    let scene = TestScenario::new("ls");
+    let result = scene.ucmd().arg("-al").run();
     println!("ls dest {}", result.stdout_str());
 }
 
@@ -167,12 +261,15 @@ fn test_mkdir_trailing_dot() {
 #[cfg(not(windows))]
 fn test_umask_compliance() {
     fn test_single_case(umask_set: mode_t) {
+        let _guard = TEST_MUTEX.lock();
+
+        let test_dir = "test_dir";
         let (at, mut ucmd) = at_and_ucmd!();
 
         let original_umask = unsafe { umask(umask_set) };
 
-        ucmd.arg(TEST_DIR12).succeeds();
-        let perms = at.metadata(TEST_DIR12).permissions().mode() as mode_t;
+        ucmd.arg(test_dir).succeeds();
+        let perms = at.metadata(test_dir).permissions().mode() as mode_t;
 
         assert_eq!(perms, (!umask_set & 0o0777) + 0o40000); // before compare, add the set GUID, UID bits
         unsafe {
diff --git a/tests/by-util/test_mkfifo.rs b/tests/by-util/test_mkfifo.rs
index f8b168195..d4ebab640 100644
--- a/tests/by-util/test_mkfifo.rs
+++ b/tests/by-util/test_mkfifo.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
diff --git a/tests/by-util/test_mknod.rs b/tests/by-util/test_mknod.rs
index c6d15e204..deea8bb4e 100644
--- a/tests/by-util/test_mknod.rs
+++ b/tests/by-util/test_mknod.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 #[cfg(not(windows))]
@@ -92,14 +92,14 @@ fn test_mknod_character_device_requires_major_and_minor() {
         .arg("1")
         .arg("c")
         .fails()
-        .stderr_contains("Invalid value 'c'");
+        .stderr_contains("invalid value 'c'");
     new_ucmd!()
         .arg("test_file")
         .arg("c")
         .arg("c")
         .arg("1")
         .fails()
-        .stderr_contains("Invalid value 'c'");
+        .stderr_contains("invalid value 'c'");
 }
 
 #[test]
@@ -109,7 +109,7 @@ fn test_mknod_invalid_arg() {
         .arg("--foo")
         .fails()
         .no_stdout()
-        .stderr_contains("Found argument '--foo' which wasn't expected");
+        .stderr_contains("unexpected argument '--foo' found");
 }
 
 #[test]
diff --git a/tests/by-util/test_mktemp.rs b/tests/by-util/test_mktemp.rs
index 109963edf..6bcb37f45 100644
--- a/tests/by-util/test_mktemp.rs
+++ b/tests/by-util/test_mktemp.rs
@@ -1,6 +1,6 @@
 // spell-checker:ignore (words) gpghome
 
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 use uucore::display::Quotable;
 
@@ -426,7 +426,6 @@ fn test_mktemp_tmpdir_one_arg() {
 
     let result = scene
         .ucmd()
-        .keep_env()
         .arg("--tmpdir")
         .arg("apt-key-gpghome.XXXXXXXXXX")
         .succeeds();
@@ -440,7 +439,6 @@ fn test_mktemp_directory_tmpdir() {
 
     let result = scene
         .ucmd()
-        .keep_env()
         .arg("--directory")
         .arg("--tmpdir")
         .arg("apt-key-gpghome.XXXXXXXXXX")
@@ -571,6 +569,32 @@ fn test_template_path_separator() {
         ));
 }
 
+/// Test that a prefix with a point is valid.
+#[test]
+fn test_prefix_template_separator() {
+    new_ucmd!().args(&["-p", ".", "-t", "a.XXXX"]).succeeds();
+}
+
+#[test]
+fn test_prefix_template_with_path_separator() {
+    #[cfg(not(windows))]
+    new_ucmd!()
+        .args(&["-t", "a/XXX"])
+        .fails()
+        .stderr_only(format!(
+            "mktemp: invalid template, {}, contains directory separator\n",
+            "a/XXX".quote()
+        ));
+    #[cfg(windows)]
+    new_ucmd!()
+        .args(&["-t", r"a\XXX"])
+        .fails()
+        .stderr_only(format!(
+            "mktemp: invalid template, {}, contains directory separator\n",
+            r"a\XXX".quote()
+        ));
+}
+
 /// Test that a suffix with a path separator is invalid.
 #[test]
 fn test_suffix_path_separator() {
@@ -704,16 +728,18 @@ fn test_tmpdir_env_var() {
     assert_suffix_matches_template!("tmp.XXXXXXXXXX", filename);
     assert!(at.file_exists(filename));
 
-    // FIXME This is not working because --tmpdir is configured to
-    // require a value.
-    //
-    // // `TMPDIR=. mktemp --tmpdir`
-    // let (at, mut ucmd) = at_and_ucmd!();
-    // let result = ucmd.env(TMPDIR, ".").arg("--tmpdir").succeeds();
-    // let filename = result.no_stderr().stdout_str().trim_end();
-    // let template = format!(".{}tmp.XXXXXXXXXX", MAIN_SEPARATOR);
-    // assert_matches_template!(&template, filename);
-    // assert!(at.file_exists(filename));
+    // `TMPDIR=. mktemp --tmpdir`
+    let (at, mut ucmd) = at_and_ucmd!();
+    let result = ucmd.env(TMPDIR, ".").arg("--tmpdir").succeeds();
+    let filename = result.no_stderr().stdout_str().trim_end();
+    #[cfg(not(windows))]
+    {
+        let template = format!(".{MAIN_SEPARATOR}tmp.XXXXXXXXXX");
+        assert_matches_template!(&template, filename);
+    }
+    #[cfg(windows)]
+    assert_suffix_matches_template!("tmp.XXXXXXXXXX", filename);
+    assert!(at.file_exists(filename));
 
     // `TMPDIR=. mktemp --tmpdir XXX`
     let (at, mut ucmd) = at_and_ucmd!();
@@ -825,6 +851,53 @@ fn test_nonexistent_dir_prefix() {
 
 #[test]
 fn test_default_missing_value() {
-    let scene = TestScenario::new(util_name!());
-    scene.ucmd().arg("-d").arg("--tmpdir").succeeds();
+    new_ucmd!().arg("-d").arg("--tmpdir").succeeds();
+}
+
+#[test]
+fn test_default_issue_4821_t_tmpdir() {
+    let scene = TestScenario::new(util_name!());
+    let pathname = scene.fixtures.as_string();
+    let result = scene
+        .ucmd()
+        .env(TMPDIR, &pathname)
+        .arg("-t")
+        .arg("foo.XXXX")
+        .succeeds();
+    let stdout = result.stdout_str();
+    println!("stdout = {stdout}");
+    assert!(stdout.contains(&pathname));
+}
+
+#[test]
+fn test_default_issue_4821_t_tmpdir_p() {
+    let scene = TestScenario::new(util_name!());
+    let pathname = scene.fixtures.as_string();
+    let result = scene
+        .ucmd()
+        .arg("-t")
+        .arg("-p")
+        .arg(&pathname)
+        .arg("foo.XXXX")
+        .succeeds();
+    let stdout = result.stdout_str();
+    println!("stdout = {stdout}");
+    assert!(stdout.contains(&pathname));
+}
+
+#[test]
+fn test_t_ensure_tmpdir_has_higher_priority_than_p() {
+    let scene = TestScenario::new(util_name!());
+    let pathname = scene.fixtures.as_string();
+    let result = scene
+        .ucmd()
+        .env(TMPDIR, &pathname)
+        .arg("-t")
+        .arg("-p")
+        .arg("should_not_attempt_to_write_in_this_nonexisting_dir")
+        .arg("foo.XXXX")
+        .succeeds();
+    let stdout = result.stdout_str();
+    println!("stdout = {stdout}");
+    assert!(stdout.contains(&pathname));
 }
diff --git a/tests/by-util/test_more.rs b/tests/by-util/test_more.rs
index b3a1522f6..95a4818b5 100644
--- a/tests/by-util/test_more.rs
+++ b/tests/by-util/test_more.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 use is_terminal::IsTerminal;
 
 #[test]
@@ -6,7 +6,34 @@ fn test_more_no_arg() {
     // Reading from stdin is now supported, so this must succeed
     if std::io::stdout().is_terminal() {
         new_ucmd!().succeeds();
-    } else {
+    }
+}
+
+#[test]
+fn test_valid_arg() {
+    if std::io::stdout().is_terminal() {
+        new_ucmd!().arg("-c").succeeds();
+        new_ucmd!().arg("--print-over").succeeds();
+
+        new_ucmd!().arg("-p").succeeds();
+        new_ucmd!().arg("--clean-print").succeeds();
+
+        new_ucmd!().arg("-s").succeeds();
+        new_ucmd!().arg("--squeeze").succeeds();
+
+        new_ucmd!().arg("-n").arg("10").succeeds();
+        new_ucmd!().arg("--lines").arg("0").succeeds();
+        new_ucmd!().arg("--number").arg("0").succeeds();
+    }
+}
+
+#[test]
+fn test_invalid_arg() {
+    if std::io::stdout().is_terminal() {
+        new_ucmd!().arg("--invalid").fails();
+
+        new_ucmd!().arg("--lines").arg("-10").fails();
+        new_ucmd!().arg("--number").arg("-10").fails();
     }
 }
 
@@ -20,6 +47,23 @@ fn test_more_dir_arg() {
             .arg(".")
             .fails()
             .usage_error("'.' is a directory.");
-    } else {
+    }
+}
+
+#[test]
+#[cfg(target_family = "unix")]
+fn test_more_invalid_file_perms() {
+    use std::fs::{set_permissions, Permissions};
+    use std::os::unix::fs::PermissionsExt;
+
+    if std::io::stdout().is_terminal() {
+        let (at, mut ucmd) = at_and_ucmd!();
+        let permissions = Permissions::from_mode(0o244);
+        at.make_file("invalid-perms.txt");
+        set_permissions(at.plus("invalid-perms.txt"), permissions).unwrap();
+        ucmd.arg("invalid-perms.txt")
+            .fails()
+            .code_is(1)
+            .stderr_contains("permission denied");
     }
 }
diff --git a/tests/by-util/test_mv.rs b/tests/by-util/test_mv.rs
index 93693279b..cef95d195 100644
--- a/tests/by-util/test_mv.rs
+++ b/tests/by-util/test_mv.rs
@@ -1,8 +1,7 @@
-extern crate filetime;
-extern crate time;
-
-use self::filetime::*;
-use crate::common::util::*;
+use crate::common::util::TestScenario;
+use filetime::FileTime;
+use std::thread::sleep;
+use std::time::Duration;
 
 #[test]
 fn test_invalid_arg() {
@@ -55,7 +54,64 @@ fn test_mv_move_file_into_dir() {
 
     ucmd.arg(file).arg(dir).succeeds().no_stderr();
 
-    assert!(at.file_exists(&format!("{dir}/{file}")));
+    assert!(at.file_exists(format!("{dir}/{file}")));
+}
+
+#[test]
+fn test_mv_move_file_into_dir_with_target_arg() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let dir = "test_mv_move_file_into_dir_with_target_arg_dir";
+    let file = "test_mv_move_file_into_dir_with_target_arg_file";
+
+    at.mkdir(dir);
+    at.touch(file);
+
+    ucmd.arg("--target")
+        .arg(dir)
+        .arg(file)
+        .succeeds()
+        .no_stderr();
+
+    assert!(at.file_exists(format!("{dir}/{file}")));
+}
+
+#[test]
+fn test_mv_move_file_into_file_with_target_arg() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file1 = "test_mv_move_file_into_file_with_target_arg_file1";
+    let file2 = "test_mv_move_file_into_file_with_target_arg_file2";
+
+    at.touch(file1);
+    at.touch(file2);
+
+    ucmd.arg("--target")
+        .arg(file1)
+        .arg(file2)
+        .fails()
+        .stderr_is(format!("mv: target directory '{file1}': Not a directory\n"));
+
+    assert!(at.file_exists(file1));
+}
+
+#[test]
+fn test_mv_move_multiple_files_into_file() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file1 = "test_mv_move_multiple_files_into_file1";
+    let file2 = "test_mv_move_multiple_files_into_file2";
+    let file3 = "test_mv_move_multiple_files_into_file3";
+
+    at.touch(file1);
+    at.touch(file2);
+    at.touch(file3);
+
+    ucmd.arg(file1)
+        .arg(file2)
+        .arg(file3)
+        .fails()
+        .stderr_is(format!("mv: target '{file3}': Not a directory\n"));
+
+    assert!(at.file_exists(file1));
+    assert!(at.file_exists(file2));
 }
 
 #[test]
@@ -67,17 +123,17 @@ fn test_mv_move_file_between_dirs() {
 
     at.mkdir(dir1);
     at.mkdir(dir2);
-    at.touch(&format!("{dir1}/{file}"));
+    at.touch(format!("{dir1}/{file}"));
 
-    assert!(at.file_exists(&format!("{dir1}/{file}")));
+    assert!(at.file_exists(format!("{dir1}/{file}")));
 
     ucmd.arg(&format!("{dir1}/{file}"))
         .arg(dir2)
         .succeeds()
         .no_stderr();
 
-    assert!(!at.file_exists(&format!("{dir1}/{file}")));
-    assert!(at.file_exists(&format!("{dir2}/{file}")));
+    assert!(!at.file_exists(format!("{dir1}/{file}")));
+    assert!(at.file_exists(format!("{dir2}/{file}")));
 }
 
 #[test]
@@ -94,7 +150,7 @@ fn test_mv_strip_slashes() {
 
     scene.ucmd().arg(&source).arg(dir).fails();
 
-    assert!(!at.file_exists(&format!("{dir}/{file}")));
+    assert!(!at.file_exists(format!("{dir}/{file}")));
 
     scene
         .ucmd()
@@ -104,7 +160,7 @@ fn test_mv_strip_slashes() {
         .succeeds()
         .no_stderr();
 
-    assert!(at.file_exists(&format!("{dir}/{file}")));
+    assert!(at.file_exists(format!("{dir}/{file}")));
 }
 
 #[test]
@@ -124,8 +180,8 @@ fn test_mv_multiple_files() {
         .succeeds()
         .no_stderr();
 
-    assert!(at.file_exists(&format!("{target_dir}/{file_a}")));
-    assert!(at.file_exists(&format!("{target_dir}/{file_b}")));
+    assert!(at.file_exists(format!("{target_dir}/{file_a}")));
+    assert!(at.file_exists(format!("{target_dir}/{file_b}")));
 }
 
 #[test]
@@ -165,7 +221,7 @@ fn test_mv_interactive() {
         .arg(file_a)
         .arg(file_b)
         .pipe_in("n")
-        .succeeds()
+        .fails()
         .no_stdout();
 
     assert!(at.file_exists(file_a));
@@ -184,6 +240,81 @@ fn test_mv_interactive() {
     assert!(at.file_exists(file_b));
 }
 
+#[test]
+fn test_mv_interactive_with_dir_as_target() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let file = "test_mv_interactive_file";
+    let target_dir = "target";
+
+    at.mkdir(target_dir);
+    at.touch(file);
+    at.touch(format!("{target_dir}/{file}"));
+
+    ucmd.arg(file)
+        .arg(target_dir)
+        .arg("-i")
+        .pipe_in("n")
+        .fails()
+        .stderr_does_not_contain("cannot move")
+        .no_stdout();
+}
+
+#[test]
+fn test_mv_interactive_dir_to_file_not_affirmative() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let dir = "test_mv_interactive_dir_to_file_not_affirmative_dir";
+    let file = "test_mv_interactive_dir_to_file_not_affirmative_file";
+
+    at.mkdir(dir);
+    at.touch(file);
+
+    ucmd.arg(dir)
+        .arg(file)
+        .arg("-i")
+        .pipe_in("n")
+        .fails()
+        .no_stdout();
+
+    assert!(at.dir_exists(dir));
+}
+
+#[test]
+fn test_mv_interactive_no_clobber_force_last_arg_wins() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let file_a = "a.txt";
+    let file_b = "b.txt";
+
+    at.touch(file_a);
+    at.touch(file_b);
+
+    scene
+        .ucmd()
+        .args(&[file_a, file_b, "-f", "-i", "-n"])
+        .fails()
+        .stderr_is(format!("mv: not replacing '{file_b}'\n"));
+
+    scene
+        .ucmd()
+        .args(&[file_a, file_b, "-n", "-f", "-i"])
+        .fails()
+        .stderr_is(format!("mv: overwrite '{file_b}'? "));
+
+    at.write(file_a, "aa");
+
+    scene
+        .ucmd()
+        .args(&[file_a, file_b, "-i", "-n", "-f"])
+        .succeeds()
+        .no_output();
+
+    assert!(!at.file_exists(file_a));
+    assert_eq!("aa", at.read(file_b));
+}
+
 #[test]
 fn test_mv_arg_update_interactive() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -215,8 +346,9 @@ fn test_mv_no_clobber() {
     ucmd.arg("-n")
         .arg(file_a)
         .arg(file_b)
-        .succeeds()
-        .no_stderr();
+        .fails()
+        .code_is(1)
+        .stderr_only(format!("mv: not replacing '{file_b}'\n"));
 
     assert!(at.file_exists(file_a));
     assert!(at.file_exists(file_b));
@@ -268,6 +400,87 @@ fn test_mv_same_file() {
         .stderr_is(format!("mv: '{file_a}' and '{file_a}' are the same file\n",));
 }
 
+#[test]
+#[cfg(all(unix, not(target_os = "android")))]
+fn test_mv_same_hardlink() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file_a = "test_mv_same_file_a";
+    let file_b = "test_mv_same_file_b";
+    at.touch(file_a);
+
+    at.hard_link(file_a, file_b);
+
+    at.touch(file_a);
+    ucmd.arg(file_a)
+        .arg(file_b)
+        .fails()
+        .stderr_is(format!("mv: '{file_a}' and '{file_b}' are the same file\n",));
+}
+
+#[test]
+#[cfg(all(unix, not(target_os = "android")))]
+fn test_mv_same_symlink() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file_a = "test_mv_same_file_a";
+    let file_b = "test_mv_same_file_b";
+    let file_c = "test_mv_same_file_c";
+
+    at.touch(file_a);
+
+    at.symlink_file(file_a, file_b);
+
+    ucmd.arg(file_b)
+        .arg(file_a)
+        .fails()
+        .stderr_is(format!("mv: '{file_b}' and '{file_a}' are the same file\n",));
+
+    let (at2, mut ucmd2) = at_and_ucmd!();
+    at2.touch(file_a);
+
+    at2.symlink_file(file_a, file_b);
+    ucmd2.arg(file_a).arg(file_b).succeeds();
+    assert!(at2.file_exists(file_b));
+    assert!(!at2.file_exists(file_a));
+
+    let (at3, mut ucmd3) = at_and_ucmd!();
+    at3.touch(file_a);
+
+    at3.symlink_file(file_a, file_b);
+    at3.symlink_file(file_b, file_c);
+
+    ucmd3.arg(file_c).arg(file_b).succeeds();
+    assert!(!at3.symlink_exists(file_c));
+    assert!(at3.symlink_exists(file_b));
+
+    let (at4, mut ucmd4) = at_and_ucmd!();
+    at4.touch(file_a);
+
+    at4.symlink_file(file_a, file_b);
+    at4.symlink_file(file_b, file_c);
+
+    ucmd4
+        .arg(file_c)
+        .arg(file_a)
+        .fails()
+        .stderr_is(format!("mv: '{file_c}' and '{file_a}' are the same file\n",));
+}
+
+#[test]
+#[cfg(all(unix, not(target_os = "android")))]
+fn test_mv_same_hardlink_backup_simple() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file_a = "test_mv_same_file_a";
+    let file_b = "test_mv_same_file_b";
+    at.touch(file_a);
+
+    at.hard_link(file_a, file_b);
+
+    ucmd.arg(file_a)
+        .arg(file_b)
+        .arg("--backup=simple")
+        .succeeds();
+}
+
 #[test]
 fn test_mv_same_file_not_dot_dir() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -305,7 +518,7 @@ fn test_mv_simple_backup() {
 
     assert!(!at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(at.file_exists(&format!("{file_b}~")));
+    assert!(at.file_exists(format!("{file_b}~")));
 }
 
 #[test]
@@ -324,7 +537,7 @@ fn test_mv_simple_backup_with_file_extension() {
 
     assert!(!at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(at.file_exists(&format!("{file_b}~")));
+    assert!(at.file_exists(format!("{file_b}~")));
 }
 
 #[test]
@@ -339,7 +552,7 @@ fn test_mv_arg_backup_arg_first() {
 
     assert!(!at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(at.file_exists(&format!("{file_b}~")));
+    assert!(at.file_exists(format!("{file_b}~")));
 }
 
 #[test]
@@ -360,7 +573,7 @@ fn test_mv_custom_backup_suffix() {
 
     assert!(!at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(at.file_exists(&format!("{file_b}{suffix}")));
+    assert!(at.file_exists(format!("{file_b}{suffix}")));
 }
 
 #[test]
@@ -381,7 +594,7 @@ fn test_mv_custom_backup_suffix_hyphen_value() {
 
     assert!(!at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(at.file_exists(&format!("{file_b}{suffix}")));
+    assert!(at.file_exists(format!("{file_b}{suffix}")));
 }
 
 #[test]
@@ -401,7 +614,7 @@ fn test_mv_custom_backup_suffix_via_env() {
 
     assert!(!at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(at.file_exists(&format!("{file_b}{suffix}")));
+    assert!(at.file_exists(format!("{file_b}{suffix}")));
 }
 
 #[test]
@@ -420,7 +633,7 @@ fn test_mv_backup_numbered_with_t() {
 
     assert!(!at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(at.file_exists(&format!("{file_b}.~1~")));
+    assert!(at.file_exists(format!("{file_b}.~1~")));
 }
 
 #[test]
@@ -439,7 +652,7 @@ fn test_mv_backup_numbered() {
 
     assert!(!at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(at.file_exists(&format!("{file_b}.~1~")));
+    assert!(at.file_exists(format!("{file_b}.~1~")));
 }
 
 #[test]
@@ -458,7 +671,7 @@ fn test_mv_backup_existing() {
 
     assert!(!at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(at.file_exists(&format!("{file_b}~")));
+    assert!(at.file_exists(format!("{file_b}~")));
 }
 
 #[test]
@@ -477,7 +690,7 @@ fn test_mv_backup_nil() {
 
     assert!(!at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(at.file_exists(&format!("{file_b}~")));
+    assert!(at.file_exists(format!("{file_b}~")));
 }
 
 #[test]
@@ -498,7 +711,7 @@ fn test_mv_numbered_if_existing_backup_existing() {
 
     assert!(at.file_exists(file_b));
     assert!(at.file_exists(file_b_backup));
-    assert!(at.file_exists(&format!("{file_b}.~2~")));
+    assert!(at.file_exists(format!("{file_b}.~2~")));
 }
 
 #[test]
@@ -519,7 +732,7 @@ fn test_mv_numbered_if_existing_backup_nil() {
 
     assert!(at.file_exists(file_b));
     assert!(at.file_exists(file_b_backup));
-    assert!(at.file_exists(&format!("{file_b}.~2~")));
+    assert!(at.file_exists(format!("{file_b}.~2~")));
 }
 
 #[test]
@@ -538,7 +751,7 @@ fn test_mv_backup_simple() {
 
     assert!(!at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(at.file_exists(&format!("{file_b}~")));
+    assert!(at.file_exists(format!("{file_b}~")));
 }
 
 #[test]
@@ -557,7 +770,7 @@ fn test_mv_backup_never() {
 
     assert!(!at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(at.file_exists(&format!("{file_b}~")));
+    assert!(at.file_exists(format!("{file_b}~")));
 }
 
 #[test]
@@ -576,7 +789,7 @@ fn test_mv_backup_none() {
 
     assert!(!at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(!at.file_exists(&format!("{file_b}~")));
+    assert!(!at.file_exists(format!("{file_b}~")));
 }
 
 #[test]
@@ -595,7 +808,7 @@ fn test_mv_backup_off() {
 
     assert!(!at.file_exists(file_a));
     assert!(at.file_exists(file_b));
-    assert!(!at.file_exists(&format!("{file_b}~")));
+    assert!(!at.file_exists(format!("{file_b}~")));
 }
 
 #[test]
@@ -618,7 +831,7 @@ fn test_mv_update_option() {
 
     at.touch(file_a);
     at.touch(file_b);
-    let ts = time::OffsetDateTime::now_local().unwrap();
+    let ts = time::OffsetDateTime::now_utc();
     let now = FileTime::from_unix_time(ts.unix_timestamp(), ts.nanosecond());
     let later = FileTime::from_unix_time(ts.unix_timestamp() + 3600, ts.nanosecond());
     filetime::set_file_times(at.plus_as_string(file_a), now, now).unwrap();
@@ -641,6 +854,208 @@ fn test_mv_update_option() {
     assert!(!at.file_exists(file_b));
 }
 
+#[test]
+fn test_mv_arg_update_none() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let file1 = "test_mv_arg_update_none_file1";
+    let file2 = "test_mv_arg_update_none_file2";
+    let file1_content = "file1 content\n";
+    let file2_content = "file2 content\n";
+
+    at.write(file1, file1_content);
+    at.write(file2, file2_content);
+
+    ucmd.arg(file1)
+        .arg(file2)
+        .arg("--update=none")
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+
+    assert_eq!(at.read(file2), file2_content);
+}
+
+#[test]
+fn test_mv_arg_update_all() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let file1 = "test_mv_arg_update_none_file1";
+    let file2 = "test_mv_arg_update_none_file2";
+    let file1_content = "file1 content\n";
+    let file2_content = "file2 content\n";
+
+    at.write(file1, file1_content);
+    at.write(file2, file2_content);
+
+    ucmd.arg(file1)
+        .arg(file2)
+        .arg("--update=all")
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+
+    assert_eq!(at.read(file2), file1_content);
+}
+
+#[test]
+fn test_mv_arg_update_older_dest_not_older() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let old = "test_mv_arg_update_none_file1";
+    let new = "test_mv_arg_update_none_file2";
+    let old_content = "file1 content\n";
+    let new_content = "file2 content\n";
+
+    at.write(old, old_content);
+
+    sleep(Duration::from_secs(1));
+
+    at.write(new, new_content);
+
+    ucmd.arg(old)
+        .arg(new)
+        .arg("--update=older")
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+
+    assert_eq!(at.read(new), new_content);
+}
+
+#[test]
+fn test_mv_arg_update_none_then_all() {
+    // take last if multiple update args are supplied,
+    // update=all wins in this case
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let old = "test_mv_arg_update_none_then_all_file1";
+    let new = "test_mv_arg_update_none_then_all_file2";
+    let old_content = "old content\n";
+    let new_content = "new content\n";
+
+    at.write(old, old_content);
+
+    sleep(Duration::from_secs(1));
+
+    at.write(new, new_content);
+
+    ucmd.arg(old)
+        .arg(new)
+        .arg("--update=none")
+        .arg("--update=all")
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+
+    assert_eq!(at.read(new), "old content\n");
+}
+
+#[test]
+fn test_mv_arg_update_all_then_none() {
+    // take last if multiple update args are supplied,
+    // update=none wins in this case
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let old = "test_mv_arg_update_all_then_none_file1";
+    let new = "test_mv_arg_update_all_then_none_file2";
+    let old_content = "old content\n";
+    let new_content = "new content\n";
+
+    at.write(old, old_content);
+
+    sleep(Duration::from_secs(1));
+
+    at.write(new, new_content);
+
+    ucmd.arg(old)
+        .arg(new)
+        .arg("--update=all")
+        .arg("--update=none")
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+
+    assert_eq!(at.read(new), "new content\n");
+}
+
+#[test]
+fn test_mv_arg_update_older_dest_older() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let old = "test_mv_arg_update_none_file1";
+    let new = "test_mv_arg_update_none_file2";
+    let old_content = "file1 content\n";
+    let new_content = "file2 content\n";
+
+    at.write(old, old_content);
+
+    sleep(Duration::from_secs(1));
+
+    at.write(new, new_content);
+
+    ucmd.arg(new)
+        .arg(old)
+        .arg("--update=all")
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+
+    assert_eq!(at.read(old), new_content);
+}
+
+#[test]
+fn test_mv_arg_update_short_overwrite() {
+    // same as --update=older
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let old = "test_mv_arg_update_none_file1";
+    let new = "test_mv_arg_update_none_file2";
+    let old_content = "file1 content\n";
+    let new_content = "file2 content\n";
+
+    at.write(old, old_content);
+
+    sleep(Duration::from_secs(1));
+
+    at.write(new, new_content);
+
+    ucmd.arg(new)
+        .arg(old)
+        .arg("-u")
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+
+    assert_eq!(at.read(old), new_content);
+}
+
+#[test]
+fn test_mv_arg_update_short_no_overwrite() {
+    // same as --update=older
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let old = "test_mv_arg_update_none_file1";
+    let new = "test_mv_arg_update_none_file2";
+    let old_content = "file1 content\n";
+    let new_content = "file2 content\n";
+
+    at.write(old, old_content);
+
+    sleep(Duration::from_secs(1));
+
+    at.write(new, new_content);
+
+    ucmd.arg(old)
+        .arg(new)
+        .arg("-u")
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+
+    assert_eq!(at.read(new), new_content);
+}
+
 #[test]
 fn test_mv_target_dir() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -660,8 +1075,8 @@ fn test_mv_target_dir() {
 
     assert!(!at.file_exists(file_a));
     assert!(!at.file_exists(file_b));
-    assert!(at.file_exists(&format!("{dir}/{file_a}")));
-    assert!(at.file_exists(&format!("{dir}/{file_b}")));
+    assert!(at.file_exists(format!("{dir}/{file_a}")));
+    assert!(at.file_exists(format!("{dir}/{file_b}")));
 }
 
 #[test]
@@ -675,7 +1090,7 @@ fn test_mv_target_dir_single_source() {
     ucmd.arg("-t").arg(dir).arg(file).succeeds().no_stderr();
 
     assert!(!at.file_exists(file));
-    assert!(at.file_exists(&format!("{dir}/{file}")));
+    assert!(at.file_exists(format!("{dir}/{file}")));
 }
 
 #[test]
@@ -728,7 +1143,9 @@ fn test_mv_backup_dir() {
         .arg(dir_a)
         .arg(dir_b)
         .succeeds()
-        .stdout_only(format!("'{dir_a}' -> '{dir_b}' (backup: '{dir_b}~')\n"));
+        .stdout_only(format!(
+            "renamed '{dir_a}' -> '{dir_b}' (backup: '{dir_b}~')\n"
+        ));
 
     assert!(!at.dir_exists(dir_a));
     assert!(at.dir_exists(dir_b));
@@ -800,7 +1217,7 @@ fn test_mv_verbose() {
         .arg(file_a)
         .arg(file_b)
         .succeeds()
-        .stdout_only(format!("'{file_a}' -> '{file_b}'\n"));
+        .stdout_only(format!("renamed '{file_a}' -> '{file_b}'\n"));
 
     at.touch(file_a);
     scene
@@ -809,7 +1226,9 @@ fn test_mv_verbose() {
         .arg(file_a)
         .arg(file_b)
         .succeeds()
-        .stdout_only(format!("'{file_a}' -> '{file_b}' (backup: '{file_b}~')\n"));
+        .stdout_only(format!(
+            "renamed '{file_a}' -> '{file_b}' (backup: '{file_b}~')\n"
+        ));
 }
 
 #[test]
@@ -872,6 +1291,29 @@ fn test_mv_info_self() {
         .stderr_contains("mv: cannot move 'dir2' to a subdirectory of itself, 'dir2/dir2'");
 }
 
+#[test]
+fn test_mv_arg_interactive_skipped() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.touch("a");
+    at.touch("b");
+    ucmd.args(&["-vi", "a", "b"])
+        .pipe_in("N\n")
+        .ignore_stdin_write_error()
+        .fails()
+        .stderr_is("mv: overwrite 'b'? ")
+        .stdout_is("skipped 'b'\n");
+}
+
+#[test]
+fn test_mv_arg_interactive_skipped_vin() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.touch("a");
+    at.touch("b");
+    ucmd.args(&["-vin", "a", "b"])
+        .fails()
+        .stdout_is("skipped 'b'\n");
+}
+
 #[test]
 fn test_mv_into_self_data() {
     let scene = TestScenario::new(util_name!());
diff --git a/tests/by-util/test_nice.rs b/tests/by-util/test_nice.rs
index 6fca05ab4..4e8d5a2ee 100644
--- a/tests/by-util/test_nice.rs
+++ b/tests/by-util/test_nice.rs
@@ -1,11 +1,14 @@
-use crate::common::util::*;
+// spell-checker:ignore libc's
+use crate::common::util::TestScenario;
 
 #[test]
 #[cfg(not(target_os = "android"))]
 fn test_get_current_niceness() {
-    // NOTE: this assumes the test suite is being run with a default niceness
-    // of 0, which may not necessarily be true
-    new_ucmd!().run().stdout_is("0\n");
+    // Test that the nice command with no arguments returns the default nice
+    // value, which we determine by querying libc's `nice` in our own process.
+    new_ucmd!()
+        .run()
+        .stdout_is(format!("{}\n", unsafe { libc::nice(0) }));
 }
 
 #[test]
diff --git a/tests/by-util/test_nl.rs b/tests/by-util/test_nl.rs
index cd59a745c..7317d8cca 100644
--- a/tests/by-util/test_nl.rs
+++ b/tests/by-util/test_nl.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
diff --git a/tests/by-util/test_nohup.rs b/tests/by-util/test_nohup.rs
index 8ef0bc9c9..c14a2e494 100644
--- a/tests/by-util/test_nohup.rs
+++ b/tests/by-util/test_nohup.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 use std::thread::sleep;
 
 // General observation: nohup.out will not be created in tests run by cargo test
diff --git a/tests/by-util/test_nproc.rs b/tests/by-util/test_nproc.rs
index abae40697..2e3c5c603 100644
--- a/tests/by-util/test_nproc.rs
+++ b/tests/by-util/test_nproc.rs
@@ -1,5 +1,5 @@
 // spell-checker:ignore incorrectnumber
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
@@ -21,7 +21,6 @@ fn test_nproc_all_omp() {
 
     let result = TestScenario::new(util_name!())
         .ucmd()
-        .keep_env()
         .env("OMP_NUM_THREADS", "60")
         .succeeds();
 
@@ -30,7 +29,6 @@ fn test_nproc_all_omp() {
 
     let result = TestScenario::new(util_name!())
         .ucmd()
-        .keep_env()
         .env("OMP_NUM_THREADS", "1") // Has no effect
         .arg("--all")
         .succeeds();
@@ -40,7 +38,6 @@ fn test_nproc_all_omp() {
     // If the parsing fails, returns the number of CPU
     let result = TestScenario::new(util_name!())
         .ucmd()
-        .keep_env()
         .env("OMP_NUM_THREADS", "incorrectnumber") // returns the number CPU
         .succeeds();
     let nproc_omp: u8 = result.stdout_str().trim().parse().unwrap();
@@ -55,7 +52,6 @@ fn test_nproc_ignore() {
         // Ignore all CPU but one
         let result = TestScenario::new(util_name!())
             .ucmd()
-            .keep_env()
             .arg("--ignore")
             .arg((nproc_total - 1).to_string())
             .succeeds();
@@ -64,7 +60,6 @@ fn test_nproc_ignore() {
         // Ignore all CPU but one with a string
         let result = TestScenario::new(util_name!())
             .ucmd()
-            .keep_env()
             .arg("--ignore= 1")
             .succeeds();
         let nproc: u8 = result.stdout_str().trim().parse().unwrap();
@@ -76,7 +71,6 @@ fn test_nproc_ignore() {
 fn test_nproc_ignore_all_omp() {
     let result = TestScenario::new(util_name!())
         .ucmd()
-        .keep_env()
         .env("OMP_NUM_THREADS", "42")
         .arg("--ignore=40")
         .succeeds();
@@ -88,7 +82,6 @@ fn test_nproc_ignore_all_omp() {
 fn test_nproc_omp_limit() {
     let result = TestScenario::new(util_name!())
         .ucmd()
-        .keep_env()
         .env("OMP_NUM_THREADS", "42")
         .env("OMP_THREAD_LIMIT", "0")
         .succeeds();
@@ -97,7 +90,6 @@ fn test_nproc_omp_limit() {
 
     let result = TestScenario::new(util_name!())
         .ucmd()
-        .keep_env()
         .env("OMP_NUM_THREADS", "42")
         .env("OMP_THREAD_LIMIT", "2")
         .succeeds();
@@ -106,7 +98,6 @@ fn test_nproc_omp_limit() {
 
     let result = TestScenario::new(util_name!())
         .ucmd()
-        .keep_env()
         .env("OMP_NUM_THREADS", "42")
         .env("OMP_THREAD_LIMIT", "2bad")
         .succeeds();
@@ -119,7 +110,6 @@ fn test_nproc_omp_limit() {
 
     let result = TestScenario::new(util_name!())
         .ucmd()
-        .keep_env()
         .env("OMP_THREAD_LIMIT", "1")
         .succeeds();
     let nproc: u8 = result.stdout_str().trim().parse().unwrap();
@@ -127,7 +117,6 @@ fn test_nproc_omp_limit() {
 
     let result = TestScenario::new(util_name!())
         .ucmd()
-        .keep_env()
         .env("OMP_NUM_THREADS", "0")
         .env("OMP_THREAD_LIMIT", "")
         .succeeds();
@@ -136,7 +125,6 @@ fn test_nproc_omp_limit() {
 
     let result = TestScenario::new(util_name!())
         .ucmd()
-        .keep_env()
         .env("OMP_NUM_THREADS", "")
         .env("OMP_THREAD_LIMIT", "")
         .succeeds();
@@ -145,7 +133,6 @@ fn test_nproc_omp_limit() {
 
     let result = TestScenario::new(util_name!())
         .ucmd()
-        .keep_env()
         .env("OMP_NUM_THREADS", "2,2,1")
         .env("OMP_THREAD_LIMIT", "")
         .succeeds();
@@ -154,7 +141,6 @@ fn test_nproc_omp_limit() {
 
     let result = TestScenario::new(util_name!())
         .ucmd()
-        .keep_env()
         .env("OMP_NUM_THREADS", "2,ignored")
         .env("OMP_THREAD_LIMIT", "")
         .succeeds();
@@ -163,7 +149,6 @@ fn test_nproc_omp_limit() {
 
     let result = TestScenario::new(util_name!())
         .ucmd()
-        .keep_env()
         .env("OMP_NUM_THREADS", "2,2,1")
         .env("OMP_THREAD_LIMIT", "0")
         .succeeds();
@@ -172,7 +157,6 @@ fn test_nproc_omp_limit() {
 
     let result = TestScenario::new(util_name!())
         .ucmd()
-        .keep_env()
         .env("OMP_NUM_THREADS", "2,2,1")
         .env("OMP_THREAD_LIMIT", "1bad")
         .succeeds();
@@ -181,7 +165,6 @@ fn test_nproc_omp_limit() {
 
     let result = TestScenario::new(util_name!())
         .ucmd()
-        .keep_env()
         .env("OMP_NUM_THREADS", "29,2,1")
         .env("OMP_THREAD_LIMIT", "1bad")
         .succeeds();
diff --git a/tests/by-util/test_numfmt.rs b/tests/by-util/test_numfmt.rs
index e162196f2..fbfe68427 100644
--- a/tests/by-util/test_numfmt.rs
+++ b/tests/by-util/test_numfmt.rs
@@ -1,6 +1,6 @@
 // spell-checker:ignore (paths) gnutest
 
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
diff --git a/tests/by-util/test_od.rs b/tests/by-util/test_od.rs
index c1857f3bc..24626cd76 100644
--- a/tests/by-util/test_od.rs
+++ b/tests/by-util/test_od.rs
@@ -4,15 +4,13 @@
 //  * For the full copyright and license information, please view the LICENSE
 //  * file that was distributed with this source code.
 
-extern crate unindent;
-
-use self::unindent::*;
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 use std::env;
 use std::fs::remove_file;
 use std::fs::File;
 use std::io::Write;
 use std::path::Path;
+use unindent::unindent;
 
 // octal dump of 'abcdefghijklmnopqrstuvwxyz\n'     // spell-checker:disable-line
 static ALPHA_OUT: &str = "
diff --git a/tests/by-util/test_paste.rs b/tests/by-util/test_paste.rs
index 977645bee..da92daa32 100644
--- a/tests/by-util/test_paste.rs
+++ b/tests/by-util/test_paste.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 struct TestData<'b> {
     name: &'b str,
@@ -156,6 +156,39 @@ fn test_multi_stdin() {
     }
 }
 
+#[test]
+// TODO: make this test work on Windows
+#[cfg(not(windows))]
+fn test_delimiter_list_ending_with_escaped_backslash() {
+    for d in ["-d", "--delimiters"] {
+        let (at, mut ucmd) = at_and_ucmd!();
+        let mut ins = vec![];
+        for (i, _in) in ["a\n", "b\n"].iter().enumerate() {
+            let file = format!("in{}", i);
+            at.write(&file, _in);
+            ins.push(file);
+        }
+        ucmd.args(&[d, "\\\\"])
+            .args(&ins)
+            .succeeds()
+            .stdout_is("a\\b\n");
+    }
+}
+
+#[test]
+fn test_delimiter_list_ending_with_unescaped_backslash() {
+    for d in ["-d", "--delimiters"] {
+        new_ucmd!()
+            .args(&[d, "\\"])
+            .fails()
+            .stderr_contains("delimiter list ends with an unescaped backslash: \\");
+        new_ucmd!()
+            .args(&[d, "_\\"])
+            .fails()
+            .stderr_contains("delimiter list ends with an unescaped backslash: _\\");
+    }
+}
+
 #[test]
 fn test_data() {
     for example in EXAMPLE_DATA {
diff --git a/tests/by-util/test_pathchk.rs b/tests/by-util/test_pathchk.rs
index 9b16fe738..771fbd0a9 100644
--- a/tests/by-util/test_pathchk.rs
+++ b/tests/by-util/test_pathchk.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
diff --git a/tests/by-util/test_pinky.rs b/tests/by-util/test_pinky.rs
index da4aab605..f266175f5 100644
--- a/tests/by-util/test_pinky.rs
+++ b/tests/by-util/test_pinky.rs
@@ -3,14 +3,9 @@
 //  * For the full copyright and license information, please view the LICENSE
 //  * file that was distributed with this source code.
 
-extern crate uucore;
-
-use crate::common::util::*;
-
-use self::uucore::entries::{Locate, Passwd};
-
-extern crate pinky;
-pub use self::pinky::*;
+use crate::common::util::{expected_result, TestScenario};
+use pinky::Capitalize;
+use uucore::entries::{Locate, Passwd};
 
 #[test]
 fn test_invalid_arg() {
diff --git a/tests/by-util/test_pr.rs b/tests/by-util/test_pr.rs
index ae18464db..b62fa4a96 100644
--- a/tests/by-util/test_pr.rs
+++ b/tests/by-util/test_pr.rs
@@ -1,7 +1,6 @@
 // spell-checker:ignore (ToDO) Sdivide
-extern crate time;
 
-use crate::common::util::*;
+use crate::common::util::{TestScenario, UCommand};
 use std::fs::metadata;
 use time::macros::format_description;
 use time::Duration;
@@ -18,11 +17,7 @@ fn file_last_modified_time(ucmd: &UCommand, path: &str) -> String {
             i.modified()
                 .map(|x| {
                     let date_time: OffsetDateTime = x.into();
-                    let offset = OffsetDateTime::now_local().unwrap().offset();
-                    date_time
-                        .to_offset(offset)
-                        .format(&DATE_TIME_FORMAT)
-                        .unwrap()
+                    date_time.format(&DATE_TIME_FORMAT).unwrap()
                 })
                 .unwrap_or_default()
         })
@@ -42,7 +37,7 @@ fn all_minutes(from: OffsetDateTime, to: OffsetDateTime) -> Vec<String> {
 }
 
 fn valid_last_modified_template_vars(from: OffsetDateTime) -> Vec<Vec<(String, String)>> {
-    all_minutes(from, OffsetDateTime::now_local().unwrap())
+    all_minutes(from, OffsetDateTime::now_utc())
         .into_iter()
         .map(|time| vec![("{last_modified_time}".to_string(), time)])
         .collect()
@@ -258,7 +253,7 @@ fn test_with_suppress_error_option() {
 fn test_with_stdin() {
     let expected_file_path = "stdin.log.expected";
     let mut scenario = new_ucmd!();
-    let start = OffsetDateTime::now_local().unwrap();
+    let start = OffsetDateTime::now_utc();
     scenario
         .pipe_in_fixture("stdin.log")
         .args(&["--pages=1:2", "-n", "-"])
@@ -321,7 +316,7 @@ fn test_with_mpr() {
     let expected_test_file_path = "mpr.log.expected";
     let expected_test_file_path1 = "mpr1.log.expected";
     let expected_test_file_path2 = "mpr2.log.expected";
-    let start = OffsetDateTime::now_local().unwrap();
+    let start = OffsetDateTime::now_utc();
     new_ucmd!()
         .args(&["--pages=1:2", "-m", "-n", test_file_path, test_file_path1])
         .succeeds()
@@ -330,7 +325,7 @@ fn test_with_mpr() {
             &valid_last_modified_template_vars(start),
         );
 
-    let start = OffsetDateTime::now_local().unwrap();
+    let start = OffsetDateTime::now_utc();
     new_ucmd!()
         .args(&["--pages=2:4", "-m", "-n", test_file_path, test_file_path1])
         .succeeds()
@@ -339,7 +334,7 @@ fn test_with_mpr() {
             &valid_last_modified_template_vars(start),
         );
 
-    let start = OffsetDateTime::now_local().unwrap();
+    let start = OffsetDateTime::now_utc();
     new_ucmd!()
         .args(&[
             "--pages=1:2",
@@ -446,7 +441,7 @@ fn test_with_join_lines_option() {
     let test_file_2 = "test.log";
     let expected_file_path = "joined.log.expected";
     let mut scenario = new_ucmd!();
-    let start = OffsetDateTime::now_local().unwrap();
+    let start = OffsetDateTime::now_utc();
     scenario
         .args(&["+1:2", "-J", "-m", test_file_1, test_file_2])
         .run()
diff --git a/tests/by-util/test_printenv.rs b/tests/by-util/test_printenv.rs
index c4f32705f..fa7d420e1 100644
--- a/tests/by-util/test_printenv.rs
+++ b/tests/by-util/test_printenv.rs
@@ -1,29 +1,21 @@
-use crate::common::util::*;
-use std::env;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_get_all() {
-    let key = "KEY";
-    env::set_var(key, "VALUE");
-    assert_eq!(env::var(key), Ok("VALUE".to_string()));
-
     TestScenario::new(util_name!())
         .ucmd()
-        .keep_env()
+        .env("HOME", "FOO")
+        .env("KEY", "VALUE")
         .succeeds()
-        .stdout_contains("HOME=")
+        .stdout_contains("HOME=FOO")
         .stdout_contains("KEY=VALUE");
 }
 
 #[test]
 fn test_get_var() {
-    let key = "KEY";
-    env::set_var(key, "VALUE");
-    assert_eq!(env::var(key), Ok("VALUE".to_string()));
-
     let result = TestScenario::new(util_name!())
         .ucmd()
-        .keep_env()
+        .env("KEY", "VALUE")
         .arg("KEY")
         .succeeds();
 
diff --git a/tests/by-util/test_printf.rs b/tests/by-util/test_printf.rs
index 77f64750c..e9b25954f 100644
--- a/tests/by-util/test_printf.rs
+++ b/tests/by-util/test_printf.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn basic_literal() {
diff --git a/tests/by-util/test_ptx.rs b/tests/by-util/test_ptx.rs
index 7372bb5cc..db4a4f3cc 100644
--- a/tests/by-util/test_ptx.rs
+++ b/tests/by-util/test_ptx.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
diff --git a/tests/by-util/test_pwd.rs b/tests/by-util/test_pwd.rs
index 461c597bd..1e43f5be6 100644
--- a/tests/by-util/test_pwd.rs
+++ b/tests/by-util/test_pwd.rs
@@ -2,7 +2,7 @@
 
 use std::path::PathBuf;
 
-use crate::common::util::*;
+use crate::common::util::{TestScenario, UCommand};
 
 #[test]
 fn test_invalid_arg() {
@@ -27,7 +27,7 @@ fn test_deleted_dir() {
     use std::process::Command;
 
     let ts = TestScenario::new(util_name!());
-    let at = ts.fixtures.clone();
+    let at = ts.fixtures;
     let output = Command::new("sh")
         .arg("-c")
         .arg(format!(
@@ -116,7 +116,7 @@ fn test_symlinked_default_posix_p() {
         .env("POSIXLY_CORRECT", "1")
         .arg("-P")
         .succeeds()
-        .stdout_is(env.symdir + "\n");
+        .stdout_is(env.subdir + "\n");
 }
 
 #[cfg(not(windows))]
diff --git a/tests/by-util/test_readlink.rs b/tests/by-util/test_readlink.rs
index 4441aebd9..f08671583 100644
--- a/tests/by-util/test_readlink.rs
+++ b/tests/by-util/test_readlink.rs
@@ -1,5 +1,5 @@
 // spell-checker:ignore regfile
-use crate::common::util::*;
+use crate::common::util::{get_root_path, TestScenario};
 
 static GIBBERISH: &str = "supercalifragilisticexpialidocious";
 
diff --git a/tests/by-util/test_realpath.rs b/tests/by-util/test_realpath.rs
index 2993d8dbb..707378c97 100644
--- a/tests/by-util/test_realpath.rs
+++ b/tests/by-util/test_realpath.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::{get_root_path, TestScenario};
 
 #[cfg(windows)]
 use regex::Regex;
@@ -192,7 +192,7 @@ fn test_realpath_existing() {
     ucmd.arg("-e")
         .arg(".")
         .succeeds()
-        .stdout_only(at.plus_as_string(&format!("{}\n", at.root_dir_resolved())));
+        .stdout_only(at.plus_as_string(format!("{}\n", at.root_dir_resolved())));
 }
 
 #[test]
diff --git a/tests/by-util/test_relpath.rs b/tests/by-util/test_relpath.rs
index 753b5d755..65cbd391e 100644
--- a/tests/by-util/test_relpath.rs
+++ b/tests/by-util/test_relpath.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 use std::borrow::Cow;
 use std::path::Path;
 
diff --git a/tests/by-util/test_rm.rs b/tests/by-util/test_rm.rs
index ce534af8d..737c4fa79 100644
--- a/tests/by-util/test_rm.rs
+++ b/tests/by-util/test_rm.rs
@@ -1,6 +1,6 @@
 use std::process::Stdio;
 
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
@@ -54,6 +54,8 @@ fn test_rm_interactive() {
 
     at.touch(file_a);
     at.touch(file_b);
+    assert!(at.file_exists(file_a));
+    assert!(at.file_exists(file_b));
 
     scene
         .ucmd()
@@ -84,6 +86,11 @@ fn test_rm_force() {
     let file_a = "test_rm_force_a";
     let file_b = "test_rm_force_b";
 
+    at.touch(file_a);
+    at.touch(file_b);
+    assert!(at.file_exists(file_a));
+    assert!(at.file_exists(file_b));
+
     ucmd.arg("-f")
         .arg(file_a)
         .arg(file_b)
@@ -100,6 +107,11 @@ fn test_rm_force_multiple() {
     let file_a = "test_rm_force_a";
     let file_b = "test_rm_force_b";
 
+    at.touch(file_a);
+    at.touch(file_b);
+    assert!(at.file_exists(file_a));
+    assert!(at.file_exists(file_b));
+
     ucmd.arg("-f")
         .arg("-f")
         .arg("-f")
@@ -349,6 +361,74 @@ fn test_rm_interactive_never() {
     assert!(!at.file_exists(file_2));
 }
 
+#[test]
+fn test_rm_interactive_missing_value() {
+    // `--interactive` is equivalent to `--interactive=always` or `-i`
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let file1 = "test_rm_interactive_missing_value_file1";
+    let file2 = "test_rm_interactive_missing_value_file2";
+
+    at.touch(file1);
+    at.touch(file2);
+
+    ucmd.arg("--interactive")
+        .arg(file1)
+        .arg(file2)
+        .pipe_in("y\ny")
+        .succeeds();
+
+    assert!(!at.file_exists(file1));
+    assert!(!at.file_exists(file2));
+}
+
+#[test]
+fn test_rm_interactive_once_prompt() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let file1 = "test_rm_interactive_once_recursive_prompt_file1";
+    let file2 = "test_rm_interactive_once_recursive_prompt_file2";
+    let file3 = "test_rm_interactive_once_recursive_prompt_file3";
+    let file4 = "test_rm_interactive_once_recursive_prompt_file4";
+
+    at.touch(file1);
+    at.touch(file2);
+    at.touch(file3);
+    at.touch(file4);
+
+    ucmd.arg("--interactive=once")
+        .arg(file1)
+        .arg(file2)
+        .arg(file3)
+        .arg(file4)
+        .pipe_in("y")
+        .succeeds()
+        .stderr_contains("remove 4 arguments?");
+
+    assert!(!at.file_exists(file1));
+    assert!(!at.file_exists(file2));
+    assert!(!at.file_exists(file3));
+    assert!(!at.file_exists(file4));
+}
+
+#[test]
+fn test_rm_interactive_once_recursive_prompt() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let file1 = "test_rm_interactive_once_recursive_prompt_file1";
+
+    at.touch(file1);
+
+    ucmd.arg("--interactive=once")
+        .arg("-r")
+        .arg(file1)
+        .pipe_in("y")
+        .succeeds()
+        .stderr_contains("remove 1 argument recursively?");
+
+    assert!(!at.file_exists(file1));
+}
+
 #[test]
 fn test_rm_descend_directory() {
     // This test descends into each directory and deletes the files and folders inside of them
@@ -578,3 +658,24 @@ fn test_fifo_removal() {
         .timeout(Duration::from_secs(2))
         .succeeds();
 }
+
+#[test]
+#[cfg(any(unix, target_os = "wasi"))]
+#[cfg(not(target_os = "macos"))]
+fn test_non_utf8() {
+    use std::ffi::OsStr;
+    #[cfg(unix)]
+    use std::os::unix::ffi::OsStrExt;
+    #[cfg(target_os = "wasi")]
+    use std::os::wasi::ffi::OsStrExt;
+
+    let file = OsStr::from_bytes(b"not\xffutf8"); // spell-checker:disable-line
+
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.touch(file);
+    assert!(at.file_exists(file));
+
+    ucmd.arg(file).succeeds();
+    assert!(!at.file_exists(file));
+}
diff --git a/tests/by-util/test_rmdir.rs b/tests/by-util/test_rmdir.rs
index 4cf84407c..56e801d7e 100644
--- a/tests/by-util/test_rmdir.rs
+++ b/tests/by-util/test_rmdir.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 const DIR: &str = "dir";
 const DIR_FILE: &str = "dir/file";
diff --git a/tests/by-util/test_seq.rs b/tests/by-util/test_seq.rs
index fa73b2937..63015b24a 100644
--- a/tests/by-util/test_seq.rs
+++ b/tests/by-util/test_seq.rs
@@ -1,5 +1,5 @@
 // spell-checker:ignore lmnop xlmnop
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 use std::process::Stdio;
 
 #[test]
@@ -36,18 +36,12 @@ fn test_hex_rejects_sign_after_identifier() {
         .args(&["-0x-123ABC"])
         .fails()
         .no_stdout()
-        .stderr_contains(
-            "Found argument '-0' which wasn't expected, or isn't valid in this context",
-        )
-        .stderr_contains("For more information try '--help'");
+        .stderr_contains("unexpected argument '-0' found");
     new_ucmd!()
         .args(&["-0x+123ABC"])
         .fails()
         .no_stdout()
-        .stderr_contains(
-            "Found argument '-0' which wasn't expected, or isn't valid in this context",
-        )
-        .stderr_contains("For more information try '--help'");
+        .stderr_contains("unexpected argument '-0' found");
 }
 
 #[test]
diff --git a/tests/by-util/test_shred.rs b/tests/by-util/test_shred.rs
index 0780411f6..a34345aee 100644
--- a/tests/by-util/test_shred.rs
+++ b/tests/by-util/test_shred.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
@@ -25,7 +25,6 @@ fn test_shred_remove() {
     assert!(at.file_exists(file_b));
 }
 
-#[cfg(not(target_os = "freebsd"))]
 #[test]
 fn test_shred_force() {
     let scene = TestScenario::new(util_name!());
@@ -52,3 +51,14 @@ fn test_shred_force() {
     // file_a was deleted.
     assert!(!at.file_exists(file));
 }
+
+#[test]
+fn test_hex() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let file = "test_hex";
+
+    at.touch(file);
+
+    ucmd.arg("--size=0x10").arg(file).succeeds();
+}
diff --git a/tests/by-util/test_shuf.rs b/tests/by-util/test_shuf.rs
index 39a7a640b..44282b8a3 100644
--- a/tests/by-util/test_shuf.rs
+++ b/tests/by-util/test_shuf.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
@@ -10,7 +10,7 @@ fn test_output_is_random_permutation() {
     let input_seq = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
     let input = input_seq
         .iter()
-        .map(|x| x.to_string())
+        .map(ToString::to_string)
         .collect::<Vec<String>>()
         .join("\n");
 
@@ -52,7 +52,7 @@ fn test_echo() {
         .args(
             &input_seq
                 .iter()
-                .map(|x| x.to_string())
+                .map(ToString::to_string)
                 .collect::<Vec<String>>(),
         )
         .succeeds();
@@ -74,7 +74,7 @@ fn test_head_count() {
     let input_seq = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
     let input = input_seq
         .iter()
-        .map(|x| x.to_string())
+        .map(ToString::to_string)
         .collect::<Vec<String>>()
         .join("\n");
 
@@ -105,7 +105,7 @@ fn test_repeat() {
     let input_seq = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
     let input = input_seq
         .iter()
-        .map(|x| x.to_string())
+        .map(ToString::to_string)
         .collect::<Vec<String>>()
         .join("\n");
 
diff --git a/tests/by-util/test_sleep.rs b/tests/by-util/test_sleep.rs
index b6b573508..13aa882b9 100644
--- a/tests/by-util/test_sleep.rs
+++ b/tests/by-util/test_sleep.rs
@@ -1,5 +1,7 @@
+use rstest::rstest;
+
 // spell-checker:ignore dont
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 use std::time::{Duration, Instant};
 
@@ -8,11 +10,11 @@ fn test_invalid_time_interval() {
     new_ucmd!()
         .arg("xyz")
         .fails()
-        .usage_error("invalid time interval 'xyz'");
+        .usage_error("invalid time interval 'xyz': Invalid input: 'xyz' at position 1");
     new_ucmd!()
         .args(&["--", "-1"])
         .fails()
-        .usage_error("invalid time interval '-1'");
+        .usage_error("invalid time interval '-1': Number was negative");
 }
 
 #[test]
@@ -129,29 +131,98 @@ fn test_sleep_wrong_time() {
     new_ucmd!().args(&["0.1s", "abc"]).fails();
 }
 
-// TODO These tests would obviously block for a very long time. We
-// only want to verify that there is no error here, so we could just
-// figure out a way to terminate the child process after a short
-// period of time.
+#[test]
+fn test_sleep_when_single_input_exceeds_max_duration_then_no_error() {
+    let mut child = new_ucmd!()
+        .arg(format!("{}", u64::MAX as u128 + 1))
+        .timeout(Duration::from_secs(10))
+        .run_no_wait();
 
-// #[test]
-#[allow(dead_code)]
-fn test_dont_overflow() {
-    new_ucmd!()
-        .arg("9223372036854775808d")
-        .succeeds()
-        .no_stderr()
-        .no_stdout();
+    #[cfg(unix)]
+    child
+        .delay(100)
+        .kill()
+        .make_assertion()
+        .with_current_output()
+        .signal_is(9) // make sure it was us who terminated the process
+        .no_output();
+    #[cfg(windows)]
+    child
+        .delay(100)
+        .kill()
+        .make_assertion()
+        .with_current_output()
+        .failure()
+        .no_output();
 }
 
-// #[test]
-#[allow(dead_code)]
-fn test_sum_overflow() {
+#[test]
+fn test_sleep_when_multiple_inputs_exceed_max_duration_then_no_error() {
+    let mut child = new_ucmd!()
+        .arg(format!("{}", u64::MAX))
+        .arg("1")
+        .timeout(Duration::from_secs(10))
+        .run_no_wait();
+
+    #[cfg(unix)]
+    child
+        .delay(100)
+        .kill()
+        .make_assertion()
+        .with_current_output()
+        .signal_is(9) // make sure it was us who terminated the process
+        .no_output();
+    #[cfg(windows)]
+    child
+        .delay(100)
+        .kill()
+        .make_assertion()
+        .with_current_output()
+        .failure()
+        .no_output();
+}
+
+#[rstest]
+#[case::whitespace_prefix(" 0.1s")]
+#[case::multiple_whitespace_prefix("   0.1s")]
+#[case::whitespace_suffix("0.1s ")]
+#[case::mixed_newlines_spaces_tabs("\n\t0.1s \n ")]
+fn test_sleep_when_input_has_whitespace_then_no_error(#[case] input: &str) {
     new_ucmd!()
-        .args(&["100000000000000d", "100000000000000d", "100000000000000d"])
+        .arg(input)
+        .timeout(Duration::from_secs(10))
         .succeeds()
-        .no_stderr()
-        .no_stdout();
+        .no_output();
+}
+
+#[rstest]
+#[case::only_space(" ")]
+#[case::only_tab("\t")]
+#[case::only_newline("\n")]
+fn test_sleep_when_input_has_only_whitespace_then_error(#[case] input: &str) {
+    new_ucmd!()
+        .arg(input)
+        .timeout(Duration::from_secs(10))
+        .fails()
+        .usage_error(format!(
+            "invalid time interval '{input}': Found only whitespace in input"
+        ));
+}
+
+#[test]
+fn test_sleep_when_multiple_input_some_with_error_then_shows_all_errors() {
+    let expected = "invalid time interval 'abc': Invalid input: 'abc' at position 1\n\
+        sleep: invalid time interval '1years': Invalid time unit: 'years' at position 2\n\
+        sleep: invalid time interval ' ': Found only whitespace in input";
+
+    // Even if one of the arguments is valid, but the rest isn't, we should still fail and exit early.
+    // So, the timeout of 10 seconds ensures we haven't executed `thread::sleep` with the only valid
+    // interval of `100000.0` seconds.
+    new_ucmd!()
+        .args(&["abc", "100000.0", "1years", " "])
+        .timeout(Duration::from_secs(10))
+        .fails()
+        .usage_error(expected);
 }
 
 #[test]
@@ -159,5 +230,5 @@ fn test_negative_interval() {
     new_ucmd!()
         .args(&["--", "-1"])
         .fails()
-        .usage_error("invalid time interval '-1'");
+        .usage_error("invalid time interval '-1': Number was negative");
 }
diff --git a/tests/by-util/test_sort.rs b/tests/by-util/test_sort.rs
index 174ac255c..e66a405ab 100644
--- a/tests/by-util/test_sort.rs
+++ b/tests/by-util/test_sort.rs
@@ -7,7 +7,7 @@
 
 use std::time::Duration;
 
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 fn test_helper(file_name: &str, possible_args: &[&str]) {
     for args in possible_args {
@@ -32,7 +32,6 @@ fn test_buffer_sizes() {
     for buffer_size in &buffer_sizes {
         TestScenario::new(util_name!())
             .ucmd()
-            .keep_env()
             .arg("-n")
             .arg("-S")
             .arg(buffer_size)
@@ -46,7 +45,6 @@ fn test_buffer_sizes() {
             for buffer_size in &buffer_sizes {
                 TestScenario::new(util_name!())
                     .ucmd()
-                    .keep_env()
                     .arg("-n")
                     .arg("-S")
                     .arg(buffer_size)
@@ -917,11 +915,11 @@ fn test_compress_merge() {
 }
 
 #[test]
+#[cfg(not(target_os = "android"))]
 fn test_compress_fail() {
     #[cfg(not(windows))]
     TestScenario::new(util_name!())
         .ucmd()
-        .keep_env()
         .args(&[
             "ext_sort.txt",
             "-n",
@@ -938,7 +936,6 @@ fn test_compress_fail() {
     #[cfg(windows)]
     TestScenario::new(util_name!())
         .ucmd()
-        .keep_env()
         .args(&[
             "ext_sort.txt",
             "-n",
@@ -954,7 +951,6 @@ fn test_compress_fail() {
 fn test_merge_batches() {
     TestScenario::new(util_name!())
         .ucmd()
-        .keep_env()
         .timeout(Duration::from_secs(120))
         .args(&["ext_sort.txt", "-n", "-S", "150b"])
         .succeeds()
@@ -965,7 +961,6 @@ fn test_merge_batches() {
 fn test_merge_batch_size() {
     TestScenario::new(util_name!())
         .ucmd()
-        .keep_env()
         .arg("--batch-size=2")
         .arg("-m")
         .arg("--unique")
@@ -999,7 +994,7 @@ fn test_conflict_check_out() {
             .fails()
             .stderr_contains(
                 // the rest of the message might be subject to change
-                "error: The argument",
+                "error: the argument",
             );
     }
 }
@@ -1074,7 +1069,6 @@ fn test_output_is_input() {
     at.append("file", input);
     scene
         .ucmd()
-        .keep_env()
         .args(&["-m", "-u", "-o", "file", "file", "file", "file"])
         .succeeds();
     assert_eq!(at.read("file"), input);
@@ -1133,7 +1127,7 @@ fn test_tmp_files_deleted_on_sigint() {
         for _ in 0..40 {
             let lines = rand_pcg::Pcg32::seed_from_u64(123)
                 .sample_iter(rand::distributions::uniform::Uniform::new(0, 10000))
-                .take(100000)
+                .take(100_000)
                 .map(|x| x.to_string() + "\n")
                 .collect::<String>();
             file.write_all(lines.as_bytes()).unwrap();
diff --git a/tests/by-util/test_split.rs b/tests/by-util/test_split.rs
index a682b1b8c..1395a4fa2 100644
--- a/tests/by-util/test_split.rs
+++ b/tests/by-util/test_split.rs
@@ -3,13 +3,10 @@
 //  * For the full copyright and license information, please view the LICENSE
 //  * file that was distributed with this source code.
 // spell-checker:ignore xzaaa sixhundredfiftyonebytes ninetyonebytes threebytes asciilowercase fghij klmno pqrst uvwxyz fivelines twohundredfortyonebytes onehundredlines nbbbb
-extern crate rand;
-extern crate regex;
 
-use self::rand::{thread_rng, Rng};
-use self::regex::Regex;
-use crate::common::util::*;
-use rand::SeedableRng;
+use crate::common::util::{AtPath, TestScenario};
+use rand::{thread_rng, Rng, SeedableRng};
+use regex::Regex;
 #[cfg(not(windows))]
 use std::env;
 use std::path::Path;
diff --git a/tests/by-util/test_stat.rs b/tests/by-util/test_stat.rs
index b404ef28e..2527dc7cd 100644
--- a/tests/by-util/test_stat.rs
+++ b/tests/by-util/test_stat.rs
@@ -3,9 +3,7 @@
 //  * For the full copyright and license information, please view the LICENSE
 //  * file that was distributed with this source code.
 
-extern crate regex;
-
-use crate::common::util::*;
+use crate::common::util::{expected_result, TestScenario};
 
 #[test]
 fn test_invalid_arg() {
diff --git a/tests/by-util/test_stdbuf.rs b/tests/by-util/test_stdbuf.rs
index b4aa64040..334715706 100644
--- a/tests/by-util/test_stdbuf.rs
+++ b/tests/by-util/test_stdbuf.rs
@@ -1,5 +1,5 @@
 #[cfg(not(target_os = "windows"))]
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[cfg(not(target_os = "windows"))]
 #[test]
@@ -30,7 +30,7 @@ fn test_stdbuf_no_buffer_option_fails() {
     ts.ucmd()
         .args(&["head"])
         .fails()
-        .stderr_contains("The following required arguments were not provided:");
+        .stderr_contains("the following required arguments were not provided:");
 }
 
 #[cfg(not(target_os = "windows"))]
diff --git a/tests/by-util/test_stty.rs b/tests/by-util/test_stty.rs
index d15052591..e85c11082 100644
--- a/tests/by-util/test_stty.rs
+++ b/tests/by-util/test_stty.rs
@@ -1,6 +1,6 @@
 // spell-checker:ignore parenb parmrk ixany iuclc onlcr ofdel icanon noflsh
 
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
diff --git a/tests/by-util/test_sum.rs b/tests/by-util/test_sum.rs
index 37451c5ce..0a43a3043 100644
--- a/tests/by-util/test_sum.rs
+++ b/tests/by-util/test_sum.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
diff --git a/tests/by-util/test_sync.rs b/tests/by-util/test_sync.rs
index 4bf2629c4..d55a874ba 100644
--- a/tests/by-util/test_sync.rs
+++ b/tests/by-util/test_sync.rs
@@ -1,5 +1,4 @@
-use crate::common::util::*;
-extern crate tempfile;
+use crate::common::util::TestScenario;
 use std::fs;
 use tempfile::tempdir;
 
diff --git a/tests/by-util/test_tac.rs b/tests/by-util/test_tac.rs
index 72fc185b9..cc98ec616 100644
--- a/tests/by-util/test_tac.rs
+++ b/tests/by-util/test_tac.rs
@@ -1,5 +1,5 @@
 // spell-checker:ignore axxbxx bxxaxx axxx axxxx xxaxx xxax xxxxa axyz zyax zyxa
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
diff --git a/tests/by-util/test_tail.rs b/tests/by-util/test_tail.rs
index b2ec0e7bd..b7740f614 100644
--- a/tests/by-util/test_tail.rs
+++ b/tests/by-util/test_tail.rs
@@ -7,10 +7,12 @@
 // spell-checker:ignore (libs) kqueue
 // spell-checker:ignore (jargon) tailable untailable datasame runneradmin tmpi
 
-extern crate tail;
-
-use crate::common::random::*;
-use crate::common::util::*;
+use crate::common::random::{AlphanumericNewline, RandomString};
+#[cfg(unix)]
+use crate::common::util::expected_result;
+#[cfg(not(windows))]
+use crate::common::util::is_ci;
+use crate::common::util::TestScenario;
 use pretty_assertions::assert_eq;
 use rand::distributions::Alphanumeric;
 use rstest::rstest;
@@ -34,19 +36,26 @@ use tail::chunks::BUFFER_SIZE as CHUNK_BUFFER_SIZE;
 ))]
 use tail::text;
 
-static FOOBAR_TXT: &str = "foobar.txt";
-static FOOBAR_2_TXT: &str = "foobar2.txt";
-static FOOBAR_WITH_NULL_TXT: &str = "foobar_with_null.txt";
+const FOOBAR_TXT: &str = "foobar.txt";
+const FOOBAR_2_TXT: &str = "foobar2.txt";
+const FOOBAR_WITH_NULL_TXT: &str = "foobar_with_null.txt";
 #[allow(dead_code)]
-static FOLLOW_NAME_TXT: &str = "follow_name.txt";
+const FOLLOW_NAME_TXT: &str = "follow_name.txt";
 #[allow(dead_code)]
-static FOLLOW_NAME_SHORT_EXP: &str = "follow_name_short.expected";
+const FOLLOW_NAME_SHORT_EXP: &str = "follow_name_short.expected";
 #[allow(dead_code)]
-static FOLLOW_NAME_EXP: &str = "follow_name.expected";
+const FOLLOW_NAME_EXP: &str = "follow_name.expected";
 
 #[cfg(not(windows))]
 const DEFAULT_SLEEP_INTERVAL_MILLIS: u64 = 1000;
 
+// The binary integer "10000000" is *not* a valid UTF-8 encoding
+// of a character: https://en.wikipedia.org/wiki/UTF-8#Encoding
+#[cfg(unix)]
+const INVALID_UTF8: u8 = 0x80;
+#[cfg(windows)]
+const INVALID_UTF16: u16 = 0xD800;
+
 #[test]
 fn test_invalid_arg() {
     new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
@@ -469,16 +478,13 @@ fn test_follow_non_utf8_bytes() {
 
     // Now append some bytes that are not valid UTF-8.
     //
-    // The binary integer "10000000" is *not* a valid UTF-8 encoding
-    // of a character: https://en.wikipedia.org/wiki/UTF-8#Encoding
-    //
     // We also write the newline character because our implementation
     // of `tail` is attempting to read a line of input, so the
     // presence of a newline character will force the `follow()`
     // function to conclude reading input bytes and start writing them
     // to output. The newline character is not fundamental to this
     // test, it is just a requirement of the current implementation.
-    let expected = [0b10000000, b'\n'];
+    let expected = [INVALID_UTF8, b'\n'];
     at.append_bytes(FOOBAR_TXT, &expected);
 
     child
@@ -1530,6 +1536,7 @@ fn test_retry8() {
 #[test]
 #[cfg(all(
     not(target_vendor = "apple"),
+    not(target_os = "android"),
     not(target_os = "windows"),
     not(target_os = "freebsd")
 ))] // FIXME: for currently not working platforms
@@ -1610,6 +1617,7 @@ fn test_retry9() {
 #[test]
 #[cfg(all(
     not(target_vendor = "apple"),
+    not(target_os = "android"),
     not(target_os = "windows"),
     not(target_os = "freebsd")
 ))] // FIXME: for currently not working platforms
@@ -1672,6 +1680,7 @@ fn test_follow_descriptor_vs_rename1() {
 #[test]
 #[cfg(all(
     not(target_vendor = "apple"),
+    not(target_os = "android"),
     not(target_os = "windows"),
     not(target_os = "freebsd")
 ))] // FIXME: for currently not working platforms
@@ -2112,6 +2121,7 @@ fn test_follow_name_move_create1() {
 #[test]
 #[cfg(all(
     not(target_vendor = "apple"),
+    not(target_os = "android"),
     not(target_os = "windows"),
     not(target_os = "freebsd")
 ))] // FIXME: for currently not working platforms
@@ -4352,14 +4362,7 @@ fn test_follow_when_file_and_symlink_are_pointing_to_same_file_and_append_data()
         .stdout_only(expected_stdout);
 }
 
-// Fails with:
-// 'Assertion failed. Expected 'tail' to be running but exited with status=exit status: 1.
-// stdout:
-// stderr: tail: warning: --retry ignored; --retry is useful only when following
-// tail: error reading 'dir': Is a directory
-// '
 #[test]
-#[cfg(disabled_until_fixed)]
 fn test_args_when_directory_given_shorthand_big_f_together_with_retry() {
     let scene = TestScenario::new(util_name!());
     let fixtures = &scene.fixtures;
@@ -4371,9 +4374,17 @@ fn test_args_when_directory_given_shorthand_big_f_together_with_retry() {
          tail: {0}: cannot follow end of this type of file\n",
         dirname
     );
-
     let mut child = scene.ucmd().args(&["-F", "--retry", "dir"]).run_no_wait();
 
+    child.make_assertion_with_delay(500).is_alive();
+    child
+        .kill()
+        .make_assertion()
+        .with_current_output()
+        .stderr_only(&expected_stderr);
+
+    let mut child = scene.ucmd().args(&["--retry", "-F", "dir"]).run_no_wait();
+
     child.make_assertion_with_delay(500).is_alive();
     child
         .kill()
@@ -4455,7 +4466,7 @@ fn test_follow_when_files_are_pointing_to_same_relative_file_and_file_stays_same
 }
 
 #[rstest]
-#[case::exponent_exceed_float_max("1.0e2048")]
+#[case::exponent_exceed_float_max("1.0e100000")]
 #[case::underscore_delimiter("1_000")]
 #[case::only_point(".")]
 #[case::space_in_primes("' '")]
@@ -4475,3 +4486,319 @@ fn test_args_sleep_interval_when_illegal_argument_then_usage_error(#[case] sleep
         .usage_error(format!("invalid number of seconds: '{sleep_interval}'"))
         .code_is(1);
 }
+
+#[test]
+fn test_gnu_args_plus_c() {
+    let scene = TestScenario::new(util_name!());
+
+    // obs-plus-c1
+    scene
+        .ucmd()
+        .arg("+2c")
+        .pipe_in("abcd")
+        .succeeds()
+        .stdout_only("bcd");
+    // obs-plus-c2
+    scene
+        .ucmd()
+        .arg("+8c")
+        .pipe_in("abcd")
+        .succeeds()
+        .stdout_only("");
+    // obs-plus-x1: same as +10c
+    scene
+        .ucmd()
+        .arg("+c")
+        .pipe_in(format!("x{}z", "y".repeat(10)))
+        .succeeds()
+        .stdout_only("yyz");
+}
+
+#[test]
+fn test_gnu_args_c() {
+    let scene = TestScenario::new(util_name!());
+
+    // obs-c3
+    scene
+        .ucmd()
+        .arg("-1c")
+        .pipe_in("abcd")
+        .succeeds()
+        .stdout_only("d");
+    // obs-c4
+    scene
+        .ucmd()
+        .arg("-9c")
+        .pipe_in("abcd")
+        .succeeds()
+        .stdout_only("abcd");
+    // obs-c5
+    scene
+        .ucmd()
+        .arg("-12c")
+        .pipe_in(format!("x{}z", "y".repeat(12)))
+        .succeeds()
+        .stdout_only(&format!("{}z", "y".repeat(11)));
+}
+
+#[test]
+fn test_gnu_args_l() {
+    let scene = TestScenario::new(util_name!());
+
+    // obs-l1
+    scene
+        .ucmd()
+        .arg("-1l")
+        .pipe_in("x")
+        .succeeds()
+        .stdout_only("x");
+    // obs-l2
+    scene
+        .ucmd()
+        .arg("-1l")
+        .pipe_in("x\ny\n")
+        .succeeds()
+        .stdout_only("y\n");
+    // obs-l3
+    scene
+        .ucmd()
+        .arg("-1l")
+        .pipe_in("x\ny")
+        .succeeds()
+        .stdout_only("y");
+    // obs-l: same as -10l
+    scene
+        .ucmd()
+        .arg("-l")
+        .pipe_in(format!("x{}z", "y\n".repeat(10)))
+        .succeeds()
+        .stdout_only(&format!("{}z", "y\n".repeat(9)));
+}
+
+#[test]
+fn test_gnu_args_plus_l() {
+    let scene = TestScenario::new(util_name!());
+
+    // obs-plus-l4
+    scene
+        .ucmd()
+        .arg("+1l")
+        .pipe_in("x\ny\n")
+        .succeeds()
+        .stdout_only("x\ny\n");
+    // ops-plus-l5
+    scene
+        .ucmd()
+        .arg("+2l")
+        .pipe_in("x\ny\n")
+        .succeeds()
+        .stdout_only("y\n");
+    // obs-plus-x2: same as +10l
+    scene
+        .ucmd()
+        .arg("+l")
+        .pipe_in(format!("x\n{}z", "y\n".repeat(10)))
+        .succeeds()
+        .stdout_only("y\ny\nz");
+}
+
+#[test]
+fn test_gnu_args_number() {
+    let scene = TestScenario::new(util_name!());
+
+    // obs-1
+    scene
+        .ucmd()
+        .arg("-1")
+        .pipe_in("x")
+        .succeeds()
+        .stdout_only("x");
+    // obs-2
+    scene
+        .ucmd()
+        .arg("-1")
+        .pipe_in("x\ny\n")
+        .succeeds()
+        .stdout_only("y\n");
+    // obs-3
+    scene
+        .ucmd()
+        .arg("-1")
+        .pipe_in("x\ny")
+        .succeeds()
+        .stdout_only("y");
+}
+
+#[test]
+fn test_gnu_args_plus_number() {
+    let scene = TestScenario::new(util_name!());
+
+    // obs-plus-4
+    scene
+        .ucmd()
+        .arg("+1")
+        .pipe_in("x\ny\n")
+        .succeeds()
+        .stdout_only("x\ny\n");
+    // ops-plus-5
+    scene
+        .ucmd()
+        .arg("+2")
+        .pipe_in("x\ny\n")
+        .succeeds()
+        .stdout_only("y\n");
+}
+
+#[test]
+fn test_gnu_args_b() {
+    let scene = TestScenario::new(util_name!());
+
+    // obs-b
+    scene
+        .ucmd()
+        .arg("-b")
+        .pipe_in("x\n".repeat(512 * 10 / 2 + 1))
+        .succeeds()
+        .stdout_only(&"x\n".repeat(512 * 10 / 2));
+}
+
+#[test]
+fn test_gnu_args_err() {
+    let scene = TestScenario::new(util_name!());
+
+    // err-1
+    scene
+        .ucmd()
+        .arg("+cl")
+        .fails()
+        .no_stdout()
+        .stderr_is("tail: cannot open '+cl' for reading: No such file or directory\n")
+        .code_is(1);
+    // err-2
+    scene
+        .ucmd()
+        .arg("-cl")
+        .fails()
+        .no_stdout()
+        .stderr_is("tail: invalid number of bytes: 'l'\n")
+        .code_is(1);
+    // err-3
+    scene
+        .ucmd()
+        .arg("+2cz")
+        .fails()
+        .no_stdout()
+        .stderr_is("tail: cannot open '+2cz' for reading: No such file or directory\n")
+        .code_is(1);
+    // err-4
+    scene
+        .ucmd()
+        .arg("-2cX")
+        .fails()
+        .no_stdout()
+        .stderr_is("tail: option used in invalid context -- 2\n")
+        .code_is(1);
+    // err-5
+    scene
+        .ucmd()
+        .arg("-c99999999999999999999")
+        .fails()
+        .no_stdout()
+        .stderr_is("tail: invalid number of bytes: '99999999999999999999'\n")
+        .code_is(1);
+    // err-6
+    scene
+        .ucmd()
+        .arg("-c --")
+        .fails()
+        .no_stdout()
+        .stderr_is("tail: invalid number of bytes: '-'\n")
+        .code_is(1);
+    scene
+        .ucmd()
+        .arg("-5cz")
+        .fails()
+        .no_stdout()
+        .stderr_is("tail: option used in invalid context -- 5\n")
+        .code_is(1);
+    scene
+        .ucmd()
+        .arg("-9999999999999999999b")
+        .fails()
+        .no_stdout()
+        .stderr_is("tail: invalid number: '-9999999999999999999b'\n")
+        .code_is(1);
+    scene
+        .ucmd()
+        .arg("-999999999999999999999b")
+        .fails()
+        .no_stdout()
+        .stderr_is(
+            "tail: invalid number: '-999999999999999999999b': Numerical result out of range\n",
+        )
+        .code_is(1);
+}
+
+#[test]
+fn test_gnu_args_f() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let source = "file";
+    at.touch(source);
+    let mut p = scene.ucmd().args(&["+f", source]).run_no_wait();
+    p.make_assertion_with_delay(500).is_alive();
+    p.kill()
+        .make_assertion()
+        .with_all_output()
+        .no_stderr()
+        .no_stdout();
+
+    let mut p = scene
+        .ucmd()
+        .set_stdin(Stdio::piped())
+        .arg("+f")
+        .run_no_wait();
+    p.make_assertion_with_delay(500).is_alive();
+    p.kill()
+        .make_assertion()
+        .with_all_output()
+        .no_stderr()
+        .no_stdout();
+}
+
+#[test]
+#[cfg(unix)]
+fn test_obsolete_encoding_unix() {
+    use std::ffi::OsStr;
+    use std::os::unix::ffi::OsStrExt;
+
+    let scene = TestScenario::new(util_name!());
+    let invalid_utf8_arg = OsStr::from_bytes(&[b'-', INVALID_UTF8, b'b']);
+
+    scene
+        .ucmd()
+        .arg(invalid_utf8_arg)
+        .fails()
+        .no_stdout()
+        .stderr_is("tail: bad argument encoding: '-�b'\n")
+        .code_is(1);
+}
+
+#[test]
+#[cfg(windows)]
+fn test_obsolete_encoding_windows() {
+    use std::ffi::OsString;
+    use std::os::windows::ffi::OsStringExt;
+
+    let scene = TestScenario::new(util_name!());
+    let invalid_utf16_arg = OsString::from_wide(&['-' as u16, INVALID_UTF16, 'b' as u16]);
+
+    scene
+        .ucmd()
+        .arg(&invalid_utf16_arg)
+        .fails()
+        .no_stdout()
+        .stderr_is("tail: bad argument encoding: '-�b'\n")
+        .code_is(1);
+}
diff --git a/tests/by-util/test_tee.rs b/tests/by-util/test_tee.rs
index 5dc5a2871..51d552d67 100644
--- a/tests/by-util/test_tee.rs
+++ b/tests/by-util/test_tee.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 // tests for basic tee functionality.
 // inspired by:
@@ -108,7 +108,7 @@ fn test_tee_no_more_writeable_2() {
 
 #[cfg(target_os = "linux")]
 mod linux_only {
-    use crate::common::util::*;
+    use crate::common::util::{AtPath, TestScenario, UCommand};
 
     use std::fs::File;
     use std::process::{Output, Stdio};
@@ -118,9 +118,10 @@ mod linux_only {
         use std::os::unix::io::FromRawFd;
 
         let mut fds: [c_int; 2] = [0, 0];
-        if unsafe { libc::pipe(&mut fds as *mut c_int) } != 0 {
-            panic!("Failed to create pipe");
-        }
+        assert!(
+            (unsafe { libc::pipe(&mut fds as *mut c_int) } == 0),
+            "Failed to create pipe"
+        );
 
         // Drop the read end of the pipe
         let _ = unsafe { File::from_raw_fd(fds[0]) };
@@ -130,7 +131,7 @@ mod linux_only {
     }
 
     fn run_tee(proc: &mut UCommand) -> (String, Output) {
-        let content = (1..=100000).map(|x| format!("{x}\n")).collect::<String>();
+        let content = (1..=100_000).map(|x| format!("{x}\n")).collect::<String>();
 
         #[allow(deprecated)]
         let output = proc
diff --git a/tests/by-util/test_test.rs b/tests/by-util/test_test.rs
index b4fb1b0ce..bf5c50b7f 100644
--- a/tests/by-util/test_test.rs
+++ b/tests/by-util/test_test.rs
@@ -10,7 +10,7 @@
 
 // spell-checker:ignore (words) egid euid pseudofloat
 
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 use std::thread::sleep;
 
 #[test]
@@ -928,3 +928,16 @@ fn test_long_integer() {
         ])
         .fails();
 }
+
+#[test]
+fn test_missing_argument_after() {
+    let mut ucmd = new_ucmd!();
+
+    let result = ucmd.args(&["(", "foo"]).fails();
+    result.no_stdout();
+    assert_eq!(result.exit_status().code().unwrap(), 2);
+    assert_eq!(
+        result.stderr_str().trim(),
+        "test: missing argument after 'foo'"
+    );
+}
diff --git a/tests/by-util/test_timeout.rs b/tests/by-util/test_timeout.rs
index deedea6c7..8e6e5db55 100644
--- a/tests/by-util/test_timeout.rs
+++ b/tests/by-util/test_timeout.rs
@@ -1,5 +1,5 @@
 // spell-checker:ignore dont
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
@@ -138,3 +138,19 @@ fn test_kill_after_long() {
         .no_stdout()
         .no_stderr();
 }
+
+#[test]
+fn test_kill_subprocess() {
+    new_ucmd!()
+        .args(&[
+            // Make sure the CI can spawn the subprocess.
+            "10",
+            "sh",
+            "-c",
+            "sh -c \"trap 'echo xyz' TERM; sleep 30\"",
+        ])
+        .fails()
+        .code_is(124)
+        .stdout_contains("xyz")
+        .stderr_contains("Terminated");
+}
diff --git a/tests/by-util/test_touch.rs b/tests/by-util/test_touch.rs
index 7ae8a3905..0e4eade3d 100644
--- a/tests/by-util/test_touch.rs
+++ b/tests/by-util/test_touch.rs
@@ -6,13 +6,11 @@
 // See https://github.com/time-rs/time/issues/293#issuecomment-946382614=
 // Defined in .cargo/config
 
-extern crate touch;
-use self::touch::filetime::{self, FileTime};
+use filetime::FileTime;
 
-extern crate time;
-use time::macros::{datetime, format_description};
+use time::macros::format_description;
 
-use crate::common::util::*;
+use crate::common::util::{AtPath, TestScenario};
 use std::fs::remove_file;
 use std::path::PathBuf;
 
@@ -49,12 +47,7 @@ fn str_to_filetime(format: &str, s: &str) -> FileTime {
         _ => panic!("unexpected dt format"),
     };
     let tm = time::PrimitiveDateTime::parse(s, &format_description).unwrap();
-    let d = match time::OffsetDateTime::now_local() {
-        Ok(now) => now,
-        Err(e) => {
-            panic!("Error {e} retrieving the OffsetDateTime::now_local");
-        }
-    };
+    let d = time::OffsetDateTime::now_utc();
     let offset_dt = tm.assume_offset(d.offset());
     FileTime::from_unix_time(offset_dt.unix_timestamp(), tm.nanosecond())
 }
@@ -108,10 +101,7 @@ fn test_touch_set_mdhm_time() {
 
     let start_of_year = str_to_filetime(
         "%Y%m%d%H%M",
-        &format!(
-            "{}01010000",
-            time::OffsetDateTime::now_local().unwrap().year()
-        ),
+        &format!("{}01010000", time::OffsetDateTime::now_utc().year()),
     );
     let (atime, mtime) = get_file_times(&at, file);
     assert_eq!(atime, mtime);
@@ -259,14 +249,39 @@ fn test_touch_set_both_date_and_reference() {
     let ref_file = "test_touch_reference";
     let file = "test_touch_set_both_date_and_reference";
 
-    let start_of_year = str_to_filetime("%Y%m%d%H%M", "201501010000");
+    let start_of_year = str_to_filetime("%Y%m%d%H%M", "201501011234");
 
     at.touch(ref_file);
     set_file_times(&at, ref_file, start_of_year, start_of_year);
     assert!(at.file_exists(ref_file));
 
     ucmd.args(&["-d", "Thu Jan 01 12:34:00 2015", "-r", ref_file, file])
-        .fails();
+        .succeeds()
+        .no_stderr();
+    let (atime, mtime) = get_file_times(&at, file);
+    assert_eq!(atime, start_of_year);
+    assert_eq!(mtime, start_of_year);
+}
+
+#[test]
+fn test_touch_set_both_offset_date_and_reference() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let ref_file = "test_touch_reference";
+    let file = "test_touch_set_both_date_and_reference";
+
+    let start_of_year = str_to_filetime("%Y%m%d%H%M", "201501011234");
+    let five_days_later = str_to_filetime("%Y%m%d%H%M", "201501061234");
+
+    at.touch(ref_file);
+    set_file_times(&at, ref_file, start_of_year, start_of_year);
+    assert!(at.file_exists(ref_file));
+
+    ucmd.args(&["-d", "+5 days", "-r", ref_file, file])
+        .succeeds()
+        .no_stderr();
+    let (atime, mtime) = get_file_times(&at, file);
+    assert_eq!(atime, five_days_later);
+    assert_eq!(mtime, five_days_later);
 }
 
 #[test]
@@ -425,7 +440,7 @@ fn test_touch_set_date3() {
 
     assert!(at.file_exists(file));
 
-    let expected = FileTime::from_unix_time(1623786360, 0);
+    let expected = FileTime::from_unix_time(1_623_786_360, 0);
     let (atime, mtime) = get_file_times(&at, file);
     assert_eq!(atime, mtime);
     assert_eq!(atime, expected);
@@ -464,9 +479,9 @@ fn test_touch_set_date5() {
     // Slightly different result on Windows for nano seconds
     // TODO: investigate
     #[cfg(windows)]
-    let expected = FileTime::from_unix_time(67413, 23456700);
+    let expected = FileTime::from_unix_time(67413, 23_456_700);
     #[cfg(not(windows))]
-    let expected = FileTime::from_unix_time(67413, 23456789);
+    let expected = FileTime::from_unix_time(67413, 23_456_789);
 
     let (atime, mtime) = get_file_times(&at, file);
     assert_eq!(atime, mtime);
@@ -485,7 +500,7 @@ fn test_touch_set_date6() {
 
     assert!(at.file_exists(file));
 
-    let expected = FileTime::from_unix_time(946684800, 0);
+    let expected = FileTime::from_unix_time(946_684_800, 0);
 
     let (atime, mtime) = get_file_times(&at, file);
     assert_eq!(atime, mtime);
@@ -504,7 +519,7 @@ fn test_touch_set_date7() {
 
     assert!(at.file_exists(file));
 
-    let expected = FileTime::from_unix_time(1074254400, 0);
+    let expected = FileTime::from_unix_time(1_074_254_400, 0);
 
     let (atime, mtime) = get_file_times(&at, file);
     assert_eq!(atime, mtime);
@@ -593,7 +608,15 @@ fn test_touch_set_date_relative_smoke() {
     // > (equivalent to ‘day’), the string ‘yesterday’ is worth one day
     // > in the past (equivalent to ‘day ago’).
     //
-    let times = ["yesterday", "tomorrow", "now"];
+    let times = [
+        "yesterday",
+        "tomorrow",
+        "now",
+        "2 seconds",
+        "2 years 1 week",
+        "2 days ago",
+        "2 months and 1 second",
+    ];
     for time in times {
         let (at, mut ucmd) = at_and_ucmd!();
         at.touch("f");
@@ -602,6 +625,11 @@ fn test_touch_set_date_relative_smoke() {
             .no_stderr()
             .no_stdout();
     }
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.touch("f");
+    ucmd.args(&["-d", "a", "f"])
+        .fails()
+        .stderr_contains("touch: Unable to parse date");
 }
 
 #[test]
@@ -630,61 +658,21 @@ fn test_touch_mtime_dst_succeeds() {
     assert_eq!(target_time, mtime);
 }
 
-// // is_dst_switch_hour returns true if timespec ts is just before the switch
-// // to Daylight Saving Time.
-// // For example, in EST (UTC-5), Timespec { sec: 1583647200, nsec: 0 }
-// // for March 8 2020 01:00:00 AM
-// // is just before the switch because on that day clock jumps by 1 hour,
-// // so 1 minute after 01:59:00 is 03:00:00.
-// fn is_dst_switch_hour(ts: time::Timespec) -> bool {
-//     let ts_after = ts + time::Duration::hours(1);
-//     let tm = time::at(ts);
-//     let tm_after = time::at(ts_after);
-//     tm_after.tm_hour == tm.tm_hour + 2
-// }
-
-// get_dst_switch_hour returns date string for which touch -m -t fails.
-// For example, in EST (UTC-5), that will be "202003080200" so
-// touch -m -t 202003080200 file
-// fails (that date/time does not exist).
-// In other locales it will be a different date/time, and in some locales
-// it doesn't exist at all, in which case this function will return None.
-fn get_dst_switch_hour() -> Option<String> {
-    //let now = time::OffsetDateTime::now_local().unwrap();
-    let now = match time::OffsetDateTime::now_local() {
-        Ok(now) => now,
-        Err(e) => {
-            panic!("Error {e} retrieving the OffsetDateTime::now_local");
-        }
-    };
-
-    // Start from January 1, 2020, 00:00.
-    let tm = datetime!(2020-01-01 00:00 UTC);
-    tm.to_offset(now.offset());
-
-    // let mut ts = tm.to_timespec();
-    // // Loop through all hours in year 2020 until we find the hour just
-    // // before the switch to DST.
-    // for _i in 0..(366 * 24) {
-    //     // if is_dst_switch_hour(ts) {
-    //     //     let mut tm = time::at(ts);
-    //     //     tm.tm_hour += 1;
-    //     //     let s = time::strftime("%Y%m%d%H%M", &tm).unwrap();
-    //     //     return Some(s);
-    //     // }
-    //     ts = ts + time::Duration::hours(1);
-    // }
-    None
-}
-
 #[test]
+#[ignore = "not implemented"]
 fn test_touch_mtime_dst_fails() {
     let (_at, mut ucmd) = at_and_ucmd!();
     let file = "test_touch_set_mtime_dst_fails";
 
-    if let Some(s) = get_dst_switch_hour() {
-        ucmd.args(&["-m", "-t", &s, file]).fails();
-    }
+    // Some timezones use daylight savings time, this leads to problems if the
+    // specified time is within the jump forward. In EST (UTC-5), there is a
+    // jump from 1:59AM to 3:00AM on, March 8 2020, so any thing in-between is
+    // invalid.
+    // See https://www.gnu.org/software/libc/manual/html_node/TZ-Variable.html
+    // for information on the TZ variable, which where the string is copied from.
+    ucmd.env("TZ", "EST+5EDT,M3.2.0/2,M11.1.0/2")
+        .args(&["-m", "-t", "202003080200", file])
+        .fails();
 }
 
 #[test]
@@ -841,3 +829,27 @@ fn test_touch_trailing_slash_no_create() {
     at.relative_symlink_dir("dir2", "link2");
     ucmd.args(&["-c", "link2/"]).succeeds();
 }
+
+#[test]
+fn test_touch_no_dereference_ref_dangling() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.touch("file");
+    at.relative_symlink_file("nowhere", "dangling");
+
+    ucmd.args(&["-h", "-r", "dangling", "file"]).succeeds();
+}
+
+#[test]
+fn test_touch_no_dereference_dangling() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.relative_symlink_file("nowhere", "dangling");
+
+    ucmd.args(&["-h", "dangling"]).succeeds();
+}
+
+#[test]
+fn test_touch_dash() {
+    let (_, mut ucmd) = at_and_ucmd!();
+
+    ucmd.args(&["-h", "-"]).succeeds().no_stderr().no_stdout();
+}
diff --git a/tests/by-util/test_tr.rs b/tests/by-util/test_tr.rs
index e6daa9c48..4e437609e 100644
--- a/tests/by-util/test_tr.rs
+++ b/tests/by-util/test_tr.rs
@@ -1,5 +1,5 @@
 // spell-checker:ignore aabbaa aabbcc aabc abbb abcc abcdefabcdef abcdefghijk abcdefghijklmn abcdefghijklmnop ABCDEFGHIJKLMNOPQRS abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ ABCDEFZZ abcxyz ABCXYZ abcxyzabcxyz ABCXYZABCXYZ acbdef alnum amzamz AMZXAMZ bbbd cclass cefgm cntrl compl dabcdef dncase Gzabcdefg PQRST upcase wxyzz xdigit xycde xyyye xyyz xyzzzzxyzzzz ZABCDEF Zamz Cdefghijkl Cdefghijklmn
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
diff --git a/tests/by-util/test_true.rs b/tests/by-util/test_true.rs
index aba32578b..1675b3903 100644
--- a/tests/by-util/test_true.rs
+++ b/tests/by-util/test_true.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "netbsd"))]
 use std::fs::OpenOptions;
 
diff --git a/tests/by-util/test_truncate.rs b/tests/by-util/test_truncate.rs
index f306a32a9..7a0bac6e9 100644
--- a/tests/by-util/test_truncate.rs
+++ b/tests/by-util/test_truncate.rs
@@ -5,7 +5,7 @@
 
 // spell-checker:ignore (words) RFILE
 
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 use std::io::{Seek, SeekFrom, Write};
 
 static FILE1: &str = "truncate_test_1";
@@ -194,7 +194,7 @@ fn test_error_filename_only() {
         .args(&["file"])
         .fails()
         .code_is(1)
-        .stderr_contains("error: The following required arguments were not provided:");
+        .stderr_contains("error: the following required arguments were not provided:");
 }
 
 #[test]
diff --git a/tests/by-util/test_tsort.rs b/tests/by-util/test_tsort.rs
index e424fe651..62a74c31d 100644
--- a/tests/by-util/test_tsort.rs
+++ b/tests/by-util/test_tsort.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
@@ -20,6 +20,14 @@ fn test_sort_self_loop() {
         .stdout_only("first\nsecond\n");
 }
 
+#[test]
+fn test_sort_floating_nodes() {
+    new_ucmd!()
+        .pipe_in("d d\nc c\na a\nb b")
+        .succeeds()
+        .stdout_only("a\nb\nc\nd\n");
+}
+
 #[test]
 fn test_no_such_file() {
     new_ucmd!()
@@ -50,7 +58,5 @@ fn test_multiple_arguments() {
         .arg("call_graph.txt")
         .arg("invalid_file")
         .fails()
-        .stderr_contains(
-            "Found argument 'invalid_file' which wasn't expected, or isn't valid in this context",
-        );
+        .stderr_contains("unexpected argument 'invalid_file' found");
 }
diff --git a/tests/by-util/test_tty.rs b/tests/by-util/test_tty.rs
index 726167673..87dcbac85 100644
--- a/tests/by-util/test_tty.rs
+++ b/tests/by-util/test_tty.rs
@@ -1,6 +1,6 @@
 use std::fs::File;
 
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 #[cfg(not(windows))]
diff --git a/tests/by-util/test_uname.rs b/tests/by-util/test_uname.rs
index c446da6c5..5076334e5 100644
--- a/tests/by-util/test_uname.rs
+++ b/tests/by-util/test_uname.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
diff --git a/tests/by-util/test_unexpand.rs b/tests/by-util/test_unexpand.rs
index 1639ee1bc..c833c93e4 100644
--- a/tests/by-util/test_unexpand.rs
+++ b/tests/by-util/test_unexpand.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
diff --git a/tests/by-util/test_uniq.rs b/tests/by-util/test_uniq.rs
index 8acd15e0a..57f0ec111 100644
--- a/tests/by-util/test_uniq.rs
+++ b/tests/by-util/test_uniq.rs
@@ -1,7 +1,7 @@
 use std::io::Write;
 
 // spell-checker:ignore nabcd
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 static INPUT: &str = "sorted.txt";
 static OUTPUT: &str = "sorted-output.txt";
diff --git a/tests/by-util/test_unlink.rs b/tests/by-util/test_unlink.rs
index 36b09be7b..5313c9eab 100644
--- a/tests/by-util/test_unlink.rs
+++ b/tests/by-util/test_unlink.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
diff --git a/tests/by-util/test_uptime.rs b/tests/by-util/test_uptime.rs
index 02cba9e8f..628f4cead 100644
--- a/tests/by-util/test_uptime.rs
+++ b/tests/by-util/test_uptime.rs
@@ -1,6 +1,5 @@
-extern crate regex;
-use self::regex::Regex;
-use crate::common::util::*;
+use crate::common::util::TestScenario;
+use regex::Regex;
 
 #[test]
 fn test_invalid_arg() {
@@ -11,7 +10,6 @@ fn test_invalid_arg() {
 fn test_uptime() {
     TestScenario::new(util_name!())
         .ucmd()
-        .keep_env()
         .succeeds()
         .stdout_contains("load average:")
         .stdout_contains(" up ");
diff --git a/tests/by-util/test_users.rs b/tests/by-util/test_users.rs
index 7fadb2bb2..6a54aa8d2 100644
--- a/tests/by-util/test_users.rs
+++ b/tests/by-util/test_users.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
@@ -23,7 +23,6 @@ fn test_users_check_name() {
     #[allow(clippy::needless_borrow)]
     let expected = TestScenario::new(&util_name)
         .cmd(util_name)
-        .keep_env()
         .env("LC_ALL", "C")
         .succeeds()
         .stdout_move_str();
diff --git a/tests/by-util/test_vdir.rs b/tests/by-util/test_vdir.rs
index 0781256b9..f6498567f 100644
--- a/tests/by-util/test_vdir.rs
+++ b/tests/by-util/test_vdir.rs
@@ -1,11 +1,5 @@
-#[cfg(not(windows))]
-extern crate libc;
-extern crate regex;
-#[cfg(not(windows))]
-extern crate tempfile;
-
-use self::regex::Regex;
-use crate::common::util::*;
+use crate::common::util::TestScenario;
+use regex::Regex;
 
 /*
  * As vdir use the same functions than ls, we don't have to retest them here.
diff --git a/tests/by-util/test_wc.rs b/tests/by-util/test_wc.rs
index bbc057972..aba5ed350 100644
--- a/tests/by-util/test_wc.rs
+++ b/tests/by-util/test_wc.rs
@@ -1,4 +1,4 @@
-use crate::common::util::*;
+use crate::common::util::{vec_of_size, TestScenario};
 
 // spell-checker:ignore (flags) lwmcL clmwL ; (path) bogusfile emptyfile manyemptylines moby notrailingnewline onelongemptyline onelongword weirdchars
 
@@ -268,12 +268,16 @@ fn test_multiple_default() {
             "lorem_ipsum.txt",
             "moby_dick.txt",
             "alice_in_wonderland.txt",
+            "alice in wonderland.txt",
         ])
         .run()
-        .stdout_is(
-            "  13  109  772 lorem_ipsum.txt\n  18  204 1115 moby_dick.txt\n   5   57  302 \
-             alice_in_wonderland.txt\n  36  370 2189 total\n",
-        );
+        .stdout_is(concat!(
+            "  13  109  772 lorem_ipsum.txt\n",
+            "  18  204 1115 moby_dick.txt\n",
+            "   5   57  302 alice_in_wonderland.txt\n",
+            "   5   57  302 alice in wonderland.txt\n",
+            "  41  427 2491 total\n",
+        ));
 }
 
 /// Test for an empty file.
@@ -352,17 +356,24 @@ fn test_file_bytes_dictate_width() {
     new_ucmd!()
         .args(&["-lwc", "alice_in_wonderland.txt", "lorem_ipsum.txt"])
         .run()
-        .stdout_is(
-            "   5   57  302 alice_in_wonderland.txt\n  13  109  772 \
-                    lorem_ipsum.txt\n  18  166 1074 total\n",
-        );
+        .stdout_is(concat!(
+            "   5   57  302 alice_in_wonderland.txt\n",
+            "  13  109  772 lorem_ipsum.txt\n",
+            "  18  166 1074 total\n",
+        ));
 
     // . is a directory, so minimum_width should get set to 7
     #[cfg(not(windows))]
-    const STDOUT: &str = "      0       0       0 emptyfile.txt\n      0       0       0 \
-                          .\n      0       0       0 total\n";
+    const STDOUT: &str = concat!(
+        "      0       0       0 emptyfile.txt\n",
+        "      0       0       0 .\n",
+        "      0       0       0 total\n",
+    );
     #[cfg(windows)]
-    const STDOUT: &str = "      0       0       0 emptyfile.txt\n      0       0       0 total\n";
+    const STDOUT: &str = concat!(
+        "      0       0       0 emptyfile.txt\n",
+        "      0       0       0 total\n",
+    );
     new_ucmd!()
         .args(&["-lwc", "emptyfile.txt", "."])
         .run()
@@ -375,7 +386,7 @@ fn test_read_from_directory_error() {
     #[cfg(not(windows))]
     const STDERR: &str = ".: Is a directory";
     #[cfg(windows)]
-    const STDERR: &str = ".: Access is denied";
+    const STDERR: &str = ".: Permission denied";
 
     #[cfg(not(windows))]
     const STDOUT: &str = "      0       0       0 .\n";
@@ -392,15 +403,10 @@ fn test_read_from_directory_error() {
 /// Test that getting counts from nonexistent file is an error.
 #[test]
 fn test_read_from_nonexistent_file() {
-    #[cfg(not(windows))]
-    const MSG: &str = "bogusfile: No such file or directory";
-    #[cfg(windows)]
-    const MSG: &str = "bogusfile: The system cannot find the file specified";
     new_ucmd!()
         .args(&["bogusfile"])
         .fails()
-        .stderr_contains(MSG)
-        .stdout_is("");
+        .stderr_only("wc: bogusfile: No such file or directory\n");
 }
 
 #[test]
@@ -424,13 +430,30 @@ fn test_files0_disabled_files_argument() {
 
 #[test]
 fn test_files0_from() {
+    // file
     new_ucmd!()
         .args(&["--files0-from=files0_list.txt"])
         .run()
-        .stdout_is(
-            "  13  109  772 lorem_ipsum.txt\n  18  204 1115 moby_dick.txt\n   5   57  302 \
-             alice_in_wonderland.txt\n  36  370 2189 total\n",
-        );
+        .success()
+        .stdout_is(concat!(
+            "  13  109  772 lorem_ipsum.txt\n",
+            "  18  204 1115 moby_dick.txt\n",
+            "   5   57  302 alice_in_wonderland.txt\n",
+            "  36  370 2189 total\n",
+        ));
+
+    // stream
+    new_ucmd!()
+        .args(&["--files0-from=-"])
+        .pipe_in_fixture("files0_list.txt")
+        .run()
+        .success()
+        .stdout_is(concat!(
+            "13 109 772 lorem_ipsum.txt\n",
+            "18 204 1115 moby_dick.txt\n",
+            "5 57 302 alice_in_wonderland.txt\n",
+            "36 370 2189 total\n",
+        ));
 }
 
 #[test]
@@ -439,7 +462,7 @@ fn test_files0_from_with_stdin() {
         .args(&["--files0-from=-"])
         .pipe_in("lorem_ipsum.txt")
         .run()
-        .stdout_is(" 13 109 772 lorem_ipsum.txt\n");
+        .stdout_is("13 109 772 lorem_ipsum.txt\n");
 }
 
 #[test]
@@ -448,10 +471,12 @@ fn test_files0_from_with_stdin_in_file() {
         .args(&["--files0-from=files0_list_with_stdin.txt"])
         .pipe_in_fixture("alice_in_wonderland.txt")
         .run()
-        .stdout_is(
-            "     13     109     772 lorem_ipsum.txt\n     18     204    1115 moby_dick.txt\n      5      57     302 \
-             -\n     36     370    2189 total\n",
-        );
+        .stdout_is(concat!(
+            "     13     109     772 lorem_ipsum.txt\n",
+            "     18     204    1115 moby_dick.txt\n",
+            "      5      57     302 -\n", // alice_in_wonderland.txt
+            "     36     370    2189 total\n",
+        ));
 }
 
 #[test]
@@ -464,3 +489,218 @@ fn test_files0_from_with_stdin_try_read_from_stdin() {
         .stderr_contains(MSG)
         .stdout_is("");
 }
+
+#[test]
+fn test_total_auto() {
+    new_ucmd!()
+        .args(&["lorem_ipsum.txt", "--total=auto"])
+        .run()
+        .stdout_is(" 13 109 772 lorem_ipsum.txt\n");
+
+    new_ucmd!()
+        .args(&["lorem_ipsum.txt", "moby_dick.txt", "--total=auto"])
+        .run()
+        .stdout_is(concat!(
+            "  13  109  772 lorem_ipsum.txt\n",
+            "  18  204 1115 moby_dick.txt\n",
+            "  31  313 1887 total\n",
+        ));
+}
+
+#[test]
+fn test_total_always() {
+    new_ucmd!()
+        .args(&["lorem_ipsum.txt", "--total=always"])
+        .run()
+        .stdout_is(concat!(
+            " 13 109 772 lorem_ipsum.txt\n",
+            " 13 109 772 total\n",
+        ));
+
+    new_ucmd!()
+        .args(&["lorem_ipsum.txt", "moby_dick.txt", "--total=always"])
+        .run()
+        .stdout_is(concat!(
+            "  13  109  772 lorem_ipsum.txt\n",
+            "  18  204 1115 moby_dick.txt\n",
+            "  31  313 1887 total\n",
+        ));
+}
+
+#[test]
+fn test_total_never() {
+    new_ucmd!()
+        .args(&["lorem_ipsum.txt", "--total=never"])
+        .run()
+        .stdout_is(" 13 109 772 lorem_ipsum.txt\n");
+
+    new_ucmd!()
+        .args(&["lorem_ipsum.txt", "moby_dick.txt", "--total=never"])
+        .run()
+        .stdout_is(concat!(
+            "  13  109  772 lorem_ipsum.txt\n",
+            "  18  204 1115 moby_dick.txt\n",
+        ));
+}
+
+#[test]
+fn test_total_only() {
+    new_ucmd!()
+        .args(&["lorem_ipsum.txt", "--total=only"])
+        .run()
+        .stdout_is("13 109 772\n");
+
+    new_ucmd!()
+        .args(&["lorem_ipsum.txt", "moby_dick.txt", "--total=only"])
+        .run()
+        .stdout_is("31 313 1887\n");
+}
+
+#[test]
+fn test_zero_length_files() {
+    // A trailing zero is ignored, but otherwise empty file names are an error...
+    const LIST: &str = "\0moby_dick.txt\0\0alice_in_wonderland.txt\0\0lorem_ipsum.txt\0";
+
+    // Try with and without the last \0
+    for l in [LIST.len(), LIST.len() - 1] {
+        new_ucmd!()
+            .args(&["--files0-from=-"])
+            .pipe_in(&LIST[..l])
+            .run()
+            .failure()
+            .stdout_is(concat!(
+                "18 204 1115 moby_dick.txt\n",
+                "5 57 302 alice_in_wonderland.txt\n",
+                "13 109 772 lorem_ipsum.txt\n",
+                "36 370 2189 total\n",
+            ))
+            .stderr_is(concat!(
+                "wc: -:1: invalid zero-length file name\n",
+                "wc: -:3: invalid zero-length file name\n",
+                "wc: -:5: invalid zero-length file name\n",
+            ));
+    }
+
+    // But, just as important, a zero-length file name may still be at the end...
+    new_ucmd!()
+        .args(&["--files0-from=-"])
+        .pipe_in(
+            LIST.as_bytes()
+                .iter()
+                .chain(b"\0")
+                .copied()
+                .collect::<Vec<_>>(),
+        )
+        .run()
+        .failure()
+        .stdout_is(concat!(
+            "18 204 1115 moby_dick.txt\n",
+            "5 57 302 alice_in_wonderland.txt\n",
+            "13 109 772 lorem_ipsum.txt\n",
+            "36 370 2189 total\n",
+        ))
+        .stderr_is(concat!(
+            "wc: -:1: invalid zero-length file name\n",
+            "wc: -:3: invalid zero-length file name\n",
+            "wc: -:5: invalid zero-length file name\n",
+            "wc: -:7: invalid zero-length file name\n",
+        ));
+}
+
+#[test]
+fn test_files0_errors_quoting() {
+    new_ucmd!()
+        .args(&["--files0-from=files0 with nonexistent.txt"])
+        .run()
+        .failure()
+        .stderr_is(concat!(
+            "wc: this_file_does_not_exist.txt: No such file or directory\n",
+            "wc: 'files0 with nonexistent.txt':2: invalid zero-length file name\n",
+            "wc: 'this file does not exist.txt': No such file or directory\n",
+            "wc: \"this files doesn't exist either.txt\": No such file or directory\n",
+        ))
+        .stdout_is("0 0 0 total\n");
+}
+
+#[test]
+fn test_files0_progressive_stream() {
+    use std::process::Stdio;
+    // You should be able to run wc and have a back-and-forth exchange with wc...
+    let mut child = new_ucmd!()
+        .args(&["--files0-from=-"])
+        .set_stdin(Stdio::piped())
+        .set_stdout(Stdio::piped())
+        .set_stderr(Stdio::piped())
+        .run_no_wait();
+
+    macro_rules! chk {
+        ($fn:ident, $exp:literal) => {
+            assert_eq!(child.$fn($exp.len()), $exp.as_bytes());
+        };
+    }
+
+    // File in, count out...
+    child.write_in("moby_dick.txt\0");
+    chk!(stdout_exact_bytes, "18 204 1115 moby_dick.txt\n");
+    child.write_in("lorem_ipsum.txt\0");
+    chk!(stdout_exact_bytes, "13 109 772 lorem_ipsum.txt\n");
+
+    // Introduce an error!
+    child.write_in("\0");
+    chk!(
+        stderr_exact_bytes,
+        "wc: -:3: invalid zero-length file name\n"
+    );
+
+    // wc is quick to forgive, let's move on...
+    child.write_in("alice_in_wonderland.txt\0");
+    chk!(stdout_exact_bytes, "5 57 302 alice_in_wonderland.txt\n");
+
+    // Fin.
+    child
+        .wait()
+        .expect("wc should finish")
+        .failure()
+        .stdout_only("36 370 2189 total\n");
+}
+
+#[test]
+fn files0_from_dir() {
+    // On Unix, `read(open("."))` fails. On Windows, `open(".")` fails. Thus, the errors happen in
+    // different contexts.
+    #[cfg(not(windows))]
+    macro_rules! dir_err {
+        ($p:literal) => {
+            concat!("wc: ", $p, ": read error: Is a directory\n")
+        };
+    }
+    #[cfg(windows)]
+    macro_rules! dir_err {
+        ($p:literal) => {
+            concat!("wc: cannot open ", $p, " for reading: Permission denied\n")
+        };
+    }
+
+    new_ucmd!()
+        .args(&["--files0-from=dir with spaces"])
+        .fails()
+        .stderr_only(dir_err!("'dir with spaces'"));
+
+    // Those contexts have different rules about quoting in errors...
+    #[cfg(windows)]
+    const DOT_ERR: &str = dir_err!("'.'");
+    #[cfg(not(windows))]
+    const DOT_ERR: &str = dir_err!(".");
+    new_ucmd!()
+        .args(&["--files0-from=."])
+        .fails()
+        .stderr_only(DOT_ERR);
+
+    // That also means you cannot `< . wc --files0-from=-` on Windows.
+    #[cfg(not(windows))]
+    new_ucmd!()
+        .args(&["--files0-from=-"])
+        .set_stdin(std::fs::File::open(".").unwrap())
+        .fails()
+        .stderr_only(dir_err!("-"));
+}
diff --git a/tests/by-util/test_who.rs b/tests/by-util/test_who.rs
index 6f98c8b9d..31b46c3bf 100644
--- a/tests/by-util/test_who.rs
+++ b/tests/by-util/test_who.rs
@@ -5,7 +5,7 @@
 
 // spell-checker:ignore (flags) runlevel mesg
 
-use crate::common::util::*;
+use crate::common::util::{expected_result, TestScenario};
 
 #[test]
 fn test_invalid_arg() {
@@ -151,7 +151,7 @@ fn test_arg1_arg2() {
 #[test]
 fn test_too_many_args() {
     const EXPECTED: &str =
-        "error: The value 'u' was provided to '[FILE]...' but it wasn't expecting any more values";
+        "error: unexpected value 'u' for '[FILE]...' found; no more were expected";
 
     let args = ["am", "i", "u"];
     new_ucmd!().args(&args).fails().stderr_contains(EXPECTED);
diff --git a/tests/by-util/test_whoami.rs b/tests/by-util/test_whoami.rs
index 044f27c57..9e6c35be6 100644
--- a/tests/by-util/test_whoami.rs
+++ b/tests/by-util/test_whoami.rs
@@ -3,7 +3,9 @@
 //  * For the full copyright and license information, please view the LICENSE
 //  * file that was distributed with this source code.
 
-use crate::common::util::*;
+#[cfg(unix)]
+use crate::common::util::expected_result;
+use crate::common::util::{is_ci, whoami, TestScenario};
 
 #[test]
 fn test_invalid_arg() {
@@ -48,3 +50,8 @@ fn test_normal_compare_env() {
         println!("test skipped:");
     }
 }
+
+#[test]
+fn test_succeeds_on_all_platforms() {
+    new_ucmd!().succeeds().no_stderr();
+}
diff --git a/tests/by-util/test_yes.rs b/tests/by-util/test_yes.rs
index 41bf3e8d9..89a68e7e1 100644
--- a/tests/by-util/test_yes.rs
+++ b/tests/by-util/test_yes.rs
@@ -1,29 +1,32 @@
+use std::ffi::OsStr;
 use std::process::{ExitStatus, Stdio};
 
 #[cfg(unix)]
 use std::os::unix::process::ExitStatusExt;
 
-use crate::common::util::*;
+use crate::common::util::TestScenario;
 
 #[cfg(unix)]
-fn check_termination(result: &ExitStatus) {
+fn check_termination(result: ExitStatus) {
     assert_eq!(result.signal(), Some(libc::SIGPIPE));
 }
 
 #[cfg(not(unix))]
-fn check_termination(result: &ExitStatus) {
+fn check_termination(result: ExitStatus) {
     assert!(result.success(), "yes did not exit successfully");
 }
 
+const NO_ARGS: &[&str] = &[];
+
 /// Run `yes`, capture some of the output, close the pipe, and verify it.
-fn run(args: &[&str], expected: &[u8]) {
+fn run(args: &[impl AsRef<OsStr>], expected: &[u8]) {
     let mut cmd = new_ucmd!();
     let mut child = cmd.args(args).set_stdout(Stdio::piped()).run_no_wait();
     let buf = child.stdout_exact_bytes(expected.len());
     child.close_stdout();
 
     #[allow(deprecated)]
-    check_termination(&child.wait_with_output().unwrap().status);
+    check_termination(child.wait_with_output().unwrap().status);
     assert_eq!(buf.as_slice(), expected);
 }
 
@@ -34,7 +37,7 @@ fn test_invalid_arg() {
 
 #[test]
 fn test_simple() {
-    run(&[], b"y\ny\ny\ny\n");
+    run(NO_ARGS, b"y\ny\ny\ny\n");
 }
 
 #[test]
@@ -44,7 +47,7 @@ fn test_args() {
 
 #[test]
 fn test_long_output() {
-    run(&[], "y\n".repeat(512 * 1024).as_bytes());
+    run(NO_ARGS, "y\n".repeat(512 * 1024).as_bytes());
 }
 
 /// Test with an output that seems likely to get mangled in case of incomplete writes.
@@ -88,3 +91,20 @@ fn test_piped_to_dev_full() {
         }
     }
 }
+
+#[test]
+#[cfg(any(unix, target_os = "wasi"))]
+fn test_non_utf8() {
+    #[cfg(unix)]
+    use std::os::unix::ffi::OsStrExt;
+    #[cfg(target_os = "wasi")]
+    use std::os::wasi::ffi::OsStrExt;
+
+    run(
+        &[
+            OsStr::from_bytes(b"\xbf\xff\xee"),
+            OsStr::from_bytes(b"bar"),
+        ],
+        &b"\xbf\xff\xee bar\n".repeat(5000),
+    );
+}
diff --git a/tests/common/util.rs b/tests/common/util.rs
index 3097a762f..0898a4ad7 100644
--- a/tests/common/util.rs
+++ b/tests/common/util.rs
@@ -10,6 +10,7 @@
 use pretty_assertions::assert_eq;
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use rlimit::prlimit;
+#[cfg(feature = "sleep")]
 use rstest::rstest;
 #[cfg(unix)]
 use std::borrow::Cow;
@@ -47,6 +48,10 @@ static MULTIPLE_STDIN_MEANINGLESS: &str = "Ucommand is designed around a typical
 static NO_STDIN_MEANINGLESS: &str = "Setting this flag has no effect if there is no stdin";
 
 pub const TESTS_BINARY: &str = env!("CARGO_BIN_EXE_coreutils");
+pub const PATH: &str = env!("PATH");
+
+/// Default environment variables to run the commands with
+const DEFAULT_ENV: [(&str, &str); 2] = [("LC_ALL", "C"), ("TZ", "UTC")];
 
 /// Test if the program is running under CI
 pub fn is_ci() -> bool {
@@ -692,6 +697,16 @@ impl CmdResult {
         self
     }
 
+    #[track_caller]
+    pub fn stderr_matches(&self, regex: &regex::Regex) -> &Self {
+        assert!(
+            regex.is_match(self.stderr_str()),
+            "Stderr does not match regex:\n{}",
+            self.stderr_str()
+        );
+        self
+    }
+
     #[track_caller]
     pub fn stdout_does_not_match(&self, regex: &regex::Regex) -> &Self {
         assert!(
@@ -750,14 +765,14 @@ impl AtPath {
         self.subdir.to_str().unwrap().to_owned()
     }
 
-    pub fn plus(&self, name: &str) -> PathBuf {
+    pub fn plus<P: AsRef<Path>>(&self, name: P) -> PathBuf {
         let mut pathbuf = self.subdir.clone();
         pathbuf.push(name);
         pathbuf
     }
 
-    pub fn plus_as_string(&self, name: &str) -> String {
-        String::from(self.plus(name).to_str().unwrap())
+    pub fn plus_as_string<P: AsRef<Path>>(&self, name: P) -> String {
+        self.plus(name).display().to_string()
     }
 
     fn minus(&self, name: &str) -> PathBuf {
@@ -880,7 +895,8 @@ impl AtPath {
         fs::remove_dir(self.plus(dir)).unwrap();
     }
 
-    pub fn mkdir(&self, dir: &str) {
+    pub fn mkdir<P: AsRef<Path>>(&self, dir: P) {
+        let dir = dir.as_ref();
         log_info("mkdir", self.plus_as_string(dir));
         fs::create_dir(self.plus(dir)).unwrap();
     }
@@ -897,7 +913,8 @@ impl AtPath {
         }
     }
 
-    pub fn touch(&self, file: &str) {
+    pub fn touch<P: AsRef<Path>>(&self, file: P) {
+        let file = file.as_ref();
         log_info("touch", self.plus_as_string(file));
         File::create(self.plus(file)).unwrap();
     }
@@ -1020,7 +1037,7 @@ impl AtPath {
         }
     }
 
-    pub fn file_exists(&self, path: &str) -> bool {
+    pub fn file_exists<P: AsRef<Path>>(&self, path: P) -> bool {
         match fs::metadata(self.plus(path)) {
             Ok(m) => m.is_file(),
             Err(_) => false,
@@ -1158,14 +1175,12 @@ impl TestScenario {
 /// * [`UCommand::from_test_scenario`]: Run `coreutils UTIL_NAME` instead of the shell in the
 ///   temporary directory of the [`TestScenario`]
 /// * [`UCommand::current_dir`]: Sets the working directory
-/// * [`UCommand::keep_env`]: Keep environment variables instead of clearing them
 /// * ...
 #[derive(Debug, Default)]
 pub struct UCommand {
     args: VecDeque<OsString>,
     env_vars: Vec<(OsString, OsString)>,
     current_dir: Option<PathBuf>,
-    env_clear: bool,
     bin_path: Option<PathBuf>,
     util_name: Option<String>,
     has_run: bool,
@@ -1191,7 +1206,6 @@ impl UCommand {
     /// temporary directory for safety purposes.
     pub fn new() -> Self {
         Self {
-            env_clear: true,
             ..Default::default()
         }
     }
@@ -1241,12 +1255,6 @@ impl UCommand {
         self
     }
 
-    /// Keep the environment variables instead of clearing them before running the command.
-    pub fn keep_env(&mut self) -> &mut Self {
-        self.env_clear = false;
-        self
-    }
-
     /// Set the working directory for this [`UCommand`]
     ///
     /// Per default the working directory is set to the [`UCommands`] temporary directory.
@@ -1328,6 +1336,18 @@ impl UCommand {
         self
     }
 
+    pub fn envs<I, K, V>(&mut self, iter: I) -> &mut Self
+    where
+        I: IntoIterator<Item = (K, V)>,
+        K: AsRef<OsStr>,
+        V: AsRef<OsStr>,
+    {
+        for (k, v) in iter {
+            self.env(k, v);
+        }
+        self
+    }
+
     #[cfg(any(target_os = "linux", target_os = "android"))]
     pub fn limit(
         &mut self,
@@ -1364,7 +1384,6 @@ impl UCommand {
     /// which this command will be run and `current_dir` will be set to this `temp_dir`.
     /// * `current_dir`: The temporary directory given by `temp_dir`.
     /// * `timeout`: `30 seconds`
-    /// * `env_clear`: `true`. (Almost) all environment variables will be cleared.
     /// * `stdin`: `Stdio::null()`
     /// * `ignore_stdin_write_error`: `false`
     /// * `stdout`, `stderr`: If not specified the output will be captured with [`CapturedOutput`]
@@ -1423,26 +1442,26 @@ impl UCommand {
             self.tmpd = Some(Rc::new(temp_dir));
         }
 
-        if self.env_clear {
-            command.env_clear();
-            if cfg!(windows) {
-                // spell-checker:ignore (dll) rsaenh
-                // %SYSTEMROOT% is required on Windows to initialize crypto provider
-                // ... and crypto provider is required for std::rand
-                // From `procmon`: RegQueryValue HKLM\SOFTWARE\Microsoft\Cryptography\Defaults\Provider\Microsoft Strong Cryptographic Provider\Image Path
-                // SUCCESS  Type: REG_SZ, Length: 66, Data: %SystemRoot%\system32\rsaenh.dll"
-                if let Some(systemroot) = env::var_os("SYSTEMROOT") {
-                    command.env("SYSTEMROOT", systemroot);
-                }
-            } else {
-                // if someone is setting LD_PRELOAD, there's probably a good reason for it
-                if let Some(ld_preload) = env::var_os("LD_PRELOAD") {
-                    command.env("LD_PRELOAD", ld_preload);
-                }
+        command.env_clear();
+        if cfg!(windows) {
+            // spell-checker:ignore (dll) rsaenh
+            // %SYSTEMROOT% is required on Windows to initialize crypto provider
+            // ... and crypto provider is required for std::rand
+            // From `procmon`: RegQueryValue HKLM\SOFTWARE\Microsoft\Cryptography\Defaults\Provider\Microsoft Strong Cryptographic Provider\Image Path
+            // SUCCESS  Type: REG_SZ, Length: 66, Data: %SystemRoot%\system32\rsaenh.dll"
+            if let Some(systemroot) = env::var_os("SYSTEMROOT") {
+                command.env("SYSTEMROOT", systemroot);
+            }
+        } else {
+            // if someone is setting LD_PRELOAD, there's probably a good reason for it
+            if let Some(ld_preload) = env::var_os("LD_PRELOAD") {
+                command.env("LD_PRELOAD", ld_preload);
             }
         }
 
-        command.envs(self.env_vars.iter().cloned());
+        command
+            .envs(DEFAULT_ENV)
+            .envs(self.env_vars.iter().cloned());
 
         if self.timeout.is_none() {
             self.timeout = Some(Duration::from_secs(30));
@@ -1997,7 +2016,7 @@ impl UChild {
 
     /// Read, consume and return the output as [`String`] from [`Child`]'s stdout.
     ///
-    /// See also [`UChild::stdout_bytes] for side effects.
+    /// See also [`UChild::stdout_bytes`] for side effects.
     pub fn stdout(&mut self) -> String {
         String::from_utf8(self.stdout_bytes()).unwrap()
     }
@@ -2443,8 +2462,8 @@ pub fn expected_result(ts: &TestScenario, args: &[&str]) -> std::result::Result<
 
     let result = ts
         .cmd(util_name.as_ref())
-        .keep_env()
-        .env("LC_ALL", "C")
+        .env("PATH", PATH)
+        .envs(DEFAULT_ENV)
         .args(args)
         .run();
 
@@ -2503,11 +2522,13 @@ pub fn run_ucmd_as_root(
     ts: &TestScenario,
     args: &[&str],
 ) -> std::result::Result<CmdResult, String> {
-    if !is_ci() {
+    if is_ci() {
+        Err(format!("{UUTILS_INFO}: {}", "cannot run inside CI"))
+    } else {
         // check if we can run 'sudo'
         log_info("run", "sudo -E --non-interactive whoami");
         match Command::new("sudo")
-            .env("LC_ALL", "C")
+            .envs(DEFAULT_ENV)
             .args(["-E", "--non-interactive", "whoami"])
             .output()
         {
@@ -2516,8 +2537,8 @@ pub fn run_ucmd_as_root(
                 // run ucmd as root:
                 Ok(ts
                     .cmd("sudo")
-                    .keep_env()
-                    .env("LC_ALL", "C")
+                    .env("PATH", PATH)
+                    .envs(DEFAULT_ENV)
                     .arg("-E")
                     .arg("--non-interactive")
                     .arg(&ts.bin_path)
@@ -2533,8 +2554,6 @@ pub fn run_ucmd_as_root(
             Ok(_output) => Err("\"sudo whoami\" didn't return \"root\"".to_string()),
             Err(e) => Err(format!("{UUTILS_WARNING}: {e}")),
         }
-    } else {
-        Err(format!("{UUTILS_INFO}: {}", "cannot run inside CI"))
     }
 }
 
@@ -2810,7 +2829,7 @@ mod tests {
     #[should_panic]
     fn test_cmd_result_stdout_check_when_false_then_panics() {
         let result = TestScenario::new("echo").ucmd().arg("Hello world").run();
-        result.stdout_check(|s| s.is_empty());
+        result.stdout_check(<[u8]>::is_empty);
     }
 
     #[cfg(feature = "echo")]
@@ -2988,7 +3007,9 @@ mod tests {
     #[cfg(unix)]
     #[cfg(feature = "whoami")]
     fn test_run_ucmd_as_root() {
-        if !is_ci() {
+        if is_ci() {
+            println!("TEST SKIPPED (cannot run inside CI)");
+        } else {
             // Skip test if we can't guarantee non-interactive `sudo`, or if we're not "root"
             if let Ok(output) = Command::new("sudo")
                 .env("LC_ALL", "C")
@@ -3007,8 +3028,6 @@ mod tests {
             } else {
                 println!("TEST SKIPPED (cannot run sudo)");
             }
-        } else {
-            println!("TEST SKIPPED (cannot run inside CI)");
         }
     }
 
@@ -3053,9 +3072,10 @@ mod tests {
         // check `child.is_alive()` and `child.delay()` is working
         let mut trials = 10;
         while child.is_alive() {
-            if trials <= 0 {
-                panic!("Assertion failed: child process is still alive.")
-            }
+            assert!(
+                trials > 0,
+                "Assertion failed: child process is still alive."
+            );
 
             child.delay(500);
             trials -= 1;
diff --git a/tests/fixtures/cksum/blake2b_multiple_files.expected b/tests/fixtures/cksum/blake2b_multiple_files.expected
new file mode 100644
index 000000000..97d06eb6f
--- /dev/null
+++ b/tests/fixtures/cksum/blake2b_multiple_files.expected
@@ -0,0 +1,2 @@
+BLAKE2b (lorem_ipsum.txt) = 0e97a09189e560c3789c0bff1f020166861ef857d1fbfe4574de1842e3c06cabb9575e4af6309a166158c2b408d3c038c1b49d828b35158142cdc0396d1195c3
+BLAKE2b (alice_in_wonderland.txt) = 91b8b0f0868e905ad18b8ac35e4a1dacd289857b19258ab5d1e071761af758b0134ec152d4f011fe1825ca889c80c2e072ca70eb50548c25fc49a98937515af4
diff --git a/tests/fixtures/cksum/blake2b_single_file.expected b/tests/fixtures/cksum/blake2b_single_file.expected
new file mode 100644
index 000000000..64ede7ca0
--- /dev/null
+++ b/tests/fixtures/cksum/blake2b_single_file.expected
@@ -0,0 +1 @@
+BLAKE2b (lorem_ipsum.txt) = 0e97a09189e560c3789c0bff1f020166861ef857d1fbfe4574de1842e3c06cabb9575e4af6309a166158c2b408d3c038c1b49d828b35158142cdc0396d1195c3
diff --git a/tests/fixtures/cksum/blake2b_stdin.expected b/tests/fixtures/cksum/blake2b_stdin.expected
new file mode 100644
index 000000000..15c34ea77
--- /dev/null
+++ b/tests/fixtures/cksum/blake2b_stdin.expected
@@ -0,0 +1 @@
+BLAKE2b (-) = 0e97a09189e560c3789c0bff1f020166861ef857d1fbfe4574de1842e3c06cabb9575e4af6309a166158c2b408d3c038c1b49d828b35158142cdc0396d1195c3
diff --git a/tests/fixtures/cksum/multiple_files.expected b/tests/fixtures/cksum/crc_multiple_files.expected
similarity index 100%
rename from tests/fixtures/cksum/multiple_files.expected
rename to tests/fixtures/cksum/crc_multiple_files.expected
diff --git a/tests/fixtures/cksum/single_file.expected b/tests/fixtures/cksum/crc_single_file.expected
similarity index 100%
rename from tests/fixtures/cksum/single_file.expected
rename to tests/fixtures/cksum/crc_single_file.expected
diff --git a/tests/fixtures/cksum/stdin.expected b/tests/fixtures/cksum/crc_stdin.expected
similarity index 100%
rename from tests/fixtures/cksum/stdin.expected
rename to tests/fixtures/cksum/crc_stdin.expected
diff --git a/tests/fixtures/cksum/md5_multiple_files.expected b/tests/fixtures/cksum/md5_multiple_files.expected
new file mode 100644
index 000000000..54023e761
--- /dev/null
+++ b/tests/fixtures/cksum/md5_multiple_files.expected
@@ -0,0 +1,2 @@
+MD5 (lorem_ipsum.txt) = cd724690f7dc61775dfac400a71f2caa
+MD5 (alice_in_wonderland.txt) = f6fa7033e16166a9589aa1c0388ffd58
diff --git a/tests/fixtures/cksum/md5_single_file.expected b/tests/fixtures/cksum/md5_single_file.expected
new file mode 100644
index 000000000..5975053d1
--- /dev/null
+++ b/tests/fixtures/cksum/md5_single_file.expected
@@ -0,0 +1 @@
+MD5 (lorem_ipsum.txt) = cd724690f7dc61775dfac400a71f2caa
diff --git a/tests/fixtures/cksum/md5_stdin.expected b/tests/fixtures/cksum/md5_stdin.expected
new file mode 100644
index 000000000..b3b1090bc
--- /dev/null
+++ b/tests/fixtures/cksum/md5_stdin.expected
@@ -0,0 +1 @@
+MD5 (-) = cd724690f7dc61775dfac400a71f2caa
diff --git a/tests/fixtures/cksum/sha1_multiple_files.expected b/tests/fixtures/cksum/sha1_multiple_files.expected
new file mode 100644
index 000000000..f20ea9471
--- /dev/null
+++ b/tests/fixtures/cksum/sha1_multiple_files.expected
@@ -0,0 +1,2 @@
+SHA1 (lorem_ipsum.txt) = ab1dd0bae1d8883a3d18a66de6afbd28252cfbef
+SHA1 (alice_in_wonderland.txt) = 22b54b2520e8b4fa59eb10719028a4e587c12d1e
diff --git a/tests/fixtures/cksum/sha1_single_file.expected b/tests/fixtures/cksum/sha1_single_file.expected
new file mode 100644
index 000000000..1b820559f
--- /dev/null
+++ b/tests/fixtures/cksum/sha1_single_file.expected
@@ -0,0 +1 @@
+SHA1 (lorem_ipsum.txt) = ab1dd0bae1d8883a3d18a66de6afbd28252cfbef
diff --git a/tests/fixtures/cksum/sha1_stdin.expected b/tests/fixtures/cksum/sha1_stdin.expected
new file mode 100644
index 000000000..ced9ce80d
--- /dev/null
+++ b/tests/fixtures/cksum/sha1_stdin.expected
@@ -0,0 +1 @@
+SHA1 (-) = ab1dd0bae1d8883a3d18a66de6afbd28252cfbef
diff --git a/tests/fixtures/cksum/sha224_multiple_files.expected b/tests/fixtures/cksum/sha224_multiple_files.expected
new file mode 100644
index 000000000..0d6b45b10
--- /dev/null
+++ b/tests/fixtures/cksum/sha224_multiple_files.expected
@@ -0,0 +1,2 @@
+SHA224 (lorem_ipsum.txt) = 3de66fbcad106e1b40ab391be56c51d2007eb1f9c655d0f4e29bfc01
+SHA224 (alice_in_wonderland.txt) = 54c9c7d78458886418ce0845111fc49fe1c628ffd4bf3da14226ffd9
diff --git a/tests/fixtures/cksum/sha224_single_file.expected b/tests/fixtures/cksum/sha224_single_file.expected
new file mode 100644
index 000000000..a08d66bb4
--- /dev/null
+++ b/tests/fixtures/cksum/sha224_single_file.expected
@@ -0,0 +1 @@
+SHA224 (lorem_ipsum.txt) = 3de66fbcad106e1b40ab391be56c51d2007eb1f9c655d0f4e29bfc01
diff --git a/tests/fixtures/cksum/sha224_stdin.expected b/tests/fixtures/cksum/sha224_stdin.expected
new file mode 100644
index 000000000..1bd138698
--- /dev/null
+++ b/tests/fixtures/cksum/sha224_stdin.expected
@@ -0,0 +1 @@
+SHA224 (-) = 3de66fbcad106e1b40ab391be56c51d2007eb1f9c655d0f4e29bfc01
diff --git a/tests/fixtures/cksum/sha256_multiple_files.expected b/tests/fixtures/cksum/sha256_multiple_files.expected
new file mode 100644
index 000000000..e6fd8beb5
--- /dev/null
+++ b/tests/fixtures/cksum/sha256_multiple_files.expected
@@ -0,0 +1,2 @@
+SHA256 (lorem_ipsum.txt) = f7c420501c50e00b309250100d67ea5e910981536b4582fe9c435bd92b3f1f02
+SHA256 (alice_in_wonderland.txt) = 14ab7e5a0aa3a670222744714bc96961d51012cb216225d965db71824a46e5fe
diff --git a/tests/fixtures/cksum/sha256_single_file.expected b/tests/fixtures/cksum/sha256_single_file.expected
new file mode 100644
index 000000000..e16abcb0f
--- /dev/null
+++ b/tests/fixtures/cksum/sha256_single_file.expected
@@ -0,0 +1 @@
+SHA256 (lorem_ipsum.txt) = f7c420501c50e00b309250100d67ea5e910981536b4582fe9c435bd92b3f1f02
diff --git a/tests/fixtures/cksum/sha256_stdin.expected b/tests/fixtures/cksum/sha256_stdin.expected
new file mode 100644
index 000000000..87bd84195
--- /dev/null
+++ b/tests/fixtures/cksum/sha256_stdin.expected
@@ -0,0 +1 @@
+SHA256 (-) = f7c420501c50e00b309250100d67ea5e910981536b4582fe9c435bd92b3f1f02
diff --git a/tests/fixtures/cksum/sha384_multiple_files.expected b/tests/fixtures/cksum/sha384_multiple_files.expected
new file mode 100644
index 000000000..a5a3324a2
--- /dev/null
+++ b/tests/fixtures/cksum/sha384_multiple_files.expected
@@ -0,0 +1,2 @@
+SHA384 (lorem_ipsum.txt) = 4be4b90a0d0d32966992921019f24abc824dcfb8b1c408102f1f6788fb80ba9a9a4c5a7b575a3353a90a8ee719481dcb
+SHA384 (alice_in_wonderland.txt) = b7966c97ef84ab5858db2e0cdd33fbaf4fa8346d84de65aba001e738c242598a43272854d0073ad1099404eaa1d93766
diff --git a/tests/fixtures/cksum/sha384_single_file.expected b/tests/fixtures/cksum/sha384_single_file.expected
new file mode 100644
index 000000000..8d673e60b
--- /dev/null
+++ b/tests/fixtures/cksum/sha384_single_file.expected
@@ -0,0 +1 @@
+SHA384 (lorem_ipsum.txt) = 4be4b90a0d0d32966992921019f24abc824dcfb8b1c408102f1f6788fb80ba9a9a4c5a7b575a3353a90a8ee719481dcb
diff --git a/tests/fixtures/cksum/sha384_stdin.expected b/tests/fixtures/cksum/sha384_stdin.expected
new file mode 100644
index 000000000..3c0d5c818
--- /dev/null
+++ b/tests/fixtures/cksum/sha384_stdin.expected
@@ -0,0 +1 @@
+SHA384 (-) = 4be4b90a0d0d32966992921019f24abc824dcfb8b1c408102f1f6788fb80ba9a9a4c5a7b575a3353a90a8ee719481dcb
diff --git a/tests/fixtures/cksum/sha512_multiple_files.expected b/tests/fixtures/cksum/sha512_multiple_files.expected
new file mode 100644
index 000000000..0f533b27c
--- /dev/null
+++ b/tests/fixtures/cksum/sha512_multiple_files.expected
@@ -0,0 +1,2 @@
+SHA512 (lorem_ipsum.txt) = 965464ab2556aad58ebc73d89ad221e559797529ecafc0f466c11795cff6d6e2c60f96a07c542cfd1f426e5e4fe0a48aa15667ba44096b213d0813cd038dfa05
+SHA512 (alice_in_wonderland.txt) = 251646d5a7eb481e0f3aced7839d78dd5e97153f822dc55938e17059c485990d85d602e2881b528b565ab6262584a69c97b068b26bda81acc9356c53c7c1c96d
diff --git a/tests/fixtures/cksum/sha512_single_file.expected b/tests/fixtures/cksum/sha512_single_file.expected
new file mode 100644
index 000000000..e9a02c96a
--- /dev/null
+++ b/tests/fixtures/cksum/sha512_single_file.expected
@@ -0,0 +1 @@
+SHA512 (lorem_ipsum.txt) = 965464ab2556aad58ebc73d89ad221e559797529ecafc0f466c11795cff6d6e2c60f96a07c542cfd1f426e5e4fe0a48aa15667ba44096b213d0813cd038dfa05
diff --git a/tests/fixtures/cksum/sha512_stdin.expected b/tests/fixtures/cksum/sha512_stdin.expected
new file mode 100644
index 000000000..8321c4cc3
--- /dev/null
+++ b/tests/fixtures/cksum/sha512_stdin.expected
@@ -0,0 +1 @@
+SHA512 (-) = 965464ab2556aad58ebc73d89ad221e559797529ecafc0f466c11795cff6d6e2c60f96a07c542cfd1f426e5e4fe0a48aa15667ba44096b213d0813cd038dfa05
diff --git a/tests/fixtures/cksum/sm3_multiple_files.expected b/tests/fixtures/cksum/sm3_multiple_files.expected
new file mode 100644
index 000000000..eae2cde2f
--- /dev/null
+++ b/tests/fixtures/cksum/sm3_multiple_files.expected
@@ -0,0 +1,2 @@
+SM3 (lorem_ipsum.txt) = 6d296b805d060bfed22808df308dbb9b4317794dd4ed6740a10770a782699bc2
+SM3 (alice_in_wonderland.txt) = d66617ae3c4e87828298dcd836f79efbab488c53b84e09c3e8e83a16c902418d
diff --git a/tests/fixtures/cksum/sm3_single_file.expected b/tests/fixtures/cksum/sm3_single_file.expected
new file mode 100644
index 000000000..cf4b8304a
--- /dev/null
+++ b/tests/fixtures/cksum/sm3_single_file.expected
@@ -0,0 +1 @@
+SM3 (lorem_ipsum.txt) = 6d296b805d060bfed22808df308dbb9b4317794dd4ed6740a10770a782699bc2
diff --git a/tests/fixtures/cksum/sm3_stdin.expected b/tests/fixtures/cksum/sm3_stdin.expected
new file mode 100644
index 000000000..436fcfb41
--- /dev/null
+++ b/tests/fixtures/cksum/sm3_stdin.expected
@@ -0,0 +1 @@
+SM3 (-) = 6d296b805d060bfed22808df308dbb9b4317794dd4ed6740a10770a782699bc2
diff --git a/tests/fixtures/cksum/untagged/blake2b_multiple_files.expected b/tests/fixtures/cksum/untagged/blake2b_multiple_files.expected
new file mode 100644
index 000000000..7c68c8573
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/blake2b_multiple_files.expected
@@ -0,0 +1,2 @@
+0e97a09189e560c3789c0bff1f020166861ef857d1fbfe4574de1842e3c06cabb9575e4af6309a166158c2b408d3c038c1b49d828b35158142cdc0396d1195c3  lorem_ipsum.txt
+91b8b0f0868e905ad18b8ac35e4a1dacd289857b19258ab5d1e071761af758b0134ec152d4f011fe1825ca889c80c2e072ca70eb50548c25fc49a98937515af4  alice_in_wonderland.txt
diff --git a/tests/fixtures/cksum/untagged/blake2b_single_file.expected b/tests/fixtures/cksum/untagged/blake2b_single_file.expected
new file mode 100644
index 000000000..1f5444c87
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/blake2b_single_file.expected
@@ -0,0 +1 @@
+0e97a09189e560c3789c0bff1f020166861ef857d1fbfe4574de1842e3c06cabb9575e4af6309a166158c2b408d3c038c1b49d828b35158142cdc0396d1195c3  lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/untagged/blake2b_stdin.expected b/tests/fixtures/cksum/untagged/blake2b_stdin.expected
new file mode 100644
index 000000000..0892bff36
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/blake2b_stdin.expected
@@ -0,0 +1 @@
+0e97a09189e560c3789c0bff1f020166861ef857d1fbfe4574de1842e3c06cabb9575e4af6309a166158c2b408d3c038c1b49d828b35158142cdc0396d1195c3  -
diff --git a/tests/fixtures/cksum/untagged/bsd_multiple_files.expected b/tests/fixtures/cksum/untagged/bsd_multiple_files.expected
new file mode 100644
index 000000000..941a2a512
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/bsd_multiple_files.expected
@@ -0,0 +1,2 @@
+08109     1 lorem_ipsum.txt
+01814     1 alice_in_wonderland.txt
diff --git a/tests/fixtures/cksum/untagged/bsd_single_file.expected b/tests/fixtures/cksum/untagged/bsd_single_file.expected
new file mode 100644
index 000000000..293ada3bd
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/bsd_single_file.expected
@@ -0,0 +1 @@
+08109     1 lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/untagged/bsd_stdin.expected b/tests/fixtures/cksum/untagged/bsd_stdin.expected
new file mode 100644
index 000000000..4843ba082
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/bsd_stdin.expected
@@ -0,0 +1 @@
+08109     1
diff --git a/tests/fixtures/cksum/untagged/crc_multiple_files.expected b/tests/fixtures/cksum/untagged/crc_multiple_files.expected
new file mode 100644
index 000000000..d7a4f5b4f
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/crc_multiple_files.expected
@@ -0,0 +1,2 @@
+378294376 772 lorem_ipsum.txt
+3805907707 302 alice_in_wonderland.txt
diff --git a/tests/fixtures/cksum/untagged/crc_single_file.expected b/tests/fixtures/cksum/untagged/crc_single_file.expected
new file mode 100644
index 000000000..e9fc1ca7c
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/crc_single_file.expected
@@ -0,0 +1 @@
+378294376 772 lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/untagged/crc_stdin.expected b/tests/fixtures/cksum/untagged/crc_stdin.expected
new file mode 100644
index 000000000..28b37d0be
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/crc_stdin.expected
@@ -0,0 +1 @@
+378294376 772
diff --git a/tests/fixtures/cksum/untagged/md5_multiple_files.expected b/tests/fixtures/cksum/untagged/md5_multiple_files.expected
new file mode 100644
index 000000000..4b63cbff7
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/md5_multiple_files.expected
@@ -0,0 +1,2 @@
+cd724690f7dc61775dfac400a71f2caa  lorem_ipsum.txt
+f6fa7033e16166a9589aa1c0388ffd58  alice_in_wonderland.txt
diff --git a/tests/fixtures/cksum/untagged/md5_single_file.expected b/tests/fixtures/cksum/untagged/md5_single_file.expected
new file mode 100644
index 000000000..ca9eb6785
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/md5_single_file.expected
@@ -0,0 +1 @@
+cd724690f7dc61775dfac400a71f2caa  lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/untagged/md5_stdin.expected b/tests/fixtures/cksum/untagged/md5_stdin.expected
new file mode 100644
index 000000000..f4094dcc7
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/md5_stdin.expected
@@ -0,0 +1 @@
+cd724690f7dc61775dfac400a71f2caa  -
diff --git a/tests/fixtures/cksum/untagged/sha1_multiple_files.expected b/tests/fixtures/cksum/untagged/sha1_multiple_files.expected
new file mode 100644
index 000000000..1712c7409
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha1_multiple_files.expected
@@ -0,0 +1,2 @@
+ab1dd0bae1d8883a3d18a66de6afbd28252cfbef  lorem_ipsum.txt
+22b54b2520e8b4fa59eb10719028a4e587c12d1e  alice_in_wonderland.txt
diff --git a/tests/fixtures/cksum/untagged/sha1_single_file.expected b/tests/fixtures/cksum/untagged/sha1_single_file.expected
new file mode 100644
index 000000000..c8e8ddca6
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha1_single_file.expected
@@ -0,0 +1 @@
+ab1dd0bae1d8883a3d18a66de6afbd28252cfbef  lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/untagged/sha1_stdin.expected b/tests/fixtures/cksum/untagged/sha1_stdin.expected
new file mode 100644
index 000000000..2396ed481
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha1_stdin.expected
@@ -0,0 +1 @@
+ab1dd0bae1d8883a3d18a66de6afbd28252cfbef  -
diff --git a/tests/fixtures/cksum/untagged/sha224_multiple_files.expected b/tests/fixtures/cksum/untagged/sha224_multiple_files.expected
new file mode 100644
index 000000000..3eb2b500a
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha224_multiple_files.expected
@@ -0,0 +1,2 @@
+3de66fbcad106e1b40ab391be56c51d2007eb1f9c655d0f4e29bfc01  lorem_ipsum.txt
+54c9c7d78458886418ce0845111fc49fe1c628ffd4bf3da14226ffd9  alice_in_wonderland.txt
diff --git a/tests/fixtures/cksum/untagged/sha224_single_file.expected b/tests/fixtures/cksum/untagged/sha224_single_file.expected
new file mode 100644
index 000000000..c5ab1f7d1
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha224_single_file.expected
@@ -0,0 +1 @@
+3de66fbcad106e1b40ab391be56c51d2007eb1f9c655d0f4e29bfc01  lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/untagged/sha224_stdin.expected b/tests/fixtures/cksum/untagged/sha224_stdin.expected
new file mode 100644
index 000000000..691e451b3
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha224_stdin.expected
@@ -0,0 +1 @@
+3de66fbcad106e1b40ab391be56c51d2007eb1f9c655d0f4e29bfc01  -
diff --git a/tests/fixtures/cksum/untagged/sha256_multiple_files.expected b/tests/fixtures/cksum/untagged/sha256_multiple_files.expected
new file mode 100644
index 000000000..a57fa2eaf
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha256_multiple_files.expected
@@ -0,0 +1,2 @@
+f7c420501c50e00b309250100d67ea5e910981536b4582fe9c435bd92b3f1f02  lorem_ipsum.txt
+14ab7e5a0aa3a670222744714bc96961d51012cb216225d965db71824a46e5fe  alice_in_wonderland.txt
diff --git a/tests/fixtures/cksum/untagged/sha256_single_file.expected b/tests/fixtures/cksum/untagged/sha256_single_file.expected
new file mode 100644
index 000000000..1b1be9516
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha256_single_file.expected
@@ -0,0 +1 @@
+f7c420501c50e00b309250100d67ea5e910981536b4582fe9c435bd92b3f1f02  lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/untagged/sha256_stdin.expected b/tests/fixtures/cksum/untagged/sha256_stdin.expected
new file mode 100644
index 000000000..998db6c66
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha256_stdin.expected
@@ -0,0 +1 @@
+f7c420501c50e00b309250100d67ea5e910981536b4582fe9c435bd92b3f1f02  -
diff --git a/tests/fixtures/cksum/untagged/sha384_multiple_files.expected b/tests/fixtures/cksum/untagged/sha384_multiple_files.expected
new file mode 100644
index 000000000..d309034b4
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha384_multiple_files.expected
@@ -0,0 +1,2 @@
+4be4b90a0d0d32966992921019f24abc824dcfb8b1c408102f1f6788fb80ba9a9a4c5a7b575a3353a90a8ee719481dcb  lorem_ipsum.txt
+b7966c97ef84ab5858db2e0cdd33fbaf4fa8346d84de65aba001e738c242598a43272854d0073ad1099404eaa1d93766  alice_in_wonderland.txt
diff --git a/tests/fixtures/cksum/untagged/sha384_single_file.expected b/tests/fixtures/cksum/untagged/sha384_single_file.expected
new file mode 100644
index 000000000..88d4da577
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha384_single_file.expected
@@ -0,0 +1 @@
+4be4b90a0d0d32966992921019f24abc824dcfb8b1c408102f1f6788fb80ba9a9a4c5a7b575a3353a90a8ee719481dcb  lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/untagged/sha384_stdin.expected b/tests/fixtures/cksum/untagged/sha384_stdin.expected
new file mode 100644
index 000000000..cde20b78b
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha384_stdin.expected
@@ -0,0 +1 @@
+4be4b90a0d0d32966992921019f24abc824dcfb8b1c408102f1f6788fb80ba9a9a4c5a7b575a3353a90a8ee719481dcb  -
diff --git a/tests/fixtures/cksum/untagged/sha512_multiple_files.expected b/tests/fixtures/cksum/untagged/sha512_multiple_files.expected
new file mode 100644
index 000000000..a5dafa7c3
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha512_multiple_files.expected
@@ -0,0 +1,2 @@
+965464ab2556aad58ebc73d89ad221e559797529ecafc0f466c11795cff6d6e2c60f96a07c542cfd1f426e5e4fe0a48aa15667ba44096b213d0813cd038dfa05  lorem_ipsum.txt
+251646d5a7eb481e0f3aced7839d78dd5e97153f822dc55938e17059c485990d85d602e2881b528b565ab6262584a69c97b068b26bda81acc9356c53c7c1c96d  alice_in_wonderland.txt
diff --git a/tests/fixtures/cksum/untagged/sha512_single_file.expected b/tests/fixtures/cksum/untagged/sha512_single_file.expected
new file mode 100644
index 000000000..adea498d6
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha512_single_file.expected
@@ -0,0 +1 @@
+965464ab2556aad58ebc73d89ad221e559797529ecafc0f466c11795cff6d6e2c60f96a07c542cfd1f426e5e4fe0a48aa15667ba44096b213d0813cd038dfa05  lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/untagged/sha512_stdin.expected b/tests/fixtures/cksum/untagged/sha512_stdin.expected
new file mode 100644
index 000000000..dd9c96843
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha512_stdin.expected
@@ -0,0 +1 @@
+965464ab2556aad58ebc73d89ad221e559797529ecafc0f466c11795cff6d6e2c60f96a07c542cfd1f426e5e4fe0a48aa15667ba44096b213d0813cd038dfa05  -
diff --git a/tests/fixtures/cksum/untagged/sm3_multiple_files.expected b/tests/fixtures/cksum/untagged/sm3_multiple_files.expected
new file mode 100644
index 000000000..de12ab0b9
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sm3_multiple_files.expected
@@ -0,0 +1,2 @@
+6d296b805d060bfed22808df308dbb9b4317794dd4ed6740a10770a782699bc2  lorem_ipsum.txt
+d66617ae3c4e87828298dcd836f79efbab488c53b84e09c3e8e83a16c902418d  alice_in_wonderland.txt
diff --git a/tests/fixtures/cksum/untagged/sm3_single_file.expected b/tests/fixtures/cksum/untagged/sm3_single_file.expected
new file mode 100644
index 000000000..54d5f40d2
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sm3_single_file.expected
@@ -0,0 +1 @@
+6d296b805d060bfed22808df308dbb9b4317794dd4ed6740a10770a782699bc2  lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/untagged/sm3_stdin.expected b/tests/fixtures/cksum/untagged/sm3_stdin.expected
new file mode 100644
index 000000000..6ba002b45
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sm3_stdin.expected
@@ -0,0 +1 @@
+6d296b805d060bfed22808df308dbb9b4317794dd4ed6740a10770a782699bc2  -
diff --git a/tests/fixtures/cksum/untagged/sysv_multiple_files.expected b/tests/fixtures/cksum/untagged/sysv_multiple_files.expected
new file mode 100644
index 000000000..83a6d6d83
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sysv_multiple_files.expected
@@ -0,0 +1,2 @@
+6985 2 lorem_ipsum.txt
+27441 1 alice_in_wonderland.txt
diff --git a/tests/fixtures/cksum/untagged/sysv_single_file.expected b/tests/fixtures/cksum/untagged/sysv_single_file.expected
new file mode 100644
index 000000000..e0f7252cb
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sysv_single_file.expected
@@ -0,0 +1 @@
+6985 2 lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/untagged/sysv_stdin.expected b/tests/fixtures/cksum/untagged/sysv_stdin.expected
new file mode 100644
index 000000000..f0fba8c81
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sysv_stdin.expected
@@ -0,0 +1 @@
+6985 2
diff --git a/tests/fixtures/comm/a_nul b/tests/fixtures/comm/a_nul
new file mode 100644
index 000000000..3142c801c
Binary files /dev/null and b/tests/fixtures/comm/a_nul differ
diff --git a/tests/fixtures/comm/ab_nul.expected b/tests/fixtures/comm/ab_nul.expected
new file mode 100644
index 000000000..f826106bb
Binary files /dev/null and b/tests/fixtures/comm/ab_nul.expected differ
diff --git a/tests/fixtures/comm/ab_nul_total.expected b/tests/fixtures/comm/ab_nul_total.expected
new file mode 100644
index 000000000..9f46f9558
Binary files /dev/null and b/tests/fixtures/comm/ab_nul_total.expected differ
diff --git a/tests/fixtures/comm/b_nul b/tests/fixtures/comm/b_nul
new file mode 100644
index 000000000..ca4569669
Binary files /dev/null and b/tests/fixtures/comm/b_nul differ
diff --git a/tests/fixtures/wc/alice in wonderland.txt b/tests/fixtures/wc/alice in wonderland.txt
new file mode 100644
index 000000000..a95562a1c
--- /dev/null
+++ b/tests/fixtures/wc/alice in wonderland.txt	
@@ -0,0 +1,5 @@
+Alice was beginning to get very tired of sitting by
+her sister on the bank, and of having nothing to do: once or twice
+she had peeped into the book her sister was reading, but it had no
+pictures or conversations in it, "and what is the use of a book,"
+thought Alice "without pictures or conversation?"
diff --git a/tests/fixtures/wc/dir with spaces/.keep b/tests/fixtures/wc/dir with spaces/.keep
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/fixtures/wc/files0 with nonexistent.txt b/tests/fixtures/wc/files0 with nonexistent.txt
new file mode 100644
index 000000000..00c00b705
Binary files /dev/null and b/tests/fixtures/wc/files0 with nonexistent.txt differ
diff --git a/tests/tests.rs b/tests/tests.rs
index 17581799d..02c3bfdab 100644
--- a/tests/tests.rs
+++ b/tests/tests.rs
@@ -1,9 +1,6 @@
 #[macro_use]
 mod common;
 
-#[cfg(unix)]
-extern crate rust_users;
-
 #[cfg(feature = "arch")]
 #[path = "by-util/test_arch.rs"]
 mod test_arch;
diff --git a/util/android-commands.sh b/util/android-commands.sh
index 42e27ad88..4b504de56 100755
--- a/util/android-commands.sh
+++ b/util/android-commands.sh
@@ -1,5 +1,5 @@
 #!/bin/bash
-# spell-checker:ignore termux keyevent sdcard binutils unmatch adb's dumpsys logcat pkill
+# spell-checker:ignore termux keyevent sdcard binutils unmatch adb's dumpsys logcat pkill nextest logfile
 
 # There are three shells: the host's, adb, and termux. Only adb lets us run
 # commands directly on the emulated device, only termux provides a GNU
@@ -8,30 +8,36 @@
 # This means that the commands sent to termux are first parsed as arguments in
 # this shell, then as arguments in the adb shell, before finally being used as
 # text inputs to the app. Hence, the "'wrapping'" on those commands.
-# There's no way to get any feedback from termux, so every time we run a
-# command on it, we make sure it ends by creating a unique *.probe file at the
-# end of the command. The contents of the file are used as a return code: 0 on
-# success, some other number for errors (an empty file is basically the same as
-# 0). Note that the return codes are text, not raw bytes.
+# There's no way to get any direct feedback from termux, so every time we run a
+# command on it, we make sure it creates a unique *.probe file which is polled
+# every 30 seconds together with the current output of the command in a *.log file.
+# The contents of the probe file are used as a return code: 0 on success, some
+# other number for errors (an empty file is basically the same as 0). Note that
+# the return codes are text, not raw bytes.
 
+this_repo="$(dirname "$(dirname -- "$(readlink -- "${0}")")")"
+cache_dir_name="__rust_cache__"
 
-this_repo="$(dirname $(dirname -- "$(readlink -- "${0}")"))"
-
-help () {
+help() {
     echo \
-"Usage: $0 COMMAND [ARG]
+        "Usage: $0 COMMAND [ARG]
 
 where COMMAND is one of:
+  init          download termux and initialize the emulator image
   snapshot APK  install APK and dependencies on an emulator to prep a snapshot
                 (you can, but probably don't want to, run this for physical
                 devices -- just set up termux and the dependencies yourself)
-  sync [REPO]   push the repo at REPO to the device, deleting and restoring all
-                symlinks (locally) in the process; by default, REPO is:
+  sync_host [REPO]
+                push the repo at REPO to the device, deleting and restoring all symlinks (locally)
+                in the process; The cached rust directories are restored, too; by default, REPO is:
                 $this_repo
+  sync_image [REPO]
+                copy the repo/target and the HOME/.cargo directories from the device back to the
+                host; by default, REPO is: $this_repo
   build         run \`cargo build --features feat_os_unix_android\` on the
-                device, then pull the output as build.log
+                device
   tests         run \`cargo test --features feat_os_unix_android\` on the
-                device, then pull the output as tests.log
+                device
 
 If you have multiple devices, use the ANDROID_SERIAL environment variable to
 specify which to connect to."
@@ -41,9 +47,13 @@ hit_enter() {
     adb shell input keyevent 66
 }
 
+exit_termux() {
+    adb shell input text "exit" && hit_enter && hit_enter
+}
+
 launch_termux() {
     echo "launching termux"
-    if ! adb shell 'am start -n com.termux/.HomeActivity' ; then
+    if ! adb shell 'am start -n com.termux/.HomeActivity'; then
         echo "failed to launch termux"
         exit 1
     fi
@@ -57,76 +67,296 @@ launch_termux() {
     adb shell 'rm /sdcard/launch.probe' && echo "removed launch.probe"
 }
 
+# Usage: run_termux_command
+#
+# Runs the command specified in $1 in a termux shell, polling for the probe specified in $2 (and the
+# current output). If polling the probe succeeded the command is considered to have finished. This
+# method prints the current stdout and stderr of the command every SLEEP_INTERVAL seconds and
+# finishes a command run with a summary. It returns with the exit code of the probe if specified as
+# file content of the probe.
+#
+# Positional arguments
+# $1                The command to execute in the termux shell
+# $2                The path to the probe. The file name must end with `.probe`
+#
+# It's possible to overwrite settings by specifying the setting the variable before calling this
+# method (Default in parentheses):
+# keep_log  0|1     Keeps the logs after running the command if set to 1. The log file name is
+#                   derived from the probe file name (the last component of the path) and
+#                   `.probe` replaced with `.log. (0)
+# debug     0|1     Adds additional debugging output to the log file if set to 1. (1)
+# timeout   SECONDS The timeout in full SECONDS for the command to complete before giving up. (3600)
+# retries   RETRIES The number of retries for trying to fix possible issues when we're not receiving
+#                   any progress from the emulator. (3)
+# sleep_interval
+#           SECONDS The time interval in full SECONDS between polls for the probe and the current
+#           output. (5)
 run_termux_command() {
-    command="$1"  # text of the escaped command, including creating the probe!
-    probe="$2"  # unique file that indicates the command is complete
+    # shellcheck disable=SC2155
+    local command="$(echo "$1" | sed -E "s/^['](.*)[']$/\1/")" # text of the escaped command, including creating the probe!
+    local probe="$2"                                           # unique file that indicates the command is complete
+    local keep_log=${keep_log:-0}
+    local debug=${debug:-1}
+
+    log_name="$(basename -s .probe "${probe}").log" # probe name must have suffix .probe
+    log_file="/sdcard/${log_name}"
+    log_read="${log_name}.read"
+    echo 0 >"${log_read}"
+    if [[ $debug -eq 1 ]]; then
+        shell_command="'set -x; { ${command}; } &> ${log_file}; set +x'"
+    else
+        shell_command="'{ ${command}; } &> ${log_file}'"
+    fi
+
     launch_termux
-    adb shell input text "$command" && hit_enter
-    while ! adb shell "ls $probe" 2>/dev/null; do echo "waiting for $probe"; sleep 30; done
-    return_code=$(adb shell "cat $probe")
-    adb shell "rm $probe"
-    echo "return code: $return_code"
+    echo "Running command: ${command}"
+    start=$(date +%s)
+    adb shell input text "$shell_command" && sleep 3 && hit_enter
+    # just for safety wait a little bit before polling for the probe and the log file
+    sleep 5
+
+    local timeout=${timeout:-3600}
+    local retries=${retries:-10}
+    local sleep_interval=${sleep_interval:-10}
+    try_fix=3
+    echo "run_termux_command with timeout=$timeout / retries=$retries / sleep_interval=$sleep_interval"
+    while ! adb shell "ls $probe" 2>/dev/null; do
+        echo -n "Waiting for $probe: "
+
+        if [[ -e "$log_name" ]]; then
+            rm "$log_name"
+        fi
+
+        adb pull "$log_file" . || try_fix=$((try_fix - 1))
+        if [[ -e "$log_name" ]]; then
+            tail -n +"$(<"$log_read")" "$log_name"
+            echo
+            wc -l <"${log_name}" | tr -d "[:space:]" >"$log_read"
+        fi
+
+        if [[ retries -le 0 ]]; then
+            echo "Maximum retries reached running command. Aborting ..."
+            return 1
+        elif [[ try_fix -le 0 ]]; then
+            retries=$((retries - 1))
+            try_fix=3
+            # Since there is no output, there is no way to know what is happening inside. See if
+            # hitting the enter key solves the issue, sometimes the github runner is just a little
+            # bit slow.
+            echo "No output received. Trying to fix the issue ... (${retries} retries left)"
+            hit_enter
+        fi
+
+        sleep "$sleep_interval"
+        timeout=$((timeout - sleep_interval))
+
+        if [[ $timeout -le 0 ]]; then
+            echo "Timeout reached running command. Aborting ..."
+            return 1
+        fi
+    done
+    end=$(date +%s)
+
+    return_code=$(adb shell "cat $probe") || return_code=0
+    adb shell "rm ${probe}"
+
+    adb pull "$log_file" .
+    echo "==================================== SUMMARY ==================================="
+    echo "Command: ${command}"
+    echo "Finished in $((end - start)) seconds."
+    echo "Output was:"
+    cat "$log_name"
+    echo "Return code: $return_code"
+    echo "================================================================================"
+
+    adb shell "rm ${log_file}"
+    [[ $keep_log -ne 1 ]] && rm -f "$log_name"
+    rm -f "$log_read" "$probe"
+
+    # shellcheck disable=SC2086
     return $return_code
 }
 
-snapshot () {
-    apk="$1"
-    echo "running snapshot"
-    adb install -g "$apk"
-    probe='/sdcard/pkg.probe'
-    command="'yes | pkg install rust binutils openssl -y; touch $probe'"
-    run_termux_command "$command" "$probe"
-    echo "snapshot complete"
-    adb shell input text "exit" && hit_enter && hit_enter
+init() {
+    arch="$1"
+    api_level="$2"
+    termux="$3"
+
+    # shellcheck disable=SC2015
+    wget "https://github.com/termux/termux-app/releases/download/${termux}/termux-app_${termux}+github-debug_${arch}.apk" &&
+        snapshot "termux-app_${termux}+github-debug_${arch}.apk" &&
+        hash_rustc &&
+        exit_termux &&
+        adb -s emulator-5554 emu avd snapshot save "${api_level}-${arch}+termux-${termux}" &&
+        echo "Emulator image created." || {
+        pkill -9 qemu-system-x86_64
+        return 1
+    }
+    pkill -9 qemu-system-x86_64 || true
 }
 
-sync () {
+snapshot() {
+    apk="$1"
+    echo "Running snapshot"
+    adb install -g "$apk"
+
+    echo "Prepare and install system packages"
+    probe='/sdcard/pkg.probe'
+    command="'mkdir -vp ~/.cargo/bin; yes | pkg install rust binutils openssl tar -y; echo \$? > $probe'"
+    run_termux_command "$command" "$probe" || return
+
+    echo "Installing cargo-nextest"
+    probe='/sdcard/nextest.probe'
+    # We need to install nextest via cargo currently, since there is no pre-built binary for android x86
+    command="'\
+export CARGO_TERM_COLOR=always; \
+cargo install cargo-nextest; \
+echo \$? > $probe'"
+    run_termux_command "$command" "$probe"
+    return_code=$?
+
+    echo "Info about cargo and rust"
+    probe='/sdcard/info.probe'
+    command="'echo \$HOME; \
+PATH=\$HOME/.cargo/bin:\$PATH; \
+export PATH; \
+echo \$PATH; \
+pwd; \
+command -v rustc && rustc -Vv; \
+ls -la ~/.cargo/bin; \
+cargo --list; \
+cargo nextest --version; \
+touch $probe'"
+    run_termux_command "$command" "$probe"
+
+    echo "Snapshot complete"
+    # shellcheck disable=SC2086
+    return $return_code
+}
+
+sync_host() {
     repo="$1"
-    echo "running sync $1"
+    cache_home="${HOME}/${cache_dir_name}"
+    cache_dest="/sdcard/${cache_dir_name}"
+
+    echo "Running sync host -> image: ${repo}"
+
     # android doesn't allow symlinks on shared dirs, and adb can't selectively push files
     symlinks=$(find "$repo" -type l)
     # dash doesn't support process substitution :(
-    echo $symlinks | sort >symlinks
+    echo "$symlinks" | sort >symlinks
+
     git -C "$repo" diff --name-status | cut -f 2 >modified
     modified_links=$(join symlinks modified)
-    if [ ! -z "$modified_links" ]; then
+    if [ -n "$modified_links" ]; then
         echo "You have modified symlinks. Either stash or commit them, then try again: $modified_links"
         exit 1
     fi
+    #shellcheck disable=SC2086
     if ! git ls-files --error-unmatch $symlinks >/dev/null; then
         echo "You have untracked symlinks. Either remove or commit them, then try again."
         exit 1
     fi
+
+    #shellcheck disable=SC2086
     rm $symlinks
     # adb's shell user only has access to shared dirs...
-    adb push "$repo" /sdcard/coreutils
+    adb push -a "$repo" /sdcard/coreutils
+    [[ -e "$cache_home" ]] && adb push -a "$cache_home" "$cache_dest"
+
+    #shellcheck disable=SC2086
     git -C "$repo" checkout $symlinks
+
     # ...but shared dirs can't build, so move it home as termux
-    probe='/sdcard/mv.probe'
-    command="'cp -r /sdcard/coreutils ~/; touch $probe'"
-    run_termux_command "$command" "$probe"
+    probe='/sdcard/sync.probe'
+    command="'mv /sdcard/coreutils ~/; \
+cd ~/coreutils; \
+if [[ -e ${cache_dest} ]]; then \
+rm -rf ~/.cargo ./target; \
+tar xzf ${cache_dest}/cargo.tgz -C ~/; \
+ls -la ~/.cargo; \
+tar xzf ${cache_dest}/target.tgz; \
+ls -la ./target; \
+rm -rf ${cache_dest}; \
+fi; \
+touch $probe'"
+    run_termux_command "$command" "$probe" || return
+
+    echo "Finished sync host -> image: ${repo}"
 }
 
-build () {
+sync_image() {
+    repo="$1"
+    cache_home="${HOME}/${cache_dir_name}"
+    cache_dest="/sdcard/${cache_dir_name}"
+
+    echo "Running sync image -> host: ${repo}"
+
+    probe='/sdcard/cache.probe'
+    command="'rm -rf /sdcard/coreutils ${cache_dest}; \
+mkdir -p ${cache_dest}; \
+cd ${cache_dest}; \
+tar czf cargo.tgz -C ~/ .cargo; \
+tar czf target.tgz -C ~/coreutils target; \
+ls -la ${cache_dest}; \
+echo \$? > ${probe}'"
+    run_termux_command "$command" "$probe" || return
+
+    rm -rf "$cache_home"
+    adb pull -a "$cache_dest" "$cache_home" || return
+
+    echo "Finished sync image -> host: ${repo}"
+}
+
+build() {
+    echo "Running build"
+
     probe='/sdcard/build.probe'
-    command="'cd ~/coreutils && cargo build --features feat_os_unix_android 2>/sdcard/build.log; echo \$? >$probe'"
-    echo "running build"
-    run_termux_command "$command" "$probe"
-    return_code=$?
-    adb pull /sdcard/build.log .
-    cat build.log
-    return $return_code
+    command="'export CARGO_TERM_COLOR=always; \
+export CARGO_INCREMENTAL=0; \
+cd ~/coreutils && cargo build --features feat_os_unix_android; \
+echo \$? >$probe'"
+    run_termux_command "$command" "$probe" || return
+
+    echo "Finished build"
 }
 
-tests () {
+tests() {
+    echo "Running tests"
+
     probe='/sdcard/tests.probe'
-    export RUST_BACKTRACE=1
-    command="'cd ~/coreutils && timeout --preserve-status --verbose -k 1m 60m cargo test --features feat_os_unix_android --no-fail-fast >/sdcard/tests.log 2>&1; echo \$? >$probe'"
-    run_termux_command "$command" "$probe"
-    return_code=$?
-    adb pull /sdcard/tests.log .
-    cat tests.log
-    return $return_code
+    command="'export PATH=\$HOME/.cargo/bin:\$PATH; \
+export RUST_BACKTRACE=1; \
+export CARGO_TERM_COLOR=always; \
+export CARGO_INCREMENTAL=0; \
+cd ~/coreutils; \
+timeout --preserve-status --verbose -k 1m 60m \
+cargo nextest run --profile ci --hide-progress-bar --features feat_os_unix_android; \
+echo \$? >$probe'"
+    run_termux_command "$command" "$probe" || return
+
+    echo "Finished tests"
+}
+
+hash_rustc() {
+    probe='/sdcard/rustc.probe'
+    tmp_hash="__rustc_hash__.tmp"
+    hash="__rustc_hash__"
+
+    echo "Hashing rustc version: ${HOME}/${hash}"
+
+    command="'rustc -Vv; echo \$? > ${probe}'"
+    keep_log=1
+    debug=0
+    run_termux_command "$command" "$probe" || return
+    rm -f "$tmp_hash"
+    mv "rustc.log" "$tmp_hash" || return
+    # sha256sum is not available. shasum is the macos native program.
+    shasum -a 256 "$tmp_hash" | cut -f 1 -d ' ' | tr -d '[:space:]' >"${HOME}/${hash}" || return
+
+    rm -f "$tmp_hash"
+
+    echo "Finished hashing rustc version: ${HOME}/${hash}"
 }
 
 #adb logcat &
@@ -134,16 +364,54 @@ exit_code=0
 
 if [ $# -eq 1 ]; then
     case "$1" in
-        sync)     sync "$this_repo"; exit_code=$?;;
-        build)    build; exit_code=$?;;
-        tests)    tests; exit_code=$?;;
-        *)        help;;
+        sync_host)
+            sync_host "$this_repo"
+            exit_code=$?
+            ;;
+        sync_image)
+            sync_image "$this_repo"
+            exit_code=$?
+            ;;
+        build)
+            build
+            exit_code=$?
+            ;;
+        tests)
+            tests
+            exit_code=$?
+            ;;
+        *) help ;;
     esac
 elif [ $# -eq 2 ]; then
     case "$1" in
-        snapshot) snapshot "$2"; exit_code=$?;;
-        sync)     sync "$2"; exit_code=$?;;
-        *)        help; exit 1;;
+        snapshot)
+            snapshot "$2"
+            exit_code=$?
+            ;;
+        sync_host)
+            sync_host "$2"
+            exit_code=$?
+            ;;
+        sync_image)
+            sync_image "$2"
+            exit_code=$?
+            ;;
+        *)
+            help
+            exit 1
+            ;;
+    esac
+elif [ $# -eq 4 ]; then
+    case "$1" in
+        init)
+            shift
+            init "$@"
+            exit_code=$?
+            ;;
+        *)
+            help
+            exit 1
+            ;;
     esac
 else
     help
diff --git a/util/build-gnu.sh b/util/build-gnu.sh
index dad970866..13fef7bb9 100755
--- a/util/build-gnu.sh
+++ b/util/build-gnu.sh
@@ -1,7 +1,7 @@
 #!/bin/bash
 # `build-gnu.bash` ~ builds GNU coreutils (from supplied sources)
 #
-# UU_MAKE_PROFILE == 'debug' | 'release' ## build profile for *uutils* build; may be supplied by caller, defaults to 'debug'
+# UU_MAKE_PROFILE == 'debug' | 'release' ## build profile for *uutils* build; may be supplied by caller, defaults to 'release'
 
 # spell-checker:ignore (paths) abmon deref discrim eacces getlimits getopt ginstall inacc infloop inotify reflink ; (misc) INT_OFLOW OFLOW baddecode submodules ; (vars/env) SRCDIR vdir rcexp xpart
 
@@ -63,11 +63,13 @@ for binary in $(./build-aux/gen-lists-of-programs.sh --list-progs); do
 done
 
 if test -f gnu-built; then
+    # Change the PATH in the Makefile to test the uutils coreutils instead of the GNU coreutils
+    sed -i "s/^[[:blank:]]*PATH=.*/  PATH='${UU_BUILD_DIR//\//\\/}\$(PATH_SEPARATOR)'\"\$\$PATH\" \\\/" Makefile
     echo "GNU build already found. Skip"
     echo "'rm -f $(pwd)/gnu-built' to force the build"
     echo "Note: the customization of the tests will still happen"
 else
-    ./bootstrap
+    ./bootstrap --skip-po
     ./configure --quiet --disable-gcc-warnings
     #Add timeout to to protect against hangs
     sed -i 's|^"\$@|/usr/bin/timeout 600 "\$@|' build-aux/test-driver
@@ -164,6 +166,9 @@ sed -i -e "s|rm: cannot remove 'a/1'|rm: cannot remove 'a'|g" tests/rm/rm2.sh
 
 sed -i -e "s|removed directory 'a/'|removed directory 'a'|g" tests/rm/v-slash.sh
 
+# 'rel' doesn't exist. Our implementation is giving a better message.
+sed -i -e "s|rm: cannot remove 'rel': Permission denied|rm: cannot remove 'rel': No such file or directory|g" tests/rm/inaccessible.sh
+
 # overlay-headers.sh test intends to check for inotify events,
 # however there's a bug because `---dis` is an alias for: `---disable-inotify`
 sed -i -e "s|---dis ||g" tests/tail-2/overlay-headers.sh
@@ -220,7 +225,10 @@ sed -i -Ez "s/\n([^\n#]*pad-3\.2[^\n]*)\n([^\n]*)\n([^\n]*)/\n# uutils\/numfmt s
 
 # Update the GNU error message to match the one generated by clap
 sed -i -e "s/\$prog: multiple field specifications/error: The argument '--field <FIELDS>' was provided more than once, but cannot be used multiple times\n\nUsage: numfmt [OPTION]... [NUMBER]...\n\n\nFor more information try '--help'/g" tests/misc/numfmt.pl
+sed -i -e "s/Try 'mv --help' for more information/For more information, try '--help'/g" -e "s/mv: missing file operand/error: the following required arguments were not provided:\n  <files>...\n\nUsage: mv [OPTION]... [-T] SOURCE DEST\n       mv [OPTION]... SOURCE... DIRECTORY\n       mv [OPTION]... -t DIRECTORY SOURCE...\n/g" -e "s/mv: missing destination file operand after 'no-file'/error: The argument '<files>...' requires at least 2 values, but only 1 was provided\n\nUsage: mv [OPTION]... [-T] SOURCE DEST\n       mv [OPTION]... SOURCE... DIRECTORY\n       mv [OPTION]... -t DIRECTORY SOURCE...\n/g" tests/mv/diag.sh
 
 # GNU doesn't support width > INT_MAX
 # disable these test cases
 sed -i -E "s|^([^#]*2_31.*)$|#\1|g" tests/misc/printf-cov.pl
+
+sed -i -e "s/du: invalid -t argument/du: invalid --threshold argument/" -e "s/du: option requires an argument/error: a value is required for '--threshold <SIZE>' but none was supplied/" -e "/Try 'du --help' for more information./d" tests/du/threshold.sh
diff --git a/util/gnu-json-result.py b/util/gnu-json-result.py
index 1cd16e64c..c1adb3ffc 100644
--- a/util/gnu-json-result.py
+++ b/util/gnu-json-result.py
@@ -18,7 +18,7 @@ for filepath in test_dir.glob("**/*.log"):
             current[key] = {}
         current = current[key]
     try:
-        with open(path) as f:
+        with open(path, errors="ignore") as f:
             content = f.read()
             result = re.search(
                 r"(PASS|FAIL|SKIP|ERROR) [^ ]+ \(exit status: \d+\)$", content
diff --git a/util/publish.sh b/util/publish.sh
index d9039fa60..71830f1f9 100755
--- a/util/publish.sh
+++ b/util/publish.sh
@@ -1,4 +1,5 @@
 #!/bin/sh
+# spell-checker:ignore uuhelp
 ARG=""
 if test "$1" != "--do-it"; then
     ARG="--dry-run --allow-dirty"
@@ -35,7 +36,7 @@ TOTAL_ORDER=$(echo -e $PARTIAL_ORDER | tsort | tac)
 TOTAL_ORDER=${TOTAL_ORDER#ROOT}
 
 set -e
-for dir in src/uucore_procs/ src/uucore/ src/uu/stdbuf/src/libstdbuf/; do
+for dir in src/uuhelp_parser/ src/uucore_procs/ src/uucore/ src/uu/stdbuf/src/libstdbuf/; do
     (
         cd "$dir"
         #shellcheck disable=SC2086
diff --git a/util/remaining-gnu-error.py b/util/remaining-gnu-error.py
index c64ee974e..5fd47300a 100755
--- a/util/remaining-gnu-error.py
+++ b/util/remaining-gnu-error.py
@@ -8,6 +8,7 @@ import urllib
 import os
 import glob
 import json
+import sys
 
 base = "../gnu/tests/"
 urllib.request.urlretrieve(
@@ -18,7 +19,8 @@ urllib.request.urlretrieve(
 types = ("/*/*.sh", "/*/*.pl", "/*/*.xpl")
 
 tests = []
-error_or_skip_tests = []
+error_tests = []
+skip_tests = []
 
 for files in types:
     tests.extend(glob.glob(base + files))
@@ -51,16 +53,29 @@ for d in data:
 
         # the tests pass, we don't care anymore
         if data[d][e] == "PASS":
+            try:
+                list_of_files.remove(a)
+            except ValueError:
+                print("Could not find test '%s'. Maybe update the GNU repo?" % a)
+                sys.exit(1)
+
+        # if it is SKIP, show it
+        if data[d][e] == "SKIP":
             list_of_files.remove(a)
+            skip_tests.append(a)
 
-        # if it is SKIP or ERROR, show it
-        if data[d][e] == "SKIP" or data[d][e] == "ERROR":
+        # if it is ERROR, show it
+        if data[d][e] == "ERROR":
             list_of_files.remove(a)
-            error_or_skip_tests.append(a)
+            error_tests.append(a)
 
-
-print("SKIP and ERROR tests:")
-show_list(error_or_skip_tests)
+print("===============")
+print("SKIP tests:")
+show_list(skip_tests)
+print("")
+print("===============")
+print("ERROR tests:")
+show_list(error_tests)
 print("")
 print("===============")
 print("FAIL tests:")
diff --git a/util/run-gnu-test.sh b/util/run-gnu-test.sh
index f5c47e645..ac736abe1 100755
--- a/util/run-gnu-test.sh
+++ b/util/run-gnu-test.sh
@@ -1,8 +1,6 @@
 #!/bin/sh
 # `run-gnu-test.bash [TEST]`
 # run GNU test (or all tests if TEST is missing/null)
-#
-# UU_MAKE_PROFILE == 'debug' | 'release' ## build profile used for *uutils* build; may be supplied by caller, defaults to 'release'
 
 # spell-checker:ignore (env/vars) GNULIB SRCDIR SUBDIRS ; (utils) shellcheck
 
@@ -62,4 +60,4 @@ else
             sudo make -j "$(nproc)" check-root SUBDIRS=. RUN_EXPENSIVE_TESTS=yes RUN_VERY_EXPENSIVE_TESTS=yes VERBOSE=no gl_public_submodule_commit="" srcdir="${path_GNU}" TEST_SUITE_LOG="tests/test-suite-root.log" || :
         fi
     fi
-fi
\ No newline at end of file
+fi
diff --git a/util/show-utils.sh b/util/show-utils.sh
index 0db72e1c4..b6a0f9856 100755
--- a/util/show-utils.sh
+++ b/util/show-utils.sh
@@ -6,7 +6,8 @@
 ME="${0}"
 ME_dir="$(dirname -- "${ME}")"
 ME_parent_dir="$(dirname -- "${ME_dir}")"
-ME_parent_dir_abs="$(realpath -mP -- "${ME_parent_dir}")"
+# NOTE: On FreeBSD, `-mP` arguments are not available.
+ME_parent_dir_abs="$(realpath -mP -- "${ME_parent_dir}" || realpath -- "${ME_parent_dir}")"
 
 # refs: <https://forge.rust-lang.org/release/platform-support.html> , <https://docs.rs/platforms/0.2.1/platforms/platform/tier1/index.html>
 
@@ -22,6 +23,6 @@ cd "${project_main_dir}" &&
         echo "WARN: missing \`jq\` (install with \`sudo apt install jq\`); falling back to default (only fully cross-platform) utility list" 1>&2
         echo "$default_utils"
     else
-        cargo metadata "$*" --format-version 1 | jq -r "[.resolve.nodes[] | { id: .id, deps: [.deps[] | { name:.name, pkg:.pkg }] }] | .[] | select(.id|startswith(\"coreutils\")) | [.deps[] | select((.name|startswith(\"uu_\")) or (.pkg|startswith(\"uu_\")))] | [.[].pkg | match(\"^\\\w+\";\"g\")] | [.[].string | sub(\"^uu_\"; \"\")] | sort | join(\" \")"
-        # cargo metadata "$*" --format-version 1 | jq -r "[.resolve.nodes[] | { id: .id, deps: [.deps[] | { name:.name, pkg:.pkg }] }] | .[] | select(.id|startswith(\"coreutils\")) | [.deps[] | select((.name|startswith(\"uu_\")) or (.pkg|startswith(\"uu_\")))] | [.[].pkg | match(\"^\\\w+\";\"g\")] | [.[].string] | sort | join(\" \")"
+        cargo metadata "$@" --format-version 1 | jq -r "[.resolve.nodes[] | { id: .id, deps: [.deps[] | { name:.name, pkg:.pkg }] }] | .[] | select(.id|startswith(\"coreutils\")) | [.deps[] | select((.name|startswith(\"uu_\")) or (.pkg|startswith(\"uu_\")))] | [.[].pkg | match(\"^\\\w+\";\"g\")] | [.[].string | sub(\"^uu_\"; \"\")] | sort | join(\" \")"
+        # cargo metadata "$@" --format-version 1 | jq -r "[.resolve.nodes[] | { id: .id, deps: [.deps[] | { name:.name, pkg:.pkg }] }] | .[] | select(.id|startswith(\"coreutils\")) | [.deps[] | select((.name|startswith(\"uu_\")) or (.pkg|startswith(\"uu_\")))] | [.[].pkg | match(\"^\\\w+\";\"g\")] | [.[].string] | sort | join(\" \")"
     fi
diff --git a/util/update-version.sh b/util/update-version.sh
index 4b7b6d554..0fd15422a 100755
--- a/util/update-version.sh
+++ b/util/update-version.sh
@@ -1,4 +1,6 @@
 #!/bin/sh
+# spell-checker:ignore uuhelp
+
 # This is a stupid helper. I will mass replace all versions (including other crates)
 # So, it should be triple-checked
 
@@ -7,12 +9,13 @@
 # 2) run it: sh util/update-version.sh
 # 3) Do a spot check with "git diff"
 # 4) cargo test --release --features unix
-# 5) Run util/publish.sh in dry mode (it will fail as packages needs more recent version of uucore)
-# 6) Run util/publish.sh --do-it
-# 7) In some cases, you might have to fix dependencies and run import
+# 5) git commit -m "New release"
+# 6) Run util/publish.sh in dry mode (it will fail as packages needs more recent version of uucore)
+# 7) Run util/publish.sh --do-it
+# 8) In some cases, you might have to fix dependencies and run import
 
-FROM="0.0.16"
-TO="0.0.17"
+FROM="0.0.18"
+TO="0.0.19"
 
 PROGS=$(ls -1d src/uu/*/Cargo.toml src/uu/stdbuf/src/libstdbuf/Cargo.toml src/uucore/Cargo.toml Cargo.toml)
 
@@ -23,6 +26,9 @@ sed -i -e "s|version = \"$FROM\"|version = \"$TO\"|" $PROGS
 # Update uucore_procs
 sed -i -e "s|version = \"$FROM\"|version = \"$TO\"|" src/uucore_procs/Cargo.toml
 
+# Update uuhelp_parser
+sed -i -e "s|version = \"$FROM\"|version = \"$TO\"|" src/uuhelp_parser/Cargo.toml
+
 # Update the stdbuf stuff
 sed -i -e "s|libstdbuf = { version=\"$FROM\"|libstdbuf = { version=\"$TO\"|" src/uu/stdbuf/Cargo.toml
 sed -i -e "s|= { optional=true, version=\"$FROM\", package=\"uu_|= { optional=true, version=\"$TO\", package=\"uu_|g" Cargo.toml
diff --git a/util/why-skip.txt b/util/why-skip.txt
new file mode 100644
index 000000000..c790311c1
--- /dev/null
+++ b/util/why-skip.txt
@@ -0,0 +1,98 @@
+# spell-checker:ignore epipe readdir restorecon SIGALRM capget bigtime rootfs enotsup
+
+= trapping SIGPIPE is not supported =
+tests/tail-2/pipe-f.sh
+tests/misc/seq-epipe.sh
+tests/misc/printf-surprise.sh
+tests/misc/env-signal-handler.sh
+
+= skipped test: breakpoint not hit =
+tests/tail-2/inotify-race2.sh
+tail-2/inotify-race.sh
+
+= internal test failure: maybe LD_PRELOAD doesn't work? =
+tests/rm/rm-readdir-fail.sh
+tests/rm/r-root.sh
+tests/df/skip-duplicates.sh
+tests/df/no-mtab-status.sh
+
+= LD_PRELOAD was ineffective? =
+tests/cp/nfs-removal-race.sh
+
+= failed to create hfs file system =
+tests/mv/hardlink-case.sh
+
+= temporarily disabled =
+tests/mkdir/writable-under-readonly.sh
+
+= this system lacks SMACK support =
+tests/mkdir/smack-root.sh
+tests/mkdir/smack-no-root.sh
+tests/id/smack.sh
+
+= this system lacks SELinux support =
+tests/mkdir/selinux.sh
+tests/mkdir/restorecon.sh
+tests/misc/selinux.sh
+tests/misc/chcon.sh
+tests/install/install-Z-selinux.sh
+tests/install/install-C-selinux.sh
+tests/id/no-context.sh
+tests/id/context.sh
+tests/cp/no-ctx.sh
+tests/cp/cp-a-selinux.sh
+
+= failed to set xattr of file =
+tests/misc/xattr.sh
+
+= timeout returned 142. SIGALRM not handled? =
+tests/misc/timeout-group.sh
+
+= FULL_PARTITION_TMPDIR not defined =
+tests/misc/tac-continue.sh
+
+= can't get window size =
+tests/misc/stty-row-col.sh
+
+= The Swedish locale with blank thousands separator is unavailable. =
+tests/misc/sort-h-thousands-sep.sh
+
+= this shell lacks ulimit support =
+tests/misc/csplit-heap.sh
+
+= multicall binary is disabled =
+tests/misc/coreutils.sh
+
+= your ls doesn't call capget =
+tests/ls/no-cap.sh
+
+
+= not running on GNU/Hurd =
+tests/id/gnu-zero-uids.sh
+
+= file system cannot represent big timestamps =
+tests/du/bigtime.sh
+
+= no rootfs in mtab =
+tests/df/skip-rootfs.sh
+
+= insufficient mount/ext2 support =
+tests/df/problematic-chars.sh
+tests/cp/cp-mv-enotsup-xattr.sh
+
+= 512 byte aligned O_DIRECT is not supported on this (file) system =
+tests/dd/direct.sh
+
+= skipped test: /usr/bin/touch -m -d '1998-01-15 23:00' didn't work =
+tests/misc/ls-time.sh
+
+= requires controlling input terminal =
+tests/misc/stty-pairs.sh
+tests/misc/stty.sh
+tests/misc/stty-invalid.sh
+
+= insufficient SEEK_DATA support =
+tests/cp/sparse-perf.sh
+tests/cp/sparse-extents.sh
+tests/cp/sparse-extents-2.sh
+tests/cp/sparse-2.sh